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.

Prometheus normally operates on a pull-based model , where it scrapes metrics from long-running targets. However, short-lived batch jobs (such as cron jobs or data processing tasks) often finish before Prometheus can scrape them. To handle this scenario, Prometheus provides the Pushgateway component.

The Pushgateway allows ephemeral jobs to push their metrics to an intermediary gateway. Prometheus then scrapes these metrics from the Pushgateway like any other target. This ensures short-lived jobs have their metrics preserved even after completion.

The Pushgateway should not be used for continuously running applications because it breaks Prometheus’s usual target lifecycle semantics. Instead, it is intended solely for transient job metrics , like backups or CI/CD tasks.

In Prometheus, when you have multiple time series that represent the same type of measurement across different instances, the sum() aggregation operator is 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 the total 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 sum over a range vector , not the current value, so it’s incorrect here.

The most widely used open-source visualization and dashboarding platform for Prometheus data is Grafana . Grafana provides native integration with Prometheus as a data source, allowing users to create real-time, interactive dashboards using PromQL queries.

Grafana supports advanced visualization panels (graphs, heatmaps, gauges, tables, etc.) and enables users to design custom dashboards to monitor infrastructure, application performance, and service-level objectives (SLOs). It also provides alerting capabilities that can complement or extend Prometheus’s own alerting system.

While Kibana is part of the Elastic Stack and focuses on log analytics, Thanos extends Prometheus for long-term storage and high availability, and Loki is a log aggregation system. None of these tools serve as the primary dashboarding solution for Prometheus metrics the way Grafana does.

Grafana’s seamless Prometheus integration and templating support make it the de facto standard visualization tool in the Prometheus ecosystem.

According to Prometheus naming rules, metric names must match the regex [a-zA-Z_:][a-zA-Z0-9_:] * . This means metric names must begin with a letter, underscore, or colon, and can only contain letters, digits, and underscores thereafter.

The valid metric name among the options is go_goroutines , which follows all these rules. It starts with a letter (g), uses underscores to separate words, and contains only allowed characters.

By contrast:

go routines is invalid because it contains a space .

go.goroutines is invalid because it contains a dot (.), which is reserved for recording rule naming hierarchies, not metric identifiers.

99_goroutines is invalid because metric names cannot start with a number .

Following these conventions ensures compatibility with PromQL syntax and Prometheus’ internal data model.

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.

The rate() function computes the per-second increase of a counter metric over a specified range, while sum by (label) aggregates those rates across dimensions — in this case, the cloud label.

The correct query is:

sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m]))

This expression:

Calculates the rate of increase in API requests per second for each instance.

Groups and sums those rates by cloud, giving the total request rate per cloud provider.

Option A incorrectly places by (cloud) after rate(), which is not valid syntax.

Option B returns raw counter totals (not rates).

Option D incorrectly applies rate() after aggregation, which distorts the calculation since rate() must operate on individual time series before aggregation.

In Prometheus, the scrape_interval parameter specifies how frequently the Prometheus server should scrape metrics from its configured targets . Each target exposes an HTTP endpoint (usually /metrics) that Prometheus collects data from at a fixed cadence. By default, the scrape_interval is set to 1 minute , but it can be overridden globally or per job configuration in the Prometheus YAML configuration file.

This setting directly affects the resolution of collected time series data —a shorter interval increases data granularity but also adds network and storage overhead, while a longer interval reduces load but might miss short-lived metric variations.

It is important to distinguish scrape_interval from evaluation_interval, which defines how often Prometheus evaluates recording and alerting rules. Thus, scrape_interval pertains only to data collection frequency , not to alerting or rule evaluation.

The Prometheus alerting philosophy emphasizes signal over noise — meaning alerts should focus only on actionable and user-impacting issues . The best practice is to alert on symptoms that indicate potential or actual user-visible problems , not on every internal metric anomaly.

This approach reduces alert fatigue, avoids desensitizing operators, and ensures high-priority alerts get the attention they deserve. For example, alerting on “service unavailable” or “latency exceeding SLO” is more effective than alerting on “CPU above 80%” or “disk usage increasing,” which may not directly affect users.

Option B correctly reflects this principle: keep alerts meaningful, few, and symptom-based. The other options contradict core best practices by promoting excessive or equal-weight alerting, which can overwhelm operations teams.

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.