Free PCA Practice Test

The histogramquantile() function is the specific PromQL function used to calculate the φ-quantile from a histogram. It takes two arguments: the desired quantile (a float between 0 and 1) and an instant vector containing the histogram's bucket counts (the time series with the bucket suffix). It then computes the estimated value at that quantile, allowing users to calculate metrics like the 95th percentile request latency from a histogram metric.

histogram() is not a valid PromQL function; it refers to a metric type used for tracking distributions of observations. predictlinear() is a forecasting function that predicts the future value of a time series based on its past behavior, not for quantile calculation. avgovertime() calculates the average value of a time series over a specified time interval, not a quantile from a histogram's distribution.

1. Prometheus Authors. (n.d.). Querying functions. Prometheus Documentation. Retrieved from https://prometheus.io/docs/prometheus/latest/querying/functions/#histogramquantile

Reference Details: The section titled "histogramquantile()" explicitly states: "histogramquantile(φ float64, b instant-vector) calculates the φ-quantile (0 ≤ φ ≤ 1) from the buckets b of a histogram." This documentation also confirms the purpose of predictlinear() and avgovertime() in their respective sections.

2. Cloud Native Computing Foundation. (n.d.). Monitoring with Prometheus. Linux Foundation Training.

Reference Details: In the LFS241 - Monitoring Systems and Services with Prometheus course materials, Module 6, "PromQL," covers the usage of aggregation and query functions. The histogramquantile() function is detailed as the primary method for calculating percentiles from histogram metrics, which is a core concept for the PCA certification.

In Prometheus Query Language (PromQL), time series are filtered using label selectors. To filter based on a regular expression match, the =~ operator is used. The query up{instance=~"fe-."} correctly selects all time series with the metric name up where the instance label value matches the regular expression fe-.. This expression matches any instance label that starts with the string "fe-".

A. regexp() is not a valid function or operator for label matching within a PromQL selector block.
B. The = operator performs an exact string match, so it would look for a label literally named "fe-.".
C. The ~ operator is not a valid label matching operator in PromQL syntax.

1. Prometheus Official Documentation, "Querying Prometheus - Selectors": This document explicitly defines the label matching operators available in PromQL. It states: "=~: Select labels that regex-match the provided string." This directly supports the use of =~ for the required regular expression matching. The documentation is available at: https://prometheus.io/docs/prometheus/latest/querying/basics/#time-series-selectors (Section: Time series Selectors).

2. University of Washington, CSE 451: Introduction to Operating Systems, "Monitoring" Lecture Slides: Course materials on system monitoring often cover Prometheus. Slide 23 of the "Monitoring" lecture deck details PromQL queries and explicitly lists =~ as the operator for "matches regex". This confirms its use in an academic context. (Reference: https://courses.cs.washington.edu/courses/cse451/21au/lectures/23-monitoring.pdf, Slide 23).

The Blackbox exporter is specifically designed for "blackbox" probing of endpoints. It allows Prometheus to monitor external-facing services over various protocols, including HTTP, HTTPS, DNS, TCP, and ICMP. For basic HTTP probing, it can be configured to check an endpoint's availability, measure response time, verify SSL certificates, and validate HTTP status codes or response body content. This makes it the ideal tool for assessing service health from a user's perspective, which is the core of HTTP probing. The other exporters are designed for "whitebox" monitoring of specific technologies.

A. JMX exporter: This is used to expose metrics from Java applications via the Java Management Extensions (JMX) framework, not for network probing.
C. Apache exporter: This scrapes internal performance metrics specifically from an Apache web server's modstatus module, not for general HTTP endpoint probing.
D. SNMP exporter: This is used to monitor network devices and other systems that expose data via the Simple Network Management Protocol (SNMP).

1. Prometheus Official Documentation, "Blackbox Probing": The official documentation explicitly states, "The Blackbox exporter allows blackbox probing of endpoints over HTTP, HTTPS, DNS, TCP and ICMP." This directly aligns with the question's requirement for HTTP probing.

Source: Prometheus Authors. (n.d.). Probing. Prometheus Documentation. Retrieved from https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrapeconfig, Section: , subsection on relabeling for blackbox.

2. Blackbox Exporter Official Repository: The primary documentation for the exporter confirms its purpose.

Source: prometheus/blackboxexporter GitHub Repository. (n.d.). README.md. "The blackbox exporter allows blackbox probing of endpoints over HTTP, HTTPS, DNS, TCP and ICMP."

3. JMX Exporter Official Repository: The documentation clarifies its specific use case for Java applications.

Source: prometheus/jmxexporter GitHub Repository. (n.d.). README.md. "A collector that can be configured to scrape and expose MBeans of a JMX target."

4. SNMP Exporter Official Repository: The documentation defines its role in monitoring SNMP-enabled devices.

Source: prometheus/snmpexporter GitHub Repository. (n.d.). README.md. "This exporter scrapes SNMP metrics from devices."

PushProx is a specialized component designed to allow Prometheus to scrape targets that are not directly reachable, such as those behind a firewall or NAT. It works by having a pushprox-client on the target's network initiate a long-lived outbound connection to a pushprox-proxy. The Prometheus server, which can reach the proxy, sends its scrape request to the proxy. The proxy then forwards this request over the pre-established connection to the client, which collects the metrics from the target and sends them back. This effectively reverses the connection initiation direction, enabling the standard pull model across restrictive network boundaries.

A. Pull Proxy: This is a generic term, not a specific, officially named Prometheus component designed to solve the problem of traversing firewalls.
B. Pull Gateway: The component for a push-based model is the Pushgateway, not "Pull Gateway". It is designed for ephemeral or batch jobs, not for network traversal.
C. HA Proxy: This is a general-purpose load balancer and proxy server. While it can be used in a monitoring stack, it is not the specific tool designed for this Prometheus use case.

1. Prometheus Community - PushProx Repository: The official README for the PushProx project explicitly states its purpose.

Source: Prometheus GitHub Organization, pushprox repository.

Reference: "PushProx is a client and proxy that allows Prometheus to scrape targets that are behind a firewall or in a different network." (From the main README.md file, first paragraph).

Link: https://github.com/prometheus/pushprox

2. Prometheus Documentation - When to use the Pushgateway: The official Prometheus documentation clarifies the use case for the Pushgateway, distinguishing it from the problem PushProx solves.

Source: Official Prometheus Documentation.

Reference: "The Pushgateway is an intermediary service which allows you to push metrics from jobs that cannot be scraped... We only recommend using the Pushgateway in certain limited cases... for service-level metrics, the Pushgateway is not a good fit." This highlights its purpose for ephemeral jobs, not network traversal.

Link: https://prometheus.io/docs/practices/pushing/

The nodeexporter is the official and most widely used Prometheus exporter for gathering hardware and operating system metrics from NIX kernels, including Linux. It is designed to expose a wide variety of system-level statistics, such as CPU utilization, memory usage, disk I/O, and network traffic. In the Prometheus ecosystem, the term "node" is a synonym for a host or machine, hence the name nodeexporter. It is a standalone binary that runs on the target machine to collect and expose these metrics over HTTP for a Prometheus server to scrape.

A. Prometheusexporter is a generic descriptor for any exporter compatible with Prometheus, not the specific name of the official OS metrics exporter.
C. metricsexporter is a functional description, not a specific product name. Many tools could be described this way, but it is not the official name.
D. osexporter is a plausible but incorrect name. The official tool is named nodeexporter to signify it exports metrics from a machine (node).

1. Prometheus Official Documentation: The official GitHub repository for the project explicitly names it nodeexporter and describes its purpose.

Source: Prometheus Community. (n.d.). prometheus/nodeexporter. GitHub.

Reference: README.md, "Prometheus exporter for hardware and OS metrics exposed by NIX kernels." Retrieved from https://github.com/prometheus/nodeexporter

2. Prometheus Official Guides: The official setup guide for monitoring Linux hosts directly specifies the use of nodeexporter.

Source: Prometheus.io. (n.d.). Monitoring a Linux host with the Node Exporter.

Reference: Section "Installing and running the Node Exporter". Retrieved from https://prometheus.io/docs/guides/node-exporter/

3. University Courseware: Reputable university courses on distributed systems and cloud computing reference nodeexporter as the standard tool for host-level metric collection.

Source: University of Tartu, Institute of Computer Science. (2023). Distributed Systems (MTAT.08.021).

Reference: Lab 10: Monitoring, "The most common way to get system metrics (CPU, memory, disk, network) is to use the nodeexporter." Retrieved from https://courses.cs.ut.ee/2023/ds/spring/Main/Lab10-Monitoring

The histogramquantile() function is specifically designed in Prometheus Query Language (PromQL) to calculate quantiles from histogram buckets. The query histogramquantile(0.95, sum(rate(httprequestdurationsecondsbucket[5m])) by (le)) correctly follows the required pattern. It first calculates the per-second rate of observations in each bucket over a 5-minute window using rate(). Then, sum(...) by (le) aggregates these rates across different instances while preserving the bucket boundary (le) label, which is essential for the quantile calculation. Finally, histogramquantile() takes this aggregated data and the desired quantile (0.95) to compute the 95th percentile value.

A. quantileovertime calculates a quantile over a time range for a gauge metric, not from the distribution provided by a histogram's buckets.
C. percentile() is not a valid function in the standard Prometheus Query Language (PromQL).
D. topk is used to select the top 'k' time series by value; it does not compute statistical percentiles from a data distribution.

1. Prometheus Authors. (n.d.). Querying functions | Prometheus Documentation.

Section: histogramquantile(φ float64, b instant-vector)

Details: The official documentation explicitly states, "Calculates the φ-quantile (0 ≤ φ ≤ 1) from the buckets b of a histogram." It provides the canonical example: histogramquantile(0.9, sum(rate(httprequestdurationsecondsbucket[10m])) by (le)), which directly supports the structure of the correct answer (B).

2. Prometheus Authors. (n.d.). Metric types | Prometheus Documentation.

Section: Histogram

Details: This document explains the structure of a histogram metric, including the bucket{le="..."} time series. It clarifies that to calculate quantiles, one must use the histogramquantile() function on the bucket series, reinforcing why option B is the correct approach.

3. Prometheus Authors. (n.d.). Querying functions | Prometheus Documentation.

Section: quantileovertime(φ float64, q range-vector)

Details: The documentation for quantileovertime confirms it calculates the φ-quantile over the values in a range vector, which is fundamentally different from calculating a quantile from a histogram's distribution of observations. This supports why option A is incorrect.

The goal is to compute the rate of requests aggregated by the cloud label. The correct approach is to first calculate the per-second rate for each individual time series using rate(apiserverrequesttotal[5m]). This function operates on the apiserverrequesttotal counter over a 5-minute window. The result is an instant vector of rates. Subsequently, the sum() by (cloud) aggregation operator is applied to this vector of rates. This sums up the rates for all instances belonging to the same cloud provider, effectively giving the total request rate per cloud.

A. rate(apiserverrequesttotal{job="kube-apiserver"}[5m]) by (cloud) This is syntactically incorrect. The by (cloud) clause is a modifier for an aggregation operator (like sum or avg), not for the rate() function itself.
B. sum by (cloud) (apiserverrequesttotal{job="kube-apiserver"}) This query sums the raw counter values, not their rate of change. It would return the total number of requests at a single point in time, which is not a rate.
D. rate(sum by (cloud)(apiserverrequesttotal{job="kube-apiserver"})[5m]) This is syntactically incorrect. The range vector selector [5m] can only be applied to an instant vector selector (e.g., a metric name), not to the output of an aggregation function like sum().

1. Prometheus Official Documentation, "Querying basics": This document explains the different selector types. It clarifies that a range-vector selector [5m] is appended to an instant-vector selector to select a range of samples. This invalidates option D, where [5m] is applied to a function's output.

Source: Prometheus Documentation, Querying, Basics. Section: "Range Vector Selectors".

2. Prometheus Official Documentation, "Querying functions": The documentation for the rate() function states that it "calculates the per-second average rate of increase of the time series in the range vector." This confirms rate() is the correct function to use on a counter metric like apiserverrequesttotal.

Source: Prometheus Documentation, Querying, Functions. Section: "rate()".

3. Prometheus Official Documentation, "Querying operators": This page details aggregation operators. It shows the correct syntax is by () (), such as sum by (cloud) (...). This confirms that the aggregation in option C is performed correctly on the result of the rate() function.

Source: Prometheus Documentation, Querying, Operators. Section: "Aggregation operators".

The @ modifier in PromQL is used to change the evaluation time for an expression. When used with aggregation operators such as sum(), the canonical and syntactically correct method is to apply the modifier to the entire aggregation expression. The expression sum(httprequeststotal{method="GET"}) @ 1609746000 correctly evaluates the sum() function as if the current time were the specified timestamp. The syntax in option D, sum(httprequeststotal{method="GET"} @ 1609746000), which places the @ modifier on the instant vector selector inside the aggregation function, is not the standard syntax for this operation and is considered invalid.

A. This is a valid expression. The start() function is used with the @ modifier to evaluate the expression at the start time of a range query.
B. This is the correct and valid syntax for evaluating an aggregation at a specific Unix timestamp. The @ modifier is correctly applied to the entire sum() expression.
C. This is a valid expression. The end() function is used with the @ modifier to evaluate the expression at the end time of a range query.

1. Prometheus Official Documentation, "Querying > Basics", @ modifier section. This section outlines the primary uses of the @ modifier. It can be applied to an instant vector selector (metric @ timestamp) or to a full expression. For aggregations, the standard is to apply it to the entire expression to set the evaluation time for the whole operation, as shown in option B. The syntax in option D is non-canonical for aggregations.

Source: https://prometheus.io/docs/prometheus/latest/querying/basics/#modifier

2. Prometheus Official Documentation, "Querying > Operators", "Aggregation operators" section. The syntax for aggregation operators is defined as aggr-op([parameter,] ). This implies that modifiers which affect the evaluation time of the entire operation, like @, should be applied to the complete aggr-op(...) construct, not to the argument within it.

Source: https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators

The delta() function in PromQL calculates the difference between the first and last value of each time series in a specified time range. This function is specifically designed for the Gauge metric type, which represents a numerical value that can arbitrarily go up and down, such as temperature or current memory usage. For example, delta(cputempcelsius[2h]) calculates how much the CPU temperature has changed over the last two hours. For Counter metrics, which only increase, the increase() function is the appropriate choice as it correctly handles counter resets.

A. Info: This is a synthetic metric type used to expose textual information; it is not a numerical time series and cannot be used with delta().
B. Histogram: This is a complex type for observing distributions. Its underlying components (sum, bucket) are counters, for which increase() is the correct function.
D. Counter: The increase() function should be used for counters as it is designed to handle resets gracefully, whereas delta() is not.

1. Prometheus Authors. (n.d.). Querying functions. Prometheus Documentation. Retrieved from https://prometheus.io/docs/prometheus/latest/querying/functions/#delta

Reference detail: The documentation explicitly states, "delta should only be used with gauges."

2. Prometheus Authors. (n.d.). Metric types. Prometheus Documentation. Retrieved from https://prometheus.io/docs/concepts/metrictypes/

Reference detail: This page defines the four metric types. It describes a Gauge as a value that "can arbitrarily go up and down," which aligns with the use case for delta(). It also specifies that for Counters, one should "use rate() to calculate the per-second average rate of increase," and by extension, increase() for the total increase.

The primary issue with the metric myappfilGuploadstotal{userid=,,5123",status="failed"} is the use of userid as a label. User IDs are considered high-cardinality labels because they can have a vast and unbounded number of unique values (one for each user). In Prometheus, every unique combination of a metric name and its labels creates a new time series. Using high-cardinality labels like userid leads to a "cardinality explosion," which drastically increases memory consumption, storage requirements, and query latency on the Prometheus server, potentially making it unstable. Best practices strongly advise against using identifiers with high or unbounded cardinality as labels.

B. The status label is appropriate. It has low cardinality (a small, finite set of values like "success" or "failed"), which is ideal for filtering and aggregation.
C. The total suffix is a standard and recommended naming convention for counter metrics in Prometheus, clearly indicating that the metric is a cumulative count.
D. Prometheus naming conventions require underscores () as separators in metric names. Dashes (-) are invalid characters for metric names and are treated as operators in PromQL.

1. Prometheus Official Documentation, Best Practices, "Metric and label naming":

CAUTION: Remember that every unique combination of key-value label pairs represents a new time series, which can dramatically increase the amount of data stored. Do not use labels to store dimensions with high cardinality (many different label values), such as user IDs, email addresses, or other unbounded sets of values.

(Source: Prometheus Authors, "Metric and label naming," Prometheus Documentation. Accessed from: https://prometheus.io/docs/practices/naming/)

2. Prometheus Official Documentation, Concepts, "Data model":

Metric names may contain ASCII letters and digits, as well as underscores and colons. It must match the regex [a-zA-Z:][a-zA-Z0-9:].

This confirms that dashes are not permitted in metric names.

(Source: Prometheus Authors, "Data model," Prometheus Documentation. Accessed from: https://prometheus.io/docs/concepts/datamodel/#metric-names-and-labels)

3. Borg, Omega, and Kubernetes: Lessons learned from three container-management systems (Academic Publication): While discussing monitoring in large-scale systems, the principles of avoiding high-cardinality dimensions are foundational. The paper notes the importance of aggregation: "Most metrics are aggregated... losing per-task details." This aligns with the principle of not using per-instance identifiers like userid as labels.

(Source: Verma, A., Pedrosa, L., et al. (2015). Borg, Omega, and Kubernetes. ACM Queue, 13(7), Section: "Monitoring". DOI: https://doi.org/10.1145/2898442.2898444)