Complete reference for all public APIs in LunarLog. Namespace: minta.

• LunarLog (Main Logger)
  • Constructor / Destructor
  • Fluent Builder (configure)
  • Log Level
  • Source Location
  • Sinks
  • Named Sinks
  • Logging Methods
  • Filtering — Global
  • Filtering — Per-Sink
  • Context
  • Template Cache
  • Locale
  • Flush
• LoggerConfiguration
• LogScope
• ContextScope
• SinkProxy
• ISink
  • Named Sink & Tag Methods on ISink
• IFormatter
• FilterRule
• LogEntry
• Enrichers
• Source Location Macros
• Global Logger
• Global Macros
• Enums and Types
• Built-in Sinks
  • ConsoleSink
  • ColorConsoleSink
  • CallbackSink
  • FileSink
  • AsyncSink (template)
  • BatchedSink (abstract)
  • SyslogSink
  • HttpSink
• Built-in Formatters

The main logger class. Non-copyable but move-constructible (move assignment is deleted).

Creates a new logger instance.

// Default: INFO level, console sink
minta::LunarLog logger;

// TRACE level, console sink
minta::LunarLog logger(minta::LogLevel::TRACE);

// DEBUG level, no default sink — you must add your own
minta::LunarLog logger(minta::LogLevel::DEBUG, false);

Destructor. Calls flush() to ensure all buffered messages are written. All logging threads must be stopped before destroying the logger. See Thread Safety.

Returns a LoggerConfiguration builder for declarative logger setup. Chain configuration methods, then call build() to produce a fully-configured LunarLog instance.

auto logger = minta::LunarLog::configure()
    .minLevel(minta::LogLevel::DEBUG)
    .writeTo<minta::ConsoleSink>("console")
    .writeTo<minta::FileSink, minta::JsonFormatter>("json-out", "app.json.log")
    .enrich(minta::Enrichers::threadId())
    .build();

The returned LoggerConfiguration is move-only. See LoggerConfiguration for all builder methods and Fluent Builder for the full guide.

Changes the minimum log level at runtime. Thread-safe (atomic).

logger.setMinLevel(minta::LogLevel::WARN); // only WARN+ from now on

Returns the current minimum log level.

auto level = logger.getMinLevel(); // e.g., LogLevel::INFO

Enables or disables capture of file, line, and function for each log entry. Default: false. Thread-safe (atomic).

When enabled, LogEntry::file, LogEntry::line, and LogEntry::function are populated.

logger.setCaptureSourceLocation(true);
logger.info("Where am I?");
// LogEntry will contain file="main.cpp", line=42, function="main"

Returns whether source location capture is enabled.

Adds a sink with the default formatter for that sink type. Template parameters are deduced.

logger.addSink<minta::FileSink>("output.log");
logger.addSink<minta::ConsoleSink>();

Adds a sink with a specific formatter type.

logger.addSink<minta::FileSink, minta::JsonFormatter>("output.json");
logger.addSink<minta::FileSink, minta::XmlFormatter>("output.xml");

Adds a fully custom sink. Use when you need control over both the sink and formatter.

auto sink = minta::detail::make_unique<MyCustomSink>();
logger.addCustomSink(std::move(sink));

Important: All addSink / addCustomSink calls must happen before the first log message. Calling after logging starts throws std::logic_error.

Adds a named sink. Use named("name") to create a SinkName.

logger.addSink<minta::ConsoleSink>(minta::named("console"));
logger.addSink<minta::FileSink>(minta::named("app-log"), "app.log");

Adds a named sink with a custom formatter.

logger.addSink<minta::FileSink, minta::JsonFormatter>(minta::named("json-out"), "app.json");

String overload — equivalent to using named().

logger.addSink<minta::FileSink>("errors", "errors.log");

Adds a named custom sink.

auto sink = minta::detail::make_unique<MyCustomSink>();
logger.addCustomSink("my-sink", std::move(sink));

Returns a SinkProxy for configuring the named sink. Throws std::invalid_argument if name is not found.

logger.sink("json-out").level(minta::LogLevel::INFO);

Duplicate names: Adding a sink with an already-registered name throws std::invalid_argument.

Auto-naming: Unnamed sinks are auto-named "sink_0", "sink_1", etc., skipping names already taken.

All logging methods use Message Templates syntax. For named placeholders, arguments are passed as alternating name-value pairs. For indexed placeholders ({0}, {1}, ...), values are passed as positional arguments.

Generic log method with explicit level.

logger.log(minta::LogLevel::INFO, "User {name} logged in", "name", "Alice");

Convenience methods for each log level.

logger.trace("Entering function {fn}", "fn", "process");
logger.debug("Cache size: {size}", "size", 42);
logger.info("Server started on port {port}", "port", 8080);
logger.warn("Disk usage at {pct}%", "pct", 85);
logger.error("Failed to connect: {reason}", "reason", "timeout");
logger.fatal("Out of memory, shutting down");

Argument passing: Placeholders are matched by position for formatting, not by name.

• Named placeholders ({name}) consume values sequentially in template order, while storing values by name for structured output.
• Indexed placeholders ({0}, {1}, ...) resolve a specific value slot directly by index.
• Out-of-range indexed placeholders render as empty strings, and named placeholders continue to use the next available mapped value without being shifted by skipped index slots.

// {username} gets "Alice", {action} gets "login"
logger.info("User {username} performed {action}", "username", "Alice", "action", "login");

// Indexed usage (positional values)
logger.info("{1} then {name} then {0}", "A", "B");
// => B then A then A

Alignment: Add ,N after the placeholder name for fixed-width output. Positive N = right-align, negative N = left-align. Applied after format specifiers and pipe transforms.

logger.info("{name,20}", "name", "Alice");         // right-align in 20 chars
logger.info("{name,-20}", "name", "Alice");        // left-align in 20 chars
logger.info("{price,12:.2f}", "price", 9.99);      // spec + alignment
logger.info("{0,10|upper}", "hello");               // indexed + transform + alignment

See Message Templates — Alignment & Padding for full details.

No arguments: Templates without placeholders work fine.

logger.info("Server started");

Type support: Any type convertible to string via std::to_string or operator<< works:

logger.info("Int: {a}, Double: {b}, Bool: {c}, String: {d}",
            "a", 42, "b", 3.14, "c", true, "d", "hello");

Log with explicit source location (instead of relying on setCaptureSourceLocation).

Log with source location and current context snapshot.

⚠️ Deprecated alias: logWithContext() is a backward-compatibility alias of logWithSourceLocation(). Prefer logWithSourceLocation().

Attach a caught std::exception to a log entry. See Exception Attachment for the full guide.

Log with an exception and message template:

try {
    riskyOperation();
} catch (const std::exception& ex) {
    logger.log(minta::LogLevel::ERROR, ex, "Failed for {id}", "id", "req-001");
}

Log an exception only — ex.what() is used as the message:

try {
    riskyOperation();
} catch (const std::exception& ex) {
    logger.log(minta::LogLevel::ERROR, ex);
}

Per-level convenience methods. Each has two overloads: exception + template + args, and exception only.

try {
    riskyDatabaseQuery();
} catch (const std::exception& ex) {
    logger.error(ex, "Operation failed for user {name}", "john");
}

Combine explicit source location with exception attachment:

try {
    process();
} catch (const std::exception& ex) {
    logger.logWithSourceLocationAndException(
        minta::LogLevel::ERROR, __FILE__, __LINE__, __func__,
        ex, "Processing failed for {id}", "id", "req-001");
}

Global filters apply to all sinks. See Filtering for detailed guide.

Sets a global predicate filter. Only entries where the predicate returns true are logged. If the predicate throws, entries are let through (fail-open).

logger.setFilter([](const minta::LogEntry& entry) {
    return entry.level >= minta::LogLevel::WARN;
});

Type: FilterPredicate = std::function<bool(const LogEntry&)>

Removes the global predicate filter.

Adds a DSL filter rule. Multiple rules are AND-combined. See Filtering — DSL Rules for syntax.

logger.addFilterRule("level >= WARN");
logger.addFilterRule("not message contains 'heartbeat'");

Removes all global DSL filter rules.

Removes both the global predicate and all global DSL rules in one call.

Static factories for creating rotation policies. Returns a RollingPolicy builder.

Fluent configuration for cleanup and hybrid rotation.

Construct a rolling file sink. Use with addSink<RollingFileSink>(policy) or addCustomSink().

Set formatter type. Must be called during initialization only, before logging begins.

See Rolling File Sink for full documentation.

Adds compact filter rules using shorthand syntax. Space-separated tokens are AND-combined. Thread-safe. See Compact Filter.

logger.filter("WARN+ ~timeout ctx:env=prod");

Per-sink filters only affect the specified sink. Sinks are indexed from 0 in the order they were added. The default console sink (if enabled) is index 0.

Sets the minimum log level for a specific sink. The effective level is the stricter of the global and per-sink levels.

logger.setSinkLevel(0, minta::LogLevel::ERROR); // sink 0: errors only

Sets a predicate filter on a specific sink.

logger.setSinkFilter(0, [](const minta::LogEntry& entry) {
    return entry.message.find("sensitive") == std::string::npos;
});

Removes the predicate filter from a specific sink.

Adds a DSL filter rule to a specific sink.

logger.addSinkFilterRule(1, "context env == 'production'");

Removes all DSL rules from a specific sink.

Removes both the predicate and all DSL rules from a specific sink.

Global key-value pairs attached to every log entry. See Context Capture.

Sets a context key-value pair. Thread-safe.

logger.setContext("session_id", "abc123");
logger.setContext("environment", "production");

Removes a specific context key. Thread-safe.

logger.clearContext("session_id");

Removes all context keys. Thread-safe.

Creates an RAII scoped context. Key-value pairs are injected into all log entries on the current thread for the lifetime of the returned LogScope. See Scoped Context (LogScope).

{
    auto scope = logger.scope({{"requestId", "req-001"}, {"userId", "u-42"}});
    logger.info("Processing");
    // context includes requestId and userId
}
// context removed automatically

Note: Scoped context is thread-wide, not per-logger. See LogScope for details.

Sets the maximum number of parsed templates to cache. Default: 128. Set to 0 to disable caching.

When the cache is full, new templates are parsed on every call but existing cached entries remain. See Structured Output — Template Cache.

logger.setTemplateCacheSize(256); // increase cache
logger.setTemplateCacheSize(0);   // disable caching

Sets the global locale for culture-specific formatting. Default: "C". Thread-safe. See Culture-Specific Formatting.

logger.setLocale("de_DE");
logger.info("Price: {amount:n}", "amount", 1234.56);
// Output: Price: 1.234,56

If the locale is not available on the system, falls back to "C". Accepts locale names like "en_US", "de_DE", "fr_FR", "ja_JP", etc. The .UTF-8 suffix is tried automatically.

Returns the current global locale name.

Sets a locale override for a specific sink. The sink re-renders messages using this locale instead of the global one. Thread-safe.

logger.setLocale("en_US");
logger.addSink<minta::FileSink>("german.log");
logger.setSinkLocale(1, "de_DE");

logger.info("Total: {val:n}", "val", 1234.56);
// sink 0 (en_US): Total: 1,234.56
// sink 1 (de_DE): Total: 1.234,56

Set to "" to revert to the entry's original locale.

Flushes all sinks. Called automatically by the destructor.

Registers an enricher function that runs on every log entry. Enrichers populate LogEntry::customContext with metadata before sinks see the entry.

Throws: std::logic_error if called after the first log entry has been emitted.

Enrichers run in registration order. Explicit context (setContext / scoped context) overwrites enricher values on key collisions: enricher < setContext < scoped context.

logger.enrich(minta::Enrichers::threadId());
logger.enrich(minta::Enrichers::processId());
logger.enrich(minta::Enrichers::property("service", "auth-api"));
logger.enrich([](minta::LogEntry& entry) {
    entry.customContext["correlationId"] = generateId();
});

See Enrichers for the full guide.

All functions return EnricherFn. Namespace: minta::Enrichers.

logger.enrich(minta::Enrichers::threadId());
logger.enrich(minta::Enrichers::machineName());
logger.enrich(minta::Enrichers::property("version", "2.1.0"));
logger.enrich(minta::Enrichers::fromEnv("AWS_REGION", "region"));

using EnricherFn = std::function<void(LogEntry&)>;

Interface for polymorphic enrichers. Wrap with a shared_ptr capture for use with enrich().

class IEnricher {
public:
    virtual ~IEnricher() = default;
    virtual void enrich(LogEntry& entry) const = 0;
};

auto enricher = std::make_shared<MyEnricher>();
logger.enrich([enricher](minta::LogEntry& entry) {
    enricher->enrich(entry);
});

Fluent proxy for configuring a named sink. Returned by logger.sink("name").

All methods return SinkProxy& for chaining.

logger.sink("json-out")
    .level(minta::LogLevel::INFO)
    .filterRule("not message contains 'heartbeat'")
    .outputTemplate("[{timestamp:HH:mm:ss}] [{level:u3}] {threadId,6} {message}")
    .only("important")
    .locale("de_DE");

Fluent builder for constructing a fully-configured LunarLog instance. Obtained via LunarLog::configure(). Non-copyable, move-only.

All methods return LoggerConfiguration& for chaining.

minta::LunarLog::configure()
    .minLevel(minta::LogLevel::DEBUG)
    .captureSourceLocation(true)
    .rateLimit(5000, std::chrono::milliseconds(1000))
    .templateCacheSize(256)
    .locale("en_US")
    .enrich(minta::Enrichers::threadId())
    .filter("!~heartbeat")
    .filterRule("level >= INFO")

Add sinks to the builder. Six overloads cover all combinations.

template<typename SinkType, typename... Args>
LoggerConfiguration& writeTo(Args&&... args);

template<typename SinkType, typename FormatterType, typename... Args>
LoggerConfiguration& writeTo(Args&&... args);

Auto-named "sink_0", "sink_1", etc. Args are forwarded to the SinkType constructor.

.writeTo<minta::ConsoleSink>()
.writeTo<minta::FileSink, minta::JsonFormatter>("app.json.log")

template<typename SinkType, typename... Args>
LoggerConfiguration& writeTo(const std::string& name, Args&&... args);

template<typename SinkType, typename FormatterType, typename... Args>
LoggerConfiguration& writeTo(const std::string& name, Args&&... args);

First argument is the sink name; remaining args go to the constructor.

.writeTo<minta::ConsoleSink>("console")
.writeTo<minta::FileSink>("app-log", "app.log")
.writeTo<minta::FileSink, minta::JsonFormatter>("json-out", "app.json.log")

SFINAE: The named overload is disabled when SinkType is constructible from (const std::string&, Args...) to prevent the name from being consumed as a constructor argument.

template<typename SinkType, typename ConfigFn, typename... CtorArgs>
LoggerConfiguration& writeTo(const std::string& name, ConfigFn&& configure, CtorArgs&&... args);

template<typename SinkType, typename FormatterType, typename ConfigFn, typename... CtorArgs>
LoggerConfiguration& writeTo(const std::string& name, ConfigFn&& configure, CtorArgs&&... args);

The lambda receives a SinkProxy& for inline sink configuration (level, filters, locale, output template, tag routing).

.writeTo<minta::FileSink>("errors",
    [](minta::SinkProxy& s) {
        s.level(minta::LogLevel::ERROR)
         .only("critical")
         .outputTemplate("[{timestamp:HH:mm:ss}] [{level:u3}] {message}{exception}");
    }, "errors.log")

See SinkProxy for all available configuration methods.

Adds a sub-logger with independent filters, enrichers, and sinks. The sub-logger receives all entries that pass the parent's global filter, then applies its own pipeline.

.subLogger("errors", [](SubLoggerConfiguration& sub) {
    sub.filter("ERROR+")
       .enrich(Enrichers::property("pipeline", "alerts"))
       .writeTo<CallbackSink>("alert", alertFn);
})

SubLoggerConfiguration supports: minLevel(), filter(), filterRule(), enrich(), writeTo() (named and unnamed variants).

See Sub-Logger for the full guide.

Constructs the configured LunarLog instance and returns it by move. Applies all settings, registers enrichers, adds sinks, and validates the configuration.

auto logger = minta::LunarLog::configure()
    .writeTo<minta::ConsoleSink>()
    .build();

See Fluent Builder for the full guide, examples, and comparison with the imperative API.

RAII scoped context that injects key-value pairs into log entries for the lifetime of the scope. Thread-wide (not per-logger). See Scoped Context (LogScope) for the full guide.

Factory: LogScope LunarLog::scope(std::initializer_list<std::pair<std::string, std::string>> pairs)

{
    auto scope = logger.scope({{"requestId", "req-001"}});
    scope.add("userId", "u-42");
    logger.info("Processing");
}
// context removed

• Non-copyable, move-only — can be returned from functions
• Thread-wide — all loggers on the same thread see the same scope stack
• Inner shadows outer — duplicate keys in nested scopes: inner wins, restored on exit
• Exception-safe — destructor always cleans up

RAII helper that sets a context key on construction and removes it on destruction.

{
    minta::ContextScope scope(logger, "request_id", "req-456");
    logger.info("Processing");
    // LogEntry::customContext contains {"request_id": "req-456"}
}
// "request_id" is automatically removed here

Constructor: ContextScope(LunarLog& logger, const std::string& key, const std::string& value)

Destructor: Calls logger.clearContext(key).

Warning: ContextScope holds a reference to the logger. The logger must outlive the scope.

Base class for all sinks. Extend this to create custom sinks.

See Custom Sinks and Formatters for examples.

These methods are available on all sinks (called internally or via SinkProxy):

Tag routing rules:

• If only-tags are set: accept only entries with at least one matching tag
• If except-tags are set: reject entries with any matching tag
• only() takes precedence over except()
• Untagged entries go to sinks with no only() filter

Base class for all formatters.

• HumanReadableFormatter — [timestamp] [LEVEL] message
• JsonFormatter — JSON with level, timestamp, message, messageTemplate, templateHash, properties
• XmlFormatter — XML with same fields

Parsed DSL filter rule. Usually created via string parsing.

See Filtering — DSL Rules for syntax.

The data structure passed to sinks and formatters for each log event.

Transforms are applied after format specifiers during message rendering. The transforms field records the transform names for downstream consumers (custom formatters, log processors).

for (const auto& prop : entry.properties) {
    if (prop.op == '@') { /* destructure */ }
    if (prop.op == '$') { /* stringify */ }
    if (prop.op == 0)   { /* no operator */ }
    for (const auto& t : prop.transforms) {
        // e.g. "upper", "comma", "truncate:10"
    }
}

Transforms are applied to placeholder values via the | operator: {name|transform}. See Pipe Transforms for the full guide.

All transform functions live in minta::detail and have the signature std::string(const std::string& value) or std::string(const std::string& value, const std::string& arg).

The Transform struct holds name (string) and arg (string, empty if no argument).

Header: <lunar_log/macros.hpp>

Convenience macros that capture __FILE__, __LINE__, and __func__ at the call site. All macros are guarded by #ifndef LUNAR_LOG_NO_MACROS.

Each calls logWithSourceLocation() after a level check that short-circuits argument evaluation.

#include <lunar_log/macros.hpp>

LUNAR_INFO(logger, "User {name} logged in", "name", "alice");

Each calls logWithSourceLocationAndException() with an attached std::exception.

try {
    connectToDatabase();
} catch (const std::exception& ex) {
    LUNAR_ERROR_EX(logger, ex, "Connection failed for {host}", "host", "db-01");
}

Define before including the header to suppress all 14 macros:

#define LUNAR_LOG_NO_MACROS
#include <lunar_log/macros.hpp>   // no macros defined

See Source Location Macros for the full guide, design notes, and comparison with the manual API.

Header: <lunar_log/global.hpp>

minta::Log is a static facade over a process-wide LunarLog instance.

minta::Log::configure()
    .minLevel(minta::LogLevel::INFO)
    .writeTo<minta::ConsoleSink>()
    .build();

minta::Log::info("Started");
minta::Log::shutdown();

Builder wrapper returned by Log::configure(). Mirrors LoggerConfiguration (minLevel, captureSourceLocation, rateLimit, templateCacheSize, locale, enrich, filter, filterRule, and all writeTo overloads).

Builds a LunarLog via internal LoggerConfiguration and installs it through Log::init().

Header: <lunar_log/global.hpp>

Defined unless LUNAR_LOG_NO_GLOBAL_MACROS is set.

Shared, thread-safe observable log level for runtime changes.

#include <lunar_log.hpp>

auto sw = std::make_shared<minta::LevelSwitch>(minta::LogLevel::INFO);

Pass to LoggerConfiguration::minLevel(sw) to enable runtime level changes. Can be shared across multiple loggers.

Internal class — not directly constructed. Created via LoggerConfiguration::watchConfig().

Polls a JSON config file at a configurable interval. Supports:

• Global minLevel changes
• Per-sink level overrides (by sink name)
• Filter rule hot-reload (COW)
• Graceful degradation on malformed config

See Dynamic Configuration wiki page for full details.

enum class LogLevel {
    TRACE = 0,
    DEBUG = 1,
    INFO = 2,
    WARN = 3,
    ERROR = 4,
    FATAL = 5
};

enum class ConsoleStream {
    StdOut,
    StdErr
};

Selects target stream for ConsoleSink / ColorConsoleSink.

using FilterPredicate = std::function<bool(const LogEntry&)>;

Tag type for disambiguating named-sink overloads:

struct SinkName {
    std::string value;
    explicit SinkName(const std::string& n);
    explicit SinkName(const char* n);
};

Convenience factory for SinkName:

inline SinkName named(const std::string& name);
inline SinkName named(const char* name);

Writes to standard console stream. Default formatter: HumanReadableFormatter.

logger.addSink<minta::ConsoleSink>(); // StdOut
logger.addSink<minta::ConsoleSink>(minta::ConsoleStream::StdErr);

Drop-in alternative to ConsoleSink that colorizes the [LEVEL] bracket with ANSI escape codes. Message body is left uncolored. Color is auto-disabled when target stream is not a TTY or NO_COLOR / LUNAR_LOG_NO_COLOR is set.

logger.addSink<minta::ColorConsoleSink>(); // StdOut
logger.addSink<minta::ColorConsoleSink>(minta::ConsoleStream::StdErr);

// Runtime toggle
auto& sink = /* get sink reference */;
sink.setColor(false);  // disable color

See Color Console Sink for full documentation.

Sink that forwards entries to user callbacks.

// Raw LogEntry callback
logger.addSink<minta::CallbackSink>(
    minta::CallbackSink::EntryCallback(
        [](const minta::LogEntry& e) {
            // custom handling
        }));

// Formatted string callback (CompactJsonFormatter default)
logger.addSink<minta::CallbackSink>(
    minta::CallbackSink::StringCallback(
        [](const std::string& line) {
            // send line to external system
        }));

String variant uses CompactJsonFormatter when fmt == nullptr.

Writes to a file. Default formatter: HumanReadableFormatter.

logger.addSink<minta::FileSink>("app.log");
logger.addSink<minta::FileSink, minta::JsonFormatter>("app.json");

Asynchronous sink decorator that wraps another sink type.

logger.addSink<minta::AsyncSink<minta::FileSink>>("app.log");

enum class OverflowPolicy {
    Block,
    DropOldest,
    DropNewest
};

Reusable base sink for batch delivery.

POSIX syslog sink (#ifndef _WIN32).

Batched HTTP sink based on BatchedSink.

(write() / flush() are inherited from BatchedSink.)

Output: [2026-02-17 12:00:00.000] [INFO] User Alice logged in

Includes source location if captured: [2026-02-17 12:00:00.000] [INFO] [main.cpp:42] User Alice logged in

HumanReadableFormatter can render logs using a custom output template with these tokens:

• {timestamp} / {timestamp:FORMAT}
• {level} / {level:u3} / {level:l}
• {message}
• {newline}
• {properties} (comma-separated key=value list)
• {template} (original message template)
• {source} (file:line function)
• {threadId}
• {exception} (exception type + message + chain; empty if no exception)

Alignment and formatting are supported:

• {level,6} (width/right-aligned)
• {level,-6} (width/left-aligned)
• {level,6:u3} (u3 spec + width)
• {level:-6:l} (l spec + width)

logger.sink("console").outputTemplate("[{timestamp:yyyy-MM-dd HH:mm:ss}] [{level:u3}] {threadId,6} {message}");

For JSON and XML formatters, this call is a no-op.

{
  "level": "INFO",
  "timestamp": "2026-02-17T12:00:00.000Z",
  "messageTemplate": "User {username} logged in",
  "templateHash": "a1b2c3d4",
  "message": "User Alice logged in",
  "properties": {
    "username": "Alice"
  }
}

Includes file, line, function if captured. Includes context if set. Properties with @ operator emit native JSON types.

JSONL output optimized for log pipelines. Short @-prefixed keys, flattened properties, single-line output.

{"@t":"2026-02-18T00:30:05.123Z","@l":"WRN","@mt":"Connection to {host} failed","@i":"a1b2c3d4","host":"db-01"}

• @l omitted for INFO level
• Properties at top level (not nested)
• User keys starting with @ escaped to @@
• includeRenderedMessage(true) adds @m field

logger.addSink<minta::FileSink, minta::CompactJsonFormatter>("logs/app.jsonl");

// Optional: include rendered message
auto fmt = minta::detail::make_unique<minta::CompactJsonFormatter>();
fmt->includeRenderedMessage(true);

See Compact JSON Formatter for full details.

<log level="INFO" timestamp="2026-02-17T12:00:00.000Z">
  <messageTemplate>User {username} logged in</messageTemplate>
  <templateHash>a1b2c3d4</templateHash>
  <message>User Alice logged in</message>
  <properties>
    <property name="username">Alice</property>
  </properties>
</log>

Properties with @ get destructure="true" attribute. Properties with $ get stringify="true".