src/varnish.c

   1 /**
   2  * collectd - src/varnish.c
   3  * Copyright (C) 2010      Jérôme Renard
   4  * Copyright (C) 2010      Marc Fournier
   5  * Copyright (C) 2010-2012 Florian Forster
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; only version 2 of the License is applicable.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  *
  20  * Authors:
  21  *   Jérôme Renard <jerome.renard at gmail.com>
  22  *   Marc Fournier <marc.fournier at camptocamp.com>
  23  *   Florian octo Forster <octo at collectd.org>
  24  **/
  25
  26 #include "collectd.h"
  27
  28 #include "common.h"
  29 #include "plugin.h"
  30
  31 #if HAVE_VARNISH_V4
  32 #include <vapi/vsc.h>
  33 #include <vapi/vsm.h>
  34 typedef struct VSC_C_main c_varnish_stats_t;
  35 #endif
  36
  37 #if HAVE_VARNISH_V3
  38 #include <varnishapi.h>
  39 #include <vsc.h>
  40 typedef struct VSC_C_main c_varnish_stats_t;
  41 #endif
  42
  43 #if HAVE_VARNISH_V2
  44 #include <varnishapi.h>
  45 typedef struct varnish_stats c_varnish_stats_t;
  46 #endif
  47
  48 /* {{{ user_config_s */
  49 struct user_config_s {
  50   char *instance;
  51
  52   _Bool collect_cache;
  53   _Bool collect_connections;
  54   _Bool collect_esi;
  55   _Bool collect_backend;
  56 #ifdef HAVE_VARNISH_V3
  57   _Bool collect_dirdns;
  58 #endif
  59   _Bool collect_fetch;
  60   _Bool collect_hcb;
  61   _Bool collect_objects;
  62 #if HAVE_VARNISH_V2
  63   _Bool collect_purge;
  64 #else
  65   _Bool collect_ban;
  66 #endif
  67   _Bool collect_session;
  68   _Bool collect_shm;
  69   _Bool collect_sms;
  70 #if HAVE_VARNISH_V2
  71   _Bool collect_sm;
  72   _Bool collect_sma;
  73 #endif
  74   _Bool collect_struct;
  75   _Bool collect_totals;
  76 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
  77   _Bool collect_uptime;
  78 #endif
  79   _Bool collect_vcl;
  80   _Bool collect_workers;
  81 #if HAVE_VARNISH_V4
  82   _Bool collect_vsm;
  83 #endif
  84 };
  85 typedef struct user_config_s user_config_t; /* }}} */
  86
  87 static _Bool have_instance = 0;
  88
  89 static int varnish_submit(const char *plugin_instance, /* {{{ */
  90                           const char *category, const char *type,
  91                           const char *type_instance, value_t value) {
  92   value_list_t vl = VALUE_LIST_INIT;
  93
  94   vl.values = &value;
  95   vl.values_len = 1;
  96
  97   sstrncpy(vl.plugin, "varnish", sizeof(vl.plugin));
  98
  99   if (plugin_instance == NULL)
 100     plugin_instance = "default";
 101   ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
 102             plugin_instance, category);
 103
 104   sstrncpy(vl.type, type, sizeof(vl.type));
 105
 106   if (type_instance != NULL)
 107     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 108
 109   return (plugin_dispatch_values(&vl));
 110 } /* }}} int varnish_submit */
 111
 112 static int varnish_submit_gauge(const char *plugin_instance, /* {{{ */
 113                                 const char *category, const char *type,
 114                                 const char *type_instance,
 115                                 uint64_t gauge_value) {
 116   return (varnish_submit(plugin_instance, category, type, type_instance,
 117                          (value_t){.gauge = (gauge_t)gauge_value}));
 118 } /* }}} int varnish_submit_gauge */
 119
 120 static int varnish_submit_derive(const char *plugin_instance, /* {{{ */
 121                                  const char *category, const char *type,
 122                                  const char *type_instance,
 123                                  uint64_t derive_value) {
 124   return (varnish_submit(plugin_instance, category, type, type_instance,
 125                          (value_t){.derive = (derive_t)derive_value}));
 126 } /* }}} int varnish_submit_derive */
 127
 128 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
 129 static int varnish_monitor(void *priv,
 130                            const struct VSC_point *const pt) /* {{{ */
 131 {
 132   uint64_t val;
 133   const user_config_t *conf;
 134   const char *class;
 135   const char *name;
 136
 137   if (pt == NULL)
 138     return (0);
 139
 140   conf = priv;
 141
 142 #if HAVE_VARNISH_V4
 143   class = pt->section->fantom->type;
 144   name = pt->desc->name;
 145
 146   if (strcmp(class, "MAIN") != 0)
 147     return (0);
 148
 149 #elif HAVE_VARNISH_V3
 150   class = pt->class;
 151   name = pt->name;
 152
 153   if (strcmp(class, "") != 0)
 154     return (0);
 155 #endif
 156
 157   val = *(const volatile uint64_t *)pt->ptr;
 158
 159   if (conf->collect_cache) {
 160     if (strcmp(name, "cache_hit") == 0)
 161       return varnish_submit_derive(conf->instance, "cache", "cache_result",
 162                                    "hit", val);
 163     else if (strcmp(name, "cache_miss") == 0)
 164       return varnish_submit_derive(conf->instance, "cache", "cache_result",
 165                                    "miss", val);
 166     else if (strcmp(name, "cache_hitpass") == 0)
 167       return varnish_submit_derive(conf->instance, "cache", "cache_result",
 168                                    "hitpass", val);
 169   }
 170
 171   if (conf->collect_connections) {
 172     if (strcmp(name, "client_conn") == 0)
 173       return varnish_submit_derive(conf->instance, "connections", "connections",
 174                                    "accepted", val);
 175     else if (strcmp(name, "client_drop") == 0)
 176       return varnish_submit_derive(conf->instance, "connections", "connections",
 177                                    "dropped", val);
 178     else if (strcmp(name, "client_req") == 0)
 179       return varnish_submit_derive(conf->instance, "connections", "connections",
 180                                    "received", val);
 181   }
 182
 183 #ifdef HAVE_VARNISH_V3
 184   if (conf->collect_dirdns) {
 185     if (strcmp(name, "dir_dns_lookups") == 0)
 186       return varnish_submit_derive(conf->instance, "dirdns", "cache_operation",
 187                                    "lookups", val);
 188     else if (strcmp(name, "dir_dns_failed") == 0)
 189       return varnish_submit_derive(conf->instance, "dirdns", "cache_result",
 190                                    "failed", val);
 191     else if (strcmp(name, "dir_dns_hit") == 0)
 192       return varnish_submit_derive(conf->instance, "dirdns", "cache_result",
 193                                    "hits", val);
 194     else if (strcmp(name, "dir_dns_cache_full") == 0)
 195       return varnish_submit_derive(conf->instance, "dirdns", "cache_result",
 196                                    "cache_full", val);
 197   }
 198 #endif
 199
 200   if (conf->collect_esi) {
 201     if (strcmp(name, "esi_errors") == 0)
 202       return varnish_submit_derive(conf->instance, "esi", "total_operations",
 203                                    "error", val);
 204     else if (strcmp(name, "esi_parse") == 0)
 205       return varnish_submit_derive(conf->instance, "esi", "total_operations",
 206                                    "parsed", val);
 207     else if (strcmp(name, "esi_warnings") == 0)
 208       return varnish_submit_derive(conf->instance, "esi", "total_operations",
 209                                    "warning", val);
 210   }
 211
 212   if (conf->collect_backend) {
 213     if (strcmp(name, "backend_conn") == 0)
 214       return varnish_submit_derive(conf->instance, "backend", "connections",
 215                                    "success", val);
 216     else if (strcmp(name, "backend_unhealthy") == 0)
 217       return varnish_submit_derive(conf->instance, "backend", "connections",
 218                                    "not-attempted", val);
 219     else if (strcmp(name, "backend_busy") == 0)
 220       return varnish_submit_derive(conf->instance, "backend", "connections",
 221                                    "too-many", val);
 222     else if (strcmp(name, "backend_fail") == 0)
 223       return varnish_submit_derive(conf->instance, "backend", "connections",
 224                                    "failures", val);
 225     else if (strcmp(name, "backend_reuse") == 0)
 226       return varnish_submit_derive(conf->instance, "backend", "connections",
 227                                    "reuses", val);
 228     else if (strcmp(name, "backend_toolate") == 0)
 229       return varnish_submit_derive(conf->instance, "backend", "connections",
 230                                    "was-closed", val);
 231     else if (strcmp(name, "backend_recycle") == 0)
 232       return varnish_submit_derive(conf->instance, "backend", "connections",
 233                                    "recycled", val);
 234     else if (strcmp(name, "backend_unused") == 0)
 235       return varnish_submit_derive(conf->instance, "backend", "connections",
 236                                    "unused", val);
 237     else if (strcmp(name, "backend_retry") == 0)
 238       return varnish_submit_derive(conf->instance, "backend", "connections",
 239                                    "retries", val);
 240     else if (strcmp(name, "backend_req") == 0)
 241       return varnish_submit_derive(conf->instance, "backend", "http_requests",
 242                                    "requests", val);
 243     else if (strcmp(name, "n_backend") == 0)
 244       return varnish_submit_gauge(conf->instance, "backend", "backends",
 245                                   "n_backends", val);
 246   }
 247
 248   if (conf->collect_fetch) {
 249     if (strcmp(name, "fetch_head") == 0)
 250       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 251                                    "head", val);
 252     else if (strcmp(name, "fetch_length") == 0)
 253       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 254                                    "length", val);
 255     else if (strcmp(name, "fetch_chunked") == 0)
 256       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 257                                    "chunked", val);
 258     else if (strcmp(name, "fetch_eof") == 0)
 259       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 260                                    "eof", val);
 261     else if (strcmp(name, "fetch_bad") == 0)
 262       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 263                                    "bad_headers", val);
 264     else if (strcmp(name, "fetch_close") == 0)
 265       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 266                                    "close", val);
 267     else if (strcmp(name, "fetch_oldhttp") == 0)
 268       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 269                                    "oldhttp", val);
 270     else if (strcmp(name, "fetch_zero") == 0)
 271       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 272                                    "zero", val);
 273     else if (strcmp(name, "fetch_failed") == 0)
 274       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 275                                    "failed", val);
 276     else if (strcmp(name, "fetch_1xx") == 0)
 277       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 278                                    "no_body_1xx", val);
 279     else if (strcmp(name, "fetch_204") == 0)
 280       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 281                                    "no_body_204", val);
 282     else if (strcmp(name, "fetch_304") == 0)
 283       return varnish_submit_derive(conf->instance, "fetch", "http_requests",
 284                                    "no_body_304", val);
 285   }
 286
 287   if (conf->collect_hcb) {
 288     if (strcmp(name, "hcb_nolock") == 0)
 289       return varnish_submit_derive(conf->instance, "hcb", "cache_operation",
 290                                    "lookup_nolock", val);
 291     else if (strcmp(name, "hcb_lock") == 0)
 292       return varnish_submit_derive(conf->instance, "hcb", "cache_operation",
 293                                    "lookup_lock", val);
 294     else if (strcmp(name, "hcb_insert") == 0)
 295       return varnish_submit_derive(conf->instance, "hcb", "cache_operation",
 296                                    "insert", val);
 297   }
 298
 299   if (conf->collect_objects) {
 300     if (strcmp(name, "n_expired") == 0)
 301       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 302                                    "expired", val);
 303     else if (strcmp(name, "n_lru_nuked") == 0)
 304       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 305                                    "lru_nuked", val);
 306     else if (strcmp(name, "n_lru_saved") == 0)
 307       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 308                                    "lru_saved", val);
 309     else if (strcmp(name, "n_lru_moved") == 0)
 310       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 311                                    "lru_moved", val);
 312     else if (strcmp(name, "n_deathrow") == 0)
 313       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 314                                    "deathrow", val);
 315     else if (strcmp(name, "losthdr") == 0)
 316       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 317                                    "header_overflow", val);
 318     else if (strcmp(name, "n_obj_purged") == 0)
 319       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 320                                    "purged", val);
 321     else if (strcmp(name, "n_objsendfile") == 0)
 322       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 323                                    "sent_sendfile", val);
 324     else if (strcmp(name, "n_objwrite") == 0)
 325       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 326                                    "sent_write", val);
 327     else if (strcmp(name, "n_objoverflow") == 0)
 328       return varnish_submit_derive(conf->instance, "objects", "total_objects",
 329                                    "workspace_overflow", val);
 330   }
 331
 332 #if HAVE_VARNISH_V3
 333   if (conf->collect_ban) {
 334     if (strcmp(name, "n_ban") == 0)
 335       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 336                                    "total", val);
 337     else if (strcmp(name, "n_ban_add") == 0)
 338       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 339                                    "added", val);
 340     else if (strcmp(name, "n_ban_retire") == 0)
 341       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 342                                    "deleted", val);
 343     else if (strcmp(name, "n_ban_obj_test") == 0)
 344       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 345                                    "objects_tested", val);
 346     else if (strcmp(name, "n_ban_re_test") == 0)
 347       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 348                                    "regexps_tested", val);
 349     else if (strcmp(name, "n_ban_dups") == 0)
 350       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 351                                    "duplicate", val);
 352   }
 353 #endif
 354 #if HAVE_VARNISH_V4
 355   if (conf->collect_ban) {
 356     if (strcmp(name, "bans") == 0)
 357       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 358                                    "total", val);
 359     else if (strcmp(name, "bans_added") == 0)
 360       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 361                                    "added", val);
 362     else if (strcmp(name, "bans_obj") == 0)
 363       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 364                                    "obj", val);
 365     else if (strcmp(name, "bans_req") == 0)
 366       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 367                                    "req", val);
 368     else if (strcmp(name, "bans_completed") == 0)
 369       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 370                                    "completed", val);
 371     else if (strcmp(name, "bans_deleted") == 0)
 372       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 373                                    "deleted", val);
 374     else if (strcmp(name, "bans_tested") == 0)
 375       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 376                                    "tested", val);
 377     else if (strcmp(name, "bans_dups") == 0)
 378       return varnish_submit_derive(conf->instance, "ban", "total_operations",
 379                                    "duplicate", val);
 380   }
 381 #endif
 382
 383   if (conf->collect_session) {
 384     if (strcmp(name, "sess_closed") == 0)
 385       return varnish_submit_derive(conf->instance, "session",
 386                                    "total_operations", "closed", val);
 387     else if (strcmp(name, "sess_pipeline") == 0)
 388       return varnish_submit_derive(conf->instance, "session",
 389                                    "total_operations", "pipeline", val);
 390     else if (strcmp(name, "sess_readahead") == 0)
 391       return varnish_submit_derive(conf->instance, "session",
 392                                    "total_operations", "readahead", val);
 393     else if (strcmp(name, "sess_conn") == 0)
 394       return varnish_submit_derive(conf->instance, "session",
 395                                    "total_operations", "accepted", val);
 396     else if (strcmp(name, "sess_drop") == 0)
 397       return varnish_submit_derive(conf->instance, "session",
 398                                    "total_operations", "dropped", val);
 399     else if (strcmp(name, "sess_fail") == 0)
 400       return varnish_submit_derive(conf->instance, "session",
 401                                    "total_operations", "failed", val);
 402     else if (strcmp(name, "sess_pipe_overflow") == 0)
 403       return varnish_submit_derive(conf->instance, "session",
 404                                    "total_operations", "overflow", val);
 405     else if (strcmp(name, "sess_queued") == 0)
 406       return varnish_submit_derive(conf->instance, "session",
 407                                    "total_operations", "queued", val);
 408     else if (strcmp(name, "sess_linger") == 0)
 409       return varnish_submit_derive(conf->instance, "session",
 410                                    "total_operations", "linger", val);
 411     else if (strcmp(name, "sess_herd") == 0)
 412       return varnish_submit_derive(conf->instance, "session",
 413                                    "total_operations", "herd", val);
 414   }
 415
 416   if (conf->collect_shm) {
 417     if (strcmp(name, "shm_records") == 0)
 418       return varnish_submit_derive(conf->instance, "shm", "total_operations",
 419                                    "records", val);
 420     else if (strcmp(name, "shm_writes") == 0)
 421       return varnish_submit_derive(conf->instance, "shm", "total_operations",
 422                                    "writes", val);
 423     else if (strcmp(name, "shm_flushes") == 0)
 424       return varnish_submit_derive(conf->instance, "shm", "total_operations",
 425                                    "flushes", val);
 426     else if (strcmp(name, "shm_cont") == 0)
 427       return varnish_submit_derive(conf->instance, "shm", "total_operations",
 428                                    "contention", val);
 429     else if (strcmp(name, "shm_cycles") == 0)
 430       return varnish_submit_derive(conf->instance, "shm", "total_operations",
 431                                    "cycles", val);
 432   }
 433
 434   if (conf->collect_sms) {
 435     if (strcmp(name, "sms_nreq") == 0)
 436       return varnish_submit_derive(conf->instance, "sms", "total_requests",
 437                                    "allocator", val);
 438     else if (strcmp(name, "sms_nobj") == 0)
 439       return varnish_submit_gauge(conf->instance, "sms", "requests",
 440                                   "outstanding", val);
 441     else if (strcmp(name, "sms_nbytes") == 0)
 442       return varnish_submit_gauge(conf->instance, "sms", "bytes", "outstanding",
 443                                   val);
 444     else if (strcmp(name, "sms_balloc") == 0)
 445       return varnish_submit_derive(conf->instance, "sms", "total_bytes",
 446                                    "allocated", val);
 447     else if (strcmp(name, "sms_bfree") == 0)
 448       return varnish_submit_derive(conf->instance, "sms", "total_bytes", "free",
 449                                    val);
 450   }
 451
 452   if (conf->collect_struct) {
 453     if (strcmp(name, "n_sess_mem") == 0)
 454       return varnish_submit_gauge(conf->instance, "struct", "current_sessions",
 455                                   "sess_mem", val);
 456     else if (strcmp(name, "n_sess") == 0)
 457       return varnish_submit_gauge(conf->instance, "struct", "current_sessions",
 458                                   "sess", val);
 459     else if (strcmp(name, "n_object") == 0)
 460       return varnish_submit_gauge(conf->instance, "struct", "objects", "object",
 461                                   val);
 462     else if (strcmp(name, "n_vampireobject") == 0)
 463       return varnish_submit_gauge(conf->instance, "struct", "objects",
 464                                   "vampireobject", val);
 465     else if (strcmp(name, "n_objectcore") == 0)
 466       return varnish_submit_gauge(conf->instance, "struct", "objects",
 467                                   "objectcore", val);
 468     else if (strcmp(name, "n_waitinglist") == 0)
 469       return varnish_submit_gauge(conf->instance, "struct", "objects",
 470                                   "waitinglist", val);
 471     else if (strcmp(name, "n_objecthead") == 0)
 472       return varnish_submit_gauge(conf->instance, "struct", "objects",
 473                                   "objecthead", val);
 474     else if (strcmp(name, "n_smf") == 0)
 475       return varnish_submit_gauge(conf->instance, "struct", "objects", "smf",
 476                                   val);
 477     else if (strcmp(name, "n_smf_frag") == 0)
 478       return varnish_submit_gauge(conf->instance, "struct", "objects",
 479                                   "smf_frag", val);
 480     else if (strcmp(name, "n_smf_large") == 0)
 481       return varnish_submit_gauge(conf->instance, "struct", "objects",
 482                                   "smf_large", val);
 483     else if (strcmp(name, "n_vbe_conn") == 0)
 484       return varnish_submit_gauge(conf->instance, "struct", "objects",
 485                                   "vbe_conn", val);
 486   }
 487
 488   if (conf->collect_totals) {
 489     if (strcmp(name, "s_sess") == 0)
 490       return varnish_submit_derive(conf->instance, "totals", "total_sessions",
 491                                    "sessions", val);
 492     else if (strcmp(name, "s_req") == 0)
 493       return varnish_submit_derive(conf->instance, "totals", "total_requests",
 494                                    "requests", val);
 495     else if (strcmp(name, "s_pipe") == 0)
 496       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 497                                    "pipe", val);
 498     else if (strcmp(name, "s_pass") == 0)
 499       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 500                                    "pass", val);
 501     else if (strcmp(name, "s_fetch") == 0)
 502       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 503                                    "fetches", val);
 504     else if (strcmp(name, "s_synth") == 0)
 505       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 506                                    "synth", val);
 507     else if (strcmp(name, "s_req_hdrbytes") == 0)
 508       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 509                                    "req_header", val);
 510     else if (strcmp(name, "s_req_bodybytes") == 0)
 511       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 512                                    "req_body", val);
 513     else if (strcmp(name, "s_resp_hdrbytes") == 0)
 514       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 515                                    "resp_header", val);
 516     else if (strcmp(name, "s_resp_bodybytes") == 0)
 517       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 518                                    "resp_body", val);
 519     else if (strcmp(name, "s_pipe_hdrbytes") == 0)
 520       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 521                                    "pipe_header", val);
 522     else if (strcmp(name, "s_pipe_in") == 0)
 523       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 524                                    "pipe_in", val);
 525     else if (strcmp(name, "s_pipe_out") == 0)
 526       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 527                                    "pipe_out", val);
 528     else if (strcmp(name, "n_purges") == 0)
 529       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 530                                    "purges", val);
 531     else if (strcmp(name, "s_hdrbytes") == 0)
 532       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 533                                    "header-bytes", val);
 534     else if (strcmp(name, "s_bodybytes") == 0)
 535       return varnish_submit_derive(conf->instance, "totals", "total_bytes",
 536                                    "body-bytes", val);
 537     else if (strcmp(name, "n_gzip") == 0)
 538       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 539                                    "gzip", val);
 540     else if (strcmp(name, "n_gunzip") == 0)
 541       return varnish_submit_derive(conf->instance, "totals", "total_operations",
 542                                    "gunzip", val);
 543   }
 544
 545   if (conf->collect_uptime) {
 546     if (strcmp(name, "uptime") == 0)
 547       return varnish_submit_gauge(conf->instance, "uptime", "uptime",
 548                                   "client_uptime", val);
 549   }
 550
 551   if (conf->collect_vcl) {
 552     if (strcmp(name, "n_vcl") == 0)
 553       return varnish_submit_gauge(conf->instance, "vcl", "vcl", "total_vcl",
 554                                   val);
 555     else if (strcmp(name, "n_vcl_avail") == 0)
 556       return varnish_submit_gauge(conf->instance, "vcl", "vcl", "avail_vcl",
 557                                   val);
 558     else if (strcmp(name, "n_vcl_discard") == 0)
 559       return varnish_submit_gauge(conf->instance, "vcl", "vcl", "discarded_vcl",
 560                                   val);
 561     else if (strcmp(name, "vmods") == 0)
 562       return varnish_submit_gauge(conf->instance, "vcl", "objects", "vmod",
 563                                   val);
 564   }
 565
 566   if (conf->collect_workers) {
 567     if (strcmp(name, "threads") == 0)
 568       return varnish_submit_gauge(conf->instance, "workers", "threads",
 569                                   "worker", val);
 570     else if (strcmp(name, "threads_created") == 0)
 571       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 572                                    "created", val);
 573     else if (strcmp(name, "threads_failed") == 0)
 574       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 575                                    "failed", val);
 576     else if (strcmp(name, "threads_limited") == 0)
 577       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 578                                    "limited", val);
 579     else if (strcmp(name, "threads_destroyed") == 0)
 580       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 581                                    "dropped", val);
 582     else if (strcmp(name, "thread_queue_len") == 0)
 583       return varnish_submit_derive(conf->instance, "workers", "queue_length",
 584                                    "threads", val);
 585     else if (strcmp(name, "n_wrk") == 0)
 586       return varnish_submit_gauge(conf->instance, "workers", "threads",
 587                                   "worker", val);
 588     else if (strcmp(name, "n_wrk_create") == 0)
 589       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 590                                    "created", val);
 591     else if (strcmp(name, "n_wrk_failed") == 0)
 592       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 593                                    "failed", val);
 594     else if (strcmp(name, "n_wrk_max") == 0)
 595       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 596                                    "limited", val);
 597     else if (strcmp(name, "n_wrk_drop") == 0)
 598       return varnish_submit_derive(conf->instance, "workers", "total_threads",
 599                                    "dropped", val);
 600     else if (strcmp(name, "n_wrk_queue") == 0)
 601       return varnish_submit_derive(conf->instance, "workers", "total_requests",
 602                                    "queued", val);
 603     else if (strcmp(name, "n_wrk_overflow") == 0)
 604       return varnish_submit_derive(conf->instance, "workers", "total_requests",
 605                                    "overflowed", val);
 606     else if (strcmp(name, "n_wrk_queued") == 0)
 607       return varnish_submit_derive(conf->instance, "workers", "total_requests",
 608                                    "queued", val);
 609     else if (strcmp(name, "n_wrk_lqueue") == 0)
 610       return varnish_submit_derive(conf->instance, "workers", "total_requests",
 611                                    "queue_length", val);
 612   }
 613
 614 #if HAVE_VARNISH_V4
 615   if (conf->collect_vsm) {
 616     if (strcmp(name, "vsm_free") == 0)
 617       return varnish_submit_gauge(conf->instance, "vsm", "bytes", "free", val);
 618     else if (strcmp(name, "vsm_used") == 0)
 619       return varnish_submit_gauge(conf->instance, "vsm", "bytes", "used", val);
 620     else if (strcmp(name, "vsm_cooling") == 0)
 621       return varnish_submit_gauge(conf->instance, "vsm", "bytes", "cooling",
 622                                   val);
 623     else if (strcmp(name, "vsm_overflow") == 0)
 624       return varnish_submit_gauge(conf->instance, "vsm", "bytes", "overflow",
 625                                   val);
 626     else if (strcmp(name, "vsm_overflowed") == 0)
 627       return varnish_submit_derive(conf->instance, "vsm", "total_bytes",
 628                                    "overflowed", val);
 629   }
 630 #endif
 631
 632   return (0);
 633
 634 } /* }}} static int varnish_monitor */
 635 #else /* if HAVE_VARNISH_V2 */
 636 static void varnish_monitor(const user_config_t *conf, /* {{{ */
 637                             const c_varnish_stats_t *stats) {
 638   if (conf->collect_cache) {
 639     /* Cache hits */
 640     varnish_submit_derive(conf->instance, "cache", "cache_result", "hit",
 641                           stats->cache_hit);
 642     /* Cache misses */
 643     varnish_submit_derive(conf->instance, "cache", "cache_result", "miss",
 644                           stats->cache_miss);
 645     /* Cache hits for pass */
 646     varnish_submit_derive(conf->instance, "cache", "cache_result", "hitpass",
 647                           stats->cache_hitpass);
 648   }
 649
 650   if (conf->collect_connections) {
 651     /* Client connections accepted */
 652     varnish_submit_derive(conf->instance, "connections", "connections",
 653                           "accepted", stats->client_conn);
 654     /* Connection dropped, no sess */
 655     varnish_submit_derive(conf->instance, "connections", "connections",
 656                           "dropped", stats->client_drop);
 657     /* Client requests received    */
 658     varnish_submit_derive(conf->instance, "connections", "connections",
 659                           "received", stats->client_req);
 660   }
 661
 662   if (conf->collect_esi) {
 663     /* ESI parse errors (unlock)   */
 664     varnish_submit_derive(conf->instance, "esi", "total_operations", "error",
 665                           stats->esi_errors);
 666     /* Objects ESI parsed (unlock) */
 667     varnish_submit_derive(conf->instance, "esi", "total_operations", "parsed",
 668                           stats->esi_parse);
 669   }
 670
 671   if (conf->collect_backend) {
 672     /* Backend conn. success       */
 673     varnish_submit_derive(conf->instance, "backend", "connections", "success",
 674                           stats->backend_conn);
 675     /* Backend conn. not attempted */
 676     varnish_submit_derive(conf->instance, "backend", "connections",
 677                           "not-attempted", stats->backend_unhealthy);
 678     /* Backend conn. too many      */
 679     varnish_submit_derive(conf->instance, "backend", "connections", "too-many",
 680                           stats->backend_busy);
 681     /* Backend conn. failures      */
 682     varnish_submit_derive(conf->instance, "backend", "connections", "failures",
 683                           stats->backend_fail);
 684     /* Backend conn. reuses        */
 685     varnish_submit_derive(conf->instance, "backend", "connections", "reuses",
 686                           stats->backend_reuse);
 687     /* Backend conn. was closed    */
 688     varnish_submit_derive(conf->instance, "backend", "connections",
 689                           "was-closed", stats->backend_toolate);
 690     /* Backend conn. recycles      */
 691     varnish_submit_derive(conf->instance, "backend", "connections", "recycled",
 692                           stats->backend_recycle);
 693     /* Backend conn. unused        */
 694     varnish_submit_derive(conf->instance, "backend", "connections", "unused",
 695                           stats->backend_unused);
 696     /* Backend requests mades      */
 697     varnish_submit_derive(conf->instance, "backend", "http_requests",
 698                           "requests", stats->backend_req);
 699     /* N backends                  */
 700     varnish_submit_gauge(conf->instance, "backend", "backends", "n_backends",
 701                          stats->n_backend);
 702   }
 703
 704   if (conf->collect_fetch) {
 705     /* Fetch head                */
 706     varnish_submit_derive(conf->instance, "fetch", "http_requests", "head",
 707                           stats->fetch_head);
 708     /* Fetch with length         */
 709     varnish_submit_derive(conf->instance, "fetch", "http_requests", "length",
 710                           stats->fetch_length);
 711     /* Fetch chunked             */
 712     varnish_submit_derive(conf->instance, "fetch", "http_requests", "chunked",
 713                           stats->fetch_chunked);
 714     /* Fetch EOF                 */
 715     varnish_submit_derive(conf->instance, "fetch", "http_requests", "eof",
 716                           stats->fetch_eof);
 717     /* Fetch bad headers         */
 718     varnish_submit_derive(conf->instance, "fetch", "http_requests",
 719                           "bad_headers", stats->fetch_bad);
 720     /* Fetch wanted close        */
 721     varnish_submit_derive(conf->instance, "fetch", "http_requests", "close",
 722                           stats->fetch_close);
 723     /* Fetch pre HTTP/1.1 closed */
 724     varnish_submit_derive(conf->instance, "fetch", "http_requests", "oldhttp",
 725                           stats->fetch_oldhttp);
 726     /* Fetch zero len            */
 727     varnish_submit_derive(conf->instance, "fetch", "http_requests", "zero",
 728                           stats->fetch_zero);
 729     /* Fetch failed              */
 730     varnish_submit_derive(conf->instance, "fetch", "http_requests", "failed",
 731                           stats->fetch_failed);
 732   }
 733
 734   if (conf->collect_hcb) {
 735     /* HCB Lookups without lock */
 736     varnish_submit_derive(conf->instance, "hcb", "cache_operation",
 737                           "lookup_nolock", stats->hcb_nolock);
 738     /* HCB Lookups with lock    */
 739     varnish_submit_derive(conf->instance, "hcb", "cache_operation",
 740                           "lookup_lock", stats->hcb_lock);
 741     /* HCB Inserts              */
 742     varnish_submit_derive(conf->instance, "hcb", "cache_operation", "insert",
 743                           stats->hcb_insert);
 744   }
 745
 746   if (conf->collect_objects) {
 747     /* N expired objects             */
 748     varnish_submit_derive(conf->instance, "objects", "total_objects", "expired",
 749                           stats->n_expired);
 750     /* N LRU nuked objects           */
 751     varnish_submit_derive(conf->instance, "objects", "total_objects",
 752                           "lru_nuked", stats->n_lru_nuked);
 753     /* N LRU saved objects           */
 754     varnish_submit_derive(conf->instance, "objects", "total_objects",
 755                           "lru_saved", stats->n_lru_saved);
 756     /* N LRU moved objects           */
 757     varnish_submit_derive(conf->instance, "objects", "total_objects",
 758                           "lru_moved", stats->n_lru_moved);
 759     /* N objects on deathrow         */
 760     varnish_submit_derive(conf->instance, "objects", "total_objects",
 761                           "deathrow", stats->n_deathrow);
 762     /* HTTP header overflows         */
 763     varnish_submit_derive(conf->instance, "objects", "total_objects",
 764                           "header_overflow", stats->losthdr);
 765     /* Objects sent with sendfile    */
 766     varnish_submit_derive(conf->instance, "objects", "total_objects",
 767                           "sent_sendfile", stats->n_objsendfile);
 768     /* Objects sent with write       */
 769     varnish_submit_derive(conf->instance, "objects", "total_objects",
 770                           "sent_write", stats->n_objwrite);
 771     /* Objects overflowing workspace */
 772     varnish_submit_derive(conf->instance, "objects", "total_objects",
 773                           "workspace_overflow", stats->n_objoverflow);
 774   }
 775
 776   if (conf->collect_purge) {
 777     /* N total active purges      */
 778     varnish_submit_derive(conf->instance, "purge", "total_operations", "total",
 779                           stats->n_purge);
 780     /* N new purges added         */
 781     varnish_submit_derive(conf->instance, "purge", "total_operations", "added",
 782                           stats->n_purge_add);
 783     /* N old purges deleted       */
 784     varnish_submit_derive(conf->instance, "purge", "total_operations",
 785                           "deleted", stats->n_purge_retire);
 786     /* N objects tested           */
 787     varnish_submit_derive(conf->instance, "purge", "total_operations",
 788                           "objects_tested", stats->n_purge_obj_test);
 789     /* N regexps tested against   */
 790     varnish_submit_derive(conf->instance, "purge", "total_operations",
 791                           "regexps_tested", stats->n_purge_re_test);
 792     /* N duplicate purges removed */
 793     varnish_submit_derive(conf->instance, "purge", "total_operations",
 794                           "duplicate", stats->n_purge_dups);
 795   }
 796
 797   if (conf->collect_session) {
 798     /* Session Closed     */
 799     varnish_submit_derive(conf->instance, "session", "total_operations",
 800                           "closed", stats->sess_closed);
 801     /* Session Pipeline   */
 802     varnish_submit_derive(conf->instance, "session", "total_operations",
 803                           "pipeline", stats->sess_pipeline);
 804     /* Session Read Ahead */
 805     varnish_submit_derive(conf->instance, "session", "total_operations",
 806                           "readahead", stats->sess_readahead);
 807     /* Session Linger     */
 808     varnish_submit_derive(conf->instance, "session", "total_operations",
 809                           "linger", stats->sess_linger);
 810     /* Session herd       */
 811     varnish_submit_derive(conf->instance, "session", "total_operations", "herd",
 812                           stats->sess_herd);
 813   }
 814
 815   if (conf->collect_shm) {
 816     /* SHM records                 */
 817     varnish_submit_derive(conf->instance, "shm", "total_operations", "records",
 818                           stats->shm_records);
 819     /* SHM writes                  */
 820     varnish_submit_derive(conf->instance, "shm", "total_operations", "writes",
 821                           stats->shm_writes);
 822     /* SHM flushes due to overflow */
 823     varnish_submit_derive(conf->instance, "shm", "total_operations", "flushes",
 824                           stats->shm_flushes);
 825     /* SHM MTX contention          */
 826     varnish_submit_derive(conf->instance, "shm", "total_operations",
 827                           "contention", stats->shm_cont);
 828     /* SHM cycles through buffer   */
 829     varnish_submit_derive(conf->instance, "shm", "total_operations", "cycles",
 830                           stats->shm_cycles);
 831   }
 832
 833   if (conf->collect_sm) {
 834     /* allocator requests */
 835     varnish_submit_derive(conf->instance, "sm", "total_requests", "nreq",
 836                           stats->sm_nreq);
 837     /* outstanding allocations */
 838     varnish_submit_gauge(conf->instance, "sm", "requests", "outstanding",
 839                          stats->sm_nobj);
 840     /* bytes allocated */
 841     varnish_submit_derive(conf->instance, "sm", "total_bytes", "allocated",
 842                           stats->sm_balloc);
 843     /* bytes free */
 844     varnish_submit_derive(conf->instance, "sm", "total_bytes", "free",
 845                           stats->sm_bfree);
 846   }
 847
 848   if (conf->collect_sma) {
 849     /* SMA allocator requests */
 850     varnish_submit_derive(conf->instance, "sma", "total_requests", "nreq",
 851                           stats->sma_nreq);
 852     /* SMA outstanding allocations */
 853     varnish_submit_gauge(conf->instance, "sma", "requests", "outstanding",
 854                          stats->sma_nobj);
 855     /* SMA outstanding bytes */
 856     varnish_submit_gauge(conf->instance, "sma", "bytes", "outstanding",
 857                          stats->sma_nbytes);
 858     /* SMA bytes allocated */
 859     varnish_submit_derive(conf->instance, "sma", "total_bytes", "allocated",
 860                           stats->sma_balloc);
 861     /* SMA bytes free */
 862     varnish_submit_derive(conf->instance, "sma", "total_bytes", "free",
 863                           stats->sma_bfree);
 864   }
 865
 866   if (conf->collect_sms) {
 867     /* SMS allocator requests */
 868     varnish_submit_derive(conf->instance, "sms", "total_requests", "allocator",
 869                           stats->sms_nreq);
 870     /* SMS outstanding allocations */
 871     varnish_submit_gauge(conf->instance, "sms", "requests", "outstanding",
 872                          stats->sms_nobj);
 873     /* SMS outstanding bytes */
 874     varnish_submit_gauge(conf->instance, "sms", "bytes", "outstanding",
 875                          stats->sms_nbytes);
 876     /* SMS bytes allocated */
 877     varnish_submit_derive(conf->instance, "sms", "total_bytes", "allocated",
 878                           stats->sms_balloc);
 879     /* SMS bytes freed */
 880     varnish_submit_derive(conf->instance, "sms", "total_bytes", "free",
 881                           stats->sms_bfree);
 882   }
 883
 884   if (conf->collect_struct) {
 885     /* N struct sess_mem       */
 886     varnish_submit_gauge(conf->instance, "struct", "current_sessions",
 887                          "sess_mem", stats->n_sess_mem);
 888     /* N struct sess           */
 889     varnish_submit_gauge(conf->instance, "struct", "current_sessions", "sess",
 890                          stats->n_sess);
 891     /* N struct object         */
 892     varnish_submit_gauge(conf->instance, "struct", "objects", "object",
 893                          stats->n_object);
 894     /* N struct objecthead     */
 895     varnish_submit_gauge(conf->instance, "struct", "objects", "objecthead",
 896                          stats->n_objecthead);
 897     /* N struct smf            */
 898     varnish_submit_gauge(conf->instance, "struct", "objects", "smf",
 899                          stats->n_smf);
 900     /* N small free smf         */
 901     varnish_submit_gauge(conf->instance, "struct", "objects", "smf_frag",
 902                          stats->n_smf_frag);
 903     /* N large free smf         */
 904     varnish_submit_gauge(conf->instance, "struct", "objects", "smf_large",
 905                          stats->n_smf_large);
 906     /* N struct vbe_conn        */
 907     varnish_submit_gauge(conf->instance, "struct", "objects", "vbe_conn",
 908                          stats->n_vbe_conn);
 909   }
 910
 911   if (conf->collect_totals) {
 912     /* Total Sessions */
 913     varnish_submit_derive(conf->instance, "totals", "total_sessions",
 914                           "sessions", stats->s_sess);
 915     /* Total Requests */
 916     varnish_submit_derive(conf->instance, "totals", "total_requests",
 917                           "requests", stats->s_req);
 918     /* Total pipe */
 919     varnish_submit_derive(conf->instance, "totals", "total_operations", "pipe",
 920                           stats->s_pipe);
 921     /* Total pass */
 922     varnish_submit_derive(conf->instance, "totals", "total_operations", "pass",
 923                           stats->s_pass);
 924     /* Total fetch */
 925     varnish_submit_derive(conf->instance, "totals", "total_operations",
 926                           "fetches", stats->s_fetch);
 927     /* Total header bytes */
 928     varnish_submit_derive(conf->instance, "totals", "total_bytes",
 929                           "header-bytes", stats->s_hdrbytes);
 930     /* Total body byte */
 931     varnish_submit_derive(conf->instance, "totals", "total_bytes", "body-bytes",
 932                           stats->s_bodybytes);
 933   }
 934
 935   if (conf->collect_vcl) {
 936     /* N vcl total     */
 937     varnish_submit_gauge(conf->instance, "vcl", "vcl", "total_vcl",
 938                          stats->n_vcl);
 939     /* N vcl available */
 940     varnish_submit_gauge(conf->instance, "vcl", "vcl", "avail_vcl",
 941                          stats->n_vcl_avail);
 942     /* N vcl discarded */
 943     varnish_submit_gauge(conf->instance, "vcl", "vcl", "discarded_vcl",
 944                          stats->n_vcl_discard);
 945   }
 946
 947   if (conf->collect_workers) {
 948     /* worker threads */
 949     varnish_submit_gauge(conf->instance, "workers", "threads", "worker",
 950                          stats->n_wrk);
 951     /* worker threads created */
 952     varnish_submit_derive(conf->instance, "workers", "total_threads", "created",
 953                           stats->n_wrk_create);
 954     /* worker threads not created */
 955     varnish_submit_derive(conf->instance, "workers", "total_threads", "failed",
 956                           stats->n_wrk_failed);
 957     /* worker threads limited */
 958     varnish_submit_derive(conf->instance, "workers", "total_threads", "limited",
 959                           stats->n_wrk_max);
 960     /* dropped work requests */
 961     varnish_submit_derive(conf->instance, "workers", "total_threads", "dropped",
 962                           stats->n_wrk_drop);
 963     /* queued work requests */
 964     varnish_submit_derive(conf->instance, "workers", "total_requests", "queued",
 965                           stats->n_wrk_queue);
 966     /* overflowed work requests */
 967     varnish_submit_derive(conf->instance, "workers", "total_requests",
 968                           "overflowed", stats->n_wrk_overflow);
 969   }
 970
 971 } /* }}} void varnish_monitor */
 972 #endif
 973
 974 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
 975 static int varnish_read(user_data_t *ud) /* {{{ */
 976 {
 977   struct VSM_data *vd;
 978   const c_varnish_stats_t *stats;
 979   _Bool ok;
 980
 981   user_config_t *conf;
 982
 983   if ((ud == NULL) || (ud->data == NULL))
 984     return (EINVAL);
 985
 986   conf = ud->data;
 987
 988   vd = VSM_New();
 989 #if HAVE_VARNISH_V3
 990   VSC_Setup(vd);
 991 #endif
 992
 993   if (conf->instance != NULL) {
 994     int status;
 995
 996     status = VSM_n_Arg(vd, conf->instance);
 997     if (status < 0) {
 998       VSM_Delete(vd);
 999       ERROR("varnish plugin: VSM_n_Arg (\"%s\") failed "
1000             "with status %i.",
1001             conf->instance, status);
1002       return (-1);
1003     }
1004   }
1005
1006 #if HAVE_VARNISH_V3
1007   ok = (VSC_Open(vd, /* diag = */ 1) == 0);
1008 #else /* if HAVE_VARNISH_V4 */
1009   ok = (VSM_Open(vd) == 0);
1010 #endif
1011   if (!ok) {
1012     VSM_Delete(vd);
1013     ERROR("varnish plugin: Unable to open connection.");
1014
1015     return (-1);
1016   }
1017
1018 #if HAVE_VARNISH_V3
1019   stats = VSC_Main(vd);
1020 #else /* if HAVE_VARNISH_V4 */
1021   stats = VSC_Main(vd, NULL);
1022 #endif
1023   if (!stats) {
1024     VSM_Delete(vd);
1025     ERROR("varnish plugin: Unable to get statistics.");
1026
1027     return (-1);
1028   }
1029
1030 #if HAVE_VARNISH_V3
1031   VSC_Iter(vd, varnish_monitor, conf);
1032 #else /* if HAVE_VARNISH_V4 */
1033   VSC_Iter(vd, NULL, varnish_monitor, conf);
1034 #endif
1035   VSM_Delete(vd);
1036
1037   return (0);
1038 } /* }}} */
1039 #else /* if HAVE_VARNISH_V2 */
1040 static int varnish_read(user_data_t *ud) /* {{{ */
1041 {
1042   const c_varnish_stats_t *stats;
1043
1044   user_config_t *conf;
1045
1046   if ((ud == NULL) || (ud->data == NULL))
1047     return (EINVAL);
1048
1049   conf = ud->data;
1050
1051   stats = VSL_OpenStats(conf->instance);
1052   if (stats == NULL) {
1053     ERROR("Varnish plugin : unable to load statistics");
1054
1055     return (-1);
1056   }
1057
1058   varnish_monitor(conf, stats);
1059
1060   return (0);
1061 } /* }}} */
1062 #endif
1063
1064 static void varnish_config_free(void *ptr) /* {{{ */
1065 {
1066   user_config_t *conf = ptr;
1067
1068   if (conf == NULL)
1069     return;
1070
1071   sfree(conf->instance);
1072   sfree(conf);
1073 } /* }}} */
1074
1075 static int varnish_config_apply_default(user_config_t *conf) /* {{{ */
1076 {
1077   if (conf == NULL)
1078     return (EINVAL);
1079
1080   conf->collect_backend = 1;
1081   conf->collect_cache = 1;
1082   conf->collect_connections = 1;
1083 #ifdef HAVE_VARNISH_V3
1084   conf->collect_dirdns = 0;
1085 #endif
1086   conf->collect_esi = 0;
1087   conf->collect_fetch = 0;
1088   conf->collect_hcb = 0;
1089   conf->collect_objects = 0;
1090 #if HAVE_VARNISH_V2
1091   conf->collect_purge = 0;
1092 #else
1093   conf->collect_ban = 0;
1094 #endif
1095   conf->collect_session = 0;
1096   conf->collect_shm = 1;
1097 #if HAVE_VARNISH_V2
1098   conf->collect_sm = 0;
1099   conf->collect_sma = 0;
1100 #endif
1101   conf->collect_sms = 0;
1102   conf->collect_struct = 0;
1103   conf->collect_totals = 0;
1104 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
1105   conf->collect_uptime = 0;
1106 #endif
1107   conf->collect_vcl = 0;
1108   conf->collect_workers = 0;
1109 #if HAVE_VARNISH_V4
1110   conf->collect_vsm = 0;
1111 #endif
1112
1113   return (0);
1114 } /* }}} int varnish_config_apply_default */
1115
1116 static int varnish_init(void) /* {{{ */
1117 {
1118   user_config_t *conf;
1119
1120   if (have_instance)
1121     return (0);
1122
1123   conf = calloc(1, sizeof(*conf));
1124   if (conf == NULL)
1125     return (ENOMEM);
1126
1127   /* Default settings: */
1128   conf->instance = NULL;
1129
1130   varnish_config_apply_default(conf);
1131
1132   plugin_register_complex_read(
1133       /* group = */ "varnish",
1134       /* name      = */ "varnish/localhost",
1135       /* callback  = */ varnish_read,
1136       /* interval  = */ 0, &(user_data_t){
1137                                .data = conf, .free_func = varnish_config_free,
1138                            });
1139
1140   return (0);
1141 } /* }}} int varnish_init */
1142
1143 static int varnish_config_instance(const oconfig_item_t *ci) /* {{{ */
1144 {
1145   user_config_t *conf;
1146   char callback_name[DATA_MAX_NAME_LEN];
1147
1148   conf = calloc(1, sizeof(*conf));
1149   if (conf == NULL)
1150     return (ENOMEM);
1151   conf->instance = NULL;
1152
1153   varnish_config_apply_default(conf);
1154
1155   if (ci->values_num == 1) {
1156     int status;
1157
1158     status = cf_util_get_string(ci, &conf->instance);
1159     if (status != 0) {
1160       sfree(conf);
1161       return (status);
1162     }
1163     assert(conf->instance != NULL);
1164
1165     if (strcmp("localhost", conf->instance) == 0) {
1166       sfree(conf->instance);
1167       conf->instance = NULL;
1168     }
1169   } else if (ci->values_num > 1) {
1170     WARNING("Varnish plugin: \"Instance\" blocks accept only "
1171             "one argument.");
1172     sfree(conf);
1173     return (EINVAL);
1174   }
1175
1176   for (int i = 0; i < ci->children_num; i++) {
1177     oconfig_item_t *child = ci->children + i;
1178
1179     if (strcasecmp("CollectCache", child->key) == 0)
1180       cf_util_get_boolean(child, &conf->collect_cache);
1181     else if (strcasecmp("CollectConnections", child->key) == 0)
1182       cf_util_get_boolean(child, &conf->collect_connections);
1183     else if (strcasecmp("CollectESI", child->key) == 0)
1184       cf_util_get_boolean(child, &conf->collect_esi);
1185     else if (strcasecmp("CollectDirectorDNS", child->key) == 0)
1186 #ifdef HAVE_VARNISH_V3
1187       cf_util_get_boolean(child, &conf->collect_dirdns);
1188 #else
1189       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1190               child->key, "v3");
1191 #endif
1192     else if (strcasecmp("CollectBackend", child->key) == 0)
1193       cf_util_get_boolean(child, &conf->collect_backend);
1194     else if (strcasecmp("CollectFetch", child->key) == 0)
1195       cf_util_get_boolean(child, &conf->collect_fetch);
1196     else if (strcasecmp("CollectHCB", child->key) == 0)
1197       cf_util_get_boolean(child, &conf->collect_hcb);
1198     else if (strcasecmp("CollectObjects", child->key) == 0)
1199       cf_util_get_boolean(child, &conf->collect_objects);
1200     else if (strcasecmp("CollectPurge", child->key) == 0)
1201 #if HAVE_VARNISH_V2
1202       cf_util_get_boolean(child, &conf->collect_purge);
1203 #else
1204       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1205               child->key, "v2");
1206 #endif
1207     else if (strcasecmp("CollectBan", child->key) == 0)
1208 #if HAVE_VARNISH_V2
1209       WARNING("Varnish plugin: \"%s\" is not available for Varnish %s.",
1210               child->key, "v2");
1211 #else
1212       cf_util_get_boolean(child, &conf->collect_ban);
1213 #endif
1214     else if (strcasecmp("CollectSession", child->key) == 0)
1215       cf_util_get_boolean(child, &conf->collect_session);
1216     else if (strcasecmp("CollectSHM", child->key) == 0)
1217       cf_util_get_boolean(child, &conf->collect_shm);
1218     else if (strcasecmp("CollectSMS", child->key) == 0)
1219       cf_util_get_boolean(child, &conf->collect_sms);
1220     else if (strcasecmp("CollectSMA", child->key) == 0)
1221 #if HAVE_VARNISH_V2
1222       cf_util_get_boolean(child, &conf->collect_sma);
1223 #else
1224       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1225               child->key, "v2");
1226 #endif
1227     else if (strcasecmp("CollectSM", child->key) == 0)
1228 #if HAVE_VARNISH_V2
1229       cf_util_get_boolean(child, &conf->collect_sm);
1230 #else
1231       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1232               child->key, "v2");
1233 #endif
1234     else if (strcasecmp("CollectStruct", child->key) == 0)
1235       cf_util_get_boolean(child, &conf->collect_struct);
1236     else if (strcasecmp("CollectTotals", child->key) == 0)
1237       cf_util_get_boolean(child, &conf->collect_totals);
1238     else if (strcasecmp("CollectUptime", child->key) == 0)
1239 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
1240       cf_util_get_boolean(child, &conf->collect_uptime);
1241 #else
1242       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1243               child->key, "v3 and v4");
1244 #endif
1245     else if (strcasecmp("CollectVCL", child->key) == 0)
1246       cf_util_get_boolean(child, &conf->collect_vcl);
1247     else if (strcasecmp("CollectWorkers", child->key) == 0)
1248       cf_util_get_boolean(child, &conf->collect_workers);
1249     else if (strcasecmp("CollectVSM", child->key) == 0)
1250 #if HAVE_VARNISH_V4
1251       cf_util_get_boolean(child, &conf->collect_vsm);
1252 #else
1253       WARNING("Varnish plugin: \"%s\" is available for Varnish %s only.",
1254               child->key, "v4");
1255 #endif
1256     else {
1257       WARNING("Varnish plugin: Ignoring unknown "
1258               "configuration option: \"%s\". Did "
1259               "you forget to add an <Instance /> "
1260               "block around the configuration?",
1261               child->key);
1262     }
1263   }
1264
1265   if (!conf->collect_cache && !conf->collect_connections &&
1266       !conf->collect_esi && !conf->collect_backend
1267 #ifdef HAVE_VARNISH_V3
1268       && !conf->collect_dirdns
1269 #endif
1270       && !conf->collect_fetch && !conf->collect_hcb && !conf->collect_objects
1271 #if HAVE_VARNISH_V2
1272       && !conf->collect_purge
1273 #else
1274       && !conf->collect_ban
1275 #endif
1276       && !conf->collect_session && !conf->collect_shm && !conf->collect_sms
1277 #if HAVE_VARNISH_V2
1278       && !conf->collect_sma && !conf->collect_sm
1279 #endif
1280       && !conf->collect_struct && !conf->collect_totals
1281 #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4
1282       && !conf->collect_uptime
1283 #endif
1284       && !conf->collect_vcl && !conf->collect_workers
1285 #if HAVE_VARNISH_V4
1286       && !conf->collect_vsm
1287 #endif
1288       ) {
1289     WARNING("Varnish plugin: No metric has been configured for "
1290             "instance \"%s\". Disabling this instance.",
1291             (conf->instance == NULL) ? "localhost" : conf->instance);
1292     sfree(conf);
1293     return (EINVAL);
1294   }
1295
1296   ssnprintf(callback_name, sizeof(callback_name), "varnish/%s",
1297             (conf->instance == NULL) ? "localhost" : conf->instance);
1298
1299   plugin_register_complex_read(
1300       /* group = */ "varnish",
1301       /* name      = */ callback_name,
1302       /* callback  = */ varnish_read,
1303       /* interval  = */ 0, &(user_data_t){
1304                                .data = conf, .free_func = varnish_config_free,
1305                            });
1306
1307   have_instance = 1;
1308
1309   return (0);
1310 } /* }}} int varnish_config_instance */
1311
1312 static int varnish_config(oconfig_item_t *ci) /* {{{ */
1313 {
1314   for (int i = 0; i < ci->children_num; i++) {
1315     oconfig_item_t *child = ci->children + i;
1316
1317     if (strcasecmp("Instance", child->key) == 0)
1318       varnish_config_instance(child);
1319     else {
1320       WARNING("Varnish plugin: Ignoring unknown "
1321               "configuration option: \"%s\"",
1322               child->key);
1323     }
1324   }
1325
1326   return (0);
1327 } /* }}} int varnish_config */
1328
1329 void module_register(void) /* {{{ */
1330 {
1331   plugin_register_complex_config("varnish", varnish_config);
1332   plugin_register_init("varnish", varnish_init);
1333 } /* }}} */