12027798626

Committed 26 Nov 2024 09:39AM UTC coverage: 64.696% (+0.008%) from 64.688%

Build # 12027798626

Build Type

Pull #14888

github

Committed by

web-flow

Commit Message

Merge 0ffd83db9 into 5eae153f9

Pull Request Pull Request #14888: dnsdist custom metrics: better error messages, small doc improvements

Run Details

37473 of 88806 branches covered (42.2%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

56 existing lines in 13 files now uncovered.

125856 of 163651 relevant lines covered (76.91%)

4919085.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.39

/pdns/dnsdistdist/dnsdist-metrics.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#include <regex>

#include "dnsdist-metrics.hh"
#include "dnsdist.hh"
#include "dnsdist-dynblocks.hh"
#include "dnsdist-web.hh"

namespace dnsdist::metrics
{

struct MutableCounter
{
  MutableCounter() = default;
  MutableCounter(const MutableCounter&) = delete;
  MutableCounter(MutableCounter&& rhs) noexcept :
    d_value(rhs.d_value.load())
  {
  }
  MutableCounter& operator=(const MutableCounter&) = delete;
  MutableCounter& operator=(MutableCounter&& rhs) noexcept
  {
    d_value = rhs.d_value.load();
    return *this;
  }
  ~MutableCounter() = default;

  mutable stat_t d_value{0};
};

struct MutableGauge
{
  MutableGauge() = default;
  MutableGauge(const MutableGauge&) = delete;
  MutableGauge(MutableGauge&& rhs) noexcept :
    d_value(rhs.d_value.load())
  {
  }
  MutableGauge& operator=(const MutableGauge&) = delete;
  MutableGauge& operator=(MutableGauge&& rhs) noexcept
  {
    d_value = rhs.d_value.load();
    return *this;
  }
  ~MutableGauge() = default;

  mutable pdns::stat_double_t d_value{0};
};

static SharedLockGuarded<std::map<std::string, MutableCounter, std::less<>>> s_customCounters;
static SharedLockGuarded<std::map<std::string, MutableGauge, std::less<>>> s_customGauges;

Stats::Stats() :
  entries{std::vector<EntryPair>{
    {"responses", &responses},
    {"servfail-responses", &servfailResponses},
    {"queries", &queries},
    {"frontend-nxdomain", &frontendNXDomain},
    {"frontend-servfail", &frontendServFail},
    {"frontend-noerror", &frontendNoError},
    {"acl-drops", &aclDrops},
    {"rule-drop", &ruleDrop},
    {"rule-nxdomain", &ruleNXDomain},
    {"rule-refused", &ruleRefused},
    {"rule-servfail", &ruleServFail},
    {"rule-truncated", &ruleTruncated},
    {"self-answered", &selfAnswered},
    {"downstream-timeouts", &downstreamTimeouts},
    {"downstream-send-errors", &downstreamSendErrors},
    {"trunc-failures", &truncFail},
    {"no-policy", &noPolicy},
    {"latency0-1", &latency0_1},
    {"latency1-10", &latency1_10},
    {"latency10-50", &latency10_50},
    {"latency50-100", &latency50_100},
    {"latency100-1000", &latency100_1000},
    {"latency-slow", &latencySlow},
    {"latency-avg100", &latencyAvg100},
    {"latency-avg1000", &latencyAvg1000},
    {"latency-avg10000", &latencyAvg10000},
    {"latency-avg1000000", &latencyAvg1000000},
    {"latency-tcp-avg100", &latencyTCPAvg100},
    {"latency-tcp-avg1000", &latencyTCPAvg1000},
    {"latency-tcp-avg10000", &latencyTCPAvg10000},
    {"latency-tcp-avg1000000", &latencyTCPAvg1000000},
    {"latency-dot-avg100", &latencyDoTAvg100},
    {"latency-dot-avg1000", &latencyDoTAvg1000},
    {"latency-dot-avg10000", &latencyDoTAvg10000},
    {"latency-dot-avg1000000", &latencyDoTAvg1000000},
    {"latency-doh-avg100", &latencyDoHAvg100},
    {"latency-doh-avg1000", &latencyDoHAvg1000},
    {"latency-doh-avg10000", &latencyDoHAvg10000},
    {"latency-doh-avg1000000", &latencyDoHAvg1000000},
    {"latency-doq-avg100", &latencyDoQAvg100},
    {"latency-doq-avg1000", &latencyDoQAvg1000},
    {"latency-doq-avg10000", &latencyDoQAvg10000},
    {"latency-doq-avg1000000", &latencyDoQAvg1000000},
    {"latency-doh3-avg100", &latencyDoH3Avg100},
    {"latency-doh3-avg1000", &latencyDoH3Avg1000},
    {"latency-doh3-avg10000", &latencyDoH3Avg10000},
    {"latency-doh3-avg1000000", &latencyDoH3Avg1000000},
    {"uptime", uptimeOfProcess},
    {"real-memory-usage", getRealMemoryUsage},
    {"special-memory-usage", getSpecialMemoryUsage},
    {"udp-in-errors", [](const std::string&) { return udpErrorStats("udp-in-errors"); }},
    {"udp-noport-errors", [](const std::string&) { return udpErrorStats("udp-noport-errors"); }},
    {"udp-recvbuf-errors", [](const std::string&) { return udpErrorStats("udp-recvbuf-errors"); }},
    {"udp-sndbuf-errors", [](const std::string&) { return udpErrorStats("udp-sndbuf-errors"); }},
    {"udp-in-csum-errors", [](const std::string&) { return udpErrorStats("udp-in-csum-errors"); }},
    {"udp6-in-errors", [](const std::string&) { return udp6ErrorStats("udp6-in-errors"); }},
    {"udp6-recvbuf-errors", [](const std::string&) { return udp6ErrorStats("udp6-recvbuf-errors"); }},
    {"udp6-sndbuf-errors", [](const std::string&) { return udp6ErrorStats("udp6-sndbuf-errors"); }},
    {"udp6-noport-errors", [](const std::string&) { return udp6ErrorStats("udp6-noport-errors"); }},
    {"udp6-in-csum-errors", [](const std::string&) { return udp6ErrorStats("udp6-in-csum-errors"); }},
    {"tcp-listen-overflows", [](const std::string&) { return tcpErrorStats("ListenOverflows"); }},
    {"noncompliant-queries", &nonCompliantQueries},
    {"noncompliant-responses", &nonCompliantResponses},
    {"proxy-protocol-invalid", &proxyProtocolInvalid},
    {"rdqueries", &rdQueries},
    {"empty-queries", &emptyQueries},
    {"cache-hits", &cacheHits},
    {"cache-misses", &cacheMisses},
    {"cpu-iowait", getCPUIOWait},
    {"cpu-steal", getCPUSteal},
    {"cpu-sys-msec", getCPUTimeSystem},
    {"cpu-user-msec", getCPUTimeUser},
    {"fd-usage", getOpenFileDescriptors},
    {"dyn-blocked", &dynBlocked},
#ifndef DISABLE_DYNBLOCKS
    {"dyn-block-nmg-size", [](const std::string&) { return dnsdist::DynamicBlocks::getClientAddressDynamicRules().size(); }},
#endif /* DISABLE_DYNBLOCKS */
    {"security-status", &securityStatus},
    {"doh-query-pipe-full", &dohQueryPipeFull},
    {"doh-response-pipe-full", &dohResponsePipeFull},
    {"doq-response-pipe-full", &doqResponsePipeFull},
    {"doh3-response-pipe-full", &doh3ResponsePipeFull},
    {"outgoing-doh-query-pipe-full", &outgoingDoHQueryPipeFull},
    {"tcp-query-pipe-full", &tcpQueryPipeFull},
    {"tcp-cross-protocol-query-pipe-full", &tcpCrossProtocolQueryPipeFull},
    {"tcp-cross-protocol-response-pipe-full", &tcpCrossProtocolResponsePipeFull},
    // Latency histogram
    {"latency-sum", &latencySum},
    {"latency-count", &latencyCount},
  }}
{
}

struct Stats g_stats;

std::optional<std::string> declareCustomMetric(const std::string& name, const std::string& type, const std::string& description, std::optional<std::string> customName)
{
  if (!std::regex_match(name, std::regex("^[a-z0-9-]+$"))) {
    return std::string("Unable to declare metric '") + std::string(name) + std::string("': invalid name\n");
  }

  const std::string finalCustomName(customName ? *customName : "");
  if (type == "counter") {
    auto customCounters = s_customCounters.write_lock();
    auto itp = customCounters->insert({name, MutableCounter()});
    if (itp.second) {
      g_stats.entries.write_lock()->emplace_back(Stats::EntryPair{name, &(*customCounters)[name].d_value});
      dnsdist::prometheus::PrometheusMetricDefinition def{name, type, description, finalCustomName};
      dnsdist::webserver::addMetricDefinition(def);
    }
  }
  else if (type == "gauge") {
    auto customGauges = s_customGauges.write_lock();
    auto itp = customGauges->insert({name, MutableGauge()});
    if (itp.second) {
      g_stats.entries.write_lock()->emplace_back(Stats::EntryPair{name, &(*customGauges)[name].d_value});
      dnsdist::prometheus::PrometheusMetricDefinition def{name, type, description, finalCustomName};
      dnsdist::webserver::addMetricDefinition(def);
    }
  }
  else {
    return std::string("Unable to declare metric: unknown type '") + type + "'";
  }
  return std::nullopt;
}

std::variant<uint64_t, Error> incrementCustomCounter(const std::string_view& name, uint64_t step)
{
  auto customCounters = s_customCounters.read_lock();
  auto metric = customCounters->find(name);
  if (metric != customCounters->end()) {
    metric->second.d_value += step;
    return metric->second.d_value.load();
  }
  return std::string("Unable to increment custom metric '") + std::string(name) + "': no such counter";
}

std::variant<uint64_t, Error> decrementCustomCounter(const std::string_view& name, uint64_t step)
{
  auto customCounters = s_customCounters.read_lock();
  auto metric = customCounters->find(name);
  if (metric != customCounters->end()) {
    metric->second.d_value -= step;
    return metric->second.d_value.load();
  }
  return std::string("Unable to decrement custom metric '") + std::string(name) + "': no such counter";
}

std::variant<double, Error> setCustomGauge(const std::string_view& name, const double value)
{
  auto customGauges = s_customGauges.read_lock();
  auto metric = customGauges->find(name);
  if (metric != customGauges->end()) {
    metric->second.d_value = value;
    return value;
  }

  return std::string("Unable to set metric '") + std::string(name) + "': no such gauge";
}

std::variant<double, Error> getCustomMetric(const std::string_view& name)
{
  {
    auto customCounters = s_customCounters.read_lock();
    auto counter = customCounters->find(name);
    if (counter != customCounters->end()) {
      return static_cast<double>(counter->second.d_value.load());
    }
  }
  {
    auto customGauges = s_customGauges.read_lock();
    auto gauge = customGauges->find(name);
    if (gauge != customGauges->end()) {
      return gauge->second.d_value.load();
    }
  }
  return std::string("Unable to get metric '") + std::string(name) + "': no such metric";
}

}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#include <regex>
23
24	#include "dnsdist-metrics.hh"
25	#include "dnsdist.hh"
26	#include "dnsdist-dynblocks.hh"
27	#include "dnsdist-web.hh"
28
29	namespace dnsdist::metrics
30	{
31
32	struct MutableCounter
33	{
34	MutableCounter() = default;	16✔
35	MutableCounter(const MutableCounter&) = delete;
36	MutableCounter(MutableCounter&& rhs) noexcept :
37	d_value(rhs.d_value.load())
38	{	31✔
39	}	31✔
40	MutableCounter& operator=(const MutableCounter&) = delete;
41	MutableCounter& operator=(MutableCounter&& rhs) noexcept
42	{	×
43	d_value = rhs.d_value.load();	×
44	return *this;	×
45	}	×
46	~MutableCounter() = default;	32✔
47
48	mutable stat_t d_value{0};
49	};
50
51	struct MutableGauge
52	{
53	MutableGauge() = default;	6✔
54	MutableGauge(const MutableGauge&) = delete;
55	MutableGauge(MutableGauge&& rhs) noexcept :
56	d_value(rhs.d_value.load())
57	{	12✔
58	}	12✔
59	MutableGauge& operator=(const MutableGauge&) = delete;
60	MutableGauge& operator=(MutableGauge&& rhs) noexcept
61	{	×
62	d_value = rhs.d_value.load();	×
63	return *this;	×
64	}	×
65	~MutableGauge() = default;	12✔
66
67	mutable pdns::stat_double_t d_value{0};
68	};
69
70	static SharedLockGuarded<std::map<std::string, MutableCounter, std::less<>>> s_customCounters;
71	static SharedLockGuarded<std::map<std::string, MutableGauge, std::less<>>> s_customGauges;
72
73	Stats::Stats() :
74	entries{std::vector<EntryPair>{
75	{"responses", &responses},
76	{"servfail-responses", &servfailResponses},
77	{"queries", &queries},
78	{"frontend-nxdomain", &frontendNXDomain},
79	{"frontend-servfail", &frontendServFail},
80	{"frontend-noerror", &frontendNoError},
81	{"acl-drops", &aclDrops},
82	{"rule-drop", &ruleDrop},
83	{"rule-nxdomain", &ruleNXDomain},
84	{"rule-refused", &ruleRefused},
85	{"rule-servfail", &ruleServFail},
86	{"rule-truncated", &ruleTruncated},
87	{"self-answered", &selfAnswered},
88	{"downstream-timeouts", &downstreamTimeouts},
89	{"downstream-send-errors", &downstreamSendErrors},
90	{"trunc-failures", &truncFail},
91	{"no-policy", &noPolicy},
92	{"latency0-1", &latency0_1},
93	{"latency1-10", &latency1_10},
94	{"latency10-50", &latency10_50},
95	{"latency50-100", &latency50_100},
96	{"latency100-1000", &latency100_1000},
97	{"latency-slow", &latencySlow},
98	{"latency-avg100", &latencyAvg100},
99	{"latency-avg1000", &latencyAvg1000},
100	{"latency-avg10000", &latencyAvg10000},
101	{"latency-avg1000000", &latencyAvg1000000},
102	{"latency-tcp-avg100", &latencyTCPAvg100},
103	{"latency-tcp-avg1000", &latencyTCPAvg1000},
104	{"latency-tcp-avg10000", &latencyTCPAvg10000},
105	{"latency-tcp-avg1000000", &latencyTCPAvg1000000},
106	{"latency-dot-avg100", &latencyDoTAvg100},
107	{"latency-dot-avg1000", &latencyDoTAvg1000},
108	{"latency-dot-avg10000", &latencyDoTAvg10000},
109	{"latency-dot-avg1000000", &latencyDoTAvg1000000},
110	{"latency-doh-avg100", &latencyDoHAvg100},
111	{"latency-doh-avg1000", &latencyDoHAvg1000},
112	{"latency-doh-avg10000", &latencyDoHAvg10000},
113	{"latency-doh-avg1000000", &latencyDoHAvg1000000},
114	{"latency-doq-avg100", &latencyDoQAvg100},
115	{"latency-doq-avg1000", &latencyDoQAvg1000},
116	{"latency-doq-avg10000", &latencyDoQAvg10000},
117	{"latency-doq-avg1000000", &latencyDoQAvg1000000},
118	{"latency-doh3-avg100", &latencyDoH3Avg100},
119	{"latency-doh3-avg1000", &latencyDoH3Avg1000},
120	{"latency-doh3-avg10000", &latencyDoH3Avg10000},
121	{"latency-doh3-avg1000000", &latencyDoH3Avg1000000},
122	{"uptime", uptimeOfProcess},
123	{"real-memory-usage", getRealMemoryUsage},
124	{"special-memory-usage", getSpecialMemoryUsage},
125	{"udp-in-errors", [](const std::string&) { return udpErrorStats("udp-in-errors"); }},	207✔
126	{"udp-noport-errors", [](const std::string&) { return udpErrorStats("udp-noport-errors"); }},	207✔
127	{"udp-recvbuf-errors", [](const std::string&) { return udpErrorStats("udp-recvbuf-errors"); }},	207✔
128	{"udp-sndbuf-errors", [](const std::string&) { return udpErrorStats("udp-sndbuf-errors"); }},	207✔
129	{"udp-in-csum-errors", [](const std::string&) { return udpErrorStats("udp-in-csum-errors"); }},	207✔
130	{"udp6-in-errors", [](const std::string&) { return udp6ErrorStats("udp6-in-errors"); }},	207✔
131	{"udp6-recvbuf-errors", [](const std::string&) { return udp6ErrorStats("udp6-recvbuf-errors"); }},	207✔
132	{"udp6-sndbuf-errors", [](const std::string&) { return udp6ErrorStats("udp6-sndbuf-errors"); }},	207✔
133	{"udp6-noport-errors", [](const std::string&) { return udp6ErrorStats("udp6-noport-errors"); }},	207✔
134	{"udp6-in-csum-errors", [](const std::string&) { return udp6ErrorStats("udp6-in-csum-errors"); }},	207✔
135	{"tcp-listen-overflows", [](const std::string&) { return tcpErrorStats("ListenOverflows"); }},	207✔
136	{"noncompliant-queries", &nonCompliantQueries},
137	{"noncompliant-responses", &nonCompliantResponses},
138	{"proxy-protocol-invalid", &proxyProtocolInvalid},
139	{"rdqueries", &rdQueries},
140	{"empty-queries", &emptyQueries},
141	{"cache-hits", &cacheHits},
142	{"cache-misses", &cacheMisses},
143	{"cpu-iowait", getCPUIOWait},
144	{"cpu-steal", getCPUSteal},
145	{"cpu-sys-msec", getCPUTimeSystem},
146	{"cpu-user-msec", getCPUTimeUser},
147	{"fd-usage", getOpenFileDescriptors},
148	{"dyn-blocked", &dynBlocked},
149	#ifndef DISABLE_DYNBLOCKS
150	{"dyn-block-nmg-size", [](const std::string&) { return dnsdist::DynamicBlocks::getClientAddressDynamicRules().size(); }},	207✔
151	#endif /* DISABLE_DYNBLOCKS */
152	{"security-status", &securityStatus},
153	{"doh-query-pipe-full", &dohQueryPipeFull},
154	{"doh-response-pipe-full", &dohResponsePipeFull},
155	{"doq-response-pipe-full", &doqResponsePipeFull},
156	{"doh3-response-pipe-full", &doh3ResponsePipeFull},
157	{"outgoing-doh-query-pipe-full", &outgoingDoHQueryPipeFull},
158	{"tcp-query-pipe-full", &tcpQueryPipeFull},
159	{"tcp-cross-protocol-query-pipe-full", &tcpCrossProtocolQueryPipeFull},
160	{"tcp-cross-protocol-response-pipe-full", &tcpCrossProtocolResponsePipeFull},
161	// Latency histogram
162	{"latency-sum", &latencySum},
163	{"latency-count", &latencyCount},
164	}}
165	{	647✔
166	}	647✔
167
168	struct Stats g_stats;
169
170	std::optional<std::string> declareCustomMetric(const std::string& name, const std::string& type, const std::string& description, std::optional<std::string> customName)
171	{	22✔
172	if (!std::regex_match(name, std::regex("^[a-z0-9-]+$"))) {	22!
173	return std::string("Unable to declare metric '") + std::string(name) + std::string("': invalid name\n");	×
174	}	×
175
176	const std::string finalCustomName(customName ? *customName : "");	22✔
177	if (type == "counter") {	22✔
178	auto customCounters = s_customCounters.write_lock();	16✔
179	auto itp = customCounters->insert({name, MutableCounter()});	16✔
180	if (itp.second) {	16✔
181	g_stats.entries.write_lock()->emplace_back(Stats::EntryPair{name, &(*customCounters)[name].d_value});	15✔
182	dnsdist::prometheus::PrometheusMetricDefinition def{name, type, description, finalCustomName};	15✔
183	dnsdist::webserver::addMetricDefinition(def);	15✔
184	}	15✔
185	}	16✔
186	else if (type == "gauge") {	6!
187	auto customGauges = s_customGauges.write_lock();	6✔
188	auto itp = customGauges->insert({name, MutableGauge()});	6✔
189	if (itp.second) {	6!
190	g_stats.entries.write_lock()->emplace_back(Stats::EntryPair{name, &(*customGauges)[name].d_value});	6✔
191	dnsdist::prometheus::PrometheusMetricDefinition def{name, type, description, finalCustomName};	6✔
192	dnsdist::webserver::addMetricDefinition(def);	6✔
193	}	6✔
194	}	6✔
195	else {	×
196	return std::string("Unable to declare metric: unknown type '") + type + "'";	×
197	}	×
198	return std::nullopt;	22✔
199	}	22✔
200
201	std::variant<uint64_t, Error> incrementCustomCounter(const std::string_view& name, uint64_t step)
202	{	6✔
203	auto customCounters = s_customCounters.read_lock();	6✔
204	auto metric = customCounters->find(name);	6✔
205	if (metric != customCounters->end()) {	6!
206	metric->second.d_value += step;	6✔
207	return metric->second.d_value.load();	6✔
208	}	6✔
NEW 209	return std::string("Unable to increment custom metric '") + std::string(name) + "': no such counter";	×
210	}	6✔
211
212	std::variant<uint64_t, Error> decrementCustomCounter(const std::string_view& name, uint64_t step)
213	{	×
214	auto customCounters = s_customCounters.read_lock();	×
215	auto metric = customCounters->find(name);	×
216	if (metric != customCounters->end()) {	×
217	metric->second.d_value -= step;	×
218	return metric->second.d_value.load();	×
219	}	×
NEW 220	return std::string("Unable to decrement custom metric '") + std::string(name) + "': no such counter";	×
221	}	×
222
223	std::variant<double, Error> setCustomGauge(const std::string_view& name, const double value)
224	{	2✔
225	auto customGauges = s_customGauges.read_lock();	2✔
226	auto metric = customGauges->find(name);	2✔
227	if (metric != customGauges->end()) {	2!
228	metric->second.d_value = value;	2✔
229	return value;	2✔
230	}	2✔
231
NEW 232	return std::string("Unable to set metric '") + std::string(name) + "': no such gauge";	×
233	}	2✔
234
235	std::variant<double, Error> getCustomMetric(const std::string_view& name)
236	{	8✔
237	{	8✔
238	auto customCounters = s_customCounters.read_lock();	8✔
239	auto counter = customCounters->find(name);	8✔
240	if (counter != customCounters->end()) {	8✔
241	return static_cast<double>(counter->second.d_value.load());	4✔
242	}	4✔
243	}	8✔
244	{	4✔
245	auto customGauges = s_customGauges.read_lock();	4✔
246	auto gauge = customGauges->find(name);	4✔
247	if (gauge != customGauges->end()) {	4!
248	return gauge->second.d_value.load();	4✔
249	}	4✔
250	}	4✔
251	return std::string("Unable to get metric '") + std::string(name) + "': no such metric";	×
252	}	4✔
253
254	}

PowerDNS / pdns / 12027798626

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous