80+ Prometheus Interview Questions and Answers (2027)

84 Prometheus interview questions with answers: metric types, PromQL, rate vs irate, histograms, Alertmanager, relabeling, Operator, HA, scenarios.

Sep 13, 2025 - 14:10
Nov 7, 2026 - 20:38
 0  169
80+ Prometheus Interview Questions and Answers (2027)

Prometheus interview questions check whether you understand pull-based metrics collection, the four metric types, PromQL, recording and alerting rules, Alertmanager routing, service discovery on Kubernetes, and how to scale storage beyond one server. This page has 84 questions with direct answers, grouped by experience level and followed by real troubleshooting scenarios.

Answers were checked against the Prometheus documentation in November 2026 and reflect Prometheus 3.x behaviour, including native histograms and the newer OTLP and UTF-8 features. For the wider picture of monitoring tools, see our pillar on observability tools for DevOps monitoring.

Key takeaways

  • Freshers are asked about architecture: the server, exporters, Alertmanager, Pushgateway, the pull model and the four metric types.
  • Mid-level candidates must write PromQL with rate(), sum by and histogram_quantile(), and explain recording rules and relabeling.
  • Senior rounds focus on cardinality, high availability, remote write, long-term storage (Thanos, Mimir, Cortex) and alert design based on SLOs.
  • Prometheus 3.0 brought a new UI, UTF-8 metric and label names, an OTLP receiver and Remote Write 2.0. Native histograms became stable in v3.8, but scraping them is opt-in with scrape_native_histograms.
  • Scenario answers should follow symptom, check, cause, fix and prevention. Interviewers listen for the exact query or metric you would look at first.

How this guide fits with other Prometheus posts

This is the main Prometheus question bank on the site. If you want a concept-first walkthrough of dashboards, read how Prometheus and Grafana work together. For role-specific practice, the Prometheus engineer questions and Prometheus monitoring questions for DevOps go deeper on specific areas.

Your levelQuestionsWhat to practise
Fresher1 to 30Run Prometheus and node_exporter locally, open the UI on port 9090, query up
2 to 5 years31 to 58Write recording rules and alerts, test them with promtool test rules
Senior59 to 72Design HA pairs, remote write and a cardinality budget
Everyone73 to 84Talk through each scenario out loud in under three minutes

Prometheus interview questions for freshers

1. What is Prometheus?

Prometheus is an open-source monitoring and alerting toolkit that stores metrics as time series, each identified by a metric name and a set of key-value labels. It started at SoundCloud in 2012, joined the CNCF in 2016 and became the second CNCF project to graduate, after Kubernetes, in 2018.

2. What are the main components of the Prometheus ecosystem?

The Prometheus server scrapes and stores metrics and evaluates rules. Exporters expose metrics for systems that do not do it natively. Alertmanager deduplicates, groups and routes alerts. The Pushgateway holds metrics pushed by short-lived jobs. Client libraries let you instrument your own code, and Grafana is the usual dashboard layer.

3. Does Prometheus pull or push metrics?

It pulls. The server sends HTTP requests to each target's metrics endpoint, usually /metrics, on a schedule set by scrape_interval. Pushing is supported only indirectly, through the Pushgateway, remote write receivers or the OTLP receiver.

4. Why did Prometheus choose the pull model?

Pull makes it easy to tell whether a target is down (the scrape fails and up becomes 0), lets you run a second Prometheus against the same targets for testing, and keeps targets simple because they only serve a page. The trade-off is that Prometheus must be able to reach every target over the network.

5. What is a time series in Prometheus?

A stream of timestamped sample values that share the same metric name and the same label set. http_requests_total{method="GET",code="200"} and http_requests_total{method="POST",code="200"} are two different series.

6. What are the four metric types?

Counter, gauge, histogram and summary. These are client library types; the server stores everything as float samples, apart from native histograms, which have their own sample type.

7. What is a counter?

A value that only goes up, or resets to zero when the process restarts. Examples are requests served or errors seen. You almost never graph a raw counter; you wrap it in rate() or increase().

8. What is a gauge?

A value that can go up and down, such as memory in use, queue length or temperature. You can graph it directly or use functions like avg_over_time() and delta().

9. What is a histogram?

A metric that counts observations into configurable buckets, plus a total count and a sum. A classic histogram exposes _bucket series with an le label, and _count and _sum series. You calculate percentiles on the server with histogram_quantile().

10. What is a summary, and how is it different from a histogram?

A summary calculates quantiles in the client and exposes them directly. Those quantiles cannot be aggregated across instances, so you cannot get a fleet-wide 95th percentile from them. Histograms can be aggregated, which is why most teams prefer them.

11. What is an exporter?

A process that reads metrics from a system and serves them in Prometheus format. node_exporter covers Linux host metrics, blackbox_exporter probes endpoints over HTTP, TCP, ICMP and DNS, and there are exporters for MySQL, PostgreSQL, Redis and many more.

12. What default ports should you know?

Prometheus server 9090, Alertmanager 9093, Pushgateway 9091, node_exporter 9100 and blackbox_exporter 9115. These are defaults and can be changed with flags.

13. What is the up metric?

A synthetic series Prometheus writes for every target on every scrape: 1 if the scrape succeeded, 0 if it failed. up == 0 is the simplest "target down" alert.

14. What does prometheus.yml contain?

The global block (default scrape and evaluation intervals, external labels), rule_files, alerting (Alertmanager addresses), scrape_configs and optional remote_write and remote_read sections.

global:
  scrape_interval: 15s
  evaluation_interval: 15s
rule_files:
  - "rules/*.yml"
alerting:
  alertmanagers:
    - static_configs:
        - targets: ["alertmanager:9093"]
scrape_configs:
  - job_name: node
    static_configs:
      - targets: ["node1:9100", "node2:9100"]

15. What is a job and what is an instance?

An instance is one endpoint you scrape, usually host:port. A job is a collection of instances with the same purpose. Prometheus attaches job and instance labels to every scraped series automatically.

16. What is PromQL?

The Prometheus query language. It selects series by name and labels, applies functions over time ranges, and aggregates across labels. Grafana dashboards, recording rules and alerts all use PromQL.

17. What is the difference between an instant vector and a range vector?

An instant vector has one sample per series at the evaluation time, for example node_load1. A range vector has a window of samples per series, written with brackets, for example node_cpu_seconds_total[5m]. Functions such as rate() take a range vector and return an instant vector.

18. How do you filter by label?

Use matchers in braces: = equal, != not equal, =~ regex match and !~ regex not match. Example: http_requests_total{job="api",code=~"5.."}.

19. What does rate() do?

It returns the per-second average increase of a counter over the range you give it, and it handles counter resets. rate(http_requests_total[5m]) gives requests per second averaged over five minutes.

20. What is the difference between rate(), irate() and increase()?

rate() averages over the whole window and suits alerts and slow-moving graphs. irate() uses only the last two samples, so it reacts quickly but is noisy. increase() returns the total increase over the window, which is rate() multiplied by the window length in seconds.

21. What are aggregation operators?

Operators that combine series: sum, avg, min, max, count, topk, bottomk, quantile, stddev and others. Use by to keep labels or without to drop them, for example sum by (job) (rate(http_requests_total[5m])).

22. What is Alertmanager?

A separate service that receives alerts from Prometheus, removes duplicates, groups related alerts, applies silences and inhibition, and sends notifications to receivers such as email, Slack, PagerDuty, Opsgenie or webhooks.

23. What is the Pushgateway for?

Short-lived batch jobs that finish before Prometheus can scrape them. The job pushes its final metrics to the Pushgateway, and Prometheus scrapes the Pushgateway. The docs warn against using it to turn Prometheus into a push system for long-running services.

24. Where does Prometheus store data?

In its own local time series database (TSDB) on disk, under the directory set by --storage.tsdb.path. Recent data sits in an in-memory head block protected by a write-ahead log, and older data is written to two-hour blocks that are later compacted.

25. What is the default retention period?

15 days. Change it with --storage.tsdb.retention.time, or cap disk use with --storage.tsdb.retention.size. When both are set, whichever limit is hit first applies.

26. What is service discovery?

The way Prometheus finds targets automatically instead of using a static list. Built-in mechanisms include Kubernetes, Consul, DNS, file-based discovery, AWS EC2, Azure, GCE and others.

27. What labels does Prometheus add during scraping?

job and instance. During discovery it also attaches temporary meta labels starting with __meta_, which you can turn into real labels with relabeling. Labels beginning with __ are dropped after relabeling.

28. How do you check a configuration file before reloading?

Run promtool check config prometheus.yml. For rule files use promtool check rules. Both return a non-zero exit code on errors, so they fit into CI.

29. How do you reload configuration without restarting?

Send SIGHUP to the process, or send an HTTP POST to /-/reload if Prometheus was started with --web.enable-lifecycle. A failed reload keeps the old configuration running.

30. What is Grafana's role next to Prometheus?

Grafana is a visualisation tool. It uses Prometheus as a data source, runs PromQL queries and shows the results in dashboards. Prometheus has its own expression browser, but teams use Grafana for shared dashboards.

Prometheus interview questions for 2 to 5 years of experience

31. How do you calculate a 95th percentile latency from a histogram?

Take the rate of the bucket series, aggregate while keeping le, then apply histogram_quantile().

histogram_quantile(0.95, sum by (le) (rate(http_request_duration_seconds_bucket[5m])))

Keep other labels, such as service, in the by clause if you want a percentile per service.

32. Why is a histogram percentile an estimate?

Prometheus only knows how many observations fell into each bucket, so it interpolates linearly inside the bucket. Accuracy depends on where your bucket boundaries sit. Native histograms reduce this problem with many automatically sized buckets.

33. What are native histograms?

A histogram type that stores buckets in a single sample with exponential boundaries instead of one series per bucket. They give better resolution at lower cost. Prometheus v3.8 marked them stable, and you enable scraping with the scrape_native_histograms setting; remote write needs send_native_histograms.

34. What is a recording rule?

A rule that evaluates a PromQL expression on a schedule and saves the result as a new series. It makes expensive dashboard queries cheap and gives alerts a stable input.

groups:
  - name: api
    rules:
      - record: job:http_requests:rate5m
        expr: sum by (job) (rate(http_requests_total[5m]))

35. What naming convention do recording rules use?

The documented pattern is level:metric:operations. level lists the labels kept, metric is the original name, and operations lists what was applied, for example job:http_requests:rate5m.

36. How do you write an alerting rule?

groups:
  - name: availability
    rules:
      - alert: HighErrorRate
        expr: sum by (job) (rate(http_requests_total{code=~"5.."}[5m]))
              / sum by (job) (rate(http_requests_total[5m])) > 0.05
        for: 10m
        labels:
          severity: page
        annotations:
          summary: "{{ $labels.job }} error rate above 5%"

The alert fires when the expression returns a result for at least the for duration.

37. What is the for clause, and what is keep_firing_for?

for keeps an alert pending until the condition has held for that long, which filters out short spikes. keep_firing_for keeps an alert firing for a set time after the condition clears, which stops flapping alerts from resolving and re-firing repeatedly.

38. What are the states of an alert?

Inactive, pending (condition true but for not yet satisfied) and firing. Only firing alerts are sent to Alertmanager.

39. What do grouping, inhibition and silences mean in Alertmanager?

Grouping combines related alerts into one notification using group_by labels. Inhibition mutes some alerts while another is firing, for example muting service alerts when the whole cluster is down. Silences mute matching alerts for a fixed time, usually during maintenance.

40. Explain group_wait, group_interval and repeat_interval.

group_wait is how long Alertmanager waits to collect alerts for a new group before the first notification. group_interval is the wait before sending an update when new alerts join an existing group. repeat_interval is how often an unchanged firing group is re-sent.

41. How does the Alertmanager routing tree work?

Every alert enters the root route and moves down child routes whose matchers fit its labels. The first matching child wins unless continue: true is set. Each route can set its own receiver, grouping and timing.

42. What is the difference between relabel_configs and metric_relabel_configs?

relabel_configs runs before the scrape and works on targets: it decides which targets to keep and sets their labels. metric_relabel_configs runs after the scrape on each sample, so it can drop or rename individual series before they are stored.

43. What relabel actions are commonly used?

replace, keep, drop, labelmap, labeldrop, labelkeep and hashmod. Prometheus 3 also has lowercase, uppercase, keepequal and dropequal.

44. How does Kubernetes service discovery work?

Prometheus queries the Kubernetes API for objects of a chosen role: node, pod, service, endpoints, endpointslice or ingress. Each discovered target carries __meta_kubernetes_* labels, such as namespace and pod labels, that you use in relabeling.

45. What is the Prometheus Operator?

A Kubernetes operator that manages Prometheus and Alertmanager through custom resources. Its CRDs include Prometheus, Alertmanager, ServiceMonitor, PodMonitor, PrometheusRule, Probe, ScrapeConfig and AlertmanagerConfig. The kube-prometheus-stack Helm chart packages it with Grafana and default dashboards.

46. What is the difference between a ServiceMonitor and a PodMonitor?

A ServiceMonitor selects Kubernetes Services and scrapes their endpoints. A PodMonitor selects pods directly, which is useful when there is no Service in front of them. Both tell the operator to generate scrape configuration.

47. What does honor_labels do?

When set to true, labels in the scraped data win over conflicting labels Prometheus would attach, such as job and instance. It is normally used for the Pushgateway and federation, where the original labels must survive.

48. What is federation?

One Prometheus scrapes selected series from another through its /federate endpoint with match[] parameters. It is used to pull aggregated data up to a global server, not to copy everything; for full copies, remote write is the better tool.

49. What is the lookback delta?

When a query needs a value at a given time, Prometheus looks back up to five minutes by default for the latest sample. You can change this with --query.lookback-delta. Series that disappear are marked stale so they stop showing in queries quickly.

50. What do the offset and @ modifiers do?

offset 1w shifts a selector back in time, useful for comparing this week with last week. @ 1700000000 pins evaluation to a fixed Unix timestamp, and @ end() pins it to the end of the query range.

51. How do you alert when a metric disappears?

Use absent() or absent_over_time(). absent(up{job="payments"}) returns 1 when no series match, which catches a job that vanished from service discovery entirely, a case up == 0 cannot catch.

52. How do you predict disk exhaustion?

Use predict_linear() on a gauge. This alert fires if the filesystem will run out of space within four hours based on the last six hours of data:

predict_linear(node_filesystem_avail_bytes{fstype!="tmpfs"}[6h], 4*3600) < 0

53. How do you join two metrics with different labels?

Use vector matching with on() or ignoring(), and group_left() or group_right() for many-to-one joins. A common pattern multiplies a metric by an info metric such as kube_pod_info to borrow its labels.

54. How do you unit test rules?

Write a test file with input series and expected results, then run promtool test rules tests.yml. It checks both recording rule outputs and which alerts fire at given times, so rule changes can be tested in CI.

55. What is blackbox monitoring with Prometheus?

Probing a service from outside instead of reading its internal metrics. blackbox_exporter does HTTP, TCP, ICMP, DNS and gRPC probes and exposes results such as probe_success and probe_duration_seconds. It catches DNS, TLS and routing failures that white-box metrics miss.

56. How do you monitor TLS certificate expiry?

blackbox_exporter exposes probe_ssl_earliest_cert_expiry as a Unix timestamp. Alert with probe_ssl_earliest_cert_expiry - time() < 14 * 86400 to get two weeks' notice.

57. What are exemplars?

Extra data attached to a sample, usually a trace ID, so you can jump from a latency spike on a graph to an example trace. Storage is enabled with --enable-feature=exemplar-storage, and the client must expose them in OpenMetrics format.

58. How do you secure the Prometheus web endpoint?

Use the web configuration file passed with --web.config.file to enable TLS and basic authentication with bcrypt-hashed passwords. Many teams also put an authenticating reverse proxy in front and restrict network access to port 9090.

Senior Prometheus interview questions

59. What is cardinality, and why does it matter?

Cardinality is the number of unique series. Each series costs memory in the head block and index space on disk, so a label with unbounded values, such as user ID, request ID or full URL, can multiply series until Prometheus runs out of memory.

60. How do you find high-cardinality metrics?

Open the TSDB status page in the UI or call /api/v1/status/tsdb, which lists the metric names and label pairs with the most series. A query like topk(10, count by (__name__) ({__name__=~".+"})) works too but is expensive on a big server.

61. How do you reduce cardinality?

Remove unbounded labels in the application, drop unused series with metric_relabel_configs, set sample_limit and label_limit per scrape job so a bad deploy cannot flood the server, and replace per-request detail with histograms or logs and traces.

62. How do you run Prometheus in high availability?

Run two identical servers scraping the same targets, with different external_labels for the replica. Point both at a clustered Alertmanager, which deduplicates notifications. For a single deduplicated query view, put Thanos Query or a remote storage backend in front.

63. How do you cluster Alertmanager?

Run several instances with --cluster.peer flags pointing at each other. They share silences and notification state over a gossip protocol. Prometheus should send alerts to every instance, not through a load balancer.

64. What is remote write?

A protocol that streams samples from Prometheus to another system as they are ingested. It is used for long-term storage, global views and managed services. Prometheus 3.0 added Remote Write 2.0, which supports metadata, exemplars, created timestamps and native histograms in the same message.

65. What are the options for long-term storage?

Thanos (sidecar or receiver writing blocks to object storage), Grafana Mimir and Cortex (horizontally scaled remote write backends), VictoriaMetrics, and managed services such as Amazon Managed Service for Prometheus and Google Cloud Managed Service for Prometheus. All of them answer PromQL.

66. What is agent mode?

A mode, started with the --agent flag, where Prometheus scrapes and remote-writes but does not store data for querying or evaluate rules. It uses less memory and suits edge clusters that forward everything to a central store.

67. How do you tune remote write when it falls behind?

Watch prometheus_remote_storage_highest_timestamp_in_seconds against the sent timestamp to measure lag, then adjust queue_config: max_shards, capacity and max_samples_per_send. Check the receiver's capacity and network first, because more shards only help if the backend can accept more.

68. How should alerts be designed for on-call?

Page on symptoms users feel, such as error rate and latency against an SLO, and send cause-based alerts like high CPU to a ticket queue or dashboard. Every paging alert should need a human action and link to a runbook in its annotations.

69. What is multi-window, multi-burn-rate alerting?

An SLO alerting method from the Google SRE Workbook. You alert when the error budget is being spent fast over both a long and a short window, for example a 14.4x burn rate over one hour and five minutes for paging, and a slower burn over six hours for tickets. It catches real problems quickly without paging on brief blips.

70. How do you shard scraping across several servers?

Use the hashmod relabel action to split targets by a hash of their address, and keep only the share that matches each server's number. The Prometheus Operator supports this through the shards field. Queries then need a global layer such as Thanos to see all shards together.

71. What changed in Prometheus 3.0 that matters for upgrades?

A new default UI (the old one stays behind the old-ui feature flag), UTF-8 support in metric and label names, the OTLP receiver, Remote Write 2.0, stricter scrape protocol handling, and removal of several deprecated flags. Read the migration guide and test rules and dashboards before upgrading.

72. How does Prometheus ingest OpenTelemetry metrics?

Enable the OTLP receiver with --web.enable-otlp-receiver, and OpenTelemetry SDKs or the Collector can send metrics to /api/v1/otlp/v1/metrics. Settings under otlp in the config control how resource attributes become labels and how names are translated.

Scenario-based Prometheus interview questions

73. A target shows as DOWN on the Targets page. What do you check?

Read the error shown on the Targets page first. Then test from the Prometheus host with curl http://target:port/metrics to separate network problems from exporter problems. Common causes are a firewall or network policy, a wrong port, TLS settings, a timeout shorter than the scrape takes, or the exporter crashing.

74. Prometheus memory keeps climbing after a new release of an application. Why?

Most likely a cardinality explosion from a new label. Check prometheus_tsdb_head_series over time and the TSDB status page to find the metric. Drop the series with metric_relabel_configs as a quick fix, set sample_limit on the job, and get the label removed in the code.

75. Your alert never fires even though the graph shows the problem. What could be wrong?

Check that the rule file is loaded on the Rules page, that the expression returns data in the expression browser, and that the for duration is not longer than the spikes. Also confirm Prometheus can reach Alertmanager (prometheus_notifications_dropped_total) and that no silence or inhibition rule matches the alert.

76. The on-call engineer receives fifty alerts for one outage. How do you fix that?

Group alerts by labels such as cluster and alertname, add inhibition so a cluster-level or node-down alert mutes the dependent service alerts, and remove cause-based pages that duplicate the symptom alert. Review the last few incidents to see which alerts helped.

77. A Grafana panel using rate() shows gaps or jumps when you zoom in. Why?

The range in rate() is probably shorter than about four scrape intervals, so some windows hold fewer than two samples. Use a longer range or Grafana's $__rate_interval variable, which accounts for the scrape interval.

78. Disk on the Prometheus server is almost full. What do you do?

Set --storage.tsdb.retention.size so Prometheus deletes the oldest blocks before the disk fills, find which jobs add the most series, and drop what nobody uses. For history beyond local retention, add remote write or Thanos with object storage instead of growing the disk forever.

79. Two Prometheus replicas send duplicate notifications. What is wrong?

Either the Alertmanagers are not clustered, so each one notifies on its own, or the replicas send to different Alertmanager instances that do not gossip. Cluster Alertmanager and make both replicas send to all members. Keep the replica label out of alert labels or Alertmanager will treat the alerts as different.

80. Pods in a new namespace are not being scraped by the Prometheus Operator. Why?

The Prometheus resource selects ServiceMonitors with serviceMonitorSelector and serviceMonitorNamespaceSelector. If the new namespace or the ServiceMonitor labels do not match, it is ignored. Also check that the ServiceMonitor port name matches the Service port and that RBAC allows Prometheus to list endpoints in that namespace.

81. A batch job's metric stays at its last value forever after the job stops. Why?

The job pushes to the Pushgateway, which keeps metrics until they are deleted. Have the job push a timestamp metric such as last_success_time and alert on its age, and delete the group with the Pushgateway API when the job is retired.

82. Queries on a dashboard time out. How do you speed them up?

Move heavy expressions into recording rules, narrow selectors with label matchers, shorten the dashboard's default time range, and check prometheus_engine_query_duration_seconds. The --query.max-samples and --query.timeout flags protect the server but will not make a bad query fast.

83. Counter values look wrong after a pod restart. Is that a bug?

No. Counters reset to zero on restart, and rate() and increase() detect the drop and adjust. Problems appear only if you use the raw counter or delta(), which is meant for gauges.

84. Management asks for 13 months of metrics for capacity planning. How do you deliver it?

Keep local retention short and send data to a long-term store with downsampling, such as Thanos compactor with object storage or Mimir. Store aggregated recording rules for planning metrics so the long-term data is small, and agree which metrics actually need 13 months.

How to prepare for a Prometheus interview

  1. Run Prometheus, node_exporter and Alertmanager with Docker Compose and break things on purpose: stop an exporter, add a bad label, fill a disk.
  2. Write ten PromQL queries from memory, including a percentile, an error ratio and a predict_linear() alert.
  3. Install kube-prometheus-stack on a local cluster and add a ServiceMonitor for your own app.
  4. Read the Google SRE Workbook chapter on alerting on SLOs and be ready to explain burn rates.
  5. If you want a credential, the Linux Foundation offers the Prometheus Certified Associate (PCA) exam. Check its page for the current syllabus.

Our Prometheus and Grafana training covers these labs in the Kharadi, Pune classroom and live online. For broader preparation, the SRE interview questions, the explainer on observability versus traditional monitoring and the 200+ DevOps interview questions hub fill in the surrounding topics.

Frequently asked questions

Is Prometheus hard to learn for freshers?

The basics are quick: you can run it and query up in an hour. PromQL takes longer. Most freshers need a week or two of practice with rate(), aggregation and histograms before they are comfortable in interviews.

Do I need Kubernetes to learn Prometheus?

No. Start with Prometheus and node_exporter on a Linux VM or Docker. Add Kubernetes service discovery and the Prometheus Operator once the core ideas are clear, because most job descriptions expect both.

What is the difference between Prometheus and Grafana?

Prometheus collects, stores and queries metrics and evaluates alerts. Grafana visualises data from Prometheus and many other sources. They are used together but do different jobs.

Can Prometheus store metrics long term?

Local storage is designed for weeks, not years, and is not clustered. For long-term or global storage, use remote write to systems such as Thanos, Grafana Mimir, Cortex, VictoriaMetrics or a managed Prometheus service.

When should I use a histogram instead of a summary?

Use a histogram when you need percentiles across many instances or want to change the percentile later in the query. Use a summary only when you need exact quantiles from a single process and will never aggregate them.

Is there a Prometheus certification?

Yes. The Linux Foundation and CNCF offer the Prometheus Certified Associate (PCA). Check the Linux Foundation Training page for the current domains, format and price.

What changed in Prometheus 3?

Prometheus 3.0 added a new UI, UTF-8 metric and label names, an OTLP receiver and Remote Write 2.0, and removed some deprecated flags. Native histograms later became stable in v3.8, with scraping turned on through scrape_native_histograms.

References

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.