11049514595

Committed 26 Sep 2024 09:30AM UTC coverage: 64.695% (+1.9%) from 62.775%

Build # 11049514595

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14701 from zeha/zeha-13039-refac

auth: move checkForCorrectTSIG into packethandler

Run Details

37071 of 88008 branches covered (42.12%)

Branch coverage included in aggregate %.

38 of 50 new or added lines in 3 files covered. (76.0%)

310 existing lines in 24 files now uncovered.

124816 of 162225 relevant lines covered (76.94%)

5066922.87 hits per line

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

97.37

/pdns/recursordist/logr.hh

/*
 * 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.
 */

#pragma once

#include <array>
#include <string>
#include <memory>
#include <map>

// Minimal logging API based on https://github.com/go-logr/logr

namespace Logr
{
struct Loggable
{
  virtual std::string to_string() const = 0;
};

// In addition to level which specifies the amount of detail and is
// structured so that a derived logger always has a higher level
// than its parent we also have a priority/urgency field that maps
// to the same field of the old logger which in turns has a direct
// mapping to syslog priority. This is done to make it easier to
// move step by step to structured logging. We consider both level
// and priority to select which messages are logged, and a backend
// can further use priority to pass to syslog.

enum Priority : uint8_t
{
  Absent = 0,
  Alert = 1,
  Critical = 2,
  Error = 3,
  Warning = 4,
  Notice = 5,
  Info = 6,
  Debug = 7
};

class Logger
{
public:
  // Enabled tests whether this Logger is enabled.  For example, commandline
  // flags might be used to set the logging verbosity and disable some info
  // logs.
  virtual bool enabled(Priority) const = 0;

  static std::string toString(Priority arg)
  {
    const std::array<std::string, 8> names = {"Absent", "Alert", "Critical", "Error", "Warning", "Notice", "Info", "Debug"};
    auto p = static_cast<unsigned int>(arg);
    if (p >= names.size()) {
      return "?";
    }
    return names.at(p);
  }
  // Info logs a non-error message with the given key/value pairs as context.
  //
  // The msg argument should be used to add some constant description to
  // the log line.  The key/value pairs can then be used to add additional
  // variable information.  The key/value pairs should alternate string
  // keys and arbitrary values.
  virtual void info(const std::string& msg) const = 0;
  virtual void info(Logr::Priority, const std::string& msg) const = 0;

  template <typename... Args>
  void info(const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->info(msg);
  }

  template <typename... Args>
  void info(Priority p, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->info(p, msg);
  }

  // Error logs an error, with the given message and key/value pairs as context.
  // It functions similarly to calling Info with the "error" named value, but may
  // have unique behavior, and should be preferred for logging errors (see the
  // package documentations for more information).
  //
  // The msg field should be used to add context to any underlying error,
  // while the err field should be used to attach the actual error that
  // triggered this log line, if present.
  virtual void error(const std::string& err, const std::string& msg) const = 0;
  virtual void error(int err, const std::string& msg) const = 0;
  virtual void error(Logr::Priority, const std::string& err, const std::string& msg) const = 0;
  virtual void error(Logr::Priority, int err, const std::string& msg) const = 0;

  template <typename... Args>
  void error(const std::string& err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->error(Logr::Absent, err, msg);
  }

  template <typename... Args>
  void error(int err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->error(Logr::Absent, err, msg);
  }

  template <typename... Args>
  void error(Priority p, const std::string& err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->error(p, err, msg);
  }

  template <typename... Args>
  void error(Priority p, int err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
  {
    auto logger = this->withValues(key, value, args...);
    logger->error(p, err, msg);
  }

  // V returns an Logger value for a specific verbosity level, relative to
  // this Logger.  In other words, V values are additive.  V higher verbosity
  // level means a log message is less important.  It's illegal to pass a log
  // level less than zero.
  virtual std::shared_ptr<Logger> v(size_t level) const = 0;

  template <typename... Args>
  std::shared_ptr<Logger> withValues(const std::string& key, const Loggable& value, const Args&... args) const
  {
    std::map<std::string, std::string> map = {};
    this->mapArguments(map, key, value, args...);
    return this->withValues(map);
  }

  // WithValues adds some key-value pairs of context to a logger.
  // See Info for documentation on how key/value pairs work.
  virtual std::shared_ptr<Logger> withValues(const std::map<std::string, std::string>& values) const = 0;

  // WithName adds a new element to the logger's name.
  // Successive calls with WithName continue to append
  // suffixes to the logger's name.  It's strongly recommended
  // that name segments contain only letters, digits, and hyphens
  // (see the package documentation for more information).
  virtual std::shared_ptr<Logger> withName(const std::string& name) const = 0;

private:
  template <typename... Args>
  void mapArguments(std::map<std::string, std::string>& map, const std::string& key, const Loggable& value, const Args&... args) const
  {
    map.emplace(key, value.to_string());
    mapArguments(map, args...);
  }

  void mapArguments(std::map<std::string, std::string>& /* map */) const {}
};

using log_t = const std::shared_ptr<Logger>&;
}

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
23	#pragma once
24
25	#include <array>
26	#include <string>
27	#include <memory>
28	#include <map>
29
30	// Minimal logging API based on https://github.com/go-logr/logr
31
32	namespace Logr
33	{
34	struct Loggable
35	{
36	virtual std::string to_string() const = 0;
37	};
38
39	// In addition to level which specifies the amount of detail and is
40	// structured so that a derived logger always has a higher level
41	// than its parent we also have a priority/urgency field that maps
42	// to the same field of the old logger which in turns has a direct
43	// mapping to syslog priority. This is done to make it easier to
44	// move step by step to structured logging. We consider both level
45	// and priority to select which messages are logged, and a backend
46	// can further use priority to pass to syslog.
47
48	enum Priority : uint8_t
49	{
50	Absent = 0,
51	Alert = 1,
52	Critical = 2,
53	Error = 3,
54	Warning = 4,
55	Notice = 5,
56	Info = 6,
57	Debug = 7
58	};
59
60	class Logger
61	{
62	public:
63	// Enabled tests whether this Logger is enabled. For example, commandline
64	// flags might be used to set the logging verbosity and disable some info
65	// logs.
66	virtual bool enabled(Priority) const = 0;
67
68	static std::string toString(Priority arg)
69	{	7,181✔
70	const std::array<std::string, 8> names = {"Absent", "Alert", "Critical", "Error", "Warning", "Notice", "Info", "Debug"};	7,181✔
71	auto p = static_cast<unsigned int>(arg);	7,181✔
72	if (p >= names.size()) {	7,181!
73	return "?";
74	}
75	return names.at(p);	7,181✔
76	}	7,181✔
77	// Info logs a non-error message with the given key/value pairs as context.
78	//
79	// The msg argument should be used to add some constant description to
80	// the log line. The key/value pairs can then be used to add additional
81	// variable information. The key/value pairs should alternate string
82	// keys and arbitrary values.
83	virtual void info(const std::string& msg) const = 0;
84	virtual void info(Logr::Priority, const std::string& msg) const = 0;
85
86	template <typename... Args>
87	void info(const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
88	{
89	auto logger = this->withValues(key, value, args...);
90	logger->info(msg);
91	}
92
93	template <typename... Args>
94	void info(Priority p, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
95	{	4,620✔
96	auto logger = this->withValues(key, value, args...);	4,620✔
97	logger->info(p, msg);	4,620✔
98	}	4,620✔
99
100	// Error logs an error, with the given message and key/value pairs as context.
101	// It functions similarly to calling Info with the "error" named value, but may
102	// have unique behavior, and should be preferred for logging errors (see the
103	// package documentations for more information).
104	//
105	// The msg field should be used to add context to any underlying error,
106	// while the err field should be used to attach the actual error that
107	// triggered this log line, if present.
108	virtual void error(const std::string& err, const std::string& msg) const = 0;
109	virtual void error(int err, const std::string& msg) const = 0;
110	virtual void error(Logr::Priority, const std::string& err, const std::string& msg) const = 0;
111	virtual void error(Logr::Priority, int err, const std::string& msg) const = 0;
112
113	template <typename... Args>
114	void error(const std::string& err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
115	{	12✔
116	auto logger = this->withValues(key, value, args...);	12✔
117	logger->error(Logr::Absent, err, msg);	12✔
118	}	12✔
119
120	template <typename... Args>
121	void error(int err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
UNCOV 122	{	72✔
UNCOV 123	auto logger = this->withValues(key, value, args...);	72✔
UNCOV 124	logger->error(Logr::Absent, err, msg);	72✔
UNCOV 125	}	72✔
126
127	template <typename... Args>
128	void error(Priority p, const std::string& err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
129	{	331✔
130	auto logger = this->withValues(key, value, args...);	331✔
131	logger->error(p, err, msg);	331✔
132	}	331✔
133
134	template <typename... Args>
135	void error(Priority p, int err, const std::string& msg, const std::string& key, const Loggable& value, const Args&... args) const
136	{	24✔
137	auto logger = this->withValues(key, value, args...);	24✔
138	logger->error(p, err, msg);	24✔
139	}	24✔
140
141	// V returns an Logger value for a specific verbosity level, relative to
142	// this Logger. In other words, V values are additive. V higher verbosity
143	// level means a log message is less important. It's illegal to pass a log
144	// level less than zero.
145	virtual std::shared_ptr<Logger> v(size_t level) const = 0;
146
147	template <typename... Args>
148	std::shared_ptr<Logger> withValues(const std::string& key, const Loggable& value, const Args&... args) const
149	{	9,135✔
150	std::map<std::string, std::string> map = {};	9,135✔
151	this->mapArguments(map, key, value, args...);	9,135✔
152	return this->withValues(map);	9,135✔
153	}	9,135✔
154
155	// WithValues adds some key-value pairs of context to a logger.
156	// See Info for documentation on how key/value pairs work.
157	virtual std::shared_ptr<Logger> withValues(const std::map<std::string, std::string>& values) const = 0;
158
159	// WithName adds a new element to the logger's name.
160	// Successive calls with WithName continue to append
161	// suffixes to the logger's name. It's strongly recommended
162	// that name segments contain only letters, digits, and hyphens
163	// (see the package documentation for more information).
164	virtual std::shared_ptr<Logger> withName(const std::string& name) const = 0;
165
166	private:
167	template <typename... Args>
168	void mapArguments(std::map<std::string, std::string>& map, const std::string& key, const Loggable& value, const Args&... args) const
169	{	36,341✔
170	map.emplace(key, value.to_string());	36,341✔
171	mapArguments(map, args...);	36,341✔
172	}	36,341✔
173
174	void mapArguments(std::map<std::string, std::string>& /* map */) const {}	9,135✔
175	};
176
177	using log_t = const std::shared_ptr<Logger>&;
178	}

PowerDNS / pdns / 11049514595

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