Struct PrometheusLayer

pub struct PrometheusLayer { /* private fields */ }

Available on crate feature layers-prometheus only.

Add prometheus for every operation.

Prometheus Metrics

We provide several metrics, please see the documentation of observe module. For a more detailed explanation of these metrics and how they are used, please refer to the Prometheus documentation.

Examples

Basic Usage

let registry = prometheus::default_registry();

let op = Operator::new(services::Memory::default())?
    .layer(
        PrometheusLayer::builder()
            .register(registry)
            .expect("register metrics successfully"),
    )
    .finish();

// Write data into object test.
op.write("test", "Hello, World!").await?;
// Read data from the object.
let bs = op.read("test").await?;
info!("content: {}", String::from_utf8_lossy(&bs.to_bytes()));

// Get object metadata.
let meta = op.stat("test").await?;
info!("meta: {:?}", meta);

// Export prometheus metrics.
let mut buffer = Vec::<u8>::new();
let encoder = prometheus::TextEncoder::new();
encoder.encode(&prometheus::gather(), &mut buffer).unwrap();
println!("## Prometheus Metrics");
println!("{}", String::from_utf8(buffer.clone()).unwrap());

Global Instance

PrometheusLayer needs to be registered before instantiation.

If there are multiple operators in an application that need the PrometheusLayer, we could instantiate it once and pass it to multiple operators. But we cannot directly call .layer(PrometheusLayer::builder().register(&registry)?) for different services, because registering the same metrics multiple times to the same registry will cause register errors. Therefore, we can provide a global instance for the PrometheusLayer.

fn global_prometheus_layer() -> &'static PrometheusLayer {
    static GLOBAL: OnceLock<PrometheusLayer> = OnceLock::new();
    GLOBAL.get_or_init(|| {
        PrometheusLayer::builder()
            .register_default()
            .expect("Failed to register with the global registry")
    })
}

let op = Operator::new(services::Memory::default())?
    .layer(global_prometheus_layer().clone())
    .finish();

// Write data into object test.
op.write("test", "Hello, World!").await?;

// Read data from the object.
let bs = op.read("test").await?;
info!("content: {}", String::from_utf8_lossy(&bs.to_bytes()));

// Get object metadata.
let meta = op.stat("test").await?;
info!("meta: {:?}", meta);

// Export prometheus metrics.
let mut buffer = Vec::<u8>::new();
let encoder = prometheus::TextEncoder::new();
encoder.encode(&prometheus::gather(), &mut buffer).unwrap();
println!("## Prometheus Metrics");
println!("{}", String::from_utf8(buffer.clone()).unwrap());

Implementations

impl PrometheusLayer

pub fn builder() -> PrometheusLayerBuilder

Create a PrometheusLayerBuilder to set the configuration of metrics.

Example

// Pick a builder and configure it.
let builder = services::Memory::default();
let registry = prometheus::default_registry();

let duration_seconds_buckets = prometheus::exponential_buckets(0.01, 2.0, 16).unwrap();
let bytes_buckets = prometheus::exponential_buckets(1.0, 2.0, 16).unwrap();
let _ = Operator::new(builder)?
    .layer(
        PrometheusLayer::builder()
            .duration_seconds_buckets(duration_seconds_buckets)
            .bytes_buckets(bytes_buckets)
            .register(registry)
            .expect("register metrics successfully"),
    )
    .finish();

Trait Implementations

impl Clone for PrometheusLayer

fn clone(&self) -> PrometheusLayer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrometheusLayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: Access> Layer<A> for PrometheusLayer

type LayeredAccess = MetricsAccessor<A, PrometheusInterceptor>

The layered accessor that returned by this layer.

fn layer(&self, inner: A) -> Self::LayeredAccess

Intercept the operations on the underlying storage.