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

diff --git a/src/varnish.c b/src/varnish.c
index 956d3e7394855c29bab1c0e6642aed7807de1171..6716231f98744f7862436198e3948e0830c84e8f 100644 (file)
--- 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 */