Linux Foundation PCA Exam Dumps

Prometheus counters with labels can cause missing time series in queries if some label combinations have not yet been observed. To ensure visibility and continuity, the recommended best practice is to instantiate 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's ephemeral metric model.

Verified from Prometheus documentation -- Instrumentation Best Practices, Counters with Labels, and Avoid Missing Time Series by Initializing Metrics.

Symptom-based alerting focuses on detecting user-visible or service-impacting issues rather than internal resource states. Metrics like API latency, error rates, and availability directly indicate degraded user experience and are therefore the preferred triggers for alerts.

In contrast, resource-based alerts (like CPU usage or disk space) often represent underlying causes, not symptoms. Alerting on them can produce noise and distract from actual service health problems.

For example, high API latency (http_request_duration_seconds) clearly reflects that users are experiencing delays, which is actionable and business-relevant.

This concept aligns with the RED (Rate, Errors, Duration) and USE (Utilization, Saturation, Errors) monitoring models promoted in Prometheus and SRE best practices.

Verified from Prometheus documentation -- Alerting Best Practices, Symptom vs. Cause Alerting, and RED/USE Monitoring Principles.

The deriv() function in PromQL calculates the per-second derivative of a time series using linear regression over the provided time range. It estimates the instantaneous rate of change for metrics that can both increase and decrease --- which are typically gauges.

Because counters can only increase (except when reset), rate() or increase() functions are more appropriate for them. deriv() is used to identify trends in fluctuating metrics like CPU temperature, memory utilization, or queue depth, where values rise and fall continuously.

In contrast, summaries and histograms consist of multiple sub-metrics (e.g., _count, _sum, _bucket) and are not directly suited for derivative calculation without decomposition.

Extracted and verified from Prometheus documentation -- PromQL Functions -- deriv(), Understanding Rates and Derivatives, and Gauge Metric Examples.

By default, Prometheus stores its time series data in a local, embedded Time Series Database (TSDB) on disk. The data is organized in block files under the data/ directory inside Prometheus's storage path.

Each block typically covers two hours of data, containing chunks, index, and metadata files. Older blocks are compacted and deleted based on retention settings.

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.