Index: head/net-mgmt/collectd5/Makefile =================================================================== --- head/net-mgmt/collectd5/Makefile (revision 401795) +++ head/net-mgmt/collectd5/Makefile (revision 401796) @@ -1,364 +1,363 @@ # Created by: Matt Peterson # $FreeBSD$ PORTNAME= collectd PORTVERSION= 5.5.0 -PORTREVISION= 3 +PORTREVISION= 4 CATEGORIES= net-mgmt MASTER_SITES= https://collectd.org/files/ \ http://collectd.org/files/ PKGNAMESUFFIX= 5 MAINTAINER= ports@bsdserwis.com COMMENT= Systems & network statistics collection daemon LICENSE= GPLv2 LICENSE_FILE= ${WRKSRC}/COPYING # Only autoreconf stage and sigrok plugin need GLIB: BUILD_DEPENDS= ${LOCALBASE}/share/aclocal/glib-2.0.m4:${PORTSDIR}/devel/glib20 LIB_DEPENDS= libltdl.so:${PORTSDIR}/devel/libltdl USES= autoreconf gmake libtool pkgconfig shebangfix tar:bzip2 GNU_CONFIGURE= yes OPTIONS_DEFINE= CGI DEBUG GCRYPT LOGSTASH VIRT OPTIONS_GROUP= INPUT OUTPUT OPTIONS_GROUP_OUTPUT= KAFKA NOTIFYDESKTOP NOTIFYEMAIL RIEMANN RRDTOOL OPTIONS_GROUP_INPUT= CURL CURL_JSON CURL_XML DBI IPMI JSON MEMCACHEC \ MODBUS MONGODB MYSQL NUTUPS OLSRD ONEWIRE OPENLDAP \ PERL PGSQL PINBA PING PYTHON RABBITMQ REDIS ROUTEROS \ SIGROK SNMP STATGRAB STATSD TOKYOTYRANT VARNISH XML \ XMMS ZOOKEEPER CGI_DESC= Install collection.cgi (requires rrdtool) CURL_DESC= Enable curl-based plugins (apache, nginx, etc) CURL_JSON_DESC= Enable curl_json plugin (implies curl and json) CURL_XML_DESC= Enable ascent, bind, curl_xml plugins (implies curl and xml) DBI_DESC= Enable dbi plugin DEBUG_DESC= Enable debugging GCRYPT_DESC= Build with libgcrypt IPMI_DESC= Enable OpenIPMI plugin JSON_DESC= Enable JSON plugins KAFKA_DESC= Enable write_kafka plugin LOGSTASH_DESC= Enable log_logstash plugin (requires json) MEMCACHEC_DESC= Enable memcachec plugin MODBUS_DESC= Enable modbus plugin MONGODB_DESC= Enable MongoDB-based plugins MYSQL_DESC= Enable mysql-based plugins NOTIFYDESKTOP_DESC= Enable desktop notifications NOTIFYEMAIL_DESC= Enable notifications via email NUTUPS_DESC= Enable nut (ups) plugin OLSRD_DESC= Enable olsrd plugin ONEWIRE_DESC= Eanble onewire plugin (via owfs) OPENLDAP_DESC= Enable OpenLDAP plugin PERL_DESC= Enable libperl plugin and binding PGSQL_DESC= Enable postgresql-based plugins PINBA_DESC= Enable pinba plugin (via protobuf-c) PING_DESC= Enable ping plugin PYTHON_DESC= Enable python-based plugins RABBITMQ_DESC= Enable rabbitmq-based plugins REDIS_DESC= Enable redis-based plugins RIEMANN_DESC= Enable write_riemann plugin (via protobuf-c) ROUTEROS_DESC= Enable routeros plugin RRDTOOL_DESC= Enable rrdtool plugin (also rrdcached plugin) SIGROK_DESC= Enable sigrok plugin SNMP_DESC= Enable SNMP plugin STATGRAB_DESC= Enable statgrab-based plugins (interface, etc) STATSD_DESC= Enable statsd plugin TOKYOTYRANT_DESC= Enable tokyotyrant plugin VARNISH_DESC= Enable varnish 4.x cache statistics VIRT_DESC= Enable libvirt plugin (requires XML) XML_DESC= Enable XML plugins XMMS_DESC= Enable xmms plugin ZOOKEEPER_DESC= Enable zookeeper plugin OPTIONS_SUB= yes USE_RC_SUBR= collectd collectdmon USE_LDCONFIG= yes CONFLICTS= collectd-4.[0-9]* CPPFLAGS+= -I${LOCALBASE}/include LIBS+= -L${LOCALBASE}/lib # NOTE: Plugins without dependencies are defined further down. CONFIGURE_ARGS= --localstatedir=/var \ --disable-all-plugins \ --disable-static \ --without-amqp \ --without-java \ --without-libaquaero5 \ --without-libganglia \ --without-libiptc \ --without-libjvm \ --without-liblvm2app \ --without-libkstat \ --without-libldap \ --without-libmnl \ --without-libmodbus \ --without-libnetlink \ --without-libnetapp \ --without-libowcapi \ --without-libperfstat \ --without-libsensors \ --without-lvm \ --without-mic \ --without-oracle \ --disable-turbostat CGI_RUN_DEPENDS= p5-URI>=0:${PORTSDIR}/net/p5-URI \ p5-CGI>=0:${PORTSDIR}/www/p5-CGI \ p5-Data-Dumper>=0:${PORTSDIR}/devel/p5-Data-Dumper \ p5-HTML-Parser>=0:${PORTSDIR}/www/p5-HTML-Parser CGI_IMPLIES= RRDTOOL CURL_LIB_DEPENDS= libcurl.so:${PORTSDIR}/ftp/curl CURL_CONFIGURE_ENABLE= apache curl nginx write_http CURL_CONFIGURE_WITH= libcurl=${LOCALBASE} CURL_JSON_IMPLIES= CURL JSON CURL_JSON_CONFIGURE_ENABLE= curl_json CURL_XML_IMPLIES= CURL XML CURL_XML_CONFIGURE_ENABLE= ascent bind curl_xml DEBUG_CONFIGURE_ENABLE= debug DBI_LIB_DEPENDS= libdbi.so:${PORTSDIR}/databases/libdbi DBI_CONFIGURE_WITH= libdbi=${LOCALBASE} DBI_CONFIGURE_ENABLE= dbi DBI_CFLAGS= -Wno-deprecated-declarations GCRYPT_LIB_DEPENDS= libgcrypt.so:${PORTSDIR}/security/libgcrypt GCRYPT_CONFIGURE_WITH= -with-libgcrypt=${LOCALBASE} GCRYPT_LIBS= -lgcrypt IPMI_LIB_DEPENDS= libOpenIPMI.so:${PORTSDIR}/sysutils/openipmi IPMI_CONFIGURE_ENABLE= ipmi JSON_LIB_DEPENDS= libyajl.so:${PORTSDIR}/devel/yajl JSON_CONFIGURE_WITH= libyajl=${LOCALBASE} KAFKA_LIB_DEPENDS= librdkafka.so:${PORTSDIR}/net/librdkafka KAFKA_CONFIGURE_ENABLE= write_kafka LOGSTASH_CONFIGURE_ENABLE= log_logstash LOGSTASH_IMPLIES= JSON MEMCACHEC_LIB_DEPENDS= libmemcached.so:${PORTSDIR}/databases/libmemcached MEMCACHEC_CONFIGURE_ENABLE= memcachec MEMCACHEC_CONFIGURE_WITH= libmemcached=${LOCALBASE} MODBUS_LIB_DEPENDS= libmodbus.so:${PORTSDIR}/comms/libmodbus MODBUS_CONFIGURE_ENABLE= modbus MODBUS_CONFIGURE_WITH= libmodbus=${LOCALBASE} MONGODB_LIB_DEPENDS= libmongoc-1.0.so:${PORTSDIR}/devel/mongo-c-driver MONGODB_CONFIGURE_ENABLE= write_mongodb MONGODB_CONFIGURE_WITH= libmongoc=${LOCALBASE} MYSQL_USE= mysql=yes MYSQL_CONFIGURE_ENABLE= mysql MYSQL_CONFIGURE_WITH= libmysql=${LOCALBASE} NOTIFYDESKTOP_LIB_DEPENDS= libnotify.so:${PORTSDIR}/devel/libnotify NOTIFYDESKTOP_CONFIGURE_ENABLE= notify_desktop NOTIFYDESKTOP_CONFIGURE_WITH= libnotify=${LOCALBASE} NOTIFYEMAIL_LIB_DEPENDS= libesmtp.so:${PORTSDIR}/mail/libesmtp NOTIFYEMAIL_CONFIGURE_ENABLE= notify_email NOTIFYEMAIL_CONFIGURE_WITH= libesmtp=${LOCALBASE} NUTUPS_LIB_DEPENDS= libupsclient.so:${PORTSDIR}/sysutils/nut NUTUPS_CONFIGURE_ENABLE= nut NUTUPS_CONFIGURE_WITH= upsclient=${LOCALBASE} OLSRD_CONFIGURE_ENABLE= olsrd ONEWIRE_LIB_DEPENDS= libow.so:${PORTSDIR}/comms/owfs ONEWIRE_CONFIGURE_ENABLE= onewire ONEWIRE_CONFIGURE_WITH= libowcapi=${LOCALBASE} OPENLDAP_USE= openldap=yes OPENLDAP_CONFIGURE_ENABLE= openldap OPENLDAP_CONFIGURE_WITH= libldap=${LOCALBASE} PGSQL_USES= pgsql PGSQL_CONFIGURE_ENABLE= postgresql PGSQL_CONFIGURE_WITH= postgresql=${LOCALBASE} libpq PINBA_LIB_DEPENDS= libprotobuf-c.so:${PORTSDIR}/devel/protobuf-c PINBA_CONFIGURE_ENABLE= pinba PING_LIB_DEPENDS= liboping.so:${PORTSDIR}/net/liboping PING_CONFIGURE_ENABLE= ping PING_CONFIGURE_WITH= liboping=${LOCALBASE} RABBITMQ_LIB_DEPENDS= librabbitmq.so:${PORTSDIR}/net/rabbitmq-c RABBITMQ_CONFIGURE_ENABLE= rabbitmq RABBITMQ_CONFIGURE_WITH= librabbitmq=${LOCALBASE} REDIS_LIB_DEPENDS= libhiredis.so:${PORTSDIR}/databases/hiredis REDIS_CONFIGURE_ENABLE= redis write_redis REDIS_CONFIGURE_WITH= libhiredis=${LOCALBASE} RIEMANN_LIB_DEPENDS= libprotobuf-c.so:${PORTSDIR}/devel/protobuf-c RIEMANN_CONFIGURE_ENABLE= write_riemann ROUTEROS_LIB_DEPENDS= librouteros.so:${PORTSDIR}/net/librouteros ROUTEROS_CONFIGURE_ENABLE= routeros ROUTEROS_CONFIGURE_WITH= librouteros=${LOCALBASE} RRDTOOL_LIB_DEPENDS= librrd.so:${PORTSDIR}/databases/rrdtool RRDTOOL_CONFIGURE_ENABLE= rrdcached rrdtool RRDTOOL_CONFIGURE_WITH= librrd=${LOCALBASE} STATGRAB_LIB_DEPENDS= libstatgrab.so:${PORTSDIR}/devel/libstatgrab STATGRAB_LIBS= `pkg-config --libs libstatgrab` STATGRAB_CONFIGURE_ENABLE= interface STATGRAB_CONFIGURE_WITH= libstatgrab=${LOCALBASE} SIGROK_USE= GNOME=glib20 SIGROK_CFLAGS= `pkg-config --cflags glib-2.0` SIGROK_LIB_DEPENDS= libsigrok.so:${PORTSDIR}/devel/libsigrok SIGROK_CONFIGURE_ENABLE= sigrok SIGROK_CONFIGURE_WITH= libsigrok SNMP_LIB_DEPENDS= libnetsnmp.so:${PORTSDIR}/net-mgmt/net-snmp SNMP_CONFIGURE_ENABLE= snmp SNMP_CONFIGURE_WITH= libnetsnmp STATSD_CONFIGURE_ENABLE= statsd TOKYOTYRANT_LIB_DEPENDS= libtokyotyrant.so:${PORTSDIR}/databases/tokyotyrant TOKYOTYRANT_CONFIGURE_ENABLE= tokyotyrant TOKYOTYRANT_CONFIGURE_WITH= libtokyotyrant=${LOCALBASE} VARNISH_LIB_DEPENDS= libvarnishapi.so:${PORTSDIR}/www/varnish4 VARNISH_CONFIGURE_ENABLE= varnish VARNISH_CONFIGURE_WITH= libvarnish=${LOCALBASE} -VARNISH_BROKEN= fails to compile with varnish4-4.1 VIRT_IMPLIES= XML VIRT_LIB_DEPENDS= libvirt.so:${PORTSDIR}/devel/libvirt VIRT_CONFIGURE_ENABLE= virt VIRT_CONFIGURE_WITH= virt=${LOCALBASE} -XML_LIB_DEPENDS= libxmms.so:${PORTSDIR}/multimedia/xmms +XML_LIB_DEPENDS= libxml2.so:${PORTSDIR}/textproc/libxml2 XML_CONFIGURE_WITH= libxml2=${LOCALBASE} XMMS_CFLAGS= `xmms-config --cflags` XMMS_LIB_DEPENDS= libxmms.so:${PORTSDIR}/multimedia/xmms XMMS_CONFIGURE_ENABLE= xmms XMMS_CONFIGURE_WITH= libxmms=${LOCALBASE} ZOOKEEPER_LIB_DEPENDS= libzookeeper_mt.so:${PORTSDIR}/devel/libzookeeper ZOOKEEPER_CONFIGURE_ENABLE= zookeeper ZOOKEEPER_CONFIGURE_WITH= libzookeeper=${LOCALBASE} # NOTE: Plugins without external dependencies CONFIGURE_ARGS+=--enable-aggregation \ --enable-apcups \ --enable-contextswitch \ --enable-cpu \ --enable-csv \ --enable-df \ --enable-disk \ --enable-dns \ --enable-email \ --enable-exec \ --enable-fhcount \ --enable-filecount \ --enable-load \ --enable-logfile \ --enable-match_empty_counter \ --enable-match_hashed \ --enable-match_regex \ --enable-match_timediff \ --enable-match_value \ --enable-mbmon \ --enable-memcached \ --enable-memory \ --enable-network \ --enable-ntpd \ --enable-openvpn \ --enable-powerdns \ --enable-pf \ --enable-processes \ --enable-statsd \ --enable-swap \ --enable-syslog \ --enable-table \ --enable-tail \ --enable-tail_csv \ --enable-target_notification \ --enable-target_replace \ --enable-target_scale \ --enable-target_set \ --enable-target_v5upgrade \ --enable-tcpconns \ --enable-teamspeak2 \ --enable-ted \ --enable-threshold \ --enable-unixsock \ --enable-uptime \ --enable-users \ --enable-uuid \ --enable-write_graphite \ --enable-write_log \ --enable-zfs_arc \ INSTALL_TARGET= install-strip SHEBANG_FILES= contrib/collection.cgi .include .if ${PORT_OPTIONS:MPERL} USES+= perl5 CONFIGURE_ARGS+=--with-perl=${PERL} --with-perl-bindings --enable-perl PLIST_SUB+= PERL="" .else CONFIGURE_ARGS+=--without-perl --without-perl-bindings --disable-perl PLIST_SUB+= PERL="@comment " .endif .if ${PORT_OPTIONS:MPYTHON} USES+= python:2 CONFIGURE_ARGS+=--with-python=${PYTHON_CMD} --enable-python PLIST_SUB+= PYTHON="" .else CONFIGURE_ARGS+=--without-python --disable-python PLIST_SUB+= PYTHON="@comment " .endif post-patch: @${REINPLACE_CMD} 's/-Werror//' \ ${WRKSRC}/configure.ac ${WRKSRC}/src/Makefile.am \ ${WRKSRC}/src/libcollectdclient/Makefile.am @${REINPLACE_CMD} \ -e 's;@prefix@/var/;/var/;' \ -e 's;/var/lib/;/var/db/;' \ -e 's;@localstatedir@/lib/;/var/db/;' \ ${WRKSRC}/src/collectd.conf.in \ ${WRKSRC}/src/collectd.conf.5 @${REINPLACE_CMD} \ -e 's;/etc/collection\.conf;${WWWDIR}/collection.conf;' \ ${WRKSRC}/contrib/collection.cgi @${REINPLACE_CMD} \ -e 's;/opt/collectd/var/lib;/var/db;' \ -e 's;/opt/collectd/lib;${PREFIX}/lib;' \ ${WRKSRC}/contrib/collection.conf post-install: ${MKDIR} ${STAGEDIR}/var/db/collectd post-install-CGI-on: ${MKDIR} ${STAGEDIR}${WWWDIR} ${INSTALL_SCRIPT} ${WRKSRC}/contrib/collection.cgi ${STAGEDIR}${WWWDIR}/ ${INSTALL_DATA} ${WRKSRC}/contrib/collection.conf \ ${STAGEDIR}${WWWDIR}/collection.conf.sample .include Index: head/net-mgmt/collectd5/files/patch-src__varnish.c =================================================================== --- head/net-mgmt/collectd5/files/patch-src__varnish.c (nonexistent) +++ head/net-mgmt/collectd5/files/patch-src__varnish.c (revision 401796) @@ -0,0 +1,806 @@ +commit 0eebd2655842fbb634f67afd44fa4fdcf4e6f189 +Author: Ruben Kerkhof +Date: Sat Jul 4 22:49:49 2015 +0200 + + varnish: fix leak on read + + Since VSM_Close doesn't free the object we leak a few bytes + every interval + +commit b208ddc7d08978f4cf52364c1935e94a0479ee42 +Author: Marc Fournier +Date: Wed Nov 4 21:12:36 2015 +0100 + + varnish: isolate varnish v2 code + + Segregating v2-specific code will allow reworking the v3 and v4 parts, + while ensuring backwards compatibility with v2. + + The downside is that this leads to a large chunk of mostly duplicate + code. That said, my suggestion would be to drop support for varnish v2 + in collectd 5.6. + + NB: this commit breaks v3 and v4 support. + +commit d010d9eff882765201359959a583033dae4b373c +Author: Marc Fournier +Date: Wed Nov 4 22:57:00 2015 +0100 + + varnish: rework v3 and v4 support + + By using VSC_Iter() to loop over the list of metrics exposed by varnish, + we can pick those we're interested *if they are found*. + + Not explicitly referring to metrics in the VSC_C_main struct makes the + plugin more resilient to small differences between minor varnish + versions. + + It also opens the possibility to monitor non-MAIN metrics, such as + per-backend or per-storage engine stats. + + This patch should be compatible with the previous way of doing, from the + user point of view. + + Fix #1302 + +commit 08bd4dd86e0fcb6828819cdf6bb3ae2115b1b8f4 +Author: Marc Fournier +Date: Thu Nov 5 10:23:19 2015 +0100 + + varnish: remove unused variable + + This was used in a DEBUG statement I didn't check in. + +--- src/varnish.c.orig 2015-03-10 14:14:45 UTC ++++ src/varnish.c +@@ -135,6 +135,397 @@ static int varnish_submit_derive (const + return (varnish_submit (plugin_instance, category, type, type_instance, value)); + } /* }}} int varnish_submit_derive */ + ++#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 ++static int varnish_monitor (void *priv, const struct VSC_point * const pt) /* {{{ */ ++{ ++ uint64_t val; ++ const user_config_t *conf; ++ const char *class; ++ const char *name; ++ ++ if (pt == NULL) ++ return (0); ++ ++ conf = priv; ++ ++#if HAVE_VARNISH_V4 ++ class = pt->section->fantom->type; ++ name = pt->desc->name; ++ ++ if (strcmp(class, "MAIN") != 0) ++ return (0); ++ ++#elif HAVE_VARNISH_V3 ++ class = pt->class; ++ name = pt->name; ++ ++ if (strcmp(class, "") != 0) ++ return (0); ++#endif ++ ++ val = *(const volatile uint64_t*) pt->ptr; ++ ++ if (conf->collect_cache) ++ { ++ if (strcmp(name, "cache_hit") == 0) ++ return varnish_submit_derive (conf->instance, "cache", "cache_result", "hit", val); ++ else if (strcmp(name, "cache_miss") == 0) ++ return varnish_submit_derive (conf->instance, "cache", "cache_result", "miss", val); ++ else if (strcmp(name, "cache_hitpass") == 0) ++ return varnish_submit_derive (conf->instance, "cache", "cache_result", "hitpass", val); ++ } ++ ++ if (conf->collect_connections) ++ { ++ if (strcmp(name, "client_conn") == 0) ++ return varnish_submit_derive (conf->instance, "connections", "connections", "accepted", val); ++ else if (strcmp(name, "client_drop") == 0) ++ return varnish_submit_derive (conf->instance, "connections", "connections", "dropped" , val); ++ else if (strcmp(name, "client_req") == 0) ++ return varnish_submit_derive (conf->instance, "connections", "connections", "received", val); ++ } ++ ++#ifdef HAVE_VARNISH_V3 ++ if (conf->collect_dirdns) ++ { ++ if (strcmp(name, "dir_dns_lookups") == 0) ++ return varnish_submit_derive (conf->instance, "dirdns", "cache_operation", "lookups", val); ++ else if (strcmp(name, "dir_dns_failed") == 0) ++ return varnish_submit_derive (conf->instance, "dirdns", "cache_result", "failed", val); ++ else if (strcmp(name, "dir_dns_hit") == 0) ++ return varnish_submit_derive (conf->instance, "dirdns", "cache_result", "hits", val); ++ else if (strcmp(name, "dir_dns_cache_full") == 0) ++ return varnish_submit_derive (conf->instance, "dirdns", "cache_result", "cache_full", val); ++ } ++#endif ++ ++ if (conf->collect_esi) ++ { ++ if (strcmp(name, "esi_errors") == 0) ++ return varnish_submit_derive (conf->instance, "esi", "total_operations", "error", val); ++ else if (strcmp(name, "esi_parse") == 0) ++ return varnish_submit_derive (conf->instance, "esi", "total_operations", "parsed", val); ++ else if (strcmp(name, "esi_warnings") == 0) ++ return varnish_submit_derive (conf->instance, "esi", "total_operations", "warning", val); ++ } ++ ++ if (conf->collect_backend) ++ { ++ if (strcmp(name, "backend_conn") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "success", val); ++ else if (strcmp(name, "backend_unhealthy") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "not-attempted", val); ++ else if (strcmp(name, "backend_busy") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "too-many", val); ++ else if (strcmp(name, "backend_fail") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "failures", val); ++ else if (strcmp(name, "backend_reuse") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "reuses", val); ++ else if (strcmp(name, "backend_toolate") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "was-closed", val); ++ else if (strcmp(name, "backend_recycle") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "recycled", val); ++ else if (strcmp(name, "backend_unused") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "unused", val); ++ else if (strcmp(name, "backend_retry") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "connections", "retries", val); ++ else if (strcmp(name, "backend_req") == 0) ++ return varnish_submit_derive (conf->instance, "backend", "http_requests", "requests", val); ++ else if (strcmp(name, "n_backend") == 0) ++ return varnish_submit_gauge (conf->instance, "backend", "backends", "n_backends", val); ++ } ++ ++ if (conf->collect_fetch) ++ { ++ if (strcmp(name, "fetch_head") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "head", val); ++ else if (strcmp(name, "fetch_length") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "length", val); ++ else if (strcmp(name, "fetch_chunked") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "chunked", val); ++ else if (strcmp(name, "fetch_eof") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "eof", val); ++ else if (strcmp(name, "fetch_bad") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "bad_headers", val); ++ else if (strcmp(name, "fetch_close") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "close", val); ++ else if (strcmp(name, "fetch_oldhttp") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "oldhttp", val); ++ else if (strcmp(name, "fetch_zero") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "zero", val); ++ else if (strcmp(name, "fetch_failed") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "failed", val); ++ else if (strcmp(name, "fetch_1xx") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_1xx", val); ++ else if (strcmp(name, "fetch_204") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_204", val); ++ else if (strcmp(name, "fetch_304") == 0) ++ return varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_304", val); ++ } ++ ++ if (conf->collect_hcb) ++ { ++ if (strcmp(name, "hcb_nolock") == 0) ++ return varnish_submit_derive (conf->instance, "hcb", "cache_operation", "lookup_nolock", val); ++ else if (strcmp(name, "hcb_lock") == 0) ++ return varnish_submit_derive (conf->instance, "hcb", "cache_operation", "lookup_lock", val); ++ else if (strcmp(name, "hcb_insert") == 0) ++ return varnish_submit_derive (conf->instance, "hcb", "cache_operation", "insert", val); ++ } ++ ++ if (conf->collect_objects) ++ { ++ if (strcmp(name, "n_expired") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "expired", val); ++ else if (strcmp(name, "n_lru_nuked") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_nuked", val); ++ else if (strcmp(name, "n_lru_saved") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_saved", val); ++ else if (strcmp(name, "n_lru_moved") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_moved", val); ++ else if (strcmp(name, "n_deathrow") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "deathrow", val); ++ else if (strcmp(name, "losthdr") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "header_overflow", val); ++ else if (strcmp(name, "n_obj_purged") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "purged", val); ++ else if (strcmp(name, "n_objsendfile") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "sent_sendfile", val); ++ else if (strcmp(name, "n_objwrite") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "sent_write", val); ++ else if (strcmp(name, "n_objoverflow") == 0) ++ return varnish_submit_derive (conf->instance, "objects", "total_objects", "workspace_overflow", val); ++ } ++ ++#if HAVE_VARNISH_V3 ++ if (conf->collect_ban) ++ { ++ if (strcmp(name, "n_ban") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "total", val); ++ else if (strcmp(name, "n_ban_add") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "added", val); ++ else if (strcmp(name, "n_ban_retire") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "deleted", val); ++ else if (strcmp(name, "n_ban_obj_test") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "objects_tested", val); ++ else if (strcmp(name, "n_ban_re_test") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "regexps_tested", val); ++ else if (strcmp(name, "n_ban_dups") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "duplicate", val); ++ } ++#endif ++#if HAVE_VARNISH_V4 ++ if (conf->collect_ban) ++ { ++ if (strcmp(name, "bans") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "total", val); ++ else if (strcmp(name, "bans_added") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "added", val); ++ else if (strcmp(name, "bans_obj") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "obj", val); ++ else if (strcmp(name, "bans_req") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "req", val); ++ else if (strcmp(name, "bans_completed") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "completed", val); ++ else if (strcmp(name, "bans_deleted") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "deleted", val); ++ else if (strcmp(name, "bans_tested") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "tested", val); ++ else if (strcmp(name, "bans_dups") == 0) ++ return varnish_submit_derive (conf->instance, "ban", "total_operations", "duplicate", val); ++ } ++#endif ++ ++ if (conf->collect_session) ++ { ++ if (strcmp(name, "sess_closed") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "closed", val); ++ else if (strcmp(name, "sess_pipeline") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "pipeline", val); ++ else if (strcmp(name, "sess_readahead") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "readahead", val); ++ else if (strcmp(name, "sess_conn") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "accepted", val); ++ else if (strcmp(name, "sess_drop") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "dropped", val); ++ else if (strcmp(name, "sess_fail") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "failed", val); ++ else if (strcmp(name, "sess_pipe_overflow") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "overflow", val); ++ else if (strcmp(name, "sess_queued") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "queued", val); ++ else if (strcmp(name, "sess_linger") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "linger", val); ++ else if (strcmp(name, "sess_herd") == 0) ++ return varnish_submit_derive (conf->instance, "session", "total_operations", "herd", val); ++ } ++ ++ if (conf->collect_shm) ++ { ++ if (strcmp(name, "shm_records") == 0) ++ return varnish_submit_derive (conf->instance, "shm", "total_operations", "records", val); ++ else if (strcmp(name, "shm_writes") == 0) ++ return varnish_submit_derive (conf->instance, "shm", "total_operations", "writes", val); ++ else if (strcmp(name, "shm_flushes") == 0) ++ return varnish_submit_derive (conf->instance, "shm", "total_operations", "flushes", val); ++ else if (strcmp(name, "shm_cont") == 0) ++ return varnish_submit_derive (conf->instance, "shm", "total_operations", "contention", val); ++ else if (strcmp(name, "shm_cycles") == 0) ++ return varnish_submit_derive (conf->instance, "shm", "total_operations", "cycles", val); ++ } ++ ++ if (conf->collect_sms) ++ { ++ if (strcmp(name, "sms_nreq") == 0) ++ return varnish_submit_derive (conf->instance, "sms", "total_requests", "allocator", val); ++ else if (strcmp(name, "sms_nobj") == 0) ++ return varnish_submit_gauge (conf->instance, "sms", "requests", "outstanding", val); ++ else if (strcmp(name, "sms_nbytes") == 0) ++ return varnish_submit_gauge (conf->instance, "sms", "bytes", "outstanding", val); ++ else if (strcmp(name, "sms_balloc") == 0) ++ return varnish_submit_derive (conf->instance, "sms", "total_bytes", "allocated", val); ++ else if (strcmp(name, "sms_bfree") == 0) ++ return varnish_submit_derive (conf->instance, "sms", "total_bytes", "free", val); ++ } ++ ++ if (conf->collect_struct) ++ { ++ if (strcmp(name, "n_sess_mem") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "current_sessions", "sess_mem", val); ++ else if (strcmp(name, "n_sess") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "current_sessions", "sess", val); ++ else if (strcmp(name, "n_object") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "object", val); ++ else if (strcmp(name, "n_vampireobject") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "vampireobject", val); ++ else if (strcmp(name, "n_objectcore") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "objectcore", val); ++ else if (strcmp(name, "n_waitinglist") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "waitinglist", val); ++ else if (strcmp(name, "n_objecthead") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "objecthead", val); ++ else if (strcmp(name, "n_smf") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "smf", val); ++ else if (strcmp(name, "n_smf_frag") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "smf_frag", val); ++ else if (strcmp(name, "n_smf_large") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "smf_large", val); ++ else if (strcmp(name, "n_vbe_conn") == 0) ++ return varnish_submit_gauge (conf->instance, "struct", "objects", "vbe_conn", val); ++ } ++ ++ if (conf->collect_totals) ++ { ++ if (strcmp(name, "s_sess") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_sessions", "sessions", val); ++ else if (strcmp(name, "s_req") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_requests", "requests", val); ++ else if (strcmp(name, "s_pipe") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "pipe", val); ++ else if (strcmp(name, "s_pass") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "pass", val); ++ else if (strcmp(name, "s_fetch") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "fetches", val); ++ else if (strcmp(name, "s_synth") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "synth", val); ++ else if (strcmp(name, "s_req_hdrbytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "req_header", val); ++ else if (strcmp(name, "s_req_bodybytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "req_body", val); ++ else if (strcmp(name, "s_resp_hdrbytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "resp_header", val); ++ else if (strcmp(name, "s_resp_bodybytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "resp_body", val); ++ else if (strcmp(name, "s_pipe_hdrbytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_header", val); ++ else if (strcmp(name, "s_pipe_in") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_in", val); ++ else if (strcmp(name, "s_pipe_out") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_out", val); ++ else if (strcmp(name, "n_purges") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "purges", val); ++ else if (strcmp(name, "s_hdrbytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "header-bytes", val); ++ else if (strcmp(name, "s_bodybytes") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_bytes", "body-bytes", val); ++ else if (strcmp(name, "n_gzip") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "gzip", val); ++ else if (strcmp(name, "n_gunzip") == 0) ++ return varnish_submit_derive (conf->instance, "totals", "total_operations", "gunzip", val); ++ } ++ ++ if (conf->collect_uptime) ++ { ++ if (strcmp(name, "uptime") == 0) ++ return varnish_submit_gauge (conf->instance, "uptime", "uptime", "client_uptime", val); ++ } ++ ++ if (conf->collect_vcl) ++ { ++ if (strcmp(name, "n_vcl") == 0) ++ return varnish_submit_gauge (conf->instance, "vcl", "vcl", "total_vcl", val); ++ else if (strcmp(name, "n_vcl_avail") == 0) ++ return varnish_submit_gauge (conf->instance, "vcl", "vcl", "avail_vcl", val); ++ else if (strcmp(name, "n_vcl_discard") == 0) ++ return varnish_submit_gauge (conf->instance, "vcl", "vcl", "discarded_vcl", val); ++ else if (strcmp(name, "vmods") == 0) ++ return varnish_submit_gauge (conf->instance, "vcl", "objects", "vmod", val); ++ } ++ ++ if (conf->collect_workers) ++ { ++ if (strcmp(name, "threads") == 0) ++ return varnish_submit_gauge (conf->instance, "workers", "threads", "worker", val); ++ else if (strcmp(name, "threads_created") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "created", val); ++ else if (strcmp(name, "threads_failed") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "failed", val); ++ else if (strcmp(name, "threads_limited") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "limited", val); ++ else if (strcmp(name, "threads_destroyed") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "dropped", val); ++ else if (strcmp(name, "thread_queue_len") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "queue_length", "threads", val); ++ else if (strcmp(name, "n_wrk") == 0) ++ return varnish_submit_gauge (conf->instance, "workers", "threads", "worker", val); ++ else if (strcmp(name, "n_wrk_create") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "created", val); ++ else if (strcmp(name, "n_wrk_failed") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "failed", val); ++ else if (strcmp(name, "n_wrk_max") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "limited", val); ++ else if (strcmp(name, "n_wrk_drop") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_threads", "dropped", val); ++ else if (strcmp(name, "n_wrk_queue") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_requests", "queued", val); ++ else if (strcmp(name, "n_wrk_overflow") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_requests", "overflowed", val); ++ else if (strcmp(name, "n_wrk_queued") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_requests", "queued", val); ++ else if (strcmp(name, "n_wrk_lqueue") == 0) ++ return varnish_submit_derive (conf->instance, "workers", "total_requests", "queue_length", val); ++ } ++ ++#if HAVE_VARNISH_V4 ++ if (conf->collect_vsm) ++ { ++ if (strcmp(name, "vsm_free") == 0) ++ return varnish_submit_gauge (conf->instance, "vsm", "bytes", "free", val); ++ else if (strcmp(name, "vsm_used") == 0) ++ return varnish_submit_gauge (conf->instance, "vsm", "bytes", "used", val); ++ else if (strcmp(name, "vsm_cooling") == 0) ++ return varnish_submit_gauge (conf->instance, "vsm", "bytes", "cooling", val); ++ else if (strcmp(name, "vsm_overflow") == 0) ++ return varnish_submit_gauge (conf->instance, "vsm", "bytes", "overflow", val); ++ else if (strcmp(name, "vsm_overflowed") == 0) ++ return varnish_submit_derive (conf->instance, "vsm", "total_bytes", "overflowed", val); ++ } ++#endif ++ ++ return (0); ++ ++} /* }}} static int varnish_monitor */ ++#else /* if HAVE_VARNISH_V2 */ + static void varnish_monitor (const user_config_t *conf, /* {{{ */ + const c_varnish_stats_t *stats) + { +@@ -150,41 +541,20 @@ static void varnish_monitor (const user_ + + if (conf->collect_connections) + { +-#ifndef HAVE_VARNISH_V4 + /* Client connections accepted */ + varnish_submit_derive (conf->instance, "connections", "connections", "accepted", stats->client_conn); + /* Connection dropped, no sess */ + varnish_submit_derive (conf->instance, "connections", "connections", "dropped" , stats->client_drop); +-#endif + /* Client requests received */ + varnish_submit_derive (conf->instance, "connections", "connections", "received", stats->client_req); + } + +-#ifdef HAVE_VARNISH_V3 +- if (conf->collect_dirdns) +- { +- /* DNS director lookups */ +- varnish_submit_derive (conf->instance, "dirdns", "cache_operation", "lookups", stats->dir_dns_lookups); +- /* DNS director failed lookups */ +- varnish_submit_derive (conf->instance, "dirdns", "cache_result", "failed", stats->dir_dns_failed); +- /* DNS director cached lookups hit */ +- varnish_submit_derive (conf->instance, "dirdns", "cache_result", "hits", stats->dir_dns_hit); +- /* DNS director full dnscache */ +- varnish_submit_derive (conf->instance, "dirdns", "cache_result", "cache_full", stats->dir_dns_cache_full); +- } +-#endif +- + if (conf->collect_esi) + { + /* ESI parse errors (unlock) */ + varnish_submit_derive (conf->instance, "esi", "total_operations", "error", stats->esi_errors); +-#if HAVE_VARNISH_V2 + /* Objects ESI parsed (unlock) */ + varnish_submit_derive (conf->instance, "esi", "total_operations", "parsed", stats->esi_parse); +-#else +- /* ESI parse warnings (unlock) */ +- varnish_submit_derive (conf->instance, "esi", "total_operations", "warning", stats->esi_warnings); +-#endif + } + + if (conf->collect_backend) +@@ -203,13 +573,8 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "backend", "connections", "was-closed" , stats->backend_toolate); + /* Backend conn. recycles */ + varnish_submit_derive (conf->instance, "backend", "connections", "recycled" , stats->backend_recycle); +-#if HAVE_VARNISH_V2 + /* Backend conn. unused */ + varnish_submit_derive (conf->instance, "backend", "connections", "unused" , stats->backend_unused); +-#else +- /* Backend conn. retry */ +- varnish_submit_derive (conf->instance, "backend", "connections", "retries" , stats->backend_retry); +-#endif + /* Backend requests mades */ + varnish_submit_derive (conf->instance, "backend", "http_requests", "requests" , stats->backend_req); + /* N backends */ +@@ -236,14 +601,6 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "fetch", "http_requests", "zero" , stats->fetch_zero); + /* Fetch failed */ + varnish_submit_derive (conf->instance, "fetch", "http_requests", "failed" , stats->fetch_failed); +-#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 +- /* Fetch no body (1xx) */ +- varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_1xx", stats->fetch_1xx); +- /* Fetch no body (204) */ +- varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_204", stats->fetch_204); +- /* Fetch no body (304) */ +- varnish_submit_derive (conf->instance, "fetch", "http_requests", "no_body_304", stats->fetch_304); +-#endif + } + + if (conf->collect_hcb) +@@ -262,32 +619,22 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "objects", "total_objects", "expired", stats->n_expired); + /* N LRU nuked objects */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_nuked", stats->n_lru_nuked); +-#if HAVE_VARNISH_V2 + /* N LRU saved objects */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_saved", stats->n_lru_saved); +-#endif + /* N LRU moved objects */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "lru_moved", stats->n_lru_moved); +-#if HAVE_VARNISH_V2 + /* N objects on deathrow */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "deathrow", stats->n_deathrow); +-#endif + /* HTTP header overflows */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "header_overflow", stats->losthdr); +-#if HAVE_VARNISH_V4 +- /* N purged objects */ +- varnish_submit_derive (conf->instance, "objects", "total_objects", "purged", stats->n_obj_purged); +-#else + /* Objects sent with sendfile */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "sent_sendfile", stats->n_objsendfile); + /* Objects sent with write */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "sent_write", stats->n_objwrite); + /* Objects overflowing workspace */ + varnish_submit_derive (conf->instance, "objects", "total_objects", "workspace_overflow", stats->n_objoverflow); +-#endif + } + +-#if HAVE_VARNISH_V2 + if (conf->collect_purge) + { + /* N total active purges */ +@@ -303,45 +650,6 @@ static void varnish_monitor (const user_ + /* N duplicate purges removed */ + varnish_submit_derive (conf->instance, "purge", "total_operations", "duplicate", stats->n_purge_dups); + } +-#endif +-#if HAVE_VARNISH_V3 +- if (conf->collect_ban) +- { +- /* N total active bans */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "total", stats->n_ban); +- /* N new bans added */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "added", stats->n_ban_add); +- /* N old bans deleted */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "deleted", stats->n_ban_retire); +- /* N objects tested */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "objects_tested", stats->n_ban_obj_test); +- /* N regexps tested against */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "regexps_tested", stats->n_ban_re_test); +- /* N duplicate bans removed */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "duplicate", stats->n_ban_dups); +- } +-#endif +-#if HAVE_VARNISH_V4 +- if (conf->collect_ban) +- { +- /* N total active bans */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "total", stats->bans); +- /* N new bans added */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "added", stats->bans_added); +- /* N bans using obj */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "obj", stats->bans_obj); +- /* N bans using req */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "req", stats->bans_req); +- /* N new bans completed */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "completed", stats->bans_completed); +- /* N old bans deleted */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "deleted", stats->bans_deleted); +- /* N objects tested */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "tested", stats->bans_tested); +- /* N duplicate bans removed */ +- varnish_submit_derive (conf->instance, "ban", "total_operations", "duplicate", stats->bans_dups); +- } +-#endif + + if (conf->collect_session) + { +@@ -351,21 +659,8 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "session", "total_operations", "pipeline", stats->sess_pipeline); + /* Session Read Ahead */ + varnish_submit_derive (conf->instance, "session", "total_operations", "readahead", stats->sess_readahead); +-#if HAVE_VARNISH_V4 +- /* Sessions accepted */ +- varnish_submit_derive (conf->instance, "session", "total_operations", "accepted", stats->sess_conn); +- /* Sessions dropped for thread */ +- varnish_submit_derive (conf->instance, "session", "total_operations", "dropped", stats->sess_drop); +- /* Sessions accept failure */ +- varnish_submit_derive (conf->instance, "session", "total_operations", "failed", stats->sess_fail); +- /* Sessions pipe overflow */ +- varnish_submit_derive (conf->instance, "session", "total_operations", "overflow", stats->sess_pipe_overflow); +- /* Sessions queued for thread */ +- varnish_submit_derive (conf->instance, "session", "total_operations", "queued", stats->sess_queued); +-#else + /* Session Linger */ + varnish_submit_derive (conf->instance, "session", "total_operations", "linger", stats->sess_linger); +-#endif + /* Session herd */ + varnish_submit_derive (conf->instance, "session", "total_operations", "herd", stats->sess_herd); + } +@@ -384,7 +679,6 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "shm", "total_operations", "cycles" , stats->shm_cycles); + } + +-#if HAVE_VARNISH_V2 + if (conf->collect_sm) + { + /* allocator requests */ +@@ -410,7 +704,6 @@ static void varnish_monitor (const user_ + /* SMA bytes free */ + varnish_submit_derive (conf->instance, "sma", "total_bytes", "free" , stats->sma_bfree); + } +-#endif + + if (conf->collect_sms) + { +@@ -428,25 +721,14 @@ static void varnish_monitor (const user_ + + if (conf->collect_struct) + { +-#if !HAVE_VARNISH_V4 + /* N struct sess_mem */ + varnish_submit_gauge (conf->instance, "struct", "current_sessions", "sess_mem", stats->n_sess_mem); + /* N struct sess */ + varnish_submit_gauge (conf->instance, "struct", "current_sessions", "sess", stats->n_sess); +-#endif + /* N struct object */ + varnish_submit_gauge (conf->instance, "struct", "objects", "object", stats->n_object); +-#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 +- /* N unresurrected objects */ +- varnish_submit_gauge (conf->instance, "struct", "objects", "vampireobject", stats->n_vampireobject); +- /* N struct objectcore */ +- varnish_submit_gauge (conf->instance, "struct", "objects", "objectcore", stats->n_objectcore); +- /* N struct waitinglist */ +- varnish_submit_gauge (conf->instance, "struct", "objects", "waitinglist", stats->n_waitinglist); +-#endif + /* N struct objecthead */ + varnish_submit_gauge (conf->instance, "struct", "objects", "objecthead", stats->n_objecthead); +-#ifdef HAVE_VARNISH_V2 + /* N struct smf */ + varnish_submit_gauge (conf->instance, "struct", "objects", "smf", stats->n_smf); + /* N small free smf */ +@@ -455,7 +737,6 @@ static void varnish_monitor (const user_ + varnish_submit_gauge (conf->instance, "struct", "objects", "smf_large", stats->n_smf_large); + /* N struct vbe_conn */ + varnish_submit_gauge (conf->instance, "struct", "objects", "vbe_conn", stats->n_vbe_conn); +-#endif + } + + if (conf->collect_totals) +@@ -470,47 +751,12 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "totals", "total_operations", "pass", stats->s_pass); + /* Total fetch */ + varnish_submit_derive (conf->instance, "totals", "total_operations", "fetches", stats->s_fetch); +-#if HAVE_VARNISH_V4 +- /* Total synth */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "synth", stats->s_synth); +- /* Request header bytes */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "req_header", stats->s_req_hdrbytes); +- /* Request body byte */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "req_body", stats->s_req_bodybytes); +- /* Response header bytes */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "resp_header", stats->s_resp_hdrbytes); +- /* Response body byte */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "resp_body", stats->s_resp_bodybytes); +- /* Pipe request header bytes */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_header", stats->s_pipe_hdrbytes); +- /* Piped bytes from client */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_in", stats->s_pipe_in); +- /* Piped bytes to client */ +- varnish_submit_derive (conf->instance, "totals", "total_bytes", "pipe_out", stats->s_pipe_out); +- /* Number of purge operations */ +- varnish_submit_derive (conf->instance, "totals", "total_operations", "purges", stats->n_purges); +-#else + /* Total header bytes */ + varnish_submit_derive (conf->instance, "totals", "total_bytes", "header-bytes", stats->s_hdrbytes); + /* Total body byte */ + varnish_submit_derive (conf->instance, "totals", "total_bytes", "body-bytes", stats->s_bodybytes); +-#endif +-#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 +- /* Gzip operations */ +- varnish_submit_derive (conf->instance, "totals", "total_operations", "gzip", stats->n_gzip); +- /* Gunzip operations */ +- varnish_submit_derive (conf->instance, "totals", "total_operations", "gunzip", stats->n_gunzip); +-#endif + } + +-#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 +- if (conf->collect_uptime) +- { +- /* Client uptime */ +- varnish_submit_gauge (conf->instance, "uptime", "uptime", "client_uptime", stats->uptime); +- } +-#endif +- + if (conf->collect_vcl) + { + /* N vcl total */ +@@ -519,28 +765,10 @@ static void varnish_monitor (const user_ + varnish_submit_gauge (conf->instance, "vcl", "vcl", "avail_vcl", stats->n_vcl_avail); + /* N vcl discarded */ + varnish_submit_gauge (conf->instance, "vcl", "vcl", "discarded_vcl", stats->n_vcl_discard); +-#if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 +- /* Loaded VMODs */ +- varnish_submit_gauge (conf->instance, "vcl", "objects", "vmod", stats->vmods); +-#endif + } + + if (conf->collect_workers) + { +-#ifdef HAVE_VARNISH_V4 +- /* total number of threads */ +- varnish_submit_gauge (conf->instance, "workers", "threads", "worker", stats->threads); +- /* threads created */ +- varnish_submit_derive (conf->instance, "workers", "total_threads", "created", stats->threads_created); +- /* thread creation failed */ +- varnish_submit_derive (conf->instance, "workers", "total_threads", "failed", stats->threads_failed); +- /* threads hit max */ +- varnish_submit_derive (conf->instance, "workers", "total_threads", "limited", stats->threads_limited); +- /* threads destroyed */ +- varnish_submit_derive (conf->instance, "workers", "total_threads", "dropped", stats->threads_destroyed); +- /* length of session queue */ +- varnish_submit_derive (conf->instance, "workers", "queue_length", "threads", stats->thread_queue_len); +-#else + /* worker threads */ + varnish_submit_gauge (conf->instance, "workers", "threads", "worker", stats->n_wrk); + /* worker threads created */ +@@ -551,37 +779,14 @@ static void varnish_monitor (const user_ + varnish_submit_derive (conf->instance, "workers", "total_threads", "limited", stats->n_wrk_max); + /* dropped work requests */ + varnish_submit_derive (conf->instance, "workers", "total_threads", "dropped", stats->n_wrk_drop); +-#ifdef HAVE_VARNISH_V2 + /* queued work requests */ + varnish_submit_derive (conf->instance, "workers", "total_requests", "queued", stats->n_wrk_queue); + /* overflowed work requests */ + varnish_submit_derive (conf->instance, "workers", "total_requests", "overflowed", stats->n_wrk_overflow); +-#else /* HAVE_VARNISH_V3 */ +- /* queued work requests */ +- varnish_submit_derive (conf->instance, "workers", "total_requests", "queued", stats->n_wrk_queued); +- /* work request queue length */ +- varnish_submit_derive (conf->instance, "workers", "total_requests", "queue_length", stats->n_wrk_lqueue); +-#endif +-#endif +- } +- +-#if HAVE_VARNISH_V4 +- if (conf->collect_vsm) +- { +- /* Free VSM space */ +- varnish_submit_gauge (conf->instance, "vsm", "bytes", "free", stats->vsm_free); +- /* Used VSM space */ +- varnish_submit_gauge (conf->instance, "vsm", "bytes", "used", stats->vsm_used); +- /* Cooling VSM space */ +- varnish_submit_gauge (conf->instance, "vsm", "bytes", "cooling", stats->vsm_cooling); +- /* Overflow VSM space */ +- varnish_submit_gauge (conf->instance, "vsm", "bytes", "overflow", stats->vsm_overflow); +- /* Total overflowed VSM space */ +- varnish_submit_derive (conf->instance, "vsm", "total_bytes", "overflowed", stats->vsm_overflowed); + } +-#endif + + } /* }}} void varnish_monitor */ ++#endif + + #if HAVE_VARNISH_V3 || HAVE_VARNISH_V4 + static int varnish_read (user_data_t *ud) /* {{{ */ +@@ -632,8 +837,12 @@ static int varnish_read (user_data_t *ud + stats = VSC_Main(vd, NULL); + #endif + +- varnish_monitor (conf, stats); +- VSM_Close (vd); ++#if HAVE_VARNISH_V3 ++ VSC_Iter (vd, varnish_monitor, conf); ++#else /* if HAVE_VARNISH_V4 */ ++ VSC_Iter (vd, NULL, varnish_monitor, conf); ++#endif ++ VSM_Delete (vd); + + return (0); + } /* }}} */ Property changes on: head/net-mgmt/collectd5/files/patch-src__varnish.c ___________________________________________________________________ Added: fbsd:nokeywords ## -0,0 +1 ## +yes \ No newline at end of property Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property