/**
* collectd - src/statsd.c
- *
* Copyright (C) 2013 Florian octo Forster
*
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*
* Authors:
* Florian octo Forster <octo at collectd.org>
#include <netdb.h>
#include <poll.h>
+/* AIX doesn't have MSG_DONTWAIT */
+#ifndef MSG_DONTWAIT
+# define MSG_DONTWAIT MSG_NONBLOCK
+#endif
+
#ifndef STATSD_DEFAULT_NODE
# define STATSD_DEFAULT_NODE NULL
#endif
struct statsd_metric_s
{
metric_type_t type;
- int64_t value;
+ double value;
latency_counter_t *latency;
c_avl_tree_t *set;
unsigned long updates_num;
static double *conf_timer_percentile = NULL;
static size_t conf_timer_percentile_num = 0;
+static _Bool conf_timer_lower = 0;
+static _Bool conf_timer_upper = 0;
+static _Bool conf_timer_sum = 0;
+static _Bool conf_timer_count = 0;
+
/* Must hold metrics_lock when calling this function. */
-static statsd_metric_t *statsd_metric_lookup_unsafe (char const *name,
+static statsd_metric_t *statsd_metric_lookup_unsafe (char const *name, /* {{{ */
metric_type_t type)
{
- char const *prefix;
char key[DATA_MAX_NAME_LEN + 2];
char *key_copy;
statsd_metric_t *metric;
switch (type)
{
- case STATSD_COUNTER: prefix = "c"; break;
- case STATSD_TIMER: prefix = "t"; break;
- case STATSD_GAUGE: prefix = "g"; break;
- case STATSD_SET: prefix = "s"; break;
+ case STATSD_COUNTER: key[0] = 'c'; break;
+ case STATSD_TIMER: key[0] = 't'; break;
+ case STATSD_GAUGE: key[0] = 'g'; break;
+ case STATSD_SET: key[0] = 's'; break;
default: return (NULL);
}
- ssnprintf (key, sizeof (key), "%s:%s", prefix, name);
+ key[1] = ':';
+ sstrncpy (&key[2], name, sizeof (key) - 2);
status = c_avl_get (metrics_tree, key, (void *) &metric);
if (status == 0)
return (metric);
} /* }}} statsd_metric_lookup_unsafe */
-static int statsd_metric_set (char const *name, int64_t value, /* {{{ */
+static int statsd_metric_set (char const *name, double value, /* {{{ */
metric_type_t type)
{
statsd_metric_t *metric;
return (0);
} /* }}} int statsd_metric_set */
-static int statsd_metric_add (char const *name, int64_t delta, /* {{{ */
+static int statsd_metric_add (char const *name, double delta, /* {{{ */
metric_type_t type)
{
statsd_metric_t *metric;
return (0);
} /* }}} int statsd_metric_add */
+static int statsd_parse_value (char const *str, value_t *ret_value) /* {{{ */
+{
+ char *endptr = NULL;
+
+ ret_value->gauge = (gauge_t) strtod (str, &endptr);
+ if ((str == endptr) || ((endptr != NULL) && (*endptr != 0)))
+ return (-1);
+
+ return (0);
+} /* }}} int statsd_parse_value */
+
static int statsd_handle_counter (char const *name, /* {{{ */
char const *value_str,
char const *extra)
{
- char key[DATA_MAX_NAME_LEN + 2];
value_t value;
value_t scale;
int status;
scale.gauge = 1.0;
if (extra != NULL)
{
- status = parse_value (extra + 1, &scale, DS_TYPE_GAUGE);
+ status = statsd_parse_value (extra + 1, &scale);
if (status != 0)
return (status);
return (-1);
}
- value.derive = 1;
- status = parse_value (value_str, &value, DS_TYPE_DERIVE);
+ value.gauge = 1.0;
+ status = statsd_parse_value (value_str, &value);
if (status != 0)
return (status);
- if (value.derive < 1)
- return (-1);
-
- ssnprintf (key, sizeof (key), "c:%s", name);
-
- return (statsd_metric_add (key,
- (int64_t) (((gauge_t) value.derive) / scale.gauge),
+ return (statsd_metric_add (name, (double) (value.gauge / scale.gauge),
STATSD_COUNTER));
} /* }}} int statsd_handle_counter */
static int statsd_handle_gauge (char const *name, /* {{{ */
char const *value_str)
{
- char key[DATA_MAX_NAME_LEN + 2];
value_t value;
int status;
- value.derive = 0;
- status = parse_value (value_str, &value, DS_TYPE_DERIVE);
+ value.gauge = 0;
+ status = statsd_parse_value (value_str, &value);
if (status != 0)
return (status);
- ssnprintf (key, sizeof (key), "g:%s", name);
-
if ((value_str[0] == '+') || (value_str[0] == '-'))
- return (statsd_metric_add (key, (int64_t) value.derive, STATSD_GAUGE));
+ return (statsd_metric_add (name, (double) value.gauge, STATSD_GAUGE));
else
- return (statsd_metric_set (key, (int64_t) value.derive, STATSD_GAUGE));
+ return (statsd_metric_set (name, (double) value.gauge, STATSD_GAUGE));
} /* }}} int statsd_handle_gauge */
static int statsd_handle_timer (char const *name, /* {{{ */
- char const *value_str)
+ char const *value_str,
+ char const *extra)
{
statsd_metric_t *metric;
value_t value_ms;
+ value_t scale;
cdtime_t value;
int status;
+ if ((extra != NULL) && (extra[0] != '@'))
+ return (-1);
+
+ scale.gauge = 1.0;
+ if (extra != NULL)
+ {
+ status = statsd_parse_value (extra + 1, &scale);
+ if (status != 0)
+ return (status);
+
+ if (!isfinite (scale.gauge) || (scale.gauge <= 0.0) || (scale.gauge > 1.0))
+ return (-1);
+ }
+
value_ms.derive = 0;
- status = parse_value (value_str, &value_ms, DS_TYPE_DERIVE);
+ status = statsd_parse_value (value_str, &value_ms);
if (status != 0)
return (status);
- value = MS_TO_CDTIME_T (value_ms.derive);
+ value = MS_TO_CDTIME_T (value_ms.gauge / scale.gauge);
pthread_mutex_lock (&metrics_lock);
if (strcmp ("c", type) == 0)
return (statsd_handle_counter (name, value, extra));
+ else if (strcmp ("ms", type) == 0)
+ return (statsd_handle_timer (name, value, extra));
- /* extra is only valid for counters */
+ /* extra is only valid for counters and timers */
if (extra != NULL)
return (-1);
if (strcmp ("g", type) == 0)
return (statsd_handle_gauge (name, value));
- else if (strcmp ("ms", type) == 0)
- return (statsd_handle_timer (name, value));
else if (strcmp ("s", type) == 0)
return (statsd_handle_set (name, value));
else
static void statsd_parse_buffer (char *buffer) /* {{{ */
{
- char *dummy;
- char *saveptr = NULL;
- char *ptr;
-
- for (dummy = buffer;
- (ptr = strtok_r (dummy, "\r\n", &saveptr)) != NULL;
- dummy = NULL)
+ while (buffer != NULL)
{
- char *line_orig = sstrdup (ptr);
+ char orig[64];
+ char *next;
int status;
- status = statsd_parse_line (ptr);
+ next = strchr (buffer, '\n');
+ if (next != NULL)
+ {
+ *next = 0;
+ next++;
+ }
+
+ if (*buffer == 0)
+ {
+ buffer = next;
+ continue;
+ }
+
+ sstrncpy (orig, buffer, sizeof (orig));
+
+ status = statsd_parse_line (buffer);
if (status != 0)
- ERROR ("statsd plugin: Unable to parse line: \"%s\"", line_orig);
+ ERROR ("statsd plugin: Unable to parse line: \"%s\"", orig);
- sfree (line_orig);
+ buffer = next;
}
} /* }}} void statsd_parse_buffer */
cf_util_get_boolean (child, &conf_delete_gauges);
else if (strcasecmp ("DeleteSets", child->key) == 0)
cf_util_get_boolean (child, &conf_delete_sets);
+ else if (strcasecmp ("TimerLower", child->key) == 0)
+ cf_util_get_boolean (child, &conf_timer_lower);
+ else if (strcasecmp ("TimerUpper", child->key) == 0)
+ cf_util_get_boolean (child, &conf_timer_upper);
+ else if (strcasecmp ("TimerSum", child->key) == 0)
+ cf_util_get_boolean (child, &conf_timer_sum);
+ else if (strcasecmp ("TimerCount", child->key) == 0)
+ cf_util_get_boolean (child, &conf_timer_count);
else if (strcasecmp ("TimerPercentile", child->key) == 0)
statsd_config_timer_percentile (child);
else
{
pthread_mutex_lock (&metrics_lock);
if (metrics_tree == NULL)
- metrics_tree = c_avl_create ((void *) strcasecmp);
+ metrics_tree = c_avl_create ((void *) strcmp);
if (!network_thread_running)
{
latency_counter_get_average (metric->latency));
plugin_dispatch_values (&vl);
+ if (conf_timer_lower) {
+ ssnprintf (vl.type_instance, sizeof (vl.type_instance),
+ "%s-lower", name);
+ values[0].gauge = CDTIME_T_TO_DOUBLE (
+ latency_counter_get_min (metric->latency));
+ plugin_dispatch_values (&vl);
+ }
+
+ if (conf_timer_upper) {
+ ssnprintf (vl.type_instance, sizeof (vl.type_instance),
+ "%s-upper", name);
+ values[0].gauge = CDTIME_T_TO_DOUBLE (
+ latency_counter_get_max (metric->latency));
+ plugin_dispatch_values (&vl);
+ }
+
+ if (conf_timer_sum) {
+ ssnprintf (vl.type_instance, sizeof (vl.type_instance),
+ "%s-sum", name);
+ values[0].gauge = CDTIME_T_TO_DOUBLE (
+ latency_counter_get_sum (metric->latency));
+ plugin_dispatch_values (&vl);
+ }
+
for (i = 0; i < conf_timer_percentile_num; i++)
{
ssnprintf (vl.type_instance, sizeof (vl.type_instance),
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);
}