New PCA Test Materials & Valid PCA Test Engine
PCA Updated Exam Dumps [2026] Practice Valid Exam Dumps Question
Linux Foundation PCA Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
NEW QUESTION # 29
Which Alertmanager feature allows you to temporarily stop notifications for a specific alert?
- A. Inhibition
- B. Deduplication
- C. Grouping
- D. Silence
Answer: D
Explanation:
The Silence feature in Alertmanager allows operators to mute specific alerts for a defined period. Each silence includes a matcher (labels), a creator, a comment, and an expiration time.
Silencing is useful during maintenance windows or known outages to prevent alert noise. Unlike inhibition, silences are manual and explicit.
NEW QUESTION # 30
Which field in alerting rules files indicates the time an alert needs to go from pending to firing state?
- A. interval
- B. timeout
- C. for
- D. duration
Answer: C
Explanation:
In Prometheus alerting rules, the for field specifies how long a condition must remain true continuously before the alert transitions from the pending to the firing state. This feature prevents transient spikes or brief metric fluctuations from triggering false alerts.
Example:
alert: HighRequestLatency
expr: http_request_duration_seconds_avg > 1
for: 5m
labels:
severity: warning
annotations:
description: "Request latency is above 1s for more than 5 minutes."
In this configuration, Prometheus evaluates the expression every rule evaluation cycle. The alert only fires if the condition (http_request_duration_seconds_avg > 1) remains true for 5 consecutive minutes. If it returns to normal before that duration, the alert resets and never fires.
This mechanism adds stability and noise reduction to alerting systems by ensuring only sustained issues generate notifications.
Reference:
Verified from Prometheus documentation - Alerting Rules Configuration Syntax, Pending vs. Firing States, and Best Practices for Alert Timing and Thresholds sections.
NEW QUESTION # 31
Which of the following signal belongs to symptom-based alerting?
- A. API latency
- B. Disk space
- C. Database memory utilization
- D. CPU usage
Answer: A
Explanation:
Symptom-based alerting focuses on user-visible problems or service-impacting symptoms rather than low-level resource metrics. In Prometheus and Site Reliability Engineering (SRE) practices, alerts should signal conditions that affect users' experience - such as high latency, request failures, or service unavailability - instead of merely reflecting internal resource states.
Among the options, API latency directly represents the performance perceived by end users. If API response times increase, it immediately impacts user satisfaction and indicates a possible service degradation.
In contrast, metrics like disk space, CPU usage, or database memory utilization are cause-based metrics - they may correlate with problems but do not always translate into observable user impact.
Prometheus alerting best practices recommend alerting on symptoms (via RED metrics - Rate, Errors, Duration) while using cause-based metrics for deeper investigation and diagnosis, not for immediate paging alerts.
Reference:
Verified from Prometheus documentation - Alerting Best Practices, Symptom vs. Cause Alerting, and RED/USE Monitoring Principles sections.
NEW QUESTION # 32
What should you do with counters that have labels?
- A. Instantiate them with their possible label values when creating them so they are exposed with a zero value.
- B. Make sure every counter with labels has an extra counter, aggregated, without labels.
- C. Investigate if you can move their label value inside their metric name to limit the number of labels.
- D. Save their state between application runs so you can restore their last value on startup.
Answer: A
Explanation:
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.
Reference:
Verified from Prometheus documentation - Instrumentation Best Practices, Counters with Labels, and Avoid Missing Time Series by Initializing Metrics.
NEW QUESTION # 33
The following is a list of metrics exposed by an application:
http_requests_total{code="500"} 10
http_requests_total{code="200"} 20
http_requests_total{code="400"} 30
http_requests_total{verb="POST"} 30
http_requests_total{verb="GET"} 30
What is the issue with the metric family?
- A. Metric names are missing a prefix to indicate which application is exposing the query.
- B. The value represents two different things across the dimensions: code and verb.
Answer: B
Explanation:
Prometheus requires that a single metric name represents one well-defined thing, and all time series in that metric share the same set of label keys so 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 a consistent 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="..."} expresses per-status-code request counts, while http_requests_total{verb="..."} expresses per-HTTP-method request counts. Because some series have only code and others only verb, the value changes its meaning across label sets, violating the consistency principle for a metric family. The correct approach is to expose one 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 the same dimensions. A missing application prefix is optional and not the core issue here.
NEW QUESTION # 34
What is a rule group?
- A. It is a set of rules that are grouped by labels.
- B. It is the set (the group) of all the rules in a file.
- C. It is a set of rules that are executed sequentially.
- D. It is a set of rules, split into groups by type.
Answer: C
Explanation:
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.
Reference:
Verified from Prometheus documentation - Rule Configuration, Rule Groups and Evaluation Order, and Recording & Alerting Rules Guide.
NEW QUESTION # 35
How do you calculate the average request duration during the last 5 minutes from a histogram or summary called http_request_duration_seconds?
- A. rate(http_request_duration_seconds_total[5m]) / rate(http_request_duration_second$_count[5m])
- B. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_average[5m])
- C. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m])
- D. rate(http_request_duration_seconds_total[5m]) / rate(http_request_duration_seconds_average[5m])
Answer: C
Explanation:
In Prometheus, histograms and summaries expose metrics with _sum and _count suffixes to represent total accumulated values and sample counts, respectively. To compute the average request duration over a given time window (for example, 5 minutes), you divide the rate of increase of _sum by the rate of increase of _count:
\text{Average duration} = \frac{\text{rate(http_request_duration_seconds_sum[5m])}}{\text{rate(http_request_duration_seconds_count[5m])}} Here,
http_request_duration_seconds_sum represents the total accumulated request time, and
http_request_duration_seconds_count represents the number of requests observed.
By dividing these rates, you obtain the average request duration per request over the specified time range.
Reference:
Extracted and verified from Prometheus documentation - Querying Histograms and Summaries, PromQL Rate Function, and Metric Naming Conventions sections.
NEW QUESTION # 36
What is the name of the official *nix OS kernel metrics exporter?
- A. Prometheus_exporter
- B. os_exporter
- C. metrics_exporter
- D. node_exporter
Answer: D
Explanation:
The official Prometheus exporter for collecting system-level and kernel-related metrics from Linux and other UNIX-like operating systems is the Node Exporter.
The Node Exporter exposes hardware and OS metrics including CPU load, memory usage, disk I/O, network traffic, and kernel statistics. It is designed to provide host-level observability and serves data at the default endpoint :9100/metrics in the standard Prometheus exposition text format.
This exporter is part of the official Prometheus ecosystem and is widely deployed for infrastructure monitoring. None of the other listed options (Prometheus_exporter, metrics_exporter, or os_exporter) are official components of the Prometheus project.
Reference:
Verified from Prometheus documentation - Node Exporter Overview, System Metrics Collection, and Official Exporters List.
NEW QUESTION # 37
Which exporter would be best suited for basic HTTP probing?
- A. Blackbox exporter
- B. SNMP exporter
- C. Apache exporter
- D. JMX exporter
Answer: A
Explanation:
The Blackbox Exporter is the Prometheus component designed specifically for probing endpoints over various network protocols, including HTTP, HTTPS, TCP, ICMP, and DNS. It acts as a generic probe service, allowing Prometheus to test endpoints' availability, latency, and correctness without requiring instrumentation in the target application itself.
For basic HTTP probing, the Blackbox Exporter performs HTTP GET or POST requests to defined URLs and exposes metrics like probe success, latency, response code, and SSL certificate validity. This makes it ideal for uptime and availability monitoring.
By contrast, the JMX exporter is used for collecting metrics from Java applications, the Apache exporter for Apache HTTP Server metrics, and the SNMP exporter for network devices. Thus, only the Blackbox Exporter serves the purpose of HTTP probing.
Reference:
Verified from Prometheus documentation - Blackbox Exporter Overview and Exporter Usage Guidelines.
NEW QUESTION # 38
What is metamonitoring?
- A. Metamonitoring is the monitoring of non-IT systems.
- B. Metamonitoring is the monitoring of the monitoring infrastructure.
- C. Metamonitoring is a monitoring that covers 100% of a service.
- D. Metamonitoring is monitoring social networks for end user complaints about quality of service.
Answer: B
Explanation:
Metamonitoring refers to monitoring the monitoring system itself-ensuring that Prometheus, Alertmanager, exporters, and dashboards are functioning properly. In other words, it's the observability of your observability stack.
This practice helps detect issues such as:
Prometheus not scraping targets,
Alertmanager being unreachable,
Exporters not exposing data, or
Storage being full or corrupted.
Without metamonitoring, an outage in the monitoring system could go unnoticed, leaving operators blind to actual infrastructure problems. A common approach is to use a secondary Prometheus instance (or external monitoring service) to monitor the health metrics of the primary Prometheus and related components.
Reference:
Verified from Prometheus documentation - Monitoring Prometheus Itself, Operational Best Practices, and Reliability of the Monitoring Infrastructure.
NEW QUESTION # 39
What function calculates the tp-quantile from a histogram?
- A. avg_over_time()
- B. histogram_quantile()
- C. histogram()
- D. predict_linear()
Answer: B
Explanation:
In Prometheus, the histogram_quantile() function is specifically designed to compute quantiles (such as tp90, tp95, or tp99) from histogram bucket data. A histogram metric records cumulative bucket counts for observed values under specific thresholds (le label).
The function works by interpolating between buckets based on the target quantile. For example, to compute the 90th percentile latency from a histogram named http_request_duration_seconds_bucket, you would use:
histogram_quantile(0.9, sum(rate(http_request_duration_seconds_bucket[5m])) by (le)) Here, 0.9 represents the tp90 quantile, and rate() converts counter increments into per-second rates.
Other options are incorrect:
histogram() is not a valid PromQL function.
predict_linear() forecasts future values of a time series.
avg_over_time() computes a simple average over a time window, not quantiles.
Reference:
Verified from Prometheus documentation - PromQL Function: histogram_quantile(), Working with Histograms, and Quantile Calculation Details.
NEW QUESTION # 40
With the following metrics over the last 5 minutes:
up{instance="localhost"} 1 1 1 1 1
up{instance="server1"} 1 0 0 0 0
What does the following query return:
min_over_time(up[5m])
- A. {instance="localhost"} 1 {instance="server1"} 0
- B. {instance="server1"} 0
Answer: A
Explanation:
The min_over_time() function in PromQL returns the minimum sample value observed within the specified time range for each time series.
In the given data:
For up{instance="localhost"}, all samples are 1. The minimum value over 5 minutes is therefore 1.
For up{instance="server1"}, the sequence is 1 0 0 0 0. The minimum observed value is 0.
Thus, the query min_over_time(up[5m]) returns two series - one per instance:
{instance="localhost"} 1
{instance="server1"} 0
This query is commonly used to check uptime consistency. If the minimum value over the time window is 0, it indicates at least one scrape failure (target down).
Reference:
Verified from Prometheus documentation - PromQL Range Vector Functions, min_over_time() definition, and up Metric Semantics sections.
NEW QUESTION # 41
Which PromQL statement returns the sum of all values of the metric node_memory_MemAvailable_bytes from 10 minutes ago?
- A. sum(node_memory_MemAvailable_bytes) setoff 10m
- B. sum(node_memory_MemAvailable_bytes) offset 10m
- C. offset sum(node_memory_MemAvailable_bytes[10m])
- D. sum(node_memory_MemAvailable_bytes offset 10m)
Answer: D
Explanation:
In PromQL, the offset modifier allows you to query metrics as they were at a past time relative to the current evaluation. To retrieve the value of node_memory_MemAvailable_bytes as it was 10 minutes ago, you place the offset keyword inside the aggregation function's argument, not after it.
The correct query is:
sum(node_memory_MemAvailable_bytes offset 10m)
This computes the total available memory across all instances, based on data from exactly 10 minutes in the past.
Placing offset after the aggregation (as in option B) is syntactically invalid because modifiers apply to instant and range vector selectors, not to complete expressions.
Reference:
Verified from Prometheus documentation - PromQL Evaluation Modifiers: offset, Aggregation Operators, and Temporal Query Examples.
NEW QUESTION # 42
Given the metric prometheus_tsdb_lowest_timestamp_seconds, how do you know in which month the lowest timestamp of your Prometheus TSDB belongs?
- A. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
- B. prometheus_tsdb_lowest_timestamp_seconds % month
- C. format_date(prometheus_tsdb_lowest_timestamp_seconds,"%M")
- D. month(prometheus_tsdb_lowest_timestamp_seconds)
Answer: A
Explanation:
The metric prometheus_tsdb_lowest_timestamp_seconds provides the oldest stored sample timestamp in Prometheus's local TSDB (in Unix epoch seconds). To determine the age or approximate date of this timestamp, you compare it with the current time (using time() in PromQL).
The expression:
(time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
converts the difference between the current time and the oldest timestamp from seconds into days (1 day = 86,400 seconds). This gives the number of days since the earliest sample was stored, allowing you to infer the time range and approximate month manually.
The other options are invalid because PromQL does not support direct date formatting (format_date) or month() extraction functions.
Reference:
Extracted and verified from Prometheus documentation - TSDB Internal Metrics, Time Functions in PromQL, and Using time() for Relative Calculations.
NEW QUESTION # 43
Which of the following signals belongs to symptom-based alerting?
- A. API latency
- B. Database availability
- C. Disk space
- D. CPU usage
Answer: A
Explanation:
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.
Reference:
Verified from Prometheus documentation - Alerting Best Practices, Symptom vs. Cause Alerting, and RED/USE Monitoring Principles.
NEW QUESTION # 44
Which Prometheus component handles service discovery?
- A. Node Exporter
- B. Prometheus Server
- C. Pushgateway
- D. Alertmanager
Answer: B
Explanation:
The Prometheus Server is responsible for service discovery, which identifies the list of targets to scrape. It integrates with multiple service discovery mechanisms such as Kubernetes, Consul, EC2, and static configurations.
This allows Prometheus to automatically adapt to dynamic environments without manual reconfiguration.
NEW QUESTION # 45
How do you configure the rule evaluation interval in Prometheus?
- A. You can configure the evaluation interval in the scraping job configuration file and in the command-line flags.
- B. You can configure the evaluation interval in the global configuration file and in the rule configuration file.
- C. You can configure the evaluation interval in the Prometheus TSDB configuration file and in the rule configuration file.
- D. You can configure the evaluation interval in the service discovery configuration and in the command-line flags.
Answer: B
Explanation:
Prometheus evaluates alerting and recording rules at a regular cadence determined by the evaluation_interval setting. This can be defined globally in the main Prometheus configuration file (prometheus.yml) under the global: section or overridden for specific rule groups in the rule configuration files.
The global evaluation_interval specifies how frequently Prometheus should execute all configured rules, while rule-specific intervals can fine-tune evaluation frequency for individual groups. For instance:
global:
evaluation_interval: 30s
This means Prometheus evaluates rules every 30 seconds unless a rule file specifies otherwise.
This parameter is distinct from scrape_interval, which governs metric collection frequency from targets. It has no relation to TSDB, service discovery, or command-line flags.
Reference:
Verified from Prometheus documentation - Configuration File Reference, Rule Evaluation and Recording Rules sections.
NEW QUESTION # 46
What is the difference between client libraries and exporters?
- A. Exporters are written in Go. Client libraries are written in many languages.
- B. Exporters expose metrics for scraping. Client libraries push metrics via Remote Write.
- C. Exporters run next to the services to monitor, and use client libraries internally.
- D. Exporters and client libraries mean the same thing.
Answer: C
Explanation:
The fundamental difference between Prometheus client libraries and exporters lies in how and where they are used.
Client libraries are integrated directly into the application's codebase. They allow developers to instrument their 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, are standalone processes that 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 for external systems, while client libraries are used for self-instrumented applications.
Reference:
Verified from Prometheus documentation - Writing Exporters, Client Libraries Overview, and Best Practices for Exporters and Instrumentation.
NEW QUESTION # 47
What are Inhibition rules?
- A. Inhibition rules inspect alerts when a matching set of alerts is firing.
- B. Inhibition rules inject a new set of alerts when a matching alert is firing.
- C. Inhibition rules repeat a set of alerts when another matching alert is firing.
- D. Inhibition rules mute a set of alerts when another matching alert is firing.
Answer: D
Explanation:
Inhibition rules in Prometheus's Alertmanager are used to suppress (mute) alerts that would otherwise be redundant when a higher-priority or related alert is already active. This feature helps avoid alert noise and ensures that operators focus on the root cause rather than multiple cascading symptoms.
For example, if a "DatacenterDown" alert is firing, inhibition rules can mute all "InstanceDown" alerts that share the same datacenter label, preventing redundant notifications. Inhibition is configured in the Alertmanager configuration file under the inhibit_rules section.
Each rule defines:
A source match (the alert that triggers inhibition),
A target match (the alert to mute), and
A match condition (labels that must be equal for inhibition to apply).
Only when the source alert is active are the target alerts silenced.
Reference:
Verified from Prometheus documentation - Alertmanager Configuration - Inhibition Rules, Alert Deduplication and Grouping, and Alert Routing Best Practices.
NEW QUESTION # 48
How can you select all the up metrics whose instance label matches the regex fe-.*?
- A. up{instance~"fe-.*"}
- B. up{instance="fe-.*"}
- C. up{instance=regexp(fe-.*)}
- D. up{instance=~"fe-.*"}
Answer: D
Explanation:
PromQL supports regular expression matching for label values using the =~ operator. To select all time series whose label values match a given regex pattern, you use the syntax {label_name=~"regex"}.
In this case, to select all up metrics where the instance label begins with fe-, the correct query is:
up{instance=~"fe-.*"}
Explanation of operators:
= → exact match.
!= → not equal.
=~ → regex match.
!~ → regex not match.
Option D uses the correct =~ syntax. Options A and B use invalid PromQL syntax, and option C is almost correct but includes a misplaced extra quote style (~''), which would cause a parsing error.
Reference:
Verified from Prometheus documentation - Expression Language Data Selectors, Label Matchers, and Regular Expression Matching Rules.
NEW QUESTION # 49
Which of the following metrics is unsuitable for a Prometheus setup?
- A. user_last_login_timestamp_seconds{email="[email protected]"}
- B. http_response_total{handler="static/*filepath"}
- C. prometheus_engine_query_log_enabled
- D. promhttp_metric_handler_requests_total{code="500"}
Answer: A
Explanation:
The metric user_last_login_timestamp_seconds{email="[email protected]"} is unsuitable for Prometheus because it includes a high-cardinality label (email). Each unique email address would generate a separate time series, potentially numbering in the millions, which severely impacts Prometheus performance and memory usage.
Prometheus is optimized for low- to medium-cardinality metrics that represent system-wide behavior rather than per-user data. High-cardinality metrics cause data explosion, complicating queries and overwhelming the storage engine.
By contrast, the other metrics-prometheus_engine_query_log_enabled, promhttp_metric_handler_requests_total{code="500"}, and http_response_total{handler="static/*filepath"}-adhere to Prometheus best practices. They represent operational or service-level metrics with limited, manageable label value sets.
Reference:
Extracted and verified from Prometheus documentation - Metric and Label Naming Best Practices, Cardinality Management, and Anti-Patterns for Metric Design sections.
NEW QUESTION # 50
What's "wrong" with the myapp_filG_uploads_total{userid=,,5123",status="failed"} metric?
- A. The status should not be exposed as a label.
- B. The _total suffix should be omitted.
- C. The metric name should consist of dashes instead of underscores.
- D. The userid should not be exposed as a label.
Answer: D
Explanation:
In Prometheus best practices, high-cardinality labels-especially those containing unique or user-specific identifiers-should be avoided. The metric myapp_filG_uploads_total{userid="5123",status="failed"} exposes the userid as a label, which is problematic. Each distinct value of a label generates a new time series in Prometheus. If there are thousands or millions of unique users, this would exponentially increase the number of time series, leading to cardinality explosion, degraded performance, and high memory usage.
The _total suffix is actually correct and required for counters, as per the Prometheus naming convention. The use of underscores in metric names is also correct, as Prometheus does not support dashes in metric identifiers. The status label, however, is perfectly valid because it typically has a low number of possible values (e.g., "success", "failed").
Reference:
Verified from Prometheus official documentation sections Instrumentation - Metric and Label Naming Best Practices and Writing Exporters.
NEW QUESTION # 51
How can you send metrics from your Prometheus setup to a remote system, e.g., for long-term storage?
- A. With "remote write"
- B. With S3 Buckets
- C. With "federation"
- D. With "scraping"
Answer: A
Explanation:
Prometheus provides a feature called Remote Write to transmit scraped and processed metrics to an external system for long-term storage, aggregation, or advanced analytics. When configured, Prometheus continuously pushes time series data to the remote endpoint defined in the remote_write section of the configuration file.
This mechanism is often used to integrate with long-term data storage backends such as Cortex, Thanos, Mimir, or InfluxDB, enabling durable retention and global query capabilities beyond Prometheus's local time series database limits.
In contrast, "scraping" refers to data collection from targets, while "federation" allows hierarchical Prometheus setups (pulling metrics from other Prometheus instances) but does not serve as long-term storage. Using "S3 Buckets" directly is also unsupported in native Prometheus configurations.
Reference:
Extracted and verified from Prometheus documentation - Remote Write/Read APIs and Long-Term Storage Integrations sections.
NEW QUESTION # 52
How would you name a metric that tracks HTTP request duration?
- A. http_request_duration_seconds
- B. http.request_latency
- C. request_duration_seconds
- D. http_request_duration
Answer: A
Explanation:
According to Prometheus metric naming conventions, a metric name must clearly describe what is being measured and include a unit suffix that specifies the base unit of measurement, following SI standards. For durations, the suffix _seconds is mandatory.
Therefore, the correct and standards-compliant name for a metric tracking HTTP request duration is:
http_request_duration_seconds
This name communicates:
http_request → the subject being measured (HTTP requests),
duration → the aspect being measured (the latency or time taken),
_seconds → the unit of measurement (seconds).
This metric name typically corresponds to a histogram or summary, exposing submetrics such as _count, _sum, and _bucket. These represent the number of observations, total duration, and distribution across time buckets respectively.
Options A, B, and C fail to fully comply with Prometheus naming standards - they either omit the http_ prefix, use invalid separators (dots), or lack the required unit suffix.
Reference:
Verified from Prometheus documentation - Metric and Label Naming Conventions, Instrumentation Best Practices, and Histogram and Summary Metric Naming Patterns.
NEW QUESTION # 53
How can you send metrics from your Prometheus setup to a remote system, e.g., for long-term storage?
- A. With "remote write"
- B. With S3 Buckets
- C. With "federation"
- D. With "scraping"
Answer: A
Explanation:
Prometheus provides a feature called Remote Write to transmit scraped and processed metrics to an external system for long-term storage, aggregation, or advanced analytics. When configured, Prometheus continuously pushes time series data to the remote endpoint defined in the remote_write section of the configuration file.
This mechanism is often used to integrate with long-term data storage backends such as Cortex, Thanos, Mimir, or InfluxDB, enabling durable retention and global query capabilities beyond Prometheus's local time series database limits.
In contrast, "scraping" refers to data collection from targets, while "federation" allows hierarchical Prometheus setups (pulling metrics from other Prometheus instances) but does not serve as long-term storage. Using "S3 Buckets" directly is also unsupported in native Prometheus configurations.
Reference:
Extracted and verified from Prometheus documentation - Remote Write/Read APIs and Long-Term Storage Integrations sections.
NEW QUESTION # 54
......
PCA Sample with Accurate & Updated Questions: https://braindumps.getvalidtest.com/PCA-brain-dumps.html