The correct way to expose a timestamp from an application in Prometheus is to use a gauge metric where the timestamp value (in Unix time, seconds since epoch) is stored as the metric’s value . This approach aligns with the Prometheus data model, which discourages embedding timestamps as labels or metadata.

Example:

app_last_successful_backup_timestamp_seconds 1.696358e+09

In this example, the gauge represents the timestamp of the last successful backup. The _seconds suffix indicates the unit of measurement, making the metric self-descriptive. Prometheus automatically assigns timestamps to scraped samples, so the metric’s value is treated purely as data, not as a Prometheus sample time.

Options B and D are incorrect because Prometheus does not allow arbitrary timestamps or labels for time values. Option C is incorrect since counters are monotonically increasing and not suited for discrete timestamp values.

A single-target exporter in Prometheus is designed to expose metrics for a specific service instance rather than multiple dynamic endpoints. The Redis Exporter is a prime example — it connects to one Redis server instance and exports its metrics (like memory usage, keyspace hits, or command statistics) to Prometheus.

By contrast, exporters like the SNMP Exporter and Blackbox Exporter can probe multiple targets dynamically, making them multi-target exporters . The Node Exporter , while often deployed per host, is considered a host-level exporter , not a true single-target one in configuration behavior.

The Redis Exporter is instrumented specifically for a single Redis endpoint per configuration, aligning it with Prometheus’s single-target exporter definition. This design simplifies monitoring and avoids dynamic reconfiguration.

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 .

In Prometheus alerting rules, you can dynamically reference label values in annotations and labels using template variables. Each alert has access to its labels via the variable $labels, which allows direct insertion of label data into alert messages or descriptions.

To include the value of the instance label dynamically in the description, replace the placeholder INSTANCE_NAME_HERE with:

description: "Instance {{$labels.instance}} down"

or equivalently:

description: "Instance $labels.instance down"

Both forms are valid — the first follows Go templating syntax and is the recommended format.

This ensures that when the alert fires, the instance label (e.g., a hostname or IP) is automatically included in the message, producing outputs like:

Instance 192.168.1.15:9100 down

Options B, C, and D are invalid because $value, $expr, and $metric are not recognized context variables in alert templates.

Prometheus metric naming best practices require that every metric name include a unit suffix that indicates the measurement type, where applicable. The unit should follow the base name, separated by an underscore, and must use base SI units (for example, _seconds, _bytes, _total, etc.).

In the case of http_requests_total, while the metric correctly includes the _total suffix—indicating it is a counter—it lacks a base unit of measurement (such as time, bytes, or duration). However, for event counters , _total is itself considered the unit, representing “total occurrences” of an event. Thus, the naming would be acceptable in strict Prometheus terms, but if this metric were measuring something like duration, size, or latency, then including a specific unit would be mandatory.

However, since the question implies that the missing unit is the issue and not the label schema, the expected answer aligns with ensuring metric names convey measurable units when applicable.

The Prometheus Node Exporter is a core system-level exporter that exposes hardware and operating system metrics from *nix-based hosts. It collects metrics such as CPU usage, memory, disk I/O, filesystem space, network statistics, and load averages.

It runs as a lightweight daemon on each host and exposes metrics via an HTTP endpoint (default: :9100/metrics), which Prometheus scrapes periodically.

Key clarification:

It does not instrument applications (A).

It does not collect metrics directly from application HTTP endpoints (B).

It is unrelated to HTTP probing tasks — those are handled by the Blackbox Exporter (D).

Thus, the correct use of the Node Exporter is to collect and expose hardware and OS-level metrics for Prometheus monitoring.

The evaluation_interval parameter defines how frequently Prometheus evaluates its recording and alerting rules . It determines the schedule at which the rule engine runs, checking whether alert conditions are met and generating new time series for recording rules.

For example, setting:

global:

evaluation_interval: 30s

means Prometheus evaluates all configured rules every 30 seconds. This setting differs from scrape_interval, which controls how often Prometheus collects data from targets.

Having a proper evaluation interval ensures alerting latency is balanced with system performance.

When Prometheus targets are behind firewalls or NAT and cannot be reached directly by the Prometheus server’s pull mechanism, the recommended component to use is PushProx .

PushProx works by reversing the usual pull model. It consists of a PushProx Proxy (accessible by Prometheus) and PushProx Clients (running alongside the targets). The clients establish outbound connections to the proxy, which allows Prometheus to “pull” metrics indirectly. This approach bypasses network restrictions without compromising the Prometheus data model.

Unlike the Pushgateway (which is used for short-lived batch jobs, not network-isolated targets), PushProx maintains the Prometheus “pull” semantics while accommodating environments where direct scraping is impossible.