src/target_v5upgrade.c

   1 /**
   2  * collectd - src/target_v5upgrade.c
   3  * Copyright (C) 2008-2010  Florian Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian Forster <octo at collectd.org>
  25  **/
  26
  27 #include "collectd.h"
  28
  29 #include "filter_chain.h"
  30 #include "plugin.h"
  31 #include "utils/common/common.h"
  32
  33 static void v5_swap_instances(value_list_t *vl) /* {{{ */
  34 {
  35   char tmp[DATA_MAX_NAME_LEN];
  36
  37   assert(sizeof(tmp) == sizeof(vl->plugin_instance));
  38   assert(sizeof(tmp) == sizeof(vl->type_instance));
  39
  40   memcpy(tmp, vl->plugin_instance, sizeof(tmp));
  41   memcpy(vl->plugin_instance, vl->type_instance, sizeof(tmp));
  42   memcpy(vl->type_instance, tmp, sizeof(tmp));
  43 } /* }}} void v5_swap_instances */
  44
  45 /*
  46  * Df type
  47  *
  48  * By default, the "df" plugin of version 4.* uses the "df" type and puts the
  49  * mount point in the type instance. Detect this behavior and convert the type
  50  * to "df_complex". This can be selected in versions 4.9 and 4.10 by setting
  51  * the "ReportReserved" option of the "df" plugin.
  52  */
  53 static int v5_df(const data_set_t *ds, value_list_t *vl) /* {{{ */
  54 {
  55   value_list_t new_vl;
  56
  57   /* Can't upgrade if both instances have been set. */
  58   if ((vl->plugin_instance[0] != 0) && (vl->type_instance[0] != 0))
  59     return FC_TARGET_CONTINUE;
  60
  61   /* Copy everything: Time, interval, host, ... */
  62   memcpy(&new_vl, vl, sizeof(new_vl));
  63
  64   /* Reset data we can't simply copy */
  65   new_vl.values = &(value_t){.gauge = NAN};
  66   new_vl.values_len = 1;
  67   new_vl.meta = NULL;
  68
  69   /* Move the mount point name to the plugin instance */
  70   if (new_vl.plugin_instance[0] == 0)
  71     v5_swap_instances(&new_vl);
  72
  73   /* Change the type to "df_complex" */
  74   sstrncpy(new_vl.type, "df_complex", sizeof(new_vl.type));
  75
  76   /* Dispatch two new value lists instead of this one */
  77   new_vl.values[0].gauge = vl->values[0].gauge;
  78   sstrncpy(new_vl.type_instance, "used", sizeof(new_vl.type_instance));
  79   plugin_dispatch_values(&new_vl);
  80
  81   new_vl.values[0].gauge = vl->values[1].gauge;
  82   sstrncpy(new_vl.type_instance, "free", sizeof(new_vl.type_instance));
  83   plugin_dispatch_values(&new_vl);
  84
  85   /* Abort processing */
  86   return FC_TARGET_STOP;
  87 } /* }}} int v5_df */
  88
  89 /*
  90  * Interface plugin
  91  *
  92  * 4.* stores the interface in the type instance and leaves the plugin
  93  * instance empty. If this is the case, put the interface name into the plugin
  94  * instance and clear the type instance.
  95  */
  96 static int v5_interface(const data_set_t *ds, value_list_t *vl) /* {{{ */
  97 {
  98   if ((vl->plugin_instance[0] != 0) || (vl->type_instance[0] == 0))
  99     return FC_TARGET_CONTINUE;
 100
 101   v5_swap_instances(vl);
 102   return FC_TARGET_CONTINUE;
 103 } /* }}} int v5_interface */
 104
 105 /*
 106  * MySQL query cache
 107  *
 108  * 4.* uses the "mysql_qcache" type which mixes different types of
 109  * information. In 5.* this has been broken up.
 110  */
 111 static int v5_mysql_qcache(const data_set_t *ds, value_list_t *vl) /* {{{ */
 112 {
 113   value_list_t new_vl;
 114
 115   if (vl->values_len != 5)
 116     return FC_TARGET_STOP;
 117
 118   /* Copy everything: Time, interval, host, ... */
 119   memcpy(&new_vl, vl, sizeof(new_vl));
 120
 121   /* Reset data we can't simply copy */
 122   new_vl.values = &(value_t){.gauge = NAN};
 123   new_vl.values_len = 1;
 124   new_vl.meta = NULL;
 125
 126   /* Change the type to "cache_result" */
 127   sstrncpy(new_vl.type, "cache_result", sizeof(new_vl.type));
 128
 129   /* Dispatch new value lists instead of this one */
 130   new_vl.values[0].derive = (derive_t)vl->values[0].counter;
 131   sstrncpy(new_vl.type_instance, "qcache-hits", sizeof(new_vl.type_instance));
 132   plugin_dispatch_values(&new_vl);
 133
 134   new_vl.values[0].derive = (derive_t)vl->values[1].counter;
 135   sstrncpy(new_vl.type_instance, "qcache-inserts",
 136            sizeof(new_vl.type_instance));
 137   plugin_dispatch_values(&new_vl);
 138
 139   new_vl.values[0].derive = (derive_t)vl->values[2].counter;
 140   sstrncpy(new_vl.type_instance, "qcache-not_cached",
 141            sizeof(new_vl.type_instance));
 142   plugin_dispatch_values(&new_vl);
 143
 144   new_vl.values[0].derive = (derive_t)vl->values[3].counter;
 145   sstrncpy(new_vl.type_instance, "qcache-prunes", sizeof(new_vl.type_instance));
 146   plugin_dispatch_values(&new_vl);
 147
 148   /* The last data source is a gauge value, so we have to use a different type
 149    * here. */
 150   new_vl.values[0].gauge = vl->values[4].gauge;
 151   sstrncpy(new_vl.type, "cache_size", sizeof(new_vl.type));
 152   sstrncpy(new_vl.type_instance, "qcache", sizeof(new_vl.type_instance));
 153   plugin_dispatch_values(&new_vl);
 154
 155   /* Abort processing */
 156   return FC_TARGET_STOP;
 157 } /* }}} int v5_mysql_qcache */
 158
 159 /*
 160  * MySQL thread count
 161  *
 162  * 4.* uses the "mysql_threads" type which mixes different types of
 163  * information. In 5.* this has been broken up.
 164  */
 165 static int v5_mysql_threads(const data_set_t *ds, value_list_t *vl) /* {{{ */
 166 {
 167   value_list_t new_vl;
 168
 169   if (vl->values_len != 4)
 170     return FC_TARGET_STOP;
 171
 172   /* Copy everything: Time, interval, host, ... */
 173   memcpy(&new_vl, vl, sizeof(new_vl));
 174
 175   /* Reset data we can't simply copy */
 176   new_vl.values = &(value_t){.gauge = NAN};
 177   new_vl.values_len = 1;
 178   new_vl.meta = NULL;
 179
 180   /* Change the type to "threads" */
 181   sstrncpy(new_vl.type, "threads", sizeof(new_vl.type));
 182
 183   /* Dispatch new value lists instead of this one */
 184   new_vl.values[0].gauge = vl->values[0].gauge;
 185   sstrncpy(new_vl.type_instance, "running", sizeof(new_vl.type_instance));
 186   plugin_dispatch_values(&new_vl);
 187
 188   new_vl.values[0].gauge = vl->values[1].gauge;
 189   sstrncpy(new_vl.type_instance, "connected", sizeof(new_vl.type_instance));
 190   plugin_dispatch_values(&new_vl);
 191
 192   new_vl.values[0].gauge = vl->values[2].gauge;
 193   sstrncpy(new_vl.type_instance, "cached", sizeof(new_vl.type_instance));
 194   plugin_dispatch_values(&new_vl);
 195
 196   /* The last data source is a counter value, so we have to use a different
 197    * type here. */
 198   new_vl.values[0].derive = (derive_t)vl->values[3].counter;
 199   sstrncpy(new_vl.type, "total_threads", sizeof(new_vl.type));
 200   sstrncpy(new_vl.type_instance, "created", sizeof(new_vl.type_instance));
 201   plugin_dispatch_values(&new_vl);
 202
 203   /* Abort processing */
 204   return FC_TARGET_STOP;
 205 } /* }}} int v5_mysql_threads */
 206
 207 /*
 208  * ZFS ARC hit and miss counters
 209  *
 210  * 4.* uses the flawed "arc_counts" type. In 5.* this has been replaced by the
 211  * more generic "cache_result" type.
 212  */
 213 static int v5_zfs_arc_counts(const data_set_t *ds, value_list_t *vl) /* {{{ */
 214 {
 215   value_list_t new_vl;
 216   bool is_hits;
 217
 218   if (vl->values_len != 4)
 219     return FC_TARGET_STOP;
 220
 221   if (strcmp("hits", vl->type_instance) == 0)
 222     is_hits = true;
 223   else if (strcmp("misses", vl->type_instance) == 0)
 224     is_hits = false;
 225   else
 226     return FC_TARGET_STOP;
 227
 228   /* Copy everything: Time, interval, host, ... */
 229   memcpy(&new_vl, vl, sizeof(new_vl));
 230
 231   /* Reset data we can't simply copy */
 232   new_vl.values = &(value_t){.gauge = NAN};
 233   new_vl.values_len = 1;
 234   new_vl.meta = NULL;
 235
 236   /* Change the type to "cache_result" */
 237   sstrncpy(new_vl.type, "cache_result", sizeof(new_vl.type));
 238
 239   /* Dispatch new value lists instead of this one */
 240   new_vl.values[0].derive = (derive_t)vl->values[0].counter;
 241   snprintf(new_vl.type_instance, sizeof(new_vl.type_instance), "demand_data-%s",
 242            is_hits ? "hit" : "miss");
 243   plugin_dispatch_values(&new_vl);
 244
 245   new_vl.values[0].derive = (derive_t)vl->values[1].counter;
 246   snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
 247            "demand_metadata-%s", is_hits ? "hit" : "miss");
 248   plugin_dispatch_values(&new_vl);
 249
 250   new_vl.values[0].derive = (derive_t)vl->values[2].counter;
 251   snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
 252            "prefetch_data-%s", is_hits ? "hit" : "miss");
 253   plugin_dispatch_values(&new_vl);
 254
 255   new_vl.values[0].derive = (derive_t)vl->values[3].counter;
 256   snprintf(new_vl.type_instance, sizeof(new_vl.type_instance),
 257            "prefetch_metadata-%s", is_hits ? "hit" : "miss");
 258   plugin_dispatch_values(&new_vl);
 259
 260   /* Abort processing */
 261   return FC_TARGET_STOP;
 262 } /* }}} int v5_zfs_arc_counts */
 263
 264 /*
 265  * ZFS ARC L2 bytes
 266  *
 267  * "arc_l2_bytes" -> "io_octets-L2".
 268  */
 269 static int v5_zfs_arc_l2_bytes(const data_set_t *ds, value_list_t *vl) /* {{{ */
 270 {
 271   value_list_t new_vl;
 272
 273   if (vl->values_len != 2)
 274     return FC_TARGET_STOP;
 275
 276   /* Copy everything: Time, interval, host, ... */
 277   memcpy(&new_vl, vl, sizeof(new_vl));
 278
 279   /* Reset data we can't simply copy */
 280   new_vl.meta = NULL;
 281
 282   /* Change the type/-instance to "io_octets-L2" */
 283   sstrncpy(new_vl.type, "io_octets", sizeof(new_vl.type));
 284   sstrncpy(new_vl.type_instance, "L2", sizeof(new_vl.type_instance));
 285
 286   /* Copy the actual values. */
 287   value_t values[] = {
 288       {.derive = (derive_t)vl->values[0].counter},
 289       {.derive = (derive_t)vl->values[1].counter},
 290   };
 291   new_vl.values = values;
 292   new_vl.values_len = STATIC_ARRAY_SIZE(values);
 293
 294   /* Dispatch new value lists instead of this one */
 295   plugin_dispatch_values(&new_vl);
 296
 297   /* Abort processing */
 298   return FC_TARGET_STOP;
 299 } /* }}} int v5_zfs_arc_l2_bytes */
 300
 301 /*
 302  * ZFS ARC L2 cache size
 303  *
 304  * 4.* uses a separate type for this. 5.* uses the generic "cache_size" type
 305  * instead.
 306  */
 307 static int v5_zfs_arc_l2_size(const data_set_t *ds, value_list_t *vl) /* {{{ */
 308 {
 309   value_list_t new_vl;
 310
 311   if (vl->values_len != 1)
 312     return FC_TARGET_STOP;
 313
 314   /* Copy everything: Time, interval, host, ... */
 315   memcpy(&new_vl, vl, sizeof(new_vl));
 316
 317   /* Reset data we can't simply copy */
 318   new_vl.values = &(value_t){.gauge = NAN};
 319   new_vl.values_len = 1;
 320   new_vl.meta = NULL;
 321
 322   new_vl.values[0].gauge = (gauge_t)vl->values[0].gauge;
 323
 324   /* Change the type to "cache_size" */
 325   sstrncpy(new_vl.type, "cache_size", sizeof(new_vl.type));
 326
 327   /* Adapt the type instance */
 328   sstrncpy(new_vl.type_instance, "L2", sizeof(new_vl.type_instance));
 329
 330   /* Dispatch new value lists instead of this one */
 331   plugin_dispatch_values(&new_vl);
 332
 333   /* Abort processing */
 334   return FC_TARGET_STOP;
 335 } /* }}} int v5_zfs_arc_l2_size */
 336
 337 /*
 338  * ZFS ARC ratio
 339  *
 340  * "arc_ratio-L1" -> "cache_ratio-arc"
 341  * "arc_ratio-L2" -> "cache_ratio-L2"
 342  */
 343 static int v5_zfs_arc_ratio(const data_set_t *ds, value_list_t *vl) /* {{{ */
 344 {
 345   value_list_t new_vl;
 346
 347   if (vl->values_len != 1)
 348     return FC_TARGET_STOP;
 349
 350   /* Copy everything: Time, interval, host, ... */
 351   memcpy(&new_vl, vl, sizeof(new_vl));
 352
 353   /* Reset data we can't simply copy */
 354   new_vl.values = &(value_t){.gauge = NAN};
 355   new_vl.values_len = 1;
 356   new_vl.meta = NULL;
 357
 358   new_vl.values[0].gauge = (gauge_t)vl->values[0].gauge;
 359
 360   /* Change the type to "cache_ratio" */
 361   sstrncpy(new_vl.type, "cache_ratio", sizeof(new_vl.type));
 362
 363   /* Adapt the type instance */
 364   if (strcmp("L1", vl->type_instance) == 0)
 365     sstrncpy(new_vl.type_instance, "arc", sizeof(new_vl.type_instance));
 366
 367   /* Dispatch new value lists instead of this one */
 368   plugin_dispatch_values(&new_vl);
 369
 370   /* Abort processing */
 371   return FC_TARGET_STOP;
 372 } /* }}} int v5_zfs_arc_ratio */
 373
 374 /*
 375  * ZFS ARC size
 376  *
 377  * 4.* uses the "arc_size" type with four data sources. In 5.* this has been
 378  * replaces with the "cache_size" type and static data has been removed.
 379  */
 380 static int v5_zfs_arc_size(const data_set_t *ds, value_list_t *vl) /* {{{ */
 381 {
 382   value_list_t new_vl;
 383
 384   if (vl->values_len != 4)
 385     return FC_TARGET_STOP;
 386
 387   /* Copy everything: Time, interval, host, ... */
 388   memcpy(&new_vl, vl, sizeof(new_vl));
 389
 390   /* Reset data we can't simply copy */
 391   new_vl.values = &(value_t){.gauge = NAN};
 392   new_vl.values_len = 1;
 393   new_vl.meta = NULL;
 394
 395   /* Change the type to "cache_size" */
 396   sstrncpy(new_vl.type, "cache_size", sizeof(new_vl.type));
 397
 398   /* Dispatch new value lists instead of this one */
 399   new_vl.values[0].derive = (derive_t)vl->values[0].counter;
 400   sstrncpy(new_vl.type_instance, "arc", sizeof(new_vl.type_instance));
 401   plugin_dispatch_values(&new_vl);
 402
 403   /* Abort processing */
 404   return FC_TARGET_STOP;
 405 } /* }}} int v5_zfs_arc_size */
 406
 407 static int v5_destroy(void **user_data) /* {{{ */
 408 {
 409   return 0;
 410 } /* }}} int v5_destroy */
 411
 412 static int v5_create(const oconfig_item_t *ci, void **user_data) /* {{{ */
 413 {
 414   *user_data = NULL;
 415   return 0;
 416 } /* }}} int v5_create */
 417
 418 static int v5_invoke(const data_set_t *ds, value_list_t *vl, /* {{{ */
 419                      notification_meta_t __attribute__((unused)) * *meta,
 420                      void __attribute__((unused)) * *user_data) {
 421   if ((ds == NULL) || (vl == NULL) || (user_data == NULL))
 422     return -EINVAL;
 423
 424   if (strcmp("df", vl->type) == 0)
 425     return v5_df(ds, vl);
 426   else if (strcmp("interface", vl->plugin) == 0)
 427     return v5_interface(ds, vl);
 428   else if (strcmp("mysql_qcache", vl->type) == 0)
 429     return v5_mysql_qcache(ds, vl);
 430   else if (strcmp("mysql_threads", vl->type) == 0)
 431     return v5_mysql_threads(ds, vl);
 432   else if (strcmp("arc_counts", vl->type) == 0)
 433     return v5_zfs_arc_counts(ds, vl);
 434   else if (strcmp("arc_l2_bytes", vl->type) == 0)
 435     return v5_zfs_arc_l2_bytes(ds, vl);
 436   else if (strcmp("arc_l2_size", vl->type) == 0)
 437     return v5_zfs_arc_l2_size(ds, vl);
 438   else if (strcmp("arc_ratio", vl->type) == 0)
 439     return v5_zfs_arc_ratio(ds, vl);
 440   else if (strcmp("arc_size", vl->type) == 0)
 441     return v5_zfs_arc_size(ds, vl);
 442
 443   return FC_TARGET_CONTINUE;
 444 } /* }}} int v5_invoke */
 445
 446 void module_register(void) {
 447   target_proc_t tproc = {0};
 448
 449   tproc.create = v5_create;
 450   tproc.destroy = v5_destroy;
 451   tproc.invoke = v5_invoke;
 452   fc_register_target("v5upgrade", tproc);
 453 } /* module_register */