From 02e12dba7080e60badf853c92aa83c6fd99ba4f0 Mon Sep 17 00:00:00 2001 From: Marc Fournier Date: Wed, 16 Jun 2010 18:32:03 +0200 Subject: [PATCH] Varnish plugin: better rrd files layout This patch groups collected values in categories, each configuration option corresponding to one category. The category name will then be part of the instance name, which leads to a more sensible directory/file structure: host/varnish-instance-category/... .../type_typeinstance.rrd .../type_typeinstance.rrd host/varnish-instance-category/... .../type_typeinstance.rrd .../type_typeinstance.rrd --- src/varnish.c | 139 ++++++++++++++++++++++++++++++---------------------------- 1 file changed, 72 insertions(+), 67 deletions(-) diff --git a/src/varnish.c b/src/varnish.c index 956d3e73..6716231f 100644 --- a/src/varnish.c +++ b/src/varnish.c @@ -153,7 +153,7 @@ typedef struct user_config_s user_config_t; /* }}} */ static _Bool have_instance = 0; static int varnish_submit (const char *plugin_instance, /* {{{ */ - const char *type, const char *type_instance, value_t value) + const char *category, const char *type, const char *type_instance, value_t value) { value_list_t vl = VALUE_LIST_INIT; @@ -163,11 +163,16 @@ static int varnish_submit (const char *plugin_instance, /* {{{ */ sstrncpy(vl.host, hostname_g, sizeof(vl.host)); sstrncpy(vl.plugin, "varnish", sizeof(vl.plugin)); - if (plugin_instance != NULL) + + if (plugin_instance != NULL) { sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance)); + strncat(vl.plugin_instance, "-", 1); + strncat(vl.plugin_instance, category, sizeof(category)); + } sstrncpy(vl.type, type, sizeof(vl.type)); + if (type_instance != NULL) sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance)); @@ -176,25 +181,25 @@ static int varnish_submit (const char *plugin_instance, /* {{{ */ } /* }}} int varnish_submit */ static int varnish_submit_gauge (const char *plugin_instance, /* {{{ */ - const char *type, const char *type_instance, + const char *category, const char *type, const char *type_instance, uint64_t gauge_value) { value_t value; value.gauge = (gauge_t) gauge_value; - return (varnish_submit (plugin_instance, type, type_instance, value)); + return (varnish_submit (plugin_instance, category, type, type_instance, value)); } /* }}} int varnish_submit_gauge */ static int varnish_submit_derive (const char *plugin_instance, /* {{{ */ - const char *type, const char *type_instance, + const char *category, const char *type, const char *type_instance, uint64_t derive_value) { value_t value; value.derive = (derive_t) derive_value; - return (varnish_submit (plugin_instance, type, type_instance, value)); + return (varnish_submit (plugin_instance, category, type, type_instance, value)); } /* }}} int varnish_submit_derive */ static void varnish_monitor(const user_config_t *conf, struct varnish_stats *VSL_stats) /* {{{ */ @@ -202,171 +207,171 @@ static void varnish_monitor(const user_config_t *conf, struct varnish_stats *VSL if(conf->collect_cache) { /* Cache hits */ - varnish_submit_derive (conf->instance, "cache_result", "hit" , VSL_stats->cache_hit); + varnish_submit_derive (conf->instance, "cache", "cache_result", "hit", VSL_stats->cache_hit); /* Cache misses */ - varnish_submit_derive (conf->instance, "cache_result", "miss" , VSL_stats->cache_miss); + varnish_submit_derive (conf->instance, "cache", "cache_result", "miss", VSL_stats->cache_miss); /* Cache hits for pass */ - varnish_submit_derive (conf->instance, "cache_result", "hitpass", VSL_stats->cache_hitpass); + varnish_submit_derive (conf->instance, "cache", "cache_result", "hitpass", VSL_stats->cache_hitpass); } if(conf->collect_connections) { /* Client connections accepted */ - varnish_submit_derive (conf->instance, "connections", "client-accepted", VSL_stats->client_conn); + varnish_submit_derive (conf->instance, "client", "connections", "accepted", VSL_stats->client_conn); /* Connection dropped, no sess */ - varnish_submit_derive (conf->instance, "connections", "client-dropped" , VSL_stats->client_drop); + varnish_submit_derive (conf->instance, "client", "connections", "dropped" , VSL_stats->client_drop); /* Client requests received */ - varnish_submit_derive (conf->instance, "connections", "client-received", VSL_stats->client_req); + varnish_submit_derive (conf->instance, "client", "connections", "received", VSL_stats->client_req); } if(conf->collect_esi) { /* Objects ESI parsed (unlock) */ - varnish_submit_derive (conf->instance, "total_operations", "esi-parsed", VSL_stats->esi_parse); + varnish_submit_derive (conf->instance, "esi", "total_operations", "parsed", VSL_stats->esi_parse); /* ESI parse errors (unlock) */ - varnish_submit_derive (conf->instance, "total_operations", "esi-error", VSL_stats->esi_errors); + varnish_submit_derive (conf->instance, "esi", "total_operations", "error", VSL_stats->esi_errors); } if(conf->collect_backend) { /* Backend conn. success */ - varnish_submit_derive (conf->instance, "connections", "backend-success" , VSL_stats->backend_conn); + varnish_submit_derive (conf->instance, "backend", "connections", "success" , VSL_stats->backend_conn); /* Backend conn. not attempted */ - varnish_submit_derive (conf->instance, "connections", "backend-not-attempted", VSL_stats->backend_unhealthy); + varnish_submit_derive (conf->instance, "backend", "connections", "not-attempted", VSL_stats->backend_unhealthy); /* Backend conn. too many */ - varnish_submit_derive (conf->instance, "connections", "backend-too-many" , VSL_stats->backend_busy); + varnish_submit_derive (conf->instance, "backend", "connections", "too-many" , VSL_stats->backend_busy); /* Backend conn. failures */ - varnish_submit_derive (conf->instance, "connections", "backend-failures" , VSL_stats->backend_fail); + varnish_submit_derive (conf->instance, "backend", "connections", "failures" , VSL_stats->backend_fail); /* Backend conn. reuses */ - varnish_submit_derive (conf->instance, "connections", "backend-reuses" , VSL_stats->backend_reuse); + varnish_submit_derive (conf->instance, "backend", "connections", "reuses" , VSL_stats->backend_reuse); /* Backend conn. was closed */ - varnish_submit_derive (conf->instance, "connections", "backend-was-closed" , VSL_stats->backend_toolate); + varnish_submit_derive (conf->instance, "backend", "connections", "was-closed" , VSL_stats->backend_toolate); /* Backend conn. recycles */ - varnish_submit_derive (conf->instance, "connections", "backend-recycled" , VSL_stats->backend_recycle); + varnish_submit_derive (conf->instance, "backend", "connections", "recycled" , VSL_stats->backend_recycle); /* Backend conn. unused */ - varnish_submit_derive (conf->instance, "connections", "backend-unused" , VSL_stats->backend_unused); + varnish_submit_derive (conf->instance, "backend", "connections", "unused" , VSL_stats->backend_unused); } if(conf->collect_fetch) { /* Fetch head */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-head" , VSL_stats->fetch_head); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "head" , VSL_stats->fetch_head); /* Fetch with length */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-length" , VSL_stats->fetch_length); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "length" , VSL_stats->fetch_length); /* Fetch chunked */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-chunked" , VSL_stats->fetch_chunked); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "chunked" , VSL_stats->fetch_chunked); /* Fetch EOF */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-eof" , VSL_stats->fetch_eof); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "eof" , VSL_stats->fetch_eof); /* Fetch bad headers */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-bad_headers", VSL_stats->fetch_bad); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "bad_headers", VSL_stats->fetch_bad); /* Fetch wanted close */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-close" , VSL_stats->fetch_close); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "close" , VSL_stats->fetch_close); /* Fetch pre HTTP/1.1 closed */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-oldhttp" , VSL_stats->fetch_oldhttp); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "oldhttp" , VSL_stats->fetch_oldhttp); /* Fetch zero len */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-zero" , VSL_stats->fetch_zero); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "zero" , VSL_stats->fetch_zero); /* Fetch failed */ - varnish_submit_derive (conf->instance, "http_requests", "fetch-failed" , VSL_stats->fetch_failed); + varnish_submit_derive (conf->instance, "fetch", "http_requests", "failed" , VSL_stats->fetch_failed); } if(conf->collect_hcb) { /* HCB Lookups without lock */ - varnish_submit_derive (conf->instance, "cache_operation", "lookup_nolock", VSL_stats->hcb_nolock); + varnish_submit_derive (conf->instance, "hcb", "cache_operation", "lookup_nolock", VSL_stats->hcb_nolock); /* HCB Lookups with lock */ - varnish_submit_derive (conf->instance, "cache_operation", "lookup_lock", VSL_stats->hcb_lock); + varnish_submit_derive (conf->instance, "hcb", "cache_operation", "lookup_lock", VSL_stats->hcb_lock); /* HCB Inserts */ - varnish_submit_derive (conf->instance, "cache_operation", "insert", VSL_stats->hcb_insert); + varnish_submit_derive (conf->instance, "hcb", "cache_operation", "insert", VSL_stats->hcb_insert); } if(conf->collect_shm) { /* SHM records */ - varnish_submit_derive (conf->instance, "total_operations", "shmlog-records" , VSL_stats->shm_records); + varnish_submit_derive (conf->instance, "shm", "total_operations", "records" , VSL_stats->shm_records); /* SHM writes */ - varnish_submit_derive (conf->instance, "total_operations", "shmlog-writes" , VSL_stats->shm_writes); + varnish_submit_derive (conf->instance, "shm", "total_operations", "writes" , VSL_stats->shm_writes); /* SHM flushes due to overflow */ - varnish_submit_derive (conf->instance, "total_operations", "shmlog-flushes" , VSL_stats->shm_flushes); + varnish_submit_derive (conf->instance, "shm", "total_operations", "flushes" , VSL_stats->shm_flushes); /* SHM MTX contention */ - varnish_submit_derive (conf->instance, "total_operations", "shmlog-contention", VSL_stats->shm_cont); + varnish_submit_derive (conf->instance, "shm", "total_operations", "contention", VSL_stats->shm_cont); /* SHM cycles through buffer */ - varnish_submit_derive (conf->instance, "total_operations", "shmlog-cycles" , VSL_stats->shm_cycles); + varnish_submit_derive (conf->instance, "shm", "total_operations", "cycles" , VSL_stats->shm_cycles); } if(conf->collect_sm) { /* allocator requests */ - varnish_submit_derive (conf->instance, "total_requests", "storage-file", VSL_stats->sm_nreq); + varnish_submit_derive (conf->instance, "sm", "total_requests", "nreq", VSL_stats->sm_nreq); /* outstanding allocations */ - varnish_submit_gauge (conf->instance, "requests", "storage-file-outstanding", VSL_stats->sm_nobj); + varnish_submit_gauge (conf->instance, "sm", "requests", "outstanding", VSL_stats->sm_nobj); /* bytes allocated */ - varnish_submit_gauge (conf->instance, "bytes", "storage-file-allocated", VSL_stats->sm_balloc); + varnish_submit_gauge (conf->instance, "sm", "bytes", "allocated", VSL_stats->sm_balloc); /* bytes free */ - varnish_submit_gauge (conf->instance, "bytes", "storage-file-free", VSL_stats->sm_bfree); + varnish_submit_gauge (conf->instance, "sm", "bytes", "free", VSL_stats->sm_bfree); } if(conf->collect_sma) { /* SMA allocator requests */ - varnish_submit_derive (conf->instance, "total_requests", "storage-mem", VSL_stats->sma_nreq); + varnish_submit_derive (conf->instance, "sma", "total_requests", "nreq", VSL_stats->sma_nreq); /* SMA outstanding allocations */ - varnish_submit_gauge (conf->instance, "requests", "storage-mem-outstanding", VSL_stats->sma_nobj); + varnish_submit_gauge (conf->instance, "sma", "requests", "outstanding", VSL_stats->sma_nobj); /* SMA outstanding bytes */ - varnish_submit_gauge (conf->instance, "bytes", "storage-mem-outstanding", VSL_stats->sma_nbytes); + varnish_submit_gauge (conf->instance, "sma", "bytes", "outstanding", VSL_stats->sma_nbytes); /* SMA bytes allocated */ - varnish_submit_gauge (conf->instance, "bytes", "storage-mem-allocated", VSL_stats->sma_balloc); + varnish_submit_gauge (conf->instance, "sma", "bytes", "allocated", VSL_stats->sma_balloc); /* SMA bytes free */ - varnish_submit_gauge (conf->instance, "bytes", "storage-mem-free" , VSL_stats->sma_bfree); + varnish_submit_gauge (conf->instance, "sma", "bytes", "free" , VSL_stats->sma_bfree); } if(conf->collect_sms) { /* SMS allocator requests */ - varnish_submit_derive (conf->instance, "total_requests", "storage-synth", VSL_stats->sms_nreq); + varnish_submit_derive (conf->instance, "sms", "total_requests", "allocator", VSL_stats->sms_nreq); /* SMS outstanding allocations */ - varnish_submit_gauge (conf->instance, "requests", "storage-synth-outstanding", VSL_stats->sms_nobj); + varnish_submit_gauge (conf->instance, "sms", "requests", "outstanding", VSL_stats->sms_nobj); /* SMS outstanding bytes */ - varnish_submit_gauge (conf->instance, "bytes", "storage-synth-outstanding", VSL_stats->sms_nbytes); + varnish_submit_gauge (conf->instance, "sms", "bytes", "outstanding", VSL_stats->sms_nbytes); /* SMS bytes allocated */ - varnish_submit_gauge (conf->instance, "bytes", "storage-synth-allocated", VSL_stats->sms_balloc); + varnish_submit_gauge (conf->instance, "sms", "bytes", "allocated", VSL_stats->sms_balloc); /* SMS bytes freed */ - varnish_submit_gauge (conf->instance, "bytes", "storage-synth-free", VSL_stats->sms_bfree); + varnish_submit_gauge (conf->instance, "sms", "bytes", "free", VSL_stats->sms_bfree); } if(conf->collect_totals) { /* Total Sessions */ - varnish_submit_derive (conf->instance, "total_sessions", "sessions", VSL_stats->s_sess); + varnish_submit_derive (conf->instance, "s", "total_sessions", "sessions", VSL_stats->s_sess); /* Total Requests */ - varnish_submit_derive (conf->instance, "total_requests", "requests", VSL_stats->s_req); + varnish_submit_derive (conf->instance, "s", "total_requests", "requests", VSL_stats->s_req); /* Total pipe */ - varnish_submit_derive (conf->instance, "total_operations", "pipe", VSL_stats->s_pipe); + varnish_submit_derive (conf->instance, "s", "total_operations", "pipe", VSL_stats->s_pipe); /* Total pass */ - varnish_submit_derive (conf->instance, "total_operations", "pass", VSL_stats->s_pass); + varnish_submit_derive (conf->instance, "s", "total_operations", "pass", VSL_stats->s_pass); /* Total fetch */ - varnish_submit_derive (conf->instance, "total_operations", "fetches", VSL_stats->s_fetch); + varnish_submit_derive (conf->instance, "s", "total_operations", "fetches", VSL_stats->s_fetch); /* Total header bytes */ - varnish_submit_derive (conf->instance, "total_bytes", "header-bytes", VSL_stats->s_hdrbytes); + varnish_submit_derive (conf->instance, "s", "total_bytes", "header-bytes", VSL_stats->s_hdrbytes); /* Total body byte */ - varnish_submit_derive (conf->instance, "total_bytes", "body-bytes", VSL_stats->s_bodybytes); + varnish_submit_derive (conf->instance, "s", "total_bytes", "body-bytes", VSL_stats->s_bodybytes); } if(conf->collect_workers) { /* worker threads */ - varnish_submit_gauge (conf->instance, "threads", "worker", VSL_stats->n_wrk); + varnish_submit_gauge (conf->instance, "n_wrk", "threads", "worker", VSL_stats->n_wrk); /* worker threads created */ - varnish_submit_gauge (conf->instance, "total_threads", "threads-created", VSL_stats->n_wrk_create); + varnish_submit_gauge (conf->instance, "n_wrk", "total_threads", "created", VSL_stats->n_wrk_create); /* worker threads not created */ - varnish_submit_gauge (conf->instance, "total_threads", "threads-failed", VSL_stats->n_wrk_failed); + varnish_submit_gauge (conf->instance, "n_wrk", "total_threads", "failed", VSL_stats->n_wrk_failed); /* worker threads limited */ - varnish_submit_gauge (conf->instance, "total_threads", "threads-limited", VSL_stats->n_wrk_max); + varnish_submit_gauge (conf->instance, "n_wrk", "total_threads", "limited", VSL_stats->n_wrk_max); /* queued work requests */ - varnish_submit_gauge (conf->instance, "total_requests", "worker-queued", VSL_stats->n_wrk_queue); + varnish_submit_gauge (conf->instance, "n_wrk", "total_requests", "queued", VSL_stats->n_wrk_queue); /* overflowed work requests */ - varnish_submit_gauge (conf->instance, "total_requests", "worker-overflowed", VSL_stats->n_wrk_overflow); + varnish_submit_gauge (conf->instance, "n_wrk", "total_requests", "overflowed", VSL_stats->n_wrk_overflow); /* dropped work requests */ - varnish_submit_gauge (conf->instance, "total_requests", "worker-dropped", VSL_stats->n_wrk_drop); + varnish_submit_gauge (conf->instance, "n_wrk", "total_requests", "dropped", VSL_stats->n_wrk_drop); } } /* }}} void varnish_monitor */ -- 2.11.0