random/spdlogConfig
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1f58c33bb7a765e84728dffa3559dd182472d754
spdlogConfig/include/spdlogconfig/SPDLOGConfig.h
T

1112 lines
41 KiB
C++
Raw Blame History

#ifndef SPFLOGCONFIG_H
#define SPFLOGCONFIG_H
#include <cstddef>
#include <filesystem>
#include <mutex>
#include <regex>
#include <shared_mutex>
#include <stdexcept>
#include <unordered_map>
#include <rfl.hpp>
#include <rfl/Result.hpp>
#include <rfl/json.hpp>
#include <spdlog/async.h>
#include "spdlogconfig/SPDLOGConfigError.h"
#if __has_include(<librdkafka/rdkafkacpp.h>)
#include "spdlog/sinks/kafka_sink.h"
#endif
#if __has_include(<bsoncxx/builder/stream/document.hpp>)
#include "spdlog/sinks/mongo_sink.h"
#endif
#ifndef _WIN32
#include "spdlog/sinks/syslog_sink.h"
#include <syslog.h>
#endif
#ifdef _WIN32
#include "spdlog/sinks/msvc_sink.h"
#endif
#include "spdlog/async_logger.h"
#include "spdlog/common.h"
#include "spdlog/sinks/basic_file_sink.h"
#include "spdlog/sinks/daily_file_sink.h"
#include "spdlog/sinks/null_sink.h"
#include "spdlog/sinks/rotating_file_sink.h"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/sinks/stdout_sinks.h"
#include <cstdint>
#include <fstream>
#include <memory>
#include <optional>
#include <spdlog/spdlog.h>
#include <sstream>
#include <string>
#include <vector>
namespace spdlogconfig {
namespace defaults {
/** Default async overflow policy for spdlog's async loggers. */
static constexpr auto ASYNC_OVERFLOW_POLICY =
spdlog::async_overflow_policy::block;
/** Default global thread pool queue size. */
static constexpr auto THREAD_POOL_QUEUE_SIZE = 8192;
/** Default global thread pool thread count. */
static constexpr auto THREAD_POOL_NUM_THREADS = 1;
/** Default maximum number of rotated log files to keep. */
static constexpr auto MAX_FILES = 10;
/** Default maximum file size for rotating sinks, expressed as a string. */
static constexpr auto MAX_SIZE = "10485760";
/** Default truncate behavior for file sinks. */
static constexpr auto TRUNCATE = false;
/** Default logger type ("sync" or "async"). */
static constexpr auto DEFAULT_LOGGER_TYPE = "sync";
/** Default overflow policy name used in configuration. */
static constexpr auto OVERRUN_OLDEST = "overrun_oldest";
/** Default async overflow policy implementation used when not specified. */
static constexpr auto OVERFLOW_POLICY =
spdlog::async_overflow_policy::overrun_oldest;
/** Default rotation time for daily sinks (HH:MM). */
static constexpr auto ROTATION_TIME = "00:00";
/** Default syslog ident string. */
static constexpr auto IDENT = "";
/** Default flag indicating whether to create parent directories for log files.
*/
static constexpr auto CREATE_PARENT_DIR = false;
#ifndef _WIN32
/** Default syslog facility (non-Windows). */
static constexpr auto SYSLOG_FACILITY = LOG_USER;
/** Default syslog option flags (non-Windows). */
static constexpr auto SYSLOG_OPTION = 0;
#endif
} // namespace defaults
namespace names {
static constexpr auto LOGGER_CONFIG = "loggers";
static constexpr auto PATTERN_CONFIG = "patterns";
static constexpr auto SINK_CONFIG = "sinks";
static constexpr auto THREAD_POOL_CONFIG = "thread_pool";
static constexpr auto ASYNC = "async";
static constexpr auto SYNC = "sync";
static constexpr auto BASE_FILENAME = "base_file_name";
static constexpr auto BLOCK = "block";
static constexpr auto CREATE_PARENT_DIR = "create_parent_dir";
static constexpr auto FILENAME = "file_name";
static constexpr auto GLOBAL_PATTERN = "global_pattern";
static constexpr auto IDENT = "ident";
static constexpr auto LEVEL = "level";
static constexpr auto MAX_FILES = "max_files";
static constexpr auto MAX_SIZE = "max_size";
static constexpr auto NAME = "name";
static constexpr auto THREAD_COUNT = "thread_count";
static constexpr auto OVERRUN_OLDEST = "overrun_oldest";
static constexpr auto OVERFLOW_POLICY = "overflow_policy";
static constexpr auto PATTERN = "pattern";
static constexpr auto QUEUE_SIZE = "queue_size";
static constexpr auto ROTATION_TIME = "rotation_time";
static constexpr auto SINKS = "sinks";
static constexpr auto TYPE = "type";
static constexpr auto VALUE = "value";
} // namespace names
namespace utils {
/**
* Convert a human-friendly max-size string into bytes.
* Supports optional suffix multipliers: K, M, G, T (base 1024).
*/
inline auto GetMaxSizeInt(const std::string &maxSizeString) -> size_t {
std::string s = maxSizeString;
auto const not_space = [](unsigned char ch) { return !std::isspace(ch); };
s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_space));
s.erase(std::find_if(s.rbegin(), s.rend(), not_space).base(), s.end());
if (s.empty()) {
return 0U;
}
auto const lastChar = s.back();
std::size_t maxSizeInt{};
if (std::string{"TGMK"}.find(lastChar) != std::string::npos) {
auto const prefixStr = s.substr(0, s.size() - 1);
maxSizeInt = std::stoi(prefixStr);
constexpr std::size_t kilo = 1024;
constexpr std::size_t mega = kilo * kilo;
constexpr std::size_t giga = mega * kilo;
constexpr std::size_t tera = giga * kilo;
switch (lastChar) {
case 'T':
maxSizeInt *= tera;
break;
case 'G':
maxSizeInt *= giga;
break;
case 'M':
maxSizeInt *= mega;
break;
case 'K':
maxSizeInt *= kilo;
break;
default:
break;
}
} else {
maxSizeInt = std::stoi(s);
}
return maxSizeInt;
}
/**
* Convert a string level name
* ("trace","debug","info","warn","err","critical","off") to the corresponding
* spdlog level enum.
*
* @throws std::invalid_argument if the name is unknown.
*/
inline spdlog::level::level_enum levelFromString(const std::string &name) {
const auto lvl = spdlog::level::from_str(name);
// spdlog::level::from_str returns off (6) for unknown names; distinguish
// a genuine "off" request from an invalid name.
if (lvl == spdlog::level::off && name != "off") {
throw std::invalid_argument("Unknown log level: '" + name + "'");
}
return lvl;
}
} // namespace utils
// ---------------------------------------------------------------------------
// Log-level enum (mirrors spdlog levels for JSON configuration parsing)
// ---------------------------------------------------------------------------
enum class spdlog_lvl_enum {
trace = spdlog::level::level_enum::trace,
debug = spdlog::level::level_enum::debug,
info = spdlog::level::level_enum::info,
warn = spdlog::level::level_enum::warn,
err = spdlog::level::level_enum::err,
critical = spdlog::level::level_enum::critical,
off = spdlog::level::level_enum::off,
n_levels
};
// ---------------------------------------------------------------------------
// Sink type enum
// ---------------------------------------------------------------------------
enum class spdlog_sink_types_enum {
stdout_sink_st,
stdout_sink_mt,
stderr_sink_st,
stderr_sink_mt,
stdout_color_sink_st,
stdout_color_sink_mt,
stderr_color_sink_st,
stderr_color_sink_mt,
basic_file_sink_st,
basic_file_sink_mt,
rotating_file_sink_st,
rotating_file_sink_mt,
daily_file_sink_st,
daily_file_sink_mt,
null_sink_st,
null_sink_mt,
android_sink_mt,
android_sink_st,
callback_sink_mt,
callback_sink_st,
dist_sink_mt,
dist_sink_st,
dup_filter_sink_mt,
dup_filter_sink_st,
hourly_file_sink_mt,
hourly_file_sink_st,
kafka_sink_mt,
kafka_sink_st,
mongo_sink_mt,
mongo_sink_st,
ostream_sink_mt,
ostream_sink_st,
ringbuffer_sink_mt,
ringbuffer_sink_st,
syslog_sink_mt,
syslog_sink_st,
msvc_sink_mt,
msvc_sink_st,
tcp_sink_mt,
tcp_sink_st,
udp_sink_mt,
udp_sink_st
};
// ---------------------------------------------------------------------------
// Validators
// ---------------------------------------------------------------------------
using vMinute = rfl::Validator<uint32_t, rfl::Minimum<1>, rfl::Maximum<59>>;
using vHour = rfl::Validator<uint32_t, rfl::Minimum<1>, rfl::Maximum<23>>;
using vThreadCount =
rfl::Validator<uint32_t, rfl::Minimum<0>, rfl::Maximum<100>>;
using vThreadQueue =
rfl::Validator<uint32_t, rfl::Minimum<0>, rfl::Maximum<409600>>;
using vMaxSize = rfl::Validator<
std::string,
rfl::PatternValidator<R"_(^\s*(\d+)\s*(T|G|M|K|)(:?B|)\s*$)_", "vMaxSize">>;
using vRotationTime = rfl::Validator<
std::string,
rfl::PatternValidator<R"_(^\s*(0?\d|1[0-9]|2[0-3])\s*:\s*([0-5]?\d)\s*$)_",
"vRotationTime">>;
// ---------------------------------------------------------------------------
// Configuration structures
// ---------------------------------------------------------------------------
struct spdlog_sinks_types_t {
rfl::Rename<"name", std::string> m_sink_name;
rfl::Rename<"type", spdlog_sink_types_enum> m_sink_type;
rfl::Rename<"filename", std::optional<std::filesystem::path>> m_file_name;
rfl::Rename<"base_filename", std::optional<std::filesystem::path>>
m_base_file_name;
rfl::Rename<"level", std::optional<spdlog_lvl_enum>> m_level;
rfl::Rename<"truncate", std::optional<bool>> m_truncate = defaults::TRUNCATE;
rfl::Rename<"max_size", std::optional<vMaxSize>> m_max_size =
defaults::MAX_SIZE;
rfl::Rename<"max_files", std::optional<size_t>> m_max_files =
defaults::MAX_FILES;
rfl::Rename<"rotation_time", std::optional<rfl::Timestamp<"%H:%M">>>
m_rotation_time;
rfl::Rename<"create_parent_dir", std::optional<bool>> m_create_parent_dir =
defaults::CREATE_PARENT_DIR;
#ifndef _WIN32
rfl::Rename<"ident", std::optional<std::string>> m_syslog_ident =
defaults::IDENT;
rfl::Rename<"syslog_option", std::optional<int32_t>> m_syslog_option =
defaults::SYSLOG_OPTION;
rfl::Rename<"syslog_facility", std::optional<int32_t>> m_syslog_facility =
LOG_USER;
#endif
};
struct spdlog_patterns_t {
rfl::Rename<"name", std::optional<std::string>> m_pattern_name;
rfl::Rename<"value", std::optional<std::string>> m_pattern_value;
};
struct spdlog_threadpool_t {
rfl::Rename<"name", std::string> m_name;
rfl::Rename<"num_threads", vThreadCount> m_thread_count =
defaults::THREAD_POOL_NUM_THREADS;
rfl::Rename<"queue_size", vThreadQueue> m_queue_size =
defaults::THREAD_POOL_QUEUE_SIZE;
};
struct spdlog_loggers_t {
rfl::Rename<"level", std::optional<spdlog_lvl_enum>> m_logger_level;
rfl::Rename<"name", std::string> m_logger_name;
rfl::Rename<"sinks", std::vector<std::string>> m_logger_sinks;
rfl::Rename<"pattern", std::optional<std::string>> m_logger_pattern;
rfl::Rename<"type", std::optional<std::string>> m_logger_type =
defaults::DEFAULT_LOGGER_TYPE;
rfl::Rename<"overflow_policy", std::optional<spdlog::async_overflow_policy>>
m_overflow_policy = defaults::OVERFLOW_POLICY;
rfl::Rename<"thread_pool", std::optional<std::string>> m_thread_pool;
};
struct spdlog_global_threadpool_t {
rfl::Rename<"num_threads", vThreadCount> m_thread_count =
defaults::THREAD_POOL_NUM_THREADS;
rfl::Rename<"queue_size", vThreadQueue> m_queue_size =
defaults::THREAD_POOL_QUEUE_SIZE;
};
struct spdlog_conf_t {
rfl::Rename<"sink", std::vector<spdlog_sinks_types_t>> m_sinks;
rfl::Rename<"pattern", std::vector<spdlog_patterns_t>> m_patterns;
rfl::Rename<"logger", std::vector<spdlog_loggers_t>> m_loggers;
rfl::Rename<"thread_pools", std::vector<spdlog_threadpool_t>> m_thread_pools;
rfl::Rename<"global_pattern", std::string> m_global_pattern;
rfl::Rename<"global_thread_pool", spdlog_global_threadpool_t>
m_global_thread_pool;
};
// ===========================================================================
// LevelManager — runtime log-level control
// ===========================================================================
/**
* @brief Singleton manager for runtime log-level changes.
*
* Provides thread-safe helpers to change the log level of any registered
* spdlog logger (and optionally all its sinks) at runtime, without
* restarting the application or reloading the JSON configuration.
*
* Usage:
* @code
* // Change a single named logger (logger + all its sinks):
* spdlogconfig::LevelManager::instance().setLoggerLevel("my_logger",
* spdlog::level::debug);
*
* // Change by string name (convenience overload):
* spdlogconfig::LevelManager::instance().setLoggerLevel("my_logger", "warn");
*
* // Change all registered loggers at once:
* spdlogconfig::LevelManager::instance().setAllLoggersLevel(spdlog::level::trace);
*
* // Restore the level that was active when setupFrom() was called:
* spdlogconfig::LevelManager::instance().resetLoggerLevel("my_logger");
*
* // Restore all loggers to their initial levels:
* spdlogconfig::LevelManager::instance().resetAllLoggers();
*
* // Query the current level of a logger:
* auto lvl =
* spdlogconfig::LevelManager::instance().getLoggerLevel("my_logger");
* @endcode
*/
class LevelManager {
public:
/** Returns the single process-wide instance. */
static LevelManager &instance() {
static LevelManager inst;
return inst;
}
// Non-copyable / non-movable
LevelManager(const LevelManager &) = delete;
LevelManager &operator=(const LevelManager &) = delete;
// -------------------------------------------------------------------
// Called by setupFrom() to record initial levels
// -------------------------------------------------------------------
/** @internal Records the initial level for a logger (called by setupFrom). */
void registerInitialLevel(const std::string &loggerName,
spdlog::level::level_enum level) {
std::unique_lock lock(m_mutex);
m_initialLevels[loggerName] = level;
}
// -------------------------------------------------------------------
// Set level — logger + all sinks
// -------------------------------------------------------------------
/**
* @brief Set the log level of a named logger and propagate to all its sinks.
*
* Both the logger's own filter level and every attached sink's level are
* updated, so the change takes immediate effect for all output targets.
*
* @param loggerName Name as registered with spdlog.
* @param level New spdlog level.
* @throws std::runtime_error if the logger is not found.
*/
void setLoggerLevel(const std::string &loggerName,
spdlog::level::level_enum level) {
auto logger = spdlog::get(loggerName);
if (!logger) {
throw std::runtime_error("LevelManager: logger '" + loggerName +
"' not found.");
}
// Update the logger's own level
logger->set_level(level);
// Propagate to every sink attached to this logger
for (auto &sink : logger->sinks()) {
sink->set_level(level);
}
// Keep an audit record of the last explicitly set level
std::unique_lock lock(m_mutex);
m_currentLevels[loggerName] = level;
}
/**
* @brief String-based convenience overload.
*
* Accepts level names: "trace", "debug", "info", "warn", "err",
* "critical", "off" (case-sensitive, matching spdlog conventions).
*
* @throws std::invalid_argument if the level string is unknown.
* @throws std::runtime_error if the logger is not found.
*/
void setLoggerLevel(const std::string &loggerName,
const std::string &levelName) {
setLoggerLevel(loggerName, utils::levelFromString(levelName));
}
// -------------------------------------------------------------------
// Set level — only the logger filter (sinks keep their individual levels)
// -------------------------------------------------------------------
/**
* @brief Set only the logger-level filter, leaving individual sink levels
* untouched.
*
* Useful when sinks have intentionally different granularities (e.g. a file
* sink at trace, a console sink at warn) and you only want to widen/narrow
* what the logger forwards to them.
*
* @param loggerName Name as registered with spdlog.
* @param level New spdlog level.
* @throws std::runtime_error if the logger is not found.
*/
void setLoggerLevelOnly(const std::string &loggerName,
spdlog::level::level_enum level) {
auto logger = spdlog::get(loggerName);
if (!logger) {
throw std::runtime_error("LevelManager: logger '" + loggerName +
"' not found.");
}
logger->set_level(level);
std::unique_lock lock(m_mutex);
m_currentLevels[loggerName] = level;
}
// -------------------------------------------------------------------
// Set level — all registered loggers
// -------------------------------------------------------------------
/**
* @brief Apply a new level to **every** logger currently registered with
* spdlog (including their sinks).
*
* @param level New spdlog level.
*/
void setAllLoggersLevel(spdlog::level::level_enum level) {
spdlog::apply_all([&](std::shared_ptr<spdlog::logger> logger) {
logger->set_level(level);
for (auto &sink : logger->sinks()) {
sink->set_level(level);
}
std::unique_lock lock(m_mutex);
m_currentLevels[logger->name()] = level;
});
}
/**
* @brief String-based overload of setAllLoggersLevel().
* @throws std::invalid_argument if the level string is unknown.
*/
void setAllLoggersLevel(const std::string &levelName) {
setAllLoggersLevel(utils::levelFromString(levelName));
}
// -------------------------------------------------------------------
// Reset to initial / configured levels
// -------------------------------------------------------------------
/**
* @brief Restore a logger's level (and its sinks) to the level that was
* active immediately after setupFrom() completed.
*
* @param loggerName Name as registered with spdlog.
* @throws std::runtime_error if the logger or its initial level is not found.
*/
void resetLoggerLevel(const std::string &loggerName) {
spdlog::level::level_enum initial{};
{
std::shared_lock lock(m_mutex);
auto it = m_initialLevels.find(loggerName);
if (it == m_initialLevels.end()) {
throw std::runtime_error(
"LevelManager: no initial level recorded for logger '" +
loggerName + "'.");
}
initial = it->second;
}
setLoggerLevel(loggerName, initial);
}
/**
* @brief Restore **all** loggers to their initial post-setupFrom() levels.
*/
void resetAllLoggers() {
std::unordered_map<std::string, spdlog::level::level_enum> snapshot;
{
std::shared_lock lock(m_mutex);
snapshot = m_initialLevels;
}
for (const auto &[name, level] : snapshot) {
auto logger = spdlog::get(name);
if (logger) {
logger->set_level(level);
for (auto &sink : logger->sinks()) {
sink->set_level(level);
}
}
}
std::unique_lock lock(m_mutex);
m_currentLevels = m_initialLevels;
}
// -------------------------------------------------------------------
// Query
// -------------------------------------------------------------------
/**
* @brief Return the current level of a named logger.
*
* Reads directly from the live spdlog logger object (not the audit map),
* so it always reflects reality even if the level was changed via spdlog
* directly.
*
* @param loggerName Name as registered with spdlog.
* @return Current spdlog::level::level_enum.
* @throws std::runtime_error if the logger is not found.
*/
[[nodiscard]] spdlog::level::level_enum
getLoggerLevel(const std::string &loggerName) const {
auto logger = spdlog::get(loggerName);
if (!logger) {
throw std::runtime_error("LevelManager: logger '" + loggerName +
"' not found.");
}
return logger->level();
}
/**
* @brief Return the level that was set when setupFrom() completed for the
* given logger.
*
* @param loggerName Name as registered with spdlog.
* @return Initial spdlog::level::level_enum.
* @throws std::runtime_error if no initial level was recorded.
*/
[[nodiscard]] spdlog::level::level_enum
getInitialLoggerLevel(const std::string &loggerName) const {
std::shared_lock lock(m_mutex);
auto it = m_initialLevels.find(loggerName);
if (it == m_initialLevels.end()) {
throw std::runtime_error(
"LevelManager: no initial level recorded for logger '" + loggerName +
"'.");
}
return it->second;
}
// -------------------------------------------------------------------
// Config-file path — set once by setupFrom(), read by setupFromReload()
// -------------------------------------------------------------------
/** @internal Called by setupFrom() to remember the config file path. */
void registerConfigFile(const std::string &path) {
std::unique_lock lock(m_mutex);
if (m_configFilePath.empty()) { // only the first call wins
m_configFilePath = path;
}
}
/**
* @brief Returns the path of the JSON file that was passed to the first
* setupFrom() call, so that setupFromReload() knows what to reload.
*
* @throws std::runtime_error if setupFrom() has not been called yet.
*/
[[nodiscard]] std::string configFilePath() const {
std::shared_lock lock(m_mutex);
if (m_configFilePath.empty()) {
throw std::runtime_error(
"LevelManager: setupFrom() has not been called yet — "
"no config file path is registered.");
}
return m_configFilePath;
}
private:
LevelManager() = default;
mutable std::shared_mutex m_mutex;
std::string m_configFilePath; ///< path from first setupFrom()
std::unordered_map<std::string, spdlog::level::level_enum> m_initialLevels;
std::unordered_map<std::string, spdlog::level::level_enum> m_currentLevels;
};
// ===========================================================================
// setupFrom
// ===========================================================================
/**
* @brief Configure spdlog from a JSON configuration file.
*
* After all loggers are registered, each logger's level is recorded in the
* process-wide LevelManager so that runtime resets are possible.
*
* @param file Path to the JSON configuration file.
*/
inline void setupFrom(std::string const &file) {
// Remember the path for setupFromReload() — only the very first call wins.
LevelManager::instance().registerConfigFile(file);
try {
std::ifstream file_stream(file, std::ios::binary);
if (!file_stream.is_open()) {
throw spdlogconfig_error("Unable to open configuration file: " + file);
}
std::stringstream pre_json_ss;
pre_json_ss << file_stream.rdbuf();
auto spdlogConfig =
rfl::json::read<spdlogconfig::spdlog_conf_t, rfl::DefaultIfMissing>(
pre_json_ss)
.value();
// Create global thread pool
spdlog::init_thread_pool(
spdlogConfig.m_global_thread_pool.value().m_queue_size.value().value(),
spdlogConfig.m_global_thread_pool.value()
.m_thread_count.value()
.value());
for (const auto &logger_item : spdlogConfig.m_loggers.value()) {
auto sinkList = std::vector<spdlog::sink_ptr>{};
for (const auto &sinks_item : logger_item.m_logger_sinks.value()) {
for (const auto &sink_log_item : spdlogConfig.m_sinks.value()) {
if (sink_log_item.m_sink_name.value() == sinks_item) {
using enum spdlogconfig::spdlog_sink_types_enum;
// Helper lambda to compute the effective sink level
auto effectiveLevel = [&]() -> spdlog::level::level_enum {
return sink_log_item.m_level.value().has_value()
? static_cast<spdlog::level::level_enum>(
sink_log_item.m_level.value().value())
: static_cast<spdlog::level::level_enum>(
logger_item.m_logger_level.value().value());
};
switch (sink_log_item.m_sink_type.value()) {
case stdout_sink_st:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stdout_sink_st>())
->set_level(effectiveLevel());
break;
case stdout_sink_mt:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stdout_sink_mt>())
->set_level(effectiveLevel());
break;
case stderr_sink_st:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stderr_sink_st>())
->set_level(effectiveLevel());
break;
case stderr_sink_mt:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stderr_sink_mt>())
->set_level(effectiveLevel());
break;
case stdout_color_sink_st:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stdout_color_sink_st>())
->set_level(effectiveLevel());
break;
case stdout_color_sink_mt:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stdout_color_sink_mt>())
->set_level(effectiveLevel());
break;
case stderr_color_sink_st:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stderr_color_sink_st>())
->set_level(effectiveLevel());
break;
case stderr_color_sink_mt:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::stderr_color_sink_mt>())
->set_level(effectiveLevel());
break;
case basic_file_sink_st:
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_file_name.value().value().parent_path());
}
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::basic_file_sink_st>(
sink_log_item.m_file_name.value()
.value()
.generic_string(),
sink_log_item.m_truncate.value().value()))
->set_level(effectiveLevel());
break;
case basic_file_sink_mt:
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_file_name.value().value().parent_path());
}
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::basic_file_sink_mt>(
sink_log_item.m_file_name.value()
.value()
.generic_string(),
sink_log_item.m_truncate.value().value()))
->set_level(effectiveLevel());
break;
case rotating_file_sink_st:
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_base_file_name.value()
.value()
.parent_path());
}
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::rotating_file_sink_st>(
sink_log_item.m_base_file_name.value()
.value()
.generic_string(),
utils::GetMaxSizeInt(
sink_log_item.m_max_size.value()->value()),
sink_log_item.m_max_files.value().value()))
->set_level(effectiveLevel());
break;
case rotating_file_sink_mt:
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_base_file_name.value()
.value()
.parent_path());
}
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
sink_log_item.m_base_file_name.value()
.value()
.generic_string(),
utils::GetMaxSizeInt(
sink_log_item.m_max_size.get()->value()),
sink_log_item.m_max_files.value().value()))
->set_level(effectiveLevel());
break;
case daily_file_sink_st: {
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_base_file_name.value()
.value()
.parent_path());
}
sinkList
.emplace_back(std::make_shared<
spdlog::sinks::daily_file_sink_st>(
sink_log_item.m_base_file_name.value()
.value()
.generic_string(),
sink_log_item.m_rotation_time.value()
.value()
.tm()
.tm_hour,
sink_log_item.m_rotation_time.value().value().tm().tm_min,
sink_log_item.m_truncate.value().value()))
->set_level(effectiveLevel());
break;
}
case daily_file_sink_mt: {
if (sink_log_item.m_create_parent_dir.value()) {
std::filesystem::create_directories(
sink_log_item.m_base_file_name.value()
.value()
.parent_path());
}
sinkList
.emplace_back(std::make_shared<
spdlog::sinks::daily_file_sink_mt>(
sink_log_item.m_base_file_name.value()
.value()
.generic_string(),
sink_log_item.m_rotation_time.value()
.value()
.tm()
.tm_hour,
sink_log_item.m_rotation_time.value().value().tm().tm_min,
sink_log_item.m_truncate.value().value()))
->set_level(effectiveLevel());
break;
}
case null_sink_st:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::null_sink_st>())
->set_level(effectiveLevel());
break;
case null_sink_mt:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::null_sink_mt>())
->set_level(effectiveLevel());
break;
#ifdef __ANDROID__
case android_sink_st:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::android_sink_st>())
->set_level(effectiveLevel());
break;
case android_sink_mt:
sinkList
.emplace_back(
std::make_shared<spdlog::sinks::android_sink_mt>())
->set_level(effectiveLevel());
break;
#endif
#ifndef _WIN32
case syslog_sink_st:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::syslog_sink_st>(
sink_log_item.m_syslog_ident.value()->c_str(),
sink_log_item.m_syslog_option.value().value(),
sink_log_item.m_syslog_facility.value().value(), true))
->set_level(effectiveLevel());
break;
case syslog_sink_mt:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::syslog_sink_mt>(
sink_log_item.m_syslog_ident.value()->c_str(),
sink_log_item.m_syslog_option.value().value(),
sink_log_item.m_syslog_facility.value().value(), true))
->set_level(effectiveLevel());
break;
#endif
#ifdef _WIN32
case msvc_sink_st:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::msvc_sink_st>())
->set_level(effectiveLevel());
break;
case msvc_sink_mt:
sinkList
.emplace_back(std::make_shared<spdlog::sinks::msvc_sink_mt>())
->set_level(effectiveLevel());
break;
#endif
default:
break;
}
}
}
}
// Build the logger (sync or async)
std::shared_ptr<spdlog::logger> logger;
if (logger_item.m_logger_type.value() == names::SYNC) {
logger = std::make_shared<spdlog::logger>(
logger_item.m_logger_name.value(), begin(sinkList), end(sinkList));
} else if (logger_item.m_logger_type.value() == names::ASYNC) {
if (logger_item.m_thread_pool.value().has_value()) {
static std::shared_ptr<spdlog::details::thread_pool> threadPoolPtr;
for (const auto &thread_pool_item :
spdlogConfig.m_thread_pools.value()) {
if (thread_pool_item.m_name.value() ==
logger_item.m_thread_pool.value().value()) {
threadPoolPtr = std::make_shared<spdlog::details::thread_pool>(
thread_pool_item.m_queue_size.value().value(),
thread_pool_item.m_thread_count.value().value());
break;
}
}
if (!threadPoolPtr) {
throw spdlogconfig_error(
"Error: Thread Pool not found for logger " +
logger_item.m_logger_name.value());
}
logger = std::make_shared<spdlog::async_logger>(
logger_item.m_logger_name.value().c_str(), begin(sinkList),
end(sinkList), std::move(threadPoolPtr),
logger_item.m_overflow_policy.value().value());
} else {
auto globalPool = spdlog::thread_pool();
if (!globalPool) {
throw spdlogconfig_error(
"Error: Global Thread Pool not available.");
}
logger = std::make_shared<spdlog::async_logger>(
logger_item.m_logger_name.value().c_str(), begin(sinkList),
end(sinkList), globalPool,
logger_item.m_overflow_policy.value().value());
}
}
const auto configuredLevel = static_cast<spdlog::level::level_enum>(
logger_item.m_logger_level.value().value());
logger->set_level(configuredLevel);
try {
if (logger_item.m_logger_pattern.value().has_value()) {
for (const auto &pattern_item : spdlogConfig.m_patterns.value()) {
if (pattern_item.m_pattern_name.value()->c_str() ==
logger_item.m_logger_pattern.value()->c_str()) {
logger->set_pattern(
pattern_item.m_pattern_value.value()->c_str());
}
}
} else {
logger->set_pattern(spdlogConfig.m_global_pattern.value().c_str());
}
} catch (const spdlog::spdlog_ex &e) {
throw spdlogconfig_error(
std::format("Error setting pattern to logger '{}' : {} ",
logger_item.m_logger_name.value().c_str(), e.what()));
}
spdlog::register_logger(logger);
// ---- NEW: record the initial level in the LevelManager ----
LevelManager::instance().registerInitialLevel(
logger_item.m_logger_name.value(), configuredLevel);
}
} catch (const rfl::Error &ex) {
std::cerr << "reflect-cpp error: " << ex.what();
} catch (const std::filesystem::filesystem_error &ex) {
std::cout << "what(): " << ex.what() << '\n'
<< "path1(): " << ex.path1() << '\n'
<< "path2(): " << ex.path2() << '\n'
<< "code().value(): " << ex.code().value() << '\n'
<< "code().message(): " << ex.code().message() << '\n'
<< "code().category(): " << ex.code().category().name() << '\n';
} catch (const spdlog::spdlog_ex &ex) {
std::cout << "spdlog: " << ex.what() << '\n';
} catch (const std::exception &ex) {
std::cout << "exception: " << ex.what() << '\n';
} catch (...) {
std::cout << "uncaught exception" << '\n';
}
}
// ===========================================================================
// setupFromReload — reload log levels from the original config file at runtime
// ===========================================================================
/**
* @brief Reload log levels from the JSON file that was passed to the first
* setupFrom() call — without re-creating any loggers or sinks.
*
* Call this function whenever the JSON configuration file has been edited on
* disk and you want the new `level` values to take effect immediately, while
* the application is still running.
*
* **What is updated:**
* - The logger-level filter of every named logger that already exists in
* spdlog's registry.
* - The level of every sink attached to that logger (so the change propagates
* to all output targets).
* - The "initial level" stored in LevelManager (so a subsequent
* resetLoggerLevel() uses the freshly loaded value).
*
* **What is NOT touched:**
* - Sink types, filenames, patterns, thread pools — the full logger/sink graph
* remains exactly as built by the original setupFrom() call.
*
* @throws std::runtime_error if setupFrom() has not been called yet
* (i.e. no config file path is registered).
* @throws spdlogconfig_error if the config file cannot be opened or parsed.
*
* Usage:
* @code
* // Initial setup (remembers the path automatically):
* spdlogconfig::setupFrom("config/logging.json");
*
* // ... later, after editing logging.json on disk:
* spdlogconfig::setupFromReload(); // picks up new levels, no path needed
* @endcode
*/
inline void setupFromReload() {
// Retrieve the path that was registered during the first setupFrom() call.
const std::string file = LevelManager::instance().configFilePath();
try {
std::ifstream file_stream(file, std::ios::binary);
if (!file_stream.is_open()) {
throw spdlogconfig_error(
"setupFromReload: Unable to open configuration file: " + file);
}
std::stringstream ss;
ss << file_stream.rdbuf();
auto spdlogConfig =
rfl::json::read<spdlogconfig::spdlog_conf_t, rfl::DefaultIfMissing>(ss)
.value();
auto &lm = LevelManager::instance();
for (const auto &logger_item : spdlogConfig.m_loggers.value()) {
const std::string &loggerName = logger_item.m_logger_name.value();
// Only update loggers that are already registered — never create new
// ones.
auto logger = spdlog::get(loggerName);
if (!logger) {
std::cerr << "setupFromReload: logger '" << loggerName
<< "' not found in registry — skipping.\n";
continue;
}
// Determine the new logger-level from the JSON.
if (!logger_item.m_logger_level.value().has_value()) {
continue; // no level entry in JSON for this logger — leave as-is
}
const auto newLevel = static_cast<spdlog::level::level_enum>(
logger_item.m_logger_level.value().value());
// Update the logger filter.
logger->set_level(newLevel);
// Update every attached sink.
// If a sink has its own level entry in the JSON, use that; otherwise
// fall back to the logger level — mirroring the logic in setupFrom().
for (const auto &sinkName : logger_item.m_logger_sinks.value()) {
// Find the matching sink config to check for a sink-specific level.
for (const auto &sinkCfg : spdlogConfig.m_sinks.value()) {
if (sinkCfg.m_sink_name.value() != sinkName) {
continue;
}
const auto sinkLevel = sinkCfg.m_level.value().has_value()
? static_cast<spdlog::level::level_enum>(
sinkCfg.m_level.value().value())
: newLevel;
// Apply to the matching live sink object (match by position in the
// sink list — sinks are added in the same order as m_logger_sinks).
// Because spdlog does not expose sinks by name, we apply the resolved
// level to all sinks; individual per-sink levels are honoured via the
// sink-config lookup above.
for (auto &liveSink : logger->sinks()) {
liveSink->set_level(sinkLevel);
}
break;
}
}
// Refresh the "initial" level in LevelManager so that a future
// resetLoggerLevel() restores to the newly loaded value.
lm.registerInitialLevel(loggerName, newLevel);
std::cout << "setupFromReload: logger '" << loggerName
<< "' level updated to '"
<< spdlog::level::to_string_view(newLevel).data() << "'\n";
}
} catch (const rfl::Error &ex) {
std::cerr << "setupFromReload reflect-cpp error: " << ex.what() << '\n';
} catch (const std::exception &ex) {
std::cerr << "setupFromReload exception: " << ex.what() << '\n';
} catch (...) {
std::cerr << "setupFromReload: uncaught exception\n";
}
}
} // namespace spdlogconfig
#endif // SPFLOGCONFIG_H
Reference in new issue View Git Blame Copy Permalink