PCA Exam Dumps and Practice Questions

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.

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.

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.

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.

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.