DOCSEARCHbyAlgolia
Submit Docs

Klogging Documentation

website·Indexed 32 days ago

https://klogging.io

A logging library for Kotlin and the JVM that supports coroutine context, multiple configuration formats including HOCON and JSON, and integration with Ktor, Spring Boot, SLF4J, and JDK Platform Logging.

Tokens
12.7K
Snippets
65
Records
99
Agent score
63%

What's inside Klogging

  1. Overview of Klogging logging library

    Klogging is a pure-Kotlin logging library designed for flexibility and ease of use. It leverages Kotlin idioms for logger creation and event dispatching. It is specifically designed to integrate with Kotlin coroutines, making it suitable for asynchronous environments like the Ktor framework. Currently, Klogging only supports Kotlin on the JVM, with plans for future Kotlin Multiplatform target support.

  2. Understand Klogging structured log events

    Klogging utilizes log events instead of simple messages to capture richer information. Every log event includes inbuilt properties that describe the immediate context of where the event was generated, such as the timestamp, severity level, and logger name.

  3. Understand Klogging's asynchronous log processing architecture

    Klogging uses Kotlin coroutines and channels to ensure log event handling is non-blocking. The architecture follows these primary asynchronous flows:

    1. Event Dispatching: Log events are sent into an events channel within a coroutine.
    2. Sink Distribution: A separate coroutine reads events from the events channel and dispatches them by sending them into the channels of each matching sink.
    3. Batching: For network destinations, events are read from sink channels in batches using dedicated coroutines to optimize throughput.

  4. Use message templates for structured logging in Klogging

    Klogging provides a partial implementation of the message templates standard, allowing developers to create structured log events. Currently, the following features of the standard are NOT supported:

    • Escaping braces using double braces (e.g., {{)
    • Numeric property names (e.g., {0})

    Full implementation of the standard is planned for future releases.

  5. Include contextual information in logs using Coroutine Context

    Klogging allows you to attach contextual information to a coroutine context, ensuring that all log events emitted within that scope (and any child coroutine scopes) automatically include these items. This is achieved using the LogContext class, which maintains a map of contextual information within the coroutine context.

  6. Understand Klogging internal logger diagnostic levels

    Klogging includes an internal logger used exclusively for diagnostics of the Klogging library itself. It emits string messages to the console based on the following levels:

    • TRACE: Detailed tracing of log events through Klogging.
    • DEBUG: Lifecycle events of Klogging components.
    • INFO: Notifications that Klogging has read configuration from DSL or file.
    • WARN: Errors encountered while interpreting configuration.

  7. Understand the Klogging log event processing pipeline

    Klogging uses Kotlin coroutine channels to move logging operations off the main execution threads. The process follows these stages:

    1. Filter: Determines if a log event should be constructed and emitted based on Klogger configuration.
    2. Emit: Sends the log event into the events channel (or directly to sinks).
    3. Dispatch: Identifies which sinks should receive the event and routes them to the corresponding sink channels.
    4. Render: Converts the log event into a format suitable for the specific sink.
    5. Send: Delivers the rendered event to the final destination.

    Key implementation details:

    • Klogger instances use suspend functions for emitting events.
    • NoCoLogger instances launch coroutines to emit events into the channel (non-suspending).
    • Each sink has its own channel and processes events in the order received.
    • Direct logging is possible, bypassing the asynchronous coroutine channels.

  8. Integrate Klogging with other logging frameworks

    Klogging can serve as the logging engine for other popular logging frameworks, allowing you to route logs from these facades through Klogging's back-end processing and destinations. It currently supports integration with:

    • Simple Logging Facade for Java (SLF4J)
    • Java Platform Logging API (JDK Platform Logging)

  9. Configure Klogging for JVM logging

    Klogging can be used as the logging library for the JVM and provides official support for the following integrations: JDK Platform Logging, Simple Logging Facade for Java (SLF4J), and Spring Boot. For users previously using the Hexagon microservices toolkit adapter, it is now recommended to use the JDK Platform Logging implementation.

  10. Klogging SLF4J compatibility in Spring Boot

    Klogging acts as the logging framework for Spring Boot. Since all Spring libraries and existing application code typically log via SLF4J, all SLF4J log events are automatically processed by Klogging. Developers can also create structured log events using SLF4J.

  11. Configure Klogging using DSL, JSON, or HOCON

    Klogging starts with no configuration and will not send log events until configured. Configuration can be implemented via three primary methods: using the Configuration domain-specific language (DSL) in code, using a JSON configuration file, or using a HOCON configuration file. Additionally, certain configurations can be overridden using environment variables.

  12. Understand Klogging Sinks and log destinations

    In Klogging, Sinks are the final destinations for log events. A Sink is conceptually composed of two parts: a renderer that converts log events into a String format, and a sender that transmits those strings to a specific destination. Common supported destinations include standard output/error streams, Seq, Graylog, Logstash (ELK stack), and Splunk.