Every public name.

The default bucket bounds the official Prometheus clients share: 0.005 through 10, fourteen finite bounds plus the implicit +Inf bucket every histogram has.

OpenMetrics caps an exemplar's combined label names and values at 128 characters; a longer set makes the exemplar unrepresentable.

count bounds starting at start and multiplying by factor.

Whether name is a label name under the OpenMetrics character rules: [a-zA-Z_][a-zA-Z0-9_]*.

Whether name is a metric name under the OpenMetrics character rules: [a-zA-Z_:][a-zA-Z0-9_:]*.

Whether unit may be appended to a metric name. A unit starts with a letter and continues with letters, digits, or underscores.

count bounds starting at start and growing by width.

A point with no labels and no metadata, the shape a bare metric collects into before its registry or family adds labels.

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.

A monotonically increasing count. inc refuses a negative step because a counter that goes down is a gauge.

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).

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.

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.

A histogram with cumulative buckets. Counts are kept per bucket and made cumulative on snapshot, which is what the wire format carries.

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.

The kind of a metric, as spelled in the # TYPE line of an exposition.

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.

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.

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.

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.

The process numbers a ProcessCollector exports. The caller reads them — this library performs no I/O — which keeps the collector portable across every target.

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.

A set of named states, each true or false. A state set with exactly one true state is the Enum of the Python client.

A summary: the count and sum of the observations, plus approximate quantiles when the constructor is given target quantiles and their permitted rank error.

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.

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.

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.

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.

Escape help text. The compatibility format escapes backslash and newline; OpenMetrics also escapes the double quote, so help text survives a round trip inside a line-oriented document.

Escape a label value: backslash, double quote, and newline are backslash-escaped, every other character passes through as UTF-8.

Format a float the way the official clients do: +Inf, -Inf, and NaN by name; otherwise the shortest decimal that round-trips, with a .0 on integers and Go's switch to a two-digit exponent once the integer part is longer than six digits (so 1000000.0 is 1e+06, matching what a Prometheus scrape expects to read).

Pick a format from an HTTP Accept header. application/openmetrics-text wins when it names a version this library speaks (or names no version); otherwise a scrape gets the compatibility format, which is also the default when the header is absent or unrecognised.

Write families in the OpenMetrics text format, version 1.0.0, ending with the # EOF marker the format requires.

Parse an exposition back into families. The compatibility format is lossy for info and state sets, which it spells as gauges; OpenMetrics keeps them. The format argument selects which spelling conventions to expect, and the same parser accepts both because the syntax is a superset.

Write families in the Prometheus protobuf format: a length-delimited stream of io.prometheus.client.MetricFamily messages, the bytes a scraper reads when it answers application/vnd.google.protobuf. It shares the text formats' snapshot, so one scrape is every format. A family is named as the text format declares it, so a counter is <name>_total with its value in the counter field and an info is <name>_info; a histogram keeps its cumulative buckets, sum, and count, its +Inf bucket being the count; a summary keeps its count, sum, and quantiles; a state set is a gauge per state.

The Content-Type an HTTP response should carry for the protobuf format: the metric family the stream holds and the framing of the messages.

Write families in the Prometheus text exposition format, version 0.0.4. Counters gain a _total suffix, info becomes a gauge ending in _info, state sets become gauges, and _created, _gcount, and _gsum series are emitted as separate gauge families, as the compatibility format requires.

Whether an Accept header asks for the protobuf format. It does when any part is the media type the protobuf exposition carries; the two text formats are picked out of the header by negotiate, which never returns a protobuf.

The exposition formats this library writes and reads.

Build a DELETE that removes every series under job and grouping_key.

Build a PUT that replaces every series under job and grouping_key with the exposition of families.

Build a POST that replaces only the series named in families, leaving other series under the same job and grouping key alone.

A push gateway request: the method, the absolute URL path, the headers, and the body. The caller sends it with whatever HTTP client it has; this package never touches a socket.

A /metrics handler for a registry. GET negotiates the format from the Accept header, OPTIONS advertises the allowed methods, anything else is refused with 405, and /favicon.ico is answered empty so a browser probing the endpoint stays quiet.

A middleware that counts handled requests (http_requests, labelled by method, route, and status) and observes their duration in seconds (http_request_duration_seconds, labelled by method and route). The clock is a parameter so a test can drive time; it defaults to wall-clock seconds.

The latency buckets the legacy metric package used, in milliseconds.

A counter partitioned by one label string, the shape the legacy metric package exposed. New code should use Family[@metric.Counter]; this exists so an existing call site can move over without being rewritten.

A report request, ready for the caller to send: a POST of JSON to the reporting endpoint.

A remote writer bound to one reporting endpoint.

The request counter and latency histogram the legacy server metric set exposed: request counts labelled by request signature, and a millisecond latency histogram.

The periodic stat report the legacy remote writer posted as JSON.

Fold the parts into one set of families.

Counters and summaries add up across processes; histograms add up per bucket and are made cumulative again; a gauge follows its mode. Families come out in the order their first part mentions them, and series in the order they were first seen, so two runs over the same directory write the same bytes.

A family that two files disagree about — a name that is a counter in one process and a histogram in another, or a gauge written under two modes — is refused. The numbers would be meaningless, and a scrape that says so is better than one that quietly picks a side.

One value in one worker's file: the family it belongs to, the name the sample is written under, its labels, the family's help text, the value, and the time the value was recorded (zero when it was not recorded with one).

The pair of metric and sample is what lets a counter be filed under orders and written as orders_total, and a histogram bucket under orders_seconds and orders_seconds_bucket.

How the values of one gauge from several processes become one series.

A gauge has no natural merge — a counter can be added up, a bucket can be added up, but "requests in flight" from three workers is a policy decision. All and LiveAll keep the processes apart, one series each, labelled pid; the other four collapse them: the smallest, the largest, the sum, or the value set most recently.

The Live spellings mean the same thing at a scrape. They decide what happens when a process exits: mark_dead removes the files of a live mode, and leaves the others, which is what makes a handful of gauges forget a dead worker instead of keeping its last value forever.

One worker's file, decoded: whose it is, what kind of metric it holds, the gauge mode it was written for, and its values.

What one flush left behind: how many files it wrote, how many series they hold, and the families it could not share between processes.