Linux Foundation PCA Practice Exam Questions & Answers

The Four Golden Signals---Traffic, Errors, Latency, and Saturation---are key service-level indicators defined by Google's Site Reliability Engineering (SRE) discipline.

Traffic: Demand placed on the system (e.g., requests per second).

Errors: Rate of failed requests.

Latency: Time taken to serve requests.

Saturation: How ''full'' the system resources are (CPU, memory, etc.).

Prometheus and its metrics-based model are ideal for capturing these signals.

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.

Verified from Prometheus documentation -- Alertmanager Configuration -- Inhibition Rules, Alert Deduplication and Grouping, and Alert Routing Best Practices.

The evaluation_interval parameter defines how frequently Prometheus evaluates 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.

Prometheus metric naming best practices require that every metric name include a unit suffix that indicates the measurement type, where applicable. The unit should follow the base name, separated by an underscore, and must use base SI units (for example, _seconds, _bytes, _total, etc.).

In the case of http_requests_total, while the metric correctly includes the _total suffix---indicating it is a counter---it lacks a base unit of measurement (such as time, bytes, or duration). However, for event counters, _total is itself considered the unit, representing ''total occurrences'' of an event. Thus, the naming would be acceptable in strict Prometheus terms, but if this metric were measuring something like duration, size, or latency, then including a specific unit would be mandatory.

However, since the question implies that the missing unit is the issue and not the label schema, the expected answer aligns with ensuring metric names convey measurable units when applicable.

Prometheus documentation -- Metric and Label Naming Conventions, Instrumentation Best Practices, and Metric Type Naming (Counters, Gauges, and Units) sections.

In Prometheus alerting rules, the for field specifies how long a condition must remain true continuously before the alert transitions from the pending to the firing state. 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 for 5 consecutive minutes. If it returns to normal before that duration, the alert resets and never fires.

This mechanism adds stability and noise reduction to alerting systems by ensuring only sustained issues generate notifications.

Verified from Prometheus documentation -- Alerting Rules Configuration Syntax, Pending vs. Firing States, and Best Practices for Alert Timing and Thresholds 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.