README- UCounter
- UEntry
- UExemplar
- UFamily
- UFormat
- UGauge
- UGaugeHistogram
- UHistogram
- UInfo
- UKind
- ULabelSet
- ULocalCounter
- UMetricFamily
- UMode
- UNative
- UPart
- UPoint
- UProcessCollector
- UProcessStats
- UPushRequest
- URegistry
- USparse
- UStateSet
- USummary
- UTypedFamily
- UValue
- Vapp
- Vbuckets
- Vdelete
- Vexemplar_label_limit
- Vexponential
- Vexponential_range
- Vformat_float
- Vis_valid_label_name
- Vis_valid_metric_name
- Vis_valid_unit
- Vlinear
- Vmerge
- Vmiddleware
- Vnative
- Vnegotiate
- Vopenmetrics
- Vprotobuf
- Vprotobuf_content_type
- Vpush
- Vpush_add
- Vtext
- Vwants_protobuf
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.
A reset is a new series, so the creation time is the reset's: passing none
clears it rather than leaving the old one in place, which would claim the
restarted counter started when the old one did.
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. With native
it also keeps native buckets, or only those when no classic buckets were asked
for.
Histogram::new
A histogram over buckets. Without buckets it uses the shared defaults, or none at
all when native is given, which is what client_golang does with a bucket factor and no
bucket list. native adds native buckets with those settings; clock is the time in Unix
seconds the native buckets' resets are measured by, the system clock 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, and in its native bucket.
NaN counts in the sum and the count but in no native bucket.
Histogram::snapshot
The snapshot of this histogram: cumulative bucket counts, the sum, and the
total count, with the retained exemplars, and the native buckets when it keeps them.
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.
Native
How a histogram keeps native buckets. Passed to Histogram::new as native, it adds them
beside the classic buckets, or replaces those when no classic buckets are given.
- factor: the largest ratio between the bounds of neighbouring buckets; the schema is the coarsest one that keeps within it. Must be above 1.
- zero_threshold: observations whose absolute value is at most this go to the zero bucket.
- max_buckets: once more buckets than this are populated, the histogram is reset if min_reset seconds have passed since the last reset, else the zero bucket is widened up to max_zero_threshold, else every bucket is made twice as wide. 0 is no limit.
- min_reset: seconds between resets; 0 never resets. A widened or coarsened histogram goes back to its first resolution once this has passed.
- max_exemplars, exemplar_ttl: how many exemplars the native buckets keep, and after how many seconds an old one is the first to go; max_exemplars 0 keeps none.
Native::new
native with the settings named here changed.
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. buckets and native are as
Histogram::new takes them.
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.
Sparse
The native buckets of a histogram at one moment. positive and negative hold the
populated buckets as (key, count) in key order, bucket key covering
(2^((key-1)/2^schema), 2^(key/2^schema)] on its side; zero_count counts the observations
within zero_threshold of zero; exemplars are the ones kept for the native buckets.
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
pub(all) enum Value {
Number(Double)
Buckets(buckets~ : Array[(Double, Int64)], sum~ : Double, count~ : Int64)
Native(buckets~ : Array[(Double, Int64)], sparse~ : Sparse, sum~ : Double, count~ : Int64)
Quantiles(quantiles~ : Array[(Double, Double)], sum~ : Double, count~ : Int64)
State(states~ : Array[(String, Bool)])
}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.
exponential_range
count bounds from low to high, each a fixed multiple of the one before,
the multiple chosen so the last is high: high / low to the power
1 / (count - 1). Two bounds are the least that names a range, and a range
that does not grow is refused rather than returned as a row of equal bounds.
This is for the case where the interesting span is known and the ratio
between steps is not: a request that answers in milliseconds or in seconds
wants exponential_range(0.001, 60.0, 12), not a factor picked by hand.
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.
native
The settings a native histogram starts from. factor 1.1 is the trade-off client_golang's
documentation recommends (eight buckets per power of two); zero_threshold is its default,
2^-128; max_buckets 100 and min_reset fifteen minutes are what its native histogram
example sets, since an unlimited bucket count lets wide-spread input grow the histogram
without end; max_zero_threshold 0 never widens the zero bucket, its default; ten
exemplars kept for five minutes are its defaults.
Install
Download zipPrometheus metrics for MoonBit.
prometheusp8smetricsopenmetricsexpositionmonitoringobservabilitytelemetrycountergaugehistogramsummaryexemplarpushgatewayclientasgiprotobufprotobuf-exportdelimitedscrapecollectormoonbit
Apache-2.0
Updated 7 hours ago
1K downloads