PCA Prometheus Certified Associate Exam Questions and Answers

The rate() function calculates the average per-second rate of increase of a counter over the specified range. It smooths out short-term fluctuations and adjusts for counter resets.

Example:

rate(http_requests_total[5m])

returns the number of requests per second averaged over the last five minutes. This function is frequently used in dashboards and alerting expressions.

To calculate a percentile (e.g., 95th percentile) from histogram data in Prometheus, the correct function is histogram_quantile() . It estimates quantiles based on cumulative bucket counts.

Example:

histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le))

This computes the 95th percentile request duration across all observed instances over the last 5 minutes.

According to Prometheus metric naming conventions , a metric name must clearly describe what is being measured and include a unit suffix that specifies the base unit of measurement, following SI standards. For durations, the suffix _seconds is mandatory.

Therefore, the correct and standards-compliant name for a metric tracking HTTP request duration is:

http_request_duration_seconds

This name communicates:

http_request → the subject being measured (HTTP requests),

duration → the aspect being measured (the latency or time taken),

_seconds → the unit of measurement (seconds).

This metric name typically corresponds to a histogram or summary , exposing submetrics such as _count, _sum, and _bucket. These represent the number of observations, total duration, and distribution across time buckets respectively.

Options A, B, and C fail to fully comply with Prometheus naming standards — they either omit the http_ prefix, use invalid separators (dots), or lack the required unit suffix.

The Prometheus Server is responsible for service discovery , which identifies the list of targets to scrape. It integrates with multiple service discovery mechanisms such as Kubernetes, Consul, EC2, and static configurations.

This allows Prometheus to automatically adapt to dynamic environments without manual reconfiguration.

Symptom-based alerting focuses on user-visible problems or service-impacting symptoms rather than low-level resource metrics. In Prometheus and Site Reliability Engineering (SRE) practices, alerts should signal conditions that affect users’ experience — such as high latency, request failures, or service unavailability — instead of merely reflecting internal resource states.

Among the options, API latency directly represents the performance perceived by end users . If API response times increase, it immediately impacts user satisfaction and indicates a possible service degradation.

In contrast, metrics like disk space , CPU usage , or database memory utilization are cause-based metrics — they may correlate with problems but do not always translate into observable user impact.

Prometheus alerting best practices recommend alerting on symptoms (via RED metrics — Rate, Errors, Duration ) while using cause-based metrics for deeper investigation and diagnosis, not for immediate paging alerts.

In Prometheus, a rule group is a logical collection of recording and alerting rules that are evaluated sequentially at a specified interval. Rule groups are defined in YAML files under the groups: key, with each group containing a name, an interval, and a list of rules.

For example:

groups:

- name: example

interval: 1m

rules:

- record: job:http_inprogress_requests:sum

expr: sum(http_inprogress_requests) by (job)

All rules in a group share the same evaluation schedule and are executed one after another. This ensures deterministic order, especially when one rule depends on another’s result.

The official Prometheus exporter for collecting system-level and kernel-related metrics from Linux and other UNIX-like operating systems is the Node Exporter .

The Node Exporter exposes hardware and OS metrics including CPU load, memory usage, disk I/O, network traffic, and kernel statistics. It is designed to provide host-level observability and serves data at the default endpoint :9100/metrics in the standard Prometheus exposition text format.

This exporter is part of the official Prometheus ecosystem and is widely deployed for infrastructure monitoring. None of the other listed options (Prometheus_exporter, metrics_exporter, or os_exporter) are official components of the Prometheus project.

Following Prometheus’s metric naming conventions , every metric should indicate:

What it measures (the quantity or event).

The unit of measurement in base SI units as a suffix.

Since the metric measures response size , the base unit is bytes . Therefore, the correct and compliant metric name is:

grpc_response_size_bytes

This clearly communicates that it measures gRPC response payload sizes expressed in bytes.

The _bytes suffix is the Prometheus-recommended unit indicator for data sizes. The other options violate naming rules:

_total is reserved for counters.

_sum is used internally by histograms or summaries.

Omitting the unit (grpc_response_size) is discouraged, as it reduces clarity.

The increase() function computes the total increase in a counter metric over a specified range vector. It accounts for counter resets and only measures the net change in the counter’s value during the time window.

Example:

increase(http_requests_total[5m])

This query returns how many HTTP requests occurred in the last five minutes. Unlike rate(), which provides a per-second average rate, increase() gives the absolute number of increments .

The correct way to expose a timestamp from an application in Prometheus is to use a gauge metric where the timestamp value (in Unix time, seconds since epoch) is stored as the metric’s value . This approach aligns with the Prometheus data model, which discourages embedding timestamps as labels or metadata.

Example:

app_last_successful_backup_timestamp_seconds 1.696358e+09

In this example, the gauge represents the timestamp of the last successful backup. The _seconds suffix indicates the unit of measurement, making the metric self-descriptive. Prometheus automatically assigns timestamps to scraped samples, so the metric’s value is treated purely as data, not as a Prometheus sample time.

Options B and D are incorrect because Prometheus does not allow arbitrary timestamps or labels for time values. Option C is incorrect since counters are monotonically increasing and not suited for discrete timestamp values.

The Prometheus Node Exporter is a core system-level exporter that exposes hardware and operating system metrics from *nix-based hosts. It collects metrics such as CPU usage, memory, disk I/O, filesystem space, network statistics, and load averages.

It runs as a lightweight daemon on each host and exposes metrics via an HTTP endpoint (default: :9100/metrics), which Prometheus scrapes periodically.

Key clarification:

It does not instrument applications (A).

It does not collect metrics directly from application HTTP endpoints (B).

It is unrelated to HTTP probing tasks — those are handled by the Blackbox Exporter (D).

Thus, the correct use of the Node Exporter is to collect and expose hardware and OS-level metrics for Prometheus monitoring.

Prometheus defines four core metric types in its official exposition format, which are: Counter , Gauge , Histogram , and Summary . These types represent the fundamental building blocks for expressing quantitative measurements of system performance, behavior, and state.

A Counter is a cumulative metric that only increases (e.g., number of requests served).

A Gauge represents a value that can go up and down, such as memory usage or temperature.

A Histogram samples observations (e.g., request durations) and counts them in configurable buckets, providing both counts and sum of observed values.

A Summary is similar to a histogram but provides quantile estimation over a sliding time window along with count and sum metrics.

These four types are the only officially supported metric types in the Prometheus text exposition format as defined by the Prometheus data model. Any additional metrics or custom naming conventions are built on top of these core types but do not constitute new types.

Prometheus provides a feature called Remote Write to transmit scraped and processed metrics to an external system for long-term storage, aggregation, or advanced analytics. When configured, Prometheus continuously pushes time series data to the remote endpoint defined in the remote_write section of the configuration file.

This mechanism is often used to integrate with long-term data storage backends such as Cortex, Thanos, Mimir, or InfluxDB, enabling durable retention and global query capabilities beyond Prometheus’s local time series database limits.

In contrast, “scraping” refers to data collection from targets, while “federation” allows hierarchical Prometheus setups (pulling metrics from other Prometheus instances) but does not serve as long-term storage. Using “S3 Buckets” directly is also unsupported in native Prometheus configurations.

A single-target exporter in Prometheus is designed to expose metrics for a specific service instance rather than multiple dynamic endpoints. The Redis Exporter is a prime example — it connects to one Redis server instance and exports its metrics (like memory usage, keyspace hits, or command statistics) to Prometheus.

By contrast, exporters like the SNMP Exporter and Blackbox Exporter can probe multiple targets dynamically, making them multi-target exporters . The Node Exporter , while often deployed per host, is considered a host-level exporter , not a true single-target one in configuration behavior.

The Redis Exporter is instrumented specifically for a single Redis endpoint per configuration, aligning it with Prometheus’s single-target exporter definition. This design simplifies monitoring and avoids dynamic reconfiguration.

Inhibition rules in Prometheus’s Alertmanager are used to suppress (mute) alerts that would otherwise be redundant when a higher-priority or related alert is already active. This feature helps avoid alert noise and ensures that operators focus on the root cause rather than multiple cascading symptoms.

For example, if a “DatacenterDown” alert is firing, inhibition rules can mute all “InstanceDown” alerts that share the same datacenter label, preventing redundant notifications. Inhibition is configured in the Alertmanager configuration file under the inhibit_rules section.

Each rule defines:

A source match (the alert that triggers inhibition),

A target match (the alert to mute), and

A match condition (labels that must be equal for inhibition to apply).

Only when the source alert is active are the target alerts silenced.