Crate tracing_log

Adapters for connecting unstructured log records from the log crate into the tracing ecosystem.

Overview

tracing is a framework for instrumenting Rust programs with context-aware, structured, event-based diagnostic information. This crate provides compatibility layers for using tracing alongside the logging facade provided by the log crate.

This crate provides:

• AsTrace and AsLog traits for converting between tracing and log types.
• LogTracer, a log::Log implementation that consumes log::Records and outputs them as tracing::Event.
• An [env_logger] module, with helpers for using the env_logger crate with tracing (optional, enabled by the env-logger feature).

Compiler support: requires rustc 1.49+

Usage

Convert log records to tracing Events

To convert log::Records as tracing::Events, set LogTracer as the default logger by calling its init or init_with_filter methods.

use tracing_log::LogTracer;
use log;

LogTracer::init()?;

// will be available for Subscribers as a tracing Event
log::trace!("an example trace log");

This conversion does not convert unstructured data in log records (such as values passed as format arguments to the log! macro) to structured tracing fields. However, it does attach these new events to to the span that was currently executing when the record was logged. This is the primary use-case for this library: making it possible to locate the log records emitted by dependencies which use log within the context of a trace.

Convert tracing Events to logs

Enabling the “log” and “log-always” feature flags on the tracing crate will cause all tracing spans and events to emit log::Records as they occur.

Caution: Mixing both conversions

Note that logger implementations that convert log records to trace events should not be used with Subscribers that convert trace events back into log records (such as the TraceLogger), as doing so will result in the event recursing between the subscriber and the logger forever (or, in real life, probably overflowing the call stack).

If the logging of trace events generated from log records produced by the log crate is desired, either the log crate should not be used to implement this logging, or an additional layer of filtering will be required to avoid infinitely converting between Event and log::Record.

Feature Flags

• trace-logger: enables an experimental log subscriber, deprecated since version 0.1.1.
• log-tracer: enables the LogTracer type (on by default)
• env_logger: enables the env_logger module, with helpers for working with the env_logger crate.
• interest-cache: makes it possible to configure an interest cache for logs emitted through the log crate (see Builder::with_interest_cache); requires std

Supported Rust Versions

Tracing is built against the latest stable release. The minimum supported version is 1.49. The current Tracing version is not guaranteed to build on Rust versions earlier than the minimum supported version.

Tracing follows the same compiler support policies as the rest of the Tokio project. The current stable Rust compiler and the three most recent minor versions before it will always be supported. For example, if the current stable compiler version is 1.45, the minimum supported version will not be increased past 1.42, three minor versions prior. Increasing the minimum supported compiler version is not considered a semver breaking change as long as doing so complies with this policy.

Re-exports

• pub use log;

Modules

• log_tracer
  An adapter for converting log records into tracing Events.

Structs

• LogTracer
  A simple “logger” that converts all log records into tracing Events.

Traits

• AsLog
  Trait implemented for tracing types that can be converted to a log equivalent.
• AsTrace
  Trait implemented for log types that can be converted to a tracing equivalent.
• NormalizeEvent
  Extends log Events to provide complete Metadata.

Functions

• format_trace
  Format a log record as a trace event in the current span.