This adds a PMDA for the Unbound DNS resolver. Currently exposing 140
metrics gathered from Unbounds "unbound-control stats" command. It's
missing the per thread metrics, but I plan on adding these at a later
point.
Signed-off-by: Jan-Frode Myklebust <janfrode@xxxxxxxxx>
---
src/pmdas/unbound/Install | 28 +
src/pmdas/unbound/Remove | 25 +
src/pmdas/unbound/pmdaunbound.python | 1344 ++++++++++++++++++++++++++++++++++
3 files changed, 1397 insertions(+)
create mode 100755 src/pmdas/unbound/Install
create mode 100755 src/pmdas/unbound/Remove
create mode 100644 src/pmdas/unbound/pmdaunbound.python
diff --git a/src/pmdas/unbound/Install b/src/pmdas/unbound/Install
new file mode 100755
index 0000000..a375fbe
--- /dev/null
+++ b/src/pmdas/unbound/Install
@@ -0,0 +1,28 @@
+#! /bin/sh
+#
+# Copyright (c) 2014 Red Hat.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+# for more details.
+#
+# Install the Unbound PMDA
+#
+
+. $PCP_DIR/etc/pcp.env
+. $PCP_SHARE_DIR/lib/pmdaproc.sh
+
+iam=unbound
+python_opt=true
+daemon_opt=false
+forced_restart=true
+
+pmdaSetup
+pmdaInstall
+exit 0
diff --git a/src/pmdas/unbound/Remove b/src/pmdas/unbound/Remove
new file mode 100755
index 0000000..7ff291f
--- /dev/null
+++ b/src/pmdas/unbound/Remove
@@ -0,0 +1,25 @@
+#! /bin/sh
+#
+# Copyright (c) 2014 Red Hat.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+# for more details.
+#
+# Remove the Linux Unbound PMDA
+#
+
+. $PCP_DIR/etc/pcp.env
+. $PCP_SHARE_DIR/lib/pmdaproc.sh
+
+iam=unbound
+
+pmdaSetup
+pmdaRemove
+exit 0
diff --git a/src/pmdas/unbound/pmdaunbound.python
b/src/pmdas/unbound/pmdaunbound.python
new file mode 100644
index 0000000..6575bb2
--- /dev/null
+++ b/src/pmdas/unbound/pmdaunbound.python
@@ -0,0 +1,1344 @@
+'''
+Performance Metrics Domain Agent exporting Unbound statistics.
+'''
+
+import cpmapi as c_api
+from pcp.pmapi import pmUnits
+from pcp.pmda import PMDA, pmdaMetric, pmdaIndom
+from subprocess import Popen, PIPE
+import string
+
+class UnboundPMDA(PMDA):
+ '''
+ Performance Metrics Domain Agent exporting Unbound metrics.
+ Install it and make basic use of it if you use Unbound, as follows:
+
+ # $PCP_PMDAS_DIR/unbound/Install
+ $ pminfo -fmdtT unbound
+ '''
+
+ def unbound_fetch(self):
+ '''
+ Called once per PCP "fetch" PDU from pmcd(1)
+ Iterates over the unbound statistics,
+ '''
+ p = Popen(['/usr/sbin/unbound-control', 'stats_noreset'], stdin=PIPE,
stdout=PIPE, stderr=PIPE)
+ p.wait()
+ stdout, stderr = p.communicate()
+ stdoutlines = string.split(stdout.strip(), '\n')
+ for line in stdoutlines:
+ keyval = string.split(line, '=')
+ if keyval[0].startswith( 'histogram' ):
+ # Replace "." with "_" to avoid splitting metric name in
multiple sub sections
+ keyval[0] = "histogram." + "_".join(str(v) for v in
keyval[0].split(".")[1:])
+ # only try to populate known metrics:
+ if keyval[0] in self.values:
+ if (
+ keyval[0] == "time.now" or
+ keyval[0] == "time.up" or
+ keyval[0] == "time.elapsed" or
+ keyval[0] == "total.requestlist.avg" or
+ keyval[0] == "total.recursion.time.avg" or
+ keyval[0] == "total.recursion.time.median"
+ ):
+ self.values[keyval[0]] = float(keyval[1])
+ else:
+ self.values[keyval[0]] = long(keyval[1])
+
+ def unbound_fetch_callback(self, cluster, item, inst):
+ '''
+ Main fetch callback - looks up value associated with requested PMID
+ (from unbound_fetch), converts units if needed, then returns a list of
+ value,status (single pair) for the requested pmid
+ '''
+ # self.log("fetch callback for %d.%d[%d]" % (cluster, item, inst))
+ if inst != c_api.PM_IN_NULL:
+ return [c_api.PM_ERR_INST, 0]
+ elif cluster != 0:
+ return [c_api.PM_ERR_PMID, 0]
+ if item >= 0 and item < self.nmetrics and self.patherrors == 1:
+ return [c_api.PM_ERR_AGAIN, 0]
+
+ if item == 0:
+ return [self.values['total.num.queries'], 1]
+ elif item == 1:
+ return [self.values['total.num.cachehits'], 1]
+ elif item == 2:
+ return [self.values['total.num.cachemiss'], 1]
+ elif item == 3:
+ return [self.values['total.num.prefetch'], 1]
+ elif item == 4:
+ return [self.values['total.num.recursivereplies'], 1]
+ elif item == 5:
+ return [self.values['total.requestlist.avg'], 1]
+ elif item == 6:
+ return [self.values['total.requestlist.max'], 1]
+ elif item == 7:
+ return [self.values['total.requestlist.overwritten'], 1]
+ elif item == 8:
+ return [self.values['total.requestlist.exceeded'], 1]
+ elif item == 9:
+ return [self.values['total.requestlist.current.all'], 1]
+ elif item == 10:
+ return [self.values['total.requestlist.current.user'], 1]
+ elif item == 11:
+ return [self.values['total.recursion.time.avg'], 1]
+ elif item == 12:
+ return [self.values['total.recursion.time.median'], 1]
+ elif item == 13:
+ return [self.values['unwanted.queries'], 1]
+ elif item == 14:
+ return [self.values['unwanted.replies'], 1]
+ elif item == 15:
+ return [self.values['num.answer.rcode.NOERROR'], 1]
+ elif item == 16:
+ return [self.values['num.answer.rcode.FORMERR'], 1]
+ elif item == 17:
+ return [self.values['num.answer.rcode.SERVFAIL'], 1]
+ elif item == 18:
+ return [self.values['num.answer.rcode.NXDOMAIN'], 1]
+ elif item == 19:
+ return [self.values['num.answer.rcode.REFUSED'], 1]
+ elif item == 20:
+ return [self.values['num.answer.rcode.nodata'], 1]
+ elif item == 21:
+ return [self.values['num.answer.secure'], 1]
+ elif item == 22:
+ return [self.values['num.answer.bogus'], 1]
+ elif item == 23:
+ return [self.values['num.rrset.bogus'], 1]
+ elif item == 24:
+ return [self.values['num.query.type.TYPE0'], 1]
+ elif item == 25:
+ return [self.values['num.query.type.A'], 1]
+ elif item == 26:
+ return [self.values['num.query.type.NS'], 1]
+ elif item == 27:
+ return [self.values['num.query.type.MD'], 1]
+ elif item == 28:
+ return [self.values['num.query.type.MF'], 1]
+ elif item == 29:
+ return [self.values['num.query.type.CNAME'], 1]
+ elif item == 30:
+ return [self.values['num.query.type.SOA'], 1]
+ elif item == 31:
+ return [self.values['num.query.type.MB'], 1]
+ elif item == 32:
+ return [self.values['num.query.type.MG'], 1]
+ elif item == 33:
+ return [self.values['num.query.type.MR'], 1]
+ elif item == 34:
+ return [self.values['num.query.type.NULL'], 1]
+ elif item == 35:
+ return [self.values['num.query.type.WKS'], 1]
+ elif item == 36:
+ return [self.values['num.query.type.PTR'], 1]
+ elif item == 37:
+ return [self.values['num.query.type.HINFO'], 1]
+ elif item == 38:
+ return [self.values['num.query.type.MINFO'], 1]
+ elif item == 39:
+ return [self.values['num.query.type.MX'], 1]
+ elif item == 40:
+ return [self.values['num.query.type.TXT'], 1]
+ elif item == 41:
+ return [self.values['num.query.type.RP'], 1]
+ elif item == 42:
+ return [self.values['num.query.type.AFSDB'], 1]
+ elif item == 43:
+ return [self.values['num.query.type.X25'], 1]
+ elif item == 44:
+ return [self.values['num.query.type.ISDN'], 1]
+ elif item == 45:
+ return [self.values['num.query.type.RT'], 1]
+ elif item == 46:
+ return [self.values['num.query.type.AAAA'], 1]
+ elif item == 47:
+ return [self.values['num.query.type.SRV'], 1]
+ elif item == 48:
+ return [self.values['num.query.type.ATMA'], 1]
+ elif item == 49:
+ return [self.values['num.query.type.NAPTR'], 1]
+ elif item == 50:
+ return [self.values['num.query.type.A6'], 1]
+ elif item == 51:
+ return [self.values['num.query.type.DS'], 1]
+ elif item == 52:
+ return [self.values['num.query.type.SSHFP'], 1]
+ elif item == 53:
+ return [self.values['num.query.type.RRSIG'], 1]
+ elif item == 54:
+ return [self.values['num.query.type.NSEC'], 1]
+ elif item == 55:
+ return [self.values['num.query.type.DNSKEY'], 1]
+ elif item == 56:
+ return [self.values['num.query.type.TLSA'], 1]
+ elif item == 57:
+ return [self.values['num.query.type.TYPE65'], 1]
+ elif item == 58:
+ return [self.values['num.query.type.TYPE67'], 1]
+ elif item == 59:
+ return [self.values['num.query.type.TYPE76'], 1]
+ elif item == 60:
+ return [self.values['num.query.type.TYPE97'], 1]
+ elif item == 61:
+ return [self.values['num.query.type.SPF'], 1]
+ elif item == 62:
+ return [self.values['num.query.type.TYPE103'], 1]
+ elif item == 63:
+ return [self.values['num.query.type.EUI64'], 1]
+ elif item == 64:
+ return [self.values['num.query.type.TYPE110'], 1]
+ elif item == 65:
+ return [self.values['num.query.type.TYPE117'], 1]
+ elif item == 66:
+ return [self.values['num.query.type.TYPE119'], 1]
+ elif item == 67:
+ return [self.values['num.query.type.TYPE123'], 1]
+ elif item == 68:
+ return [self.values['num.query.type.TKEY'], 1]
+ elif item == 69:
+ return [self.values['num.query.type.IXFR'], 1]
+ elif item == 70:
+ return [self.values['num.query.type.AXFR'], 1]
+ elif item == 71:
+ return [self.values['num.query.type.ANY'], 1]
+ elif item == 72:
+ return [self.values['num.query.type.other'], 1]
+ elif item == 73:
+ return [self.values['num.query.class.CLASS0'], 1]
+ elif item == 74:
+ return [self.values['num.query.class.IN'], 1]
+ elif item == 75:
+ return [self.values['num.query.class.CH'], 1]
+ elif item == 76:
+ return [self.values['num.query.class.CLASS6'], 1]
+ elif item == 77:
+ return [self.values['num.query.class.CLASS65'], 1]
+ elif item == 78:
+ return [self.values['num.query.class.CLASS115'], 1]
+ elif item == 79:
+ return [self.values['num.query.class.CLASS240'], 1]
+ elif item == 80:
+ return [self.values['num.query.class.ANY'], 1]
+ elif item == 81:
+ return [self.values['num.query.class.other'], 1]
+ elif item == 82:
+ return [self.values['num.query.opcode.QUERY'], 1]
+ elif item == 83:
+ return [self.values['num.query.tcp'], 1]
+ elif item == 84:
+ return [self.values['num.query.ipv6'], 1]
+ elif item == 85:
+ return [self.values['num.query.flags.QR'], 1]
+ elif item == 86:
+ return [self.values['num.query.flags.AA'], 1]
+ elif item == 87:
+ return [self.values['num.query.flags.TC'], 1]
+ elif item == 88:
+ return [self.values['num.query.flags.RD'], 1]
+ elif item == 89:
+ return [self.values['num.query.flags.RA'], 1]
+ elif item == 90:
+ return [self.values['num.query.flags.Z'], 1]
+ elif item == 91:
+ return [self.values['num.query.flags.AD'], 1]
+ elif item == 92:
+ return [self.values['num.query.flags.CD'], 1]
+ elif item == 93:
+ return [self.values['num.query.edns.present'], 1]
+ elif item == 94:
+ return [self.values['num.query.edns.DO'], 1]
+ elif item == 95:
+ return [self.values['mem.total.sbrk'], 1]
+ elif item == 96:
+ return [self.values['mem.cache.rrset'], 1]
+ elif item == 97:
+ return [self.values['mem.cache.message'], 1]
+ elif item == 98:
+ return [self.values['mem.mod.iterator'], 1]
+ elif item == 99:
+ return [self.values['mem.mod.validator'], 1]
+ elif item == 100:
+ return [self.values['histogram.000000_000000_to_000000_000001'], 1]
+ elif item == 101:
+ return [self.values['histogram.000000_000001_to_000000_000002'], 1]
+ elif item == 102:
+ return [self.values['histogram.000000_000002_to_000000_000004'], 1]
+ elif item == 103:
+ return [self.values['histogram.000000_000004_to_000000_000008'], 1]
+ elif item == 104:
+ return [self.values['histogram.000000_000008_to_000000_000016'], 1]
+ elif item == 105:
+ return [self.values['histogram.000000_000016_to_000000_000032'], 1]
+ elif item == 106:
+ return [self.values['histogram.000000_000032_to_000000_000064'], 1]
+ elif item == 107:
+ return [self.values['histogram.000000_000064_to_000000_000128'], 1]
+ elif item == 108:
+ return [self.values['histogram.000000_000128_to_000000_000256'], 1]
+ elif item == 109:
+ return [self.values['histogram.000000_000256_to_000000_000512'], 1]
+ elif item == 110:
+ return [self.values['histogram.000000_000512_to_000000_001024'], 1]
+ elif item == 111:
+ return [self.values['histogram.000000_001024_to_000000_002048'], 1]
+ elif item == 112:
+ return [self.values['histogram.000000_002048_to_000000_004096'], 1]
+ elif item == 113:
+ return [self.values['histogram.000000_004096_to_000000_008192'], 1]
+ elif item == 114:
+ return [self.values['histogram.000000_008192_to_000000_016384'], 1]
+ elif item == 115:
+ return [self.values['histogram.000000_016384_to_000000_032768'], 1]
+ elif item == 116:
+ return [self.values['histogram.000000_032768_to_000000_065536'], 1]
+ elif item == 117:
+ return [self.values['histogram.000000_065536_to_000000_131072'], 1]
+ elif item == 118:
+ return [self.values['histogram.000000_131072_to_000000_262144'], 1]
+ elif item == 119:
+ return [self.values['histogram.000000_262144_to_000000_524288'], 1]
+ elif item == 120:
+ return [self.values['histogram.000000_524288_to_000001_000000'], 1]
+ elif item == 121:
+ return [self.values['histogram.000001_000000_to_000002_000000'], 1]
+ elif item == 122:
+ return [self.values['histogram.000002_000000_to_000004_000000'], 1]
+ elif item == 123:
+ return [self.values['histogram.000004_000000_to_000008_000000'], 1]
+ elif item == 124:
+ return [self.values['histogram.000008_000000_to_000016_000000'], 1]
+ elif item == 125:
+ return [self.values['histogram.000016_000000_to_000032_000000'], 1]
+ elif item == 126:
+ return [self.values['histogram.000032_000000_to_000064_000000'], 1]
+ elif item == 127:
+ return [self.values['histogram.000064_000000_to_000128_000000'], 1]
+ elif item == 128:
+ return [self.values['histogram.000128_000000_to_000256_000000'], 1]
+ elif item == 129:
+ return [self.values['histogram.000256_000000_to_000512_000000'], 1]
+ elif item == 130:
+ return [self.values['histogram.000512_000000_to_001024_000000'], 1]
+ elif item == 131:
+ return [self.values['histogram.001024_000000_to_002048_000000'], 1]
+ elif item == 132:
+ return [self.values['histogram.002048_000000_to_004096_000000'], 1]
+ elif item == 133:
+ return [self.values['histogram.004096_000000_to_008192_000000'], 1]
+ elif item == 134:
+ return [self.values['histogram.008192_000000_to_016384_000000'], 1]
+ elif item == 135:
+ return [self.values['histogram.016384_000000_to_032768_000000'], 1]
+ elif item == 136:
+ return [self.values['histogram.032768_000000_to_065536_000000'], 1]
+ elif item == 137:
+ return [self.values['histogram.065536_000000_to_131072_000000'], 1]
+ elif item == 138:
+ return [self.values['histogram.131072_000000_to_262144_000000'], 1]
+ elif item == 139:
+ return [self.values['histogram.262144_000000_to_524288_000000'], 1]
+ return [c_api.PM_ERR_PMID, 0]
+
+ def setup_unbound_metrics(self, name):
+ '''
+ Setup the metric table - ensure a values hash entry is setup for
+ each metric; that way we don't need to worry about KeyErrors in
+ the fetch callback routine (e.g. if the kernel interface changes).
+ '''
+ self.values['total.num.queries'] = 0
+ self.add_metric(name + '.total.num.queries', pmdaMetric(
+ self.pmid(0, 0),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Total number of queries received from all threads.')
+
+ self.values['total.num.cachehits'] = 0
+ self.add_metric(name + '.total.num.cachehits', pmdaMetric(
+ self.pmid(0, 1),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Total number of queries that were successfully answered using a cache
lookup.')
+
+ self.values['total.num.cachemiss'] = 0
+ self.add_metric(name + '.total.num.cachemiss', pmdaMetric(
+ self.pmid(0, 2),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Total number of queries that needed recursive processing.')
+
+ self.values['total.num.prefetch'] = 0
+ self.add_metric(name + '.total.num.prefetch', pmdaMetric(
+ self.pmid(0, 3),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Total number cache prefetches performed.')
+
+ self.values['total.num.recursivereplies'] = 0
+ self.add_metric(name + '.total.num.recursivereplies', pmdaMetric(
+ self.pmid(0, 4),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Total number of replies sent to queries that needed recursive
processing.')
+
+ self.values['total.requestlist.avg'] = 0
+ self.add_metric(name + '.total.requestlist.avg', pmdaMetric(
+ self.pmid(0, 5),
+ c_api.PM_TYPE_FLOAT, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Average number of requests in the internal recursive processing
request list on insert of a new incoming recursive processing query.')
+
+ self.values['total.requestlist.max'] = 0
+ self.add_metric(name + '.total.requestlist.max', pmdaMetric(
+ self.pmid(0, 6),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Maximum size attained by the internal recursive processing request
list.')
+
+ self.values['total.requestlist.overwritten'] = 0
+ self.add_metric(name + '.total.requestlist.overwritten', pmdaMetric(
+ self.pmid(0, 7),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of requests in the request list that were overwritten by newer
entries.')
+
+ self.values['total.requestlist.exceeded'] = 0
+ self.add_metric(name + '.total.requestlist.exceeded', pmdaMetric(
+ self.pmid(0, 8),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Queries that were dropped because the request list was full.')
+
+ self.values['total.requestlist.current.all'] = 0
+ self.add_metric(name + '.total.requestlist.current.all', pmdaMetric(
+ self.pmid(0, 9),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Current size of the request list, includes internally generated
queries.')
+
+ self.values['total.requestlist.current.user'] = 0
+ self.add_metric(name + '.total.requestlist.current.user', pmdaMetric(
+ self.pmid(0, 10),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Current size of the request list, only the requests from client
queries.')
+
+ self.values['total.recursion.time.avg'] = 0
+ self.add_metric(name + '.total.recursion.time.avg', pmdaMetric(
+ self.pmid(0, 11),
+ c_api.PM_TYPE_FLOAT, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 1, 0, 0, c_api.PM_TIME_SEC, 0)),
+ 'Average time it took to answer queries that needed recursive
processing.')
+
+ self.values['total.recursion.time.median'] = 0
+ self.add_metric(name + '.total.recursion.time.median', pmdaMetric(
+ self.pmid(0, 12),
+ c_api.PM_TYPE_FLOAT, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(0, 1, 0, 0, c_api.PM_TIME_SEC, 0)),
+ 'Median time it took to answer queries that needed recursive
processing.')
+
+ self.values['unwanted.queries'] = 0
+ self.add_metric(name + '.unwanted.queries', pmdaMetric(
+ self.pmid(0, 13),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of queries that were refused or dropped because they failed
the access control settings.')
+
+ self.values['unwanted.replies'] = 0
+ self.add_metric(name + '.unwanted.replies', pmdaMetric(
+ self.pmid(0, 14),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Replies that were unwanted or unsolicited.')
+
+ self.values['num.answer.rcode.NOERROR'] = 0
+ self.add_metric(name + '.num.answer.rcode.NOERROR', pmdaMetric(
+ self.pmid(0, 15),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers that were without faults.')
+
+ self.values['num.answer.rcode.FORMERR'] = 0
+ self.add_metric(name + '.num.answer.rcode.FORMERR', pmdaMetric(
+ self.pmid(0, 16),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers with format error.')
+
+ self.values['num.answer.rcode.SERVFAIL'] = 0
+ self.add_metric(name + '.num.answer.rcode.SERVFAIL', pmdaMetric(
+ self.pmid(0, 17),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers with SERVFAIL.')
+
+ self.values['num.answer.rcode.NXDOMAIN'] = 0
+ self.add_metric(name + '.num.answer.rcode.NXDOMAIN', pmdaMetric(
+ self.pmid(0, 18),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers with NXDOMAIN.')
+
+ self.values['num.answer.rcode.REFUSED'] = 0
+ self.add_metric(name + '.num.answer.rcode.REFUSED', pmdaMetric(
+ self.pmid(0, 19),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers status REFUSED.')
+
+ self.values['num.answer.rcode.nodata'] = 0
+ self.add_metric(name + '.num.answer.rcode.nodata', pmdaMetric(
+ self.pmid(0, 20),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'The number of answers to queries that had the pseudo return code
nodata.')
+
+ self.values['num.answer.secure'] = 0
+ self.add_metric(name + '.num.answer.secure', pmdaMetric(
+ self.pmid(0, 21),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers that were secure. The answer validated correctly.')
+
+ self.values['num.answer.bogus'] = 0
+ self.add_metric(name + '.num.answer.bogus', pmdaMetric(
+ self.pmid(0, 22),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Number of answers that were bogus. Answer failed validation.')
+
+ self.values['num.rrset.bogus'] = 0
+ self.add_metric(name + '.num.rrset.bogus', pmdaMetric(
+ self.pmid(0, 23),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'The number of rrsets marked bogus by the validator.')
+
+ self.values['num.query.type.TYPE0'] = 0
+ self.add_metric(name + '.num.query.type.TYPE0', pmdaMetric(
+ self.pmid(0, 24),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE0')
+
+ self.values['num.query.type.A'] = 0
+ self.add_metric(name + '.num.query.type.A', pmdaMetric(
+ self.pmid(0, 25),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.A')
+
+ self.values['num.query.type.NS'] = 0
+ self.add_metric(name + '.num.query.type.NS', pmdaMetric(
+ self.pmid(0, 26),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.NS')
+
+ self.values['num.query.type.MD'] = 0
+ self.add_metric(name + '.num.query.type.MD', pmdaMetric(
+ self.pmid(0, 27),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MD')
+
+ self.values['num.query.type.MF'] = 0
+ self.add_metric(name + '.num.query.type.MF', pmdaMetric(
+ self.pmid(0, 28),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MF')
+
+ self.values['num.query.type.CNAME'] = 0
+ self.add_metric(name + '.num.query.type.CNAME', pmdaMetric(
+ self.pmid(0, 29),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.CNAME')
+
+ self.values['num.query.type.SOA'] = 0
+ self.add_metric(name + '.num.query.type.SOA', pmdaMetric(
+ self.pmid(0, 30),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.SOA')
+
+ self.values['num.query.type.MB'] = 0
+ self.add_metric(name + '.num.query.type.MB', pmdaMetric(
+ self.pmid(0, 31),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MB')
+
+ self.values['num.query.type.MG'] = 0
+ self.add_metric(name + '.num.query.type.MG', pmdaMetric(
+ self.pmid(0, 32),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MG')
+
+ self.values['num.query.type.MR'] = 0
+ self.add_metric(name + '.num.query.type.MR', pmdaMetric(
+ self.pmid(0, 33),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MR')
+
+ self.values['num.query.type.NULL'] = 0
+ self.add_metric(name + '.num.query.type.NULL', pmdaMetric(
+ self.pmid(0, 34),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.NULL')
+
+ self.values['num.query.type.WKS'] = 0
+ self.add_metric(name + '.num.query.type.WKS', pmdaMetric(
+ self.pmid(0, 35),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.WKS')
+
+ self.values['num.query.type.PTR'] = 0
+ self.add_metric(name + '.num.query.type.PTR', pmdaMetric(
+ self.pmid(0, 36),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.PTR')
+
+ self.values['num.query.type.HINFO'] = 0
+ self.add_metric(name + '.num.query.type.HINFO', pmdaMetric(
+ self.pmid(0, 37),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.HINFO')
+
+ self.values['num.query.type.MINFO'] = 0
+ self.add_metric(name + '.num.query.type.MINFO', pmdaMetric(
+ self.pmid(0, 38),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MINFO')
+
+ self.values['num.query.type.MX'] = 0
+ self.add_metric(name + '.num.query.type.MX', pmdaMetric(
+ self.pmid(0, 39),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.MX')
+
+ self.values['num.query.type.TXT'] = 0
+ self.add_metric(name + '.num.query.type.TXT', pmdaMetric(
+ self.pmid(0, 40),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TXT')
+
+ self.values['num.query.type.RP'] = 0
+ self.add_metric(name + '.num.query.type.RP', pmdaMetric(
+ self.pmid(0, 41),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.RP')
+
+ self.values['num.query.type.AFSDB'] = 0
+ self.add_metric(name + '.num.query.type.AFSDB', pmdaMetric(
+ self.pmid(0, 42),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.AFSDB')
+
+ self.values['num.query.type.X25'] = 0
+ self.add_metric(name + '.num.query.type.X25', pmdaMetric(
+ self.pmid(0, 43),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.X25')
+
+ self.values['num.query.type.ISDN'] = 0
+ self.add_metric(name + '.num.query.type.ISDN', pmdaMetric(
+ self.pmid(0, 44),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.ISDN')
+
+ self.values['num.query.type.RT'] = 0
+ self.add_metric(name + '.num.query.type.RT', pmdaMetric(
+ self.pmid(0, 45),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.RT')
+
+ self.values['num.query.type.AAAA'] = 0
+ self.add_metric(name + '.num.query.type.AAAA', pmdaMetric(
+ self.pmid(0, 46),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.AAAA')
+
+ self.values['num.query.type.SRV'] = 0
+ self.add_metric(name + '.num.query.type.SRV', pmdaMetric(
+ self.pmid(0, 47),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.SRV')
+
+ self.values['num.query.type.ATMA'] = 0
+ self.add_metric(name + '.num.query.type.ATMA', pmdaMetric(
+ self.pmid(0, 48),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.ATMA')
+
+ self.values['num.query.type.NAPTR'] = 0
+ self.add_metric(name + '.num.query.type.NAPTR', pmdaMetric(
+ self.pmid(0, 49),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.NAPTR')
+
+ self.values['num.query.type.A6'] = 0
+ self.add_metric(name + '.num.query.type.A6', pmdaMetric(
+ self.pmid(0, 50),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.A6')
+
+ self.values['num.query.type.DS'] = 0
+ self.add_metric(name + '.num.query.type.DS', pmdaMetric(
+ self.pmid(0, 51),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.DS')
+
+ self.values['num.query.type.SSHFP'] = 0
+ self.add_metric(name + '.num.query.type.SSHFP', pmdaMetric(
+ self.pmid(0, 52),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.SSHFP')
+
+ self.values['num.query.type.RRSIG'] = 0
+ self.add_metric(name + '.num.query.type.RRSIG', pmdaMetric(
+ self.pmid(0, 53),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.RRSIG')
+
+ self.values['num.query.type.NSEC'] = 0
+ self.add_metric(name + '.num.query.type.NSEC', pmdaMetric(
+ self.pmid(0, 54),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.NSEC')
+
+ self.values['num.query.type.DNSKEY'] = 0
+ self.add_metric(name + '.num.query.type.DNSKEY', pmdaMetric(
+ self.pmid(0, 55),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.DNSKEY')
+
+ self.values['num.query.type.TLSA'] = 0
+ self.add_metric(name + '.num.query.type.TLSA', pmdaMetric(
+ self.pmid(0, 56),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TLSA')
+
+ self.values['num.query.type.TYPE65'] = 0
+ self.add_metric(name + '.num.query.type.TYPE65', pmdaMetric(
+ self.pmid(0, 57),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE65')
+
+ self.values['num.query.type.TYPE67'] = 0
+ self.add_metric(name + '.num.query.type.TYPE67', pmdaMetric(
+ self.pmid(0, 58),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE67')
+
+ self.values['num.query.type.TYPE76'] = 0
+ self.add_metric(name + '.num.query.type.TYPE76', pmdaMetric(
+ self.pmid(0, 59),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE76')
+
+ self.values['num.query.type.TYPE97'] = 0
+ self.add_metric(name + '.num.query.type.TYPE97', pmdaMetric(
+ self.pmid(0, 60),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE97')
+
+ self.values['num.query.type.SPF'] = 0
+ self.add_metric(name + '.num.query.type.SPF', pmdaMetric(
+ self.pmid(0, 61),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.SPF')
+
+ self.values['num.query.type.TYPE103'] = 0
+ self.add_metric(name + '.num.query.type.TYPE103', pmdaMetric(
+ self.pmid(0, 62),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE103')
+
+ self.values['num.query.type.EUI64'] = 0
+ self.add_metric(name + '.num.query.type.EUI64', pmdaMetric(
+ self.pmid(0, 63),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.EUI64')
+
+ self.values['num.query.type.TYPE110'] = 0
+ self.add_metric(name + '.num.query.type.TYPE110', pmdaMetric(
+ self.pmid(0, 64),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE110')
+
+ self.values['num.query.type.TYPE117'] = 0
+ self.add_metric(name + '.num.query.type.TYPE117', pmdaMetric(
+ self.pmid(0, 65),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE117')
+
+ self.values['num.query.type.TYPE119'] = 0
+ self.add_metric(name + '.num.query.type.TYPE119', pmdaMetric(
+ self.pmid(0, 66),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE119')
+
+ self.values['num.query.type.TYPE123'] = 0
+ self.add_metric(name + '.num.query.type.TYPE123', pmdaMetric(
+ self.pmid(0, 67),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TYPE123')
+
+ self.values['num.query.type.TKEY'] = 0
+ self.add_metric(name + '.num.query.type.TKEY', pmdaMetric(
+ self.pmid(0, 68),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.TKEY')
+
+ self.values['num.query.type.IXFR'] = 0
+ self.add_metric(name + '.num.query.type.IXFR', pmdaMetric(
+ self.pmid(0, 69),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.IXFR')
+
+ self.values['num.query.type.AXFR'] = 0
+ self.add_metric(name + '.num.query.type.AXFR', pmdaMetric(
+ self.pmid(0, 70),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.AXFR')
+
+ self.values['num.query.type.ANY'] = 0
+ self.add_metric(name + '.num.query.type.ANY', pmdaMetric(
+ self.pmid(0, 71),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.ANY')
+
+ self.values['num.query.type.other'] = 0
+ self.add_metric(name + '.num.query.type.other', pmdaMetric(
+ self.pmid(0, 72),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.type.other')
+
+ self.values['num.query.class.CLASS0'] = 0
+ self.add_metric(name + '.num.query.class.CLASS0', pmdaMetric(
+ self.pmid(0, 73),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CLASS0')
+
+ self.values['num.query.class.IN'] = 0
+ self.add_metric(name + '.num.query.class.IN', pmdaMetric(
+ self.pmid(0, 74),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.IN')
+
+ self.values['num.query.class.CH'] = 0
+ self.add_metric(name + '.num.query.class.CH', pmdaMetric(
+ self.pmid(0, 75),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CH')
+
+ self.values['num.query.class.CLASS6'] = 0
+ self.add_metric(name + '.num.query.class.CLASS6', pmdaMetric(
+ self.pmid(0, 76),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CLASS6')
+
+ self.values['num.query.class.CLASS65'] = 0
+ self.add_metric(name + '.num.query.class.CLASS65', pmdaMetric(
+ self.pmid(0, 77),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CLASS65')
+
+ self.values['num.query.class.CLASS115'] = 0
+ self.add_metric(name + '.num.query.class.CLASS115', pmdaMetric(
+ self.pmid(0, 78),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CLASS115')
+
+ self.values['num.query.class.CLASS240'] = 0
+ self.add_metric(name + '.num.query.class.CLASS240', pmdaMetric(
+ self.pmid(0, 79),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.CLASS240')
+
+ self.values['num.query.class.ANY'] = 0
+ self.add_metric(name + '.num.query.class.ANY', pmdaMetric(
+ self.pmid(0, 80),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.ANY')
+
+ self.values['num.query.class.other'] = 0
+ self.add_metric(name + '.num.query.class.other', pmdaMetric(
+ self.pmid(0, 81),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.class.other')
+
+ self.values['num.query.opcode.QUERY'] = 0
+ self.add_metric(name + '.num.query.opcode.QUERY', pmdaMetric(
+ self.pmid(0, 82),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.opcode.QUERY')
+
+ self.values['num.query.tcp'] = 0
+ self.add_metric(name + '.num.query.tcp', pmdaMetric(
+ self.pmid(0, 83),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.tcp')
+
+ self.values['num.query.ipv6'] = 0
+ self.add_metric(name + '.num.query.ipv6', pmdaMetric(
+ self.pmid(0, 84),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.ipv6')
+
+ self.values['num.query.flags.QR'] = 0
+ self.add_metric(name + '.num.query.flags.QR', pmdaMetric(
+ self.pmid(0, 85),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.QR')
+
+ self.values['num.query.flags.AA'] = 0
+ self.add_metric(name + '.num.query.flags.AA', pmdaMetric(
+ self.pmid(0, 86),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.AA')
+
+ self.values['num.query.flags.TC'] = 0
+ self.add_metric(name + '.num.query.flags.TC', pmdaMetric(
+ self.pmid(0, 87),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.TC')
+
+ self.values['num.query.flags.RD'] = 0
+ self.add_metric(name + '.num.query.flags.RD', pmdaMetric(
+ self.pmid(0, 88),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.RD')
+
+ self.values['num.query.flags.RA'] = 0
+ self.add_metric(name + '.num.query.flags.RA', pmdaMetric(
+ self.pmid(0, 89),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.RA')
+
+ self.values['num.query.flags.Z'] = 0
+ self.add_metric(name + '.num.query.flags.Z', pmdaMetric(
+ self.pmid(0, 90),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.Z')
+
+ self.values['num.query.flags.AD'] = 0
+ self.add_metric(name + '.num.query.flags.AD', pmdaMetric(
+ self.pmid(0, 91),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.AD')
+
+ self.values['num.query.flags.CD'] = 0
+ self.add_metric(name + '.num.query.flags.CD', pmdaMetric(
+ self.pmid(0, 92),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.flags.CD')
+
+ self.values['num.query.edns.present'] = 0
+ self.add_metric(name + '.num.query.edns.present', pmdaMetric(
+ self.pmid(0, 93),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.edns.present')
+
+ self.values['num.query.edns.DO'] = 0
+ self.add_metric(name + '.num.query.edns.DO', pmdaMetric(
+ self.pmid(0, 94),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'num.query.edns.DO')
+
+ self.values['mem.total.sbrk'] = 0
+ self.add_metric(name + '.mem.total.sbrk', pmdaMetric(
+ self.pmid(0, 95),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)),
+ 'Estimate of the heap size of the program in number of bytes.')
+
+ self.values['mem.cache.rrset'] = 0
+ self.add_metric(name + '.mem.cache.rrset', pmdaMetric(
+ self.pmid(0, 96),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)),
+ 'Memory in bytes in use by the RRset cache.')
+
+ self.values['mem.cache.message'] = 0
+ self.add_metric(name + '.mem.cache.message', pmdaMetric(
+ self.pmid(0, 97),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)),
+ 'Memory in bytes in use by the message cache.')
+
+ self.values['mem.mod.iterator'] = 0
+ self.add_metric(name + '.mem.mod.iterator', pmdaMetric(
+ self.pmid(0, 98),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)),
+ 'Memory in bytes in use by the iterator module.')
+
+ self.values['mem.mod.validator'] = 0
+ self.add_metric(name + '.mem.mod.validator', pmdaMetric(
+ self.pmid(0, 99),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_INSTANT,
+ pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)),
+ 'Memory in bytes in use by the validator module.')
+
+ self.values['histogram.000000_000000_to_000000_000001'] = 0
+ self.add_metric(name + '.histogram.000000_000000_to_000000_000001',
pmdaMetric(
+ self.pmid(0, 100),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000001_to_000000_000002'] = 0
+ self.add_metric(name + '.histogram.000000_000001_to_000000_000002',
pmdaMetric(
+ self.pmid(0, 101),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000002_to_000000_000004'] = 0
+ self.add_metric(name + '.histogram.000000_000002_to_000000_000004',
pmdaMetric(
+ self.pmid(0, 102),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000004_to_000000_000008'] = 0
+ self.add_metric(name + '.histogram.000000_000004_to_000000_000008',
pmdaMetric(
+ self.pmid(0, 103),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000008_to_000000_000016'] = 0
+ self.add_metric(name + '.histogram.000000_000008_to_000000_000016',
pmdaMetric(
+ self.pmid(0, 104),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000016_to_000000_000032'] = 0
+ self.add_metric(name + '.histogram.000000_000016_to_000000_000032',
pmdaMetric(
+ self.pmid(0, 105),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000032_to_000000_000064'] = 0
+ self.add_metric(name + '.histogram.000000_000032_to_000000_000064',
pmdaMetric(
+ self.pmid(0, 106),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000064_to_000000_000128'] = 0
+ self.add_metric(name + '.histogram.000000_000064_to_000000_000128',
pmdaMetric(
+ self.pmid(0, 107),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000128_to_000000_000256'] = 0
+ self.add_metric(name + '.histogram.000000_000128_to_000000_000256',
pmdaMetric(
+ self.pmid(0, 108),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000256_to_000000_000512'] = 0
+ self.add_metric(name + '.histogram.000000_000256_to_000000_000512',
pmdaMetric(
+ self.pmid(0, 109),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_000512_to_000000_001024'] = 0
+ self.add_metric(name + '.histogram.000000_000512_to_000000_001024',
pmdaMetric(
+ self.pmid(0, 110),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_001024_to_000000_002048'] = 0
+ self.add_metric(name + '.histogram.000000_001024_to_000000_002048',
pmdaMetric(
+ self.pmid(0, 111),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_002048_to_000000_004096'] = 0
+ self.add_metric(name + '.histogram.000000_002048_to_000000_004096',
pmdaMetric(
+ self.pmid(0, 112),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_004096_to_000000_008192'] = 0
+ self.add_metric(name + '.histogram.000000_004096_to_000000_008192',
pmdaMetric(
+ self.pmid(0, 113),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_008192_to_000000_016384'] = 0
+ self.add_metric(name + '.histogram.000000_008192_to_000000_016384',
pmdaMetric(
+ self.pmid(0, 114),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_016384_to_000000_032768'] = 0
+ self.add_metric(name + '.histogram.000000_016384_to_000000_032768',
pmdaMetric(
+ self.pmid(0, 115),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_032768_to_000000_065536'] = 0
+ self.add_metric(name + '.histogram.000000_032768_to_000000_065536',
pmdaMetric(
+ self.pmid(0, 116),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_065536_to_000000_131072'] = 0
+ self.add_metric(name + '.histogram.000000_065536_to_000000_131072',
pmdaMetric(
+ self.pmid(0, 117),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_131072_to_000000_262144'] = 0
+ self.add_metric(name + '.histogram.000000_131072_to_000000_262144',
pmdaMetric(
+ self.pmid(0, 118),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_262144_to_000000_524288'] = 0
+ self.add_metric(name + '.histogram.000000_262144_to_000000_524288',
pmdaMetric(
+ self.pmid(0, 119),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000000_524288_to_000001_000000'] = 0
+ self.add_metric(name + '.histogram.000000_524288_to_000001_000000',
pmdaMetric(
+ self.pmid(0, 120),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000001_000000_to_000002_000000'] = 0
+ self.add_metric(name + '.histogram.000001_000000_to_000002_000000',
pmdaMetric(
+ self.pmid(0, 121),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000002_000000_to_000004_000000'] = 0
+ self.add_metric(name + '.histogram.000002_000000_to_000004_000000',
pmdaMetric(
+ self.pmid(0, 122),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000004_000000_to_000008_000000'] = 0
+ self.add_metric(name + '.histogram.000004_000000_to_000008_000000',
pmdaMetric(
+ self.pmid(0, 123),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000008_000000_to_000016_000000'] = 0
+ self.add_metric(name + '.histogram.000008_000000_to_000016_000000',
pmdaMetric(
+ self.pmid(0, 124),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000016_000000_to_000032_000000'] = 0
+ self.add_metric(name + '.histogram.000016_000000_to_000032_000000',
pmdaMetric(
+ self.pmid(0, 125),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000032_000000_to_000064_000000'] = 0
+ self.add_metric(name + '.histogram.000032_000000_to_000064_000000',
pmdaMetric(
+ self.pmid(0, 126),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000064_000000_to_000128_000000'] = 0
+ self.add_metric(name + '.histogram.000064_000000_to_000128_000000',
pmdaMetric(
+ self.pmid(0, 127),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000128_000000_to_000256_000000'] = 0
+ self.add_metric(name + '.histogram.000128_000000_to_000256_000000',
pmdaMetric(
+ self.pmid(0, 128),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000256_000000_to_000512_000000'] = 0
+ self.add_metric(name + '.histogram.000256_000000_to_000512_000000',
pmdaMetric(
+ self.pmid(0, 129),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.000512_000000_to_001024_000000'] = 0
+ self.add_metric(name + '.histogram.000512_000000_to_001024_000000',
pmdaMetric(
+ self.pmid(0, 130),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.001024_000000_to_002048_000000'] = 0
+ self.add_metric(name + '.histogram.001024_000000_to_002048_000000',
pmdaMetric(
+ self.pmid(0, 131),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.002048_000000_to_004096_000000'] = 0
+ self.add_metric(name + '.histogram.002048_000000_to_004096_000000',
pmdaMetric(
+ self.pmid(0, 132),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.004096_000000_to_008192_000000'] = 0
+ self.add_metric(name + '.histogram.004096_000000_to_008192_000000',
pmdaMetric(
+ self.pmid(0, 133),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.008192_000000_to_016384_000000'] = 0
+ self.add_metric(name + '.histogram.008192_000000_to_016384_000000',
pmdaMetric(
+ self.pmid(0, 134),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.016384_000000_to_032768_000000'] = 0
+ self.add_metric(name + '.histogram.016384_000000_to_032768_000000',
pmdaMetric(
+ self.pmid(0, 135),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.032768_000000_to_065536_000000'] = 0
+ self.add_metric(name + '.histogram.032768_000000_to_065536_000000',
pmdaMetric(
+ self.pmid(0, 136),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.065536_000000_to_131072_000000'] = 0
+ self.add_metric(name + '.histogram.065536_000000_to_131072_000000',
pmdaMetric(
+ self.pmid(0, 137),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.131072_000000_to_262144_000000'] = 0
+ self.add_metric(name + '.histogram.131072_000000_to_262144_000000',
pmdaMetric(
+ self.pmid(0, 138),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ self.values['histogram.262144_000000_to_524288_000000'] = 0
+ self.add_metric(name + '.histogram.262144_000000_to_524288_000000',
pmdaMetric(
+ self.pmid(0, 139),
+ c_api.PM_TYPE_U64, c_api.PM_INDOM_NULL, c_api.PM_SEM_COUNTER,
+ pmUnits(0, 0, 1, 0, 0, c_api.PM_COUNT_ONE)),
+ 'Recursive queries whose reply time fit between the lower and upper
bound.')
+
+ def __init__(self, name, domain):
+ PMDA.__init__(self, name, domain)
+ self.patherrors = 0
+ self.fileerrors = 0
+
+ self.values = {}
+ self.setup_unbound_metrics(name)
+ self.nmetrics = len(self.values)
+
+ self.set_fetch(self.unbound_fetch)
+ self.set_fetch_callback(self.unbound_fetch_callback)
+
+
+if __name__ == '__main__':
+ UnboundPMDA('unbound', 132).run()
--
1.8.3.1
|