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 **/
26 #include "collectd.h"
28 #include "common.h"
29 #include "plugin.h"
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
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
43 #if HAVE_VARNISH_V2
44 #include <varnishapi.h>
45 typedef struct varnish_stats c_varnish_stats_t;
46 #endif
48 /* {{{ user_config_s */
49 struct user_config_s {
50 char *instance;
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; /* }}} */
87 static _Bool have_instance = 0;
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;
94 vl.values = &value;
95 vl.values_len = 1;
97 sstrncpy(vl.plugin, "varnish", sizeof(vl.plugin));
99 if (plugin_instance == NULL)
100 plugin_instance = "default";
101 ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
102 plugin_instance, category);
104 sstrncpy(vl.type, type, sizeof(vl.type));
106 if (type_instance != NULL)
107 sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
109 return (plugin_dispatch_values(&vl));
110 } /* }}} int varnish_submit */
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 */
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 */
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;
137 if (pt == NULL)
138 return (0);
140 conf = priv;
142 #if HAVE_VARNISH_V4
143 class = pt->section->fantom->type;
144 name = pt->desc->name;
146 if (strcmp(class, "MAIN") != 0)
147 return (0);
149 #elif HAVE_VARNISH_V3
150 class = pt->class;
151 name = pt->name;
153 if (strcmp(class, "") != 0)
154 return (0);
155 #endif
157 val = *(const volatile uint64_t *)pt->ptr;
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 }
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 }
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
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 }
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 }
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 }
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 }
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 }
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
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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
632 return (0);
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
971 } /* }}} void varnish_monitor */
972 #endif
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;
981 user_config_t *conf;
983 if ((ud == NULL) || (ud->data == NULL))
984 return (EINVAL);
986 conf = ud->data;
988 vd = VSM_New();
989 #if HAVE_VARNISH_V3
990 VSC_Setup(vd);
991 #endif
993 if (conf->instance != NULL) {
994 int status;
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 }
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.");
1015 return (-1);
1016 }
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.");
1027 return (-1);
1028 }
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);
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;
1044 user_config_t *conf;
1046 if ((ud == NULL) || (ud->data == NULL))
1047 return (EINVAL);
1049 conf = ud->data;
1051 stats = VSL_OpenStats(conf->instance);
1052 if (stats == NULL) {
1053 ERROR("Varnish plugin : unable to load statistics");
1055 return (-1);
1056 }
1058 varnish_monitor(conf, stats);
1060 return (0);
1061 } /* }}} */
1062 #endif
1064 static void varnish_config_free(void *ptr) /* {{{ */
1065 {
1066 user_config_t *conf = ptr;
1068 if (conf == NULL)
1069 return;
1071 sfree(conf->instance);
1072 sfree(conf);
1073 } /* }}} */
1075 static int varnish_config_apply_default(user_config_t *conf) /* {{{ */
1076 {
1077 if (conf == NULL)
1078 return (EINVAL);
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
1113 return (0);
1114 } /* }}} int varnish_config_apply_default */
1116 static int varnish_init(void) /* {{{ */
1117 {
1118 user_config_t *conf;
1120 if (have_instance)
1121 return (0);
1123 conf = calloc(1, sizeof(*conf));
1124 if (conf == NULL)
1125 return (ENOMEM);
1127 /* Default settings: */
1128 conf->instance = NULL;
1130 varnish_config_apply_default(conf);
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 });
1140 return (0);
1141 } /* }}} int varnish_init */
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];
1148 conf = calloc(1, sizeof(*conf));
1149 if (conf == NULL)
1150 return (ENOMEM);
1151 conf->instance = NULL;
1153 varnish_config_apply_default(conf);
1155 if (ci->values_num == 1) {
1156 int status;
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);
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 }
1176 for (int i = 0; i < ci->children_num; i++) {
1177 oconfig_item_t *child = ci->children + i;
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 }
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 }
1296 ssnprintf(callback_name, sizeof(callback_name), "varnish/%s",
1297 (conf->instance == NULL) ? "localhost" : conf->instance);
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 });
1307 have_instance = 1;
1309 return (0);
1310 } /* }}} int varnish_config_instance */
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;
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 }
1326 return (0);
1327 } /* }}} int varnish_config */
1329 void module_register(void) /* {{{ */
1330 {
1331 plugin_register_complex_config("varnish", varnish_config);
1332 plugin_register_init("varnish", varnish_init);
1333 } /* }}} */