Struct SystemdLayer 

pub struct SystemdLayer { /* private fields */ }

A tracing-subscriber Layer that emits a pretty span-chain line per event.

Construct with SystemdLayer::stdout, then chain with_* methods to configure formatting, and pass it to a tracing-subscriber::registry().

use tracing_subscriber::prelude::*;
use tracing_systemd::SystemdLayer;

tracing_subscriber::registry()
    .with(SystemdLayer::stdout().with_target(true))
    .init();

Implementations

impl SystemdLayer

pub fn stdout() -> Self

Construct a layer that writes formatted lines to standard output. All formatting options have sensible defaults; chain with_* methods to override them.

Examples found in repository

examples/stdout.rs (line 15)

fn main() {
    tracing_subscriber::registry()
        .with(
            SystemdLayer::stdout()
                .with_target(true)
                .with_thread_ids(true)
                .with_level_prefix(false),
        )
        .init();

    root_log_fn(true);
}

examples/combined.rs (line 13)

fn main() {
    // Stdout layer: pretty for humans.
    let stdout_layer = SystemdLayer::stdout()
        .with_target(true)
        .with_level_prefix(false);

    // Journald layer: optional. None if we're not running under systemd.
    let journald_layer = tracing_systemd::journald::layer_with_identifier("combined-example").ok();

    tracing_subscriber::registry()
        .with(stdout_layer)
        .with(journald_layer)
        .init();

    work(42);
}

pub fn stderr() -> Self

Construct a layer that writes formatted lines to standard error.

pub fn unit_stdout() -> Self

Construct a layer that writes formatted lines to a journald-friendly stream — i.e. stdout with syslog-priority prefixes (<3>–<7>). journalctl understands these prefixes when no native journal field is supplied, which is what happens for processes managed by a systemd unit (their stdout is already routed to the journal).

For direct journal-protocol writes (without going through stdout), enable the journald feature and use crate::journald::layer.

pub fn json() -> Self

Available on crate feature json only.

Construct a layer that emits a single-line JSON object per event to standard output.

Defaults differ from the pretty-mode constructors: target is on, timestamps are on with TimestampFormat::Rfc3339, and the syslog level prefix is off (so each line is a valid standalone JSON object). Pretty-only builders (with_color_*, separators, brackets, thread-id prefix/suffix) compile but have no effect in JSON mode.

Schema (per line):

{
  "timestamp": "2026-05-05T14:23:45.123Z",
  "level": "INFO",
  "message": "served request",
  "target": "my_app::handlers",
  "span_chain": [
    {"name": "request", "fields": {"method": "GET"}},
    {"name": "handler", "fields": {}}
  ],
  "fields": {"latency_ms": 4}
}

thread_id is added at the top level when Self::with_thread_ids is true. Non-finite f64 values become JSON null, matching tracing-subscriber’s JSON formatter.

Examples found in repository

examples/json.rs (line 14)

fn main() {
    tracing_subscriber::registry()
        .with(SystemdLayer::json().with_thread_ids(true))
        .init();

    handle_request("GET", "/api/users");
    handle_request("POST", "/api/orders");
}

impl SystemdLayer

pub fn with_output(self, output: Output) -> Self

Override the destination. Useful for Output::stderr() or Output::writer(buf) (test capture).

pub fn with_target(self, show: bool) -> Self

Show the event’s target (typically the module path) before the span chain. Default: false.

Examples found in repository

examples/stdout.rs (line 16)

fn main() {
    tracing_subscriber::registry()
        .with(
            SystemdLayer::stdout()
                .with_target(true)
                .with_thread_ids(true)
                .with_level_prefix(false),
        )
        .init();

    root_log_fn(true);
}

examples/combined.rs (line 14)

fn main() {
    // Stdout layer: pretty for humans.
    let stdout_layer = SystemdLayer::stdout()
        .with_target(true)
        .with_level_prefix(false);

    // Journald layer: optional. None if we're not running under systemd.
    let journald_layer = tracing_systemd::journald::layer_with_identifier("combined-example").ok();

    tracing_subscriber::registry()
        .with(stdout_layer)
        .with(journald_layer)
        .init();

    work(42);
}

pub fn with_thread_ids(self, show: bool) -> Self

Include the OS thread id in each line. Default: false.

Examples found in repository

examples/json.rs (line 14)

fn main() {
    tracing_subscriber::registry()
        .with(SystemdLayer::json().with_thread_ids(true))
        .init();

    handle_request("GET", "/api/users");
    handle_request("POST", "/api/orders");
}

examples/stdout.rs (line 17)

fn main() {
    tracing_subscriber::registry()
        .with(
            SystemdLayer::stdout()
                .with_target(true)
                .with_thread_ids(true)
                .with_level_prefix(false),
        )
        .init();

    root_log_fn(true);
}

pub fn with_timestamps(self, show: bool) -> Self

Show a timestamp at the start of each line. Default: false. See also SystemdLayer::with_timestamp_format.

pub fn with_timestamp_format(self, format: TimestampFormat) -> Self

Choose the timestamp format. Implies with_timestamps(true) for any non-None value. Default: TimestampFormat::None.

pub fn with_level_prefix(self, use_prefix: bool) -> Self

Emit a syslog-priority prefix (<3> – <7>) before each line. This is what journalctl uses to assign a PRIORITY when ingesting plain stdout from a systemd unit. Default: true.

Examples found in repository

examples/stdout.rs (line 18)

fn main() {
    tracing_subscriber::registry()
        .with(
            SystemdLayer::stdout()
                .with_target(true)
                .with_thread_ids(true)
                .with_level_prefix(false),
        )
        .init();

    root_log_fn(true);
}

examples/combined.rs (line 15)

fn main() {
    // Stdout layer: pretty for humans.
    let stdout_layer = SystemdLayer::stdout()
        .with_target(true)
        .with_level_prefix(false);

    // Journald layer: optional. None if we're not running under systemd.
    let journald_layer = tracing_systemd::journald::layer_with_identifier("combined-example").ok();

    tracing_subscriber::registry()
        .with(stdout_layer)
        .with(journald_layer)
        .init();

    work(42);
}

pub fn with_span_separator(self, sep: impl Into<Cow<'static, str>>) -> Self

Separator between spans in the chain. Default: "::".

pub fn with_message_separator(self, sep: impl Into<Cow<'static, str>>) -> Self

Separator between the level/span chain and the event message. Default: ": ".

pub fn with_level_separator(self, sep: impl Into<Cow<'static, str>>) -> Self

Separator after the level. Default: " ".

pub fn with_function_bracket_left(self, s: impl Into<Cow<'static, str>>) -> Self

String wrapping the opening of a span argument list. Default: "(".

pub fn with_function_bracket_right( self, s: impl Into<Cow<'static, str>>, ) -> Self

String wrapping the closing of a span argument list. Default: ")".

pub fn with_arguments_equality(self, s: impl Into<Cow<'static, str>>) -> Self

String between an argument name and its value. Default: ": ".

pub fn with_arguments_separator(self, s: impl Into<Cow<'static, str>>) -> Self

String between consecutive arguments. Default: ", ".

pub fn with_thread_id_prefix(self, s: impl Into<Cow<'static, str>>) -> Self

Prefix for the thread id when with_thread_ids(true). Default: "[".

pub fn with_thread_id_suffix(self, s: impl Into<Cow<'static, str>>) -> Self

Suffix for the thread id when with_thread_ids(true). Default: "] ".

pub fn with_color_mode(self, mode: ColorMode) -> Self

Available on crate feature colors only.

Set the ColorMode. Default: ColorMode::Auto (color iff TTY and NO_COLOR is unset).

pub fn with_color_theme(self, theme: ColorTheme) -> Self

Available on crate feature colors only.

Set the ColorTheme. Default: ColorTheme::default (matches 0.1).

Trait Implementations

impl Debug for SystemdLayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SystemdLayer

fn default() -> Self

Returns the “default value” for a type.

impl<S> Layer<S> for SystemdLayer

where S: Subscriber + for<'a> LookupSpan<'a>,

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Notifies this layer that a new span was constructed with the given Attributes and Id.

fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)

Notifies this layer that an event has occurred.

fn on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

fn on_layer(&mut self, subscriber: &mut S)

Performs late initialization when attaching a Layer to a Subscriber.

fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest

Registers a new callsite with this layer, returning whether or not the layer is interested in being notified about the callsite, similarly to Subscriber::register_callsite.

fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool

Returns true if this layer is interested in a span or event with the given metadata in the current Context, similarly to Subscriber::enabled.

fn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, S>)

Notifies this layer that a span with the given Id recorded the given values.

fn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the ID span recorded that it follows from the span with the ID follows.

fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool

Called before on_event, to determine if on_event should be called.

fn on_enter(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the given ID was entered.

fn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that the span with the given ID was exited.

fn on_close(&self, _id: Id, _ctx: Context<'_, S>)

Notifies this layer that the span with the given ID has been closed.

fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span ID has been cloned, and that the subscriber returned a different ID.

fn and_then<L>(self, layer: L) -> Layered<L, Self, S>

where L: Layer<S>, Self: Sized,

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S>

where Self: Sized,

Composes this Layer with the given Subscriber, returning a Layered struct that implements Subscriber.

fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>

where Self: Sized, F: Filter<S>,

Available on crate features registry and std only.

Combines self with a Filter, returning a Filtered layer.

fn boxed(self) -> Box<dyn Layer<S> + Send + Sync>

where Self: Sized + Layer<S> + Send + Sync + 'static, S: Subscriber,

Available on crate features alloc or std only.

Erases the type of this Layer, returning a Boxed dyn Layer trait object.