Struct opendal::layers::PrometheusLayer

pub struct PrometheusLayer { /* private fields */ }

Available on crate feature layers-prometheus only.

Add prometheus for every operations.

Prometheus Metrics

In this section, we will introduce three metrics that are currently being exported by our project. These metrics are essential for understanding the behavior and performance of our applications.

Metric Name	Type	Description	Labels
requests_total	Counter	Total times of ‘create’ operation being called	scheme, operation
requests_duration_seconds	Histogram	Histogram of the time spent on specific operation	scheme, operation
bytes_total	Histogram	Total size	scheme, operation

For a more detailed explanation of these metrics and how they are used, please refer to the Prometheus documentation.

Histogram Configuration

The metric buckets for these histograms are automatically generated based on the exponential_buckets(0.01, 2.0, 16) configuration.

Examples

use log::debug;
use log::info;
use opendal::layers::PrometheusLayer;
use opendal::services;
use opendal::Operator;
use opendal::Result;
use prometheus::Encoder;

/// Visit [`opendal::services`] for more service related config.
/// Visit [`opendal::Operator`] for more operator level APIs.
#[tokio::main]
async fn main() -> Result<()> {
    // Pick a builder and configure it.
    let builder = services::Memory::default();
    let registry = prometheus::default_registry();

    let op = Operator::new(builder)
        .expect("must init")
        .layer(PrometheusLayer::with_registry(registry.clone()))
        .finish();
    debug!("operator: {op:?}");

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

    // 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());
    Ok(())
}

Implementations

impl PrometheusLayer

pub fn with_registry(registry: Registry) -> Self

create PrometheusLayer by incoming registry.

pub fn requests_duration_seconds_buckets(self, buckets: Vec<f64>) -> Self

set buckets for requests_duration_seconds

pub fn bytes_total_buckets(self, buckets: Vec<f64>) -> Self

set buckets for bytes_total

pub fn enable_path_label(self, level: usize) -> Self

set path label level 0: no path label, the path label will be the “” >0: the path label will be the path split by “/” and get the last n level, like “/abc/def/ghi”, if n=1, the path label will be “/abc”

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 Default for PrometheusLayer

fn default() -> PrometheusLayer

Returns the “default value” for a type.

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

type LayeredAccess = PrometheusAccessor<A>

The layered accessor that returned by this layer.

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

Intercept the operations on the underlying storage.