Linux Foundation Prometheus Certified Associate Exam PCA Exam Dumps: Updated Questions & Answers (October 2025)

PromQL supportsregular expression matchingfor label values using the =~ operator. To select all time series whose label values match a given regex pattern, you use the syntax {label_name=~"regex"}.

In this case, to select all up metrics where the instance label begins with fe-, the correct query is:

up{instance=~"fe-.*"}

Explanation of operators:

= → exact match.

!= → not equal.

=~ → regex match.

!~ → regexnotmatch.

Option D uses the correct =~ syntax. Options A and B use invalid PromQL syntax, and option C is almost correct but includes a misplaced extra quote style (~’’), which would cause a parsing error.

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.

TheSilencefeature in Alertmanager allows operators tomute specific alertsfor a defined period. Each silence includes a matcher (labels), a creator, a comment, and an expiration time.

Silencing is useful during maintenance windows or known outages to prevent alert noise. Unlike inhibition, silences are manual and explicit.

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.

In Prometheus, histograms and summaries expose metrics with _sum and _count suffixes to represent total accumulated values and sample counts, respectively. To compute theaverage request durationover a given time window (for example, 5 minutes), you divide the rate of increase of _sum by the rate of increase of _count:

\text{Average duration} = \frac{\text{rate(http_request_duration_seconds_sum[5m])}}{\text{rate(http_request_duration_seconds_count[5m])}}

Here,

http_request_duration_seconds_sum represents the total accumulated request time, and

http_request_duration_seconds_count represents the number of requests observed.

By dividing these rates, you obtain the average request duration per request over the specified time range.

Symptom-based alertingfocuses onuser-visible problemsorservice-impacting symptomsrather than low-level resource metrics. In Prometheus and Site Reliability Engineering (SRE) practices, alerts should signal conditions that affect users’ experience — such ashigh latency, request failures, or service unavailability— instead of merely reflecting internal resource states.

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

In contrast, metrics likedisk space,CPU usage, ordatabase memory utilizationarecause-based metrics— they may correlate with problems but do not always translate into observable user impact.

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

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.

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.

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.

In Prometheus alerting rules, theforfield specifies how long a condition must remaintrue continuouslybefore the alert transitions from thependingto thefiringstate. This feature prevents transient spikes or brief metric fluctuations from triggering false alerts.

Example:

alert: HighRequestLatency

expr: http_request_duration_seconds_avg > 1

for: 5m

labels:

severity: warning

annotations:

description: "Request latency is above 1s for more than 5 minutes."

In this configuration, Prometheus evaluates the expression every rule evaluation cycle. The alert only fires if the condition (http_request_duration_seconds_avg > 1) remains true for5 consecutive minutes. If it returns to normal before that duration, the alert resets and never fires.

This mechanism addsstability and noise reductionto alerting systems by ensuring only sustained issues generate notifications.