Struct ObservabilityState 

pub struct ObservabilityState {
    pub metrics_collector: Arc<MetricsCollector>,
    pub log_collector: Arc<LogCollector>,
    pub trace_collector: Arc<TraceCollector>,
    pub system_metrics: Arc<SystemMetricsCollector>,
    pub metrics_store: Arc<MetricsStore>,
    pub log_store: Arc<LogStore>,
    pub trace_store: Arc<TraceStore>,
    pub alert_store: Arc<AlertStore>,
    /* private fields */
}

Shared observability state for the runtime.

This struct encapsulates all observability components (collectors and stores) and provides a unified interface for recording and querying observability data.

Fields

metrics_collector: Arc<MetricsCollector>

Metrics collector for buffering metrics.

log_collector: Arc<LogCollector>

Log collector for buffering logs.

trace_collector: Arc<TraceCollector>

Trace collector for buffering traces.

system_metrics: Arc<SystemMetricsCollector>

System metrics collector.

metrics_store: Arc<MetricsStore>

Metrics store for persistence.

log_store: Arc<LogStore>

Log store for persistence.

trace_store: Arc<TraceStore>

Trace store for persistence.

alert_store: Arc<AlertStore>

Alert store for persistence.

Implementations

impl ObservabilityState

pub fn new(config: ObservabilityConfig, pool: PgPool) -> Self

Create a new observability state from config and database pool.

pub fn is_enabled(&self) -> bool

Check if observability is enabled.

pub async fn record_metric(&self, metric: Metric)

Record a metric.

pub async fn increment_counter(&self, name: impl Into<String>, value: f64)

Increment a counter metric.

pub async fn set_gauge(&self, name: impl Into<String>, value: f64)

Set a gauge metric.

pub async fn record_log(&self, log: LogEntry)

Record a log entry.

pub async fn info(&self, message: impl Into<String>)

Log at info level.

pub async fn warn(&self, message: impl Into<String>)

Log at warn level.

pub async fn error(&self, message: impl Into<String>)

Log at error level.

pub async fn record_span(&self, span: Span)

Record a span.

pub async fn flush(&self) -> Result<()>

Flush all collectors and persist to stores.

pub fn start_background_tasks(&self) -> Vec<JoinHandle<()>>

Start background flush loops.

This spawns tasks that periodically flush collectors to stores and run cleanup based on retention policies.

pub async fn shutdown(&self)

Signal shutdown to background tasks.

pub fn tracing_layer(&self) -> ForgeTracingLayer

Get a tracing layer that forwards logs to the LogCollector.

Use this to add log collection to your tracing subscriber:

use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

tracing_subscriber::registry()
    .with(observability.tracing_layer())
    .with(tracing_subscriber::fmt::layer())
    .init();

Trait Implementations

impl Clone for ObservabilityState

fn clone(&self) -> ObservabilityState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.