src/redis.c

   1 /**
   2  * collectd - src/redis.c, based on src/memcached.c
   3  * Copyright (C) 2010       Andrés J. Díaz <ajdiaz@connectical.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Andrés J. Díaz <ajdiaz@connectical.com>
  21  **/
  22
  23 #include "collectd.h"
  24 #include "common.h"
  25 #include "plugin.h"
  26 #include "configfile.h"
  27 #include "utils_avltree.h"
  28
  29 #include <pthread.h>
  30 #include <credis.h>
  31
  32 #define REDIS_DEF_HOST "127.0.0.1"
  33 #define REDIS_DEF_PORT 6379
  34 #define MAX_REDIS_NODE_NAME 64
  35
  36 /* Redis plugin configuration example:
  37  *
  38  * <Plugin redis>
  39  *   <Node mynode>
  40  *     Host localhost
  41  *     Port 6379
  42  *     Timeout 2000
  43  *   </Node>
  44  * </Plugin>
  45  */
  46
  47 static c_avl_tree_t *redis_tree = NULL;
  48 static pthread_mutex_t redis_lock = PTHREAD_MUTEX_INITIALIZER;
  49
  50 typedef struct redis_node_s {
  51   char name[MAX_REDIS_NODE_NAME];
  52   char host[HOST_NAME_MAX];
  53   int port;
  54   int timeout;
  55 } redis_node_t;
  56
  57 static int redis_config_node (redis_node_t *rn, oconfig_item_t *ci) /* {{{ */
  58 {
  59   int i;
  60   int status = 0;
  61
  62   if ((ci->values_num != 1)
  63       || (ci->values[0].type != OCONFIG_TYPE_STRING))
  64   {
  65     WARNING ("redis plugin: The `Node' block needs exactly one string "
  66         "argument.");
  67     return (-1);
  68   }
  69
  70   if (ci->children_num < 1)
  71   {
  72     WARNING ("redis plugin: The `Node' block needs at least one option.");
  73     return (-1);
  74   }
  75
  76   sstrncpy (rn->name, ci->values[0].value.string, sizeof (rn->name));
  77
  78   for (i = 0; i < ci->children_num; i++)
  79   {
  80     oconfig_item_t *option = ci->children + i;
  81     status = 0;
  82
  83     if (strcasecmp ("Host", option->key) == 0)
  84       status = cf_util_get_string_buffer (option, rn->host, sizeof (rn->host));
  85     else if (strcasecmp ("Port", option->key) == 0)
  86       status = rn->port = cf_util_get_port_number (option);
  87     else if (strcasecmp ("Timeout", option->key) == 0)
  88       status = cf_util_get_int (option, &rn->timeout);
  89     else
  90     {
  91       WARNING ("redis plugin: Option `%s' not allowed inside a `Node' "
  92           "block.", option->key);
  93       status = -1;
  94     }
  95
  96     if (status != 0)
  97       break;
  98   }
  99
 100   return (status);
 101 } /* }}} */
 102
 103 static redis_node_t *redis_node_get (const char *name, redis_node_t *rn) /* {{{ */
 104 {
 105   if (c_avl_get (redis_tree, name, (void *) rn) == 0)
 106     return (rn);
 107   else
 108     return (NULL);
 109 } /* }}} */
 110
 111 static int redis_node_add (const redis_node_t *rn) /* {{{ */
 112 {
 113   int status;
 114   redis_node_t *rn_copy = NULL;
 115   redis_node_t *rn_ptr;
 116   redis_node_t  rn_get;
 117
 118   rn_copy = (redis_node_t *) malloc (sizeof (redis_node_t));
 119   if (rn_copy == NULL)
 120   {
 121     sfree (rn_copy);
 122     ERROR ("redis plugin: malloc failed adding redis_node to the tree.");
 123     return (-1);
 124   }
 125   memcpy (rn_copy, rn, sizeof (redis_node_t));
 126   if (*rn_copy->name == '\0')
 127   {
 128     (void) strncpy(rn_copy->name, "default", sizeof (rn_copy->name)); /* in theory never fails */
 129   }
 130
 131   DEBUG ("redis plugin: adding entry `%s' to the tree.", rn_copy->name);
 132
 133   pthread_mutex_lock (&redis_lock);
 134
 135   if ( (rn_ptr = redis_node_get (rn_copy->name, &rn_get)) != NULL )
 136   {
 137     WARNING ("redis plugin: the node `%s' override a previous node with same node.", rn_copy->name);
 138   }
 139
 140   status = c_avl_insert (redis_tree, rn_copy->name, rn_copy);
 141   pthread_mutex_unlock (&redis_lock);
 142
 143   if (status != 0)
 144   {
 145     ERROR ("redis plugin: c_avl_insert (%s) failed adding noew node.", rn_copy->name);
 146     sfree (rn_copy);
 147     return (-1);
 148   }
 149
 150   return (status);
 151 } /* }}} */
 152
 153 static int redis_config (oconfig_item_t *ci) /* {{{ */
 154 {
 155   int status;
 156   int i;
 157
 158   redis_node_t rn = {
 159     .name = "",
 160     .host = "",
 161     .port = REDIS_DEF_PORT,
 162     .timeout = 2000
 163   };
 164
 165   if (redis_tree == NULL)
 166   {
 167     redis_tree = c_avl_create ((void *) strcmp);
 168     if (redis_tree == NULL)
 169     {
 170       ERROR ("redis plugin: c_avl_create failed reading config.");
 171       return (-1);
 172     }
 173   }
 174
 175   status = 0;
 176   for (i = 0; i < ci->children_num; i++)
 177   {
 178     oconfig_item_t *option = ci->children + i;
 179
 180     if (strcasecmp ("Node", option->key) == 0)
 181     {
 182       if ( (status = redis_config_node (&rn, option)) == 0 )
 183         status = redis_node_add (&rn);
 184     }
 185     else if (strcasecmp ("Host", option->key) == 0)
 186       status = cf_util_get_string_buffer (option, rn.host, sizeof (rn.host));
 187     else if (strcasecmp ("Port", option->key) == 0)
 188       status = rn.port = cf_util_get_port_number (option);
 189     else if (strcasecmp ("Timeout", option->key) == 0)
 190       status = cf_util_get_int (option, &rn.timeout);
 191     else
 192     {
 193       WARNING ("redis plugin: Option `%s' not allowed in redis"
 194           " configuration.", option->key);
 195       status = -1;
 196     }
 197
 198
 199     if (status != 0)
 200       break;
 201   }
 202
 203   if ( status == 0 && *rn.name != '\0') {
 204     status = redis_node_add (&rn);
 205   }
 206
 207   return (status);
 208 } /* }}} */
 209
 210   __attribute__ ((nonnull(2)))
 211 static void redis_submit_g (char *plugin_instance,
 212     const char *type, const char *type_instance,
 213     gauge_t value) /* {{{ */
 214 {
 215   value_t values[1];
 216   value_list_t vl = VALUE_LIST_INIT;
 217
 218   values[0].gauge = value;
 219
 220   vl.values = values;
 221   vl.values_len = 1;
 222   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 223   sstrncpy (vl.plugin, "redis", sizeof (vl.plugin));
 224   if (plugin_instance != NULL)
 225     sstrncpy (vl.plugin_instance, plugin_instance,
 226         sizeof (vl.plugin_instance));
 227   sstrncpy (vl.type, type, sizeof (vl.type));
 228   if (type_instance != NULL)
 229     sstrncpy (vl.type_instance, type_instance,
 230         sizeof (vl.type_instance));
 231
 232   plugin_dispatch_values (&vl);
 233 } /* }}} */
 234
 235   __attribute__ ((nonnull(2)))
 236 static void redis_submit_c (char *plugin_instance,
 237     const char *type, const char *type_instance,
 238     counter_t value) /* {{{ */
 239 {
 240   value_t values[1];
 241   value_list_t vl = VALUE_LIST_INIT;
 242
 243   values[0].counter = value;
 244
 245   vl.values = values;
 246   vl.values_len = 1;
 247   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 248   sstrncpy (vl.plugin, "redis", sizeof (vl.plugin));
 249   if (plugin_instance != NULL)
 250     sstrncpy (vl.plugin_instance, plugin_instance,
 251         sizeof (vl.plugin_instance));
 252   sstrncpy (vl.type, type, sizeof (vl.type));
 253   if (type_instance != NULL)
 254     sstrncpy (vl.type_instance, type_instance,
 255         sizeof (vl.type_instance));
 256
 257   plugin_dispatch_values (&vl);
 258 } /* }}} */
 259
 260 static int redis_read (void) /* {{{ */
 261 {
 262   REDIS rh;
 263   REDIS_INFO info;
 264
 265   char key[64];
 266   int status;
 267   c_avl_iterator_t *iter;
 268   redis_node_t *rn;
 269
 270   status = -1;
 271   if ( (iter = c_avl_get_iterator (redis_tree)) == NULL )
 272   {
 273     ERROR ("redis plugin: unable to iterate redis tree.");
 274     return (-1);
 275   }
 276
 277   while (c_avl_iterator_next (iter, (void *) &key, (void *) &rn) == 0)
 278   {
 279     DEBUG ("redis plugin: querying info from node `%s'.", rn->name);
 280
 281     if ( (rh = credis_connect (rn->host, rn->port, rn->timeout)) == NULL )
 282     {
 283       ERROR ("redis plugin: unable to connect to node `%s' (%s:%d).", rn->name, rn->host, rn->port);
 284       status = -1;
 285       break;
 286     }
 287
 288     if ( (status = credis_info (rh, &info)) == -1 )
 289     {
 290       WARNING ("redis plugin: unable to get info from node `%s'.", rn->name);
 291       credis_close (rh);
 292       break;
 293     }
 294
 295     /* typedef struct _cr_info {
 296      *   char redis_version[CREDIS_VERSION_STRING_SIZE];
 297      *   int bgsave_in_progress;
 298      *   int connected_clients;
 299      *   int connected_slaves;
 300      *   unsigned int used_memory;
 301      *   long long changes_since_last_save;
 302      *   int last_save_time;
 303      *   long long total_connections_received;
 304      *   long long total_commands_processed;
 305      *   int uptime_in_seconds;
 306      *   int uptime_in_days;
 307      *   int role;
 308      * } REDIS_INFO; */
 309
 310     DEBUG ("redis plugin: received info from node `%s': connected_clients = %d; "
 311         "connected_slaves = %d; used_memory = %lu; changes_since_last_save = %lld; "
 312         "bgsave_in_progress = %d; total_connections_received = %lld; "
 313         "total_commands_processed = %lld; uptime_in_seconds = %ld", rn->name,
 314         info.connected_clients, info.connected_slaves, info.used_memory,
 315         info.changes_since_last_save, info.bgsave_in_progress,
 316         info.total_connections_received, info.total_commands_processed,
 317         info.uptime_in_seconds);
 318
 319     redis_submit_g (rn->name, "connected_clients", NULL, info.connected_clients);
 320     redis_submit_g (rn->name, "connected_slaves", NULL, info.connected_slaves);
 321     redis_submit_g (rn->name, "used_memory", NULL, info.used_memory);
 322     redis_submit_g (rn->name, "changes_since_last_save", NULL, info.changes_since_last_save);
 323     redis_submit_g (rn->name, "bgsave_in_progress", NULL, info.bgsave_in_progress);
 324     redis_submit_c (rn->name, "total_connections_received", NULL, info.total_connections_received);
 325     redis_submit_c (rn->name, "total_commands_processed", NULL, info.total_commands_processed);
 326     redis_submit_c (rn->name, "uptime_in_seconds", NULL, info.uptime_in_seconds);
 327
 328     credis_close (rh);
 329     status = 0;
 330   }
 331
 332   c_avl_iterator_destroy(iter);
 333   if ( status != 0 )
 334   {
 335     return (-1);
 336   }
 337
 338   return 0;
 339 }
 340 /* }}} */
 341
 342 void module_register (void) /* {{{ */
 343 {
 344   plugin_register_complex_config ("redis", redis_config);
 345   plugin_register_read ("redis", redis_read);
 346   /* TODO: plugin_register_write: one redis list per value id with
 347    * X elements */
 348 }
 349 /* }}} */
 350
 351 /* vim: set sw=2 sts=2 et fdm=marker : */