Code

Varnish plugin: better rrd files layout
authorMarc Fournier <marc.fournier@camptocamp.com>
Wed, 16 Jun 2010 16:32:03 +0000 (18:32 +0200)
committerMarc Fournier <marc.fournier@camptocamp.com>
Wed, 16 Jun 2010 17:07:41 +0000 (19:07 +0200)
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

index 956d3e7394855c29bab1c0e6642aed7807de1171..6716231f98744f7862436198e3948e0830c84e8f 100644 (file)
@@ -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 */