X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Futils_cache.c;h=5e62aa40fbf7e21faeb94cd5183fd75df1fb2732;hb=fa9fd186f4e09c24a02d9541c2409d21bf282087;hp=04075f5579dade1175687f793c3f056288267d4a;hpb=43b3f7d1ce3195c93c5357bcafb60421699aab7d;p=collectd.git

diff --git a/src/utils_cache.c b/src/utils_cache.c
index 04075f55..5e62aa40 100644
--- a/src/utils_cache.c
+++ b/src/utils_cache.c
@@ -34,7 +34,7 @@ typedef struct cache_entry_s
 	char name[6 * DATA_MAX_NAME_LEN];
 	int        values_num;
 	gauge_t   *values_gauge;
-	counter_t *values_counter;
+	value_t   *values_raw;
 	/* Time contained in the package
 	 * (for calculating rates) */
 	time_t last_time;
@@ -69,12 +69,12 @@ static cache_entry_t *cache_alloc (int values_num)
   memset (ce, '\0', sizeof (cache_entry_t));
   ce->values_num = values_num;
 
-  ce->values_gauge = (gauge_t *) calloc (values_num, sizeof (gauge_t));
-  ce->values_counter = (counter_t *) calloc (values_num, sizeof (counter_t));
-  if ((ce->values_gauge == NULL) || (ce->values_counter == NULL))
+  ce->values_gauge = calloc (values_num, sizeof (*ce->values_gauge));
+  ce->values_raw   = calloc (values_num, sizeof (*ce->values_raw));
+  if ((ce->values_gauge == NULL) || (ce->values_raw == NULL))
   {
     sfree (ce->values_gauge);
-    sfree (ce->values_counter);
+    sfree (ce->values_raw);
     sfree (ce);
     ERROR ("utils_cache: cache_alloc: calloc failed.");
     return (NULL);
@@ -89,7 +89,7 @@ static void cache_free (cache_entry_t *ce)
     return;
 
   sfree (ce->values_gauge);
-  sfree (ce->values_counter);
+  sfree (ce->values_raw);
   sfree (ce);
 } /* void cache_free */
 
@@ -167,6 +167,21 @@ static int uc_send_notification (const char *name)
   return (0);
 } /* int uc_send_notification */
 
+static void uc_check_range (const data_set_t *ds, cache_entry_t *ce)
+{
+  int i;
+
+  for (i = 0; i < ds->ds_num; i++)
+  {
+    if (isnan (ce->values_gauge[i]))
+      continue;
+    else if (ce->values_gauge[i] < ds->ds[i].min)
+      ce->values_gauge[i] = NAN;
+    else if (ce->values_gauge[i] > ds->ds[i].max)
+      ce->values_gauge[i] = NAN;
+  }
+} /* void uc_check_range */
+
 static int uc_insert (const data_set_t *ds, const value_list_t *vl,
     const char *key)
 {
@@ -186,6 +201,7 @@ static int uc_insert (const data_set_t *ds, const value_list_t *vl,
   ce = cache_alloc (ds->ds_num);
   if (ce == NULL)
   {
+    sfree (key_copy);
     ERROR ("uc_insert: cache_alloc (%i) failed.", ds->ds_num);
     return (-1);
   }
@@ -194,17 +210,42 @@ static int uc_insert (const data_set_t *ds, const value_list_t *vl,
 
   for (i = 0; i < ds->ds_num; i++)
   {
-    if (ds->ds[i].type == DS_TYPE_COUNTER)
-    {
-      ce->values_gauge[i] = NAN;
-      ce->values_counter[i] = vl->values[i].counter;
-    }
-    else /* if (ds->ds[i].type == DS_TYPE_GAUGE) */
+    switch (ds->ds[i].type)
     {
-      ce->values_gauge[i] = vl->values[i].gauge;
-    }
+      case DS_TYPE_COUNTER:
+	ce->values_gauge[i] = NAN;
+	ce->values_raw[i].counter = vl->values[i].counter;
+	break;
+
+      case DS_TYPE_GAUGE:
+	ce->values_gauge[i] = vl->values[i].gauge;
+	ce->values_raw[i].gauge = vl->values[i].gauge;
+	break;
+
+      case DS_TYPE_DERIVE:
+	ce->values_gauge[i] = NAN;
+	ce->values_raw[i].derive = vl->values[i].derive;
+	break;
+
+      case DS_TYPE_ABSOLUTE:
+	ce->values_gauge[i] = NAN;
+	if (vl->interval > 0)
+	  ce->values_gauge[i] = ((double) vl->values[i].absolute)
+	    / ((double) vl->interval);
+	ce->values_raw[i].absolute = vl->values[i].absolute;
+	break;
+	
+      default:
+	/* This shouldn't happen. */
+	ERROR ("uc_insert: Don't know how to handle data source type %i.",
+	    ds->ds[i].type);
+	return (-1);
+    } /* switch (ds->ds[i].type) */
   } /* for (i) */
 
+  /* Prune invalid gauge data */
+  uc_check_range (ds, ce);
+
   ce->last_time = vl->time;
   ce->last_update = time (NULL);
   ce->interval = vl->interval;
@@ -259,8 +300,10 @@ int uc_check_timeout (void)
 	  (keys_len + 1) * sizeof (char *));
       if (tmp == NULL)
       {
-	ERROR ("uc_purge: realloc failed.");
+	ERROR ("uc_check_timeout: realloc failed.");
 	c_avl_iterator_destroy (iter);
+	sfree (keys);
+	pthread_mutex_unlock (&cache_lock);
 	return (-1);
       }
 
@@ -275,6 +318,8 @@ int uc_check_timeout (void)
     }
   } /* while (c_avl_iterator_next) */
 
+  ce = NULL;
+
   for (i = 0; i < keys_len; i++)
   {
     int status;
@@ -285,10 +330,10 @@ int uc_check_timeout (void)
     {
       ERROR ("uc_check_timeout: ut_check_interesting failed.");
       sfree (keys[i]);
+      continue;
     }
     else if (status == 0) /* ``service'' is uninteresting */
     {
-      ce = NULL;
       DEBUG ("uc_check_timeout: %s is missing but ``uninteresting''",
 	  keys[i]);
       status = c_avl_remove (cache_tree, keys[i],
@@ -298,21 +343,35 @@ int uc_check_timeout (void)
 	ERROR ("uc_check_timeout: c_avl_remove (%s) failed.", keys[i]);
       }
       sfree (keys[i]);
+      sfree (key);
       cache_free (ce);
     }
-    else if (status == 1) /* persist */
+
+    /* If we get here, the value is ``interesting''. Query the record from the
+     * cache and update the state field. */
+    if (c_avl_get (cache_tree, keys[i], (void *) &ce) != 0)
+    {
+      ERROR ("uc_check_timeout: cannot get data for %s from cache", keys[i]);
+      /* Do not free `keys[i]' so a notification is sent further down. */
+      continue;
+    }
+    assert (ce != NULL);
+
+    if (status == 2) /* persist */
     {
       DEBUG ("uc_check_timeout: %s is missing, sending notification.",
 	  keys[i]);
       ce->state = STATE_MISSING;
+      /* Do not free `keys[i]' so a notification is sent further down. */
     }
-    else if (status == 2) /* do not persist */
+    else if (status == 1) /* do not persist */
     {
       if (ce->state == STATE_MISSING)
       {
 	DEBUG ("uc_check_timeout: %s is missing but "
 	    "notification has already been sent.",
 	    keys[i]);
+	/* Set `keys[i]' to NULL to no notification is sent. */
 	sfree (keys[i]);
       }
       else /* (ce->state != STATE_MISSING) */
@@ -320,6 +379,7 @@ int uc_check_timeout (void)
 	DEBUG ("uc_check_timeout: %s is missing, sending one notification.",
 	    keys[i]);
 	ce->state = STATE_MISSING;
+	/* Do not free `keys[i]' so a notification is sent further down. */
       }
     }
     else
@@ -327,6 +387,7 @@ int uc_check_timeout (void)
       WARNING ("uc_check_timeout: ut_check_interesting (%s) returned "
 	  "invalid status %i.",
 	  keys[i], status);
+      sfree (keys[i]);
     }
   } /* for (keys[i]) */
 
@@ -397,36 +458,70 @@ int uc_update (const data_set_t *ds, const value_list_t *vl)
 
   for (i = 0; i < ds->ds_num; i++)
   {
-    if (ds->ds[i].type == DS_TYPE_COUNTER)
+    switch (ds->ds[i].type)
     {
-      counter_t diff;
+      case DS_TYPE_COUNTER:
+	{
+	  counter_t diff;
+
+	  /* check if the counter has wrapped around */
+	  if (vl->values[i].counter < ce->values_raw[i].counter)
+	  {
+	    if (ce->values_raw[i].counter <= 4294967295U)
+	      diff = (4294967295U - ce->values_raw[i].counter)
+		+ vl->values[i].counter;
+	    else
+	      diff = (18446744073709551615ULL - ce->values_raw[i].counter)
+		+ vl->values[i].counter;
+	  }
+	  else /* counter has NOT wrapped around */
+	  {
+	    diff = vl->values[i].counter - ce->values_raw[i].counter;
+	  }
+
+	  ce->values_gauge[i] = ((double) diff)
+	    / ((double) (vl->time - ce->last_time));
+	  ce->values_raw[i].counter = vl->values[i].counter;
+	}
+	break;
 
-      /* check if the counter has wrapped around */
-      if (vl->values[i].counter < ce->values_counter[i])
-      {
-	if (ce->values_counter[i] <= 4294967295U)
-	  diff = (4294967295U - ce->values_counter[i])
-	    + vl->values[i].counter;
-	else
-	  diff = (18446744073709551615ULL - ce->values_counter[i])
-	    + vl->values[i].counter;
-      }
-      else /* counter has NOT wrapped around */
-      {
-	diff = vl->values[i].counter - ce->values_counter[i];
-      }
+      case DS_TYPE_GAUGE:
+	ce->values_raw[i].gauge = vl->values[i].gauge;
+	ce->values_gauge[i] = vl->values[i].gauge;
+	break;
+
+      case DS_TYPE_DERIVE:
+	{
+	  derive_t diff;
+
+	  diff = vl->values[i].derive - ce->values_raw[i].derive;
+
+	  ce->values_gauge[i] = ((double) diff)
+	    / ((double) (vl->time - ce->last_time));
+	  ce->values_raw[i].derive = vl->values[i].derive;
+	}
+	break;
+
+      case DS_TYPE_ABSOLUTE:
+	ce->values_gauge[i] = ((double) vl->values[i].absolute)
+	  / ((double) (vl->time - ce->last_time));
+	ce->values_raw[i].absolute = vl->values[i].absolute;
+	break;
+
+      default:
+	/* This shouldn't happen. */
+	pthread_mutex_unlock (&cache_lock);
+	ERROR ("uc_update: Don't know how to handle data source type %i.",
+	    ds->ds[i].type);
+	return (-1);
+    } /* switch (ds->ds[i].type) */
 
-      ce->values_gauge[i] = ((double) diff)
-	/ ((double) (vl->time - ce->last_time));
-      ce->values_counter[i] = vl->values[i].counter;
-    }
-    else /* if (ds->ds[i].type == DS_TYPE_GAUGE) */
-    {
-      ce->values_gauge[i] = vl->values[i].gauge;
-    }
     DEBUG ("uc_update: %s: ds[%i] = %lf", name, i, ce->values_gauge[i]);
   } /* for (i) */
 
+  /* Prune invalid gauge data */
+  uc_check_range (ds, ce);
+
   ce->last_time = vl->time;
   ce->last_update = time (NULL);
   ce->interval = vl->interval;
@@ -509,7 +604,7 @@ gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl)
 
   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
   {
-    ERROR ("uc_insert: FORMAT_VL failed.");
+    ERROR ("utils_cache: uc_get_rate: FORMAT_VL failed.");
     return (NULL);
   }
 
@@ -519,10 +614,10 @@ gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl)
 
   /* This is important - the caller has no other way of knowing how many
    * values are returned. */
-  if (ret_num != ds->ds_num)
+  if (ret_num != (size_t) ds->ds_num)
   {
     ERROR ("utils_cache: uc_get_rate: ds[%s] has %i values, "
-	"but uc_get_rate_by_name returned %i.",
+	"but uc_get_rate_by_name returned %zu.",
 	ds->type, ds->ds_num, ret_num);
     sfree (ret);
     return (NULL);