From: Marc Fournier <marc.fournier@camptocamp.com>
Date: Mon, 24 Nov 2014 08:44:45 +0000 (+0100)
Subject: Merge branch 'collectd-5.4'
X-Git-Tag: collectd-5.5.0~127
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e1812f8e5c5f91328398c66b602d07ee7c6ede51;p=thirdparty%2Fcollectd.git

Merge branch 'collectd-5.4'

Conflicts:
	src/Makefile.am
	src/cpu.c
	src/swap.c
	src/write_redis.c

NB: dropped change to src/swap.c made in 1a146775d4, as suggested in the
commit message.
---

e1812f8e5c5f91328398c66b602d07ee7c6ede51
diff --cc src/collectd.conf.in
index 5196979ea,1e0f78c17..a25cce55f
--- a/src/collectd.conf.in
+++ b/src/collectd.conf.in
@@@ -1039,16 -1002,20 +1074,22 @@@
  #  DeleteGauges   false
  #  DeleteSets     false
  #  TimerPercentile 90.0
+ #  TimerPercentile 95.0
+ #  TimerPercentile 99.0
+ #  TimerLower     false
+ #  TimerUpper     false
+ #  TimerSum       false
+ #  TimerCount     false
  #</Plugin>
  
 -#<Plugin "swap">
 +#<Plugin swap>
  #	ReportByDevice false
  #	ReportBytes true
 +#	ValuesAbsolute true
 +#	ValuesPercentage false
  #</Plugin>
  
 -#<Plugin "table">
 +#<Plugin table>
  #	<Table "/proc/slabinfo">
  #		Instance "slabinfo"
  #		Separator " "
diff --cc src/collectd.conf.pod
index 20c612600,03a144432..a65d432bd
--- a/src/collectd.conf.pod
+++ b/src/collectd.conf.pod
@@@ -7105,9 -6304,64 +7118,64 @@@ want to set B<metadata.broker.list> to 
  
  =back
  
+ =head2 Plugin C<write_redis>
+ 
+ The I<write_redis plugin> submits values to I<Redis>, a data structure server.
+ 
+ Synopsis:
+ 
+   <Plugin "write_redis">
+     <Node "example">
+         Host "localhost"
+         Port "6379"
+         Timeout 1000
+     </Node>
+   </Plugin>
+ 
+ Values are submitted to I<Sorted Sets>, using the metric name as the key, and
+ the timestamp as the score. Retrieving a date range can then be done using the
+ C<ZRANGEBYSCORE> I<Redis> command. Additionnally, all the identifiers of these
+ I<Sorted Sets> are kept in a I<Set> called C<collectd/values> and can be
+ retrieved using the C<SMEMBERS> I<Redis> command. See
+ L<http://redis.io/commands#sorted_set> and L<http://redis.io/commands#set> for
+ details.
+ 
+ The information shown in the synopsis above is the I<default configuration>
+ which is used by the plugin if no configuration is present.
+ 
+ The plugin can send values to multiple instances of I<Redis> by specifying
+ one B<Node> block for each instance. Within the B<Node> blocks, the following
+ options are available:
+ 
+ =over 4
+ 
+ =item B<Node> I<Nodename>
+ 
+ The B<Node> block identifies a new I<Redis> node, that is a new I<Redis>
+ instance running in an specified host and port. The name for node is a
+ canonical identifier which is used as I<plugin instance>. It is limited to
+ 64E<nbsp>characters in length.
+ 
+ =item B<Host> I<Hostname>
+ 
+ The B<Host> option is the hostname or IP-address where the I<Redis> instance is
+ running on.
+ 
+ =item B<Port> I<Port>
+ 
+ The B<Port> option is the TCP port on which the Redis instance accepts
+ connections. Either a service name of a port number may be given. Please note
+ that numerical port numbers must be given as a string, too.
+ 
+ =item B<Timeout> I<Timeout in miliseconds>
+ 
+ The B<Timeout> option sets the socket connection timeout, in milliseconds.
+ 
+ =back
+ 
  =head2 Plugin C<write_riemann>
  
 -The I<write_riemann plugin> will send values to I<Riemann>, a powerfull stream
 +The I<write_riemann plugin> will send values to I<Riemann>, a powerful stream
  aggregation and monitoring system. The plugin sends I<Protobuf> encoded data to
  I<Riemann> using UDP packets.
  
diff --cc src/cpu.c
index d1978f96b,1c4e5f6ba..2fb4918b9
--- a/src/cpu.c
+++ b/src/cpu.c
@@@ -172,57 -139,9 +166,57 @@@ static int numcpu
  static int pnumcpu;
  #endif /* HAVE_PERFSTAT */
  
 +#define RATE_ADD(sum, val) do { \
 +	if (isnan (sum))        \
 +	(sum) = (val);          \
 +	else if (!isnan (val))  \
 +	(sum) += (val);         \
 +} while (0)
 +
 +struct cpu_state_s
 +{
 +	value_to_rate_state_t conv;
 +	gauge_t rate;
 +	_Bool has_value;
 +};
 +typedef struct cpu_state_s cpu_state_t;
 +
 +static cpu_state_t *cpu_states = NULL;
 +static size_t cpu_states_num = 0; /* #cpu_states allocated */
 +
 +/* Highest CPU number in the current iteration. Used by the dispatch logic to
 + * determine how many CPUs there were. Reset to 0 by cpu_reset(). */
 +static size_t global_cpu_num = 0;
 +
 +static _Bool report_by_cpu = 1;
 +static _Bool report_by_state = 1;
 +static _Bool report_percent = 0;
 +
 +static const char *config_keys[] =
 +{
 +	"ReportByCpu",
 +	"ReportByState",
 +	"ValuesPercentage"
 +};
 +static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
 +
 +static int cpu_config (char const *key, char const *value) /* {{{ */
 +{
 +	if (strcasecmp (key, "ReportByCpu") == 0)
 +		report_by_cpu = IS_TRUE (value) ? 1 : 0;
 +	else if (strcasecmp (key, "ValuesPercentage") == 0)
 +		report_percent = IS_TRUE (value) ? 1 : 0;
 +	else if (strcasecmp (key, "ReportByState") == 0)
 +		report_by_state = IS_TRUE (value) ? 1 : 0;
 +	else
 +		return (-1);
 +
 +	return (0);
 +} /* }}} int cpu_config */
 +
  static int init (void)
  {
- #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE
+ #if PROCESSOR_CPU_LOAD_INFO
  	kern_return_t status;
  
  	port_host = mach_host_self ();
@@@ -339,257 -254,15 +333,251 @@@ static void submit_value (int cpu_num, 
  	plugin_dispatch_values (&vl);
  }
  
 +static void submit_percent(int cpu_num, int cpu_state, gauge_t percent)
 +{
 +	value_t value;
 +
 +	/* This function is called for all known CPU states, but each read
 +	 * method will only report a subset. The remaining states are left as
 +	 * NAN and we ignore them here. */
 +	if (isnan (percent))
 +		return;
 +
 +	value.gauge = percent;
 +	submit_value (cpu_num, cpu_state, "percent", value);
 +}
 +
 +static void submit_derive(int cpu_num, int cpu_state, derive_t derive)
 +{
 +	value_t value;
 +
 +	value.derive = derive;
 +	submit_value (cpu_num, cpu_state, "cpu", value);
 +}
 +
 +/* Takes the zero-index number of a CPU and makes sure that the module-global
 + * cpu_states buffer is large enough. Returne ENOMEM on erorr. */
 +static int cpu_states_alloc (size_t cpu_num) /* {{{ */
 +{
 +	cpu_state_t *tmp;
 +	size_t sz;
 +
 +	sz = (((size_t) cpu_num) + 1) * CPU_STATE_MAX;
 +	assert (sz > 0);
 +
 +	/* We already have enough space. */
 +	if (cpu_states_num >= sz)
 +		return 0;
 +
 +	tmp = realloc (cpu_states, sz * sizeof (*cpu_states));
 +	if (tmp == NULL)
 +	{
 +		ERROR ("cpu plugin: realloc failed.");
 +		return (ENOMEM);
 +	}
 +	cpu_states = tmp;
 +	tmp = cpu_states + cpu_states_num;
 +
 +	memset (tmp, 0, (sz - cpu_states_num) * sizeof (*cpu_states));
 +	cpu_states_num = sz;
 +	return 0;
 +} /* }}} cpu_states_alloc */
 +
 +static cpu_state_t *get_cpu_state (size_t cpu_num, size_t state) /* {{{ */
 +{
 +	size_t index = ((cpu_num * CPU_STATE_MAX) + state);
 +
 +	if (index >= cpu_states_num)
 +		return (NULL);
 +
 +	return (&cpu_states[index]);
 +} /* }}} cpu_state_t *get_cpu_state */
 +
 +/* Populates the per-CPU CPU_STATE_ACTIVE rate and the global rate_by_state
 + * array. */
 +static void aggregate (gauge_t *sum_by_state) /* {{{ */
 +{
 +	size_t cpu_num;
 +	size_t state;
 +
 +	for (state = 0; state < CPU_STATE_MAX; state++)
 +		sum_by_state[state] = NAN;
 +
 +	for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
 +	{
 +		cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
 +
 +		this_cpu_states[CPU_STATE_ACTIVE].rate = NAN;
 +
 +		for (state = 0; state < CPU_STATE_ACTIVE; state++)
 +		{
 +			if (!this_cpu_states[state].has_value)
 +				continue;
 +
 +			RATE_ADD (sum_by_state[state], this_cpu_states[state].rate);
 +			if (state != CPU_STATE_IDLE)
 +				RATE_ADD (this_cpu_states[CPU_STATE_ACTIVE].rate, this_cpu_states[state].rate);
 +		}
 +
 +		RATE_ADD (sum_by_state[CPU_STATE_ACTIVE], this_cpu_states[CPU_STATE_ACTIVE].rate);
 +	}
 +} /* }}} void aggregate */
 +
 +/* Commits (dispatches) the values for one CPU or the global aggregation.
 + * cpu_num is the index of the CPU to be committed or -1 in case of the global
 + * aggregation. rates is a pointer to CPU_STATE_MAX gauge_t values holding the
 + * current rate; each rate may be NAN. Calculates the percentage of each state
 + * and dispatches the metric. */
 +static void cpu_commit_one (int cpu_num, /* {{{ */
 +		gauge_t rates[static CPU_STATE_MAX])
 +{
 +	size_t state;
 +	gauge_t sum;
 +
 +	sum = rates[CPU_STATE_ACTIVE];
 +	RATE_ADD (sum, rates[CPU_STATE_IDLE]);
 +
 +	if (!report_by_state)
 +	{
 +		gauge_t percent = 100.0 * rates[CPU_STATE_ACTIVE] / sum;
 +		submit_percent (cpu_num, CPU_STATE_ACTIVE, percent);
 +		return;
 +	}
 +
 +	for (state = 0; state < CPU_STATE_ACTIVE; state++)
 +	{
 +		gauge_t percent = 100.0 * rates[state] / sum;
 +		submit_percent (cpu_num, state, percent);
 +	}
 +} /* }}} void cpu_commit_one */
 +
 +/* Resets the internal aggregation. This is called by the read callback after
 + * each iteration / after each call to cpu_commit(). */
 +static void cpu_reset (void) /* {{{ */
 +{
 +	size_t i;
 +
 +	for (i = 0; i < cpu_states_num; i++)
 +		cpu_states[i].has_value = 0;
 +
 +	global_cpu_num = 0;
 +} /* }}} void cpu_reset */
 +
 +/* Legacy behavior: Dispatches the raw derive values without any aggregation. */
 +static void cpu_commit_without_aggregation (void) /* {{{ */
 +{
 +	int state;
 +
 +	for (state = 0; state < CPU_STATE_ACTIVE; state++)
 +	{
 +		size_t cpu_num;
 +		if (report_by_cpu) {
 +			for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
 +			{
 +				cpu_state_t *s = get_cpu_state (cpu_num, state);
 +
 +				if (!s->has_value)
 +					continue;
 +
 +				submit_derive ((int) cpu_num, (int) state, s->conv.last_value.derive);
 +			}
 +		} else {
 +			derive_t derive_total = 0;
 +			for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
 +				{
 +					cpu_state_t *s = get_cpu_state (cpu_num, state);
 +
 +					if (!s->has_value)
 +						continue;
 +
 +					derive_total += s->conv.last_value.derive;
 +			
 +				}
 +			submit_derive (-1, (int) state, derive_total);
 +		}
 +	}
 +} /* }}} void cpu_commit_without_aggregation */
 +
 +/* Aggregates the internal state and dispatches the metrics. */
 +static void cpu_commit (void) /* {{{ */
 +{
 +	gauge_t global_rates[CPU_STATE_MAX] = {
 +		NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN
 +	};
 +	size_t cpu_num;
 +
 +	if (report_by_state && !report_percent)
 +	{
 +		cpu_commit_without_aggregation ();
 +		return;
 +	}
 +
 +	aggregate (global_rates);
 +
 +	if (!report_by_cpu)
 +	{
 +		cpu_commit_one (-1, global_rates);
 +		return;
 +	}
 +
 +	for (cpu_num = 0; cpu_num < global_cpu_num; cpu_num++)
 +	{
 +		cpu_state_t *this_cpu_states = get_cpu_state (cpu_num, 0);
 +		gauge_t local_rates[CPU_STATE_MAX] = {
 +			NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN
 +		};
 +		size_t state;
 +
 +		for (state = 0; state < CPU_STATE_ACTIVE; state++)
 +			if (this_cpu_states[state].has_value)
 +				local_rates[state] = this_cpu_states[state].rate;
 +
 +		cpu_commit_one ((int) cpu_num, local_rates);
 +	}
 +} /* }}} void cpu_commit */
 +
 +/* Adds a derive value to the internal state. This should be used by each read
 + * function for each state. At the end of the iteration, the read function
 + * should call cpu_commit(). */
 +static int cpu_stage (size_t cpu_num, size_t state, derive_t value, cdtime_t now) /* {{{ */
 +{
 +	int status;
 +	cpu_state_t *s;
 +	value_t v;
 +
 +	if (state >= CPU_STATE_ACTIVE)
 +		return (EINVAL);
 +
 +	status = cpu_states_alloc (cpu_num);
 +	if (status != 0)
 +		return (status);
 +
 +	if (global_cpu_num <= cpu_num)
 +		global_cpu_num = cpu_num + 1;
 +
 +	s = get_cpu_state (cpu_num, state);
 +
 +	v.gauge = NAN;
 +	status = value_to_rate (&v, value, &s->conv, DS_TYPE_DERIVE, now);
 +	if (status != 0)
 +		return (status);
 +
 +	s->rate = v.gauge;
 +	s->has_value = 1;
 +	return (0);
 +} /* }}} int cpu_stage */
 +
  static int cpu_read (void)
  {
 -#if PROCESSOR_CPU_LOAD_INFO
 +	cdtime_t now = cdtime ();
 +
- #if PROCESSOR_CPU_LOAD_INFO || PROCESSOR_TEMPERATURE /* {{{ */
++#if PROCESSOR_CPU_LOAD_INFO /* {{{ */
  	int cpu;
  
  	kern_return_t status;
 -	
 +
- #if PROCESSOR_CPU_LOAD_INFO
  	processor_cpu_load_info_data_t cpu_info;
  	mach_msg_type_number_t         cpu_info_len;
- #endif
- #if PROCESSOR_TEMPERATURE
- 	processor_info_data_t          cpu_temp;
- 	mach_msg_type_number_t         cpu_temp_len;
- #endif
  
  	host_t cpu_host;
  
@@@ -613,59 -286,17 +601,15 @@@
  			continue;
  		}
  
 -		submit (cpu, "user", (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER]);
 -		submit (cpu, "nice", (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE]);
 -		submit (cpu, "system", (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM]);
 -		submit (cpu, "idle", (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE]);
 +		cpu_stage (cpu, CPU_STATE_USER,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_USER],   now);
 +		cpu_stage (cpu, CPU_STATE_NICE,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_NICE],   now);
 +		cpu_stage (cpu, CPU_STATE_SYSTEM, (derive_t) cpu_info.cpu_ticks[CPU_STATE_SYSTEM], now);
 +		cpu_stage (cpu, CPU_STATE_IDLE,   (derive_t) cpu_info.cpu_ticks[CPU_STATE_IDLE],   now);
- #endif /* PROCESSOR_CPU_LOAD_INFO */
- 
- #if PROCESSOR_TEMPERATURE
- 		/*
- 		 * Not all Apple computers do have this ability. To minimize
- 		 * the messages sent to the syslog we do an exponential
- 		 * stepback if `processor_info' fails. We still try ~once a day
- 		 * though..
- 		 */
- 		if (cpu_temp_retry_counter > 0)
- 		{
- 			cpu_temp_retry_counter--;
- 			continue;
- 		}
- 
- 		cpu_temp_len = PROCESSOR_INFO_MAX;
- 
- 		status = processor_info (cpu_list[cpu],
- 				PROCESSOR_TEMPERATURE,
- 				&cpu_host,
- 				cpu_temp, &cpu_temp_len);
- 		if (status != KERN_SUCCESS)
- 		{
- 			ERROR ("cpu plugin: processor_info failed: %s",
- 					mach_error_string (status));
- 
- 			cpu_temp_retry_counter = cpu_temp_retry_step;
- 			cpu_temp_retry_step *= 2;
- 			if (cpu_temp_retry_step > cpu_temp_retry_max)
- 				cpu_temp_retry_step = cpu_temp_retry_max;
- 
- 			continue;
- 		}
- 
- 		if (cpu_temp_len != 1)
- 		{
- 			DEBUG ("processor_info (PROCESSOR_TEMPERATURE) returned %i elements..?",
- 					(int) cpu_temp_len);
- 			continue;
- 		}
- 
- 		cpu_temp_retry_counter = 0;
- 		cpu_temp_retry_step    = 1;
- #endif /* PROCESSOR_TEMPERATURE */
  	}
 -/* #endif PROCESSOR_CPU_LOAD_INFO */
 +/* }}} #endif PROCESSOR_CPU_LOAD_INFO */
  
 -#elif defined(KERNEL_LINUX)
 +#elif defined(KERNEL_LINUX) /* {{{ */
  	int cpu;
 -	derive_t user, nice, syst, idle;
 -	derive_t wait, intr, sitr; /* sitr == soft interrupt */
  	FILE *fh;
  	char buf[1024];