PCA Linux Foundation Prometheus Certified Associate Exam Free Practice Exam Questions (2025 Updated)

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

Whatit measures (the quantity or event).

The unitof measurement inbase SI unitsas a suffix.

Since the metric measuresresponse size, the base unit isbytes. 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.

Prometheus collects metrics byscraping an HTTP endpointexposed by the target application. Therefore, theonly essential requirementfor an application to expose metrics to Prometheus is that itserves metrics in the Prometheus text exposition format over HTTP.

This endpoint is conventionally available at /metrics and provides metrics in plain text format (e.g., Content-Type: text/plain; version=0.0.4). The application can run on any operating system, architecture, or network — as long as Prometheus can reach its endpoint.

It doesnotneed to be Internet-accessible (it can be internal) and isnot limited to Linuxor any specific bitness.

In Prometheus, arule groupis a logical collection ofrecording and alerting rulesthat areevaluated sequentiallyat 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.

Therate()function computes theper-second increaseof a counter metric over a specified range, whilesum by (label)aggregates those rates across dimensions — in this case, the cloud label.

The correct query is:

sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m]))

This expression:

Calculates the rate of increase in API requests per second for each instance.

Groups and sums those rates by cloud, giving the total request rate per cloud provider.

Option A incorrectly places by (cloud) after rate(), which is not valid syntax.

Option B returns raw counter totals (not rates).

Option D incorrectly applies rate() after aggregation, which distorts the calculation since rate() must operate on individual time series before aggregation.

Prometheus counters with labels can causemissing time seriesin queries if some label combinations have not yet been observed. To ensure visibility and continuity, therecommended best practiceis toinstantiate counters with all expected label values at application startup, even if their initial value is zero.

This ensures that every possible labeled time series is exported consistently, which helps when dashboards or alerting rules expect the presence of those series. For example, if a counter like http_requests_total{method="POST",status="200"} has not yet received a POST request, initializing it with a zero ensures it is still exposed.

Option A is incorrect — label values should never be encoded into metric names.

Option B adds redundancy and does not solve the initialization issue.

Option D is discouraged; counters should reset naturally upon restart, reflecting Prometheus’sephemeral metric model.

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

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

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

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

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

These four types are theonly officially supported metric typesin 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.

ThePrometheus naming conventionfor metrics that exposebuild or version informationabout an application binary uses the _info suffix. The standard pattern is:

_build_info

This metric typically includes constant labels such as version, revision, branch, and goversion to describe the build environment.

For example:

app_build_info{version="1.2.3", revision="abc123", goversion="go1.22"} 1

This approach follows the official Prometheus instrumentation guidelines, where metrics ending in _info convey metadata or constant characteristics about the running process.

The other options do not conform to the Prometheus best practice of suffix-based semantic naming.

When Prometheus targets arebehind firewalls or NATand cannot be reached directly by the Prometheus server’s pull mechanism, the recommended component to use isPushProx.

PushProxworks by reversing the usual pull model. It consists of aPushProx Proxy(accessible by Prometheus) andPushProx Clients(running alongside the targets). The clients establish outbound connections to the proxy, which allows Prometheus to “pull” metrics indirectly. This approach bypasses network restrictions without compromising the Prometheus data model.

Unlike the Pushgateway (which is used for short-lived batch jobs, not network-isolated targets), PushProx maintains the Prometheus “pull” semantics while accommodating environments where direct scraping is impossible.

Theincrease()function computes thetotal increase in a counter metricover 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 theabsolute number of increments.

Theevaluation_intervalparameter defines how frequently Prometheusevaluates its recording and alerting rules. It determines the schedule at which the rule engine runs, checking whether alert conditions are met and generating new time series for recording rules.

For example, setting:

global:

evaluation_interval: 30s

means Prometheus evaluates all configured rules every 30 seconds. This setting differs from scrape_interval, which controls how often Prometheus collects data from targets.

Having a proper evaluation interval ensures alerting latency is balanced with system performance.

The@ modifierin PromQL allows querying data as it existed at a specific point in time rather than the evaluation time. It can be appliedafter a selector or an entire expression, but the syntax rules are strict.

✅go_goroutines @ start() → Valid; queries value at the start of the evaluation range.

✅sum(http_requests_total{method="GET"}) @ 1609746000 → Valid; applies the modifier after the full expression.

✅go_goroutines @ end() → Valid; queries value at the end of the evaluation range.

❌sum(http_requests_total{method="GET"} @ 1609746000) →Invalid, because the @ modifier cannot appearinsidethe selector braces; it must appearafterthe selector or aggregation expression.

This invalid placement violates PromQL’s syntax grammar for subquery and modifier ordering.

Theofficial Prometheus exporterfor collecting system-level and kernel-related metrics from Linux and other UNIX-like operating systems is theNode Exporter.

TheNode Exporterexposes 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.

The metric user_last_login_timestamp_seconds{email="john.doe@example.com"} isunsuitable for Prometheusbecause it includes ahigh-cardinality label(email). Each unique email address would generate a separate time series, potentially numbering in the millions, which severely impacts Prometheus performance and memory usage.

Prometheus is optimized for low- to medium-cardinality metrics that represent system-wide behavior rather than per-user data. High-cardinality metrics causedata explosion, complicating queries and overwhelming the storage engine.

By contrast, the other metrics—prometheus_engine_query_log_enabled, promhttp_metric_handler_requests_total{code="500"}, and http_response_total{handler="static/*filepath"}—adhere to Prometheus best practices. They represent operational or service-level metrics with limited, manageable label value sets.

The fundamental difference betweenPrometheus client librariesandexporterslies inhowandwherethey are used.

Client librariesare integrated directly into theapplication’s codebase. They allow developers toinstrumenttheir own code to define and expose custom metrics. Prometheus provides official client libraries for multiple languages, including Go, Java, Python, and Ruby.

Exporters, on the other hand, arestandalone processesthat run alongside the applications or systems they monitor. They use client libraries internally to collect and expose metrics from software that cannot be instrumented directly (e.g., operating systems, databases, or third-party services). Examples include the Node Exporter (for system metrics) and MySQL Exporter (for database metrics).

Thus, exporters are typically used forexternal systems, while client libraries are used forself-instrumented applications.

TheBlackbox Exporteris the Prometheus component designed specifically forprobing endpoints over various network protocols, including HTTP, HTTPS, TCP, ICMP, and DNS. It acts as a generic probe service, allowing Prometheus to test endpoints' availability, latency, and correctness without requiring instrumentation in the target application itself.

For basicHTTP probing, the Blackbox Exporter performs HTTP GET or POST requests to defined URLs and exposes metrics like probe success, latency, response code, and SSL certificate validity. This makes it ideal for uptime and availability monitoring.

By contrast, theJMX exporteris used for collecting metrics from Java applications, theApache exporterfor Apache HTTP Server metrics, and theSNMP exporterfor network devices. Thus, only the Blackbox Exporter serves the purpose of HTTP probing.

In Prometheus,histogram metricsuse cumulative buckets to record the count of observations that fall within specific duration thresholds. Each bucket has a label le (“less than or equal to”), representing the upper bound of that bucket.

In the given metric, the bucket labeled le="0.1" has a value of1, meaning exactlyone requesttook less than or equal to 0.1 seconds. Buckets are cumulative, so:

le="0.05" → 0 requests ≤ 0.05 seconds

le="0.1" → 1 request ≤ 0.1 seconds

le="1" → 3 requests ≤ 1 second

le="+Inf" → all 3 requests total

The _sum and _count values represent total duration and request count respectively, but thenumber of requests below a given thresholdis read directly from the bucket’s le value.

Prometheus normally operates on apull-based model, where it scrapes metrics from long-running targets. However,short-lived batch jobs(such as cron jobs or data processing tasks) often finish before Prometheus can scrape them. To handle this scenario, Prometheus provides thePushgatewaycomponent.

The Pushgateway allows ephemeral jobs topush their metricsto an intermediary gateway. Prometheus then scrapes these metrics from the Pushgateway like any other target. This ensures short-lived jobs have their metrics preserved even after completion.

The Pushgateway should not be used for continuously running applications because it breaks Prometheus’s usual target lifecycle semantics. Instead, it is intended solely fortransient job metrics, like backups or CI/CD tasks.