XenoAtom.Logging

https://github.com/xenoatom/xenoatom.logging
Admin
XenoAtom.Logging is a high-performance structured logging runtime for .NET, designed for zero...
Tokens:48,614
Snippets:386
Trust Score:8.6
License:BSD-2-Clause
Update:2 days ago
Show doc for...
Tokens:
Raw
### Install lunet tool

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/AGENTS.md

Install the lunet dotnet tool globally. Run once before building the site.

```bash
dotnet tool install -g lunet
```

--------------------------------

### Default style example output

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal-visuals.md

Example log output with default styling, showing Info, Warning, and Error levels with timestamps and exception details.

```text
2026-02-09 18:21:04.7253194 INF Sample.App: Service started
2026-02-09 18:21:04.7319831 WRN Sample.App: Queue latency above threshold
2026-02-09 18:21:04.7424107 ERR Sample.App [42]: Failed to process request
System.InvalidOperationException: boom
```

--------------------------------

### Configure and use TerminalLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Shows how to initialize XenoAtom.Logging with a TerminalLogWriter, set the minimum log level to Info, and log a message. The example includes creating a LogManagerConfig, initializing the LogManager, getting a logger, and shutting down.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers =
        {
            new TerminalLogWriter()
        }
    }
};

LogManager.Initialize(config);
var logger = LogManager.GetLogger("Sample.Terminal");
logger.Info("Hello terminal");
LogManager.Shutdown();
```

--------------------------------

### Alignment example with [LogFormatter]

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Example formatter using alignment specifiers for Level and LoggerName. Demonstrates that values longer than alignment width are not truncated.

```csharp
[LogFormatter("{Level,-5} {LoggerName,30} {Text}")]
public sealed partial record Example : LogFormatter;
```

--------------------------------

### Markup message example output

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal-visuals.md

Example log output with markup tags in messages, rendered when EnableMarkupMessages is enabled.

```text
2026-02-09 18:21:04.7501062 INF Sample.Terminal: ready worker=api-1
2026-02-09 18:21:04.7529450 ERR Sample.Terminal: failed request=REQ-0042
```

--------------------------------

### Minimal synchronous logging setup

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/getting-started.md

Initializes XenoAtom.Logging with synchronous processing, writes to standard output, and logs an info and warning message. Shutdown flushes and disposes writers.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers =
        {
            new StreamLogWriter(Console.OpenStandardOutput())
        }
    }
};

LogManager.Initialize(config);

var logger = LogManager.GetLogger("App");
logger.Info("Application started");
logger.Warn($"Retry attempt = {3}");

LogManager.Shutdown();
```

--------------------------------

### Asynchronous logging setup with FileLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/getting-started.md

Initializes logging for asynchronous processing with a queue capacity of 4096 and an error handler. Uses a file writer and Block overflow mode to preserve correctness.

```csharp
var config = new LogManagerConfig
{
    AsyncLogMessageQueueCapacity = 4096,
    AsyncErrorHandler = exception =>
    {
        Console.Error.WriteLine($"[async logging error] {exception.Message}");
    },
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        OverflowMode = LoggerOverflowMode.Block,
        Writers =
        {
            new FileLogWriter("logs/app.log")
        }
    }
};

LogManager.InitializeForAsync(config);
```

--------------------------------

### Install XenoAtom.Logging core package

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/packages.md

Adds the core XenoAtom.Logging package to a project. Includes LogManager, Logger, scopes, processors, formatters, writers, and source generators.

```sh
dotnet add package XenoAtom.Logging
```

--------------------------------

### Install XenoAtom.Logging.Terminal package

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/packages.md

Adds the terminal sink package for CLI/console apps. Provides TerminalLogWriter and markup logging extensions.

```sh
dotnet add package XenoAtom.Logging.Terminal
```

--------------------------------

### HTML banner structure

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/banner.md

Banner markup with project logo, title, description, feature pills, install command, and links.

```html
<div class="banner-root">
  <div class="banner-canvas" role="img" aria-label="{{site.project_name}} branding banner">
    <div class="banner-inner">
      <div class="banner-card">
        <div class="banner-top">
          <img class="banner-logo" src="{{site.basepath}}{{site.project_logo_path}}" alt="{{site.project_name}} logo" width="96" height="96">
          <div>
            <h1 class="banner-title"><span class="c64-text">{{site.project_name}}</span></h1>
            <p class="banner-subtitle">{{site.description}}</p>
          </div>
        </div>
        <div class="banner-pill-row" aria-hidden="true">
          <span class="banner-pill"><i class="bi bi-lightning-charge"></i>Zero-allocation hot path</span>
          <span class="banner-pill"><i class="bi bi-cpu"></i>Sync + async modes</span>
          <span class="banner-pill"><i class="bi bi-braces"></i>Source-generated APIs</span>
          <span class="banner-pill"><i class="bi bi-file-earmark-text"></i>File + JSON sinks</span>
          <span class="banner-pill"><i class="bi bi-display"></i>Terminal + LogControl visuals</span>
        </div>
        <div class="banner-code" aria-label="Install command">
          <span>Install:</span>
          <kbd>dotnet add package {{site.project_package_id}}</kbd>
        </div>
        <div class="banner-links">
          <a href="{{site.basepath}}/docs/"><i class="bi bi-book"></i>Docs</a>
          <a href="{{site.github_repo_url}}"><i class="bi bi-github"></i>GitHub</a>
          <a href="https://www.nuget.org/packages/{{site.project_package_id}}/"><i class="bi bi-box-seam"></i>NuGet</a>
        </div>
      </div>
    </div>
  </div>
</div>
```

--------------------------------

### Rendered output of visual attachment

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal-visuals.md

Example terminal output showing the rendered table with the log message.

```text
2026-02-09 18:21:04.7604120 INF Sample.Terminal: Run summary
┌───────────────┬────────┬───────────┐
│ Step          │ Status │ Duration  │
├───────────────┼────────┼───────────┤
│ Initialize    │ OK     │ 00:00.045 │
│ ProcessRequest│ FAILED │ 00:00.003 │
└───────────────┴────────┴───────────┘
```

--------------------------------

### Add reject and accept filters to a writer

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/filtering.md

Adds a reject filter to suppress loggers whose name starts with 'App.Noisy' and an accept filter to only allow log entries with level Warn or higher.

```csharp
fileWriter.RejectFilters.Add(static m =>
    m.Logger.Name.StartsWith("App.Noisy", StringComparison.Ordinal));

fileWriter.AcceptFilters.Add(static m =>
    m.Level >= LogLevel.Warn);
```

--------------------------------

### Build the website with lunet

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/AGENTS.md

Build the site using lunet. Always run this after changing files under site/**. Execute from the site folder.

```bash
lunet build
```

--------------------------------

### Run HelloLogControl sample

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/samples/readme.md

Command to run the HelloLogControl sample project from the repository root. Demonstrates writing logs to a LogControl in a fullscreen UI with rich formatting and background-thread marshaling.

```sh
dotnet run --project samples/HelloLogControl/HelloLogControl.csproj -c Release
```

--------------------------------

### Build and test commands

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/AGENTS.md

Commands to build, test, and build the documentation site from the project root. Run from the project root folder.

```sh
# from the project root (this folder)
cd src
dotnet build -c Release
dotnet test -c Release
cd ../site
lunet build
```

--------------------------------

### Run HelloLogging sample

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/samples/readme.md

Command to run the HelloLogging sample project from the repository root. Demonstrates rich terminal styling, markup logging, visual attachments, scoped properties, and exception logging.

```sh
dotnet run --project samples/HelloLogging/HelloLogging.csproj -c Release
```

--------------------------------

### Run all benchmarks

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Runs the full benchmark suite from the repository root in Release configuration.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release
```

--------------------------------

### Run preset suites

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Runs the predefined benchmark suites 'comparison' and 'async' as implemented in Program.cs.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --suite comparison
```

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --suite async
```

--------------------------------

### List available suites

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Lists all available preset suites and their aliases.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --list-suites
```

--------------------------------

### Conditional sections example with [LogFormatter]

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Shows conditional sections that emit content only when referenced emptyable fields are non-empty. Here, [{EventId}] appears only when EventId is present, and | {Exception} only when an exception is attached.

```csharp
[LogFormatter("{Timestamp} {Level} {LoggerName}{? [{EventId}]?} {Text}{? | {Exception}?}")]
public sealed partial record Standardish : LogFormatter;
```

--------------------------------

### Run FileJsonLogging sample

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/samples/readme.md

Command to run the FileJsonLogging sample project from the repository root. Demonstrates text and JSON lines logging with rolling and retention options, structured properties, scopes, event IDs, and exception logging.

```sh
dotnet run --project samples/FileJsonLogging/FileJsonLogging.csproj -c Release
```

--------------------------------

### Configure and initialize XenoAtom.Logging with file writer

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/readme.md

Creates a LogManagerConfig with a FileLogWriter that rolls daily, limits file size to 10 MB, rolls on startup, and retains 7 files. Initializes the logger, logs a message, and shuts down. The default processor is synchronous.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers =
        {
            new FileLogWriter(
                new FileLogWriterOptions("logs/app.log")
                {
                    FileSizeLimitBytes = 10 * 1024 * 1024,
                    RollingInterval = FileRollingInterval.Daily,
                    RollOnStartup = true,
                    RetainedFileCountLimit = 7
                })
        }
    }
};

LogManager.Initialize(config); // sync processor by default

var logger = LogManager.GetLogger("Sample");
logger.Info($"Hello {42}");

LogManager.Shutdown();
```

--------------------------------

### XenoAtom.Logging minimal configuration

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Initializes XenoAtom.Logging with a LogManagerConfig that sets minimum level to Info and uses a StreamLogWriter writing to standard output.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers =
        {
            new StreamLogWriter(Console.OpenStandardOutput())
        }
    }
};

LogManager.Initialize(config);
```

--------------------------------

### Configure rolling and retention for FileLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Creates a FileLogWriter with a 10 MB size limit, daily rolling, retention of 14 archives, and startup rollover. Archived files are named app.<timestamp>.log using UTC timestamps. Set RetainedFileCountLimit to null to disable cleanup; FlushToDisk forces durable writes.

```csharp
var writer = new FileLogWriter(
    new FileLogWriterOptions("logs/app.log")
    {
        FileSizeLimitBytes = 10 * 1024 * 1024, // 10 MB
        RollingInterval = FileRollingInterval.Daily,
        RetainedFileCountLimit = 14, // defaults to 31; set null to keep indefinitely
        RollOnStartup = true,
        AutoFlush = false,
        ArchiveTimestampMode = FileArchiveTimestampMode.Utc,
        FlushToDisk = false
    });
```

--------------------------------

### Basic file logging with FileLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Configures the root logger to write to logs/app.log at Info level. If the file already contains data, it is archived and a fresh file is created on startup.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers =
        {
            new FileLogWriter("logs/app.log")
        }
    }
};

LogManager.Initialize(config);
```

--------------------------------

### Add XenoAtom.Logging NuGet packages

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/readme.md

Use these dotnet CLI commands to add the core and terminal packages to your project.

```sh
dotnet add package XenoAtom.Logging
dotnet add package XenoAtom.Logging.Terminal
```

--------------------------------

### Recommended usage for service/hosted apps

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/shutdown.md

Wrap the application run in a try-finally block to ensure LogManager.Shutdown() is called, guaranteeing a coordinated stop and resource cleanup.

```csharp
try
{
    RunApplication();
}
finally
{
    LogManager.Shutdown();
}
```

--------------------------------

### Run async-consumer scenarios

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Runs only benchmarks in the AsyncEnabledStructured or AsyncEnabledException categories.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --anyCategories AsyncEnabledStructured AsyncEnabledException
```

--------------------------------

### Configure logger hierarchy with RootLogger and Loggers

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/filtering.md

Sets up a root logger with a file writer and adds a named logger config for 'App.Http' with Debug level and both file and JSON writers, with includeParents set to true.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var fileWriter = new FileLogWriter("logs/app.log");
var jsonWriter = new JsonFileLogWriter("logs/app.jsonl");

var config = new LogManagerConfig
{
    RootLogger =
    {
        MinimumLevel = LogLevel.Info,
        Writers = { fileWriter }
    }
};

// "App.Http" and children become Debug and fan out to both writers.
config.Loggers.Add("App.Http", LogLevel.Debug, [fileWriter, jsonWriter], includeParents: true);
```

--------------------------------

### MEL minimal logging configuration

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Configures logging with Microsoft.Extensions.Logging, setting minimum level to Information and adding a console provider.

```csharp
builder.Services.AddLogging(logging =>
{
    logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Information);
    logging.AddConsole();
});
```

--------------------------------

### Configure StreamLogWriter with CompactLogFormatter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Sets a CompactLogFormatter on a StreamLogWriter writing to standard output. Requires the XenoAtom.Logging, XenoAtom.Logging.Formatters, and XenoAtom.Logging.Writers namespaces.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Formatters;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        Writers =
        {
            new StreamLogWriter(Console.OpenStandardOutput())
            {
                Formatter = CompactLogFormatter.Instance
            }
        }
    }
};

LogManager.Initialize(config);
```

--------------------------------

### Add XenoAtom.Logging package reference

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Adds the XenoAtom.Logging NuGet package to enable the generator/analyzer. A single package reference is sufficient.

```xml
<ItemGroup>
  <PackageReference Include="XenoAtom.Logging" Version="*" />
</ItemGroup>
```

--------------------------------

### Terminal output with markup

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/getting-started.md

Initializes logging with a TerminalLogWriter and logs a message with markup formatting. Requires the XenoAtom.Logging.Terminal package.

```csharp
using XenoAtom.Logging;
using XenoAtom.Logging.Writers;

var config = new LogManagerConfig
{
    RootLogger =
    {
        Writers =
        {
            new TerminalLogWriter()
        }
    }
};

LogManager.Initialize(config);
LogManager.GetLogger("App").InfoMarkup("[green]ready[/]");
LogManager.Shutdown();
```

--------------------------------

### Use markup logging methods

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Calls InfoMarkup and ErrorMarkup with markup tags to render colored messages.

```csharp
logger.InfoMarkup("[green]ready[/] [gray]service started[/]");
logger.ErrorMarkup($"[red]failed[/] request={requestId}");
```

--------------------------------

### Configure FileLogWriter with DetailedLogFormatter via options

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Creates a FileLogWriter with a DetailedLogFormatter using FileLogWriterOptions. The log file path is 'logs/app.log'.

```csharp
using XenoAtom.Logging.Formatters;
using XenoAtom.Logging.Writers;

var writer = new FileLogWriter(
    new FileLogWriterOptions("logs/app.log")
    {
        Formatter = DetailedLogFormatter.Instance
    });
```

--------------------------------

### Enable async processing in XenoAtom.Logging

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/readme.md

Sets an async error handler and initializes the logger with an async processor. Use this instead of the default synchronous Initialize when you need asynchronous logging.

```csharp
config.AsyncErrorHandler = exception =>
{
    Console.Error.WriteLine($"[logging async error] {exception}");
};

LogManager.InitializeForAsync(config);
```

--------------------------------

### dotnet publish command for Native AOT

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/aot.md

Recommended publish command for Native AOT and trimming. Replace win-x64 with your runtime identifier.

```sh
dotnet publish -c Release -r win-x64 -p:PublishAot=true -p:PublishTrimmed=true
```

--------------------------------

### Access generated Instance property

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Retrieves the singleton instance of a template-generated formatter.

```csharp
var formatter = MyLogFormatter.Instance;
```

--------------------------------

### Run a single benchmark method

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Runs only the benchmark method matching the given filter pattern, e.g., *XenoAtom_Enabled_Structured*.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --filter *XenoAtom_Enabled_Structured*
```

--------------------------------

### Run benchmarks by category

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/benchmarks.md

Runs only benchmarks matching the specified category, e.g., EnabledStructured.

```sh
dotnet run --project src/XenoAtom.Logging.Benchmark/XenoAtom.Logging.Benchmark.csproj -c Release -- --anyCategories EnabledStructured
```

--------------------------------

### Configure styles by segment kind and log level

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Clears existing styles and sets styles for timestamp, logger name, and log levels. Use during startup; avoid concurrent mutation without synchronization.

```csharp
writer.Styles.Clear();
writer.Styles.SetStyle(LogMessageFormatSegmentKind.Timestamp, "dim");
writer.Styles.SetStyle(LogMessageFormatSegmentKind.LoggerName, "blue");
writer.Styles.SetLevelStyle(LogLevel.Info, "green");
writer.Styles.SetLevelStyle(LogLevel.Error, "bold white on red");
```

--------------------------------

### Configure failure handling with Retry mode

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Sets FailureMode to Retry with 5 retries and a 100ms delay, and defines a FailureHandler that logs failure details. The handler receives context with FilePath, Attempt, WillRetry, and Exception.Message.

```csharp
var options = new FileLogWriterOptions("logs/app.log")
{
    FailureMode = FileLogWriterFailureMode.Retry,
    RetryCount = 5,
    RetryDelay = TimeSpan.FromMilliseconds(100),
    FailureHandler = context =>
    {
        Console.WriteLine(
            $"File log failure on {context.FilePath}. " +
            $"Attempt={context.Attempt} Retry={context.WillRetry} " +
            $"Error={context.Exception.Message}");
    }
};
```

--------------------------------

### Attach Visual table to log messages

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Creates a Table visual and attaches it to log messages using logger.Info and logger.InfoMarkup. Requires XenoAtom.Terminal.UI and XenoAtom.Terminal.UI.Controls namespaces.

```csharp
using XenoAtom.Terminal.UI;
using XenoAtom.Terminal.UI.Controls;

var table = new Table()
    .Headers("Step", "Status")
    .AddRow("Build", "OK")
    .AddRow("Deploy", "Done");

logger.Info(table, "Deployment summary");
logger.InfoMarkup(table, "[bold]Deployment report[/]");
```

--------------------------------

### Configure FileLogWriter with StandardLogFormatter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Creates a FileLogWriter with a formatter that sets timestamp format to "HH:mm:ss" and level format to Tri. Use this when writing to a file sink.

```csharp
var writer = new FileLogWriter(
    new FileLogWriterOptions("logs/app.log")
    {
        Formatter = StandardLogFormatter.Instance with
        {
            TimestampFormat = "HH:mm:ss",
            LevelFormat = LogLevelFormat.Tri
        }
    });
```

--------------------------------

### XenoAtom.Logging per-message properties

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Logs a message with explicit properties using LogProperties, demonstrating allocation-aware structured logging.

```csharp
logger.Info(
    properties: new LogProperties { ("UserId", 42), ("Feature", "checkout") },
    msg: "Validation failed");
```

--------------------------------

### Add logger config with includeParents false

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/filtering.md

Adds a logger config for 'App.Audit' with Info level and only the JSON writer, with includeParents set to false, so that App.Audit.* writes only to jsonWriter.

```csharp
config.Loggers.Add("App.Audit", LogLevel.Info, [jsonWriter], includeParents: false);
```

--------------------------------

### Custom archive file names with FileArchiveFileNameFormatters.DateTime

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Configures a FileLogWriter with daily rolling and a DateTime archive file name formatter, producing names like output.2026-02-19-19_16_03.txt.

```csharp
var writer = new FileLogWriter(
    new FileLogWriterOptions("logs/output.txt")
    {
        RollingInterval = FileRollingInterval.Daily,
        ArchiveFileNameFormatter = FileArchiveFileNameFormatters.DateTime
    });
```

--------------------------------

### Attach visual table to log entries with TerminalLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/readme.md

Creates a Table control from XenoAtom.Terminal.UI and attaches it to log entries. The table is rendered under the log line by TerminalLogWriter. Requires the XenoAtom.Terminal.UI package.

```csharp
using XenoAtom.Terminal.UI;
using XenoAtom.Terminal.UI.Controls;

var table = new Table()
    .Headers("Step", "Status", "Duration")
    .AddRow("Initialize", "OK", "00:00.045")
    .AddRow("ProcessRequest", "FAILED", "00:00.003");

logger.Info(table, "Run summary");
logger.InfoMarkup(table, "[bold]Run summary (styled)[/]");
```

--------------------------------

### XenoAtom.Logging LogMethod source generator

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Defines a partial method with LogMethod attribute for source-generated logging in XenoAtom.Logging.

```csharp
using XenoAtom.Logging;

public static partial class AppLog
{
    [LogMethod(LogLevel.Info, "Processing item {itemId}", EventId = 1)]
    public static partial void ProcessingItem(Logger logger, int itemId);
}
```

--------------------------------

### Attach visual object to log call

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal-visuals.md

C# code showing how to attach a Table visual to log calls using Info and InfoMarkup methods.

```csharp
var table = new Table()
    .Headers("Step", "Status", "Duration")
    .AddRow("Initialize", "OK", "00:00.045")
    .AddRow("ProcessRequest", "FAILED", "00:00.003");

logger.Info(table, "Run summary");
logger.InfoMarkup(table, "[bold]Run summary (styled)[/]");
```

--------------------------------

### XenoAtom.Logging scope with LogProperties

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Uses BeginScope with LogProperties to add structured data to a log scope.

```csharp
using (logger.BeginScope(new LogProperties { ("RequestId", requestId) }))
{
    logger.Info("Handling request");
}
```

--------------------------------

### Apply runtime configuration changes

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/filtering.md

Calls ApplyChanges() on the LogManagerConfig to apply runtime updates to the configuration collections.

```csharp
config.ApplyChanges();
```

--------------------------------

### Create custom text formatter with [LogFormatter]

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/source-generator.md

Declares a partial record inheriting LogFormatter with [LogFormatter] to generate a high-performance text formatter. The template uses placeholders like {Timestamp:HH:mm:ss} and conditional sections. See the Log Formatters page for usage and template reference.

```csharp
using XenoAtom.Logging;

[LogFormatter("{Timestamp:HH:mm:ss} {Level,-5} {LoggerName} {Text}{? | {Exception}?}")]
public sealed partial record MyFormatter : LogFormatter;
```

--------------------------------

### Declare markup-aware logging methods with [LogMethodMarkup]

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/source-generator.md

Declares static partial methods with [LogMethodMarkup] to generate markup-aware logging methods. Requires the XenoAtom.Logging.Terminal package. Generated code routes through terminal markup APIs and sets LogMessage.IsMarkup = true.

```csharp
using XenoAtom.Logging;

public static partial class AppLogs
{
    [LogMethodMarkup(LogLevel.Info, "[green]User {userId} connected[/]")]
    public static partial void UserConnectedMarkup(Logger logger, int userId);
}
```

--------------------------------

### Declare logging methods with [LogMethod]

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/source-generator.md

Declares static partial methods with [LogMethod] to generate strongly-typed logging methods. The generator emits level checks, optional LogEventId, and calls to LoggerExtensions methods. Placeholder names must match method parameter names.

```csharp
using XenoAtom.Logging;

public static partial class AppLogs
{
    [LogMethod(LogLevel.Info, "User {userId} connected from {ip}")]
    public static partial void UserConnected(Logger logger, int userId, string ip);

    [LogMethod(LogLevel.Error, "Request {requestId} failed", EventId = 42, EventName = "RequestFailed")]
    public static partial void RequestFailed(Logger logger, Exception exception, LogProperties properties, int requestId);
}
```

--------------------------------

### CSS for banner links and icons

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/banner.md

Styles for hover effects on banner links and spacing for Bootstrap icons.

```css
.banner-links a:hover {
    color: rgba(220, 216, 228, 1);
    border-bottom-color: rgba(220, 216, 228, 0.75);
  }

  .banner-links i.bi {
    margin-right: 0.35rem;
  }
```

--------------------------------

### Create TerminalLogControlWriter with LogControl

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Shows how to instantiate a TerminalLogControlWriter with a LogControl, enabling rich formatting and markup messages. This writer marshals background thread writes to the UI thread and does not render attachments by default.

```csharp
using XenoAtom.Logging.Writers;
using XenoAtom.Terminal.UI.Controls;

var logControl = new LogControl();
var writer = new TerminalLogControlWriter(logControl)
{
    EnableRichFormatting = true,
    EnableMarkupMessages = true
};
```

--------------------------------

### Reset styles to defaults

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Restores default styles on the writer's Styles configuration.

```csharp
writer.Styles.ResetToDefaults();
```

--------------------------------

### MEL scope with BeginScope

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/microsoft-extensions-logging.md

Uses BeginScope with a message template to add structured data to a log scope.

```csharp
using (_logger.BeginScope("Request {RequestId}", requestId))
{
    _logger.LogInformation("Handling request");
}
```

--------------------------------

### JSON-lines logging with JsonFileLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Creates a JsonFileLogWriter with daily rolling and a retained file count limit of 7, emitting one JSON object per line.

```csharp
var writer = new JsonFileLogWriter(
    new FileLogWriterOptions("logs/app.jsonl")
    {
        RollingInterval = FileRollingInterval.Daily,
        RetainedFileCountLimit = 7
    });
```

--------------------------------

### Define custom formatter with [LogFormatter] attribute

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Declares a partial record inheriting LogFormatter and decorated with [LogFormatter]. The generator emits a TryFormat implementation and a singleton Instance property.

```csharp
using XenoAtom.Logging;

namespace MyApp.Logging;

[LogFormatter("{Timestamp:HH:mm:ss} {Level,-5} {LoggerName} {Text}{? | {Exception}?}")]
public sealed partial record MyLogFormatter : LogFormatter;
```

--------------------------------

### Log structured properties

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/getting-started.md

Logs a message with structured properties using LogProperties, including requestId and tenant.

```csharp
var properties = new LogProperties
{
    ("requestId", 1423),
    ("tenant", "alpha")
};

logger.Info(properties: properties, msg: "Processing request");
```

--------------------------------

### Log with scoped context

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/getting-started.md

Uses BeginScope to add contextual data (traceId) to all log messages within the scope.

```csharp
using (logger.BeginScope(new LogProperties { ("traceId", "abc-123") }))
{
    logger.Info("Inside request scope");
}
```

--------------------------------

### Configure TerminalLogWriter with StandardLogFormatter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Sets a StandardLogFormatter on a TerminalLogWriter for terminal output.

```csharp
var terminalWriter = new TerminalLogWriter()
{
    Formatter = StandardLogFormatter.Instance
};
```

--------------------------------

### Enable rich formatting and markup messages on TerminalLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal.md

Creates a TerminalLogWriter with EnableRichFormatting and EnableMarkupMessages set to true, enabling rich formatting by default.

```csharp
var writer = new TerminalLogWriter()
{
    EnableRichFormatting = true,
    EnableMarkupMessages = true,
};
```

--------------------------------

### Log markup messages with InfoMarkup and ErrorMarkup

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/readme.md

Logs markup-formatted messages to the terminal sink. InfoMarkup writes an informational message, ErrorMarkup writes an error message with an interpolated request ID.

```csharp
logger.InfoMarkup("[green]ready[/]");
logger.ErrorMarkup($"[bold red]failed[/] id={requestId}");
```

--------------------------------

### Custom archive file name callback

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/file-writer.md

Provides a custom callback for ArchiveFileNameFormatter that formats the timestamp and includes base file name and extension.

```csharp
ArchiveFileNameFormatter = context =>
    $"{context.BaseFileName}.{context.Timestamp:yyyy-MM-dd-HH_mm_ss}{context.Extension}";
```

--------------------------------

### Log markup message with InfoMarkup

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/log-formatter.md

Logs a message containing markup tags. The [green] and [/] tags are rendered by terminal writers or stripped by text-based writers.

```csharp
logger.InfoMarkup("[green]ready[/]");
```

--------------------------------

### Style customization with TerminalLogWriter

Source: https://github.com/xenoatom/xenoatom.logging/blob/main/site/docs/terminal-visuals.md

C# code configuring TerminalLogWriter with rich formatting, markup messages, and custom styles for log segments and levels.

```csharp
var writer = new TerminalLogWriter()
{
    EnableRichFormatting = true,
    EnableMarkupMessages = true,
};

writer.Styles.Clear();
writer.Styles.SetStyle(LogMessageFormatSegmentKind.Timestamp, "dim");
writer.Styles.SetStyle(LogMessageFormatSegmentKind.LoggerName, "blue");
writer.Styles.SetLevelStyle(LogLevel.Info, "green");
writer.Styles.SetLevelStyle(LogLevel.Warn, "bold yellow");
writer.Styles.SetLevelStyle(LogLevel.Error, "bold white on red");
```
Tokens:
Raw