Pith. sign in

REVIEW 3 major objections 4 minor 112 references

Approximation-First Timeseries Monitoring Query At Scale

T0 review · 3 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read PromSketch caches overlapping window aggregations in compact sketches, cutting rule-query latency by up to two orders of magnitude while keeping mean errors at 5% or below.

desk verdict Real system, real latency wins, but the 400x cost claim prices the measured ingestion overhead at zero. read the letter →

arxiv 2505.10560 v1 pith:PIO2RF3V submitted 2025-05-15 cs.DB cs.NI

Zeying Zhu , Jonathan Chamberlain , Kenny Wu , David Starobinski , Zaoxing Liu This is my paper · ORCID
classification cs.DBcs.NI
keywords timeseriesmonitoringapproximatequeryprocessingrulequeriesExponentialHistogramKLLsketchuniversalslidingwindowcaching
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

PromSketch sets out to show that the dominant cost of timeseries monitoring rule queries is wasted work: periodic queries over overlapping windows repeatedly scan the same samples and recompute the same aggregations. The paper claims that an in-memory cache of approximate intermediate summaries, built from Exponential Histograms combined with quantile, universal, and sampling sketches, can serve a large share of these queries—covering 70% of Prometheus' aggregation-over-time functions—with mean errors at or below 5%. If true, a Prometheus-compatible engine could cut rule-query latency by up to two orders of magnitude and query-processing cost by roughly 400x versus Prometheus and at least 4x versus VictoriaMetrics without increasing storage or ingestion charges. That would change the default economics of alerting and recording rules for large cluster monitoring.

What carries the argument

The load-bearing mechanism is the Exponential Histogram used as a cache index: a sequence of non-overlapping buckets whose sizes grow exponentially as they age, each bucket holding a sketch. Because EH buckets are mergeable (the target statistics are weakly additive), a query over any sub-window $(t_1,t_2)$ is answered by merging the buckets strictly between the two boundary buckets, with the discarded boundary buckets contributing controlled rank or norm error. The paper pairs EH with KLL sketches for quantiles (EHKLL), with universal sketches for GSum statistics (EHUniv), and with uniform sampling for sum/avg/stddev, and adds a hybrid optimization in which small buckets keep exact item-frequency maps before converting to sketches. This machinery is what lets the cache answer many overlapping and drill-down windows from one compact in-memory structure.

What would settle it

Run the Table 1 1000-node, 268-billion-sample workload on the released PromSketch code and bill the extra ingestion CPU (the measured 1.3x–3x insertion slowdown) at the same per-vCPU-hour rate the paper applies to query processing; if the resulting total monthly cost is not roughly two orders of magnitude below Prometheus's, the central cost claim is falsified.

Watch

Extended reading notes

Core claim

The central discovery is that repeated data scans and repeated query computations over overlapping windows are the two bottlenecks in rule-query engines, and both can be bypassed by caching intermediate results rather than raw samples or final answers. PromSketch maintains, per timeseries, an Exponential Histogram whose buckets hold composable sketches—KLL sketches for quantiles (and min/max), universal sketches for entropy, distinct count, L2 norm, and top-k, and a sliding-window uniform sample for average, sum, and variance. Any sub-window of the recent window is answered by merging the buckets that cover it, so a 5-, 10-, or 15-minute drill-down can be served from the same cached structure without rescanning storage. The paper proves rank-error bounds for the EH+KLL combination (final normalized rank error at most $2\epsilon_{EH}+\epsilon_{KLL}$) and memory bounds for the EH+universal-sketch combination, and it reports end-to-end latency and cost results on synthetic and real traces.

Load-bearing premise

The cost-reduction numbers assume that the ingestion-time sketching work, which the paper itself measures as a 1.3x–3x insertion-throughput slowdown, is operationally free: Table 1 charges PromSketch only for query processing while keeping storage and data-ingestion costs at the uncached baseline.

Editorial extensions

If this is right

  • Rule queries with overlapping windows, such as 10-minute windows evaluated every minute, can be served from precomputed bucket merges, so alerting and recording rules no longer rescan storage on every evaluation.
  • Drill-down queries that zoom from a 1M-sample window into 100K and 10K sub-windows keep mean errors under 5% at a fraction of the memory of exact storage, which supports anomaly localization on the same cache.
  • Operators can trade memory for accuracy explicitly through knobs such as $k_{EH}$ and $k_{KLL}$, since error decreases as memory grows for all evaluated statistics.
  • Because the cache is a standalone module integrated through a small query-parser patch, the same design transfers to any PromQL-like engine, including distributed deployments where nodes shard timeseries by consistent hashing.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper, the cost comparison depends heavily on the query-to-ingestion ratio: PromSketch's advantage should grow with more frequent rule evaluations and shrink for workloads that mostly ingest data and rarely query, since the ingestion-path overhead remains in either case.
  • Beyond the paper, the same EH-as-cache design could be applied to label-dimensional aggregation or to metrics with string values beyond IP addresses, since universal sketches operate on any item universe, though the paper leaves that extension unproven.
  • Beyond the paper, because small EH buckets use exact maps, a natural adaptive policy would set bucket sizes so that typical drill-down queries touch only exact-map buckets, potentially pushing mean error far below 5% for common workloads.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper proposes PromSketch, an approximate in-memory intermediate-result cache for Prometheus-compatible timeseries monitoring systems. The system maintains Exponential Histogram (EH) buckets over recent time windows, using KLL sketches per bucket for quantile queries, universal sketches with an exact-map hybrid for GSum statistics (entropy, distinct count, L2 norm, top-K), and uniform sampling for average/stddev queries. At query time it answers overlapping sub-window aggregations by merging bucket sketches instead of rescanning raw samples. The authors provide error-bound analyses for EHKLL and EHUniv, describe single-machine and distributed integrations into Prometheus and VictoriaMetrics, and report experiments on synthetic and real traces claiming mean errors at or below 5%, latency reductions of up to about 200x, and query-processing cost reductions of 400x versus Prometheus and at least 4x versus VictoriaMetrics. They also report ingestion-throughput slowdowns of 1.3-3.1x over Prometheus and 1.4-7.2x over VictoriaMetrics in §6.1.3.

Significance. If the cost accounting is corrected and the sub-window error bound is fixed, this is a substantial contribution: it is, to my knowledge, the first end-to-end approximate intermediate-cache design for overlapping time-window rule queries in Prometheus-like systems; it combines a general window framework with mergeable sketches and includes provable memory-accuracy statements; and it ships a public Go implementation and uses public datasets. The latency and error measurements in Table 4 and Figures 6-13 are systematic, repeated, and reported against two real baselines, which is a genuine strength. The two issues below, however, affect the two headline claims (cost reduction and guaranteed sub-window accuracy), so the paper needs revision before the claims can be accepted as stated.

major comments (3)
  1. [§6.1.1, Table 1; §6.1.3, Fig. 7] The headline cost reductions of 400x and at least 4x are computed with an incomplete cost model. Table 1 keeps PromSketch's ingestion costs at the baseline ($9,186 for PS-PM and 'incl.' for PS-VM) while moving query processing to $28.6/month, and §6.1.1 states that PromSketch reduces query-processing cost 'while not increasing the storage and data ingestion costs.' But §6.1.3 and Fig. 7 measure a 1.3-3.1x insertion-throughput slowdown over Prometheus and a 1.4-7.2x slowdown over VictoriaMetrics, so the precomputation consumes real CPU on the ingestion path. Under the resource-based billing model used for VictoriaMetrics in the same table, those cycles are billable; under a per-sample model, reprocessing the 268B samples at the paper's own $0.1/B-sample query rate would add roughly $26.8/month to the PS-PM row. Please recompute the cost comparison with the ingestion-path precomputation priced (e.g., vCPU-hour for PS-VM and per-sample for PS-PM), report both query-path and total operational costs, and state explicitly whether the 'two orders of magnitude' claim refers only to query-path spend.
  2. [§4.2.1, EHKLL Error Guarantee] The sub-window rank-error analysis for EHKLL appears incorrect. The text says the total rank difference from the EH sub-window query is at most C_i - C_j, where B_i is the discarded bucket containing t1 and B_j is the included bucket containing t2. Each of these buckets contributes a nonnegative error: excluding part of B_i misses up to C_i items, and including all of B_j adds up to C_j items after t2. The combined rank error should therefore be bounded by a sum of the two contributions (or by max(C_i, C_j) in the best case), not by their difference. As written, C_i - C_j is non-positive under Invariant 2 (C_1 <= ... <= C_l), so the subsequent upper bound of 2*epsilon_EH * N_t1/(N_t1 - N_t2) + epsilon_KLL does not follow. Please rederive this bound with absolute values or explicit worst-case analysis, and state the assumptions needed for the claimed sub-window guarantee.
  3. [§4.2.1, Algorithm 1 and query semantics] The sub-window query procedure in Algorithm 1 includes the whole bucket B_j when t2 falls strictly inside B_j, which adds the suffix of B_j after t2 to the approximate window. The error analysis should explicitly account for this suffix, since the stated guarantee is for the window (t1, t2). The current discussion mentions that B_j contributes at most C_j, but the formula then uses C_i - C_j, and the relationship between the approximate window [end(B_i), end(B_j)] and the true window [t1, t2] is never made precise. A precise statement of which samples are included and excluded would also resolve the sign issue in the preceding comment.
minor comments (4)
  1. [§2.3 and §6.1.1] The AWS Prometheus cost figures are internally inconsistent: the Introduction gives $11,520 for query processing and $9,256 for ingestion, while §6.1.1 gives $11,560 and $9,186, and Table 1 gives $11,520 and $9,186. Please harmonize these numbers and show the arithmetic, since 10 queries/minute each processing 8B samples per month does not obviously produce $11,520 at the stated $0.1/B-samples rate without additional assumptions.
  2. [Abstract and Table 3] The claim that PromSketch covers '70% of Prometheus' aggregation over time queries' is not supported by any query-corpus analysis. Please state the query corpus, the weighting of queries, and the counting methodology that yields the 70% figure.
  3. [§6.1.2 and Table 4] The body text says the drill-down queries cover '10^5-, 10^4-, and 10^3-second time windows' while the Table 4 caption says '10K-, 100K-, and 1M-sample windows.' Please clarify whether the axes are time durations or sample counts, and use consistent units throughout.
  4. [Throughout] There are several typographical errors and inconsistent spellings, e.g., 'remoevd' in §4.3, 'Kubernates' in the introduction and §4.4, and 'Google Promethues' in reference [101]. A thorough proofreading pass is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the latency/accuracy claims come from independent experiments, and the cost-model caveat about free precomputation is an accounting limitation rather than a self-referential derivation.

full rationale

The paper's central latency, throughput, and accuracy results are measured end-to-end against Prometheus and VictoriaMetrics on public and synthetic datasets, so they are not generated by the paper's own prior claims. EHKLL's error bound is derived from Exponential Histogram invariants [60] and KLL's rank-error guarantee [72], both external; EHUniv's construction and guarantees are cited to [69], which shares an author with the present paper, but [69] is a published theorem with assumptions that do not include the present evaluation targets, so under the stated rules it is independent support rather than a circular self-citation. No fitted constants are renamed as predictions: the 5% accuracy target is an explicit configuration objective (k_EH, k_KLL), and the reported errors are measured, not assumed. The one substantive caveat is the operational-cost model: §6.1.1 claims PromSketch reduces query-processing cost 'while not increasing the storage and data ingestion costs,' yet §6.1.3/Fig. 7 measures a 1.3–3.1x insertion-throughput slowdown for the Prometheus integration and 4.1–4.5x for EHKLL/EHUniv on VictoriaMetrics, meaning sketch precomputation consumes real CPU that Table 1 does not price. That is a limitation in the cost accounting (the 400x and 4x ratios are arithmetic consequences of the chosen billing assumptions), but it is not circular: the cost estimate is an explicit model-based calculation, not a prediction that reduces to its own inputs, and it does not contaminate the independent latency/accuracy measurements.

Assumptions & free parameters 4 free parameters · 6 assumptions · 0 invented entities

There are no invented physical or mathematical entities. The free parameters are user-specified accuracy knobs rather than hidden data-fitted constants. The axioms combine standard sketch theory from the cited literature with two domain assumptions: that monitoring workloads are periodic and overlapping, and that approximate answers are acceptable for alerting and recording rules.

free parameters (4)
  • EH bucket parameter k_EH (EHKLL) = 50
    User-specified accuracy knob: sets EH rank error epsilon_EH = 1/k_EH. Chosen to target 5% KSTest error, not fit to evaluation data.
  • KLL space parameter k_KLL = 256
    Sets KLL rank-error target via the space limit from [72]. Chosen for 5% error, not fitted to the eval datasets.
  • EH bucket parameter k_EH (EHUniv) = 20
    Sets EH bucket count for L2^2 with error target 5%. Reported memory and error numbers depend on this value.
  • Uniform sampling rate p = 10%
    Sampling probability for sum/avg/stddev cache. Chosen as the main comparison configuration in the evaluation.
assumptions (6)
  • standard math Target functions are weakly additive or admit composable sketches (Eq. 1)
    EH error guarantees require weak additivity with constant C_f for functions like sum, L2^2, and quantile rank; cited to Datar et al. [60] and Ivkin et al. [69].
  • standard math Universal sketching GSum estimation theorem (Theorem 2 in [52])
    Alg. 2's error bounds rely on Braverman et al.'s theorem that GSum functions with certain growth conditions can be estimated in sub-linear space; the paper does not re-derive this theorem.
  • standard math KLL sketches are mergeable with rank error guarantees
    EHKLL merges KLL sketches across EH buckets; mergeability and rank-error bounds are cited to Karnin et al. [72].
  • domain assumption Monitoring rule queries tolerate approximate results
    The paper states that applications tolerate approximate but highly accurate results (§2.4), but it does not validate this against actual alerting thresholds.
  • domain assumption Out-of-order and duplicate samples are rejected upstream
    PromSketch assumes the same data-ordering model as Prometheus and VictoriaMetrics, placing the cache after deduplication and reordering (§4.3).
  • domain assumption Rule query workload is dominated by periodic overlapping windows
    The motivation and evaluation assume repeated rule queries with overlapping windows; non-repeated, ad-hoc queries would not benefit from the cache.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Approximation-First Timeseries Monitoring Query At Scale." pith.science (2026). https://pith.science/paper/PIO2RF3V

@misc{pith2026250510560,
  author       = {Pith},
  title        = {Pith review of: Approximation-First Timeseries Monitoring Query At Scale},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PIO2RF3V}},
  note         = {Machine review of arXiv:2505.10560}
}
read the original abstract

Timeseries monitoring systems such as Prometheus play a crucial role in gaining observability of the underlying system components. These systems collect timeseries metrics from various system components and perform monitoring queries over periodic window-based aggregations (i.e., rule queries). However, despite wide adoption, the operational costs and query latency of rule queries remain high. In this paper, we identify major bottlenecks associated with repeated data scans and query computations concerning window overlaps in rule queries, and present PromSketch, an approximation-first query framework as intermediate caches for monitoring systems. It enables low operational costs and query latency, by combining approximate window-based query frameworks and sketch-based precomputation. PromSketch is implemented as a standalone module that can be integrated into Prometheus and VictoriaMetrics, covering 70% of Prometheus' aggregation over time queries. Our evaluation shows that PromSketch achieves up to a two orders of magnitude reduction in query latency over Prometheus and VictoriaMetrics, while lowering operational dollar costs of query processing by two orders of magnitude compared to Prometheus and by at least 4x compared to VictoriaMetrics with at most 5% average errors across statistics. The source code has been made available at https://github.com/Froot-NetSys/promsketch.

Figures

Figures reproduced from arXiv: 2505.10560 by the authors.

Figure 1
Figure 1. A Prometheus monitoring ecosystem with PromSketch. In this paper, we revisit the promises of approximate analytics to improve operational efficiency and performance in timeseries monitoring systems. We present PromSketch, an approximate query cache that improves operational cost and query latency by up to two orders of magnitude while preserving high accuracies (e.g., >95%). In contrast to Prometheus’ independent qu… view at source ↗
Figure 3
Figure 3. Timeseries data and different types of queries in Prometheus. Each row is a timeseries identified by its labels. metric recording the CPU usage of each node and each core can be represented as cpu_usage{node_id=“node0”,cpu_id=“0”}, spec￾ified with labels of node ID and CPU core ID. Queries. Monitoring systems like Prometheus offer various queries for downstream applications, especially alerting and recording rules [… view at source ↗
Figure 4
Figure 4. PromSketch Architecture. Challenge 1: Caching many recent query windows and re￾sults. Query statistics and functions are various in real use cases. Caching all samples ensures generality but is memory-intensive, while caching only final results limits optimization for unforeseen drill-down queries. A raw data cache also fails to reduce redundancy from overlapping query windows. Key Idea. We extend the window-based a… view at source ↗
Figures from the paper (7 more)
Figure 6
Figure 6. Figure 6: Query cost-accuracy analysis of multiple zoomed-in sub-window queries. Normalized costs refer to compute (microseconds) and memory usage (Bytes) costs per set of queries (10K-, 100K, 1M-sample sub-windows) in total. Each bar shows the error region of multiple sub-windo…
Figure 7
Figure 7. Figure 7: Single-Machine data insertion throughput with different timeseries numbers and sliding window sizes on Dynamic dataset for (a) PromSketch, (b) PromSketch integrated to Prometheus, and (c) PromSketch integrated to VictoriaMetrics; (d) insertion scalability with differen…
Figure 8
Figure 8. Figure 8: Uniform sampling’s mean average estimation error for (a) memory-error in 300-600K intervals, and (b) various sub-windows. A legend label x% refers to a configuration with x% sampling rate. 0 2 4 6 8 Memory Requirement (MB) 0.00 0.01 0.02 0.03 KSTest Error Google Power …
Figure 9
Figure 9. Figure 9: EHKLL’s mean quantile estimation KSTest error for (a) memory-error in 300K-600K intervals, and (b) various sub-window sizes. A legend label x-y(z MB) denotes an EHKLL configuration with 𝑘𝐸𝐻 = 𝑥, 𝑘𝐾𝐿𝐿 = 𝑦, and 𝑧 MB total memory. 4 5 6 7 Memory Requirement (MB) 0.0 0.1 0…
Figure 10
Figure 10. Figure 10: EHUniv’s mean relative errors of entropy, distinct count￾ing, and 𝐿2 norm estimation for (a) memory-error in 300K-600K intervals, and (b) various suffix lengths on CAIDA2018. A legend label x(z MB) denotes an EHUniv configuration with 𝑘𝐸𝐻 = 𝑥, a 16-layer universal ske…
Figure 13
Figure 13. Figure 13: TopK-frequent item estimation comparing to Micro￾scopeSketch with HeavyGuardian (HG) and SpaceSaving (SS). 6.2.2 Memory with different timeseries numbers and sliding window sizes. We evaluate PromSketch memory consumption under 5% error target and 1M-sample sliding wi…
Figure 12
Figure 12. Figure 12: Memory usage with sliding window sizes. In (a), a legend label x-y denotes an EHKLL configuration with 𝑘𝐸𝐻 = 𝑥, 𝑘𝐾𝐿𝐿 = 𝑦. The exact baseline stores every point with its associated timestamp. 6.2 PromSketch Sensitivity Analysis 6.2.1 Accuracy with different memory cons…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

112 extracted references · 73 canonical work pages

  1. [69]

    Nikita Ivkin, Ran Ben Basat, Zaoxing Liu, Gil Einziger, Roy Friedman, and Vladimir Braverman. 2019. I know what you did last summer: Network mon- itoring using interval queries. Proceedings of the ACM on Measurement and Analysis of Computing Systems 3, 3 (2019), 1–28

    work page 2019

  2. [1]

    Prometheus: Monitoring at SoundCloud

    2015. Prometheus: Monitoring at SoundCloud. https://github.com/pingcap/ docs/blob/master/tidb-monitoring-framework.md

    2015

  3. [2]

    Packets-per-second limits in EC2

    2019. Packets-per-second limits in EC2. Retrieved 2024 from https://stressgrid. com/blog/pps_limits_in_ec2/

    2019

  4. [3]

    Google ClusterData 2019 traces

    2020. Google ClusterData 2019 traces. Retrieved 2024 from https://github.com/ google/cluster-data/blob/master/ClusterData2019.md

    2020

  5. [4]

    Amazon EC2 On-Demand Pricing

    2022. Amazon EC2 On-Demand Pricing. Retrieved 2024 from https://aws. amazon.com/ec2/pricing/on-demand/

    2022

  6. [5]

    Kubernetes

    2022. Kubernetes. https://kubernetes.io/

    2022

  7. [6]

    Prometheus handling out-of-order samples

    2022. Prometheus handling out-of-order samples. Retrieved 2024 from https://promlabs.com/blog/2022/12/15/understanding-duplicate-samples- and-out-of-order-timestamp-errors-in-prometheus/

    2022

  8. [7]

    VictoriaMetrics

    2022. VictoriaMetrics. https://victoriametrics.com

    2022

Show all 112 references
  1. [8]

    PromCon 2023 - Yet Another Streaming PromQL Engine

    2023. PromCon 2023 - Yet Another Streaming PromQL Engine. Retrieved 2024 from https://www.youtube.com/watch?v=3kM2Asj6hcg

    2023

  2. [9]

    Prometheus Metrics based autoscaling in Kubernetes

    2023. Prometheus Metrics based autoscaling in Kubernetes. Retrieved 2024 from https://gcore.com/learning/prometheus-metrics-based-autoscaling-in- kubernetes/

    2023

  3. [10]

    Amazon Managed Service for Prometheus pricing

    2024. Amazon Managed Service for Prometheus pricing. Retrieved 2024 from https://aws.amazon.com/prometheus/pricing/

    2024

  4. [11]

    Awesome Prometheus alerts

    2024. Awesome Prometheus alerts. https://samber.github.io/awesome- prometheus-alerts/

    2024

  5. [12]

    Cloudflare Blog - Monitoring our monitoring: how we validate our Prometheus alert rules

    2024. Cloudflare Blog - Monitoring our monitoring: how we validate our Prometheus alert rules. https://blog.cloudflare.com/monitoring-our- monitoring/

    2024

  6. [13]

    Cluster VictoriaMetrics

    2024. Cluster VictoriaMetrics. Retrieved 2024 from https://docs.victoriametrics. com/cluster-victoriametrics/

    2024

  7. [14]

    DataDog Anomaly Detection

    2024. DataDog Anomaly Detection. https://docs.datadoghq.com/monitors/ types/anomaly/

    2024

  8. [15]

    Fastcache used by VictoriaMetrics

    2024. Fastcache used by VictoriaMetrics. https://github.com/VictoriaMetrics/ fastcache

    2024

  9. [16]

    Google Cloud scales based on Monitoring metrics

    2024. Google Cloud scales based on Monitoring metrics. https://cloud.google. com/compute/docs/autoscaler/scaling-cloud-monitoring-metrics

    2024

  10. [17]

    Google Kubernetes Engine Quotas and Limits

    2024. Google Kubernetes Engine Quotas and Limits. https://cloud.google.com/ kubernetes-engine/quotas

    2024

  11. [18]

    Grafana Dashboards

    2024. Grafana Dashboards. https://grafana.com/grafana/dashboards/

    2024

  12. [19]

    Grafana Mimir

    2024. Grafana Mimir. https://grafana.com/docs/mimir/latest/

    2024

  13. [20]

    Grafana Mimir uses Redis or Memcached as chunks-cache, index-cache, results-cache and metadata-cache

    2024. Grafana Mimir uses Redis or Memcached as chunks-cache, index-cache, results-cache and metadata-cache. https://grafana.com/docs/helm-charts/ mimir-distributed/latest/configure/configure-redis-cache/

    2024

  14. [21]

    InfluxDB

    2024. InfluxDB. https://www.influxdata.com/

    2024

  15. [22]

    Kubernetes monitoring with Prometheus

    2024. Kubernetes monitoring with Prometheus. Retrieved 2024 from https://prometheus.io/docs/prometheus/latest/configuration/configuration/ #kubernetes_sd_config

    2024

  16. [23]

    Memcached

    2024. Memcached. https://memcached.org

    2024

  17. [24]

    Monitoring Juniper Networks with Prometheus

    2024. Monitoring Juniper Networks with Prometheus. Retrieved 2024 from https://github.com/czerwonk/junos_exporter

    2024

  18. [25]

    Open5GS Metrics with Prometheus

    2024. Open5GS Metrics with Prometheus. Retrieved 2024 from https://open5gs. org/open5gs/docs/tutorial/04-metrics-prometheus/

    2024

  19. [26]

    Prometheus Configurations

    2024. Prometheus Configurations. Retrieved 2024 from https://prometheus.io/ docs/prometheus/latest/configuration/configuration/

    2024

  20. [27]

    Prometheus functions

    2024. Prometheus functions. Retrieved 2024 from https://prometheus.io/docs/ prometheus/latest/querying/functions/

    2024

  21. [28]

    Prometheus Query Language

    2024. Prometheus Query Language. Retrieved 2024 from https://prometheus. io/docs/prometheus/latest/querying/basics/

    2024

  22. [29]

    Prometheus SNMP exporter

    2024. Prometheus SNMP exporter. Retrieved 2024 from https://github.com/ prometheus/snmp_exporter

    2024

  23. [30]

    2024. Redis. https://redis.io

    2024

  24. [31]

    2024. Thanos. https://thanos.io/

    2024

  25. [32]

    Thanos Downsampling, Resolution and Retention

    2024. Thanos Downsampling, Resolution and Retention. Retrieved 2024 from https://thanos.io/v0.8/components/compact/

    2024

  26. [33]

    The CAIDA UCSD Anonymized Internet Traces

    2024. The CAIDA UCSD Anonymized Internet Traces. https://www.caida.org/ catalog/datasets/passive_dataset/. Online

    2024

  27. [34]

    VictoriaMetrics Anomaly Detection

    2024. VictoriaMetrics Anomaly Detection. Retrieved 2024 from https://victoriametrics.com/blog/victoriametrics-anomaly-detection- handbook-chapter-2/index.html

    2024

  28. [35]

    VictoriaMetrics backfilling support for out-of-order samples

    2024. VictoriaMetrics backfilling support for out-of-order samples. Retrieved 2025 from https://docs.victoriametrics.com/#backfilling

    2024

  29. [36]

    VictoriaMetrics Deduplication

    2024. VictoriaMetrics Deduplication. Retrieved 2024 from https://docs. victoriametrics.com/#deduplication

    2024

  30. [37]

    VictoriaMetrics parallel query in vm-select

    2024. VictoriaMetrics parallel query in vm-select. https://github.com/ VictoriaMetrics/VictoriaMetrics/issues/2886

    2024

  31. [38]

    VictoriaMetrics Pricing compared to Prometheus

    2024. VictoriaMetrics Pricing compared to Prometheus. Retrieved 2024 from https://victoriametrics.com/blog/managed-prometheus-pricing/

    2024

  32. [39]

    VictoriaMetrics rollup functions

    2024. VictoriaMetrics rollup functions. Retrieved 2024 from https://docs. victoriametrics.com/metricsql/#rollup-functions

    2024

  33. [40]

    VictoriaMetrics Single Version

    2024. VictoriaMetrics Single Version. Retrieved 2024 from https://docs. victoriametrics.com/single-server-victoriametrics/

    2024

  34. [41]

    Lior Abraham, John Allen, Oleksandr Barykin, Vinayak Borkar, Bhuwan Chopra, Ciprian Gerea, Daniel Merl, Josh Metzler, David Reiss, Subbu Subramanian, et al

  35. [42]

    Swarup Acharya, Phillip B Gibbons, Viswanath Poosala, and Sridhar Ra- maswamy. 1999. The aqua approximate query answering system. InProceedings of the 1999 ACM SIGMOD international conference on Management of data . 574– 576

    1999

  36. [43]

    Sameer Agarwal, Barzan Mozafari, Aurojit Panda, Henry Milner, Samuel Mad- den, and Ion Stoica. 2013. BlinkDB: queries with bounded errors and bounded response times on very large data. In Proceedings of the 8th ACM European conference on computer systems . 29–42

    2013

  37. [44]

    Nitin Agrawal and Ashish Vulimiri. 2017. Low-latency analytics on colossal data streams with summarystore. In Proceedings of the 26th Symposium on Operating Systems Principles. 647–664

    2017

  38. [45]

    Manos Antonakakis, Tim April, Michael Bailey, Matt Bernhard, Elie Bursztein, Jaime Cochran, Zakir Durumeric, J Alex Halderman, Luca Invernizzi, Michalis Kallitsis, et al. 2017. Understanding the mirai botnet. In 26th USENIX security symposium (USENIX Security 17) . 1093–1110

    2017

  39. [46]

    Arvind Arasu and Gurmeet Singh Manku. 2004. Approximate counts and quantiles over sliding windows. InProceedings of the twenty-third ACM SIGMOD- SIGACT-SIGART symposium on Principles of database systems . 286–296

    2004

  40. [47]

    Ran Ben Basat, Gil Einziger, Isaac Keslassy, Ariel Orda, Shay Vargaftik, and Erez Waisbard. 2018. Memento: Making sliding windows efficient for heavy hitters. In Proceedings of the 14th International Conference on Emerging Networking EXperiments and Technologies. 254–266

    2018

  41. [48]

    Ran Ben-Basat, Gil Einziger, Roy Friedman, and Yaron Kassner. 2016. Heavy hitters in streams and sliding windows. InIEEE INFOCOM 2016-The 35th Annual IEEE International Conference on Computer Communications . IEEE, 1–9

    2016

  42. [49]

    Ran Ben Basat, Gil Einziger, Roy Friedman, and Yaron Kassner. 2019. Succinct summing over sliding windows. Algorithmica 81 (2019), 2072–2091

    2019

  43. [50]

    Vance W Berger and YanYan Zhou. 2014. Kolmogorov–smirnov test: Overview. Wiley statsref: Statistics reference online (2014). Zeying Zhu, Jonathan Chamberlain, Kenny Wu, David Starobinski, and Zaoxing Liu

    2014

  44. [51]

    Burton H Bloom. 1970. Space/time trade-offs in hash coding with allowable errors. Commun. ACM 13, 7 (1970), 422–426

    1970

  45. [52]

    Vladimir Braverman, Stephen R Chestnut, David P Woodruff, and Lin F Yang

  46. [53]

    Vladimir Braverman and Rafail Ostrovsky. 2007. Smooth histograms for sliding windows. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS’07). IEEE, 283–293

    2007

  47. [54]

    Vladimir Braverman and Rafail Ostrovsky. 2010. Zero-one frequency laws. In Proceedings of the forty-second ACM symposium on Theory of computing . 281–290

    2010

  48. [55]

    Yousra Chabchoub and Georges Heébrail. 2010. Sliding hyperloglog: Estimating cardinality in a data stream over a sliding window. In 2010 IEEE International Conference on Data Mining Workshops. IEEE, 1297–1303

    2010

  49. [56]

    Shiyu Chang, Yang Zhang, Jiliang Tang, Dawei Yin, Yi Chang, Mark A Hasegawa- Johnson, and Thomas S Huang. 2017. Streaming recommender systems. In Proceedings of the 26th international conference on world wide web . 381–389

    2017

  50. [57]

    Moses Charikar, Kevin Chen, and Martin Farach-Colton. 2002. Finding frequent items in data streams. In International Colloquium on Automata, Languages, and Programming. Springer, 693–703

    2002

  51. [58]

    Graham Cormode and Shan Muthukrishnan. 2005. An improved data stream summary: the count-min sketch and its applications. Journal of Algorithms 55, 1 (2005), 58–75

    2005

  52. [59]

    Chuck Cranor, Theodore Johnson, Oliver Spataschek, and Vladislav Shkapenyuk

  53. [60]

    Mayur Datar, Aristides Gionis, Piotr Indyk, and Rajeev Motwani. 2002. Main- taining stream statistics over sliding windows. SIAM journal on computing 31, 6 (2002), 1794–1813

    2002

  54. [61]

    Ronen Ben David and Anat Bremler Barr. 2021. Kubernetes autoscaling: Yoyo attack vulnerability and mitigation. arXiv preprint arXiv:2105.00542 (2021)

    2021 arXiv

  55. [62]

    Cristian Estan and George Varghese. 2002. New directions in traffic measure- ment and accounting. In Proceedings of the 2002 conference on Applications, technologies, architectures, and protocols for computer communications . 323–336

    2002

  56. [63]

    Edward Gan, Peter Bailis, and Moses Charikar. 2020. Coopstore: Optimizing precomputed summaries for aggregation. Proceedings of the VLDB Endowment 13, 12 (2020), 2174–2187

    2020

  57. [64]

    Xiangyang Gou, Long He, Yinda Zhang, Ke Wang, Xilai Liu, Tong Yang, Yi Wang, and Bin Cui. 2020. Sliding sketches: A framework using time zones for data stream processing in sliding windows. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery &...

    2020

  58. [65]

    Michael Greenwald and Sanjeev Khanna. 2001. Space-efficient online computa- tion of quantile summaries. ACM SIGMOD Record 30, 2 (2001), 58–66

    2001

  59. [66]

    Georges Hebrail and Alice Berard. 2012. Individual Household Elec- tric Power Consumption. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C58K54

    2012 doi

  60. [67]

    Ching-Tien Ho, Rakesh Agrawal, Nimrod Megiddo, and Ramakrishnan Srikant

  61. [68]

    Peng Huang, Chuanxiong Guo, Lidong Zhou, Jacob R Lorch, Yingnong Dang, Murali Chintalapati, and Randolph Yao. 2017. Gray failure: The achilles’ heel of cloud-scale systems. In Proceedings of the 16th Workshop on Hot Topics in Operating Systems. 150–155

    2017

  62. [70]

    Uwe Jugel, Zbigniew Jerzak, Gregor Hackenbroich, and Volker Markl. 2014. M4: a visualization-oriented time series data aggregation. Proceedings of the VLDB Endowment 7, 10 (2014), 797–808

    2014

  63. [71]

    David Karger, Eric Lehman, Tom Leighton, Rina Panigrahy, Matthew Levine, and Daniel Lewin. 1997. Consistent hashing and random trees: Distributed caching protocols for relieving hot spots on the world wide web. In Proceedings of the twenty-ninth annual ACM symposium on Theory ...

    1997

  64. [72]

    Zohar Karnin, Kevin Lang, and Edo Liberty. 2016. Optimal quantile approxima- tion in streams. In 2016 ieee 57th annual symposium on foundations of computer science (focs). IEEE, 71–78

    2016

  65. [73]

    Yehuda Koren. 2009. Collaborative filtering with temporal dynamics. InProceed- ings of the 15th ACM SIGKDD international conference on Knowledge discovery and data mining. 447–456

    2009

  66. [74]

    Ashwin Lall, Vyas Sekar, Mitsunori Ogihara, Jun Xu, and Hui Zhang. 2006. Data streaming algorithms for estimating entropy of network traffic. ACM SIGMETRICS Performance Evaluation Review 34, 1 (2006), 145–156

    2006

  67. [75]

    Xi Liang, Stavros Sintos, Zechao Shang, and Sanjay Krishnan. 2021. Combining aggregation and sampling (nearly) optimally for approximate query processing. In Proceedings of the 2021 International Conference on Management of Data . 1129–1141

    2021

  68. [76]

    Xi Liang, Stavros Sintos, Zechao Shang, and Sanjay Krishnan. 2021. Com- bining Aggregation and Sampling (Nearly) Optimally for Approximate Query Processing. https://doi.org/10.48550/ARXIV.2103.15994

    2021 doi arXiv

  69. [77]

    Gangmuk Lim, Mohamed S Hassan, Ze Jin, Stavros Volos, and Myeongjae Jeon

  70. [78]

    Zaoxing Liu, Antonis Manousis, Gregory Vorsanger, Vyas Sekar, and Vladimir Braverman. 2016. One sketch to rule them all: Rethinking network flow mon- itoring with univmon. In Proceedings of the 2016 ACM SIGCOMM Conference . 101–114

    2016

  71. [79]

    Zaoxing Liu, Hun Namkung, Georgios Nikolaidis, Jeongkeun Lee, Changhoon Kim, Xin Jin, Vladimir Braverman, Minlan Yu, and Vyas Sekar. 2021. Jaqen: A High-Performance Switch-Native Approach for Detecting and Mitigating Volumetric DDoS Attacks with Programmable Switches. In30th U...

    2021

  72. [80]

    Xuesong Lu, Wee Hyong Tok, Chedy Raissi, and Stéphane Bressan. 2010. A simple, yet effective and efficient, sliding window sampling algorithm. In Data- base Systems for Advanced Applications: 15th International Conference, DASFAA 2010, Tsukuba, Japan, April 1-4, 2010, Proceedi...

    2010

  73. [81]

    Samuel Madden, Michael J Franklin, Joseph M Hellerstein, and Wei Hong

  74. [82]

    Antonis Manousis, Zhuo Cheng, Ran Ben Basat, Zaoxing Liu, and Vyas Sekar

  75. [83]

    Stavros Maroulis, Vassilis Stamatopoulos, George Papastefanatos, and Manolis Terrovitis. 2024. Visualization-aware Time Series Min-Max Caching with Error Bound Guarantees. Proceedings of the VLDB Endowment 17, 8 (2024), 2091–2103

    2024

  76. [84]

    Octavian Mart, Catalin Negru, Florin Pop, and Aniello Castiglione. 2020. Observ- ability in kubernetes cluster: Automatic anomalies detection using prometheus. In 2020 IEEE 22nd International Conference on High Performance Computing and Communications; IEEE 18th International ...

    2020

  77. [85]

    Artur Marzano, David Alexander, Osvaldo Fonseca, Elverton Fazzion, Cristine Hoepers, Klaus Steding-Jessen, Marcelo HPC Chaves, Ítalo Cunha, Dorgival Guedes, and Wagner Meira. 2018. The evolution of bashlite and mirai iot botnets. In 2018 IEEE Symposium on Computers and Communi...

    2018

  78. [86]

    Charles Masson, Jee E Rim, and Homin K Lee. 2019. DDSketch: A fast and fully-mergeable quantile sketch with relative-error guarantees. arXiv preprint arXiv:1908.10693 (2019)

    2019 arXiv

  79. [87]

    In Proceedings of the 2003 ACM SIGMOD international conference on Management of data

    The design of an acquisitional query processor for sensor networks. In Proceedings of the 2003 ACM SIGMOD international conference on Management of data. 491–502

    2003

  80. [88]

    Muhammad Aashiq Moosa, Apurva K Vangujar, and Dnyanesh Pramod Ma- hajan. 2023. Detection and Analysis of DDoS Attack Using a Collaborative Network Monitoring Stack. In 2023 16th International Conference on Security of Information and Networks (SIN) . IEEE, 1–9

    2023

  81. [89]

    Ohsita, S

    Y. Ohsita, S. Ata, and M. Murata. 2004. Detecting distributed denial-of- service attacks by analyzing TCP SYN packets statistically. In IEEE Global Telecommunications Conference, 2004. GLOBECOM ’04. , Vol. 4. 2043–2049 Vol.4. https://doi.org/10.1109/GLOCOM.2004.1378371

    2004 arXiv

  82. [90]

    Alessandro Vittorio Papadopoulos, Ahmed Ali-Eldin, Karl-Erik Årzén, Johan Tordsson, and Erik Elmroth. 2016. PEAS: A performance evaluation framework for auto-scaling strategies in cloud applications. ACM Transactions on Modeling and Performance Evaluation of Computing Systems ...

    2016

  83. [91]

    Odysseas Papapetrou, Minos Garofalakis, and Antonios Deligiannakis. 2012. Sketch-based querying of distributed sliding-window data streams. arXiv preprint arXiv:1207.0139 (2012)

    2012 arXiv

  84. [92]

    Yongjoo Park, Barzan Mozafari, Joseph Sorenson, and Junhao Wang. 2018. Verdictdb: Universalizing approximate query processing. In Proceedings of the 2018 International Conference on Management of Data . 1461–1476

    2018

  85. [93]

    Tuomas Pelkonen, Scott Franklin, Justin Teller, Paul Cavallaro, Qi Huang, Justin Meza, and Kaushik Veeraraghavan. 2015. Gorilla: A fast, scalable, in-memory time series database. Proceedings of the VLDB Endowment 8, 12 (2015), 1816– 1827

    2015

  86. [94]

    Michael Mitzenmacher, Thomas Steinke, and Justin Thaler. 2012. Hierarchical heavy hitters with the space saving algorithm. In 2012 Proceedings of the Four- teenth Workshop on Algorithm Engineering and Experiments (ALENEX) . SIAM, 160–174

    2012

  87. [95]

    James Pope, Francesco Raimondo, Vijay Kumar, Ryan McConville, Rob Piechocki, George Oikonomou, Thomas Pasquier, Bo Luo, Dan Howarth, Ioan- nis Mavromatis, et al. 2021. Container escape detection for edge devices. In Approximation-First Timeseries Monitoring Query At Scale Proc...

    2021

  88. [96]

    Athanasios Priovolos, Dimitris Lioprasitis, Georgios Gardikis, and Socrates Costicoglou. 2021. Using anomaly detection techniques for securing 5G infras- tructure and applications. In 2021 IEEE International Mediterranean Conference on Communications and Networking (MeditCom) ...

    2021

  89. [97]

    Chunhui Shen, Qianyu Ouyang, Feibo Li, Zhipeng Liu, Longcheng Zhu, Yujie Zou, Qing Su, Tianhuan Yu, Yi Yi, Jianhong Hu, et al . 2023. Lindorm TSDB: A Cloud-Native Time-Series Database for Large-Scale Monitoring Systems. Proceedings of the VLDB Endowment 16, 12 (2023), 3715–3727

    2023

  90. [98]

    Mor Sides, Anat Bremler-Barr, and Elisha Rosensweig. 2015. Yo-Yo Attack: vul- nerability in auto-scaling mechanism. InProceedings of the 2015 ACM Conference on Special Interest Group on Data Communication . 103–104

    2015

  91. [99]

    James Turnbull. 2018. Monitoring with Prometheus. Turnbull Press

    2018

  92. [100]

    Zhiqi Wang, Jin Xue, and Zili Shao. 2021. Heracles: an efficient storage model and data flushing for performance monitoring timeseries. Proceedings of the VLDB Endowment 14, 6 (2021), 1080–1092

    2021

  93. [101]

    Jinglin Peng, Dongxiang Zhang, Jiannan Wang, and Jian Pei. 2018. Aqp++ connecting approximate query processing with aggregate precomputation for interactive analytics. In Proceedings of the 2018 International Conference on Management of Data. 1477–1492

    2018

  94. [102]

    Yuhan Wu, Shiqi Jiang, Siyuan Dong, Zheng Zhong, Jiale Chen, Yutong Hu, Tong Yang, Steve Uhlig, and Bin Cui. 2023. MicroscopeSketch: Accurate Sliding Estimation Using Adaptive Zooming. In Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining . 2660–2671

    2023

  95. [103]

    future-proof

    Mingran Yang, Junbo Zhang, Akshay Gadre, Zaoxing Liu, Swarun Kumar, and Vyas Sekar. 2020. Joltik: enabling energy-efficient" future-proof" analytics on low-power wide-area networks. In Proceedings of the 26th Annual International Conference on Mobile Computing and Networking . 1–14

    2020

  96. [104]

    Tong Yang, Junzhi Gong, Haowei Zhang, Lei Zou, Lei Shi, and Xiaoming Li. 2018. Heavyguardian: Separate and guard hot items in data streams. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 2584–2593

    2018

  97. [105]

    Bohan Zhao, Xiang Li, Boyu Tian, Zhiyu Mei, and Wenfei Wu. 2021. Dhs: Adaptive memory layout organization of sketch slots for fast and accurate data stream processing. In Proceedings of ACM SIGKDD . 2285–2293

    2021

  98. [108]

    Jamie Wilkinson. 2016. Google Promethues: A practical guide to alerting at scale. Retrieved 2024 from https://docs.google.com/presentation/d/ 1X1rKozAUuF2MVc1YXElFWq9wkcWv3Axdldl8LOH9Vik/edit#slide=id. g598ef96a6_0_341

    2016

  99. [1997]

    ACM SIGMOD Record 26, 2 (1997), 73–88

    Range queries in OLAP data cubes. ACM SIGMOD Record 26, 2 (1997), 73–88

    1997

  100. [2003]

    In Proceedings of the 2003 ACM SIGMOD international conference on Management of data

    Gigascope: A stream database for network applications. In Proceedings of the 2003 ACM SIGMOD international conference on Management of data . 647– 651

    2003

  101. [2013]

    Proceedings of the VLDB Endowment 6, 11 (2013), 1057–1067

    Scuba: Diving into data at facebook. Proceedings of the VLDB Endowment 6, 11 (2013), 1057–1067

    2013

  102. [2016]

    In Proceedings of the 35th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems

    Streaming space complexity of nearly all functions of one variable on frequency vectors. In Proceedings of the 35th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems . 261–276

  103. [2020]

    In 2020 IEEE 36th International Conference on Data Engineering (ICDE)

    Approximate quantiles for datacenter telemetry monitoring. In 2020 IEEE 36th International Conference on Data Engineering (ICDE) . IEEE, 1914–1917

    2020

  104. [2022]

    arXiv preprint arXiv:2208.04927 (2022)

    Enabling efficient and general subpopulation analytics in multidimen- sional data streams. arXiv preprint arXiv:2208.04927 (2022)

    2022 arXiv

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.