Struct PrometheusObserver 

pub struct PrometheusObserver { /* private fields */ }

Available on crate feature metrics only.

Prometheus-backed Observer. Construct it, register it on the engine builder, and expose its registry on your /metrics endpoint.

use arcly_stream::observability::PrometheusObserver;
use arcly_stream::prelude::*;

let metrics = PrometheusObserver::new().expect("register metrics");
let registry = metrics.registry().clone();
let engine = Engine::builder()
    .application(AppSpec::new("live"))
    .observer(metrics)
    .build();
assert!(!registry.gather().is_empty());

Implementations

impl PrometheusObserver

pub fn new() -> Result<Self>

Create an observer with a fresh registry.

pub fn with_registry(registry: Registry) -> Result<Self>

Create an observer registering into an existing registry (e.g. the process-wide default).

pub fn registry(&self) -> &Registry

The registry to gather and expose on /metrics.

Trait Implementations

impl Observer for PrometheusObserver

fn on_publish_started(&self, app: &str)

A publish session started in application app.

fn on_publish_ended(&self, app: &str)

A publish session ended in application app.

fn on_frame(&self, key: &StreamKey, _frame: &MediaFrame)

A frame was published. Hot-path hook — keep it cheap. The default is a no-op so the branch is trivially predicted away when no observer is installed.

fn on_subscriber_lagged(&self, key: &StreamKey, skipped: u64)

A subscriber fell behind the broadcast buffer and skipped frames were dropped from its view before it could read them. This is the canonical slow-consumer signal: alert on it. Fired by StreamHandle::subscribe_resilient.

fn on_event(&self, _event: &StreamEvent)

A stream lifecycle event was emitted.

fn on_subscriber_evicted(&self, _key: &StreamKey)

A chronically slow subscriber crossed its max_lag budget and was shed. Fired by Subscription::recv.

fn on_rate_limited(&self, _key: &StreamKey)

An ingress rate limit was exceeded for key; the protocol handler should drop or backpressure the connection. Handlers call this from their ingest loop (e.g. when IngestRateLimit returns false).

fn on_stream_reaped(&self, _key: &StreamKey)

A publish session was reaped for exceeding the engine’s idle timeout.