/**
* Sort comparator for ch_ring_entry structs on pos, ip and instance.
*/
static int
entrycmp_carbon(const void *l, const void *r)
{
ch_ring_entry *ch_l = (ch_ring_entry *)l;
ch_ring_entry *ch_r = (ch_ring_entry *)r;
if (ch_l->pos != ch_r->pos)
return ch_l->pos - ch_r->pos;
#ifndef CH_CMP_V40_BEHAVIOUR
{
int d = strcmp(server_ip(ch_l->server), server_ip(ch_r->server));
char *i_l, *i_r;
if (d != 0)
return d;
i_l = server_instance(ch_l->server);
i_r = server_instance(ch_r->server);
if (i_l == NULL && i_r == NULL)
return 0;
if (i_l == NULL)
return 1;
if (i_r == NULL)
return -1;
return strcmp(i_l, i_r);
}
#endif
return 0;
}
/**
* Sort comparator for ch_ring_entry structs on pos, ip and port.
*/
static int
entrycmp_fnv1a(const void *l, const void *r)
{
ch_ring_entry *ch_l = (ch_ring_entry *)l;
ch_ring_entry *ch_r = (ch_ring_entry *)r;
if (ch_l->pos != ch_r->pos)
return ch_l->pos - ch_r->pos;
#ifndef CH_CMP_V40_BEHAVIOUR
{
int d = strcmp(server_ip(ch_l->server), server_ip(ch_r->server));
if (d != 0)
return d;
return server_port(ch_l->server) - server_port(ch_r->server);
}
#endif
return 0;
}
static void *
collector_writer(void *unused)
{
int i = 0;
size_t queued;
size_t queuesize;
double queueusage;
size_t totdropped;
size_t numaggregators = aggregator_numaggregators();
server **srvs = NULL;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_clusters);
if (srvs != NULL)
free(srvs);
srvs = newservers;
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
i++;
if (i < collector_interval)
continue;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
queued = server_get_queue_len(srvs[i]);
queuesize = server_get_queue_size(srvs[i]);
totdropped += server_get_dropped(srvs[i]);
queueusage = (double)queued / (double)queuesize;
if (queueusage >= 0.75)
logout("warning: metrics queuing up "
"for %s:%u: %zd metrics (%d%% of queue size)\n",
server_ip(srvs[i]), server_port(srvs[i]), queued,
(int)(queueusage * 100));
}
if (totdropped - lastdropped > 0)
logout("warning: dropped %zd metrics\n", totdropped - lastdropped);
lastdropped = totdropped;
if (numaggregators > 0) {
totdropped = aggregator_get_dropped();
if (totdropped - lastaggrdropped > 0)
logout("warning: aggregator dropped %zd metrics\n",
totdropped - lastaggrdropped);
lastaggrdropped = totdropped;
}
i = 0;
}
return NULL;
}
/*
* Connects to specified server(s)
* - @servers_count: the number of servers to be connected to
* - @servers: a vector of Connection objects (for ip, port, pub_id)
*/
void Communication::Connect(int servers_count, std::vector<Connection> servers)
{
// connect with the server(s)
for (int i=0; i<servers_count; i++)
{
boost::shared_ptr<boost::asio::ip::tcp::socket> sock(new boost::asio::ip::tcp::socket(*io_service_));
// get the pub from the options
Connection con = servers[i];
boost::shared_ptr<std::string> server_name(new std::string(con.pub_id));
boost::shared_ptr<std::string> server_ip(new std::string(con.ip));
boost::shared_ptr<std::string> server_port(new std::string(con.port));
try
{
// try to connect
boost::asio::ip::tcp::resolver resolver(*io_service_);
boost::asio::ip::tcp::resolver::query query(con.ip, con.port);
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
boost::asio::ip::tcp::endpoint endpoint = *iterator;
sock->async_connect(endpoint,
boost::bind(&Communication::AddServer,
this,
boost::asio::placeholders::error(),
sock,
endpoint,
server_name,
server_ip,
server_port));
std::cout << "[" << boost::this_thread::get_id()
<< "] Connecting to: " << endpoint << std::endl;
}
// catch any exception
catch (std::exception & ex)
{
std::cout << "[" << boost::this_thread::get_id()
<< "] Exception: " << ex.what() << std::endl;
}
}
}
void
ch_printhashring(ch_ring *ring, FILE *f)
{
ch_ring_entry *w;
char column = 0;
char srvbuf[21];
for (w = ring->entries; w != NULL; w = w->next) {
snprintf(srvbuf, sizeof(srvbuf), "%s:%d%s%s",
server_ip(w->server),
server_port(w->server),
server_instance(w->server) ? "=" : "",
server_instance(w->server) ? server_instance(w->server) : "");
fprintf(f, "%5d@%-20s", w->pos, srvbuf);
if (column < 2) {
fprintf(f, " ");
column++;
} else {
fprintf(f, "\n");
column = 0;
}
}
}
/**
* Collects metrics from dispatchers and servers and emits them.
*/
static void *
collector_runner(void *s)
{
int i;
size_t totticks;
size_t totmetrics;
size_t totblackholes;
size_t totqueued;
size_t totstalls;
size_t totdropped;
size_t totsleeps;
size_t ticks;
size_t metrics;
size_t blackholes;
size_t queued;
size_t stalls;
size_t dropped;
size_t sleeps;
time_t now;
time_t nextcycle;
char destbuf[1024]; /* sort of POSIX_MAX_PATH */
char *p;
size_t numaggregators = 0;
aggregator *aggrs = NULL;
server *submission = (server *)s;
server **srvs = NULL;
char metric[METRIC_BUFSIZ];
char *m = NULL;
size_t sizem = 0;
size_t (*s_ticks)(server *);
size_t (*s_metrics)(server *);
size_t (*s_stalls)(server *);
size_t (*s_dropped)(server *);
size_t (*d_ticks)(dispatcher *);
size_t (*d_metrics)(dispatcher *);
size_t (*d_blackholes)(dispatcher *);
size_t (*d_sleeps)(dispatcher *);
size_t (*a_received)(aggregator *);
size_t (*a_sent)(aggregator *);
size_t (*a_dropped)(aggregator *);
/* setup functions to target what the user wants */
if (debug & 2) {
s_ticks = server_get_ticks_sub;
s_metrics = server_get_metrics_sub;
s_stalls = server_get_stalls_sub;
s_dropped = server_get_dropped_sub;
d_ticks = dispatch_get_ticks_sub;
d_metrics = dispatch_get_metrics_sub;
d_blackholes = dispatch_get_blackholes_sub;
d_sleeps = dispatch_get_sleeps_sub;
a_received = aggregator_get_received_sub;
a_sent = aggregator_get_sent_sub;
a_dropped = aggregator_get_dropped_sub;
} else {
s_ticks = server_get_ticks;
s_metrics = server_get_metrics;
s_stalls = server_get_stalls;
s_dropped = server_get_dropped;
d_ticks = dispatch_get_ticks;
d_metrics = dispatch_get_metrics;
d_blackholes = dispatch_get_blackholes;
d_sleeps = dispatch_get_sleeps;
a_received = aggregator_get_received;
a_sent = aggregator_get_sent;
a_dropped = aggregator_get_dropped;
}
#define send(metric) \
if (debug & 1) \
logout("%s", metric); \
else \
server_send(submission, strdup(metric), 1);
nextcycle = time(NULL) + collector_interval;
while (keep_running) {
if (cluster_refresh_pending) {
char *stub = router_getcollectorstub(pending_router);
server **newservers = router_getservers(pending_router);
if (srvs != NULL)
free(srvs);
srvs = newservers;
aggrs = router_getaggregators(pending_router);
numaggregators = aggregator_numaggregators(aggrs);
/* prepare hostname for graphite metrics */
snprintf(metric, sizeof(metric), "%scarbon.relays.%s",
stub == NULL ? "" : stub, relay_hostname);
for (m = metric + strlen("carbon.relays."); *m != '\0'; m++)
if (*m == '.')
*m = '_';
*m++ = '.';
*m = '\0';
sizem = sizeof(metric) - (m - metric);
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
now = time(NULL);
if (nextcycle > now)
continue;
nextcycle += collector_interval;
totticks = 0;
totmetrics = 0;
totblackholes = 0;
totsleeps = 0;
for (i = 0; dispatchers[i] != NULL; i++) {
totsleeps += sleeps = d_sleeps(dispatchers[i]);
totticks += ticks = d_ticks(dispatchers[i]);
totmetrics += metrics = d_metrics(dispatchers[i]);
totblackholes += blackholes = d_blackholes(dispatchers[i]);
snprintf(m, sizem, "dispatcher%d.metricsReceived %zu %zu\n",
i + 1, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.metricsBlackholed %zu %zu\n",
i + 1, blackholes, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.wallTime_us %zu %zu\n",
i + 1, ticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.sleepTime_us %zu %zu\n",
i + 1, sleeps, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsReceived %zu %zu\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsBlackholed %zu %zu\n",
totblackholes, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_wallTime_us %zu %zu\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_sleepTime_us %zu %zu\n",
totsleeps, (size_t)now);
send(metric);
#define send_server_metrics(ipbuf, ticks, metrics, queued, stalls, dropped) \
snprintf(m, sizem, "destinations.%s.sent %zu %zu\n", \
ipbuf, metrics, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.queued %zu %zu\n", \
ipbuf, queued, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.stalls %zu %zu\n", \
ipbuf, stalls, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.dropped %zu %zu\n", \
ipbuf, dropped, (size_t)now); \
send(metric); \
snprintf(m, sizem, "destinations.%s.wallTime_us %zu %zu\n", \
ipbuf, ticks, (size_t)now); \
send(metric);
totticks = 0;
totmetrics = 0;
totqueued = 0;
totstalls = 0;
totdropped = 0;
/* exclude internal_submission metrics from the totals to avoid
* artificial doubles due to internal routing details */
ticks = s_ticks(submission);
metrics = s_metrics(submission);
queued = server_get_queue_len(submission);
stalls = s_stalls(submission);
dropped = s_dropped(submission);
send_server_metrics(server_ip(submission),
ticks, metrics, queued, stalls, dropped);
for (i = 0; srvs[i] != NULL; i++) {
switch (server_ctype(srvs[i])) {
case CON_FILE:
case CON_PIPE:
snprintf(destbuf, sizeof(destbuf), "%s",
server_ip(srvs[i]));
break;
case CON_TCP:
snprintf(destbuf, sizeof(destbuf), "%s:%u",
server_ip(srvs[i]), server_port(srvs[i]));
break;
case CON_UDP:
snprintf(destbuf, sizeof(destbuf), "%s:%u-udp",
server_ip(srvs[i]), server_port(srvs[i]));
break;
}
for (p = destbuf; *p != '\0'; p++)
if (*p == '.')
*p = '_';
totticks += ticks = s_ticks(srvs[i]);
totmetrics += metrics = s_metrics(srvs[i]);
totqueued += queued = server_get_queue_len(srvs[i]);
totstalls += stalls = s_stalls(srvs[i]);
totdropped += dropped = s_dropped(srvs[i]);
send_server_metrics(destbuf,
ticks, metrics, queued, stalls, dropped);
}
snprintf(m, sizem, "metricsSent %zu %zu\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsQueued %zu %zu\n",
totqueued, (size_t)now);
send(metric);
snprintf(m, sizem, "metricStalls %zu %zu\n",
totstalls, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsDropped %zu %zu\n",
totdropped, (size_t)now);
send(metric);
snprintf(m, sizem, "server_wallTime_us %zu %zu\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "connections %zu %zu\n",
dispatch_get_accepted_connections(), (size_t)now);
send(metric);
snprintf(m, sizem, "disconnects %zu %zu\n",
dispatch_get_closed_connections(), (size_t)now);
send(metric);
if (numaggregators > 0) {
snprintf(m, sizem, "aggregators.metricsReceived %zu %zu\n",
a_received(aggrs), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsSent %zu %zu\n",
a_sent(aggrs), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsDropped %zu %zu\n",
a_dropped(aggrs), (size_t)now);
send(metric);
}
if (debug & 1)
fflush(stdout);
}
if (srvs != NULL)
free(srvs);
return NULL;
}
static void *
collector_writer(void *unused)
{
int i = 0;
size_t queued;
size_t queuesize;
double queueusage;
size_t totdropped;
size_t lastconn = 0;
size_t lastdisc = 0;
size_t numaggregators = 0;
server **srvs = NULL;
aggregator *aggrs = NULL;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_router);
if (srvs != NULL)
free(srvs);
srvs = newservers;
aggrs = router_getaggregators(pending_router);
numaggregators = aggregator_numaggregators(aggrs);
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
if (debug & 1) {
size_t mpsout;
size_t totout;
size_t mpsdrop;
size_t totdrop;
size_t totqueue;
size_t mpsin;
size_t totin;
size_t totconn;
size_t totdisc;
size_t dticks;
size_t dsleeps;
int j;
/* Solaris iostat like output:
metrics in metrics out metrics drop queue conns disconn workr
mps tot mps tot dps tot cur cps tot dps tot act
99999 9999999 99999 9999999 99999 9999999 99999 999 99999 999 99999 99%
*/
if (i % 24 == 0)
printf(" metrics in metrics out metrics drop queue conns disconn workr\n"
" mps tot mps tot dps tot cur cps tot dps tot act\n");
mpsout = totout = 0;
mpsdrop = totdrop = 0;
totqueue = 0;
for (j = 0; srvs[j] != NULL; j++) {
mpsout += server_get_metrics_sub(srvs[j]);
totout += server_get_metrics(srvs[j]);
mpsdrop += server_get_dropped_sub(srvs[j]);
totdrop += server_get_dropped(srvs[j]);
totqueue += server_get_queue_len(srvs[j]);
}
mpsin = totin = 0;
dticks = dsleeps = 0;
for (j = 0; dispatchers[j] != NULL; j++) {
mpsin += dispatch_get_metrics_sub(dispatchers[j]);
totin += dispatch_get_metrics(dispatchers[j]);
dticks += dispatch_get_ticks_sub(dispatchers[j]);
dsleeps += dispatch_get_sleeps_sub(dispatchers[j]);
}
totconn = dispatch_get_accepted_connections();
totdisc = dispatch_get_closed_connections();
printf("%5zu %7zu " /* metrics in */
"%5zu %7zu " /* metrics out */
"%5zu %7zu " /* metrics dropped */
"%5zu " /* queue */
"%3zu %5zu " /* conns */
"%3zu %5zu " /* disconns */
"%2d%%\n", /* workers */
mpsin, totin,
mpsout, totout,
mpsdrop, totdrop,
totqueue,
totconn - lastconn, totconn,
totdisc - lastdisc, totdisc,
(int)(((double)dticks * 100.0) / (double)(dticks + dsleeps))
);
lastconn = totconn;
lastdisc = totdisc;
}
i++;
if (i < collector_interval)
continue;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
queued = server_get_queue_len(srvs[i]);
queuesize = server_get_queue_size(srvs[i]);
totdropped += server_get_dropped(srvs[i]);
queueusage = (double)queued / (double)queuesize;
if (queueusage >= 0.75)
logout("warning: metrics queuing up "
"for %s:%u: %zu metrics (%d%% of queue size)\n",
server_ip(srvs[i]), server_port(srvs[i]), queued,
(int)(queueusage * 100));
}
if (totdropped - lastdropped > 0)
logout("warning: dropped %zu metrics\n", totdropped - lastdropped);
lastdropped = totdropped;
if (numaggregators > 0) {
totdropped = aggregator_get_dropped(aggrs);
if (totdropped - lastaggrdropped > 0)
logout("warning: aggregator dropped %zu metrics\n",
totdropped - lastaggrdropped);
lastaggrdropped = totdropped;
}
i = 0;
}
return NULL;
}
/**
* Computes the hash positions for the server name given. This is based
* on the hashpos function. The server name usually is the IPv4
* address. The port component is just stored and not used in the
* carbon hash calculation in case of carbon_ch. The instance component
* is used in the hash calculation of carbon_ch, it is ignored for
* fnv1a_ch. Returns an updated ring.
*/
ch_ring *
ch_addnode(ch_ring *ring, server *s)
{
int i;
char buf[256];
ch_ring_entry *entries;
char *instance = server_instance(s);
int (*cmp)(const void *, const void *) = NULL;
if (ring == NULL)
return NULL;
entries =
(ch_ring_entry *)malloc(sizeof(ch_ring_entry) * ring->hash_replicas);
if (entries == NULL)
return NULL;
switch (ring->type) {
case CARBON:
for (i = 0; i < ring->hash_replicas; i++) {
/* this format is actually Python's tuple format that is
* used in serialised form as input for the hash */
snprintf(buf, sizeof(buf), "('%s', %s%s%s):%d",
server_ip(s),
instance == NULL ? "" : "'",
instance == NULL ? "None" : instance,
instance == NULL ? "" : "'",
i);
/* carbon upstream committed:
* https://github.com/graphite-project/carbon/commit/024f9e67ca47619438951c59154c0dec0b0518c7
* this makes sure no collissions exist on pos, however,
* at the expense of being agnostic to the input order,
* therefore that change isn't implemented here, see
* https://github.com/grobian/carbon-c-relay/issues/84 */
entries[i].pos = carbon_hashpos(buf, buf + strlen(buf));
entries[i].server = s;
entries[i].next = NULL;
entries[i].malloced = 0;
}
cmp = *entrycmp_carbon;
break;
case FNV1a:
for (i = 0; i < ring->hash_replicas; i++) {
/* take all server info into account, such that
* different port numbers for the same hosts will work
* (unlike CARBON), unless we got a full overrride */
if (instance == NULL) {
snprintf(buf, sizeof(buf), "%d-%s:%u",
i, server_ip(s), server_port(s));
} else {
snprintf(buf, sizeof(buf), "%d-%s", i, instance);
}
entries[i].pos = fnv1a_hash16(buf, buf + strlen(buf));
entries[i].server = s;
entries[i].next = NULL;
entries[i].malloced = 0;
}
cmp = *entrycmp_fnv1a;
break;
}
/* sort to allow merge joins later down the road */
qsort(entries, ring->hash_replicas, sizeof(ch_ring_entry), cmp);
entries[0].malloced = 1;
if (ring->entries == NULL) {
for (i = 1; i < ring->hash_replicas; i++)
entries[i - 1].next = &entries[i];
ring->entries = entries;
} else {
/* merge-join the two rings */
ch_ring_entry *w, *last;
i = 0;
last = NULL;
assert(ring->hash_replicas > 0);
for (w = ring->entries; w != NULL && i < ring->hash_replicas; ) {
if (cmp(&w->pos, &entries[i].pos) <= 0) {
last = w;
w = w->next;
} else {
entries[i].next = w;
if (last == NULL) {
ring->entries = &entries[i];
} else {
last->next = &entries[i];
}
last = &entries[i];
i++;
}
}
if (w != NULL) {
last->next = w;
} else {
last->next = &entries[i];
for (i = i + 1; i < ring->hash_replicas; i++)
entries[i - 1].next = &entries[i];
}
}
return ring;
}
/**
* Collects metrics from dispatchers and servers and emits them.
*/
static void *
collector_runner(void *s)
{
int i;
size_t totticks;
size_t totmetrics;
size_t totqueued;
size_t totstalls;
size_t totdropped;
size_t ticks;
size_t metrics;
size_t queued;
size_t stalls;
size_t dropped;
size_t dispatchers_idle;
size_t dispatchers_busy;
time_t now;
time_t nextcycle;
char ipbuf[32];
char *p;
size_t numaggregators = aggregator_numaggregators();
server *submission = (server *)s;
server **srvs = NULL;
char metric[METRIC_BUFSIZ];
char *m;
size_t sizem = 0;
/* prepare hostname for graphite metrics */
snprintf(metric, sizeof(metric), "carbon.relays.%s", relay_hostname);
for (m = metric + strlen("carbon.relays."); *m != '\0'; m++)
if (*m == '.')
*m = '_';
*m++ = '.';
*m = '\0';
sizem = sizeof(metric) - (m - metric);
#define send(metric) \
if (debug) \
logout("%s", metric); \
else \
server_send(submission, strdup(metric), 1);
nextcycle = time(NULL) + collector_interval;
while (keep_running) {
if (cluster_refresh_pending) {
server **newservers = router_getservers(pending_clusters);
if (srvs != NULL)
free(srvs);
srvs = newservers;
cluster_refresh_pending = 0;
}
assert(srvs != NULL);
sleep(1);
now = time(NULL);
if (nextcycle > now)
continue;
nextcycle += collector_interval;
totticks = 0;
totmetrics = 0;
dispatchers_idle = 0;
dispatchers_busy = 0;
for (i = 0; dispatchers[i] != NULL; i++) {
if (dispatch_busy(dispatchers[i])) {
dispatchers_busy++;
} else {
dispatchers_idle++;
}
totticks += ticks = dispatch_get_ticks(dispatchers[i]);
totmetrics += metrics = dispatch_get_metrics(dispatchers[i]);
snprintf(m, sizem, "dispatcher%d.metricsReceived %zd %zd\n",
i + 1, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatcher%d.wallTime_us %zd %zd\n",
i + 1, ticks, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsReceived %zd %zd\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_wallTime_us %zd %zd\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_busy %zd %zd\n",
dispatchers_busy, (size_t)now);
send(metric);
snprintf(m, sizem, "dispatch_idle %zd %zd\n",
dispatchers_idle, (size_t)now);
send(metric);
totticks = 0;
totmetrics = 0;
totqueued = 0;
totstalls = 0;
totdropped = 0;
for (i = 0; srvs[i] != NULL; i++) {
if (server_ctype(srvs[i]) == CON_PIPE) {
strncpy(ipbuf, "internal", sizeof(ipbuf));
ticks = server_get_ticks(srvs[i]);
metrics = server_get_metrics(srvs[i]);
queued = server_get_queue_len(srvs[i]);
stalls = server_get_stalls(srvs[i]);
dropped = server_get_dropped(srvs[i]);
} else {
snprintf(ipbuf, sizeof(ipbuf), "%s:%u",
server_ip(srvs[i]), server_port(srvs[i]));
for (p = ipbuf; *p != '\0'; p++)
if (*p == '.')
*p = '_';
totticks += ticks = server_get_ticks(srvs[i]);
totmetrics += metrics = server_get_metrics(srvs[i]);
totqueued += queued = server_get_queue_len(srvs[i]);
totstalls += stalls = server_get_stalls(srvs[i]);
totdropped += dropped = server_get_dropped(srvs[i]);
}
snprintf(m, sizem, "destinations.%s.sent %zd %zd\n",
ipbuf, metrics, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.queued %zd %zd\n",
ipbuf, queued, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.stalls %zd %zd\n",
ipbuf, stalls, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.dropped %zd %zd\n",
ipbuf, dropped, (size_t)now);
send(metric);
snprintf(m, sizem, "destinations.%s.wallTime_us %zd %zd\n",
ipbuf, ticks, (size_t)now);
send(metric);
}
snprintf(m, sizem, "metricsSent %zd %zd\n",
totmetrics, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsQueued %zd %zd\n",
totqueued, (size_t)now);
send(metric);
snprintf(m, sizem, "metricStalls %zd %zd\n",
totstalls, (size_t)now);
send(metric);
snprintf(m, sizem, "metricsDropped %zd %zd\n",
totdropped, (size_t)now);
send(metric);
snprintf(m, sizem, "server_wallTime_us %zd %zd\n",
totticks, (size_t)now);
send(metric);
snprintf(m, sizem, "connections %zd %zd\n",
dispatch_get_accepted_connections(), (size_t)now);
send(metric);
snprintf(m, sizem, "disconnects %zd %zd\n",
dispatch_get_closed_connections(), (size_t)now);
send(metric);
if (numaggregators > 0) {
snprintf(m, sizem, "aggregators.metricsReceived %zd %zd\n",
aggregator_get_received(), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsSent %zd %zd\n",
aggregator_get_sent(), (size_t)now);
send(metric);
snprintf(m, sizem, "aggregators.metricsDropped %zd %zd\n",
aggregator_get_dropped(), (size_t)now);
send(metric);
}
if (debug)
fflush(stdout);
}
return NULL;
}
