src/rrdtool.c

   1 /**
   2  * collectd - src/rrdtool.c
   3  * Copyright (C) 2006  Florian octo Forster
   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; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "plugin.h"
  24 #include "common.h"
  25 #include "utils_avltree.h"
  26
  27 /*
  28  * Private types
  29  */
  30 struct rrd_cache_s
  31 {
  32         int    values_num;
  33         char **values;
  34         time_t first_value;
  35 };
  36 typedef struct rrd_cache_s rrd_cache_t;
  37
  38 /*
  39  * Private variables
  40  */
  41 static int rra_timespans[] =
  42 {
  43         3600,
  44         86400,
  45         604800,
  46         2678400,
  47         31622400
  48 };
  49 static int rra_timespans_num = STATIC_ARRAY_SIZE (rra_timespans);
  50
  51 static char *rra_types[] =
  52 {
  53         "AVERAGE",
  54         "MIN",
  55         "MAX"
  56 };
  57 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
  58
  59 static const char *config_keys[] =
  60 {
  61         "CacheTimeout",
  62         "CacheFlush",
  63         "DataDir",
  64         "StepSize",
  65         "HeartBeat",
  66         "RRARows",
  67         "XFF"
  68 };
  69 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  70
  71 static char   *datadir   = NULL;
  72 static int     stepsize  = 0;
  73 static int     heartbeat = 0;
  74 static int     rrarows   = 1200;
  75 static double  xff       = 0.1;
  76
  77 static int         cache_timeout = 0;
  78 static int         cache_flush_timeout = 0;
  79 static time_t      cache_flush_last;
  80 static avl_tree_t *cache = NULL;
  81
  82 /* * * * * * * * * *
  83  * WARNING:  Magic *
  84  * * * * * * * * * */
  85 static int rra_get (char ***ret)
  86 {
  87         static char **rra_def = NULL;
  88         static int rra_num = 0;
  89
  90         int rra_max = rra_timespans_num * rra_types_num;
  91
  92         int span;
  93
  94         int cdp_num;
  95         int cdp_len;
  96         int i, j;
  97
  98         char buffer[64];
  99
 100         if ((rra_num != 0) && (rra_def != NULL))
 101         {
 102                 *ret = rra_def;
 103                 return (rra_num);
 104         }
 105
 106         if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
 107                 return (-1);
 108         memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
 109
 110         if ((stepsize <= 0) || (rrarows <= 0))
 111         {
 112                 *ret = NULL;
 113                 return (-1);
 114         }
 115
 116         cdp_len = 0;
 117         for (i = 0; i < rra_timespans_num; i++)
 118         {
 119                 span = rra_timespans[i];
 120
 121                 if ((span / stepsize) < rrarows)
 122                         continue;
 123
 124                 if (cdp_len == 0)
 125                         cdp_len = 1;
 126                 else
 127                         cdp_len = (int) floor (((double) span)
 128                                         / ((double) (rrarows * stepsize)));
 129
 130                 cdp_num = (int) ceil (((double) span)
 131                                 / ((double) (cdp_len * stepsize)));
 132
 133                 for (j = 0; j < rra_types_num; j++)
 134                 {
 135                         if (rra_num >= rra_max)
 136                                 break;
 137
 138                         if (snprintf (buffer, sizeof (buffer), "RRA:%s:%3.1f:%u:%u",
 139                                                 rra_types[j], xff,
 140                                                 cdp_len, cdp_num) >= sizeof (buffer))
 141                         {
 142                                 ERROR ("rra_get: Buffer would have been truncated.");
 143                                 continue;
 144                         }
 145
 146                         rra_def[rra_num++] = sstrdup (buffer);
 147                 }
 148         }
 149
 150 #if COLLECT_DEBUG
 151         DEBUG ("rra_num = %i", rra_num);
 152         for (i = 0; i < rra_num; i++)
 153                 DEBUG ("  %s", rra_def[i]);
 154 #endif
 155
 156         *ret = rra_def;
 157         return (rra_num);
 158 }
 159
 160 static void ds_free (int ds_num, char **ds_def)
 161 {
 162         int i;
 163
 164         for (i = 0; i < ds_num; i++)
 165                 if (ds_def[i] != NULL)
 166                         free (ds_def[i]);
 167         free (ds_def);
 168 }
 169
 170 static int ds_get (char ***ret, const data_set_t *ds)
 171 {
 172         char **ds_def;
 173         int ds_num;
 174
 175         char min[32];
 176         char max[32];
 177         char buffer[128];
 178
 179         DEBUG ("ds->ds_num = %i", ds->ds_num);
 180
 181         ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
 182         if (ds_def == NULL)
 183         {
 184                 ERROR ("rrdtool plugin: malloc failed: %s",
 185                                 strerror (errno));
 186                 return (-1);
 187         }
 188         memset (ds_def, '\0', ds->ds_num * sizeof (char *));
 189
 190         for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
 191         {
 192                 data_source_t *d = ds->ds + ds_num;
 193                 char *type;
 194                 int status;
 195
 196                 ds_def[ds_num] = NULL;
 197
 198                 if (d->type == DS_TYPE_COUNTER)
 199                         type = "COUNTER";
 200                 else if (d->type == DS_TYPE_GAUGE)
 201                         type = "GAUGE";
 202                 else
 203                 {
 204                         ERROR ("rrdtool plugin: Unknown DS type: %i",
 205                                         d->type);
 206                         break;
 207                 }
 208
 209                 if (isnan (d->min))
 210                 {
 211                         strcpy (min, "U");
 212                 }
 213                 else
 214                 {
 215                         snprintf (min, sizeof (min), "%lf", d->min);
 216                         min[sizeof (min) - 1] = '\0';
 217                 }
 218
 219                 if (isnan (d->max))
 220                 {
 221                         strcpy (max, "U");
 222                 }
 223                 else
 224                 {
 225                         snprintf (max, sizeof (max), "%lf", d->max);
 226                         max[sizeof (max) - 1] = '\0';
 227                 }
 228
 229                 status = snprintf (buffer, sizeof (buffer),
 230                                 "DS:%s:%s:%i:%s:%s",
 231                                 d->name, type, heartbeat,
 232                                 min, max);
 233                 if ((status < 1) || (status >= sizeof (buffer)))
 234                         break;
 235
 236                 ds_def[ds_num] = sstrdup (buffer);
 237         } /* for ds_num = 0 .. ds->ds_num */
 238
 239 #if COLLECT_DEBUG
 240 {
 241         int i;
 242         DEBUG ("ds_num = %i", ds_num);
 243         for (i = 0; i < ds_num; i++)
 244                 DEBUG ("  %s", ds_def[i]);
 245 }
 246 #endif
 247
 248         if (ds_num != ds->ds_num)
 249         {
 250                 ds_free (ds_num, ds_def);
 251                 return (-1);
 252         }
 253
 254         *ret = ds_def;
 255         return (ds_num);
 256 }
 257
 258 static int rrd_create_file (char *filename, const data_set_t *ds)
 259 {
 260         char **argv;
 261         int argc;
 262         char **rra_def;
 263         int rra_num;
 264         char **ds_def;
 265         int ds_num;
 266         int i, j;
 267         char stepsize_str[16];
 268         int status = 0;
 269
 270         if (check_create_dir (filename))
 271                 return (-1);
 272
 273         if ((rra_num = rra_get (&rra_def)) < 1)
 274         {
 275                 ERROR ("rrd_create_file failed: Could not calculate RRAs");
 276                 return (-1);
 277         }
 278
 279         if ((ds_num = ds_get (&ds_def, ds)) < 1)
 280         {
 281                 ERROR ("rrd_create_file failed: Could not calculate DSes");
 282                 return (-1);
 283         }
 284
 285         argc = ds_num + rra_num + 4;
 286
 287         if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 288         {
 289                 ERROR ("rrd_create failed: %s", strerror (errno));
 290                 return (-1);
 291         }
 292
 293         status = snprintf (stepsize_str, sizeof (stepsize_str),
 294                         "%i", stepsize);
 295         if ((status < 1) || (status >= sizeof (stepsize_str)))
 296         {
 297                 ERROR ("rrdtool plugin: snprintf failed.");
 298                 return (-1);
 299         }
 300
 301         argv[0] = "create";
 302         argv[1] = filename;
 303         argv[2] = "-s";
 304         argv[3] = stepsize_str;
 305
 306         j = 4;
 307         for (i = 0; i < ds_num; i++)
 308                 argv[j++] = ds_def[i];
 309         for (i = 0; i < rra_num; i++)
 310                 argv[j++] = rra_def[i];
 311         argv[j] = NULL;
 312
 313         optind = 0; /* bug in librrd? */
 314         rrd_clear_error ();
 315         if (rrd_create (argc, argv) == -1)
 316         {
 317                 ERROR ("rrd_create failed: %s: %s", filename, rrd_get_error ());
 318                 status = -1;
 319         }
 320
 321         free (argv);
 322         ds_free (ds_num, ds_def);
 323
 324         return (status);
 325 }
 326
 327 static int value_list_to_string (char *buffer, int buffer_len,
 328                 const data_set_t *ds, const value_list_t *vl)
 329 {
 330         int offset;
 331         int status;
 332         int i;
 333
 334         memset (buffer, '\0', sizeof (buffer_len));
 335
 336         status = snprintf (buffer, buffer_len, "%u", (unsigned int) vl->time);
 337         if ((status < 1) || (status >= buffer_len))
 338                 return (-1);
 339         offset = status;
 340
 341         for (i = 0; i < ds->ds_num; i++)
 342         {
 343                 if ((ds->ds[i].type != DS_TYPE_COUNTER)
 344                                 && (ds->ds[i].type != DS_TYPE_GAUGE))
 345                         return (-1);
 346
 347                 if (ds->ds[i].type == DS_TYPE_COUNTER)
 348                         status = snprintf (buffer + offset, buffer_len - offset,
 349                                         ":%llu", vl->values[i].counter);
 350                 else
 351                         status = snprintf (buffer + offset, buffer_len - offset,
 352                                         ":%lf", vl->values[i].gauge);
 353
 354                 if ((status < 1) || (status >= (buffer_len - offset)))
 355                         return (-1);
 356
 357                 offset += status;
 358         } /* for ds->ds_num */
 359
 360         return (0);
 361 } /* int value_list_to_string */
 362
 363 static int value_list_to_filename (char *buffer, int buffer_len,
 364                 const data_set_t *ds, const value_list_t *vl)
 365 {
 366         int offset = 0;
 367         int status;
 368
 369         if (datadir != NULL)
 370         {
 371                 status = snprintf (buffer + offset, buffer_len - offset,
 372                                 "%s/", datadir);
 373                 if ((status < 1) || (status >= buffer_len - offset))
 374                         return (-1);
 375                 offset += status;
 376         }
 377
 378         status = snprintf (buffer + offset, buffer_len - offset,
 379                         "%s/", vl->host);
 380         if ((status < 1) || (status >= buffer_len - offset))
 381                 return (-1);
 382         offset += status;
 383
 384         if (strlen (vl->plugin_instance) > 0)
 385                 status = snprintf (buffer + offset, buffer_len - offset,
 386                                 "%s-%s/", vl->plugin, vl->plugin_instance);
 387         else
 388                 status = snprintf (buffer + offset, buffer_len - offset,
 389                                 "%s/", vl->plugin);
 390         if ((status < 1) || (status >= buffer_len - offset))
 391                 return (-1);
 392         offset += status;
 393
 394         if (strlen (vl->type_instance) > 0)
 395                 status = snprintf (buffer + offset, buffer_len - offset,
 396                                 "%s-%s.rrd", ds->type, vl->type_instance);
 397         else
 398                 status = snprintf (buffer + offset, buffer_len - offset,
 399                                 "%s.rrd", ds->type);
 400         if ((status < 1) || (status >= buffer_len - offset))
 401                 return (-1);
 402         offset += status;
 403
 404         return (0);
 405 } /* int value_list_to_filename */
 406
 407 static rrd_cache_t *rrd_cache_insert (const char *filename,
 408                 const char *value)
 409 {
 410         rrd_cache_t *rc = NULL;
 411         int new_rc = 0;
 412
 413         if (cache != NULL)
 414                 avl_get (cache, filename, (void *) &rc);
 415
 416         if (rc == NULL)
 417         {
 418                 rc = (rrd_cache_t *) malloc (sizeof (rrd_cache_t));
 419                 if (rc == NULL)
 420                         return (NULL);
 421                 rc->values_num = 0;
 422                 rc->values = NULL;
 423                 rc->first_value = 0;
 424                 new_rc = 1;
 425         }
 426
 427         rc->values = (char **) realloc ((void *) rc->values,
 428                         (rc->values_num + 1) * sizeof (char *));
 429         if (rc->values == NULL)
 430         {
 431                 ERROR ("rrdtool plugin: realloc failed: %s",
 432                                 strerror (errno));
 433                 if (cache != NULL)
 434                 {
 435                         void *cache_key = NULL;
 436                         avl_remove (cache, filename, &cache_key, NULL);
 437                         sfree (cache_key);
 438                 }
 439                 free (rc);
 440                 return (NULL);
 441         }
 442
 443         rc->values[rc->values_num] = strdup (value);
 444         if (rc->values[rc->values_num] != NULL)
 445                 rc->values_num++;
 446
 447         if (rc->values_num == 1)
 448                 rc->first_value = time (NULL);
 449
 450         /* Insert if this is the first value */
 451         if ((cache != NULL) && (new_rc == 1))
 452         {
 453                 void *cache_key = strdup (filename);
 454
 455                 if (cache_key == NULL)
 456                 {
 457                         ERROR ("rrdtool plugin: strdup failed: %s",
 458                                         strerror (errno));
 459                         sfree (rc->values[0]);
 460                         sfree (rc->values);
 461                         sfree (rc);
 462                         return (NULL);
 463                 }
 464
 465                 avl_insert (cache, cache_key, rc);
 466         }
 467
 468         DEBUG ("rrd_cache_insert (%s, %s) = %p", filename, value, (void *) rc);
 469
 470         return (rc);
 471 } /* rrd_cache_t *rrd_cache_insert */
 472
 473 static int rrd_write_cache_entry (const char *filename, rrd_cache_t *rc)
 474 {
 475         char **argv;
 476         int    argc;
 477
 478         char *fn;
 479         int status;
 480
 481         int i;
 482
 483         argc = rc->values_num + 2;
 484         argv = (char **) malloc ((argc + 1) * sizeof (char *));
 485         if (argv == NULL)
 486                 return (-1);
 487
 488         fn = strdup (filename);
 489         if (fn == NULL)
 490         {
 491                 free (argv);
 492                 return (-1);
 493         }
 494
 495         argv[0] = "update";
 496         argv[1] = fn;
 497         memcpy (argv + 2, rc->values, rc->values_num * sizeof (char *));
 498         argv[argc] = NULL;
 499
 500         DEBUG ("rrd_update (argc = %i, argv = %p)", argc, (void *) argv);
 501
 502         optind = 0; /* bug in librrd? */
 503         rrd_clear_error ();
 504         status = rrd_update (argc, argv);
 505
 506         free (argv);
 507         free (fn);
 508
 509         /* Free the value list of `rc' */
 510         for (i = 0; i < rc->values_num; i++)
 511                 free (rc->values[i]);
 512         free (rc->values);
 513         rc->values = NULL;
 514         rc->values_num = 0;
 515
 516         if (status != 0)
 517         {
 518                 WARNING ("rrd_update failed: %s: %s",
 519                                 filename, rrd_get_error ());
 520                 return (-1);
 521         }
 522
 523         return (0);
 524 } /* int rrd_write_cache_entry */
 525
 526 static void rrd_cache_flush (int timeout)
 527 {
 528         rrd_cache_t *rc;
 529         time_t       now;
 530
 531         char **keys = NULL;
 532         int    keys_num = 0;
 533
 534         char *key;
 535         avl_iterator_t *iter;
 536         int i;
 537
 538         if (cache == NULL)
 539                 return;
 540
 541         DEBUG ("Flushing cache, timeout = %i", timeout);
 542
 543         now = time (NULL);
 544
 545         /* Build a list of entries to be flushed */
 546         iter = avl_get_iterator (cache);
 547         while (avl_iterator_next (iter, (void *) &key, (void *) &rc) == 0)
 548         {
 549                 DEBUG ("key = %s; age = %i;", key, now - rc->first_value);
 550                 if ((now - rc->first_value) >= timeout)
 551                 {
 552                         keys = (char **) realloc ((void *) keys,
 553                                         (keys_num + 1) * sizeof (char *));
 554                         if (keys == NULL)
 555                         {
 556                                 DEBUG ("realloc failed: %s", strerror (errno));
 557                                 ERROR ("rrdtool plugin: "
 558                                                 "realloc failed: %s",
 559                                                 strerror (errno));
 560                                 avl_iterator_destroy (iter);
 561                                 return;
 562                         }
 563                         keys[keys_num] = key;
 564                         keys_num++;
 565                 }
 566         } /* while (avl_iterator_next) */
 567         avl_iterator_destroy (iter);
 568
 569         for (i = 0; i < keys_num; i++)
 570         {
 571                 if (avl_remove (cache, keys[i], (void *) &key, (void *) &rc) != 0)
 572                 {
 573                         DEBUG ("avl_remove (%s) failed.", keys[i]);
 574                         continue;
 575                 }
 576
 577                 rrd_write_cache_entry (keys[i], rc);
 578                 /* rc's value-list is free's by `rrd_write_cache_entry' */
 579                 sfree (rc);
 580                 sfree (key);
 581                 keys[i] = NULL;
 582         } /* for (i = 0..keys_num) */
 583
 584         free (keys);
 585         DEBUG ("Flushed %i value(s)", keys_num);
 586
 587         cache_flush_last = now;
 588 } /* void rrd_cache_flush */
 589
 590 static int rrd_write (const data_set_t *ds, const value_list_t *vl)
 591 {
 592         struct stat  statbuf;
 593         char         filename[512];
 594         char         values[512];
 595         rrd_cache_t *rc;
 596         time_t       now;
 597
 598         if (value_list_to_filename (filename, sizeof (filename), ds, vl) != 0)
 599                 return (-1);
 600
 601         if (value_list_to_string (values, sizeof (values), ds, vl) != 0)
 602                 return (-1);
 603
 604         if (stat (filename, &statbuf) == -1)
 605         {
 606                 if (errno == ENOENT)
 607                 {
 608                         if (rrd_create_file (filename, ds))
 609                                 return (-1);
 610                 }
 611                 else
 612                 {
 613                         ERROR ("stat(%s) failed: %s",
 614                                         filename, strerror (errno));
 615                         return (-1);
 616                 }
 617         }
 618         else if (!S_ISREG (statbuf.st_mode))
 619         {
 620                 ERROR ("stat(%s): Not a regular file!",
 621                                 filename);
 622                 return (-1);
 623         }
 624
 625         rc = rrd_cache_insert (filename, values);
 626         if (rc == NULL)
 627                 return (-1);
 628
 629         if (cache == NULL)
 630         {
 631                 rrd_write_cache_entry (filename, rc);
 632                 /* rc's value-list is free's by `rrd_write_cache_entry' */
 633                 sfree (rc);
 634                 return (0);
 635         }
 636
 637         now = time (NULL);
 638
 639         DEBUG ("age (%s) = %i", filename, now - rc->first_value);
 640
 641         /* `rc' is not free'd here, because we'll likely reuse it. If not, then
 642          * the next flush will remove this entry.  */
 643         if ((now - rc->first_value) >= cache_timeout)
 644                 rrd_write_cache_entry (filename, rc);
 645
 646         if ((now - cache_flush_last) >= cache_flush_timeout)
 647                 rrd_cache_flush (cache_flush_timeout);
 648
 649         return (0);
 650 } /* int rrd_write */
 651
 652 static int rrd_config (const char *key, const char *value)
 653 {
 654         if (strcasecmp ("CacheTimeout", key) == 0)
 655         {
 656                 int tmp = atoi (value);
 657                 if (tmp < 0)
 658                 {
 659                         fprintf (stderr, "rrdtool: `CacheTimeout' must "
 660                                         "be greater than 0.\n");
 661                         return (1);
 662                 }
 663                 cache_timeout = tmp;
 664         }
 665         else if (strcasecmp ("CacheFlush", key) == 0)
 666         {
 667                 int tmp = atoi (value);
 668                 if (tmp < 0)
 669                 {
 670                         fprintf (stderr, "rrdtool: `CacheFlush' must "
 671                                         "be greater than 0.\n");
 672                         return (1);
 673                 }
 674                 cache_flush_timeout = tmp;
 675         }
 676         else if (strcasecmp ("DataDir", key) == 0)
 677         {
 678                 if (datadir != NULL)
 679                         free (datadir);
 680                 datadir = strdup (value);
 681                 if (datadir != NULL)
 682                 {
 683                         int len = strlen (datadir);
 684                         while ((len > 0) && (datadir[len - 1] == '/'))
 685                         {
 686                                 len--;
 687                                 datadir[len] = '\0';
 688                         }
 689                         if (len <= 0)
 690                         {
 691                                 free (datadir);
 692                                 datadir = NULL;
 693                         }
 694                 }
 695         }
 696         else if (strcasecmp ("StepSize", key) == 0)
 697         {
 698                 int tmp = atoi (value);
 699                 if (tmp <= 0)
 700                 {
 701                         fprintf (stderr, "rrdtool: `StepSize' must "
 702                                         "be greater than 0.\n");
 703                         return (1);
 704                 }
 705                 stepsize = tmp;
 706         }
 707         else if (strcasecmp ("HeartBeat", key) == 0)
 708         {
 709                 int tmp = atoi (value);
 710                 if (tmp <= 0)
 711                 {
 712                         fprintf (stderr, "rrdtool: `HeartBeat' must "
 713                                         "be greater than 0.\n");
 714                         return (1);
 715                 }
 716                 heartbeat = tmp;
 717         }
 718         else if (strcasecmp ("RRARows", key) == 0)
 719         {
 720                 int tmp = atoi (value);
 721                 if (tmp <= 0)
 722                 {
 723                         fprintf (stderr, "rrdtool: `RRARows' must "
 724                                         "be greater than 0.\n");
 725                         return (1);
 726                 }
 727                 rrarows = tmp;
 728         }
 729         else if (strcasecmp ("XFF", key) == 0)
 730         {
 731                 double tmp = atof (value);
 732                 if ((tmp < 0.0) || (tmp >= 1.0))
 733                 {
 734                         fprintf (stderr, "rrdtool: `XFF' must "
 735                                         "be in the range 0 to 1 (exclusive).");
 736                         return (1);
 737                 }
 738                 xff = tmp;
 739         }
 740         else
 741         {
 742                 return (-1);
 743         }
 744         return (0);
 745 } /* int rrd_config */
 746
 747 static int rrd_shutdown (void)
 748 {
 749         rrd_cache_flush (-1);
 750         if (cache != NULL)
 751                 avl_destroy (cache);
 752         cache = NULL;
 753
 754         return (0);
 755 } /* int rrd_shutdown */
 756
 757 static int rrd_init (void)
 758 {
 759         if (stepsize <= 0)
 760                 stepsize = interval_g;
 761         if (heartbeat <= 0)
 762                 heartbeat = 2 * interval_g;
 763
 764         if (heartbeat < interval_g)
 765                 WARNING ("rrdtool plugin: Your `heartbeat' is "
 766                                 "smaller than your `interval'. This will "
 767                                 "likely cause problems.");
 768         else if (stepsize < interval_g)
 769                 WARNING ("rrdtool plugin: Your `stepsize' is "
 770                                 "smaller than your `interval'. This will "
 771                                 "create needlessly big RRD-files.");
 772
 773         if (cache_timeout < 2)
 774         {
 775                 cache_timeout = 0;
 776                 cache_flush_timeout = 0;
 777         }
 778         else
 779         {
 780                 if (cache_flush_timeout < cache_timeout)
 781                         cache_flush_timeout = 10 * cache_timeout;
 782
 783                 cache = avl_create ((int (*) (const void *, const void *)) strcmp);
 784                 cache_flush_last = time (NULL);
 785                 plugin_register_shutdown ("rrdtool", rrd_shutdown);
 786         }
 787
 788         DEBUG ("datadir = %s; stepsize = %i; heartbeat = %i; rrarows = %i; xff = %lf;",
 789                         (datadir == NULL) ? "(null)" : datadir,
 790                         stepsize, heartbeat, rrarows, xff);
 791
 792         return (0);
 793 } /* int rrd_init */
 794
 795 void module_register (void)
 796 {
 797         plugin_register_config ("rrdtool", rrd_config,
 798                         config_keys, config_keys_num);
 799         plugin_register_init ("rrdtool", rrd_init);
 800         plugin_register_write ("rrdtool", rrd_write);
 801 }