Struct RiObservabilityModule 

pub struct RiObservabilityModule { /* private fields */ }

Main observability module for Ri.

This module provides distributed tracing and metrics collection capabilities, following modern observability best practices. It implements the ServiceModule trait for seamless integration with the Ri application lifecycle.

Implementations

impl RiObservabilityModule

pub fn new() -> Self

Creates a new observability module with default configuration.

Returns

A new RiObservabilityModule instance with default configuration

pub fn with_config(self, config: RiObservabilityConfig) -> Self

Configures the observability module with custom settings.

Parameters

• config: The custom configuration to apply

Returns

The updated RiObservabilityModule instance

pub fn export_data(&self) -> RiObservabilityData

Exports observability data.

This method collects and returns the current observability data, including metrics in Prometheus format and information about active traces and spans.

Returns

A RiObservabilityData struct containing the exported observability data

Trait Implementations

impl Default for RiObservabilityModule

fn default() -> Self

Returns the “default value” for a type.

impl<'py> IntoPyObject<'py> for RiObservabilityModule

type Target = RiObservabilityModule

The Python output type

type Output = Bound<'py, <RiObservabilityModule as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for RiObservabilityModule

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiObservabilityModule

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// with the Ri application lifecycle.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<RiObservabilityModule>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<RiObservabilityModule> for PyClassImplCollector<RiObservabilityModule>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiObservabilityModule

const NAME: &'static str = "RiObservabilityModule"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl RiModule for RiObservabilityModule

fn name(&self) -> &str

Returns the name of the observability module.

Returns

The module name as a string

fn is_critical(&self) -> bool

Indicates whether the observability module is critical.

The observability module is non-critical, meaning that if it fails to initialize or operate, it should not break the entire application. This allows the core functionality to continue even if observability features are unavailable.

Returns

false since observability is non-critical

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Initializes the observability module.

This method performs the following steps:

1. Loads configuration from the service context
2. Initializes tracing with the configured sampling rate
3. Initializes the metrics registry
4. Creates common service metrics
5. Registers lifecycle hooks for automatic metrics collection
6. Logs initialization completion

Parameters

• ctx: The service context containing configuration and other services

Returns

A RiResult<()> indicating success or failure

fn after_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs cleanup after the application has shut down.

This method exports the final observability data and logs information about active traces and spans at the time of shutdown.

Parameters

• ctx: The service context containing the logger service

Returns

A RiResult<()> indicating success or failure

fn priority(&self) -> i32

Returns the priority of the module.

fn dependencies(&self) -> Vec<&str>

Returns the list of module dependencies.

fn before_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the module for startup.

fn start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Starts the service module.

fn after_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs post-startup operations.

fn before_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the module for shutdown.

fn shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Shuts down the service module.

impl DerefToPyAny for RiObservabilityModule

impl ExtractPyClassWithClone for RiObservabilityModule