size_t uc_get_size (void) { size_t size_arrays = 0; pthread_mutex_lock (&cache_lock); size_arrays = (size_t) c_avl_size (cache_tree); pthread_mutex_unlock (&cache_lock); return (size_arrays); }
/* Must hold metrics_lock when calling this function. */ static int statsd_metric_submit_unsafe (statsd_config_t *conf, char const *name, /* {{{ */ statsd_metric_t const *metric) { value_t values[1]; value_list_t vl = VALUE_LIST_INIT; char *global_prefix = NULL; char *type_prefix = NULL; char *global_postfix = NULL; char full_name[DATA_MAX_NAME_LEN] = {0}; DEBUG("statsd plugin: submit metric"); vl.values = values; vl.values_len = 1; sstrncpy (vl.host, hostname_g, sizeof (vl.host)); sstrncpy (vl.plugin, "statsd", sizeof (vl.plugin)); sstrncpy (vl.plugin_instance, conf->node_name, sizeof (vl.plugin_instance)); global_prefix = (NULL == conf->global_prefix) ? "" : conf->global_prefix; global_postfix = (NULL == conf->global_postfix) ? "" : conf->global_postfix; switch (metric->type) { case STATSD_GAUGE: sstrncpy (vl.type, "gauge", sizeof (vl.type)); type_prefix = (NULL == conf->gauge_prefix) ? "" : conf->gauge_prefix; break; case STATSD_TIMER: sstrncpy (vl.type, "latency", sizeof (vl.type)); type_prefix = (NULL == conf->timer_prefix) ? "" : conf->timer_prefix; break; case STATSD_SET: sstrncpy (vl.type, "objects", sizeof (vl.type)); type_prefix = (NULL == conf->set_prefix) ? "" : conf->set_prefix; break; case STATSD_COUNTER: sstrncpy (vl.type, "derive", sizeof (vl.type)); type_prefix = (NULL == conf->counter_prefix) ? "" : conf->counter_prefix; break; default: ERROR("statsd plugin: unknow metrics type %d", metric->type); } ssnprintf(full_name, sizeof(full_name), "%s%s%s%s", global_prefix, type_prefix, name, global_postfix); DEBUG("statsd plugin: metric name %s", full_name); sstrncpy (vl.type_instance, full_name, sizeof (vl.type_instance)); if (metric->type == STATSD_GAUGE) values[0].gauge = (gauge_t) metric->value; else if (metric->type == STATSD_TIMER) { size_t i; _Bool have_events = (metric->updates_num > 0); /* Make sure all timer metrics share the *same* timestamp. */ vl.time = cdtime (); if (!conf->leave_metrics_name_asis) ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-average", full_name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_average (metric->latency)) : NAN; plugin_dispatch_values (&vl); if (conf->timer_lower) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-lower", full_name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_min (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf->timer_upper) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-upper", full_name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_max (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf->timer_sum) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-sum", full_name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_sum (metric->latency)) : NAN; plugin_dispatch_values (&vl); } for (i = 0; i < conf->timer_percentile_num; i++) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-percentile-%.0f", full_name, conf->timer_percentile[i]); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (metric->latency, conf->timer_percentile[i])) : NAN; plugin_dispatch_values (&vl); } /* Keep this at the end, since vl.type is set to "gauge" here. The * vl.type's above are implicitly set to "latency". */ if (conf->timer_count) { sstrncpy (vl.type, "gauge", sizeof (vl.type)); ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-count", full_name); values[0].gauge = latency_counter_get_num (metric->latency); plugin_dispatch_values (&vl); } latency_counter_reset (metric->latency); return (0); } else if (metric->type == STATSD_SET) { if (metric->set == NULL) values[0].gauge = 0.0; else values[0].gauge = (gauge_t) c_avl_size (metric->set); } else { /* STATSD_COUNTER */ /* * Expand a single value to two metrics: * * - The absolute counter, as a gauge * - A derived rate for this counter */ values[0].derive = (derive_t) metric->value; plugin_dispatch_values(&vl); sstrncpy(vl.type, "gauge", sizeof (vl.type)); values[0].gauge = (gauge_t) metric->value; } return (plugin_dispatch_values (&vl)); } /* }}} int statsd_metric_submit_unsafe */
/* Must hold metrics_lock when calling this function. */ static int statsd_metric_submit_unsafe (char const *name, /* {{{ */ statsd_metric_t const *metric) { value_t values[1]; value_list_t vl = VALUE_LIST_INIT; vl.values = values; vl.values_len = 1; sstrncpy (vl.host, hostname_g, sizeof (vl.host)); sstrncpy (vl.plugin, "statsd", sizeof (vl.plugin)); if (metric->type == STATSD_GAUGE) sstrncpy (vl.type, "gauge", sizeof (vl.type)); else if (metric->type == STATSD_TIMER) sstrncpy (vl.type, "latency", sizeof (vl.type)); else if (metric->type == STATSD_SET) sstrncpy (vl.type, "objects", sizeof (vl.type)); else /* if (metric->type == STATSD_COUNTER) */ sstrncpy (vl.type, "derive", sizeof (vl.type)); sstrncpy (vl.type_instance, name, sizeof (vl.type_instance)); if (metric->type == STATSD_GAUGE) values[0].gauge = (gauge_t) metric->value; else if (metric->type == STATSD_TIMER) { size_t i; _Bool have_events = (metric->updates_num > 0); /* Make sure all timer metrics share the *same* timestamp. */ vl.time = cdtime (); ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-average", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_average (metric->latency)) : NAN; plugin_dispatch_values (&vl); if (conf_timer_lower) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-lower", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_min (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf_timer_upper) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-upper", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_max (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf_timer_sum) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-sum", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_sum (metric->latency)) : NAN; plugin_dispatch_values (&vl); } for (i = 0; i < conf_timer_percentile_num; i++) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-percentile-%.0f", name, conf_timer_percentile[i]); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (metric->latency, conf_timer_percentile[i])) : NAN; plugin_dispatch_values (&vl); } /* Keep this at the end, since vl.type is set to "gauge" here. The * vl.type's above are implicitly set to "latency". */ if (conf_timer_count) { sstrncpy (vl.type, "gauge", sizeof (vl.type)); ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-count", name); values[0].gauge = latency_counter_get_num (metric->latency); plugin_dispatch_values (&vl); } latency_counter_reset (metric->latency); return (0); } else if (metric->type == STATSD_SET) { if (metric->set == NULL) values[0].gauge = 0.0; else values[0].gauge = (gauge_t) c_avl_size (metric->set); } else values[0].derive = (derive_t) metric->value; return (plugin_dispatch_values (&vl)); } /* }}} int statsd_metric_submit_unsafe */
int uc_get_names (char ***ret_names, cdtime_t **ret_times, size_t *ret_number) { c_avl_iterator_t *iter; char *key; cache_entry_t *value; char **names = NULL; cdtime_t *times = NULL; size_t number = 0; size_t size_arrays = 0; int status = 0; if ((ret_names == NULL) || (ret_number == NULL)) return (-1); pthread_mutex_lock (&cache_lock); size_arrays = (size_t) c_avl_size (cache_tree); if (size_arrays < 1) { /* Handle the "no values" case here, to avoid the error message when * calloc() returns NULL. */ pthread_mutex_unlock (&cache_lock); return (0); } names = calloc (size_arrays, sizeof (*names)); times = calloc (size_arrays, sizeof (*times)); if ((names == NULL) || (times == NULL)) { ERROR ("uc_get_names: calloc failed."); sfree (names); sfree (times); pthread_mutex_unlock (&cache_lock); return (ENOMEM); } iter = c_avl_get_iterator (cache_tree); while (c_avl_iterator_next (iter, (void *) &key, (void *) &value) == 0) { /* remove missing values when list values */ if (value->state == STATE_MISSING) continue; /* c_avl_size does not return a number smaller than the number of elements * returned by c_avl_iterator_next. */ assert (number < size_arrays); if (ret_times != NULL) times[number] = value->last_time; names[number] = strdup (key); if (names[number] == NULL) { status = -1; break; } number++; } /* while (c_avl_iterator_next) */ c_avl_iterator_destroy (iter); pthread_mutex_unlock (&cache_lock); if (status != 0) { size_t i; for (i = 0; i < number; i++) { sfree (names[i]); } sfree (names); sfree (times); return (-1); } *ret_names = names; if (ret_times != NULL) *ret_times = times; else sfree (times); *ret_number = number; return (0); } /* int uc_get_names */
/* Must hold metrics_lock when calling this function. */ static int statsd_metric_submit_unsafe (char const *name, statsd_metric_t *metric) /* {{{ */ { value_t values[1]; value_list_t vl = VALUE_LIST_INIT; vl.values = values; vl.values_len = 1; sstrncpy (vl.host, hostname_g, sizeof (vl.host)); sstrncpy (vl.plugin, "statsd", sizeof (vl.plugin)); if (metric->type == STATSD_GAUGE) sstrncpy (vl.type, "gauge", sizeof (vl.type)); else if (metric->type == STATSD_TIMER) sstrncpy (vl.type, "latency", sizeof (vl.type)); else if (metric->type == STATSD_SET) sstrncpy (vl.type, "objects", sizeof (vl.type)); else /* if (metric->type == STATSD_COUNTER) */ sstrncpy (vl.type, "derive", sizeof (vl.type)); sstrncpy (vl.type_instance, name, sizeof (vl.type_instance)); if (metric->type == STATSD_GAUGE) values[0].gauge = (gauge_t) metric->value; else if (metric->type == STATSD_TIMER) { size_t i; _Bool have_events = (metric->updates_num > 0); /* Make sure all timer metrics share the *same* timestamp. */ vl.time = cdtime (); ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-average", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_average (metric->latency)) : NAN; plugin_dispatch_values (&vl); if (conf_timer_lower) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-lower", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_min (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf_timer_upper) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-upper", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_max (metric->latency)) : NAN; plugin_dispatch_values (&vl); } if (conf_timer_sum) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-sum", name); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_sum (metric->latency)) : NAN; plugin_dispatch_values (&vl); } for (i = 0; i < conf_timer_percentile_num; i++) { ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-percentile-%.0f", name, conf_timer_percentile[i]); values[0].gauge = have_events ? CDTIME_T_TO_DOUBLE (latency_counter_get_percentile (metric->latency, conf_timer_percentile[i])) : NAN; plugin_dispatch_values (&vl); } /* Keep this at the end, since vl.type is set to "gauge" here. The * vl.type's above are implicitly set to "latency". */ if (conf_timer_count) { sstrncpy (vl.type, "gauge", sizeof (vl.type)); ssnprintf (vl.type_instance, sizeof (vl.type_instance), "%s-count", name); values[0].gauge = latency_counter_get_num (metric->latency); plugin_dispatch_values (&vl); } latency_counter_reset (metric->latency); return (0); } else if (metric->type == STATSD_SET) { if (metric->set == NULL) values[0].gauge = 0.0; else values[0].gauge = (gauge_t) c_avl_size (metric->set); } else { /* STATSD_COUNTER */ gauge_t delta = nearbyint (metric->value); /* Etsy's statsd writes counters as two metrics: a rate and the change since * the last write. Since collectd does not reset its DERIVE metrics to zero, * this makes little sense, but we're dispatching a "count" metric here * anyway - if requested by the user - for compatibility reasons. */ if (conf_counter_sum) { sstrncpy (vl.type, "count", sizeof (vl.type)); values[0].gauge = delta; plugin_dispatch_values (&vl); /* restore vl.type */ sstrncpy (vl.type, "derive", sizeof (vl.type)); } /* Rather than resetting value to zero, subtract delta so we correctly keep * track of residuals. */ metric->value -= delta; metric->counter += (derive_t) delta; values[0].derive = metric->counter; } return (plugin_dispatch_values (&vl)); } /* }}} int statsd_metric_submit_unsafe */