Struct PythonCallbackLayerBridge

pub struct PythonCallbackLayerBridge { /* private fields */ }

PythonCallbackLayerBridge is an adapter allowing the tracing_subscriber::layer::Layer trait to be implemented by a Python object. Each trait method’s arguments are serialized as JSON strings and passed to the corresponding method on the Python object if it exists.

The interface PythonCallbackLayerBridge expects Python objects to implement differs slightly from the Layer trait in Rust:

• The Python implementation of on_new_span may return some state that will be stored in the new span’s tracing_subscriber::registry::Extensions.
• When calling other trait methods, PythonCallbackLayerBridge will get that state from the current span and pass it back to Python as an additional positional argument.

The state is opaque to PythonCallbackLayerBridge but, for example, a layer for a Python tracing system could create a Python span for each Rust span and use a reference to the Python span as the state.

Currently only a subset of Layer methods are bridged to Python:

• tracing_subscriber::layer::Layer::on_event, with corresponding Python signature python def on_event(self, event: str, state: Any): ...
• tracing_subscriber::layer::Layer::on_new_span python def on_new_span(self, span_attrs: str, span_id: str): ...
• tracing_subscriber::layer::Layer::on_close python def on_close(self, span_id: str, state: Any): ...
• tracing_subscriber::layer::Layer::on_record python def on_record(self, span_id: str, values: str, state: Any): ...

Implementations

impl PythonCallbackLayerBridge

pub fn new(py_impl: Bound<'_, PyAny>) -> PythonCallbackLayerBridge

Trait Implementations

impl<S> Layer<S> for PythonCallbackLayerBridge

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

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

Notifies this layer that an event has occurred.

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

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

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

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

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

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

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