Linux Foundation PCA Practice Exam Questions & 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.

The @ modifier in PromQL allows querying data as it existed at a specific point in time rather than the evaluation time. It can be applied after 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 appear inside the selector braces; it must appear after the selector or aggregation expression.

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

Verified from Prometheus documentation -- PromQL @ Modifier Syntax, Evaluation Modifiers, and PromQL Expression Grammar sections.

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.

Verified from Prometheus documentation -- Instrumentation Best Practices (Exposing Timestamps), Gauge Metric Semantics, and Metric Naming Conventions -- _seconds suffix.

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.

Verified from Prometheus documentation -- Rule Configuration, Rule Groups and Evaluation Order, and Recording & Alerting Rules Guide.

When Prometheus targets are behind firewalls or NAT and cannot be reached directly by the Prometheus server's pull mechanism, the recommended component to use is PushProx.

PushProx works by reversing the usual pull model. It consists of a PushProx Proxy (accessible by Prometheus) and PushProx 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.

Verified from Prometheus documentation and official PushProx design notes -- Monitoring Behind NAT/Firewall, PushProx Overview, and Architecture and Usage Scenarios sections.

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.

Verified from Prometheus documentation -- Node Exporter Overview, System Metrics Collection, and Official Exporters List.

In Prometheus best practices, high-cardinality labels---especially those containing unique or user-specific identifiers---should be avoided. The metric myapp_filG_uploads_total{userid='5123',status='failed'} exposes the userid as a label, which is problematic. Each distinct value of a label generates a new time series in Prometheus. If there are thousands or millions of unique users, this would exponentially increase the number of time series, leading to cardinality explosion, degraded performance, and high memory usage.

The _total suffix is actually correct and required for counters, as per the Prometheus naming convention. The use of underscores in metric names is also correct, as Prometheus does not support dashes in metric identifiers. The status label, however, is perfectly valid because it typically has a low number of possible values (e.g., ''success'', ''failed'').

Verified from Prometheus official documentation sections Instrumentation -- Metric and Label Naming Best Practices and Writing Exporters.