Prometheus Certified Associate key terms

A stream of timestamped numeric samples identified by a metric name plus a set of label pairs. Every unique label combination forms its own separate series with its own storage and query path.

One individual data point in a time series: a float64 value paired with a millisecond-precision timestamp. Scrapes typically append one sample per series per scrape interval.

A key/value pair attached to a metric that adds dimensions such as instance, job, or status code. Labels are what allow filtering, grouping, and aggregation in queries and alerts.

The value of the special name label that identifies what a series measures, such as http_requests_total. It is matched like any other label but usually written before the braces in PromQL.

A metric type whose value only increases, or resets to zero on restart. Because raw counter values are rarely useful, they are normally queried through rate or increase functions.

A metric type representing a value that can go up or down arbitrarily, such as temperature or queue depth. Gauges are queried directly rather than through rate functions.

A metric type that counts observations into configurable buckets plus a sum and count, stored as several related series. It supports server-side quantile estimation via histogram_quantile and allows aggregation across instances.

A metric type that reports client-side computed quantiles over a sliding time window, along with sum and count. Quantiles cannot be aggregated across instances, and the configured quantiles are fixed at instrumentation time.

An optional trace or request identifier attached to a histogram or counter observation, letting you jump from a metric spike to a specific trace. Exemplars are exposed in the OpenMetrics text format.

A single HTTP GET that Prometheus performs against a target's /metrics endpoint to collect the current values of its exposed series. The result is stored with the scrape timestamp.

The configured time between consecutive scrapes of a target, set globally or per job. It bounds query resolution and determines how quickly rate windows and alerts can react to change.

The maximum time Prometheus waits for a target's response during a scrape before marking it failed. It must be shorter than the scrape interval, otherwise scrapes overlap and are skipped.

An endpoint that Prometheus scrapes, identified by an address and a set of labels such as job and instance. Targets are discovered statically or dynamically and tracked by the up metric.

The mechanism by which Prometheus finds targets dynamically from providers like Kubernetes, EC2, Consul, or DNS instead of a fixed list. Discovered metadata becomes labels available for relabeling.

Rules that rewrite, drop, or add labels on discovered targets or scraped samples before storage. relabel_configs acts on targets, while metric_relabel_configs acts on samples and is often used to drop costly series.

A named collection of targets that share a purpose and configuration, exposed as the job label. Queries and alerts commonly aggregate or filter by job to separate one workload from another.

The label identifying a specific scraped endpoint within a job, usually host:port. The instance label distinguishes replicas of the same service in queries and dashboards.

Prometheus actively fetches metrics from targets over HTTP rather than receiving pushes. This makes target health observable and centralizes scrape configuration, with a push gateway covering short-lived jobs.

An intermediary that accepts pushed metrics from jobs that cannot be scraped, such as batch jobs, and exposes them for Prometheus to pull. It never forgets series unless they are explicitly deleted.

A process that translates metrics from a system that cannot expose Prometheus format natively, such as a database or hardware device, into an HTTP endpoint Prometheus can scrape.

Adding client library code to an application so it records and exposes its own metrics. Direct instrumentation gives richer semantics than black-box exporters because it knows request and business context.

A language-specific package that registers metrics, updates them from application code, and serves them in the Prometheus exposition format. It handles counters, gauges, histograms, and summaries.

The plain-text line format in which metrics are served, one series per line as name{labels} value. A HELP and TYPE comment usually precedes each metric family.

A standardized evolution of the Prometheus exposition format that adds features such as exemplars, the info metric type, and explicit end-of-stream markers. Prometheus can negotiate it during scrapes.

The standard exporter for host-level metrics on Linux and other Unix systems, covering CPU, memory, disk, filesystem, and network statistics. It is commonly run as a systemd service or DaemonSet.

Prometheus's query language for selecting and transforming time series. It combines instant vector selectors, range vectors, functions, aggregations, and binary operators with label matching.

A query result holding at most one sample per series at a single evaluation timestamp. Most PromQL functions and all binary comparisons operate on instant vectors.

A set of samples per series over a lookback window, written with a duration in brackets such as [5m]. Range vectors cannot be graphed directly and must be passed to functions like rate.

A condition in a selector that filters series by label value using =, !=, =, or !. At least one matcher that does not match the empty string is required in every selector.

A function that computes the per-second average increase of a counter over a range vector, correctly handling counter resets. The range should span at least four scrape intervals for reliable results.

A function returning the total amount a counter grew over a range vector, equivalent to rate multiplied by the range in seconds. It extrapolates to range boundaries, so results may be fractional.

A function that computes a per-second rate from only the last two samples in a range vector. It reacts quickly to spikes but produces noisy, jumpy graphs.

A function that estimates a quantile from bucketed histogram series, grouped by the labels that define a single histogram. It interpolates within the bucket containing the target rank and is approximate.

Operators such as sum, avg, max, and count that collapse many series into fewer by grouping on chosen labels. The without or by clause decides which labels survive the operation.

The PromQL keyword, optionally followed by by or without, that reduces an instant vector across series, for example sum by (job) (rate(http_requests_total[5m])).

A rule that periodically evaluates a PromQL expression and stores the result as a new series. Recording rules precompute expensive queries and give dashboards and alerts stable, fast names.

A rule containing a PromQL expression and a for duration; when the expression returns results continuously for that duration, the alert fires. Labels and annotations define its identity and message.

A separate service that receives alerts from Prometheus and handles deduplication, grouping, inhibition, silencing, and routing to receivers such as email, chat, or incident tooling.

The clause in an alerting rule specifying how long an expression must keep returning results before the alert becomes firing. It suppresses transient blips and reduces alert noise.

An Alertmanager feature that suppresses certain alerts while a related, higher-severity alert is active, defined by source and target matchers. It prevents cascading notifications during a single incident.

A time-bounded Alertmanager rule that mutes alerts matching given label matchers, typically created during maintenance. Unlike inhibition, silences are set manually rather than triggered by other alerts.

The number of distinct time series a metric produces, driven by how many unique label combinations occur. High cardinality inflates memory and storage, so labels with unbounded values should be avoided.

How Prometheus marks a series as no longer present when it disappears from a scrape, so queries stop returning stale values. Stale markers are inserted after a target vanishes or stops exposing a series.

The window, five minutes by default, within which Prometheus looks back from an evaluation time to find the most recent sample for an instant vector selector. It keeps recent values visible between scrapes.

A Prometheus feature that lets one server scrape selected aggregated series from another server's /federate endpoint. It is typically used to build hierarchical, cross-cluster views without full data duplication.

A configuration that streams samples from Prometheus to a remote storage system over HTTP for long-term retention or centralization. It sends data as it is ingested rather than on query.

The four service health indicators: latency, traffic, errors, and saturation. They guide which metrics to instrument first and are a common structure for dashboards and alerts.

A resource-oriented checklist for host metrics: for each resource examine utilization, saturation, and errors. It complements the request-oriented golden signals when designing infrastructure monitoring.

A synthetic metric Prometheus writes for every target on each scrape, valued 1 for success and 0 for failure. It is the standard basis for target-availability alerts.