From: Otto Moerbeek Date: Mon, 19 Dec 2022 12:39:36 +0000 (+0100) Subject: Move DNSSEC and Policy counters to TCounter object X-Git-Tag: dnsdist-1.8.0-rc1~144^2~1 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=377d04a5f19cf7db3a6f4f8d88d9f8b0659104ad;p=thirdparty%2Fpdns.git Move DNSSEC and Policy counters to TCounter object --- diff --git a/pdns/recursordist/pdns_recursor.cc b/pdns/recursordist/pdns_recursor.cc index 3937e10db5..010b511cbe 100644 --- a/pdns/recursordist/pdns_recursor.cc +++ b/pdns/recursordist/pdns_recursor.cc @@ -483,7 +483,8 @@ static PolicyResult handlePolicyHit(const DNSFilterEngine::Policy& appliedPolicy { /* don't account truncate actions for TCP queries, since they are not applied */ if (appliedPolicy.d_kind != DNSFilterEngine::PolicyKind::Truncate || !dc->d_tcp) { - ++g_stats.policyResults[appliedPolicy.d_kind]; + //++g_stats.policyResults[appliedPolicy.d_kind]; + t_Counters.at(rec::PolicyHistogram::policy).at(appliedPolicy.d_kind)++; ++(g_stats.policyHits.lock()->operator[](appliedPolicy.getName())); } diff --git a/pdns/recursordist/rec-tcounters.cc b/pdns/recursordist/rec-tcounters.cc index 23d2cb77a8..680afb5929 100644 --- a/pdns/recursordist/rec-tcounters.cc +++ b/pdns/recursordist/rec-tcounters.cc @@ -52,6 +52,19 @@ Counters& Counters::merge(const Counters& data) histograms.at(i) += data.histograms.at(i); } responseStats += data.responseStats; + + // DNSSEC histograms: add individual entries + for (size_t i = 0; i < dnssecCounters.size(); i++) { + auto& lhs = dnssecCounters.at(i); + const auto& rhs = data.dnssecCounters.at(i); + for (size_t j = 0; j < lhs.counts.size(); j++) { + lhs.counts.at(j) += rhs.counts.at(j); + } + } + for (size_t i = 0; i < policyCounters.counts.size(); i++) { + policyCounters.counts.at(i) += data.policyCounters.counts.at(i); + } + return *this; } @@ -74,6 +87,9 @@ std::string Counters::toString() const for (const auto& element : histograms) { stream << element.getName() << ": NYI"; } + stream << "DNSSEC Histograms: "; + stream << "NYI"; + stream << std::endl; return stream.str(); } diff --git a/pdns/recursordist/rec-tcounters.hh b/pdns/recursordist/rec-tcounters.hh index 6947228723..9aa0996220 100644 --- a/pdns/recursordist/rec-tcounters.hh +++ b/pdns/recursordist/rec-tcounters.hh @@ -28,6 +28,8 @@ #include "histogram.hh" #include "rec-responsestats.hh" +#include "validate.hh" +#include "filterpo.hh" namespace rec { @@ -132,6 +134,23 @@ enum class Histogram : uint8_t numberOfCounters }; +// DNSSEC validation results +enum class DNSSECHistogram : uint8_t +{ + dnssec, + xdnssec, + + numberOfCounters +}; + +// Policy hits +enum class PolicyHistogram : uint8_t +{ + policy, + + numberOfCounters +}; + struct Counters { // An array of simple counters @@ -183,6 +202,42 @@ struct Counters // Response stats RecResponseStats responseStats{}; + // DNSSEC stats + struct DNSSECCounters + { + DNSSECCounters& operator+=(const DNSSECCounters& rhs) + { + for (size_t i = 0; i < counts.size(); i++) { + counts.at(i) += rhs.counts.at(i); + } + return *this; + } + uint64_t& at(vState index) + { + return counts.at(static_cast(index)); + } + std::array(vState::BogusInvalidDNSKEYProtocol) + 1> counts; + }; + std::array(DNSSECHistogram::numberOfCounters)> dnssecCounters{}; + + // Policy histogram + struct PolicyCounters + { + PolicyCounters& operator+=(const PolicyCounters& rhs) + { + for (size_t i = 0; i < counts.size(); i++) { + counts.at(i) += rhs.counts.at(i); + } + return *this; + } + uint64_t& at(DNSFilterEngine::PolicyKind index) + { + return counts.at(static_cast(index)); + } + std::array(DNSFilterEngine::PolicyKind::Custom) + 1> counts; + }; + PolicyCounters policyCounters{}; + Counters() { for (auto& elem : uint64Count) { @@ -194,6 +249,14 @@ struct Counters } // Histogram has a constructor that initializes // RecResponseStats has a default constructor that initializes + for (auto& histogram : dnssecCounters) { + for (auto& elem : histogram.counts) { + elem = 0; + } + } + for (auto& elem : policyCounters.counts) { + elem = 0; + } } // Merge a set of counters into an existing set of counters. For simple counters, that will be additions @@ -228,6 +291,16 @@ struct Counters return histograms.at(static_cast(index)); } + DNSSECCounters& at(DNSSECHistogram index) + { + return dnssecCounters.at(static_cast(index)); + } + + PolicyCounters& at(PolicyHistogram index) + { + return policyCounters; + } + // Mainly for debugging purposes [[nodiscard]] std::string toString() const; }; diff --git a/pdns/recursordist/rec_channel_rec.cc b/pdns/recursordist/rec_channel_rec.cc index 6dbc293531..48fd3bf97e 100644 --- a/pdns/recursordist/rec_channel_rec.cc +++ b/pdns/recursordist/rec_channel_rec.cc @@ -1027,11 +1027,6 @@ static string getRemoteLoggerStats() return outputStream.str(); } -static uint64_t calculateUptime() -{ - return time(nullptr) - g_stats.startupTime; -} - static string* pleaseGetCurrentQueries() { ostringstream ostr; @@ -1311,6 +1306,8 @@ static StatsMap toRemoteLoggerStatsMap(const string& name) return entries; } +static time_t s_startupTime = time(nullptr); + static void registerAllStats1() { addGetStat("questions", [] { return g_Counters.sum(rec::Counter::qcounter); }); @@ -1449,7 +1446,7 @@ static void registerAllStats1() addGetStat("noping-outqueries", [] { return g_Counters.sum(rec::Counter::noPingOutQueries); }); addGetStat("noedns-outqueries", [] { return g_Counters.sum(rec::Counter::noEdnsOutQueries); }); - addGetStat("uptime", calculateUptime); + addGetStat("uptime", [] { return time(nullptr) - s_startupTime; }); addGetStat("real-memory-usage", [] { return getRealMemoryUsage(string()); }); addGetStat("special-memory-usage", [] { return getSpecialMemoryUsage(string()); }); addGetStat("fd-usage", [] { return getOpenFileDescriptors(string()); }); @@ -1472,71 +1469,73 @@ static void registerAllStats1() #endif addGetStat("dnssec-validations", [] { return g_Counters.sum(rec::Counter::dnssecValidations); }); - addGetStat("dnssec-result-insecure", &g_stats.dnssecResults[vState::Insecure]); - addGetStat("dnssec-result-secure", &g_stats.dnssecResults[vState::Secure]); + addGetStat("dnssec-result-insecure", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::Insecure); }); + addGetStat("dnssec-result-secure", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::Secure); }); addGetStat("dnssec-result-bogus", []() { std::set const bogusStates = {vState::BogusNoValidDNSKEY, vState::BogusInvalidDenial, vState::BogusUnableToGetDSs, vState::BogusUnableToGetDNSKEYs, vState::BogusSelfSignedDS, vState::BogusNoRRSIG, vState::BogusNoValidRRSIG, vState::BogusMissingNegativeIndication, vState::BogusSignatureNotYetValid, vState::BogusSignatureExpired, vState::BogusUnsupportedDNSKEYAlgo, vState::BogusUnsupportedDSDigestType, vState::BogusNoZoneKeyBitSet, vState::BogusRevokedDNSKEY, vState::BogusInvalidDNSKEYProtocol}; + auto counts = g_Counters.sum(rec::DNSSECHistogram::dnssec); uint64_t total = 0; for (const auto& state : bogusStates) { - total += g_stats.dnssecResults[state]; + total += counts.at(state); } return total; }); - addGetStat("dnssec-result-bogus-no-valid-dnskey", &g_stats.dnssecResults[vState::BogusNoValidDNSKEY]); - addGetStat("dnssec-result-bogus-invalid-denial", &g_stats.dnssecResults[vState::BogusInvalidDenial]); - addGetStat("dnssec-result-bogus-unable-to-get-dss", &g_stats.dnssecResults[vState::BogusUnableToGetDSs]); - addGetStat("dnssec-result-bogus-unable-to-get-dnskeys", &g_stats.dnssecResults[vState::BogusUnableToGetDNSKEYs]); - addGetStat("dnssec-result-bogus-self-signed-ds", &g_stats.dnssecResults[vState::BogusSelfSignedDS]); - addGetStat("dnssec-result-bogus-no-rrsig", &g_stats.dnssecResults[vState::BogusNoRRSIG]); - addGetStat("dnssec-result-bogus-no-valid-rrsig", &g_stats.dnssecResults[vState::BogusNoValidRRSIG]); - addGetStat("dnssec-result-bogus-missing-negative-indication", &g_stats.dnssecResults[vState::BogusMissingNegativeIndication]); - addGetStat("dnssec-result-bogus-signature-not-yet-valid", &g_stats.dnssecResults[vState::BogusSignatureNotYetValid]); - addGetStat("dnssec-result-bogus-signature-expired", &g_stats.dnssecResults[vState::BogusSignatureExpired]); - addGetStat("dnssec-result-bogus-unsupported-dnskey-algo", &g_stats.dnssecResults[vState::BogusUnsupportedDNSKEYAlgo]); - addGetStat("dnssec-result-bogus-unsupported-ds-digest-type", &g_stats.dnssecResults[vState::BogusUnsupportedDSDigestType]); - addGetStat("dnssec-result-bogus-no-zone-key-bit-set", &g_stats.dnssecResults[vState::BogusNoZoneKeyBitSet]); - addGetStat("dnssec-result-bogus-revoked-dnskey", &g_stats.dnssecResults[vState::BogusRevokedDNSKEY]); - addGetStat("dnssec-result-bogus-invalid-dnskey-protocol", &g_stats.dnssecResults[vState::BogusInvalidDNSKEYProtocol]); - addGetStat("dnssec-result-indeterminate", &g_stats.dnssecResults[vState::Indeterminate]); - addGetStat("dnssec-result-nta", &g_stats.dnssecResults[vState::NTA]); + addGetStat("dnssec-result-bogus-no-valid-dnskey", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusNoValidDNSKEY); }); + addGetStat("dnssec-result-bogus-invalid-denial", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusInvalidDenial); }); + addGetStat("dnssec-result-bogus-unable-to-get-dss", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusUnableToGetDSs); }); + addGetStat("dnssec-result-bogus-unable-to-get-dnskeys", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusUnableToGetDNSKEYs); }); + addGetStat("dnssec-result-bogus-self-signed-ds", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusSelfSignedDS); }); + addGetStat("dnssec-result-bogus-no-rrsig", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusNoRRSIG); }); + addGetStat("dnssec-result-bogus-no-valid-rrsig", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusNoValidRRSIG); }); + addGetStat("dnssec-result-bogus-missing-negative-indication", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusMissingNegativeIndication); }); + addGetStat("dnssec-result-bogus-signature-not-yet-valid", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusSignatureNotYetValid); }); + addGetStat("dnssec-result-bogus-signature-expired", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusSignatureExpired); }); + addGetStat("dnssec-result-bogus-unsupported-dnskey-algo", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusUnsupportedDNSKEYAlgo); }); + addGetStat("dnssec-result-bogus-unsupported-ds-digest-type", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusUnsupportedDSDigestType); }); + addGetStat("dnssec-result-bogus-no-zone-key-bit-set", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusNoZoneKeyBitSet); }); + addGetStat("dnssec-result-bogus-revoked-dnskey", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusRevokedDNSKEY); }); + addGetStat("dnssec-result-bogus-invalid-dnskey-protocol", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::BogusInvalidDNSKEYProtocol); }); + addGetStat("dnssec-result-indeterminate", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::Indeterminate); }); + addGetStat("dnssec-result-nta", [] { return g_Counters.sum(rec::DNSSECHistogram::dnssec).at(vState::NTA); }); if (::arg()["x-dnssec-names"].length() > 0) { addGetStat("x-dnssec-result-bogus", []() { std::set const bogusStates = {vState::BogusNoValidDNSKEY, vState::BogusInvalidDenial, vState::BogusUnableToGetDSs, vState::BogusUnableToGetDNSKEYs, vState::BogusSelfSignedDS, vState::BogusNoRRSIG, vState::BogusNoValidRRSIG, vState::BogusMissingNegativeIndication, vState::BogusSignatureNotYetValid, vState::BogusSignatureExpired, vState::BogusUnsupportedDNSKEYAlgo, vState::BogusUnsupportedDSDigestType, vState::BogusNoZoneKeyBitSet, vState::BogusRevokedDNSKEY, vState::BogusInvalidDNSKEYProtocol}; + auto counts = g_Counters.sum(rec::DNSSECHistogram::xdnssec); uint64_t total = 0; for (const auto& state : bogusStates) { - total += g_stats.xdnssecResults[state]; + total += counts.at(state); } return total; }); - addGetStat("x-dnssec-result-bogus-no-valid-dnskey", &g_stats.xdnssecResults[vState::BogusNoValidDNSKEY]); - addGetStat("x-dnssec-result-bogus-invalid-denial", &g_stats.xdnssecResults[vState::BogusInvalidDenial]); - addGetStat("x-dnssec-result-bogus-unable-to-get-dss", &g_stats.xdnssecResults[vState::BogusUnableToGetDSs]); - addGetStat("x-dnssec-result-bogus-unable-to-get-dnskeys", &g_stats.xdnssecResults[vState::BogusUnableToGetDNSKEYs]); - addGetStat("x-dnssec-result-bogus-self-signed-ds", &g_stats.xdnssecResults[vState::BogusSelfSignedDS]); - addGetStat("x-dnssec-result-bogus-no-rrsig", &g_stats.xdnssecResults[vState::BogusNoRRSIG]); - addGetStat("x-dnssec-result-bogus-no-valid-rrsig", &g_stats.xdnssecResults[vState::BogusNoValidRRSIG]); - addGetStat("x-dnssec-result-bogus-missing-negative-indication", &g_stats.xdnssecResults[vState::BogusMissingNegativeIndication]); - addGetStat("x-dnssec-result-bogus-signature-not-yet-valid", &g_stats.xdnssecResults[vState::BogusSignatureNotYetValid]); - addGetStat("x-dnssec-result-bogus-signature-expired", &g_stats.xdnssecResults[vState::BogusSignatureExpired]); - addGetStat("x-dnssec-result-bogus-unsupported-dnskey-algo", &g_stats.xdnssecResults[vState::BogusUnsupportedDNSKEYAlgo]); - addGetStat("x-dnssec-result-bogus-unsupported-ds-digest-type", &g_stats.xdnssecResults[vState::BogusUnsupportedDSDigestType]); - addGetStat("x-dnssec-result-bogus-no-zone-key-bit-set", &g_stats.xdnssecResults[vState::BogusNoZoneKeyBitSet]); - addGetStat("x-dnssec-result-bogus-revoked-dnskey", &g_stats.xdnssecResults[vState::BogusRevokedDNSKEY]); - addGetStat("x-dnssec-result-bogus-invalid-dnskey-protocol", &g_stats.xdnssecResults[vState::BogusInvalidDNSKEYProtocol]); - addGetStat("x-dnssec-result-indeterminate", &g_stats.xdnssecResults[vState::Indeterminate]); - addGetStat("x-dnssec-result-nta", &g_stats.xdnssecResults[vState::NTA]); - addGetStat("x-dnssec-result-insecure", &g_stats.xdnssecResults[vState::Insecure]); - addGetStat("x-dnssec-result-secure", &g_stats.xdnssecResults[vState::Secure]); - } - - addGetStat("policy-result-noaction", &g_stats.policyResults[DNSFilterEngine::PolicyKind::NoAction]); - addGetStat("policy-result-drop", &g_stats.policyResults[DNSFilterEngine::PolicyKind::Drop]); - addGetStat("policy-result-nxdomain", &g_stats.policyResults[DNSFilterEngine::PolicyKind::NXDOMAIN]); - addGetStat("policy-result-nodata", &g_stats.policyResults[DNSFilterEngine::PolicyKind::NODATA]); - addGetStat("policy-result-truncate", &g_stats.policyResults[DNSFilterEngine::PolicyKind::Truncate]); - addGetStat("policy-result-custom", &g_stats.policyResults[DNSFilterEngine::PolicyKind::Custom]); + addGetStat("x-dnssec-result-bogus-no-valid-dnskey", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusNoValidDNSKEY); }); + addGetStat("x-dnssec-result-bogus-invalid-denial", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusInvalidDenial); }); + addGetStat("x-dnssec-result-bogus-unable-to-get-dss", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusUnableToGetDSs); }); + addGetStat("x-dnssec-result-bogus-unable-to-get-dnskeys", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusUnableToGetDNSKEYs); }); + addGetStat("x-dnssec-result-bogus-self-signed-ds", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusSelfSignedDS); }); + addGetStat("x-dnssec-result-bogus-no-rrsig", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusNoRRSIG); }); + addGetStat("x-dnssec-result-bogus-no-valid-rrsig", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusNoValidRRSIG); }); + addGetStat("x-dnssec-result-bogus-missing-negative-indication", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusMissingNegativeIndication); }); + addGetStat("x-dnssec-result-bogus-signature-not-yet-valid", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusSignatureNotYetValid); }); + addGetStat("x-dnssec-result-bogus-signature-expired", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusSignatureExpired); }); + addGetStat("x-dnssec-result-bogus-unsupported-dnskey-algo", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusUnsupportedDNSKEYAlgo); }); + addGetStat("x-dnssec-result-bogus-unsupported-ds-digest-type", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusUnsupportedDSDigestType); }); + addGetStat("x-dnssec-result-bogus-no-zone-key-bit-set", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusNoZoneKeyBitSet); }); + addGetStat("x-dnssec-result-bogus-revoked-dnskey", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusRevokedDNSKEY); }); + addGetStat("x-dnssec-result-bogus-invalid-dnskey-protocol", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::BogusInvalidDNSKEYProtocol); }); + addGetStat("x-dnssec-result-indeterminate", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::Indeterminate); }); + addGetStat("x-dnssec-result-nta", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::NTA); }); + addGetStat("x-dnssec-result-insecure", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::Insecure); }); + addGetStat("x-dnssec-result-secure", [] { return g_Counters.sum(rec::DNSSECHistogram::xdnssec).at(vState::Secure); }); + } + + addGetStat("policy-result-noaction", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::NoAction); }); + addGetStat("policy-result-drop", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::Drop); }); + addGetStat("policy-result-nxdomain", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::NXDOMAIN); }); + addGetStat("policy-result-nodata", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::NODATA); }); + addGetStat("policy-result-truncate", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::Truncate); }); + addGetStat("policy-result-custom", [] { return g_Counters.sum(rec::PolicyHistogram::policy).at(DNSFilterEngine::PolicyKind::Custom); }); addGetStat("rebalanced-queries", [] { return g_Counters.sum(rec::Counter::rebalancedQueries); }); diff --git a/pdns/recursordist/syncres.cc b/pdns/recursordist/syncres.cc index 79201e4f0f..83a639e002 100644 --- a/pdns/recursordist/syncres.cc +++ b/pdns/recursordist/syncres.cc @@ -3237,7 +3237,8 @@ void SyncRes::handlePolicyHit(const std::string& prefix, const DNSName& qname, c /* don't account truncate actions for TCP queries, since they are not applied */ if (d_appliedPolicy.d_kind != DNSFilterEngine::PolicyKind::Truncate || !d_queryReceivedOverTCP) { - ++g_stats.policyResults[d_appliedPolicy.d_kind]; + t_Counters.at(rec::PolicyHistogram::policy).at(d_appliedPolicy.d_kind)++; + //++g_stats.policyResults[d_appliedPolicy.d_kind]; ++(g_stats.policyHits.lock()->operator[](d_appliedPolicy.getName())); } diff --git a/pdns/recursordist/syncres.hh b/pdns/recursordist/syncres.hh index 097e1db7d2..dedceb1d93 100644 --- a/pdns/recursordist/syncres.hh +++ b/pdns/recursordist/syncres.hh @@ -773,11 +773,7 @@ extern thread_local rec::TCounters t_Counters; struct RecursorStats { - time_t startupTime{time(nullptr)}; - // XXX Convert counter below to be part of rec::Counters - std::map dnssecResults; - std::map xdnssecResults; - std::map policyResults; + // XXX Convert counters below to be part of rec::Counters LockGuarded> policyHits; }; diff --git a/pdns/recursordist/validate-recursor.cc b/pdns/recursordist/validate-recursor.cc index a8b0ae8755..ba8c2cae21 100644 --- a/pdns/recursordist/validate-recursor.cc +++ b/pdns/recursordist/validate-recursor.cc @@ -6,6 +6,7 @@ #include "dnssecinfra.hh" #include "dnsseckeeper.hh" #include "zoneparser-tng.hh" +#include "rec-tcounters.hh" DNSSECMode g_dnssecmode{DNSSECMode::ProcessNoValidate}; bool g_dnssecLogBogus; @@ -30,13 +31,13 @@ bool warnIfDNSSECDisabled(const string& msg) vState increaseDNSSECStateCounter(const vState& state) { - g_stats.dnssecResults[state]++; + t_Counters.at(rec::DNSSECHistogram::dnssec).at(state)++; return state; } vState increaseXDNSSECStateCounter(const vState& state) { - g_stats.xdnssecResults[state]++; + t_Counters.at(rec::DNSSECHistogram::xdnssec).at(state)++; return state; }