void buffer_strcat(BUFFER *wb, const char *txt) { if(unlikely(!txt || !*txt)) return; buffer_need_bytes(wb, (size_t)(1)); char *s = &wb->buffer[wb->len], *end = &wb->buffer[wb->size]; long len = wb->len; while(*txt && s != end) { *s++ = *txt++; len++; } wb->len = len; buffer_overflow_check(wb); if(*txt) { debug(D_WEB_BUFFER, "strcat(): increasing web_buffer at position %ld, size = %ld\n", wb->len, wb->size); len = strlen(txt); buffer_increase(wb, len); buffer_strcat(wb, txt); } else { // terminate the string // without increasing the length buffer_need_bytes(wb, (size_t)1); wb->buffer[wb->len] = '\0'; } }
void buffer_sprintf(BUFFER *wb, const char *fmt, ...) { if(unlikely(!fmt || !*fmt)) return; buffer_need_bytes(wb, 2); size_t len = wb->size - wb->len - 1; size_t wrote; va_list args; va_start(args, fmt); wrote = (size_t) vsnprintfz(&wb->buffer[wb->len], len, fmt, args); va_end(args); if(unlikely(wrote >= len)) { // truncated buffer_overflow_check(wb); debug(D_WEB_BUFFER, "web_buffer_sprintf(): increasing web_buffer at position %zu, size = %zu\n", wb->len, wb->size); buffer_need_bytes(wb, len + WEB_DATA_LENGTH_INCREASE_STEP); va_start(args, fmt); buffer_vsprintf(wb, fmt, args); va_end(args); } else wb->len += wrote; // the buffer is \0 terminated by vsnprintf }
void buffer_sprintf(BUFFER *wb, const char *fmt, ...) { if(unlikely(!fmt || !*fmt)) return; buffer_need_bytes(wb, 1); size_t len = wb->size - wb->len, wrote; va_list args; va_start(args, fmt); wrote = (size_t) vsnprintf(&wb->buffer[wb->len], len, fmt, args); va_end(args); if(unlikely(wrote >= len)) { // there is bug in vsnprintf() and it returns // a number higher to len, but it does not // overflow the buffer. // our buffer overflow detector will log it // if it does. buffer_overflow_check(wb); debug(D_WEB_BUFFER, "web_buffer_sprintf(): increasing web_buffer at position %ld, size = %ld\n", wb->len, wb->size); buffer_need_bytes(wb, len + WEB_DATA_LENGTH_INCREASE_STEP); va_start(args, fmt); buffer_vsprintf(wb, fmt, args); va_end(args); } else wb->len += wrote; // the buffer is \0 terminated by vsnprintf }
void buffer_rrd_value(BUFFER *wb, calculated_number value) { buffer_need_bytes(wb, 50); wb->len += print_calculated_number(&wb->buffer[wb->len], value); // terminate it buffer_need_bytes(wb, 1); wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
void buffer_print_llu(BUFFER *wb, unsigned long long uvalue) { buffer_need_bytes(wb, 50); char *str = &wb->buffer[wb->len]; char *wstr = str; #ifdef ENVIRONMENT32 if(uvalue > (unsigned long long)0xffffffff) wstr = print_number_llu_r(wstr, uvalue); else wstr = print_number_lu_r(wstr, uvalue); #else do *wstr++ = (char)('0' + (uvalue % 10)); while(uvalue /= 10); #endif // terminate it *wstr = '\0'; // reverse it char *begin = str, *end = wstr - 1, aux; while (end > begin) aux = *end, *end-- = *begin, *begin++ = aux; // return the buffer length wb->len += wstr - str; }
void buffer_rrd_value(BUFFER *wb, calculated_number value) { buffer_need_bytes(wb, 50); if(isnan(value) || isinf(value)) { buffer_strcat(wb, "null"); return; } else wb->len += print_calculated_number(&wb->buffer[wb->len], value); // terminate it buffer_need_bytes(wb, 1); wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
const char *buffer_tostring(BUFFER *wb) { buffer_need_bytes(wb, (size_t)1); wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); return(wb->buffer); }
// generate a javascript date, the fastest possible way... void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds) { // 10 20 30 = 35 // 01234567890123456789012345678901234 // Date(2014,04,01,03,28,20) buffer_need_bytes(wb, 30); char *b = &wb->buffer[wb->len], *p; unsigned int *q = (unsigned int *)b; #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ *q++ = 0x65746144; // "Date" backwards. #else *q++ = 0x44617465; // "Date" #endif p = (char *)q; *p++ = '('; *p++ = '0' + year / 1000; year %= 1000; *p++ = '0' + year / 100; year %= 100; *p++ = '0' + year / 10; *p++ = '0' + year % 10; *p++ = ','; *p = '0' + month / 10; if (*p != '0') p++; *p++ = '0' + month % 10; *p++ = ','; *p = '0' + day / 10; if (*p != '0') p++; *p++ = '0' + day % 10; *p++ = ','; *p = '0' + hours / 10; if (*p != '0') p++; *p++ = '0' + hours % 10; *p++ = ','; *p = '0' + minutes / 10; if (*p != '0') p++; *p++ = '0' + minutes % 10; *p++ = ','; *p = '0' + seconds / 10; if (*p != '0') p++; *p++ = '0' + seconds % 10; unsigned short *r = (unsigned short *)p; #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ *r++ = 0x0029; // ")\0" backwards. #else *r++ = 0x2900; // ")\0" #endif wb->len += (size_t)((char *)r - b - 1); // terminate it wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
// generate a javascript date, the fastest possible way... void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds) { // 10 20 30 = 35 // 01234567890123456789012345678901234 // Date(2014,04,01,03,28,20) buffer_need_bytes(wb, 30); char *b = &wb->buffer[wb->len]; int i = 0; b[i++]='D'; b[i++]='a'; b[i++]='t'; b[i++]='e'; b[i++]='('; b[i++]= (char) (48 + year / 1000); year -= (year / 1000) * 1000; b[i++]= (char) (48 + year / 100); year -= (year / 100) * 100; b[i++]= (char) (48 + year / 10); b[i++]= (char) (48 + year % 10); b[i++]=','; b[i]= (char) (48 + month / 10); if(b[i] != '0') i++; b[i++]= (char) (48 + month % 10); b[i++]=','; b[i]= (char) (48 + day / 10); if(b[i] != '0') i++; b[i++]= (char) (48 + day % 10); b[i++]=','; b[i]= (char) (48 + hours / 10); if(b[i] != '0') i++; b[i++]= (char) (48 + hours % 10); b[i++]=','; b[i]= (char) (48 + minutes / 10); if(b[i] != '0') i++; b[i++]= (char) (48 + minutes % 10); b[i++]=','; b[i]= (char) (48 + seconds / 10); if(b[i] != '0') i++; b[i++]= (char) (48 + seconds % 10); b[i++]=')'; b[i]='\0'; wb->len += i; // terminate it wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
void buffer_vsprintf(BUFFER *wb, const char *fmt, va_list args) { if(unlikely(!fmt || !*fmt)) return; buffer_need_bytes(wb, 1); size_t len = wb->size - wb->len; wb->len += vsnprintf(&wb->buffer[wb->len], len, fmt, args); buffer_overflow_check(wb); // the buffer is \0 terminated by vsnprintf }
void buffer_snprintf(BUFFER *wb, size_t len, const char *fmt, ...) { if(unlikely(!fmt || !*fmt)) return; buffer_need_bytes(wb, len+1); va_list args; va_start(args, fmt); wb->len += vsnprintf(&wb->buffer[wb->len], len+1, fmt, args); va_end(args); buffer_overflow_check(wb); // the buffer is \0 terminated by vsnprintf }
// generate a date, the fastest possible way... void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds) { // 10 20 30 = 35 // 01234567890123456789012345678901234 // 2014-04-01 03:28:20 buffer_need_bytes(wb, 36); char *b = &wb->buffer[wb->len]; int i = 0; b[i++]= (char) (48 + year / 1000); year -= (year / 1000) * 1000; b[i++]= (char) (48 + year / 100); year -= (year / 100) * 100; b[i++]= (char) (48 + year / 10); b[i++]= (char) (48 + year % 10); b[i++]='-'; b[i++]= (char) (48 + month / 10); b[i++]= (char) (48 + month % 10); b[i++]='-'; b[i++]= (char) (48 + day / 10); b[i++]= (char) (48 + day % 10); b[i++]=' '; b[i++]= (char) (48 + hours / 10); b[i++]= (char) (48 + hours % 10); b[i++]=':'; b[i++]= (char) (48 + minutes / 10); b[i++]= (char) (48 + minutes % 10); b[i++]=':'; b[i++]= (char) (48 + seconds / 10); b[i++]= (char) (48 + seconds % 10); b[i]='\0'; wb->len += i; // terminate it wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
// generate a date, the fastest possible way... void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds) { // 10 20 30 = 35 // 01234567890123456789012345678901234 // 2014-04-01 03:28:20 buffer_need_bytes(wb, 36); char *b = &wb->buffer[wb->len]; char *p = b; *p++ = '0' + year / 1000; year %= 1000; *p++ = '0' + year / 100; year %= 100; *p++ = '0' + year / 10; *p++ = '0' + year % 10; *p++ = '-'; *p++ = '0' + month / 10; *p++ = '0' + month % 10; *p++ = '-'; *p++ = '0' + day / 10; *p++ = '0' + day % 10; *p++ = ' '; *p++ = '0' + hours / 10; *p++ = '0' + hours % 10; *p++ = ' '; *p++ = '0' + minutes / 10; *p++ = '0' + minutes % 10; *p++ = ' '; *p++ = '0' + seconds / 10; *p++ = '0' + seconds % 10; *p = '\0'; wb->len += (size_t)(p - b); // terminate it wb->buffer[wb->len] = '\0'; buffer_overflow_check(wb); }
void *backends_main(void *ptr) { netdata_thread_cleanup_push(backends_main_cleanup, ptr); int default_port = 0; int sock = -1; BUFFER *b = buffer_create(1), *response = buffer_create(1); int (*backend_request_formatter)(BUFFER *, const char *, RRDHOST *, const char *, RRDSET *, RRDDIM *, time_t, time_t, uint32_t) = NULL; int (*backend_response_checker)(BUFFER *) = NULL; // ------------------------------------------------------------------------ // collect configuration options struct timeval timeout = { .tv_sec = 0, .tv_usec = 0 }; int enabled = config_get_boolean(CONFIG_SECTION_BACKEND, "enabled", 0); const char *source = config_get(CONFIG_SECTION_BACKEND, "data source", "average"); const char *type = config_get(CONFIG_SECTION_BACKEND, "type", "graphite"); const char *destination = config_get(CONFIG_SECTION_BACKEND, "destination", "localhost"); backend_prefix = config_get(CONFIG_SECTION_BACKEND, "prefix", "netdata"); const char *hostname = config_get(CONFIG_SECTION_BACKEND, "hostname", localhost->hostname); backend_update_every = (int)config_get_number(CONFIG_SECTION_BACKEND, "update every", backend_update_every); int buffer_on_failures = (int)config_get_number(CONFIG_SECTION_BACKEND, "buffer on failures", 10); long timeoutms = config_get_number(CONFIG_SECTION_BACKEND, "timeout ms", backend_update_every * 2 * 1000); backend_send_names = config_get_boolean(CONFIG_SECTION_BACKEND, "send names instead of ids", backend_send_names); charts_pattern = simple_pattern_create(config_get(CONFIG_SECTION_BACKEND, "send charts matching", "*"), NULL, SIMPLE_PATTERN_EXACT); hosts_pattern = simple_pattern_create(config_get(CONFIG_SECTION_BACKEND, "send hosts matching", "localhost *"), NULL, SIMPLE_PATTERN_EXACT); // ------------------------------------------------------------------------ // validate configuration options // and prepare for sending data to our backend backend_options = backend_parse_data_source(source, backend_options); if(timeoutms < 1) { error("BACKEND: invalid timeout %ld ms given. Assuming %d ms.", timeoutms, backend_update_every * 2 * 1000); timeoutms = backend_update_every * 2 * 1000; } timeout.tv_sec = (timeoutms * 1000) / 1000000; timeout.tv_usec = (timeoutms * 1000) % 1000000; if(!enabled || backend_update_every < 1) goto cleanup; // ------------------------------------------------------------------------ // select the backend type if(!strcmp(type, "graphite") || !strcmp(type, "graphite:plaintext")) { default_port = 2003; backend_response_checker = process_graphite_response; if((backend_options & BACKEND_SOURCE_BITS) == BACKEND_SOURCE_DATA_AS_COLLECTED) backend_request_formatter = format_dimension_collected_graphite_plaintext; else backend_request_formatter = format_dimension_stored_graphite_plaintext; } else if(!strcmp(type, "opentsdb") || !strcmp(type, "opentsdb:telnet")) { default_port = 4242; backend_response_checker = process_opentsdb_response; if((backend_options & BACKEND_SOURCE_BITS) == BACKEND_SOURCE_DATA_AS_COLLECTED) backend_request_formatter = format_dimension_collected_opentsdb_telnet; else backend_request_formatter = format_dimension_stored_opentsdb_telnet; } else if (!strcmp(type, "json") || !strcmp(type, "json:plaintext")) { default_port = 5448; backend_response_checker = process_json_response; if ((backend_options & BACKEND_SOURCE_BITS) == BACKEND_SOURCE_DATA_AS_COLLECTED) backend_request_formatter = format_dimension_collected_json_plaintext; else backend_request_formatter = format_dimension_stored_json_plaintext; } else { error("BACKEND: Unknown backend type '%s'", type); goto cleanup; } if(backend_request_formatter == NULL || backend_response_checker == NULL) { error("BACKEND: backend is misconfigured - disabling it."); goto cleanup; } // ------------------------------------------------------------------------ // prepare the charts for monitoring the backend operation struct rusage thread; collected_number chart_buffered_metrics = 0, chart_lost_metrics = 0, chart_sent_metrics = 0, chart_buffered_bytes = 0, chart_received_bytes = 0, chart_sent_bytes = 0, chart_receptions = 0, chart_transmission_successes = 0, chart_transmission_failures = 0, chart_data_lost_events = 0, chart_lost_bytes = 0, chart_backend_reconnects = 0, chart_backend_latency = 0; RRDSET *chart_metrics = rrdset_create_localhost("netdata", "backend_metrics", NULL, "backend", NULL, "Netdata Buffered Metrics", "metrics", "backends", NULL, 130600, backend_update_every, RRDSET_TYPE_LINE); rrddim_add(chart_metrics, "buffered", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_metrics, "lost", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_metrics, "sent", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); RRDSET *chart_bytes = rrdset_create_localhost("netdata", "backend_bytes", NULL, "backend", NULL, "Netdata Backend Data Size", "KB", "backends", NULL, 130610, backend_update_every, RRDSET_TYPE_AREA); rrddim_add(chart_bytes, "buffered", NULL, 1, 1024, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_bytes, "lost", NULL, 1, 1024, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_bytes, "sent", NULL, 1, 1024, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_bytes, "received", NULL, 1, 1024, RRD_ALGORITHM_ABSOLUTE); RRDSET *chart_ops = rrdset_create_localhost("netdata", "backend_ops", NULL, "backend", NULL, "Netdata Backend Operations", "operations", "backends", NULL, 130630, backend_update_every, RRDSET_TYPE_LINE); rrddim_add(chart_ops, "write", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_ops, "discard", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_ops, "reconnect", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_ops, "failure", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); rrddim_add(chart_ops, "read", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE); /* * this is misleading - we can only measure the time we need to send data * this time is not related to the time required for the data to travel to * the backend database and the time that server needed to process them * * issue #1432 and https://www.softlab.ntua.gr/facilities/documentation/unix/unix-socket-faq/unix-socket-faq-2.html * RRDSET *chart_latency = rrdset_create_localhost("netdata", "backend_latency", NULL, "backend", NULL, "Netdata Backend Latency", "ms", "backends", NULL, 130620, backend_update_every, RRDSET_TYPE_AREA); rrddim_add(chart_latency, "latency", NULL, 1, 1000, RRD_ALGORITHM_ABSOLUTE); */ RRDSET *chart_rusage = rrdset_create_localhost("netdata", "backend_thread_cpu", NULL, "backend", NULL, "NetData Backend Thread CPU usage", "milliseconds/s", "backends", NULL, 130630, backend_update_every, RRDSET_TYPE_STACKED); rrddim_add(chart_rusage, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); rrddim_add(chart_rusage, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL); // ------------------------------------------------------------------------ // prepare the backend main loop info("BACKEND: configured ('%s' on '%s' sending '%s' data, every %d seconds, as host '%s', with prefix '%s')", type, destination, source, backend_update_every, hostname, backend_prefix); usec_t step_ut = backend_update_every * USEC_PER_SEC; time_t after = now_realtime_sec(); int failures = 0; heartbeat_t hb; heartbeat_init(&hb); while(!netdata_exit) { // ------------------------------------------------------------------------ // Wait for the next iteration point. heartbeat_next(&hb, step_ut); time_t before = now_realtime_sec(); debug(D_BACKEND, "BACKEND: preparing buffer for timeframe %lu to %lu", (unsigned long)after, (unsigned long)before); // ------------------------------------------------------------------------ // add to the buffer the data we need to send to the backend netdata_thread_disable_cancelability(); size_t count_hosts = 0; size_t count_charts_total = 0; size_t count_dims_total = 0; rrd_rdlock(); RRDHOST *host; rrdhost_foreach_read(host) { if(unlikely(!rrdhost_flag_check(host, RRDHOST_FLAG_BACKEND_SEND|RRDHOST_FLAG_BACKEND_DONT_SEND))) { char *name = (host == localhost)?"localhost":host->hostname; if (!hosts_pattern || simple_pattern_matches(hosts_pattern, name)) { rrdhost_flag_set(host, RRDHOST_FLAG_BACKEND_SEND); info("enabled backend for host '%s'", name); } else { rrdhost_flag_set(host, RRDHOST_FLAG_BACKEND_DONT_SEND); info("disabled backend for host '%s'", name); } } if(unlikely(!rrdhost_flag_check(host, RRDHOST_FLAG_BACKEND_SEND))) continue; rrdhost_rdlock(host); count_hosts++; size_t count_charts = 0; size_t count_dims = 0; size_t count_dims_skipped = 0; const char *__hostname = (host == localhost)?hostname:host->hostname; RRDSET *st; rrdset_foreach_read(st, host) { if(likely(backends_can_send_rrdset(backend_options, st))) { rrdset_rdlock(st); count_charts++; RRDDIM *rd; rrddim_foreach_read(rd, st) { if (likely(rd->last_collected_time.tv_sec >= after)) { chart_buffered_metrics += backend_request_formatter(b, backend_prefix, host, __hostname, st, rd, after, before, backend_options); count_dims++; } else { debug(D_BACKEND, "BACKEND: not sending dimension '%s' of chart '%s' from host '%s', its last data collection (%lu) is not within our timeframe (%lu to %lu)", rd->id, st->id, __hostname, (unsigned long)rd->last_collected_time.tv_sec, (unsigned long)after, (unsigned long)before); count_dims_skipped++; } } rrdset_unlock(st); } } debug(D_BACKEND, "BACKEND: sending host '%s', metrics of %zu dimensions, of %zu charts. Skipped %zu dimensions.", __hostname, count_dims, count_charts, count_dims_skipped); count_charts_total += count_charts; count_dims_total += count_dims; rrdhost_unlock(host); } rrd_unlock(); netdata_thread_enable_cancelability(); debug(D_BACKEND, "BACKEND: buffer has %zu bytes, added metrics for %zu dimensions, of %zu charts, from %zu hosts", buffer_strlen(b), count_dims_total, count_charts_total, count_hosts); // ------------------------------------------------------------------------ chart_buffered_bytes = (collected_number)buffer_strlen(b); // reset the monitoring chart counters chart_received_bytes = chart_sent_bytes = chart_sent_metrics = chart_lost_metrics = chart_transmission_successes = chart_transmission_failures = chart_data_lost_events = chart_lost_bytes = chart_backend_reconnects = chart_backend_latency = 0; if(unlikely(netdata_exit)) break; //fprintf(stderr, "\nBACKEND BEGIN:\n%s\nBACKEND END\n", buffer_tostring(b)); // FIXME //fprintf(stderr, "after = %lu, before = %lu\n", after, before); // prepare for the next iteration // to add incrementally data to buffer after = before; // ------------------------------------------------------------------------ // if we are connected, receive a response, without blocking if(likely(sock != -1)) { errno = 0; // loop through to collect all data while(sock != -1 && errno != EWOULDBLOCK) { buffer_need_bytes(response, 4096); ssize_t r = recv(sock, &response->buffer[response->len], response->size - response->len, MSG_DONTWAIT); if(likely(r > 0)) { // we received some data response->len += r; chart_received_bytes += r; chart_receptions++; } else if(r == 0) { error("BACKEND: '%s' closed the socket", destination); close(sock); sock = -1; } else { // failed to receive data if(errno != EAGAIN && errno != EWOULDBLOCK) { error("BACKEND: cannot receive data from backend '%s'.", destination); } } } // if we received data, process them if(buffer_strlen(response)) backend_response_checker(response); } // ------------------------------------------------------------------------ // if we are not connected, connect to a backend server if(unlikely(sock == -1)) { usec_t start_ut = now_monotonic_usec(); size_t reconnects = 0; sock = connect_to_one_of(destination, default_port, &timeout, &reconnects, NULL, 0); chart_backend_reconnects += reconnects; chart_backend_latency += now_monotonic_usec() - start_ut; } if(unlikely(netdata_exit)) break; // ------------------------------------------------------------------------ // if we are connected, send our buffer to the backend server if(likely(sock != -1)) { size_t len = buffer_strlen(b); usec_t start_ut = now_monotonic_usec(); int flags = 0; #ifdef MSG_NOSIGNAL flags += MSG_NOSIGNAL; #endif ssize_t written = send(sock, buffer_tostring(b), len, flags); chart_backend_latency += now_monotonic_usec() - start_ut; if(written != -1 && (size_t)written == len) { // we sent the data successfully chart_transmission_successes++; chart_sent_bytes += written; chart_sent_metrics = chart_buffered_metrics; // reset the failures count failures = 0; // empty the buffer buffer_flush(b); } else { // oops! we couldn't send (all or some of the) data error("BACKEND: failed to write data to database backend '%s'. Willing to write %zu bytes, wrote %zd bytes. Will re-connect.", destination, len, written); chart_transmission_failures++; if(written != -1) chart_sent_bytes += written; // increment the counter we check for data loss failures++; // close the socket - we will re-open it next time close(sock); sock = -1; } } else { error("BACKEND: failed to update database backend '%s'", destination); chart_transmission_failures++; // increment the counter we check for data loss failures++; } if(failures > buffer_on_failures) { // too bad! we are going to lose data chart_lost_bytes += buffer_strlen(b); error("BACKEND: reached %d backend failures. Flushing buffers to protect this host - this results in data loss on back-end server '%s'", failures, destination); buffer_flush(b); failures = 0; chart_data_lost_events++; chart_lost_metrics = chart_buffered_metrics; } if(unlikely(netdata_exit)) break; // ------------------------------------------------------------------------ // update the monitoring charts if(likely(chart_ops->counter_done)) rrdset_next(chart_ops); rrddim_set(chart_ops, "read", chart_receptions); rrddim_set(chart_ops, "write", chart_transmission_successes); rrddim_set(chart_ops, "discard", chart_data_lost_events); rrddim_set(chart_ops, "failure", chart_transmission_failures); rrddim_set(chart_ops, "reconnect", chart_backend_reconnects); rrdset_done(chart_ops); if(likely(chart_metrics->counter_done)) rrdset_next(chart_metrics); rrddim_set(chart_metrics, "buffered", chart_buffered_metrics); rrddim_set(chart_metrics, "lost", chart_lost_metrics); rrddim_set(chart_metrics, "sent", chart_sent_metrics); rrdset_done(chart_metrics); if(likely(chart_bytes->counter_done)) rrdset_next(chart_bytes); rrddim_set(chart_bytes, "buffered", chart_buffered_bytes); rrddim_set(chart_bytes, "lost", chart_lost_bytes); rrddim_set(chart_bytes, "sent", chart_sent_bytes); rrddim_set(chart_bytes, "received", chart_received_bytes); rrdset_done(chart_bytes); /* if(likely(chart_latency->counter_done)) rrdset_next(chart_latency); rrddim_set(chart_latency, "latency", chart_backend_latency); rrdset_done(chart_latency); */ getrusage(RUSAGE_THREAD, &thread); if(likely(chart_rusage->counter_done)) rrdset_next(chart_rusage); rrddim_set(chart_rusage, "user", thread.ru_utime.tv_sec * 1000000ULL + thread.ru_utime.tv_usec); rrddim_set(chart_rusage, "system", thread.ru_stime.tv_sec * 1000000ULL + thread.ru_stime.tv_usec); rrdset_done(chart_rusage); if(likely(buffer_strlen(b) == 0)) chart_buffered_metrics = 0; if(unlikely(netdata_exit)) break; } cleanup: if(sock != -1) close(sock); buffer_free(b); buffer_free(response); netdata_thread_cleanup_pop(1); return NULL; }