Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 16 additions & 2 deletions docs/configuration-loading-RU.md
Original file line number Diff line number Diff line change
Expand Up @@ -70,5 +70,19 @@ schema v1 предусмотрены только signed и unsigned integer з

Следующие этапы вызываются явно через `materialize_configuration()` и
`instantiate_configuration()`. Frontend не читает файлы, не вводит собственные
defaults, не разрешает callback'и и не создаёт logger'ы. Properties input и hot
reload пока не реализованы.
defaults, не разрешает callback'и и не создаёт logger'ы. `instantiate_configuration()`
остаётся compatibility API для backend-instantiation: factory сама владеет
level logger'а и не создаёт formatter из materialized strategy. Для атомарного
применения strategy используйте `prepare_configuration()`: он создаёт formatter
и назначает explicit level или default `TRACE`. Properties input и hot reload
пока не реализованы.

Для подготовки runtime-пар доступен `prepare_configuration()`. Он возвращает
`ConfigurationPreparedSet`: стабильный ID logger'а, конкретные `ILogger`,
`ILogFormatter` и применённый `LogLevel`. При отсутствии level используется
`TRACE`; formatter schema v1 имеет тип `simple`, defaults публичного
`SimpleLogFormatter::Config`, а затем применяет явные pattern и JSON overrides.
Prepared result использует shared ownership в соответствии с существующим
factory API. `Logger::add_logger()` пока принимает unique ownership, поэтому
регистрация остаётся отдельной границей; подготовка не изменяет глобальный
singleton поэлементно.
19 changes: 17 additions & 2 deletions docs/configuration-loading.md
Original file line number Diff line number Diff line change
Expand Up @@ -75,5 +75,20 @@ unsigned integer numeric values.

Call `materialize_configuration()` and `instantiate_configuration()` explicitly
for the later phases. The frontend does not read files, apply frontend-specific
defaults, resolve callbacks, or construct loggers. Properties input and hot
reload remain outside the current implementation.
defaults, resolve callbacks, or construct loggers. `instantiate_configuration()`
is the compatibility backend-instantiation API: the factory remains responsible
for the logger's level and accepts the materialized formatter fields without
constructing a formatter. Use `prepare_configuration()` when the schema
strategy must be applied atomically; it constructs the formatter and assigns the
explicit level or the `TRACE` default. Properties input and hot reload remain
outside the current implementation.

Runtime preparation is available through `prepare_configuration()`. It returns
a `ConfigurationPreparedSet` containing each stable logger ID, the concrete
`ILogger`, its `ILogFormatter`, and the applied `LogLevel`. Omitted levels use
`TRACE`; schema-v1 formatters use `simple` with the public
`SimpleLogFormatter::Config` defaults, then apply explicit pattern and JSON
overrides. The prepared result uses shared ownership to match the existing
factory API. `Logger::add_logger()` currently accepts unique ownership and is
therefore a separate registration boundary; preparation does not mutate the
global singleton incrementally.
238 changes: 192 additions & 46 deletions include/logit_cpp/logit/configuration_runtime.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,11 @@
/// \brief Binding and runtime-instantiation contract for materialized plans.

#include "configuration.hpp"
#include "formatter.hpp"
#include "loggers.hpp"

#include <cstdint>
#include <exception>
#include <map>
#include <memory>
#include <string>
Expand Down Expand Up @@ -105,76 +108,219 @@ namespace logit {
ConfigurationDiagnostics& diagnostics) const = 0;
};

/// \brief Resolve bindings and publish a complete logger set atomically.
/// \struct ConfigurationPreparedLogger
/// \brief Complete runtime pair prepared from one materialized entry.
///
/// The caller-visible logger vector is updated only after every binding has
/// resolved and every factory call has returned a logger. Factories may
/// still perform external side effects while constructing instances; those
/// effects are not transactional and are not rolled back if a later factory
/// fails.
inline bool instantiate_configuration(
/// Shared ownership matches the existing ConfigurationLoggerFactory API.
/// This result is intentionally not accepted by `Logger::add_logger()`,
/// which currently takes unique ownership; defining an atomic batch
/// registration and ownership transfer API is a separate boundary.
struct ConfigurationPreparedLogger {
std::string id;
std::shared_ptr<ILogger> logger;
std::shared_ptr<ILogFormatter> formatter;
LogLevel level = LogLevel::LOG_LVL_TRACE;
};

/// \struct ConfigurationPreparedSet
/// \brief Atomically published runtime preparation result.
struct ConfigurationPreparedSet {
std::uint32_t schema_version = 0;
std::vector<ConfigurationPreparedLogger> loggers;
};

namespace configuration_runtime_detail {

inline std::shared_ptr<ILogFormatter> make_configuration_formatter(
const ConfigurationMaterializedLogger& logger,
ConfigurationDiagnostics& diagnostics) {
try {
SimpleLogFormatter::Config config;
if (logger.strategy.has_formatter) {
const ConfigurationFormatterSpec& formatter = logger.strategy.formatter;
if (formatter.type != "simple") {
diagnostics.add(ConfigurationErrorCode::InvalidValue,
"strategy.formatter.type",
"Only the simple formatter is supported in schema v1");
return std::shared_ptr<ILogFormatter>();
}
if (formatter.has_pattern) config.pattern = formatter.pattern;
if (formatter.has_json_format) config.json_format = formatter.json_format;
}
return std::shared_ptr<ILogFormatter>(
new SimpleLogFormatter(config.pattern, config.json_format));
} catch (const std::exception& error) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
"strategy.formatter.pattern",
std::string("Formatter construction failed: ") + error.what());
} catch (...) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
"strategy.formatter.pattern",
"Formatter construction failed");
}
return std::shared_ptr<ILogFormatter>();
}

inline bool resolve_bindings(
const ConfigurationPlan& plan,
const ConfigurationBindingResolver& resolver,
std::vector<ConfigurationBindingSet>& resolved_bindings,
ConfigurationDiagnostics& diagnostics) {
resolved_bindings.reserve(plan.loggers.size());
bool bindings_ok = true;
for (std::size_t index = 0; index < plan.loggers.size(); ++index) {
const ConfigurationMaterializedLogger& entry = plan.loggers[index];
ConfigurationBindingSet bindings;
ConfigurationDiagnostics local_diagnostics;
const bool resolved = resolver.resolve(entry, bindings, local_diagnostics);
bool missing_binding = false;
for (std::vector<std::string>::const_iterator required =
entry.required_bindings.begin();
required != entry.required_bindings.end(); ++required) {
if (!bindings.contains(*required)) {
local_diagnostics.add(ConfigurationErrorCode::MissingProgrammaticBinding,
"binding." + *required,
"Required programmatic binding was not resolved");
missing_binding = true;
}
}
const std::string prefix = "loggers[" + std::to_string(index) + "]";
if (!resolved || !local_diagnostics.empty() || missing_binding) {
bindings_ok = false;
if (local_diagnostics.empty()) {
diagnostics.add(ConfigurationErrorCode::BindingResolutionFailed,
prefix + ".binding",
"Programmatic bindings could not be resolved");
} else {
diagnostics.append_rebased(local_diagnostics, prefix);
}
}
resolved_bindings.push_back(bindings);
}
return bindings_ok;
}

inline std::shared_ptr<ILogger> instantiate_logger(
const ConfigurationMaterializedLogger& entry,
const ConfigurationBindingSet& bindings,
const ConfigurationLoggerFactory& factory,
const std::string& prefix,
ConfigurationDiagnostics& diagnostics) {
ConfigurationDiagnostics local_diagnostics;
std::shared_ptr<ILogger> runtime_logger =
factory.instantiate(entry, bindings, local_diagnostics);
if (!runtime_logger || !local_diagnostics.empty()) {
if (local_diagnostics.empty()) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
prefix,
"Logger factory could not instantiate the plan entry");
} else {
diagnostics.append_rebased(local_diagnostics, prefix);
}
return std::shared_ptr<ILogger>();
}
return runtime_logger;
}

} // namespace configuration_runtime_detail

/// \brief Resolve bindings and prepare complete logger/formatter pairs.
///
/// The caller-visible prepared set is updated only after every binding,
/// backend factory call, formatter construction, and level assignment has
/// succeeded. Factory side effects remain non-transactional.
inline bool prepare_configuration(
const ConfigurationPlan& plan,
const ConfigurationBindingResolver& resolver,
const ConfigurationLoggerFactory& factory,
std::vector<std::shared_ptr<ILogger>>& loggers,
ConfigurationPreparedSet& output,
ConfigurationDiagnostics& diagnostics) {
diagnostics = ConfigurationDiagnostics();
std::vector<ConfigurationBindingSet> resolved_bindings;
resolved_bindings.reserve(plan.loggers.size());
bool bindings_ok = true;
if (!configuration_runtime_detail::resolve_bindings(
plan, resolver, resolved_bindings, diagnostics)) return false;

ConfigurationPreparedSet candidate;
candidate.schema_version = plan.schema_version;
candidate.loggers.reserve(plan.loggers.size());
for (std::size_t index = 0; index < plan.loggers.size(); ++index) {
const ConfigurationMaterializedLogger& entry = plan.loggers[index];
ConfigurationBindingSet bindings;
ConfigurationDiagnostics local_diagnostics;
const bool resolved = resolver.resolve(entry, bindings, local_diagnostics);

bool missing_binding = false;
for (std::vector<std::string>::const_iterator required =
entry.required_bindings.begin();
required != entry.required_bindings.end(); ++required) {
if (!bindings.contains(*required)) {
local_diagnostics.add(ConfigurationErrorCode::MissingProgrammaticBinding,
"binding." + *required,
"Required programmatic binding was not resolved");
missing_binding = true;
}
}

const std::string prefix = "loggers[" + std::to_string(index) + "]";
if (!resolved || !local_diagnostics.empty() || missing_binding) {
bindings_ok = false;
std::shared_ptr<ILogger> runtime_logger =
configuration_runtime_detail::instantiate_logger(
entry, resolved_bindings[index], factory, prefix, diagnostics);
if (!runtime_logger) return false;

ConfigurationDiagnostics local_diagnostics;
std::shared_ptr<ILogFormatter> formatter =
configuration_runtime_detail::make_configuration_formatter(entry, local_diagnostics);
if (!formatter) {
if (local_diagnostics.empty()) {
diagnostics.add(ConfigurationErrorCode::BindingResolutionFailed,
prefix + ".binding",
"Programmatic bindings could not be resolved");
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
prefix + ".strategy.formatter.pattern",
"Formatter could not be prepared");
} else {
diagnostics.append_rebased(local_diagnostics, prefix);
}
return false;
}
resolved_bindings.push_back(bindings);

const LogLevel level = entry.strategy.has_level
? entry.strategy.level : LogLevel::LOG_LVL_TRACE;
try {
runtime_logger->set_log_level(level);
} catch (const std::exception& error) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
prefix + ".strategy.level",
std::string("Logger level assignment failed: ") + error.what());
return false;
} catch (...) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
prefix + ".strategy.level",
"Logger level assignment failed");
return false;
}

ConfigurationPreparedLogger prepared;
prepared.id = entry.id;
prepared.logger = runtime_logger;
prepared.formatter = formatter;
prepared.level = level;
candidate.loggers.push_back(prepared);
}
output = candidate;
return true;
}

if (!bindings_ok) return false;
/// \brief Resolve bindings and publish a complete logger set atomically.
///
/// This is the legacy backend-instantiation API. It deliberately preserves
/// the pre-runtime-preparation contract: the factory owns logger strategy
/// state, so this function does not construct formatters or assign levels.
/// Use `prepare_configuration()` when strategy-aware formatter and level
/// preparation is required. The caller-visible logger vector is updated
/// only after every binding has resolved and every factory call has
/// returned a logger. Factory side effects remain non-transactional.
inline bool instantiate_configuration(
const ConfigurationPlan& plan,
const ConfigurationBindingResolver& resolver,
const ConfigurationLoggerFactory& factory,
std::vector<std::shared_ptr<ILogger>>& loggers,
ConfigurationDiagnostics& diagnostics) {
diagnostics = ConfigurationDiagnostics();
std::vector<ConfigurationBindingSet> resolved_bindings;
if (!configuration_runtime_detail::resolve_bindings(
plan, resolver, resolved_bindings, diagnostics)) return false;

std::vector<std::shared_ptr<ILogger>> candidate;
candidate.reserve(plan.loggers.size());
for (std::size_t index = 0; index < plan.loggers.size(); ++index) {
const ConfigurationMaterializedLogger& entry = plan.loggers[index];
const std::string prefix = "loggers[" + std::to_string(index) + "]";

ConfigurationDiagnostics factory_diagnostics;
std::shared_ptr<ILogger> runtime_logger =
factory.instantiate(entry, resolved_bindings[index], factory_diagnostics);
if (!runtime_logger || !factory_diagnostics.empty()) {
if (factory_diagnostics.empty()) {
diagnostics.add(ConfigurationErrorCode::InstantiationFailed,
prefix,
"Logger factory could not instantiate the plan entry");
} else {
diagnostics.append_rebased(factory_diagnostics, prefix);
}
return false;
}
configuration_runtime_detail::instantiate_logger(
entry, resolved_bindings[index], factory, prefix, diagnostics);
if (!runtime_logger) return false;
candidate.push_back(runtime_logger);
}

Expand Down
2 changes: 2 additions & 0 deletions include/logit_cpp/logit/utils.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,8 @@
#include "config.hpp"
#include "enums.hpp"
#include "utils/format.hpp"
// TimeShield's time_formatting.hpp uses std::fill without including <algorithm>.
#include <algorithm>
#include "utils/VariableValue.hpp"
#include "utils/argument_utils.hpp"
#include "utils/BufferedLogEntry.hpp"
Expand Down
Loading
Loading