Struct DltLayer

pub struct DltLayer {
    pub app: Arc<DltApplication>,
    /* private fields */
}

COVESA DLT layer for tracing

Integrates tracing with DLT (Diagnostic Log and Trace). Spans can specify their own DLT context via the dlt_context field; events outside spans use “DFLT” context.

See the crate-level documentation for usage examples.

Fields

app: Arc<DltApplication>

Implementations

impl DltLayer

pub fn new(app_id: &DltId, app_description: &str) -> Result<Self, DltError>

Create a new DLT layer

Registers the application with DLT and creates a default “DFLT” context. Span contexts are created on-demand using the dlt_context field.

Errors

Returns error if DLT registration fails or strings contain null bytes.

Panics

If called outside a Tokio runtime context.

Trait Implementations

impl<S> Filter<S> for DltLayer

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

Determines if a span or event with the given metadata is enabled.

This implementation checks if the event/span level is within the current DLT maximum log level across all contexts. It also filters out internal DLT layer errors to prevent recursion.

Since we don’t know which context will be used at this point, we use the most permissive level across all contexts.

fn max_level_hint(&self) -> Option<LevelFilter>

Returns the current maximum log level from DLT.

This hint allows the tracing infrastructure to skip callsites that are more verbose than the current DLT log level, improving performance.

When the DLT log level changes (via DLT daemon or configuration), the background task calls rebuild_interest_cache() to ensure this new hint takes effect immediately.

This returns the most permissive (verbose) level across all contexts, since we can’t know which context will be used at callsite registration time.

fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest

Returns an Interest indicating whether this layer will always, sometimes, or never be interested in the given Metadata.

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

Called before the filtered [Layer]'s [on_event], to determine if on_event` should be called.

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

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

fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>)

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

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

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

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

Notifies this filter that a span with the given ID was exited.

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

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

impl<S> Layer<S> for DltLayer

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

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_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_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_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 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>,

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,

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