README- UCounter
- UExemplar
- UFamily
- UFormat
- UGauge
- UGaugeHistogram
- UHistogram
- UInfo
- UKind
- ULocalCounter
- UMetricFamily
- UPoint
- UProcessCollector
- UProcessStats
- UPushRequest
- URegistry
- UStateSet
- USummary
- UTypedFamily
- UValue
- Vapp
- Vbuckets
- Vdelete
- Vexemplar_label_limit
- Vexponential
- Vformat_float
- Vis_valid_label_name
- Vis_valid_metric_name
- Vis_valid_unit
- Vlinear
- Vmiddleware
- Vnegotiate
- Vopenmetrics
- Vpush
- Vpush_add
- Vtext
moonbitstack/moonp8s/metric does not have a README file
Collector
A custom source of metric families. Implement this to contribute series whose
shape the built-in metric types do not cover; the registry applies its prefix
and constant labels to whatever collect returns.
LabelSet
A record that can name its own label pairs. Implementing this for a struct
and using TypedFamily gives a family keyed by a typed label set instead of
an array of strings.
Metric
Anything a registry can collect: a metric, a family of metrics, or a custom
collector's contribution. Implement this to plug a new metric shape into a
registry without changing the registry.
Refused
pub(all) suberror Refused {
Refused(String)
}The one error this library raises: a request it will not honour, with the
reason in the message. Messages carry the offending value and, where a
position is meaningful, an at offset counted from zero.
Counter
pub struct Counter {
// private fields
}A monotonically increasing count. inc refuses a negative step because a
counter that goes down is a gauge.
Counter::inc
Increase the counter by by, keeping exemplar as the latest exemplar.
Counter::new
A counter at zero. created records when the series came into existence, for
the _created series OpenMetrics exposes.
Counter::reset
Restart the counter at zero, optionally dating the reset as a new creation
time. Use this when a logical process restarts without restarting the
program.
Counter::shard
A shard of this counter. Many shards may feed one counter; each flushes its
own accumulations.
Exemplar
An exemplar ties a sample to the request that produced it: the request's
labels, the observed value, and optionally when it was observed (Unix
seconds).
Family
pub struct Family[M] {
// private fields
}A family of metrics sharing one name and one fixed list of label names. The
label names are fixed at construction; labels gets or creates the child for
one combination of values.
Family::labels
The child for values, created if this is the first time it is seen. A
value count that does not match the family's label names is refused.
Family::new
A family over names, creating a child with make on first sight.
Family::remove
Drop the child for values if it exists.
Gauge
pub struct Gauge {
// private fields
}An instantaneous value that may go up or down. set takes the timestamp to
record, because this library never reads a clock; pass timestamp~ when the
sample is worth dating.
Gauge::set
Set the gauge to v, optionally dating the sample.
GaugeHistogram
pub struct GaugeHistogram {
// private fields
}A gauge histogram: the same buckets as a histogram, but the sum and count are
a gauge's, and the wire format spells them _gsum and _gcount.
impl Metric for GaugeHistogramGaugeHistogram::new
A gauge histogram over buckets (the shared defaults unless given).
GaugeHistogram::observe
Record one observation.
GaugeHistogram::snapshot
The snapshot of this gauge histogram.
Gk
type GkA Greenwald-Khanna sketch: it keeps a sorted summary of the observations so
that a quantile can be answered to within epsilon of the rank using memory
logarithmic in the number of observations. The targeted-quantile (CKMS)
family generalises this sketch; a single epsilon is what a summary's
quantile-and-error pairs reduce to.
Histogram
pub struct Histogram {
// private fields
}A histogram with cumulative buckets. Counts are kept per bucket and made
cumulative on snapshot, which is what the wire format carries.
Histogram::new
A histogram over buckets (the shared defaults unless given).
Histogram::observe
Record one observation in the first bucket whose bound it does not exceed,
or in the +Inf bucket when it exceeds every bound.
Histogram::snapshot
The snapshot of this histogram: cumulative bucket counts, the sum, and the
total count, with the retained exemplars.
Histogram::sum_value
The sum of the observations.
Info
pub struct Info {
// private fields
}An info metric: a fixed set of labels whose value is always 1. It carries
build and version metadata, which is why it never changes after creation.
Info::labels
The labels this info metric carries.
Info::new
An info metric with these labels.
Kind
pub(all) enum Kind {
Counter
Gauge
Histogram
GaugeHistogram
Summary
Info
StateSet
Unknown
}The kind of a metric, as spelled in the # TYPE line of an exposition.
Kind::code
The wire spelling of this kind: counter, gauge, histogram,
gaugehistogram, summary, info, stateset, or unknown.
LocalCounter
pub struct LocalCounter {
// private fields
}A non-atomic shard of a counter. Increments land in the shard and are added
to the shared counter on flush, which is the local accumulation the Rust
client offers; it keeps a hot path off the shared value without requiring
thread-local storage.
impl Metric for LocalCounterLocalCounter::flush
Add the shard's value to the shared counter and clear the shard.
LocalCounter::get
The shard's unflushed value.
LocalCounter::inc
Increase the shard by by.
LocalCounter::reset
Drop the unflushed value.
MetricFamily
A family of series sharing one name, help text, kind, and optional unit.
This is what an exposition is written from and what a parser produces.
Point
One series of a family: its labels, its value, and the optional metadata
OpenMetrics carries alongside it. created is when the series was created
(Unix seconds); exemplars are the retained exemplars, matched to histogram
buckets by the value that produced them.
ProcessCollector
pub struct ProcessCollector {
// private fields
}The seven process_* series the Rust client's process collector exposes:
CPU time, open and maximum file descriptors, virtual and resident memory,
start time, and thread count.
impl Collector for ProcessCollectorProcessCollector::collect
ProcessCollector::new
A process collector over stats. namespace prefixes every name, as the
Rust client's namespace does.
ProcessStats
pub(all) struct ProcessStats {
cpu_seconds : Double
open_fds : Int64
max_fds : Int64
virtual_memory_bytes : Int64
resident_memory_bytes : Int64
start_time_seconds : Double
threads : Int64
}The process numbers a ProcessCollector exports. The caller reads them —
this library performs no I/O — which keeps the collector portable across
every target.
Registry
pub struct Registry {
// private fields
}The set of metrics one exposition exposes, with an optional name prefix and
optional constant labels applied to everything registered. A registry refuses
a metric name that is not a valid OpenMetrics name, a label name that is not
a valid label name, a unit that is not a valid unit, and a name registered
twice.
Registry::add
Add a custom collector. Its families are exposed after the registered
metrics, with this registry's prefix and labels applied.
Registry::collect
The snapshot of everything registered: one family per registered metric or
collector family, in registration order.
at is the moment of the scrape. Every sample that does not already carry a
timestamp is stamped with it, which is what a real scrape does: the exporter does
not know when it will be read. A sample that was given a timestamp keeps it — a
backfilled point is not the scrape's.
Registry::counter
Create a counter, register it, and return it.
Registry::gauge
Create a gauge, register it, and return it.
Registry::histogram
Create a histogram, register it, and return it.
Registry::new
An empty registry. prefix is prepended to every registered name, and
labels is added to every series.
Registry::register
Register metric under name, with help and an optional unit. The unit
is appended to the name on the wire.
StateSet
pub struct StateSet {
// private fields
}A set of named states, each true or false. A state set with exactly one true
state is the Enum of the Python client.
StateSet::exclusive
A state set with exactly one state true: the first, which is the Python
client's default.
StateSet::new
A state set whose states all start false, in the order given.
StateSet::set
Set one state true, leaving the others as they are.
StateSet::set_many
Apply a whole map of states at once.
Summary
pub struct Summary {
// private fields
}A summary: the count and sum of the observations, plus approximate quantiles
when the constructor is given target quantiles and their permitted rank
error.
Summary::new
A summary. With quantiles (pairs of target quantile and permitted error),
observations also feed a sketch so that snapshot can report those
quantiles; without them the summary carries only count and sum, as the
official clients do by default.
Summary::observe
Record one observation.
Summary::snapshot
The snapshot of this summary: the configured quantiles (empty when none were
configured), the sum, and the count.
TypedFamily
pub struct TypedFamily[L, M] {
// private fields
}A family keyed by a typed label set. Use this instead of Family when the
label combination is better expressed as a record than as an array of
strings; the record must implement LabelSet and be hashable and comparable.
impl Metric for TypedFamily[L, M]TypedFamily::clear
Drop every child.
TypedFamily::get
fn[L : Hash + Eq + LabelSet, M] TypedFamily::get(self : TypedFamily[L, M], labels : L) -> M raise RefusedThe child for labels, created if this is the first time it is seen.
TypedFamily::new
fn[L : Hash + Eq, M : Metric] TypedFamily::new(make : () -> M raise Refused) -> TypedFamily[L, M] raise RefusedA typed family, creating a child with make on first sight.
TypedFamily::points
TypedFamily::remove
Drop the child for labels if it exists.
TypedFamily::size
The number of children seen so far.
Value
The value of one series. A histogram carries its cumulative buckets, sum,
and count together so that one series stays one Point; a summary carries
its quantiles, sum, and count the same way; a state set carries every state
with its flag.
buckets
The default bucket bounds the official Prometheus clients share: 0.005
through 10, fourteen finite bounds plus the implicit +Inf bucket every
histogram has.
exemplar_label_limit
let exemplar_label_limit : IntOpenMetrics caps an exemplar's combined label names and values at 128
characters; a longer set makes the exemplar unrepresentable.
exponential
count bounds starting at start and multiplying by factor.
is_valid_label_name
fn is_valid_label_name(name : String) -> BoolWhether name is a label name under the OpenMetrics character rules:
[a-zA-Z_][a-zA-Z0-9_]*.
is_valid_metric_name
fn is_valid_metric_name(name : String) -> BoolWhether name is a metric name under the OpenMetrics character rules:
[a-zA-Z_:][a-zA-Z0-9_:]*.
is_valid_unit
fn is_valid_unit(unit : String) -> BoolWhether unit may be appended to a metric name. A unit starts with a letter
and continues with letters, digits, or underscores.
linear
count bounds starting at start and growing by width.
Install
Download zipPrometheus metrics for MoonBit.
prometheusp8smetricsopenmetricsexpositionmonitoringobservabilitytelemetrycountergaugehistogramsummaryexemplarpushgatewayclientasgimoonbit
Apache-2.0
Updated 14 hours ago
11 downloads