mirrors/opendht
1
0 Fork 0
mirror of https://github.com/savoirfairelinux/opendht.git synced 2026-11-08 04:21:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

logs: use fmt

Browse Source
This commit is contained in:
Adrien Béraud committed 2023-05-17 23:43:55 -04:00
1 parent 4041b69800
commit e176e4baa6
9 files changed
+178 -179
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

CMakeLists.txt
+3 -2
View File
@@ -88,10 +88,11 @@ if (NOT MSVC)
find_path(ASIO_INCLUDE_DIR asio.hpp REQUIRED)
endif ()
find_library(FMT_LIBRARY fmt)
add_library(fmt SHARED IMPORTED)
if (OPENDHT_HTTP)
find_package(Restinio REQUIRED)
find_library(FMT_LIBRARY fmt)
add_library(fmt SHARED IMPORTED)
find_library(HTTP_PARSER_LIBRARY http_parser)
add_library(http_parser SHARED IMPORTED)
set(http_parser_lib "-lhttp_parser")
configure.ac
+7 -6
View File
@@ -171,15 +171,16 @@ AS_IF([test "x$have_openssl" = "xyes"], [
AC_MSG_NOTICE([Not using OpenSSL])
])
PKG_CHECK_MODULES([Fmt], [fmt >= 5.3.0], [have_fmt=yes], [have_fmt=no])
AS_IF([test "x$have_fmt" = "xyes"], [
AC_MSG_NOTICE([Using libfmt])
], [
AC_MSG_NOTICE([Missing libfmt files])
])
AM_COND_IF([PROXY_CLIENT_OR_SERVER], [
AC_CHECK_HEADERS([asio.hpp],, AC_MSG_ERROR([Missing Asio headers files]))
CXXFLAGS="${CXXFLAGS} -DASIO_STANDALONE"
PKG_CHECK_MODULES([Fmt], [fmt >= 5.3.0], [have_fmt=yes], [have_fmt=no])
AS_IF([test "x$have_fmt" = "xyes"], [
AC_MSG_NOTICE([Using libfmt])
], [
AC_MSG_NOTICE([Missing libfmt files])
])
# http_parser has no pkgconfig, instead we check with:
AC_CHECK_LIB(http_parser, exit,, AC_MSG_ERROR([Missing HttpParser library files]))
AC_CHECK_HEADERS([http_parser.h], [http_parser_headers=yes; break;])
include/opendht/dht_proxy_server.h
+2 -2
View File
@@ -87,7 +87,7 @@ public:
*/
DhtProxyServer(const std::shared_ptr<DhtRunner>& dht,
const ProxyServerConfig& config = {},
const std::shared_ptr<dht::Logger>& logger = {});
const std::shared_ptr<log::Logger>& logger = {});
virtual ~DhtProxyServer();
@@ -364,7 +364,7 @@ private:
mutable std::mutex requestLock_;
std::map<unsigned int /*id*/, std::shared_ptr<http::Request>> requests_;
std::shared_ptr<dht::Logger> logger_;
std::shared_ptr<log::Logger> logger_;
std::shared_ptr<ServerStats> stats_;
std::shared_ptr<NodeInfo> nodeInfo_ {};
include/opendht/http.h
+19 -17
View File
@@ -53,7 +53,9 @@ class tls_socket_t;
}
namespace dht {
namespace log {
struct Logger;
}
namespace crypto {
struct Certificate;
@@ -88,9 +90,9 @@ public:
class OPENDHT_PUBLIC Connection : public std::enable_shared_from_this<Connection>
{
public:
Connection(asio::io_context& ctx, const bool ssl = true, std::shared_ptr<dht::Logger> l = {});
Connection(asio::io_context& ctx, const bool ssl = true, std::shared_ptr<log::Logger> l = {});
Connection(asio::io_context& ctx, std::shared_ptr<dht::crypto::Certificate> server_ca,
const dht::crypto::Identity& identity, std::shared_ptr<dht::Logger> l = {});
const dht::crypto::Identity& identity, std::shared_ptr<log::Logger> l = {});
~Connection();
inline unsigned int id() const { return id_; };
@@ -148,7 +150,7 @@ private:
asio::ip::address local_address_;
std::unique_ptr<asio::steady_timer> timeout_timer_;
std::shared_ptr<dht::Logger> logger_;
std::shared_ptr<log::Logger> logger_;
bool checkOcsp_ {false};
};
@@ -172,15 +174,15 @@ public:
using ResolverCb = std::function<void(const asio::error_code& ec,
const std::vector<asio::ip::tcp::endpoint>& endpoints)>;
Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
Resolver(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::Logger> logger = {});
Resolver(asio::io_context& ctx, const std::string& host, const std::string& service,
const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
// use already resolved endpoints with classes using this resolver
Resolver(asio::io_context& ctx, std::vector<asio::ip::tcp::endpoint> endpoints,
const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
Resolver(asio::io_context& ctx, const std::string& url, std::vector<asio::ip::tcp::endpoint> endpoints,
std::shared_ptr<dht::Logger> logger = {});
std::shared_ptr<log::Logger> logger = {});
~Resolver();
@@ -190,7 +192,7 @@ public:
void add_callback(ResolverCb cb, sa_family_t family = AF_UNSPEC);
std::shared_ptr<Logger> getLogger() const {
std::shared_ptr<log::Logger> getLogger() const {
return logger_;
}
@@ -208,7 +210,7 @@ private:
bool completed_ {false};
std::queue<ResolverCb> cbs_;
std::shared_ptr<dht::Logger> logger_;
std::shared_ptr<log::Logger> logger_;
};
class Request;
@@ -240,14 +242,14 @@ public:
// resolves implicitly
Request(asio::io_context& ctx, const std::string& url, const Json::Value& json, OnJsonCb jsoncb,
std::shared_ptr<dht::Logger> logger = {});
std::shared_ptr<log::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& url, OnJsonCb jsoncb,
std::shared_ptr<dht::Logger> logger = {});
std::shared_ptr<log::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<dht::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& url, std::shared_ptr<log::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& host, const std::string& service,
const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<dht::Logger> logger = {});
const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
Request(asio::io_context& ctx, const std::string& url, OnDoneCb onDone, std::shared_ptr<log::Logger> logger = {});
// user defined resolver
Request(asio::io_context& ctx, std::shared_ptr<Resolver> resolver, sa_family_t family = AF_UNSPEC);
@@ -255,7 +257,7 @@ public:
// user defined resolved endpoints
Request(asio::io_context& ctx, std::vector<asio::ip::tcp::endpoint>&& endpoints,
const bool ssl = false, std::shared_ptr<dht::Logger> logger = {});
const bool ssl = false, std::shared_ptr<log::Logger> logger = {});
~Request();
@@ -282,7 +284,7 @@ public:
void set_certificate_authority(std::shared_ptr<dht::crypto::Certificate> certificate);
void set_identity(const dht::crypto::Identity& identity);
void set_logger(std::shared_ptr<dht::Logger> logger);
void set_logger(std::shared_ptr<log::Logger> logger);
/**
* Define the HTTP header/body as per https://tools.ietf.org/html/rfc7230.
@@ -347,7 +349,7 @@ private:
mutable std::mutex mutex_;
std::shared_ptr<dht::Logger> logger_;
std::shared_ptr<log::Logger> logger_;
restinio::http_request_header_t header_;
std::map<restinio::http_field_t, std::string> headers_;
include/opendht/log_enable.h
+75 -106
View File
@@ -24,163 +24,130 @@
#include "infohash.h"
#include <functional>
#include <string_view>
#include <cstdarg>
#ifndef OPENDHT_LOG
#define OPENDHT_LOG true
#endif
#include <fmt/format.h>
#include <fmt/printf.h>
namespace dht {
namespace log {
// Logging related utility functions
/**
* Wrapper for logging methods
*/
struct LogMethod {
LogMethod() = default;
LogMethod(LogMethod&& l) : func(std::move(l.func)) {}
LogMethod(const LogMethod& l) : func(l.func) {}
LogMethod& operator=(dht::LogMethod&& l) {
func = std::forward<LogMethod>(l.func);
return *this;
}
LogMethod& operator=(const dht::LogMethod& l) {
func = l.func;
return *this;
}
template<typename T>
explicit LogMethod(T&& t) : func(std::forward<T>(t)) {}
template<typename T>
LogMethod(const T& t) : func(t) {}
void operator()(char const* format, ...) const {
va_list args;
va_start(args, format);
func(format, args);
va_end(args);
}
inline void log(char const* format, va_list args) const {
func(format, args);
}
explicit operator bool() const {
return (bool)func;
}
void logPrintable(const uint8_t *buf, size_t buflen) const {
std::string buf_clean(buflen, '\0');
for (size_t i=0; i<buflen; i++)
buf_clean[i] = isprint(buf[i]) ? buf[i] : '.';
(*this)("%s", buf_clean.c_str());
}
private:
std::function<void(char const*, va_list)> func;
enum class LogLevel {
debug, warning, error
};
using LogMethodFmt = std::function<void(LogLevel, fmt::string_view, fmt::format_args)>;
using LogMethodPrintf = std::function<void(LogLevel, fmt::string_view, fmt::printf_args)>;
struct Logger {
LogMethod ERR = {};
LogMethod WARN = {};
LogMethod DBG = {};
LogMethodFmt logger = {};
LogMethodPrintf loggerf = {};
Logger() = default;
Logger(LogMethod&& err, LogMethod&& warn, LogMethod&& dbg)
: ERR(std::move(err)), WARN(std::move(warn)), DBG(std::move(dbg)) {}
Logger(LogMethodFmt&& logger, LogMethodPrintf&& loggerf)
: logger(std::move(logger)), loggerf(std::move(loggerf)) {}
void setFilter(const InfoHash& f) {
filter_ = f;
filterEnable_ = static_cast<bool>(filter_);
}
inline void log0(const LogMethod& logger, char const* format, va_list args) const {
#if OPENDHT_LOG
inline void logfmt(LogLevel level, fmt::string_view format, fmt::format_args args) {
if (logger and not filterEnable_)
logger.log(format, args);
logger(level, format, args);
}
inline void log0(LogLevel level, fmt::string_view format, fmt::printf_args args) const {
#if OPENDHT_LOG
if (loggerf and not filterEnable_)
loggerf(level, format, args);
#endif
}
inline void log1(const LogMethod& logger, const InfoHash& f, char const* format, va_list args) const {
inline void log1(LogLevel level, const InfoHash& f, fmt::string_view format, fmt::printf_args args) const {
#if OPENDHT_LOG
if (logger and (not filterEnable_ or f == filter_))
logger.log(format, args);
if (loggerf and (not filterEnable_ or f == filter_))
loggerf(level, format, args);
#endif
}
inline void log2(const LogMethod& logger, const InfoHash& f1, const InfoHash& f2, char const* format, va_list args) const {
inline void log2(LogLevel level, const InfoHash& f1, const InfoHash& f2, fmt::string_view format, fmt::printf_args args) const {
#if OPENDHT_LOG
if (logger and (not filterEnable_ or f1 == filter_ or f2 == filter_))
logger.log(format, args);
if (loggerf and (not filterEnable_ or f1 == filter_ or f2 == filter_))
loggerf(level, format, args);
#endif
}
inline void d(char const* format, ...) const {
template <typename... T>
inline void debug(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log0(DBG, format, args);
va_end(args);
logFmt(LogLevel::debug, format, fmt::make_format_args(args...));
#endif
}
inline void d(const InfoHash& f, char const* format, ...) const {
template <typename... T>
inline void warn(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log1(DBG, f, format, args);
va_end(args);
logFmt(LogLevel::warning, format, fmt::make_format_args(args...));
#endif
}
inline void d(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
template <typename... T>
inline void error(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log2(DBG, f1, f2, format, args);
va_end(args);
logFmt(LogLevel::error, format, fmt::make_format_args(args...));
#endif
}
inline void w(char const* format, ...) const {
template <typename... T>
inline void d(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log0(WARN, format, args);
va_end(args);
log0(LogLevel::debug, format, fmt::make_printf_args(args...));
#endif
}
inline void w(const InfoHash& f, char const* format, ...) const {
template <typename... T>
inline void d(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log1(WARN, f, format, args);
va_end(args);
log1(LogLevel::debug, f, format, fmt::make_printf_args(args...));
#endif
}
inline void w(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
template <typename... T>
inline void d(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log2(WARN, f1, f2, format, args);
va_end(args);
log2(LogLevel::debug, f1, f2, format, fmt::make_printf_args(args...));
#endif
}
inline void e(char const* format, ...) const {
template <typename... T>
inline void w(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log0(ERR, format, args);
va_end(args);
log0(LogLevel::warning, format, fmt::make_printf_args(args...));
#endif
}
inline void e(const InfoHash& f, char const* format, ...) const {
template <typename... T>
inline void w(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log1(ERR, f, format, args);
va_end(args);
log1(LogLevel::warning, f, format, fmt::make_printf_args(args...));
#endif
}
inline void e(const InfoHash& f1, const InfoHash& f2, char const* format, ...) const {
template <typename... T>
inline void w(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
va_list args;
va_start(args, format);
log2(ERR, f1, f2, format, args);
va_end(args);
log2(LogLevel::warning, f1, f2, format, fmt::make_printf_args(args...));
#endif
}
template <typename... T>
inline void e(fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
log0(LogLevel::error, format, fmt::make_printf_args(args...));
#endif
}
template <typename... T>
inline void e(const InfoHash& f, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
log1(LogLevel::error, f, format, fmt::make_printf_args(args...));
#endif
}
template <typename... T>
inline void e(const InfoHash& f1, const InfoHash& f2, fmt::format_string<T...> format, T&&... args) const {
#if OPENDHT_LOG
log2(LogLevel::error, f1, f2, format, fmt::make_printf_args(args...));
#endif
}
private:
@@ -189,3 +156,5 @@ private:
};
}
using Logger = log::Logger;
}
meson.build
+2 -1
View File
@@ -11,6 +11,7 @@ msgpack = dependency('msgpack-cxx', required : false)
argon2 = dependency('libargon2')
openssl = dependency('openssl', required: get_option('proxy_client'))
jsoncpp = dependency('jsoncpp', required: get_option('proxy_client'))
fmt = dependency('fmt')
dirs=[]
if host_machine.system() == 'freebsd'
@@ -19,7 +20,7 @@ elif host_machine.system() == 'darwin'
dirs+='/opt/homebrew/lib'
endif
http_parser = meson.get_compiler('c').find_library('http_parser', dirs: dirs, required: get_option('proxy_client'))
deps = [gnutls, nettle, msgpack, argon2, openssl, jsoncpp, http_parser]
deps = [fmt, gnutls, nettle, msgpack, argon2, openssl, jsoncpp, http_parser]
add_project_arguments('-DMSGPACK_NO_BOOST', language : 'cpp')
add_project_arguments(['-Wno-return-type','-Wno-deprecated','-Wnon-virtual-dtor','-pedantic-errors','-fvisibility=hidden'], language : 'cpp')
src/dhtrunner.cpp
+10 -10
View File
@@ -93,7 +93,7 @@ DhtRunner::run(const Config& config, Context&& context)
auto expected = State::Idle;
if (not running.compare_exchange_strong(expected, State::Running)) {
if (context.logger)
context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", this);
context.logger->w("[runner %p] Node is already running. Call join() first before calling run() again.", fmt::ptr(this));
return;
}
@@ -102,7 +102,7 @@ DhtRunner::run(const Config& config, Context&& context)
auto local6 = config.bind6;
if (not local4 and not local6) {
if (context.logger)
context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", this);
context.logger->w("[runner %p] No address to bind specified in the configuration, using default addresses", fmt::ptr(this));
local4.setFamily(AF_INET);
local6.setFamily(AF_INET6);
}
@@ -116,14 +116,14 @@ DhtRunner::run(const Config& config, Context&& context)
if (inConfig >> port) {
if (local4.getPort() == 0) {
if (context.logger)
context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", this, port);
context.logger->d("[runner %p] Using IPv4 port %hu from saved configuration", fmt::ptr(this), port);
local4.setPort(port);
}
}
if (inConfig >> port) {
if (local6.getPort() == 0) {
if (context.logger)
context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", this, port);
context.logger->d("[runner %p] Using IPv6 port %hu from saved configuration", fmt::ptr(this), port);
local6.setPort(port);
}
}
@@ -132,7 +132,7 @@ DhtRunner::run(const Config& config, Context&& context)
if (context.logger) {
logger_ = context.logger;
logger_->d("[runner %p] state changed to Running", this);
logger_->d("[runner %p] state changed to Running", fmt::ptr(this));
}
#ifdef OPENDHT_PROXY_CLIENT
@@ -155,7 +155,7 @@ DhtRunner::run(const Config& config, Context&& context)
dropped++;
}
if (dropped and logger_) {
logger_->w("[runner %p] dropped %zu packets: queue is full!", this, dropped);
logger_->w("[runner %p] dropped %zu packets: queue is full!", fmt::ptr(this), dropped);
}
ret = std::move(rcv_free);
}
@@ -281,7 +281,7 @@ DhtRunner::shutdown(ShutdownCallback cb, bool stop) {
return;
}
if (logger_)
logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", this, ongoing_ops.load());
logger_->d("[runner %p] state changed to Stopping, %zu ongoing ops", fmt::ptr(this), ongoing_ops.load());
ongoing_ops++;
shutdownCallbacks_.emplace_back(std::move(cb));
pending_ops.emplace([=](SecureDht&) mutable {
@@ -346,7 +346,7 @@ DhtRunner::join()
if (auto sock = dht_->getSocket())
sock->stop();
if (logger_)
logger_->d("[runner %p] state changed to Idle", this);
logger_->d("[runner %p] state changed to Idle", fmt::ptr(this));
}
if (dht_thread.joinable())
@@ -355,7 +355,7 @@ DhtRunner::join()
{
std::lock_guard<std::mutex> lck(storage_mtx);
if (ongoing_ops and logger_) {
logger_->w("[runner %p] stopping with %zu remaining ops", this, ongoing_ops.load());
logger_->w("[runner %p] stopping with %zu remaining ops", fmt::ptr(this), ongoing_ops.load());
}
pending_ops = decltype(pending_ops)();
pending_ops_prio = decltype(pending_ops_prio)();
@@ -680,7 +680,7 @@ DhtRunner::loop_()
}
if (dropped && logger_)
logger_->e("[runner %p] Dropped %zu packets with high delay.", this, dropped);
logger_->e("[runner %p] Dropped %zu packets with high delay.", fmt::ptr(this), dropped);
NodeStatus nstatus4 = dht_->updateStatus(AF_INET);
NodeStatus nstatus6 = dht_->updateStatus(AF_INET6);
src/log.cpp
+58 -33
View File
@@ -20,6 +20,10 @@
#include "log.h"
#include "dhtrunner.h"
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <fmt/printf.h>
#ifndef _WIN32
#include <syslog.h>
#endif
@@ -64,42 +68,45 @@ constexpr const Color::Modifier yellow(Color::FG_YELLOW);
* Print va_list to std::ostream (used for logging).
*/
void
printLog(std::ostream& s, char const *m, va_list args) {
// print log to buffer
std::array<char, 8192> buffer;
int ret = vsnprintf(buffer.data(), buffer.size(), m, args);
if (ret <= 0)
return;
// write timestamp
printfLog(std::ostream& s, fmt::string_view format, fmt::printf_args args) {
using namespace std::chrono;
using log_precision = microseconds;
constexpr auto den = log_precision::period::den;
auto num = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
s << '[' << std::setfill('0') << std::setw(6) << num / den << '.'
<< std::setfill('0') << std::setw(6) << num % den << "] ";
// write log
s.write(buffer.data(), std::min((size_t) ret, buffer.size()));
if ((size_t) ret >= buffer.size())
s << "[[TRUNCATED]]";
constexpr auto den = log_precision::period::den;
fmt::print(s, "[{:06d}.{:06d}] ", num / den, num % den);
s << fmt::vsprintf(format, args);
s << std::endl;
}
void
printLog(std::ostream& s, fmt::string_view format, fmt::format_args args) {
using namespace std::chrono;
using log_precision = microseconds;
auto num = duration_cast<log_precision>(steady_clock::now().time_since_epoch()).count();
constexpr auto den = log_precision::period::den;
fmt::print(s, "[{:06d}.{:06d}] ", num / den, num % den);
fmt::vprint(s, format, args);
s << std::endl;
}
std::shared_ptr<Logger>
getStdLogger() {
return std::make_shared<Logger>(
[](char const *m, va_list args) {
std::cerr << red;
printLog(std::cerr, m, args);
[](LogLevel level, fmt::string_view format, fmt::format_args args) {
if (level == LogLevel::error)
std::cerr << red;
else if (level == LogLevel::warning)
std::cerr << yellow;
printLog(std::cerr, format, args);
std::cerr << def;
},
[](char const *m, va_list args) {
std::cout << yellow;
printLog(std::cout, m, args);
std::cout << def;
},
[](char const *m, va_list args) { printLog(std::cout, m, args); }
[](LogLevel level, fmt::string_view format, fmt::printf_args args) {
if (level == LogLevel::error)
std::cerr << red;
else if (level == LogLevel::warning)
std::cerr << yellow;
printfLog(std::cerr, format, args);
std::cerr << def;
}
);
}
@@ -107,14 +114,29 @@ std::shared_ptr<Logger>
getFileLogger(const std::string &path) {
auto logfile = std::make_shared<std::ofstream>();
logfile->open(path, std::ios::out);
return std::make_shared<Logger>(
[=](char const *m, va_list args) { printLog(*logfile, m, args); },
[=](char const *m, va_list args) { printLog(*logfile, m, args); },
[=](char const *m, va_list args) { printLog(*logfile, m, args); }
[logfile](LogLevel level, fmt::string_view format, fmt::format_args args) {
printLog(*logfile, format, args);
},
[logfile](LogLevel level, fmt::string_view format, fmt::printf_args args) {
printfLog(*logfile, format, args);
}
);
}
constexpr
int syslogLevel(LogLevel level) {
switch (level) {
case LogLevel::error:
return LOG_ERR;
case LogLevel::warning:
return LOG_WARNING;
case LogLevel::debug:
return LOG_INFO;
}
return LOG_ERR;
}
std::shared_ptr<Logger>
getSyslogLogger(const char* name) {
#ifndef _WIN32
@@ -134,10 +156,13 @@ getSyslogLogger(const char* name) {
opened_logfile = logfile;
}
return std::make_shared<Logger>(
[logfile](char const *m, va_list args) { vsyslog(LOG_ERR, m, args); },
[logfile](char const *m, va_list args) { vsyslog(LOG_WARNING, m, args); },
[logfile](char const *m, va_list args) { vsyslog(LOG_INFO, m, args); }
);
[logfile](LogLevel level, fmt::string_view format, fmt::format_args args) {
syslog(syslogLevel(level), "%s", fmt::vformat(format, args).c_str());
},
[logfile](LogLevel level, fmt::string_view format, fmt::printf_args args) {
auto fmt = fmt::vsprintf(format, args);
syslog(syslogLevel(level), "%s", fmt.data());
});
#else
return std::make_shared<Logger>();
#endif
tools/tools_common.h
+2 -2
View File
@@ -187,8 +187,8 @@ getDhtConfig(dht_params& params)
context.logger = dht::log::getStdLogger();
}
if (context.logger) {
context.statusChangedCallback = [logger = *context.logger](dht::NodeStatus status4, dht::NodeStatus status6) {
logger.WARN("Connectivity changed: IPv4: %s, IPv6: %s", dht::statusToStr(status4), dht::statusToStr(status6));
context.statusChangedCallback = [logger = context.logger](dht::NodeStatus status4, dht::NodeStatus status6) {
logger->w("Connectivity changed: IPv4: %s, IPv6: %s", dht::statusToStr(status4), dht::statusToStr(status6));
};
}
return {std::move(config), std::move(context)};