From 4d96daf21023891214ecfaae1e2063c73fadeefc Mon Sep 17 00:00:00 2001 From: LimiNode <20008174+LimiNode@users.noreply.github.com> Date: Wed, 4 Nov 2026 19:27:35 +0300 Subject: [PATCH 1/4] feat(config): prepare runtime strategy and formatter Add an atomic prepared runtime result that carries logger IDs, logger instances, formatters, and effective levels. Apply schema-v1 formatter defaults and overrides, preserve the legacy instantiation API, and cover the JSON-to-runtime path with focused regressions. --- docs/configuration-loading-RU.md | 10 ++ docs/configuration-loading.md | 10 ++ .../logit_cpp/logit/configuration_runtime.hpp | 152 +++++++++++++++--- tests/configuration_contract_test.cpp | 79 +++++++++ tests/configuration_json_test.cpp | 41 +++++ 5 files changed, 273 insertions(+), 19 deletions(-) diff --git a/docs/configuration-loading-RU.md b/docs/configuration-loading-RU.md index 3b65214..23b48f3 100644 --- a/docs/configuration-loading-RU.md +++ b/docs/configuration-loading-RU.md @@ -72,3 +72,13 @@ schema v1 предусмотрены только signed и unsigned integer з `instantiate_configuration()`. Frontend не читает файлы, не вводит собственные defaults, не разрешает callback'и и не создаёт logger'ы. 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 поэлементно. diff --git a/docs/configuration-loading.md b/docs/configuration-loading.md index 35e5459..fcff72f 100644 --- a/docs/configuration-loading.md +++ b/docs/configuration-loading.md @@ -77,3 +77,13 @@ 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. + +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. diff --git a/include/logit_cpp/logit/configuration_runtime.hpp b/include/logit_cpp/logit/configuration_runtime.hpp index 1dc5e14..ab312d8 100644 --- a/include/logit_cpp/logit/configuration_runtime.hpp +++ b/include/logit_cpp/logit/configuration_runtime.hpp @@ -6,8 +6,11 @@ /// \brief Binding and runtime-instantiation contract for materialized plans. #include "configuration.hpp" +#include "formatter.hpp" #include "loggers.hpp" +#include +#include #include #include #include @@ -105,18 +108,71 @@ 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 logger; + std::shared_ptr 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 loggers; + }; + + namespace configuration_runtime_detail { + + inline std::shared_ptr 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(); + } + if (formatter.has_pattern) config.pattern = formatter.pattern; + if (formatter.has_json_format) config.json_format = formatter.json_format; + } + return std::shared_ptr( + 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(); + } + + } // 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>& loggers, + ConfigurationPreparedSet& output, ConfigurationDiagnostics& diagnostics) { diagnostics = ConfigurationDiagnostics(); std::vector resolved_bindings; @@ -127,7 +183,6 @@ namespace logit { ConfigurationBindingSet bindings; ConfigurationDiagnostics local_diagnostics; const bool resolved = resolver.resolve(entry, bindings, local_diagnostics); - bool missing_binding = false; for (std::vector::const_iterator required = entry.required_bindings.begin(); @@ -153,29 +208,88 @@ namespace logit { } resolved_bindings.push_back(bindings); } - if (!bindings_ok) return false; - std::vector> candidate; - candidate.reserve(plan.loggers.size()); + 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]; const std::string prefix = "loggers[" + std::to_string(index) + "]"; - - ConfigurationDiagnostics factory_diagnostics; + ConfigurationDiagnostics local_diagnostics; std::shared_ptr runtime_logger = - factory.instantiate(entry, resolved_bindings[index], factory_diagnostics); - if (!runtime_logger || !factory_diagnostics.empty()) { - if (factory_diagnostics.empty()) { + factory.instantiate(entry, resolved_bindings[index], 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(factory_diagnostics, prefix); + diagnostics.append_rebased(local_diagnostics, prefix); } return false; } - candidate.push_back(runtime_logger); + + std::shared_ptr formatter = + configuration_runtime_detail::make_configuration_formatter(entry, local_diagnostics); + if (!formatter) { + if (local_diagnostics.empty()) { + diagnostics.add(ConfigurationErrorCode::InstantiationFailed, + prefix + ".strategy.formatter.pattern", + "Formatter could not be prepared"); + } else { + diagnostics.append_rebased(local_diagnostics, prefix); + } + return false; + } + + 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; + } + + /// \brief Resolve bindings and publish a complete logger set atomically. + /// + /// 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( + const ConfigurationPlan& plan, + const ConfigurationBindingResolver& resolver, + const ConfigurationLoggerFactory& factory, + std::vector>& loggers, + ConfigurationDiagnostics& diagnostics) { + ConfigurationPreparedSet prepared; + if (!prepare_configuration(plan, resolver, factory, prepared, diagnostics)) return false; + std::vector> candidate; + candidate.reserve(prepared.loggers.size()); + for (std::vector::const_iterator it = + prepared.loggers.begin(); it != prepared.loggers.end(); ++it) { + candidate.push_back(it->logger); } loggers = candidate; diff --git a/tests/configuration_contract_test.cpp b/tests/configuration_contract_test.cpp index 51382ad..a15b7c6 100644 --- a/tests/configuration_contract_test.cpp +++ b/tests/configuration_contract_test.cpp @@ -534,6 +534,84 @@ void test_builtin_runtime_factory_consumes_materialized_plan() { assert(std::dynamic_pointer_cast(loggers[0])); } +struct EmptyBindingResolver : logit::ConfigurationBindingResolver { + bool resolve(const logit::ConfigurationMaterializedLogger&, + logit::ConfigurationBindingSet&, + logit::ConfigurationDiagnostics&) const override { + return true; + } +}; + +void test_prepared_runtime_applies_strategy_atomically() { + logit::ConfigurationDocument document; + document.schema_version = 1; + + logit::ConfigurationLoggerSpec patterned; + patterned.id = "patterned"; + patterned.type = "memory"; + patterned.strategy.has_level = true; + patterned.strategy.level = logit::LogLevel::LOG_LVL_INFO; + patterned.strategy.has_formatter = true; + patterned.strategy.formatter.has_pattern = true; + patterned.strategy.formatter.pattern = "%l|%v"; + document.loggers.push_back(patterned); + + logit::ConfigurationLoggerSpec json; + json.id = "json"; + json.type = "memory"; + json.strategy.has_formatter = true; + json.strategy.formatter.has_json_format = true; + json.strategy.formatter.json_format = true; + document.loggers.push_back(json); + + logit::ConfigurationLoggerSpec defaults; + defaults.id = "defaults"; + defaults.type = "memory"; + document.loggers.push_back(defaults); + + logit::BuiltinConfigurationMaterializer materializer; + logit::ConfigurationPlan plan; + logit::ConfigurationDiagnostics diagnostics; + assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + + EmptyBindingResolver resolver; + logit::BuiltinConfigurationLoggerFactory factory; + logit::ConfigurationPreparedSet prepared; + assert(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); + assert(prepared.schema_version == 1); + assert(prepared.loggers.size() == 3); + assert(prepared.loggers[0].id == "patterned"); + assert(prepared.loggers[1].id == "json"); + assert(prepared.loggers[2].id == "defaults"); + assert(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); + assert(prepared.loggers[1].level == logit::LogLevel::LOG_LVL_TRACE); + assert(prepared.loggers[0].formatter); + assert(prepared.loggers[1].formatter); + assert(prepared.loggers[2].formatter); + + logit::LogRecord record(logit::LogLevel::LOG_LVL_INFO, 0, "test.cpp", 7, + "test", "hello", "", -1, false); + assert(prepared.loggers[0].formatter->format(record) == "INFO|hello"); + assert(prepared.loggers[1].formatter->format(record).find("\"format\"") != std::string::npos); + logit::SimpleLogFormatter default_formatter; + assert(prepared.loggers[2].formatter->format(record) == default_formatter.format(record)); + assert(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); + + logit::ConfigurationPreparedSet sentinel; + logit::ConfigurationPreparedLogger existing; + existing.id = "existing"; + sentinel.loggers.push_back(existing); + logit::ConfigurationMaterializedLogger invalid = plan.loggers[0]; + invalid.strategy.has_formatter = true; + invalid.strategy.formatter.type = "unsupported"; + plan.loggers[0] = invalid; + assert(!logit::prepare_configuration(plan, resolver, factory, sentinel, diagnostics)); + assert(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); + assert(diagnostics.items()[0].path == "loggers[0].strategy.formatter.type"); + assert(sentinel.loggers.size() == 1); + assert(sentinel.loggers[0].id == "existing"); +} + void test_builtin_runtime_factory_supports_payload_backends() { #if defined(LOGIT_WITH_MDBX) { @@ -706,6 +784,7 @@ int main() { test_optional_format_defaults_merge_recursively(); test_runtime_binding_and_instantiation_are_atomic(); test_builtin_runtime_factory_consumes_materialized_plan(); + test_prepared_runtime_applies_strategy_atomically(); test_builtin_runtime_factory_supports_payload_backends(); return 0; } diff --git a/tests/configuration_json_test.cpp b/tests/configuration_json_test.cpp index 658d3fb..89ae2db 100644 --- a/tests/configuration_json_test.cpp +++ b/tests/configuration_json_test.cpp @@ -5,6 +5,14 @@ namespace { +struct EmptyBindingResolver : logit::ConfigurationBindingResolver { + bool resolve(const logit::ConfigurationMaterializedLogger&, + logit::ConfigurationBindingSet&, + logit::ConfigurationDiagnostics&) const override { + return true; + } +}; + void test_valid_json_maps_and_materializes() { const std::string input = R"json({ "schema_version": 1, @@ -136,6 +144,38 @@ void test_frontend_rejects_unknown_strategy_and_named_values() { assert(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); } +void test_json_reaches_prepared_runtime_strategy() { + const std::string input = R"json({ + "schema_version": 1, + "loggers": [{ + "id": "json-memory", + "type": "memory", + "strategy": { + "level": "info", + "formatter": {"pattern": "%l|%v"} + }, + "backend": {} + }] + })json"; + logit::ConfigurationDocument document; + logit::ConfigurationDiagnostics diagnostics; + assert(logit::parse_configuration_json(input, document, diagnostics)); + logit::BuiltinConfigurationMaterializer materializer; + logit::ConfigurationPlan plan; + assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + logit::ConfigurationPreparedSet prepared; + EmptyBindingResolver resolver; + logit::BuiltinConfigurationLoggerFactory factory; + assert(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); + assert(prepared.loggers.size() == 1); + assert(prepared.loggers[0].id == "json-memory"); + assert(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); + logit::LogRecord record(logit::LogLevel::LOG_LVL_INFO, 0, "json.cpp", 1, + "test", "payload", "", -1, false); + assert(prepared.loggers[0].formatter->format(record) == "INFO|payload"); + assert(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); +} + } // namespace int main() { @@ -144,5 +184,6 @@ int main() { test_parsed_and_programmatic_json_use_schema_integer_types(); test_frontend_rejects_invalid_input_atomically(); test_frontend_rejects_unknown_strategy_and_named_values(); + test_json_reaches_prepared_runtime_strategy(); return 0; } From 8e9a9237a5da293e72092f2bb7cd91832261d20c Mon Sep 17 00:00:00 2001 From: LimiNode <20008174+LimiNode@users.noreply.github.com> Date: Thu, 12 Nov 2026 04:36:50 +0300 Subject: [PATCH 2/4] fix(config): keep release configuration tests active Make configuration contract and JSON tests evaluate every operation in Release builds instead of relying on assert side effects. Preserve the legacy instantiate_configuration backend-only contract while keeping strategy-aware formatter and level preparation in prepare_configuration, and cover that compatibility boundary with a regression test. --- docs/configuration-loading-RU.md | 8 +- docs/configuration-loading.md | 9 +- .../logit_cpp/logit/configuration_runtime.hpp | 144 +++++--- tests/configuration_contract_test.cpp | 345 ++++++++++-------- tests/configuration_json_test.cpp | 96 ++--- 5 files changed, 352 insertions(+), 250 deletions(-) diff --git a/docs/configuration-loading-RU.md b/docs/configuration-loading-RU.md index 23b48f3..31673d2 100644 --- a/docs/configuration-loading-RU.md +++ b/docs/configuration-loading-RU.md @@ -70,8 +70,12 @@ 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`, diff --git a/docs/configuration-loading.md b/docs/configuration-loading.md index fcff72f..d60825e 100644 --- a/docs/configuration-loading.md +++ b/docs/configuration-loading.md @@ -75,8 +75,13 @@ 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 diff --git a/include/logit_cpp/logit/configuration_runtime.hpp b/include/logit_cpp/logit/configuration_runtime.hpp index ab312d8..8780117 100644 --- a/include/logit_cpp/logit/configuration_runtime.hpp +++ b/include/logit_cpp/logit/configuration_runtime.hpp @@ -161,6 +161,67 @@ namespace logit { return std::shared_ptr(); } + inline bool resolve_bindings( + const ConfigurationPlan& plan, + const ConfigurationBindingResolver& resolver, + std::vector& 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::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 instantiate_logger( + const ConfigurationMaterializedLogger& entry, + const ConfigurationBindingSet& bindings, + const ConfigurationLoggerFactory& factory, + const std::string& prefix, + ConfigurationDiagnostics& diagnostics) { + ConfigurationDiagnostics local_diagnostics; + std::shared_ptr 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(); + } + return runtime_logger; + } + } // namespace configuration_runtime_detail /// \brief Resolve bindings and prepare complete logger/formatter pairs. @@ -176,39 +237,8 @@ namespace logit { ConfigurationDiagnostics& diagnostics) { diagnostics = ConfigurationDiagnostics(); std::vector resolved_bindings; - 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::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); - } - if (!bindings_ok) return false; + if (!configuration_runtime_detail::resolve_bindings( + plan, resolver, resolved_bindings, diagnostics)) return false; ConfigurationPreparedSet candidate; candidate.schema_version = plan.schema_version; @@ -216,20 +246,12 @@ namespace logit { 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 local_diagnostics; std::shared_ptr runtime_logger = - factory.instantiate(entry, resolved_bindings[index], 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 false; - } + configuration_runtime_detail::instantiate_logger( + entry, resolved_bindings[index], factory, prefix, diagnostics); + if (!runtime_logger) return false; + ConfigurationDiagnostics local_diagnostics; std::shared_ptr formatter = configuration_runtime_detail::make_configuration_formatter(entry, local_diagnostics); if (!formatter) { @@ -272,24 +294,34 @@ namespace logit { /// \brief Resolve bindings and publish a complete logger set atomically. /// - /// 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. + /// 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>& loggers, ConfigurationDiagnostics& diagnostics) { - ConfigurationPreparedSet prepared; - if (!prepare_configuration(plan, resolver, factory, prepared, diagnostics)) return false; + diagnostics = ConfigurationDiagnostics(); + std::vector resolved_bindings; + if (!configuration_runtime_detail::resolve_bindings( + plan, resolver, resolved_bindings, diagnostics)) return false; + std::vector> candidate; - candidate.reserve(prepared.loggers.size()); - for (std::vector::const_iterator it = - prepared.loggers.begin(); it != prepared.loggers.end(); ++it) { - candidate.push_back(it->logger); + 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) + "]"; + std::shared_ptr runtime_logger = + configuration_runtime_detail::instantiate_logger( + entry, resolved_bindings[index], factory, prefix, diagnostics); + if (!runtime_logger) return false; + candidate.push_back(runtime_logger); } loggers = candidate; diff --git a/tests/configuration_contract_test.cpp b/tests/configuration_contract_test.cpp index a15b7c6..b12084d 100644 --- a/tests/configuration_contract_test.cpp +++ b/tests/configuration_contract_test.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include #include @@ -10,6 +10,17 @@ namespace { +void require_impl(bool condition, const char* expression, + const char* file, int line) { + if (!condition) { + std::fprintf(stderr, "%s:%d: requirement failed: %s\n", file, line, expression); + std::abort(); + } +} + +#define require(condition) \ + require_impl(static_cast(condition), #condition, __FILE__, __LINE__) + struct RecordingMaterializer : logit::ConfigurationMaterializer { mutable int validate_calls = 0; mutable int materialize_calls = 0; @@ -158,20 +169,20 @@ logit::ConfigurationDocument valid_document() { void test_validation_and_materialization() { const logit::ConfigurationDocument document = valid_document(); const logit::ConfigurationDiagnostics diagnostics = logit::validate_configuration(document); - assert(diagnostics.empty()); + require(diagnostics.empty()); RecordingMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics materialization_diagnostics; - assert(logit::materialize_configuration(document, + require(logit::materialize_configuration(document, materializer, plan, materialization_diagnostics)); - assert(materialization_diagnostics.empty()); - assert(materializer.validate_calls == 1); - assert(materializer.materialize_calls == 1); - assert(plan.loggers.size() == 1); - assert(plan.loggers[0].id == "file-main"); + require(materialization_diagnostics.empty()); + require(materializer.validate_calls == 1); + require(materializer.materialize_calls == 1); + require(plan.loggers.size() == 1); + require(plan.loggers[0].id == "file-main"); } void test_structural_diagnostics() { @@ -182,9 +193,9 @@ void test_structural_diagnostics() { logit::ConfigurationLoggerSpec duplicate = document.loggers[0]; document.loggers.push_back(duplicate); const logit::ConfigurationDiagnostics diagnostics = logit::validate_configuration(document); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnsupportedSchemaVersion)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::DuplicateLoggerId)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnsupportedCombination)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnsupportedSchemaVersion)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::DuplicateLoggerId)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnsupportedCombination)); } void test_nested_values_are_representable() { @@ -195,11 +206,11 @@ void test_nested_values_are_representable() { }})); const logit::ConfigurationValue value = logit::ConfigurationValue::make_array(routes); std::vector observed; - assert(value.get_array(observed)); - assert(observed.size() == 1); + require(value.get_array(observed)); + require(observed.size() == 1); std::map observed_route; - assert(observed[0].get_object(observed_route)); - assert(observed_route["min_level"].type() == + require(observed[0].get_object(observed_route)); + require(observed_route["min_level"].type() == logit::ConfigurationValue::Type::String); } @@ -210,20 +221,20 @@ void test_diagnostics_fail_closed() { validation_diagnostic.add_validation_diagnostic = true; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, + require(!logit::materialize_configuration(document, validation_diagnostic, plan, diagnostics)); - assert(validation_diagnostic.materialize_calls == 0); - assert(!diagnostics.empty()); + require(validation_diagnostic.materialize_calls == 0); + require(!diagnostics.empty()); RecordingMaterializer materialization_diagnostic; materialization_diagnostic.add_materialization_diagnostic = true; - assert(!logit::materialize_configuration(document, + require(!logit::materialize_configuration(document, materialization_diagnostic, plan, diagnostics)); - assert(!diagnostics.empty()); + require(!diagnostics.empty()); } void test_plan_is_preserved_on_late_failure() { @@ -239,10 +250,10 @@ void test_plan_is_preserved_on_late_failure() { sentinel.id = "existing"; plan.loggers.push_back(sentinel); logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(plan.schema_version == 77); - assert(plan.loggers.size() == 1); - assert(plan.loggers[0].id == "existing"); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(plan.schema_version == 77); + require(plan.loggers.size() == 1); + require(plan.loggers[0].id == "existing"); } void test_materializer_is_not_called_after_validation_failure() { @@ -252,9 +263,9 @@ void test_materializer_is_not_called_after_validation_failure() { RecordingMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(materializer.validate_calls == 0); - assert(materializer.materialize_calls == 0); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(materializer.validate_calls == 0); + require(materializer.materialize_calls == 0); } void test_builtin_materializer_applies_file_defaults() { @@ -268,18 +279,18 @@ void test_builtin_materializer_applies_file_defaults() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.empty()); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.empty()); std::string directory; std::uint64_t queue_capacity = 1; bool async = false; - assert(plan.loggers[0].backend.at("directory").get_string(directory)); - assert(directory == "logs"); - assert(plan.loggers[0].backend.at("async").get_boolean(async)); - assert(async); - assert(plan.loggers[0].backend.at("queue_capacity").get_unsigned(queue_capacity)); - assert(queue_capacity == 0); + require(plan.loggers[0].backend.at("directory").get_string(directory)); + require(directory == "logs"); + require(plan.loggers[0].backend.at("async").get_boolean(async)); + require(async); + require(plan.loggers[0].backend.at("queue_capacity").get_unsigned(queue_capacity)); + require(queue_capacity == 0); } void test_builtin_materializer_rejects_unknown_field() { @@ -294,8 +305,8 @@ void test_builtin_materializer_rejects_unknown_field() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); } void test_builtin_materializer_handles_optional_backends_explicitly() { @@ -312,13 +323,13 @@ void test_builtin_materializer_handles_optional_backends_explicitly() { const bool materialized = logit::materialize_configuration(document, materializer, plan, diagnostics); #if defined(LOGIT_WITH_MDBX) - assert(materialized); - assert(diagnostics.empty()); - assert(plan.loggers[0].backend.at("path").type() == + require(materialized); + require(diagnostics.empty()); + require(plan.loggers[0].backend.at("path").type() == logit::ConfigurationValue::Type::String); #else - assert(!materialized); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnavailableBackend)); + require(!materialized); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnavailableBackend)); #endif } @@ -332,9 +343,9 @@ void test_materializer_diagnostics_are_rebased_to_logger_index() { materializer.validation_diagnostic_at = 2; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.size() == 1); - assert(diagnostics.items()[0].path == "loggers[1].type"); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.size() == 1); + require(diagnostics.items()[0].path == "loggers[1].type"); } void test_callback_backends_record_required_bindings_when_available() { @@ -349,10 +360,10 @@ void test_callback_backends_record_required_bindings_when_available() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.empty()); - assert(plan.loggers[0].required_bindings.size() == 1); - assert(plan.loggers[0].required_bindings[0] == "on_payload"); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.empty()); + require(plan.loggers[0].required_bindings.size() == 1); + require(plan.loggers[0].required_bindings[0] == "on_payload"); #endif } @@ -372,15 +383,15 @@ void test_optional_format_defaults_merge_recursively() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); std::map observed; - assert(plan.loggers[0].backend["format"].get_object(observed)); + require(plan.loggers[0].backend["format"].get_object(observed)); std::string service_name; bool include_source = false; - assert(observed["service_name"].get_string(service_name)); - assert(service_name == "orders"); - assert(observed["include_source"].get_boolean(include_source)); - assert(include_source); + require(observed["service_name"].get_string(service_name)); + require(service_name == "orders"); + require(observed["include_source"].get_boolean(include_source)); + require(include_source); } #endif #if defined(LOGIT_WITH_PROMETHEUS) || defined(LOGIT_WITH_PROMETHEUS_SERVER) @@ -403,22 +414,22 @@ void test_optional_format_defaults_merge_recursively() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); std::map observed; - assert(plan.loggers[0].backend["format"].get_object(observed)); + require(plan.loggers[0].backend["format"].get_object(observed)); std::string metric_prefix; bool include_help = false; - assert(observed["metric_prefix"].get_string(metric_prefix)); - assert(metric_prefix == "app_"); - assert(observed["include_help"].get_boolean(include_help)); - assert(include_help); + require(observed["metric_prefix"].get_string(metric_prefix)); + require(metric_prefix == "app_"); + require(observed["include_help"].get_boolean(include_help)); + require(include_help); #if !defined(LOGIT_WITH_PROMETHEUS_SERVER) bool emit_on_log = false; bool emit_on_wait = false; - assert(plan.loggers[0].backend["emit_on_log"].get_boolean(emit_on_log)); - assert(plan.loggers[0].backend["emit_on_wait"].get_boolean(emit_on_wait)); - assert(emit_on_log); - assert(emit_on_wait); + require(plan.loggers[0].backend["emit_on_log"].get_boolean(emit_on_log)); + require(plan.loggers[0].backend["emit_on_wait"].get_boolean(emit_on_wait)); + require(emit_on_log); + require(emit_on_wait); #endif std::map invalid_label; @@ -432,8 +443,8 @@ void test_optional_format_defaults_merge_recursively() { std::map{ {"const_labels", logit::ConfigurationValue::make_array(labels)}}); diagnostics = logit::ConfigurationDiagnostics(); - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); } #endif } @@ -452,32 +463,32 @@ void test_runtime_binding_and_instantiation_are_atomic() { std::shared_ptr sentinel(new logit::MemoryLogger()); loggers.push_back(sentinel); logit::ConfigurationDiagnostics diagnostics; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.empty()); - assert(loggers.size() == 1); - assert(loggers[0] != sentinel); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.empty()); + require(loggers.size() == 1); + require(loggers[0] != sentinel); resolver.provide_binding = false; loggers.clear(); loggers.push_back(sentinel); - assert(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.items()[0].path == "loggers[0].binding.on_payload"); - assert(loggers.size() == 1); - assert(loggers[0] == sentinel); + require(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.items()[0].path == "loggers[0].binding.on_payload"); + require(loggers.size() == 1); + require(loggers[0] == sentinel); resolver.provide_binding = true; resolver.provide_null_binding = true; factory.calls = 0; - assert(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::MissingProgrammaticBinding)); - assert(factory.calls == 0); + require(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::MissingProgrammaticBinding)); + require(factory.calls == 0); resolver.provide_null_binding = false; resolver.provide_wrong_type = true; logit::ConfigurationBindingSet bindings; bindings.set("value", std::shared_ptr(new int(1))); - assert(bindings.get("value")); - assert(!bindings.get("value")); + require(bindings.get("value")); + require(!bindings.get("value")); resolver.provide_wrong_type = false; resolver.provide_binding = true; @@ -485,11 +496,11 @@ void test_runtime_binding_and_instantiation_are_atomic() { factory.calls = 0; loggers.clear(); loggers.push_back(sentinel); - assert(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); - assert(factory.calls == 1); - assert(loggers.size() == 1); - assert(loggers[0] == sentinel); + require(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); + require(factory.calls == 1); + require(loggers.size() == 1); + require(loggers[0] == sentinel); resolver.provide_wrong_type = false; resolver.provide_binding = true; @@ -499,17 +510,17 @@ void test_runtime_binding_and_instantiation_are_atomic() { plan.loggers.push_back(second); resolver.calls = 0; resolver.missing_at = 2; - assert(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::MissingProgrammaticBinding)); - assert(factory.calls == 0); - assert(loggers.size() == 1); - assert(loggers[0] == sentinel); + require(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::MissingProgrammaticBinding)); + require(factory.calls == 0); + require(loggers.size() == 1); + require(loggers[0] == sentinel); resolver.provide_binding = true; resolver.missing_at = -1; factory.fail_at = 2; - assert(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); + require(!logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); } void test_builtin_runtime_factory_consumes_materialized_plan() { @@ -523,15 +534,15 @@ void test_builtin_runtime_factory_consumes_materialized_plan() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); RecordingBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(diagnostics.empty()); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.empty()); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); } struct EmptyBindingResolver : logit::ConfigurationBindingResolver { @@ -542,6 +553,43 @@ struct EmptyBindingResolver : logit::ConfigurationBindingResolver { } }; +struct PreconfiguredLoggerFactory : logit::ConfigurationLoggerFactory { + std::shared_ptr instantiate( + const logit::ConfigurationMaterializedLogger&, + const logit::ConfigurationBindingSet&, + logit::ConfigurationDiagnostics&) const override { + std::shared_ptr logger(new logit::MemoryLogger()); + logger->set_log_level(logit::LogLevel::LOG_LVL_ERROR); + return logger; + } +}; + +void test_legacy_instantiation_preserves_factory_contract() { + logit::ConfigurationPlan plan; + plan.schema_version = 1; + logit::ConfigurationMaterializedLogger entry; + entry.id = "legacy"; + entry.type = "custom"; + entry.strategy.has_level = true; + entry.strategy.level = logit::LogLevel::LOG_LVL_INFO; + entry.strategy.has_formatter = true; + entry.strategy.formatter.type = "unsupported"; + plan.loggers.push_back(entry); + + EmptyBindingResolver resolver; + PreconfiguredLoggerFactory factory; + logit::ConfigurationDiagnostics diagnostics; + std::vector > loggers; + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(diagnostics.empty()); + require(loggers.size() == 1); + require(loggers[0]->get_log_level() == logit::LogLevel::LOG_LVL_ERROR); + + logit::ConfigurationPreparedSet prepared; + require(!logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); +} + void test_prepared_runtime_applies_strategy_atomically() { logit::ConfigurationDocument document; document.schema_version = 1; @@ -572,30 +620,30 @@ void test_prepared_runtime_applies_strategy_atomically() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); EmptyBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; logit::ConfigurationPreparedSet prepared; - assert(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); - assert(prepared.schema_version == 1); - assert(prepared.loggers.size() == 3); - assert(prepared.loggers[0].id == "patterned"); - assert(prepared.loggers[1].id == "json"); - assert(prepared.loggers[2].id == "defaults"); - assert(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); - assert(prepared.loggers[1].level == logit::LogLevel::LOG_LVL_TRACE); - assert(prepared.loggers[0].formatter); - assert(prepared.loggers[1].formatter); - assert(prepared.loggers[2].formatter); + require(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); + require(prepared.schema_version == 1); + require(prepared.loggers.size() == 3); + require(prepared.loggers[0].id == "patterned"); + require(prepared.loggers[1].id == "json"); + require(prepared.loggers[2].id == "defaults"); + require(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); + require(prepared.loggers[1].level == logit::LogLevel::LOG_LVL_TRACE); + require(prepared.loggers[0].formatter); + require(prepared.loggers[1].formatter); + require(prepared.loggers[2].formatter); logit::LogRecord record(logit::LogLevel::LOG_LVL_INFO, 0, "test.cpp", 7, "test", "hello", "", -1, false); - assert(prepared.loggers[0].formatter->format(record) == "INFO|hello"); - assert(prepared.loggers[1].formatter->format(record).find("\"format\"") != std::string::npos); + require(prepared.loggers[0].formatter->format(record) == "INFO|hello"); + require(prepared.loggers[1].formatter->format(record).find("\"format\"") != std::string::npos); logit::SimpleLogFormatter default_formatter; - assert(prepared.loggers[2].formatter->format(record) == default_formatter.format(record)); - assert(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); + require(prepared.loggers[2].formatter->format(record) == default_formatter.format(record)); + require(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); logit::ConfigurationPreparedSet sentinel; logit::ConfigurationPreparedLogger existing; @@ -605,11 +653,11 @@ void test_prepared_runtime_applies_strategy_atomically() { invalid.strategy.has_formatter = true; invalid.strategy.formatter.type = "unsupported"; plan.loggers[0] = invalid; - assert(!logit::prepare_configuration(plan, resolver, factory, sentinel, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); - assert(diagnostics.items()[0].path == "loggers[0].strategy.formatter.type"); - assert(sentinel.loggers.size() == 1); - assert(sentinel.loggers[0].id == "existing"); + require(!logit::prepare_configuration(plan, resolver, factory, sentinel, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); + require(diagnostics.items()[0].path == "loggers[0].strategy.formatter.type"); + require(sentinel.loggers.size() == 1); + require(sentinel.loggers[0].id == "existing"); } void test_builtin_runtime_factory_supports_payload_backends() { @@ -630,29 +678,29 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); RecordingBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); loggers.clear(); OptionalErrorBindingResolver optional_resolver; optional_resolver.provide_error = true; - assert(logit::instantiate_configuration(plan, optional_resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, optional_resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); loggers.clear(); optional_resolver.provide_wrong_type = true; std::shared_ptr sentinel(new logit::MemoryLogger()); loggers.push_back(sentinel); - assert(!logit::instantiate_configuration(plan, optional_resolver, factory, loggers, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); - assert(loggers.size() == 1); - assert(loggers[0] == sentinel); + require(!logit::instantiate_configuration(plan, optional_resolver, factory, loggers, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InstantiationFailed)); + require(loggers.size() == 1); + require(loggers[0] == sentinel); std::remove(path.c_str()); std::remove((path + "-lck").c_str()); @@ -674,9 +722,9 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnavailableBackend)); - assert(diagnostics.items()[0].path == "loggers[0].backend.payload_compression"); + require(!logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnavailableBackend)); + require(diagnostics.items()[0].path == "loggers[0].backend.payload_compression"); } #endif #endif @@ -693,13 +741,13 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); PayloadBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); } { logit::ConfigurationDocument document; @@ -713,13 +761,13 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); RecordingBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); } #endif #if defined(LOGIT_WITH_PROMETHEUS) @@ -734,13 +782,13 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); PayloadBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); } #endif #if defined(LOGIT_WITH_PROMETHEUS_SERVER) @@ -756,13 +804,13 @@ void test_builtin_runtime_factory_supports_payload_backends() { logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; logit::ConfigurationDiagnostics diagnostics; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); RecordingBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; std::vector> loggers; - assert(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); - assert(loggers.size() == 1); - assert(std::dynamic_pointer_cast(loggers[0])); + require(logit::instantiate_configuration(plan, resolver, factory, loggers, diagnostics)); + require(loggers.size() == 1); + require(std::dynamic_pointer_cast(loggers[0])); } #endif } @@ -785,6 +833,7 @@ int main() { test_runtime_binding_and_instantiation_are_atomic(); test_builtin_runtime_factory_consumes_materialized_plan(); test_prepared_runtime_applies_strategy_atomically(); + test_legacy_instantiation_preserves_factory_contract(); test_builtin_runtime_factory_supports_payload_backends(); return 0; } diff --git a/tests/configuration_json_test.cpp b/tests/configuration_json_test.cpp index 89ae2db..3084f84 100644 --- a/tests/configuration_json_test.cpp +++ b/tests/configuration_json_test.cpp @@ -1,10 +1,22 @@ -#include +#include +#include #include #include namespace { +void require_impl(bool condition, const char* expression, + const char* file, int line) { + if (!condition) { + std::fprintf(stderr, "%s:%d: requirement failed: %s\n", file, line, expression); + std::abort(); + } +} + +#define require(condition) \ + require_impl(static_cast(condition), #condition, __FILE__, __LINE__) + struct EmptyBindingResolver : logit::ConfigurationBindingResolver { bool resolve(const logit::ConfigurationMaterializedLogger&, logit::ConfigurationBindingSet&, @@ -36,22 +48,22 @@ void test_valid_json_maps_and_materializes() { logit::ConfigurationDocument document; logit::ConfigurationDiagnostics diagnostics; - assert(logit::parse_configuration_json(input, document, diagnostics)); - assert(diagnostics.empty()); - assert(document.schema_version == 1); - assert(document.loggers.size() == 1); - assert(document.loggers[0].id == "application-file"); - assert(document.loggers[0].strategy.has_level); - assert(document.loggers[0].strategy.level == logit::LogLevel::LOG_LVL_INFO); - assert(document.loggers[0].strategy.has_formatter); - assert(document.loggers[0].strategy.formatter.has_pattern); - assert(document.loggers[0].strategy.formatter.pattern == "%v"); + require(logit::parse_configuration_json(input, document, diagnostics)); + require(diagnostics.empty()); + require(document.schema_version == 1); + require(document.loggers.size() == 1); + require(document.loggers[0].id == "application-file"); + require(document.loggers[0].strategy.has_level); + require(document.loggers[0].strategy.level == logit::LogLevel::LOG_LVL_INFO); + require(document.loggers[0].strategy.has_formatter); + require(document.loggers[0].strategy.formatter.has_pattern); + require(document.loggers[0].strategy.formatter.pattern == "%v"); logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); - assert(diagnostics.empty()); - assert(plan.loggers.size() == 1); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(diagnostics.empty()); + require(plan.loggers.size() == 1); } void test_nested_backend_values_are_preserved() { @@ -70,12 +82,12 @@ void test_nested_backend_values_are_preserved() { logit::ConfigurationDocument document; logit::ConfigurationDiagnostics diagnostics; - assert(logit::parse_configuration_json(input, document, diagnostics)); + require(logit::parse_configuration_json(input, document, diagnostics)); logit::ConfigurationFieldMap custom; - assert(document.loggers[0].backend["custom"].get_object(custom)); + require(document.loggers[0].backend["custom"].get_object(custom)); std::vector labels; - assert(custom["labels"].get_array(labels)); - assert(labels.size() == 1); + require(custom["labels"].get_array(labels)); + require(labels.size() == 1); } void test_parsed_and_programmatic_json_use_schema_integer_types() { @@ -89,14 +101,14 @@ void test_parsed_and_programmatic_json_use_schema_integer_types() { }; logit::ConfigurationDocument document; logit::ConfigurationDiagnostics diagnostics; - assert(logit::parse_configuration_json(input, document, diagnostics)); - assert(document.loggers[0].backend["max_records"].type() == + require(logit::parse_configuration_json(input, document, diagnostics)); + require(document.loggers[0].backend["max_records"].type() == logit::ConfigurationValue::Type::UnsignedInteger); - assert(document.loggers[0].backend["max_age_ms"].type() == + require(document.loggers[0].backend["max_age_ms"].type() == logit::ConfigurationValue::Type::SignedInteger); logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); } void test_frontend_rejects_invalid_input_atomically() { @@ -107,10 +119,10 @@ void test_frontend_rejects_invalid_input_atomically() { output.loggers.push_back(existing); logit::ConfigurationDiagnostics diagnostics; - assert(!logit::parse_configuration_json("{", output, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::ConfigurationParseFailed)); - assert(output.schema_version == 77); - assert(output.loggers.size() == 1); + require(!logit::parse_configuration_json("{", output, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::ConfigurationParseFailed)); + require(output.schema_version == 77); + require(output.loggers.size() == 1); const std::string invalid = R"json({ "schema_version": 1, @@ -121,11 +133,11 @@ void test_frontend_rejects_invalid_input_atomically() { "backend": {"max_records": 1.5} }] })json"; - assert(!logit::parse_configuration_json(invalid, output, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); - assert(output.schema_version == 77); - assert(output.loggers.size() == 1); + require(!logit::parse_configuration_json(invalid, output, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); + require(output.schema_version == 77); + require(output.loggers.size() == 1); } void test_frontend_rejects_unknown_strategy_and_named_values() { @@ -139,9 +151,9 @@ void test_frontend_rejects_unknown_strategy_and_named_values() { })json"; logit::ConfigurationDocument document; logit::ConfigurationDiagnostics diagnostics; - assert(!logit::parse_configuration_json(input, document, diagnostics)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); - assert(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); + require(!logit::parse_configuration_json(input, document, diagnostics)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::UnknownField)); + require(diagnostics.has_code(logit::ConfigurationErrorCode::InvalidValue)); } void test_json_reaches_prepared_runtime_strategy() { @@ -159,21 +171,21 @@ void test_json_reaches_prepared_runtime_strategy() { })json"; logit::ConfigurationDocument document; logit::ConfigurationDiagnostics diagnostics; - assert(logit::parse_configuration_json(input, document, diagnostics)); + require(logit::parse_configuration_json(input, document, diagnostics)); logit::BuiltinConfigurationMaterializer materializer; logit::ConfigurationPlan plan; - assert(logit::materialize_configuration(document, materializer, plan, diagnostics)); + require(logit::materialize_configuration(document, materializer, plan, diagnostics)); logit::ConfigurationPreparedSet prepared; EmptyBindingResolver resolver; logit::BuiltinConfigurationLoggerFactory factory; - assert(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); - assert(prepared.loggers.size() == 1); - assert(prepared.loggers[0].id == "json-memory"); - assert(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); + require(logit::prepare_configuration(plan, resolver, factory, prepared, diagnostics)); + require(prepared.loggers.size() == 1); + require(prepared.loggers[0].id == "json-memory"); + require(prepared.loggers[0].level == logit::LogLevel::LOG_LVL_INFO); logit::LogRecord record(logit::LogLevel::LOG_LVL_INFO, 0, "json.cpp", 1, "test", "payload", "", -1, false); - assert(prepared.loggers[0].formatter->format(record) == "INFO|payload"); - assert(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); + require(prepared.loggers[0].formatter->format(record) == "INFO|payload"); + require(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); } } // namespace From 19b680c9f2b5a64f20772ebc6b0c38e9eee5174c Mon Sep 17 00:00:00 2001 From: LimiNode <20008174+LimiNode@users.noreply.github.com> Date: Thu, 12 Nov 2026 04:42:15 +0300 Subject: [PATCH 3/4] fix(build): provide algorithm for TimeShield include Include before the TimeShield formatting header reached through the public utils umbrella. TimeShield uses std::fill without including its declaring header, which breaks the Emscripten smoke build on the current toolchain. --- include/logit_cpp/logit/utils.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/logit_cpp/logit/utils.hpp b/include/logit_cpp/logit/utils.hpp index 0375b4f..ba5f14c 100644 --- a/include/logit_cpp/logit/utils.hpp +++ b/include/logit_cpp/logit/utils.hpp @@ -13,6 +13,8 @@ #include "config.hpp" #include "enums.hpp" #include "utils/format.hpp" +// TimeShield's time_formatting.hpp uses std::fill without including . +#include #include "utils/VariableValue.hpp" #include "utils/argument_utils.hpp" #include "utils/BufferedLogEntry.hpp" From 8c1f09b02ecdf88c230efab3bd57e41a37ebc19d Mon Sep 17 00:00:00 2001 From: LimiNode <20008174+LimiNode@users.noreply.github.com> Date: Thu, 12 Nov 2026 04:43:10 +0300 Subject: [PATCH 4/4] test(config): retain prepared pair ownership Verify that prepared logger and formatter shared ownership survives clearing the published set, while the existing atomic failure and strategy checks remain active in Release. --- tests/configuration_contract_test.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/configuration_contract_test.cpp b/tests/configuration_contract_test.cpp index b12084d..286b39b 100644 --- a/tests/configuration_contract_test.cpp +++ b/tests/configuration_contract_test.cpp @@ -645,6 +645,11 @@ void test_prepared_runtime_applies_strategy_atomically() { require(prepared.loggers[2].formatter->format(record) == default_formatter.format(record)); require(prepared.loggers[0].logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); + const logit::ConfigurationPreparedLogger retained = prepared.loggers[0]; + prepared.loggers.clear(); + require(retained.logger->get_log_level() == logit::LogLevel::LOG_LVL_INFO); + require(retained.formatter->format(record) == "INFO|hello"); + logit::ConfigurationPreparedSet sentinel; logit::ConfigurationPreparedLogger existing; existing.id = "existing";