Prometheus Certified Associate (PCA) — Questions and Answers

Question 1: What is the significance of the `_bucket`, `_sum`, and `_count` suffixes automatically created for a Prometheus Histogram?

They are required labels for histogram queries only
They are optional metadata fields for histogram configuration
They represent minimum, average, and maximum values respectively
They are the three separate time series Prometheus stores for every histogram metric (Correct answer)

Correct answer: They are the three separate time series Prometheus stores for every histogram metric

Prometheus automatically creates three time series for each histogram: `_bucket` (cumulative counts per bucket), `_sum` (total sum of observations), and `_count` (total number of observations).

Question 2: What does the `remote_read` configuration in Prometheus enable?

Fetching recording rules from a remote API
Querying historical data from a remote storage backend when local data is unavailable (Correct answer)
Importing Grafana dashboards remotely
Reading scrape targets from a remote file server

Correct answer: Querying historical data from a remote storage backend when local data is unavailable

remote_read allows Prometheus to transparently query an external long-term storage system for data that is no longer in local storage.

Question 3: Which function correctly calculates the per-second rate of increase of a counter over the last 5 minutes, accounting for resets?

increase(metric[5m])
delta(metric[5m])
rate(metric[5m]) (Correct answer)
irate(metric[5m])

Correct answer: rate(metric[5m])

`rate()` computes the per-second average rate of increase over the specified range, handling counter resets automatically.

Question 4: Which PromQL function would you use to detect a sudden spike in a metric's rate compared to the same time yesterday?

deriv()
holt_winters()
predict_linear()
rate() with offset modifier (Correct answer)

Correct answer: rate() with offset modifier

Using rate() combined with the offset modifier (e.g., rate(metric[5m] offset 1d)) lets you compare current behavior against the same window 24 hours ago.

Question 5: An inhibition rule in Alertmanager has `source_match: {severity: 'critical'}` and `target_match: {severity: 'warning'}`. What happens when a critical alert fires?

Warning alerts are promoted to critical
Warning alerts matching the target are suppressed (Correct answer)
The critical alert is silenced automatically
Both critical and warning alerts are routed to the same receiver

Correct answer: Warning alerts matching the target are suppressed

Inhibition rules suppress (mute) target alerts when a matching source alert is firing, reducing redundant notifications.

Question 6: What is the primary role of a Prometheus exporter?

Generating alerting rules automatically
Translating third-party system metrics into Prometheus exposition format (Correct answer)
Storing time-series data long-term
Sending metrics directly to Grafana

Correct answer: Translating third-party system metrics into Prometheus exposition format

Exporters bridge systems that don't natively expose Prometheus metrics by collecting data from them and serving it in the Prometheus text exposition format.

Question 7: Which Prometheus internal component evaluates recording and alerting rules at regular intervals?

Rule evaluation engine (Correct answer)
WAL (Write-Ahead Log)
Retrieval (scrape loop)
Notifier queue

Correct answer: Rule evaluation engine

Prometheus's rule evaluation engine runs at a configurable interval (evaluation_interval) and computes rule results, storing them or forwarding alerts.

Question 8: What role does the Prometheus service discovery mechanism play in the architecture?

It compresses TSDB blocks
It routes alerts to receivers
It dynamically finds scrape targets without static configuration (Correct answer)
It stores alert rules

Correct answer: It dynamically finds scrape targets without static configuration

Service discovery (e.g., Kubernetes SD, Consul SD) allows Prometheus to automatically detect and update scrape targets as infrastructure changes.

Question 9: Which open-source project extends Prometheus with global query capability and long-term object storage integration?

Thanos (Correct answer)
OpenTelemetry Collector
Jaeger
Loki

Correct answer: Thanos

Thanos adds a sidecar to Prometheus that uploads blocks to object storage (e.g., S3, GCS) and provides a global query layer across multiple Prometheus instances.

Question 10: An Alertmanager route has `group_wait: 30s` and `group_interval: 5m`. A second alert fires in the same group 10 seconds after the first. When will the second alert be sent?

After its own 30s group_wait starts independently
Immediately, because it is a new alert
After the 5m group_interval elapses from the first notification
Together with the first alert after the 30s group_wait expires (Correct answer)

Correct answer: Together with the first alert after the 30s group_wait expires

Alerts in the same group are batched together; the second alert joins the existing group and is sent when the group_wait of 30s expires.

Question 11: What does Prometheus TSDB compaction do?

Merges and deduplicated smaller blocks into larger, more efficient blocks (Correct answer)
Aggregates metrics across multiple Prometheus instances
Compresses WAL files to reduce RAM usage
Converts text exposition format to binary

Correct answer: Merges and deduplicated smaller blocks into larger, more efficient blocks

Compaction merges multiple small blocks into larger ones and removes deleted or out-of-order samples to improve query efficiency.

Question 12: What does the `address` label represent in Prometheus service discovery?

The metric namespace prefix
The alertmanager endpoint
The host:port of the scrape target (Correct answer)
The Prometheus server's own address

Correct answer: The host:port of the scrape target

The __address__ label holds the host:port string that Prometheus will use to scrape a target.

Question 13: How can Prometheus scrape targets that require HTTP Basic Authentication?

By setting AUTH_USER and AUTH_PASS environment variables
By specifying basic_auth with username and password in the scrape_config (Correct answer)
By using a pre-shared key in tls_config
By encoding credentials in the target URL

Correct answer: By specifying basic_auth with username and password in the scrape_config

The basic_auth block in scrape_configs allows Prometheus to send HTTP Basic Authentication headers to protected targets.

Question 14: What does the `up` metric in Prometheus indicate?

Whether the Prometheus server itself is running
The health status of Alertmanager
The uptime in seconds of the Prometheus process
Whether each scrape target was successfully scraped (1) or failed (0) (Correct answer)

Correct answer: Whether each scrape target was successfully scraped (1) or failed (0)

Prometheus automatically generates the up metric for each scrape target, setting it to 1 on success and 0 on failure.

Question 15: In Prometheus, what does the `le` label represent in a histogram metric?

Label expression
Log exponent
Less than or equal to bucket boundary (Correct answer)
Label encoding

Correct answer: Less than or equal to bucket boundary

The `le` label in histograms denotes the upper inclusive bound ('less than or equal to') for each bucket.

Question 16: In Alertmanager, what is the difference between `resolve_timeout` and the `for` clause in a Prometheus alerting rule?

resolve_timeout is set in Prometheus; for is set in Alertmanager
for controls when an alert fires; resolve_timeout controls how long Alertmanager waits before marking it resolved (Correct answer)
for applies only to critical alerts; resolve_timeout applies to all severities
They are identical; one is an alias of the other

Correct answer: for controls when an alert fires; resolve_timeout controls how long Alertmanager waits before marking it resolved

The for clause in Prometheus determines how long a condition must be true before alerting, while resolve_timeout in Alertmanager sets how long to wait after the condition clears before sending a resolution notification.

Question 17: What does the `_bucket` suffix on a Histogram metric represent?

The raw storage bucket in TSDB where histogram data is written
A cumulative count of observations that fall at or below each configured upper bound (le label) (Correct answer)
A bucketed summary of quantile values for the histogram
The total number of histogram bins defined in the instrumentation code

Correct answer: A cumulative count of observations that fall at or below each configured upper bound (le label)

Each _bucket series has an le (less than or equal) label representing an upper bound; its value is the cumulative count of observations at or below that bound.

Question 18: What OAuth2 configuration capability does Prometheus support natively in scrape_configs?

Authorization code flow for user-facing authentication
SAML-based federated identity for scrape targets
Client credentials flow to obtain a bearer token before scraping (Correct answer)
PKCE-secured token exchange for dashboards

Correct answer: Client credentials flow to obtain a bearer token before scraping

Prometheus's oauth2 block supports the client credentials grant, allowing it to fetch access tokens to authenticate against protected scrape endpoints.

Question 19: What is the role of the Prometheus Pushgateway?

Aggregate metrics from multiple Prometheus servers
Allow short-lived batch jobs to expose metrics to Prometheus (Correct answer)
Push alert notifications to external systems
Forward scraped metrics to remote storage

Correct answer: Allow short-lived batch jobs to expose metrics to Prometheus

Pushgateway acts as an intermediary so ephemeral jobs that cannot be scraped directly can push their metrics before they exit.

Question 20: Which action in relabel_configs drops a target entirely from the scrape list?

labelmap
keep
replace
drop (Correct answer)

Correct answer: drop

The `drop` action in relabel_configs removes a target if the source label value matches the specified regex.

Question 21: Which label is automatically added by Prometheus to every scraped metric to identify where it was collected from?

`target`
`endpoint`
`source`
`instance` (Correct answer)

Correct answer: `instance`

Prometheus automatically adds the `instance` label to scraped metrics, typically set to the `host:port` of the scrape target.

Question 22: What is a key drawback of using the Prometheus Pushgateway for all metrics collection?

It increases scrape latency because Prometheus must poll the gateway frequently
It can serve stale metrics from jobs that have already finished, masking failures (Correct answer)
It requires a dedicated Prometheus instance and cannot share one with scrape-based jobs
It does not support gauge metrics, only counters

Correct answer: It can serve stale metrics from jobs that have already finished, masking failures

Once metrics are pushed, the Pushgateway retains them indefinitely until explicitly deleted, so Prometheus may keep scraping old values from finished or failed jobs.

Question 23: Which Prometheus metric type is best suited for measuring request latency distributions with configurable quantile calculations?

Gauge
Histogram
Counter
Summary (Correct answer)

Correct answer: Summary

Summary calculates streaming quantiles (e.g., p50, p99) client-side and exposes them directly, making it suited when you need accurate per-instance quantiles.

Question 24: What is a potential security concern with Prometheus's `/api/v1/admin/tsdb/delete_series` endpoint?

It is enabled by default and deletes data older than 15 days automatically
It allows any unauthenticated caller to permanently delete metric data if the admin API is not protected (Correct answer)
It triggers immediate compaction, causing a denial of service
It requires direct disk access and bypasses WAL checksums

Correct answer: It allows any unauthenticated caller to permanently delete metric data if the admin API is not protected

The admin API delete endpoint can irreversibly remove series data, so it must be protected by auth or network controls since Prometheus has no built-in access control by default.

Question 25: Which Prometheus CLI flag triggers a hot reload of the configuration file without restarting the process?

--reload-config
Sending SIGHUP to the Prometheus process (Correct answer)
--config.reload=true
POST to /-/restart

Correct answer: Sending SIGHUP to the Prometheus process

Sending `SIGHUP` to the Prometheus process causes it to re-read `prometheus.yml` and apply changes without downtime.

Question 26: What is the purpose of monitoring in Prometheus?

To collect metrics and monitor system performance (Correct answer)
To store data
To collect logs
To generate alerts only

Correct answer: To collect metrics and monitor system performance

Prometheus is invaluable for troubleshooting because it collects and stores detailed time-series data about system performance and behavior. When an issue arises, engineers can use PromQL to query this historical data, visualize trends, correlate different metrics, and pinpoint the exact time and conditions under which the problem occurred. This data-driven approach helps quickly diagnose root causes and resolve issues efficiently.

Question 27: What is the purpose of the `relabel_configs` section in a Prometheus scrape job?

To rewrite or filter target labels before scraping (Correct answer)
To set scrape intervals per metric
To configure remote storage destinations
To define alerting thresholds for discovered targets

Correct answer: To rewrite or filter target labels before scraping

relabel_configs lets you rewrite, drop, or keep target labels before Prometheus scrapes them.

Question 28: A PromQL query returns `No data` for `rate(http_requests_total[5m])`. The metric exists in Prometheus. What is the most common reason?

The metric name contains illegal characters
Prometheus has no scrape targets configured
The selected time window is shorter than two scrape intervals (Correct answer)
The rate function does not support counter metrics

Correct answer: The selected time window is shorter than two scrape intervals

rate() requires at least two data points within the range; if the range window is shorter than two scrape intervals, there may be insufficient data.

Question 29: What does the Prometheus HTTP API endpoint /api/v1/query_range return?

The current Alertmanager cluster status
The list of all active scrape targets
A matrix of values for a PromQL expression evaluated over a time range with a step interval (Correct answer)
A single instant vector at the latest timestamp

Correct answer: A matrix of values for a PromQL expression evaluated over a time range with a step interval

/api/v1/query_range evaluates a PromQL expression at multiple evenly-spaced timestamps between start and end, returning a matrix result used for graphing.

Question 30: How can Prometheus query time-series data?

By querying logs
By using SQL
By using PromQL to query time-series data (Correct answer)
By pushing data to a server

Correct answer: By using PromQL to query time-series data

In Prometheus, a time-series is the fundamental data model. It represents a stream of data points, where each point consists of a specific value recorded at a precise timestamp. This continuous sequence of time-stamped values, identified by a unique metric name and a set of labels, allows for tracking changes and trends over time, forming the basis of all monitoring.

Question 31: What is stale marker handling in the context of Prometheus recording rules?

Stale markers are injected into WAL to signal block compaction boundaries
Recording rules inject NaN values when source metrics exceed retention
When a source series disappears, Prometheus marks recorded outputs as stale so dashboards show gaps instead of stale values (Correct answer)
It is a mechanism that replaces missing data points with the last known good value

Correct answer: When a source series disappears, Prometheus marks recorded outputs as stale so dashboards show gaps instead of stale values

Prometheus propagates staleness from input series to recording rule outputs, causing downstream metrics to also show as stale/missing when the source goes away.

Question 32: Which promtool subcommand runs unit tests against Prometheus alerting and recording rules?

promtool validate rules <test-file>
promtool test rules <test-file> (Correct answer)
promtool run rules <test-file>
promtool check rules <test-file>

Correct answer: promtool test rules <test-file>

The `promtool test rules` command executes YAML-based unit tests that assert expected metric values and alert states from rule expressions.

Question 33: What is the main advantage of Cortex or Thanos over a standalone Prometheus for production long-term storage?

They eliminate the need for any exporters by using agent-based metric push
They automatically generate Grafana dashboards from ingested metric names
They provide horizontally scalable, multi-tenant storage with global query capability across instances (Correct answer)
They support additional metric types not available in standard Prometheus

Correct answer: They provide horizontally scalable, multi-tenant storage with global query capability across instances

Cortex and Thanos both decouple storage from individual Prometheus instances, enabling scalable multi-tenant long-term retention and unified querying across many Prometheus servers.

Question 34: Which mutual TLS (mTLS) configuration field in Prometheus scrape_config specifies the client certificate to present to the target?

mtls_cert in basic_auth
client_cert in authorization block
identity_cert in oauth2 block
cert_file under tls_config (Correct answer)

Correct answer: cert_file under tls_config

In tls_config, cert_file specifies the client certificate Prometheus presents during mutual TLS handshakes with scrape targets.

Question 35: What is the `interval` field in a Prometheus rule group used for?

Setting the retention period for metrics produced by the group
Defining the time range used in range vector selectors within the group
Controlling how often Alertmanager receives notifications from the group
Setting how frequently all rules in the group are evaluated (Correct answer)

Correct answer: Setting how frequently all rules in the group are evaluated

The interval field overrides the global evaluation_interval for a specific rule group, allowing different groups to evaluate at different frequencies.

Question 36: What is the architecture of Prometheus?

Data storage in SQL
Centralized data server
Push-based system
Pull-based system (Correct answer)

Correct answer: Pull-based system

Prometheus operates as a pull-based system, meaning it actively scrapes metrics endpoints from configured targets at regular intervals. This architecture simplifies target discovery and management, as services only need to expose their metrics, and Prometheus handles the collection process.

Question 37: What does `vector(0)` return in PromQL?

The zero-value of all currently active time series
A boolean false represented as 0
An empty instant vector
A vector containing a single element with value 0 and no labels (Correct answer)

Correct answer: A vector containing a single element with value 0 and no labels

vector(scalar) converts a scalar value into an instant vector with a single element, which is useful for arithmetic comparisons.

Question 38: Which exporter is the standard choice for exposing Linux host-level metrics such as CPU, memory, and disk?

blackbox_exporter
node_exporter (Correct answer)
process_exporter
host_exporter

Correct answer: node_exporter

The `node_exporter` exposes a comprehensive set of hardware and OS metrics from Linux/Unix hosts via `/proc` and `/sys`.

Question 39: Which TSDB concept represents a contiguous on-disk directory containing immutable compressed samples for a fixed time range?

Segment
Block (Correct answer)
WAL frame
Chunk

Correct answer: Block

A TSDB block is a directory (e.g., 01BX…) holding an index, chunks, and metadata for a specific time range, produced by compaction from the WAL.

Question 40: What is the recommended approach for instrumenting a new Go application with Prometheus?

Write metrics to a file for file_sd to pick up
Import the prometheus/client_golang library and register metrics with the default registry (Correct answer)
Use the Pushgateway for all application metrics
Embed the statsd_exporter as a sidecar

Correct answer: Import the prometheus/client_golang library and register metrics with the default registry

The official `prometheus/client_golang` library provides Counter, Gauge, Histogram, and Summary types that auto-register with the default registry and expose via an HTTP handler.

Question 41: A Prometheus server shows high memory usage. Which configuration change is most likely to reduce memory consumption?

Decrease the retention time with --storage.tsdb.retention.time
Increase scrape_interval to reduce ingestion rate (Correct answer)
Disable WAL compression
Increase the number of chunks in the head block

Correct answer: Increase scrape_interval to reduce ingestion rate

Increasing the scrape interval reduces the volume of samples ingested per unit time, which directly lowers memory usage for the TSDB head block.

Question 42: Which exposition format field declares the type of a metric before its samples appear?

`# META`
`# TYPE` (Correct answer)
`# UNIT`
`# HELP`

Correct answer: `# TYPE`

The `# TYPE` line in the Prometheus text exposition format declares the metric type (counter, gauge, histogram, summary, or untyped).

Question 43: In Prometheus recording rules, what is the effect of using `sum without (instance)` in the expression?

It excludes the instance metric from the sum calculation
It sums only series that do not have an instance label
It sums all matching series and drops the instance label from the result, aggregating across all instances (Correct answer)
It filters out instances with zero values before summing

Correct answer: It sums all matching series and drops the instance label from the result, aggregating across all instances

sum without (instance) aggregates series together by removing the instance dimension, producing per-job or per-cluster totals.

Question 44: Which flag must be explicitly enabled to allow the Prometheus admin HTTP API (e.g., snapshot, delete_series) to function?

--admin.enabled=true
--web.enable-admin-api (Correct answer)
--api.admin-access=true
--storage.tsdb.enable-admin

Correct answer: --web.enable-admin-api

Admin API endpoints are disabled by default and require the --web.enable-admin-api flag to be set when starting Prometheus.

Question 45: What does the `absent()` function return when the time series passed to it exists and has a value?

An empty vector (Correct answer)
0
The current value of the series
1

Correct answer: An empty vector

absent() returns an empty vector when the time series is present, and a vector with value 1 only when the series is absent.

Question 46: What HTTP method should a batch job use to delete its metrics from the Pushgateway after completion?

POST /delete/job/<name>
GET /metrics/job/<name>
DELETE /metrics/job/<name> (Correct answer)
PUT /metrics/job/<name>/clear

Correct answer: DELETE /metrics/job/<name>

Sending an HTTP DELETE to `/metrics/job/<jobname>` removes the metric group from the Pushgateway, preventing stale data from persisting.

Question 47: How does Prometheus handle high cardinality when scraping a target with millions of unique label combinations?

It stores each unique label set as a separate time series, which can exhaust memory (Correct answer)
It hashes label values to reduce storage
It automatically drops high-cardinality metrics
It sends cardinality warnings to Alertmanager

Correct answer: It stores each unique label set as a separate time series, which can exhaust memory

Each unique combination of metric name and label set is a distinct time series; too many unique combinations cause memory and CPU exhaustion known as a 'cardinality explosion'.

Question 48: A Prometheus target exposes 500,000 unique time series. What is the primary concern with this configuration?

Scrape timeouts due to network bandwidth
Violating the OpenMetrics specification limit
High cardinality causing excessive memory usage in Prometheus (Correct answer)
Exceeding the maximum metric name length

Correct answer: High cardinality causing excessive memory usage in Prometheus

High cardinality (many unique label combinations) causes Prometheus to consume large amounts of memory to store and index all time series.

Question 49: What is the use of a metric’s timestamp?

To label metrics
To classify metric types
To set alert thresholds (Correct answer)
To track performance changes over time

Correct answer: To set alert thresholds

While Prometheus fundamentally stores time-series data, the provided answer suggests metrics are structured 'as logs and alerts.' In a broader monitoring context, metrics often complement logs for detailed event information and are the foundation upon which alerts are triggered. Therefore, one might consider metrics as part of an integrated system that includes logs for context and alerts for notifications, even though metrics themselves are distinct time-stamped numerical values.

Question 50: What does the `--collector.disable-defaults` flag do when added to node_exporter?

Prevents node_exporter from reading /proc
Disables all default metric collectors, requiring explicit --collector.X flags to enable each one (Correct answer)
Disables TLS for the metrics endpoint
Disables the web UI

Correct answer: Disables all default metric collectors, requiring explicit --collector.X flags to enable each one

Passing `--collector.disable-defaults` starts node_exporter with no collectors active; only collectors explicitly enabled via `--collector.<name>` will run.

Question 51: Which Prometheus configuration block allows per-target scrape parameter overrides such as custom query params?

params (Correct answer)
query_params
target_params
scrape_params

Correct answer: params

The `params` map in a scrape_config appends arbitrary HTTP query parameters to every scrape request, commonly used with multi-target exporters.

Question 52: What is the OpenMetrics format and how does it relate to Prometheus exposition format?

OpenMetrics is a standardized evolution of Prometheus exposition format with additional features, published as an IETF standard (Correct answer)
OpenMetrics is a Grafana Labs format that extends Prometheus with trace correlation
OpenMetrics replaces Prometheus internally but is not exposed over HTTP
OpenMetrics is a competing standard unrelated to Prometheus that uses JSON encoding

Correct answer: OpenMetrics is a standardized evolution of Prometheus exposition format with additional features, published as an IETF standard

OpenMetrics is a standardized specification based on the Prometheus text format, adding features like exemplars and becoming an IETF Internet Standard.

Question 53: What is the correct way to calculate the 95th percentile from a Prometheus histogram metric named `http_request_duration_seconds`?

`quantile(0.95, http_request_duration_seconds_sum)`
`histogram_quantile(95, http_request_duration_seconds_bucket)`
`histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))` (Correct answer)
`percentile(0.95, http_request_duration_seconds)`

Correct answer: `histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))`

`histogram_quantile()` requires the quantile as a decimal (0-1) and a range vector of the `_bucket` series with `rate()` applied.

Question 54: What Prometheus label controls which Alertmanager instance a particular alert is routed to?

There is no per-alert routing to specific Alertmanagers (Correct answer)
alertmanager_url
__alertmanager__
__replica__

Correct answer: There is no per-alert routing to specific Alertmanagers

Prometheus sends all alerts to all configured Alertmanager instances; per-alert Alertmanager selection is not a Prometheus feature — routing is handled inside Alertmanager.

Question 55: When troubleshooting a failing alerting rule, which Prometheus API endpoint provides the current evaluation state and any errors for alerting rules?

/api/v1/targets
/api/v1/rules (Correct answer)
/api/v1/query
/api/v1/alerts

Correct answer: /api/v1/rules

/api/v1/rules returns all loaded alerting and recording rules along with their current state, last evaluation time, and any evaluation errors.

Question 56: What are histograms used for in Prometheus?

To track errors
To store time-series data
To track events
To monitor distribution of values like durations (Correct answer)

Correct answer: To monitor distribution of values like durations

Prometheus typically uses a pull model, but short-lived jobs (like batch scripts or cron jobs) may not exist long enough for Prometheus to scrape them directly. The Pushgateway acts as an intermediary, allowing these ephemeral jobs to push their metrics to it. Prometheus then scrapes the Pushgateway, ensuring that metrics from short-lived processes are collected and stored for monitoring.

Question 57: Which Prometheus web configuration file field specifies the path to the server's TLS certificate?

ssl_cert_path
cert_file (Correct answer)
server_certificate
tls_cert

Correct answer: cert_file

The cert_file field in the web configuration YAML points to the PEM-encoded TLS certificate file for the Prometheus server.

Question 58: What Prometheus relabeling action copies a source label value into a new label name?

replace (Correct answer)
labelmap
copy
labelkeep

Correct answer: replace

The `replace` action (the default) copies a matched source label value (optionally transformed by regex) into a target label.

Question 59: The `statsd_exporter` converts StatsD metrics to Prometheus format using which configuration file feature?

Mapping rules that translate StatsD metric names to Prometheus labels and names (Correct answer)
Prometheus relabel_configs
PromQL transform rules
scrape_configs mapping

Correct answer: Mapping rules that translate StatsD metric names to Prometheus labels and names

The statsd_exporter's mapping configuration translates dot-separated StatsD metric names into Prometheus metric names with proper labels using regex-based mapping rules.

Question 60: What does the `target_label` field specify in a Prometheus relabel_config rule?

The label used to determine scrape frequency
The name of the label that will be written with the replacement value (Correct answer)
The label to drop from the target
The label whose value is used as the regex source

Correct answer: The name of the label that will be written with the replacement value

`target_label` names the destination label that receives the result of the regex replacement in a relabeling rule.

Question 61: What is the purpose of the `authorization` section in a Prometheus scrape_config?

It controls which IP ranges can reach the Prometheus API
It configures bearer token or custom header authentication for scraping a target (Correct answer)
It sets the OAuth2 provider for the Prometheus server itself
It defines which users can access the Prometheus UI

Correct answer: It configures bearer token or custom header authentication for scraping a target

The authorization block lets Prometheus send a bearer token or other credentials when scraping targets that require authentication.

Prometheus Certified Associate (PCA)

The PCA certifies foundational knowledge of Prometheus monitoring and observability, covering PromQL, Prometheus architecture, instrumentation, exporters, and alerting. It is offered by the Linux Foundation and CNCF.

Questions

90 min

Time Limit

75%

To Pass

Checking for saved progress...

Exam Rules

You can skip questions and return to them later
Flag questions for review before submitting
No feedback shown until you submit the entire exam
Unanswered questions count as wrong — answer everything
10 pretest questions are mixed in and don't affect your score
Timer auto-submits when time runs out
Your progress is auto-saved every 30 seconds