6561796397

Committed 18 Oct 2023 01:43PM UTC coverage: 57.727% (+0.3%) from 57.471%

Build # 6561796397

Build Type

Pull #13385

github

Committed by

web-flow

Commit Message

Merge 199e75c7e into 8314f12e9

Pull Request Pull Request #13385: Assorted delinting, mark do while loops as ok

Run Details

31363 of 84880 branches covered (0.0%)

Branch coverage included in aggregate %.

14 of 29 new or added lines in 4 files covered. (48.28%)

17 existing lines in 5 files now uncovered.

105667 of 152494 relevant lines covered (69.29%)

5346147.61 hits per line

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

57.29

/pdns/dnsdist-carbon.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.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "dnsdist-carbon.hh"
#include "dnsdist.hh"
#include "dnsdist-metrics.hh"

#ifndef DISABLE_CARBON
#include "dolog.hh"
#include "sstuff.hh"
#include "threadname.hh"

namespace dnsdist
{

LockGuarded<Carbon::Config> Carbon::s_config;

static bool doOneCarbonExport(const Carbon::Endpoint& endpoint)
{
  const auto& server = endpoint.server;
  const std::string& namespace_name = endpoint.namespace_name;
  const std::string& hostname = endpoint.ourname;
  const std::string& instance_name = endpoint.instance_name;

  try {
    Socket s(server.sin4.sin_family, SOCK_STREAM);
    s.setNonBlocking();
    s.connect(server); // we do the connect so the attempt happens while we gather stats
    ostringstream str;

    const time_t now = time(nullptr);

    {
      auto entries = dnsdist::metrics::g_stats.entries.read_lock();
      for (const auto& entry : *entries) {
        str << namespace_name << "." << hostname << "." << instance_name << "." << entry.d_name << ' ';
        if (const auto& val = std::get_if<pdns::stat_t*>(&entry.d_value)) {
          str << (*val)->load();
        }
        else if (const auto& adval = std::get_if<pdns::stat_t_trait<double>*>(&entry.d_value)) {
          str << (*adval)->load();
        }
        else if (const auto& dval = std::get_if<double*>(&entry.d_value)) {
          str << **dval;
        }
        else if (const auto& func = std::get_if<dnsdist::metrics::Stats::statfunction_t>(&entry.d_value)) {
          str << (*func)(entry.d_name);
        }
        str << ' ' << now << "\r\n";
      }
    }

    auto states = g_dstates.getLocal();
    for (const auto& state : *states) {
      string serverName = state->getName().empty() ? state->d_config.remote.toStringWithPort() : state->getName();
      boost::replace_all(serverName, ".", "_");
      const string base = namespace_name + "." + hostname + "." + instance_name + ".servers." + serverName + ".";
      str << base << "queries" << ' ' << state->queries.load() << " " << now << "\r\n";
      str << base << "responses" << ' ' << state->responses.load() << " " << now << "\r\n";
      str << base << "drops" << ' ' << state->reuseds.load() << " " << now << "\r\n";
      str << base << "latency" << ' ' << (state->d_config.availability != DownstreamState::Availability::Down ? state->latencyUsec / 1000.0 : 0) << " " << now << "\r\n";
      str << base << "latencytcp" << ' ' << (state->d_config.availability != DownstreamState::Availability::Down ? state->latencyUsecTCP / 1000.0 : 0) << " " << now << "\r\n";
      str << base << "senderrors" << ' ' << state->sendErrors.load() << " " << now << "\r\n";
      str << base << "outstanding" << ' ' << state->outstanding.load() << " " << now << "\r\n";
      str << base << "tcpdiedsendingquery" << ' ' << state->tcpDiedSendingQuery.load() << " " << now << "\r\n";
      str << base << "tcpdiedreaddingresponse" << ' ' << state->tcpDiedReadingResponse.load() << " " << now << "\r\n";
      str << base << "tcpgaveup" << ' ' << state->tcpGaveUp.load() << " " << now << "\r\n";
      str << base << "tcpreadimeouts" << ' ' << state->tcpReadTimeouts.load() << " " << now << "\r\n";
      str << base << "tcpwritetimeouts" << ' ' << state->tcpWriteTimeouts.load() << " " << now << "\r\n";
      str << base << "tcpconnecttimeouts" << ' ' << state->tcpConnectTimeouts.load() << " " << now << "\r\n";
      str << base << "tcpcurrentconnections" << ' ' << state->tcpCurrentConnections.load() << " " << now << "\r\n";
      str << base << "tcpmaxconcurrentconnections" << ' ' << state->tcpMaxConcurrentConnections.load() << " " << now << "\r\n";
      str << base << "tcpnewconnections" << ' ' << state->tcpNewConnections.load() << " " << now << "\r\n";
      str << base << "tcpreusedconnections" << ' ' << state->tcpReusedConnections.load() << " " << now << "\r\n";
      str << base << "tlsresumptions" << ' ' << state->tlsResumptions.load() << " " << now << "\r\n";
      str << base << "tcpavgqueriesperconnection" << ' ' << state->tcpAvgQueriesPerConnection.load() << " " << now << "\r\n";
      str << base << "tcpavgconnectionduration" << ' ' << state->tcpAvgConnectionDuration.load() << " " << now << "\r\n";
      str << base << "tcptoomanyconcurrentconnections" << ' ' << state->tcpTooManyConcurrentConnections.load() << " " << now << "\r\n";
      str << base << "healthcheckfailures" << ' ' << state->d_healthCheckMetrics.d_failures << " " << now << "\r\n";
      str << base << "healthcheckfailuresparsing" << ' ' << state->d_healthCheckMetrics.d_parseErrors << " " << now << "\r\n";
      str << base << "healthcheckfailurestimeout" << ' ' << state->d_healthCheckMetrics.d_timeOuts << " " << now << "\r\n";
      str << base << "healthcheckfailuresnetwork" << ' ' << state->d_healthCheckMetrics.d_networkErrors << " " << now << "\r\n";
      str << base << "healthcheckfailuresmismatch" << ' ' << state->d_healthCheckMetrics.d_mismatchErrors << " " << now << "\r\n";
      str << base << "healthcheckfailuresinvalid" << ' ' << state->d_healthCheckMetrics.d_invalidResponseErrors << " " << now << "\r\n";
    }

    std::map<std::string, uint64_t> frontendDuplicates;
    for (const auto& front : g_frontends) {
      if (front->udpFD == -1 && front->tcpFD == -1) {
        continue;
      }

      string frontName = front->local.toStringWithPort() + (front->udpFD >= 0 ? "_udp" : "_tcp");
      boost::replace_all(frontName, ".", "_");
      auto dupPair = frontendDuplicates.insert({frontName, 1});
      if (!dupPair.second) {
        frontName = frontName + "_" + std::to_string(dupPair.first->second);
        ++(dupPair.first->second);
      }

      const string base = namespace_name + "." + hostname + "." + instance_name + ".frontends." + frontName + ".";
      str << base << "queries" << ' ' << front->queries.load() << " " << now << "\r\n";
      str << base << "responses" << ' ' << front->responses.load() << " " << now << "\r\n";
      str << base << "tcpdiedreadingquery" << ' ' << front->tcpDiedReadingQuery.load() << " " << now << "\r\n";
      str << base << "tcpdiedsendingresponse" << ' ' << front->tcpDiedSendingResponse.load() << " " << now << "\r\n";
      str << base << "tcpgaveup" << ' ' << front->tcpGaveUp.load() << " " << now << "\r\n";
      str << base << "tcpclienttimeouts" << ' ' << front->tcpClientTimeouts.load() << " " << now << "\r\n";
      str << base << "tcpdownstreamtimeouts" << ' ' << front->tcpDownstreamTimeouts.load() << " " << now << "\r\n";
      str << base << "tcpcurrentconnections" << ' ' << front->tcpCurrentConnections.load() << " " << now << "\r\n";
      str << base << "tcpmaxconcurrentconnections" << ' ' << front->tcpMaxConcurrentConnections.load() << " " << now << "\r\n";
      str << base << "tcpavgqueriesperconnection" << ' ' << front->tcpAvgQueriesPerConnection.load() << " " << now << "\r\n";
      str << base << "tcpavgconnectionduration" << ' ' << front->tcpAvgConnectionDuration.load() << " " << now << "\r\n";
      str << base << "tls10-queries" << ' ' << front->tls10queries.load() << " " << now << "\r\n";
      str << base << "tls11-queries" << ' ' << front->tls11queries.load() << " " << now << "\r\n";
      str << base << "tls12-queries" << ' ' << front->tls12queries.load() << " " << now << "\r\n";
      str << base << "tls13-queries" << ' ' << front->tls13queries.load() << " " << now << "\r\n";
      str << base << "tls-unknown-queries" << ' ' << front->tlsUnknownqueries.load() << " " << now << "\r\n";
      str << base << "tlsnewsessions" << ' ' << front->tlsNewSessions.load() << " " << now << "\r\n";
      str << base << "tlsresumptions" << ' ' << front->tlsResumptions.load() << " " << now << "\r\n";
      str << base << "tlsunknownticketkeys" << ' ' << front->tlsUnknownTicketKey.load() << " " << now << "\r\n";
      str << base << "tlsinactiveticketkeys" << ' ' << front->tlsInactiveTicketKey.load() << " " << now << "\r\n";

      const TLSErrorCounters* errorCounters = nullptr;
      if (front->tlsFrontend != nullptr) {
        errorCounters = &front->tlsFrontend->d_tlsCounters;
      }
      else if (front->dohFrontend != nullptr) {
        errorCounters = &front->dohFrontend->d_tlsContext.d_tlsCounters;
      }
      if (errorCounters != nullptr) {
        str << base << "tlsdhkeytoosmall" << ' ' << errorCounters->d_dhKeyTooSmall << " " << now << "\r\n";
        str << base << "tlsinappropriatefallback" << ' ' << errorCounters->d_inappropriateFallBack << " " << now << "\r\n";
        str << base << "tlsnosharedcipher" << ' ' << errorCounters->d_noSharedCipher << " " << now << "\r\n";
        str << base << "tlsunknownciphertype" << ' ' << errorCounters->d_unknownCipherType << " " << now << "\r\n";
        str << base << "tlsunknownkeyexchangetype" << ' ' << errorCounters->d_unknownKeyExchangeType << " " << now << "\r\n";
        str << base << "tlsunknownprotocol" << ' ' << errorCounters->d_unknownProtocol << " " << now << "\r\n";
        str << base << "tlsunsupportedec" << ' ' << errorCounters->d_unsupportedEC << " " << now << "\r\n";
        str << base << "tlsunsupportedprotocol" << ' ' << errorCounters->d_unsupportedProtocol << " " << now << "\r\n";
      }
    }

    auto localPools = g_pools.getLocal();
    for (const auto& entry : *localPools) {
      string poolName = entry.first;
      boost::replace_all(poolName, ".", "_");
      if (poolName.empty()) {
        poolName = "_default_";
      }
      const string base = namespace_name + "." + hostname + "." + instance_name + ".pools." + poolName + ".";
      const std::shared_ptr<ServerPool> pool = entry.second;
      str << base << "servers"
          << " " << pool->countServers(false) << " " << now << "\r\n";
      str << base << "servers-up"
          << " " << pool->countServers(true) << " " << now << "\r\n";
      if (pool->packetCache != nullptr) {
        const auto& cache = pool->packetCache;
        str << base << "cache-size"
            << " " << cache->getMaxEntries() << " " << now << "\r\n";
        str << base << "cache-entries"
            << " " << cache->getEntriesCount() << " " << now << "\r\n";
        str << base << "cache-hits"
            << " " << cache->getHits() << " " << now << "\r\n";
        str << base << "cache-misses"
            << " " << cache->getMisses() << " " << now << "\r\n";
        str << base << "cache-deferred-inserts"
            << " " << cache->getDeferredInserts() << " " << now << "\r\n";
        str << base << "cache-deferred-lookups"
            << " " << cache->getDeferredLookups() << " " << now << "\r\n";
        str << base << "cache-lookup-collisions"
            << " " << cache->getLookupCollisions() << " " << now << "\r\n";
        str << base << "cache-insert-collisions"
            << " " << cache->getInsertCollisions() << " " << now << "\r\n";
        str << base << "cache-ttl-too-shorts"
            << " " << cache->getTTLTooShorts() << " " << now << "\r\n";
        str << base << "cache-cleanup-count"
            << " " << cache->getCleanupCount() << " " << now << "\r\n";
      }
    }

#ifdef HAVE_DNS_OVER_HTTPS
    {
      std::map<std::string, uint64_t> dohFrontendDuplicates;
      const string base = "dnsdist." + hostname + ".main.doh.";
      for (const auto& doh : g_dohlocals) {
        string name = doh->d_tlsContext.d_addr.toStringWithPort();
        boost::replace_all(name, ".", "_");
        boost::replace_all(name, ":", "_");
        boost::replace_all(name, "[", "_");
        boost::replace_all(name, "]", "_");

        auto dupPair = dohFrontendDuplicates.insert({name, 1});
        if (!dupPair.second) {
          name = name + "_" + std::to_string(dupPair.first->second);
          ++(dupPair.first->second);
        }

        vector<pair<const char*, const pdns::stat_t&>> v{
          {"http-connects", doh->d_httpconnects},
          {"http1-queries", doh->d_http1Stats.d_nbQueries},
          {"http2-queries", doh->d_http2Stats.d_nbQueries},
          {"http1-200-responses", doh->d_http1Stats.d_nb200Responses},
          {"http2-200-responses", doh->d_http2Stats.d_nb200Responses},
          {"http1-400-responses", doh->d_http1Stats.d_nb400Responses},
          {"http2-400-responses", doh->d_http2Stats.d_nb400Responses},
          {"http1-403-responses", doh->d_http1Stats.d_nb403Responses},
          {"http2-403-responses", doh->d_http2Stats.d_nb403Responses},
          {"http1-500-responses", doh->d_http1Stats.d_nb500Responses},
          {"http2-500-responses", doh->d_http2Stats.d_nb500Responses},
          {"http1-502-responses", doh->d_http1Stats.d_nb502Responses},
          {"http2-502-responses", doh->d_http2Stats.d_nb502Responses},
          {"http1-other-responses", doh->d_http1Stats.d_nbOtherResponses},
          {"http2-other-responses", doh->d_http2Stats.d_nbOtherResponses},
          {"get-queries", doh->d_getqueries},
          {"post-queries", doh->d_postqueries},
          {"bad-requests", doh->d_badrequests},
          {"error-responses", doh->d_errorresponses},
          {"redirect-responses", doh->d_redirectresponses},
          {"valid-responses", doh->d_validresponses}};

        for (const auto& item : v) {
          str << base << name << "." << item.first << " " << item.second << " " << now << "\r\n";
        }
      }
    }
#endif /* HAVE_DNS_OVER_HTTPS */

    {
      std::string qname;
      auto records = g_qcount.records.write_lock();
      for (const auto& record : *records) {
        qname = record.first;
        boost::replace_all(qname, ".", "_");
        str << "dnsdist.querycount." << qname << ".queries " << record.second << " " << now << "\r\n";
      }
      records->clear();
    }

    const string msg = str.str();

    int ret = waitForRWData(s.getHandle(), false, 1, 0);
    if (ret <= 0) {
      vinfolog("Unable to write data to carbon server on %s: %s", server.toStringWithPort(), (ret < 0 ? stringerror() : "Timeout"));
      return false;
    }
    s.setBlocking();
    writen2(s.getHandle(), msg.c_str(), msg.size());
  }
  catch (const std::exception& e) {
    warnlog("Problem sending carbon data to %s: %s", server.toStringWithPort(), e.what());
    return false;
  }

  return true;
}

static void carbonHandler(Carbon::Endpoint&& endpoint)
{
  setThreadName("dnsdist/carbon");
  const auto intervalUSec = endpoint.interval * 1000 * 1000;

  try {
    uint8_t consecutiveFailures = 0;
    do {
      DTime dt;
      dt.set();
      if (doOneCarbonExport(endpoint)) {
        const auto elapsedUSec = dt.udiff();
        if (elapsedUSec < 0 || static_cast<unsigned int>(elapsedUSec) <= intervalUSec) {
          useconds_t toSleepUSec = intervalUSec - elapsedUSec;
          usleep(toSleepUSec);
        }
        else {
          vinfolog("Carbon export for %s took longer (%s us) than the configured interval (%d us)", endpoint.server.toStringWithPort(), elapsedUSec, intervalUSec);
        }
        consecutiveFailures = 0;
      }
      else {
        /* maximum interval between two attempts is 10 minutes */
        const time_t maxBackOff = 10 * 60;
        time_t backOff = 1;
        double backOffTmp = std::pow(2.0, static_cast<double>(consecutiveFailures));
        if (backOffTmp != HUGE_VAL && static_cast<uint64_t>(backOffTmp) <= static_cast<uint64_t>(std::numeric_limits<time_t>::max())) {
          backOff = static_cast<time_t>(backOffTmp);
          if (backOff > maxBackOff) {
            backOff = maxBackOff;
          }
        }
        if (consecutiveFailures < std::numeric_limits<decltype(consecutiveFailures)>::max()) {
          consecutiveFailures++;
        }
        vinfolog("Run for %s - %s failed, next attempt in %d", endpoint.server.toStringWithPort(), endpoint.ourname, backOff);
        sleep(backOff);
      }
    } while (true);
  }
  catch (const PDNSException& e) {
    errlog("Carbon thread for %s died, PDNSException: %s", endpoint.server.toStringWithPort(), e.reason);
  }
  catch (...) {
    errlog("Carbon thread for %s died", endpoint.server.toStringWithPort());
  }
}

bool Carbon::addEndpoint(Carbon::Endpoint&& endpoint)
{
  if (endpoint.ourname.empty()) {
    try {
      endpoint.ourname = getCarbonHostName();
    }
    catch (const std::exception& e) {
      throw std::runtime_error(std::string("The 'ourname' setting in 'carbonServer()' has not been set and we are unable to determine the system's hostname: ") + e.what());
    }
  }

  auto config = s_config.lock();
  if (config->d_running) {
    // we already started the threads, let's just spawn a new one
    std::thread newHandler(carbonHandler, std::move(endpoint));
    newHandler.detach();
  }
  else {
    config->d_endpoints.push_back(std::move(endpoint));
  }
  return true;
}

void Carbon::run()
{
  auto config = s_config.lock();
  if (config->d_running) {
    throw std::runtime_error("The carbon threads are already running");
  }
  for (auto& endpoint : config->d_endpoints) {
    std::thread newHandler(carbonHandler, std::move(endpoint));
    newHandler.detach();
  }
  config->d_endpoints.clear();
  config->d_running = true;
}

}
#endif /* DISABLE_CARBON */

static time_t s_start = time(nullptr);

uint64_t uptimeOfProcess(const std::string& str)
{
  return time(nullptr) - s_start;
}

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	#ifdef HAVE_CONFIG_H
23	#include "config.h"
24	#endif
25
26	#include "dnsdist-carbon.hh"
27	#include "dnsdist.hh"
28	#include "dnsdist-metrics.hh"
29
30	#ifndef DISABLE_CARBON
31	#include "dolog.hh"
32	#include "sstuff.hh"
33	#include "threadname.hh"
34
35	namespace dnsdist
36	{
37
38	LockGuarded<Carbon::Config> Carbon::s_config;
39
40	static bool doOneCarbonExport(const Carbon::Endpoint& endpoint)
41	{	16✔
42	const auto& server = endpoint.server;	16✔
43	const std::string& namespace_name = endpoint.namespace_name;	16✔
44	const std::string& hostname = endpoint.ourname;	16✔
45	const std::string& instance_name = endpoint.instance_name;	16✔
46
47	try {	16✔
48	Socket s(server.sin4.sin_family, SOCK_STREAM);	16✔
49	s.setNonBlocking();	16✔
50	s.connect(server); // we do the connect so the attempt happens while we gather stats	16✔
51	ostringstream str;	16✔
52
53	const time_t now = time(nullptr);	16✔
54
55	{	16✔
56	auto entries = dnsdist::metrics::g_stats.entries.read_lock();	16✔
57	for (const auto& entry : *entries) {	1,231✔
58	str << namespace_name << "." << hostname << "." << instance_name << "." << entry.d_name << ' ';	1,231✔
59	if (const auto& val = std::get_if<pdns::stat_t*>(&entry.d_value)) {	1,231✔
60	str << (*val)->load();	655✔
61	}	655✔
62	else if (const auto& adval = std::get_if<pdns::stat_t_trait<double>*>(&entry.d_value)) {	576!
63	str << (*adval)->load();	×
64	}	×
65	else if (const auto& dval = std::get_if<double*>(&entry.d_value)) {	576✔
66	str << **dval;	256✔
67	}	256✔
68	else if (const auto& func = std::get_if<dnsdist::metrics::Stats::statfunction_t>(&entry.d_value)) {	320✔
69	str << (*func)(entry.d_name);	319✔
70	}	319✔
71	str << ' ' << now << "\r\n";	1,231✔
72	}	1,231✔
73	}	16✔
74
75	auto states = g_dstates.getLocal();	16✔
76	for (const auto& state : *states) {	48✔
77	string serverName = state->getName().empty() ? state->d_config.remote.toStringWithPort() : state->getName();	48!
78	boost::replace_all(serverName, ".", "_");	48✔
79	const string base = namespace_name + "." + hostname + "." + instance_name + ".servers." + serverName + ".";	48✔
80	str << base << "queries" << ' ' << state->queries.load() << " " << now << "\r\n";	48✔
81	str << base << "responses" << ' ' << state->responses.load() << " " << now << "\r\n";	48✔
82	str << base << "drops" << ' ' << state->reuseds.load() << " " << now << "\r\n";	48✔
83	str << base << "latency" << ' ' << (state->d_config.availability != DownstreamState::Availability::Down ? state->latencyUsec / 1000.0 : 0) << " " << now << "\r\n";	48✔
84	str << base << "latencytcp" << ' ' << (state->d_config.availability != DownstreamState::Availability::Down ? state->latencyUsecTCP / 1000.0 : 0) << " " << now << "\r\n";	48✔
85	str << base << "senderrors" << ' ' << state->sendErrors.load() << " " << now << "\r\n";	48✔
86	str << base << "outstanding" << ' ' << state->outstanding.load() << " " << now << "\r\n";	48✔
87	str << base << "tcpdiedsendingquery" << ' ' << state->tcpDiedSendingQuery.load() << " " << now << "\r\n";	48✔
88	str << base << "tcpdiedreaddingresponse" << ' ' << state->tcpDiedReadingResponse.load() << " " << now << "\r\n";	48✔
89	str << base << "tcpgaveup" << ' ' << state->tcpGaveUp.load() << " " << now << "\r\n";	48✔
90	str << base << "tcpreadimeouts" << ' ' << state->tcpReadTimeouts.load() << " " << now << "\r\n";	48✔
91	str << base << "tcpwritetimeouts" << ' ' << state->tcpWriteTimeouts.load() << " " << now << "\r\n";	48✔
92	str << base << "tcpconnecttimeouts" << ' ' << state->tcpConnectTimeouts.load() << " " << now << "\r\n";	48✔
93	str << base << "tcpcurrentconnections" << ' ' << state->tcpCurrentConnections.load() << " " << now << "\r\n";	48✔
94	str << base << "tcpmaxconcurrentconnections" << ' ' << state->tcpMaxConcurrentConnections.load() << " " << now << "\r\n";	48✔
95	str << base << "tcpnewconnections" << ' ' << state->tcpNewConnections.load() << " " << now << "\r\n";	48✔
96	str << base << "tcpreusedconnections" << ' ' << state->tcpReusedConnections.load() << " " << now << "\r\n";	48✔
97	str << base << "tlsresumptions" << ' ' << state->tlsResumptions.load() << " " << now << "\r\n";	48✔
98	str << base << "tcpavgqueriesperconnection" << ' ' << state->tcpAvgQueriesPerConnection.load() << " " << now << "\r\n";	48✔
99	str << base << "tcpavgconnectionduration" << ' ' << state->tcpAvgConnectionDuration.load() << " " << now << "\r\n";	48✔
100	str << base << "tcptoomanyconcurrentconnections" << ' ' << state->tcpTooManyConcurrentConnections.load() << " " << now << "\r\n";	48✔
101	str << base << "healthcheckfailures" << ' ' << state->d_healthCheckMetrics.d_failures << " " << now << "\r\n";	48✔
102	str << base << "healthcheckfailuresparsing" << ' ' << state->d_healthCheckMetrics.d_parseErrors << " " << now << "\r\n";	48✔
103	str << base << "healthcheckfailurestimeout" << ' ' << state->d_healthCheckMetrics.d_timeOuts << " " << now << "\r\n";	48✔
104	str << base << "healthcheckfailuresnetwork" << ' ' << state->d_healthCheckMetrics.d_networkErrors << " " << now << "\r\n";	48✔
105	str << base << "healthcheckfailuresmismatch" << ' ' << state->d_healthCheckMetrics.d_mismatchErrors << " " << now << "\r\n";	48✔
106	str << base << "healthcheckfailuresinvalid" << ' ' << state->d_healthCheckMetrics.d_invalidResponseErrors << " " << now << "\r\n";	48✔
107	}	48✔
108
109	std::map<std::string, uint64_t> frontendDuplicates;	16✔
110	for (const auto& front : g_frontends) {	32✔
111	if (front->udpFD == -1 && front->tcpFD == -1) {	32!
112	continue;	×
113	}	×
114
115	string frontName = front->local.toStringWithPort() + (front->udpFD >= 0 ? "_udp" : "_tcp");	32✔
116	boost::replace_all(frontName, ".", "_");	32✔
117	auto dupPair = frontendDuplicates.insert({frontName, 1});	32✔
118	if (!dupPair.second) {	32!
119	frontName = frontName + "_" + std::to_string(dupPair.first->second);	×
120	++(dupPair.first->second);	×
121	}	×
122
123	const string base = namespace_name + "." + hostname + "." + instance_name + ".frontends." + frontName + ".";	32✔
124	str << base << "queries" << ' ' << front->queries.load() << " " << now << "\r\n";	32✔
125	str << base << "responses" << ' ' << front->responses.load() << " " << now << "\r\n";	32✔
126	str << base << "tcpdiedreadingquery" << ' ' << front->tcpDiedReadingQuery.load() << " " << now << "\r\n";	32✔
127	str << base << "tcpdiedsendingresponse" << ' ' << front->tcpDiedSendingResponse.load() << " " << now << "\r\n";	32✔
128	str << base << "tcpgaveup" << ' ' << front->tcpGaveUp.load() << " " << now << "\r\n";	32✔
129	str << base << "tcpclienttimeouts" << ' ' << front->tcpClientTimeouts.load() << " " << now << "\r\n";	32✔
130	str << base << "tcpdownstreamtimeouts" << ' ' << front->tcpDownstreamTimeouts.load() << " " << now << "\r\n";	32✔
131	str << base << "tcpcurrentconnections" << ' ' << front->tcpCurrentConnections.load() << " " << now << "\r\n";	32✔
132	str << base << "tcpmaxconcurrentconnections" << ' ' << front->tcpMaxConcurrentConnections.load() << " " << now << "\r\n";	32✔
133	str << base << "tcpavgqueriesperconnection" << ' ' << front->tcpAvgQueriesPerConnection.load() << " " << now << "\r\n";	32✔
134	str << base << "tcpavgconnectionduration" << ' ' << front->tcpAvgConnectionDuration.load() << " " << now << "\r\n";	32✔
135	str << base << "tls10-queries" << ' ' << front->tls10queries.load() << " " << now << "\r\n";	32✔
136	str << base << "tls11-queries" << ' ' << front->tls11queries.load() << " " << now << "\r\n";	32✔
137	str << base << "tls12-queries" << ' ' << front->tls12queries.load() << " " << now << "\r\n";	32✔
138	str << base << "tls13-queries" << ' ' << front->tls13queries.load() << " " << now << "\r\n";	32✔
139	str << base << "tls-unknown-queries" << ' ' << front->tlsUnknownqueries.load() << " " << now << "\r\n";	32✔
140	str << base << "tlsnewsessions" << ' ' << front->tlsNewSessions.load() << " " << now << "\r\n";	32✔
141	str << base << "tlsresumptions" << ' ' << front->tlsResumptions.load() << " " << now << "\r\n";	32✔
142	str << base << "tlsunknownticketkeys" << ' ' << front->tlsUnknownTicketKey.load() << " " << now << "\r\n";	32✔
143	str << base << "tlsinactiveticketkeys" << ' ' << front->tlsInactiveTicketKey.load() << " " << now << "\r\n";	32✔
144
145	const TLSErrorCounters* errorCounters = nullptr;	32✔
146	if (front->tlsFrontend != nullptr) {	32!
147	errorCounters = &front->tlsFrontend->d_tlsCounters;	×
148	}	×
149	else if (front->dohFrontend != nullptr) {	32!
150	errorCounters = &front->dohFrontend->d_tlsContext.d_tlsCounters;	×
151	}	×
152	if (errorCounters != nullptr) {	32!
153	str << base << "tlsdhkeytoosmall" << ' ' << errorCounters->d_dhKeyTooSmall << " " << now << "\r\n";	×
154	str << base << "tlsinappropriatefallback" << ' ' << errorCounters->d_inappropriateFallBack << " " << now << "\r\n";	×
155	str << base << "tlsnosharedcipher" << ' ' << errorCounters->d_noSharedCipher << " " << now << "\r\n";	×
156	str << base << "tlsunknownciphertype" << ' ' << errorCounters->d_unknownCipherType << " " << now << "\r\n";	×
157	str << base << "tlsunknownkeyexchangetype" << ' ' << errorCounters->d_unknownKeyExchangeType << " " << now << "\r\n";	×
158	str << base << "tlsunknownprotocol" << ' ' << errorCounters->d_unknownProtocol << " " << now << "\r\n";	×
159	str << base << "tlsunsupportedec" << ' ' << errorCounters->d_unsupportedEC << " " << now << "\r\n";	×
160	str << base << "tlsunsupportedprotocol" << ' ' << errorCounters->d_unsupportedProtocol << " " << now << "\r\n";	×
161	}	×
162	}	32✔
163
164	auto localPools = g_pools.getLocal();	16✔
165	for (const auto& entry : *localPools) {	16✔
166	string poolName = entry.first;	16✔
167	boost::replace_all(poolName, ".", "_");	16✔
168	if (poolName.empty()) {	16!
169	poolName = "_default_";	16✔
170	}	16✔
171	const string base = namespace_name + "." + hostname + "." + instance_name + ".pools." + poolName + ".";	16✔
172	const std::shared_ptr<ServerPool> pool = entry.second;	16✔
173	str << base << "servers"	16✔
174	<< " " << pool->countServers(false) << " " << now << "\r\n";	16✔
175	str << base << "servers-up"	16✔
176	<< " " << pool->countServers(true) << " " << now << "\r\n";	16✔
177	if (pool->packetCache != nullptr) {	16!
178	const auto& cache = pool->packetCache;	×
179	str << base << "cache-size"	×
180	<< " " << cache->getMaxEntries() << " " << now << "\r\n";	×
181	str << base << "cache-entries"	×
182	<< " " << cache->getEntriesCount() << " " << now << "\r\n";	×
183	str << base << "cache-hits"	×
184	<< " " << cache->getHits() << " " << now << "\r\n";	×
185	str << base << "cache-misses"	×
186	<< " " << cache->getMisses() << " " << now << "\r\n";	×
187	str << base << "cache-deferred-inserts"	×
188	<< " " << cache->getDeferredInserts() << " " << now << "\r\n";	×
189	str << base << "cache-deferred-lookups"	×
190	<< " " << cache->getDeferredLookups() << " " << now << "\r\n";	×
191	str << base << "cache-lookup-collisions"	×
192	<< " " << cache->getLookupCollisions() << " " << now << "\r\n";	×
193	str << base << "cache-insert-collisions"	×
194	<< " " << cache->getInsertCollisions() << " " << now << "\r\n";	×
195	str << base << "cache-ttl-too-shorts"	×
196	<< " " << cache->getTTLTooShorts() << " " << now << "\r\n";	×
197	str << base << "cache-cleanup-count"	×
198	<< " " << cache->getCleanupCount() << " " << now << "\r\n";	×
199	}	×
200	}	16✔
201
202	#ifdef HAVE_DNS_OVER_HTTPS	16✔
203	{	16✔
204	std::map<std::string, uint64_t> dohFrontendDuplicates;	16✔
205	const string base = "dnsdist." + hostname + ".main.doh.";	16✔
206	for (const auto& doh : g_dohlocals) {	16!
207	string name = doh->d_tlsContext.d_addr.toStringWithPort();	×
208	boost::replace_all(name, ".", "_");	×
209	boost::replace_all(name, ":", "_");	×
210	boost::replace_all(name, "[", "_");	×
211	boost::replace_all(name, "]", "_");	×
212
213	auto dupPair = dohFrontendDuplicates.insert({name, 1});	×
214	if (!dupPair.second) {	×
215	name = name + "_" + std::to_string(dupPair.first->second);	×
216	++(dupPair.first->second);	×
217	}	×
218
219	vector<pair<const char*, const pdns::stat_t&>> v{	×
220	{"http-connects", doh->d_httpconnects},	×
221	{"http1-queries", doh->d_http1Stats.d_nbQueries},	×
222	{"http2-queries", doh->d_http2Stats.d_nbQueries},	×
223	{"http1-200-responses", doh->d_http1Stats.d_nb200Responses},	×
224	{"http2-200-responses", doh->d_http2Stats.d_nb200Responses},	×
225	{"http1-400-responses", doh->d_http1Stats.d_nb400Responses},	×
226	{"http2-400-responses", doh->d_http2Stats.d_nb400Responses},	×
227	{"http1-403-responses", doh->d_http1Stats.d_nb403Responses},	×
228	{"http2-403-responses", doh->d_http2Stats.d_nb403Responses},	×
229	{"http1-500-responses", doh->d_http1Stats.d_nb500Responses},	×
230	{"http2-500-responses", doh->d_http2Stats.d_nb500Responses},	×
231	{"http1-502-responses", doh->d_http1Stats.d_nb502Responses},	×
232	{"http2-502-responses", doh->d_http2Stats.d_nb502Responses},	×
233	{"http1-other-responses", doh->d_http1Stats.d_nbOtherResponses},	×
234	{"http2-other-responses", doh->d_http2Stats.d_nbOtherResponses},	×
235	{"get-queries", doh->d_getqueries},	×
236	{"post-queries", doh->d_postqueries},	×
237	{"bad-requests", doh->d_badrequests},	×
238	{"error-responses", doh->d_errorresponses},	×
239	{"redirect-responses", doh->d_redirectresponses},	×
240	{"valid-responses", doh->d_validresponses}};	×
241
242	for (const auto& item : v) {	×
243	str << base << name << "." << item.first << " " << item.second << " " << now << "\r\n";	×
244	}	×
245	}	×
246	}	16✔
247	#endif /* HAVE_DNS_OVER_HTTPS */	16✔
248
249	{	16✔
250	std::string qname;	16✔
251	auto records = g_qcount.records.write_lock();	16✔
252	for (const auto& record : *records) {	16!
253	qname = record.first;	×
254	boost::replace_all(qname, ".", "_");	×
255	str << "dnsdist.querycount." << qname << ".queries " << record.second << " " << now << "\r\n";	×
256	}	×
257	records->clear();	16✔
258	}	16✔
259
260	const string msg = str.str();	16✔
261
262	int ret = waitForRWData(s.getHandle(), false, 1, 0);	16✔
263	if (ret <= 0) {	16!
264	vinfolog("Unable to write data to carbon server on %s: %s", server.toStringWithPort(), (ret < 0 ? stringerror() : "Timeout"));	×
265	return false;	×
266	}	×
267	s.setBlocking();	16✔
268	writen2(s.getHandle(), msg.c_str(), msg.size());	16✔
269	}	16✔
270	catch (const std::exception& e) {	16✔
271	warnlog("Problem sending carbon data to %s: %s", server.toStringWithPort(), e.what());	×
272	return false;	×
273	}	×
274
275	return true;	16✔
276	}	16✔
277
278	static void carbonHandler(Carbon::Endpoint&& endpoint)
279	{	4✔
280	setThreadName("dnsdist/carbon");	4✔
281	const auto intervalUSec = endpoint.interval * 1000 * 1000;	4✔
282
283	try {	4✔
284	uint8_t consecutiveFailures = 0;	4✔
285	do {	16✔
286	DTime dt;	16✔
287	dt.set();	16✔
288	if (doOneCarbonExport(endpoint)) {	16!
289	const auto elapsedUSec = dt.udiff();	16✔
290	if (elapsedUSec < 0 \|\| static_cast<unsigned int>(elapsedUSec) <= intervalUSec) {	16!
291	useconds_t toSleepUSec = intervalUSec - elapsedUSec;	16✔
292	usleep(toSleepUSec);	16✔
293	}	16✔
294	else {	×
295	vinfolog("Carbon export for %s took longer (%s us) than the configured interval (%d us)", endpoint.server.toStringWithPort(), elapsedUSec, intervalUSec);	×
296	}	×
297	consecutiveFailures = 0;	16✔
298	}	16✔
UNCOV 299	else {	×
300	/* maximum interval between two attempts is 10 minutes */
UNCOV 301	const time_t maxBackOff = 10 * 60;	×
UNCOV 302	time_t backOff = 1;	×
UNCOV 303	double backOffTmp = std::pow(2.0, static_cast<double>(consecutiveFailures));	×
UNCOV 304	if (backOffTmp != HUGE_VAL && static_cast<uint64_t>(backOffTmp) <= static_cast<uint64_t>(std::numeric_limits<time_t>::max())) {	×
305	backOff = static_cast<time_t>(backOffTmp);	×
306	if (backOff > maxBackOff) {	×
307	backOff = maxBackOff;	×
308	}	×
309	}	×
UNCOV 310	if (consecutiveFailures < std::numeric_limits<decltype(consecutiveFailures)>::max()) {	×
311	consecutiveFailures++;	×
312	}	×
UNCOV 313	vinfolog("Run for %s - %s failed, next attempt in %d", endpoint.server.toStringWithPort(), endpoint.ourname, backOff);	×
UNCOV 314	sleep(backOff);	×
UNCOV 315	}	×
316	} while (true);	16✔
317	}	4✔
318	catch (const PDNSException& e) {	4✔
319	errlog("Carbon thread for %s died, PDNSException: %s", endpoint.server.toStringWithPort(), e.reason);	×
320	}	×
321	catch (...) {	4✔
322	errlog("Carbon thread for %s died", endpoint.server.toStringWithPort());	×
323	}	×
324	}	4✔
325
326	bool Carbon::addEndpoint(Carbon::Endpoint&& endpoint)
327	{	8✔
328	if (endpoint.ourname.empty()) {	8!
329	try {	×
330	endpoint.ourname = getCarbonHostName();	×
331	}	×
332	catch (const std::exception& e) {	×
333	throw std::runtime_error(std::string("The 'ourname' setting in 'carbonServer()' has not been set and we are unable to determine the system's hostname: ") + e.what());	×
334	}	×
335	}	×
336
337	auto config = s_config.lock();	8✔
338	if (config->d_running) {	8!
339	// we already started the threads, let's just spawn a new one
340	std::thread newHandler(carbonHandler, std::move(endpoint));	×
341	newHandler.detach();	×
342	}	×
343	else {	8✔
344	config->d_endpoints.push_back(std::move(endpoint));	8✔
345	}	8✔
346	return true;	8✔
347	}	8✔
348
349	void Carbon::run()
350	{	558✔
351	auto config = s_config.lock();	558✔
352	if (config->d_running) {	558!
353	throw std::runtime_error("The carbon threads are already running");	×
354	}	×
355	for (auto& endpoint : config->d_endpoints) {	558✔
356	std::thread newHandler(carbonHandler, std::move(endpoint));	4✔
357	newHandler.detach();	4✔
358	}	4✔
359	config->d_endpoints.clear();	558✔
360	config->d_running = true;	558✔
361	}	558✔
362
363	}
364	#endif /* DISABLE_CARBON */
365
366	static time_t s_start = time(nullptr);
367
368	uint64_t uptimeOfProcess(const std::string& str)
369	{	434✔
370	return time(nullptr) - s_start;	434✔
371	}	434✔

PowerDNS / pdns / 6561796397

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