Struct PrometheusRenderer 

pub struct PrometheusRenderer { /* private fields */ }

A renderer for the Prometheus text exposition format.

The renderer owns internal buffers that are reused across calls, amortizing allocation costs when rendering multiple payloads over time.

Usage

There are two ways to use the renderer:

High-level: Use [render_group][Self::render_group] for counter/gauge groups where all series are simple label/value pairs. This handles the TYPE/HELP headers and all series lines in one call.

Low-level: Use begin_group to start a new metric group (writes TYPE/HELP headers), then call individual series writing methods like write_gauge_or_counter_series, write_histogram_series, or write_summary_series for each tag combination. Finally, call finish_group to append the group to the output. This is useful when you have multiple series with complex types (histograms/summaries) sharing a single TYPE header.

Implementations

impl PrometheusRenderer

pub fn new() -> Self

Creates a new PrometheusRenderer.

pub fn clear(&mut self)

Clears the output buffer to start a fresh payload, retaining allocated capacity.

pub fn output(&self) -> &str

Returns the accumulated output as a string slice.

pub fn normalize_metric_name<'a>(&'a mut self, name: &str) -> &'a str

Normalizes a metric name to a valid Prometheus metric name, returning a reference to the internal name buffer.

Periods (.) are converted to double underscores (__). Other invalid characters are converted to a single underscore (_).

pub fn render_scalar_group<S, L, K, V>( &mut self, metric_name: &str, metric_type: MetricType, help_text: Option<&str>, series: S, )

where S: IntoIterator<Item = (L, f64)>, L: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

Renders a counter or gauge metric group: # TYPE header, optional # HELP header, and all series lines.

The metric name is automatically normalized to a valid Prometheus name.

pub fn begin_group( &mut self, metric_name: &str, metric_type: MetricType, help_text: Option<&str>, )

Begins a new metric group by writing the # TYPE and optional # HELP headers.

The metric name is automatically normalized to a valid Prometheus name and stored internally for use by subsequent series writing methods.

After calling this, write individual series using write_gauge_or_counter_series, write_histogram_series, or write_summary_series. When done, call finish_group.

pub fn write_gauge_or_counter_series<L, K, V>(&mut self, labels: L, value: f64)

where L: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>,

Writes a single counter or gauge series line to the current metric group.

Uses the metric name set by the most recent begin_group call.

pub fn write_histogram_series<L, K, V, B>( &mut self, labels: L, buckets: B, sum: f64, count: u64, )

where L: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>, B: IntoIterator<Item = (&'static str, u64)>,

Writes a single histogram series (one set of labels) to the current metric group.

Uses the metric name set by the most recent begin_group call.

Each bucket is (upper_bound_str, cumulative_count). A +Inf bucket is automatically appended using the total count.

pub fn write_summary_series<L, K, V, Q>( &mut self, labels: L, quantiles: Q, sum: f64, count: u64, )

where L: IntoIterator<Item = (K, V)>, K: AsRef<str>, V: AsRef<str>, Q: IntoIterator<Item = (f64, f64)>,

Writes a single summary series (one set of labels) to the current metric group.

Uses the metric name set by the most recent begin_group call.

Each quantile is (quantile_value, observed_value).

pub fn finish_group(&mut self)

Finishes the current metric group, appending the metric buffer to the output.

Trait Implementations

impl Default for PrometheusRenderer

fn default() -> Self

Returns the “default value” for a type.