Move DNSSEC and Policy counters to TCounter object

diff --git a/pdns/recursordist/pdns_recursor.cc b/pdns/recursordist/pdns_recursor.cc
index 3937e10db51ca6153398c977daa1d281fc1aefd2..010b511cbe78089044f3d9aa40d0acb9384f17fe 100644 (file)
--- 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 23d2cb77a86f714c371260852e2c0ef28ecb6eb2..680afb5929cbfa336b02db51c25ceeb20b41ec85 100644 (file)
--- 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 6947228723768e2a821584fd8304160569aac889..9aa09962203439d93baaba112802781a905a8b05 100644 (file)
--- 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<size_t>(index));
+    }
+    std::array<uint64_t, static_cast<size_t>(vState::BogusInvalidDNSKEYProtocol) + 1> counts;
+  };
+  std::array<DNSSECCounters, static_cast<size_t>(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<size_t>(index));
+    }
+    std::array<uint64_t, static_cast<size_t>(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<size_t>(index));
   }
 
+  DNSSECCounters& at(DNSSECHistogram index)
+  {
+    return dnssecCounters.at(static_cast<size_t>(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 6dbc29353185ab1415485cec98a72da0bdc595be..48fd3bf97ea47cbbcb2add69767d72377da6073b 100644 (file)
--- 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<vState> 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<vState> 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 79201e4f0f174b1a80d5fb93279785a27c947892..83a639e002e5a9d011fe1403c5c97019fb867a6c 100644 (file)
--- 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 097e1db7d262b76c4e4dd43ba939768b6ff0a324..dedceb1d9338935898867a8f1a06fb817d949ab7 100644 (file)
--- 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<vState, pdns::stat_t> dnssecResults;
-  std::map<vState, pdns::stat_t> xdnssecResults;
-  std::map<DNSFilterEngine::PolicyKind, pdns::stat_t> policyResults;
+  // XXX Convert counters below to be part of rec::Counters
   LockGuarded<std::unordered_map<std::string, pdns::stat_t>> policyHits;
 };
 

diff --git a/pdns/recursordist/validate-recursor.cc b/pdns/recursordist/validate-recursor.cc
index a8b0ae87554adbe44dac7112a4544c10cde20295..ba8c2cae219f67a9cf5d351759099cff8f9fc0d5 100644 (file)
--- 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;
 }