7057769616

Committed 01 Dec 2023 08:46AM UTC coverage: 57.393% (+0.02%) from 57.372%

Build # 7057769616

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13062 from Habbie/auth-loglevel-prefix

auth: add loglevel-show setting

Run Details

31525 of 86018 branches covered (0.0%)

Branch coverage included in aggregate %.

21 of 26 new or added lines in 2 files covered. (80.77%)

42 existing lines in 12 files now uncovered.

106102 of 153779 relevant lines covered (69.0%)

4293205.06 hits per line

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

79.35

/pdns/logger.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#include <ostream>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <iomanip>
#include <mutex>

#include "logger.hh"
#include "misc.hh"
#ifndef RECURSOR
#include "statbag.hh"
extern StatBag S;
#endif
#include "namespaces.hh"

thread_local Logger::PerThread Logger::t_perThread;

Logger& getLogger()
{
  /* Since the Logger can be called very early, we need to make sure
     that the relevant parts are initialized no matter what, which is tricky
     because we can't easily control the initialization order, especially with
     built-in backends.
     t_perThread is thread_local, so it will be initialized when first accessed,
     but we need to make sure that the object itself is initialized, and making
     it a function-level static variable achieves that, because it will be
     initialized the first time we enter this function at the very last.
  */
  static Logger log("", LOG_DAEMON);
  return log;
}

void Logger::log(const string& msg, Urgency u) noexcept
{
#ifndef RECURSOR
  bool mustAccount(false);
#endif
  if (u <= consoleUrgency) {
    std::array<char, 50> buffer{};
    buffer[0] = '\0';
    if (d_timestamps) {
      struct tm tm;
      time_t t;
      time(&t);
      localtime_r(&t, &tm);
      if (strftime(buffer.data(), buffer.size(), "%b %d %H:%M:%S ", &tm) == 0) {
        buffer[0] = '\0';
      }
    }

    string severity;
    if (d_prefixed) {
      switch (u) {
      case All:
        severity = "All";
        break;
      case Alert:
        severity = "Alert";
        break;
      case Critical:
        severity = "Critical";
        break;
      case Error:
        severity = "Error";
        break;
      case Warning:
        severity = "Warning";
        break;
      case Notice:
        severity = "Notice";
        break;
      case Info:
        severity = "Info";
        break;
      case Debug:
        severity = "Debug";
        break;
      case None:
        severity = "None";
        break;
      }
    }

    static std::mutex mutex;
    std::lock_guard<std::mutex> lock(mutex); // the C++-2011 spec says we need this, and OSX actually does

    // To avoid issuing multiple syscalls, we write the complete line to clog with a single << call.
    // For that we need a buffer allocated, we might want to use writev(2) one day to avoid that.
    ostringstream line;
    line << buffer.data();
    if (d_prefixed) {
      line << "msg=" << std::quoted(msg) << " prio=" << std::quoted(severity) << endl;
    }
    else {
      line << msg << endl;
    }
    clog << line.str() << std::flush;
#ifndef RECURSOR
    mustAccount = true;
#endif
  }
  if (u <= d_loglevel && !d_disableSyslog) {
    syslog(u, "%s", msg.c_str());
#ifndef RECURSOR
    mustAccount = true;
#endif
  }

#ifndef RECURSOR
  if (mustAccount) {
    try {
      S.ringAccount("logmessages", msg);
    }
    catch (const runtime_error& e) {
      cerr << e.what() << endl;
    }
  }
#endif
}

void Logger::setLoglevel(Urgency u)
{
  d_loglevel = u;
}

void Logger::toConsole(Urgency u)
{
  consoleUrgency = u;
}

void Logger::open()
{
  if (opened)
    closelog();
  openlog(name.c_str(), flags, d_facility);
  opened = true;
}

void Logger::setName(const string& _name)
{
  name = _name;
  open();
}

Logger::Logger(string n, int facility) :
  name(std::move(n)), flags(LOG_PID | LOG_NDELAY), d_facility(facility), d_loglevel(Logger::None), consoleUrgency(Error), opened(false), d_disableSyslog(false)
{
  open();
}

Logger& Logger::operator<<(Urgency u)
{
  getPerThread().d_urgency = u;
  return *this;
}

Logger::PerThread& Logger::getPerThread()
{
  return t_perThread;
}

Logger& Logger::operator<<(const string& s)
{
  PerThread& pt = getPerThread();
  pt.d_output.append(s);
  return *this;
}

Logger& Logger::operator<<(const char* s)
{
  *this << string(s);
  return *this;
}

Logger& Logger::operator<<(ostream& (&)(ostream&))
{
  PerThread& pt = getPerThread();

  log(pt.d_output, pt.d_urgency);
  pt.d_output.clear();
  pt.d_urgency = Info;
  return *this;
}

Logger& Logger::operator<<(const DNSName& d)
{
  *this << d.toLogString();

  return *this;
}

Logger& Logger::operator<<(const ComboAddress& ca)
{
  *this << ca.toLogString();
  return *this;
}

void addTraceTS(const timeval& start, ostringstream& str)
{
  const auto& content = str.str();
  if (content.empty() || content.back() == '\n') {
    timeval time{};
    gettimeofday(&time, nullptr);
    auto elapsed = time - start;
    auto diff = elapsed.tv_sec * 1000000 + static_cast<time_t>(elapsed.tv_usec);
    str << diff << ' ';
  }
}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#include <ostream>
23	#ifdef HAVE_CONFIG_H
24	#include "config.h"
25	#endif
26
27	#include <iomanip>
28	#include <mutex>
29
30	#include "logger.hh"
31	#include "misc.hh"
32	#ifndef RECURSOR
33	#include "statbag.hh"
34	extern StatBag S;
35	#endif
36	#include "namespaces.hh"
37
38	thread_local Logger::PerThread Logger::t_perThread;
39
40	Logger& getLogger()
41	{	86,468✔
42	/* Since the Logger can be called very early, we need to make sure
43	that the relevant parts are initialized no matter what, which is tricky
44	because we can't easily control the initialization order, especially with
45	built-in backends.
46	t_perThread is thread_local, so it will be initialized when first accessed,
47	but we need to make sure that the object itself is initialized, and making
48	it a function-level static variable achieves that, because it will be
49	initialized the first time we enter this function at the very last.
50	*/
51	static Logger log("", LOG_DAEMON);	86,468✔
52	return log;	86,468✔
53	}	86,468✔
54
55	void Logger::log(const string& msg, Urgency u) noexcept
56	{	78,493✔
57	#ifndef RECURSOR	78,324✔
58	bool mustAccount(false);	78,324✔
59	#endif	78,324✔
60	if (u <= consoleUrgency) {	78,493✔
61	std::array<char, 50> buffer{};	9,029✔
62	buffer[0] = '\0';	9,029✔
63	if (d_timestamps) {	9,029✔
64	struct tm tm;	8,848✔
65	time_t t;	8,848✔
66	time(&t);	8,848✔
67	localtime_r(&t, &tm);	8,848✔
68	if (strftime(buffer.data(), buffer.size(), "%b %d %H:%M:%S ", &tm) == 0) {	8,848!
69	buffer[0] = '\0';	×
70	}	×
71	}	8,848✔
72
73	string severity;	9,029✔
74	if (d_prefixed) {	9,029✔
75	switch (u) {	181!
76	case All:	×
NEW 77	severity = "All";	×
78	break;	×
79	case Alert:	×
NEW 80	severity = "Alert";	×
81	break;	×
82	case Critical:	×
NEW 83	severity = "Critical";	×
84	break;	×
85	case Error:	×
NEW 86	severity = "Error";	×
87	break;	×
88	case Warning:	13✔
89	severity = "Warning";	13✔
90	break;	13✔
91	case Notice:	28✔
92	severity = "Notice";	28✔
93	break;	28✔
94	case Info:	41✔
95	severity = "Info";	41✔
96	break;	41✔
97	case Debug:	99✔
98	severity = "Debug";	99✔
99	break;	99✔
100	case None:	×
NEW 101	severity = "None";	×
102	break;	×
103	}	181✔
104	}	181✔
105
106	static std::mutex mutex;	9,029✔
107	std::lock_guard<std::mutex> lock(mutex); // the C++-2011 spec says we need this, and OSX actually does	9,029✔
108
109	// To avoid issuing multiple syscalls, we write the complete line to clog with a single << call.
110	// For that we need a buffer allocated, we might want to use writev(2) one day to avoid that.
111	ostringstream line;	9,029✔
112	line << buffer.data();	9,029✔
113	if (d_prefixed) {	9,029✔
114	line << "msg=" << std::quoted(msg) << " prio=" << std::quoted(severity) << endl;	181✔
115	}	181✔
116	else {	8,848✔
117	line << msg << endl;	8,848✔
118	}	8,848✔
119	clog << line.str() << std::flush;	9,029✔
120	#ifndef RECURSOR	8,984✔
121	mustAccount = true;	8,984✔
122	#endif	8,984✔
123	}	9,029✔
124	if (u <= d_loglevel && !d_disableSyslog) {	78,493✔
125	syslog(u, "%s", msg.c_str());	7,928✔
126	#ifndef RECURSOR	7,893✔
127	mustAccount = true;	7,893✔
128	#endif	7,893✔
129	}	7,928✔
130
131	#ifndef RECURSOR	78,324✔
132	if (mustAccount) {	78,324✔
133	try {	8,984✔
134	S.ringAccount("logmessages", msg);	8,984✔
135	}	8,984✔
136	catch (const runtime_error& e) {	8,984✔
137	cerr << e.what() << endl;
138	}
139	}	8,984✔
140	#endif	78,324✔
141	}	78,493✔
142
143	void Logger::setLoglevel(Urgency u)
144	{	389✔
145	d_loglevel = u;	389✔
146	}	389✔
147
148	void Logger::toConsole(Urgency u)
149	{	6,573✔
150	consoleUrgency = u;	6,573✔
151	}	6,573✔
152
153	void Logger::open()
154	{	3,623✔
155	if (opened)	3,623✔
156	closelog();	380✔
157	openlog(name.c_str(), flags, d_facility);	3,623✔
158	opened = true;	3,623✔
159	}	3,623✔
160
161	void Logger::setName(const string& _name)
162	{	380✔
163	name = _name;	380✔
164	open();	380✔
165	}	380✔
166
167	Logger::Logger(string n, int facility) :
168	name(std::move(n)), flags(LOG_PID \| LOG_NDELAY), d_facility(facility), d_loglevel(Logger::None), consoleUrgency(Error), opened(false), d_disableSyslog(false)
169	{	3,243✔
170	open();	3,243✔
171	}	3,243✔
172
173	Logger& Logger::operator<<(Urgency u)
174	{	77,315✔
175	getPerThread().d_urgency = u;	77,315✔
176	return *this;	77,315✔
177	}	77,315✔
178
179	Logger::PerThread& Logger::getPerThread()
180	{	454,978✔
181	return t_perThread;	454,978✔
182	}	454,978✔
183
184	Logger& Logger::operator<<(const string& s)
185	{	300,373✔
186	PerThread& pt = getPerThread();	300,373✔
187	pt.d_output.append(s);	300,373✔
188	return *this;	300,373✔
189	}	300,373✔
190
191	Logger& Logger::operator<<(const char* s)
192	{	207,144✔
193	*this << string(s);	207,144✔
194	return *this;	207,144✔
195	}	207,144✔
196
197	Logger& Logger::operator<<(ostream& (&)(ostream&))
198	{	77,288✔
199	PerThread& pt = getPerThread();	77,288✔
200
201	log(pt.d_output, pt.d_urgency);	77,288✔
202	pt.d_output.clear();	77,288✔
203	pt.d_urgency = Info;	77,288✔
204	return *this;	77,288✔
205	}	77,288✔
206
207	Logger& Logger::operator<<(const DNSName& d)
208	{	9,458✔
209	*this << d.toLogString();	9,458✔
210
211	return *this;	9,458✔
212	}	9,458✔
213
214	Logger& Logger::operator<<(const ComboAddress& ca)
215	{	1,564✔
216	*this << ca.toLogString();	1,564✔
217	return *this;	1,564✔
218	}	1,564✔
219
220	void addTraceTS(const timeval& start, ostringstream& str)
221	{	×
222	const auto& content = str.str();	×
223	if (content.empty() \|\| content.back() == '\n') {	×
224	timeval time{};	×
225	gettimeofday(&time, nullptr);	×
226	auto elapsed = time - start;	×
227	auto diff = elapsed.tv_sec * 1000000 + static_cast<time_t>(elapsed.tv_usec);	×
228	str << diff << ' ';	×
229	}	×
230	}	×

PowerDNS / pdns / 7057769616

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