PCA Dumps with Practice Exam Questions Answers

Prometheus requires that asingle metric name represents one well-defined thing, and all time series in that metricshare the same set of label keysso the value’s meaning is consistent across dimensions. The official guidance states that metrics should not “mix different dimensions under the same name,” and that a metric name should have aconsistent label schema; otherwise, “the same metric name would represent different things,” making queries ambiguous and aggregations error-prone. In the example, http_requests_total{code="…"} expressesper-status-code request counts, while http_requests_total{verb="…"} expressesper-HTTP-method request counts. Because some series have only code and others only verb, thevalue changes its meaning across label sets, violating the consistency principle for a metric family. The correct approach is to exposeone metric with both labels present on every series, e.g., http_requests_total{code="200", method="GET"}, ensuring every time series has the same label keys and the value always means “count of requests,” sliced by thesamedimensions. A missing application prefix is optional and not the core issue here.

In Prometheus, when you have multiple time series that represent the same type of measurement across different instances, thesum() aggregation operatoris used to compute their total value.

Here, each instance (1 and 2) exposes the metric apiserver_current_inflight_requests, indicating the number of active API requests currently being processed.

To find thetotal number of in-flight requests across all instances, the correct expression is:

sum(apiserver_current_inflight_requests)

This returns 5 + 7 = 12.

min() would return the lowest value (5).

max() would return the highest value (7).

sum_over_time() calculates the cumulative sumover a range vector, not the current value, so it’s incorrect here.

The fundamental difference betweenPrometheus client librariesandexporterslies inhowandwherethey are used.

Client librariesare integrated directly into theapplication’s codebase. They allow developers toinstrumenttheir own code to define and expose custom metrics. Prometheus provides official client libraries for multiple languages, including Go, Java, Python, and Ruby.

Exporters, on the other hand, arestandalone processesthat run alongside the applications or systems they monitor. They use client libraries internally to collect and expose metrics from software that cannot be instrumented directly (e.g., operating systems, databases, or third-party services). Examples include the Node Exporter (for system metrics) and MySQL Exporter (for database metrics).

Thus, exporters are typically used forexternal systems, while client libraries are used forself-instrumented applications.

The key difference between acounterand agaugein Prometheus lies in how their values change over time. Acounteris a cumulative metric thatonly increases—it resets to zero only when the process restarts. Counters are typically used for metrics like total requests served, bytes processed, or errors encountered. You can derive rates of change from counters using functions like rate() or increase() in PromQL.

Agauge, on the other hand, represents a metric that cango up and down. It measures values that fluctuate, such as CPU usage, memory consumption, temperature, or active session counts. Gauges provide a snapshot of current state rather than a cumulative total.

This distinction ensures proper interpretation of time-series trends and prevents misrepresentation of one-time or fluctuating values as cumulative metrics.

Symptom-based alertingfocuses on detectinguser-visible or service-impacting issuesrather than internal resource states. Metrics likeAPI latency,error rates, andavailabilitydirectly 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 theRED(Rate, Errors, Duration) andUSE(Utilization, Saturation, Errors) monitoring models promoted in Prometheus and SRE best practices.