docs: update version to v1.146.0

Signed-off-by: f41gh7 <nik@victoriametrics.com>
app/vmselect: run make vmui-update
2026-06-19 16:53:32 +03:00 · 2026-06-19 14:18:31 +02:00 · 2026-06-19 14:16:01 +02:00 · 2026-06-19 13:47:49 +02:00 · 2026-06-19 13:23:01 +02:00 · 2026-06-19 13:16:31 +02:00
42 changed files with 1342 additions and 734 deletions
--- a/app/vmagent/remotewrite/client.go
+++ b/app/vmagent/remotewrite/client.go
@@ -187,7 +187,7 @@ func newHTTPClient(argIdx int, remoteWriteURL, sanitizedURL string, fq *persiste
 	return c
 }

-func (c *client) init(argIdx, concurrency int, sanitizedURL string) {
+func (c *client) init(argIdx int, sanitizedURL string) {
 	limitReached := metrics.GetOrCreateCounter(fmt.Sprintf(`vmagent_remotewrite_rate_limit_reached_total{url=%q}`, c.sanitizedURL))
 	if bytesPerSec := rateLimit.GetOptionalArg(argIdx); bytesPerSec > 0 {
 		logger.Infof("applying %d bytes per second rate limit for -remoteWrite.url=%q", bytesPerSec, sanitizedURL)
@@ -204,11 +204,20 @@ func (c *client) init(argIdx, concurrency int, sanitizedURL string) {
 	c.packetsDropped = metrics.GetOrCreateCounter(fmt.Sprintf(`vmagent_remotewrite_packets_dropped_total{url=%q}`, c.sanitizedURL))
 	c.retriesCount = metrics.GetOrCreateCounter(fmt.Sprintf(`vmagent_remotewrite_retries_count_total{url=%q}`, c.sanitizedURL))
 	c.sendDuration = metrics.GetOrCreateFloatCounter(fmt.Sprintf(`vmagent_remotewrite_send_duration_seconds_total{url=%q}`, c.sanitizedURL))
-	metrics.GetOrCreateGauge(fmt.Sprintf(`vmagent_remotewrite_queues{url=%q}`, c.sanitizedURL), func() float64 {
-		return float64(concurrency)
-	})
-	for range concurrency {
-		c.wg.Go(c.runWorker)
+	workers := queues.GetOptionalArg(argIdx)
+	if workers <= 0 {
+		workers = 1
+	}
+	inmemoryWorkers := inmemoryQueues.GetOptionalArg(argIdx)
+	for range inmemoryWorkers {
+		c.wg.Go(func() {
+			c.runWorker(c.fq.MustReadInMemoryBlockBlocking)
+		})
+	}
+	for range workers {
+		c.wg.Go(func() {
+			c.runWorker(c.fq.MustReadBlock)
+		})
 	}
 	logger.Infof("initialized client for -remoteWrite.url=%q", c.sanitizedURL)
 }
@@ -302,12 +311,12 @@ func getAWSAPIConfig(argIdx int) (*awsapi.Config, error) {
 	return cfg, nil
 }

-func (c *client) runWorker() {
+func (c *client) runWorker(readBlock func(dst []byte) ([]byte, bool)) {
 	var ok bool
 	var block []byte
 	ch := make(chan bool, 1)
 	for {
-		block, ok = c.fq.MustReadBlock(block[:0])
+		block, ok = readBlock(block[:0])
 		if !ok {
 			return
 		}
--- a/app/vmagent/remotewrite/remotewrite.go
+++ b/app/vmagent/remotewrite/remotewrite.go
@@ -66,6 +66,9 @@ var (
 	queues = flagutil.NewArrayInt("remoteWrite.queues", cgroup.AvailableCPUs()*2, "The number of concurrent queues to each -remoteWrite.url. Set more queues if default number of queues "+
 		"isn't enough for sending high volume of collected data to remote storage. "+
 		"Default value depends on the number of available CPU cores. It should work fine in most cases since it minimizes resource usage")
+	inmemoryQueues = flagutil.NewArrayInt("remoteWrite.inmemoryQueues", 0, "The number of additional workers per each -remoteWrite.url, which send only recently ingested data from the in-memory queue, "+
+		"while the file-based queue at -remoteWrite.tmpDataPath is drained by workers configured via -remoteWrite.queues. "+
+		"This reduces delivery lag for fresh samples when the file-based queue contains a backlog accumulated during remote storage outages.")
 	showRemoteWriteURL = flag.Bool("remoteWrite.showURL", false, "Whether to show -remoteWrite.url in the exported metrics. "+
 		"It is hidden by default, since it can contain sensitive info such as auth key")
 	maxPendingBytesPerURL = flagutil.NewArrayBytes("remoteWrite.maxDiskUsagePerURL", 0, "The maximum file-based buffer size in bytes at -remoteWrite.tmpDataPath "+
@@ -906,7 +909,8 @@ func newRemoteWriteCtx(argIdx int, remoteWriteURL *url.URL, sanitizedURL string)
 	}

 	isPQDisabled := disableOnDiskQueue.GetOptionalArg(argIdx)
-	queuesSize := queues.GetOptionalArg(argIdx)
+	inmemoryQueueSize := inmemoryQueues.GetOptionalArg(argIdx)
+	queuesSize := queues.GetOptionalArg(argIdx) + inmemoryQueueSize
 	if queuesSize > maxQueues {
 		queuesSize = maxQueues
 	} else if queuesSize <= 0 {
@@ -923,7 +927,13 @@ func newRemoteWriteCtx(argIdx int, remoteWriteURL *url.URL, sanitizedURL string)
 	if maxInmemoryBlocks < 2 {
 		maxInmemoryBlocks = 2
 	}
-	fq := persistentqueue.MustOpenFastQueue(queuePath, sanitizedURL, maxInmemoryBlocks, maxPendingBytes, isPQDisabled)
+	fqOpts := persistentqueue.OpenFastQueueOpts{
+		MaxInmemoryBlocks:      maxInmemoryBlocks,
+		MaxPendingBytes:        maxPendingBytes,
+		IsPQDisabled:           isPQDisabled,
+		PrioritizeInmemoryData: inmemoryQueueSize > 0,
+	}
+	fq := persistentqueue.MustOpenFastQueueWithOpts(queuePath, sanitizedURL, fqOpts)
 	_ = metrics.GetOrCreateGauge(fmt.Sprintf(`vmagent_remotewrite_pending_data_bytes{path=%q, url=%q}`, queuePath, sanitizedURL), func() float64 {
 		return float64(fq.GetPendingBytes())
 	})
@@ -936,6 +946,9 @@ func newRemoteWriteCtx(argIdx int, remoteWriteURL *url.URL, sanitizedURL string)
 		}
 		return 0
 	})
+	metrics.GetOrCreateGauge(fmt.Sprintf(`vmagent_remotewrite_queues{url=%q}`, sanitizedURL), func() float64 {
+		return float64(queuesSize)
+	})

 	var c *client
 	switch remoteWriteURL.Scheme {
@@ -944,7 +957,7 @@ func newRemoteWriteCtx(argIdx int, remoteWriteURL *url.URL, sanitizedURL string)
 	default:
 		logger.Fatalf("unsupported scheme: %s for remoteWriteURL: %s, want `http`, `https`", remoteWriteURL.Scheme, sanitizedURL)
 	}
-	c.init(argIdx, queuesSize, sanitizedURL)
+	c.init(argIdx, sanitizedURL)

 	// Initialize pss
 	sf := significantFigures.GetOptionalArg(argIdx)
--- a/app/vmctl/influx/influx.go
+++ b/app/vmctl/influx/influx.go
@@ -259,7 +259,7 @@ func (cr *ChunkedResponse) Next() ([]int64, []float64, error) {

 	fieldValues, ok := r.values[cr.field]
 	if !ok {
-		return nil, nil, fmt.Errorf("response doesn't contain filed %q", cr.field)
+		return nil, nil, fmt.Errorf("response doesn't contain field %q", cr.field)
 	}
 	values := make([]float64, len(fieldValues))
 	for i, fv := range fieldValues {
--- a/app/vmctl/vm_native.go
+++ b/app/vmctl/vm_native.go
@@ -405,7 +405,16 @@ func buildMatchWithFilter(filter string, metricName string) (string, error) {
 			if len(tf.Key) == 0 {
 				continue
 			}
-			a = append(a, tf.String())
+			switch {
+			case tf.IsNegative && tf.IsRegexp:
+				a = append(a, fmt.Sprintf("%s!~%q", tf.Key, tf.Value))
+			case tf.IsNegative:
+				a = append(a, fmt.Sprintf("%s!=%q", tf.Key, tf.Value))
+			case tf.IsRegexp:
+				a = append(a, fmt.Sprintf("%s=~%q", tf.Key, tf.Value))
+			default:
+				a = append(a, fmt.Sprintf("%s=%q", tf.Key, tf.Value))
+			}
 		}
 		a = append(a, nameFilter)
 		filters = append(filters, strings.Join(a, ","))
--- a/app/vmselect/prometheus/metadata_response.qtpl
+++ b/app/vmselect/prometheus/metadata_response.qtpl
@@ -15,7 +15,7 @@ See https://prometheus.io/docs/prometheus/latest/querying/api/#querying-metric-m
 			currentItem := 0
 		 %}
 		{% for _, row := range result %}
-			"{%s string(row.MetricFamilyName) %}": [
+			{%q= string(row.MetricFamilyName) %}: [
 					{
 						"type": {%q= row.Type.String() %},
            {% if len(row.Unit) > 0 -%}
--- a/app/vmselect/prometheus/metadata_response.qtpl.go
+++ b/app/vmselect/prometheus/metadata_response.qtpl.go
@@ -35,12 +35,10 @@ func StreamMetadataResponse(qw422016 *qt422016.Writer, result []*metricsmetadata

 //line app/vmselect/prometheus/metadata_response.qtpl:17
 	for _, row := range result {
-//line app/vmselect/prometheus/metadata_response.qtpl:17
-		qw422016.N().S(`"`)
 //line app/vmselect/prometheus/metadata_response.qtpl:18
-		qw422016.E().S(string(row.MetricFamilyName))
+		qw422016.N().Q(string(row.MetricFamilyName))
 //line app/vmselect/prometheus/metadata_response.qtpl:18
-		qw422016.N().S(`": [{"type":`)
+		qw422016.N().S(`: [{"type":`)
 //line app/vmselect/prometheus/metadata_response.qtpl:20
 		qw422016.N().Q(row.Type.String())
 //line app/vmselect/prometheus/metadata_response.qtpl:20
--- a/app/vmselect/vmui/assets/index-CoGukb-x.js
+++ b/app/vmselect/vmui/assets/index-CoGukb-x.js
--- a/app/vmselect/vmui/assets/index-CusQvJzs.js
+++ b/app/vmselect/vmui/assets/index-CusQvJzs.js
--- a/app/vmselect/vmui/assets/rolldown-runtime-COnpUsM8.js
+++ b/app/vmselect/vmui/assets/rolldown-runtime-COnpUsM8.js
@@ -1 +0,0 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(e&&(t=e(e=0)),t),s=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),c=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n||t(r,Symbol.toStringTag,{value:`Module`}),r},l=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},u=(n,r,a)=>(a=n==null?{}:e(i(n)),l(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),d=e=>a.call(e,`module.exports`)?e[`module.exports`]:l(t({},`__esModule`,{value:!0}),e);export{u as a,d as i,o as n,c as r,s as t};
--- a/app/vmselect/vmui/assets/rolldown-runtime-Cyuzqnbw.js
+++ b/app/vmselect/vmui/assets/rolldown-runtime-Cyuzqnbw.js
@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(e&&(t=e(e=0)),t),s=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),c=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n||t(r,Symbol.toStringTag,{value:`Module`}),r},l=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},u=(n,r,a)=>(a=n==null?{}:e(i(n)),l(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),d=e=>a.call(e,`module.exports`)?e[`module.exports`]:l(t({},`__esModule`,{value:!0}),e);export{u as a,d as i,o as n,c as r,s as t};
--- a/app/vmselect/vmui/assets/vendor-B83wxFqK.js
+++ b/app/vmselect/vmui/assets/vendor-B83wxFqK.js
--- a/app/vmselect/vmui/assets/vendor-C8Kwp93_.js
+++ b/app/vmselect/vmui/assets/vendor-C8Kwp93_.js
--- a/app/vmselect/vmui/index.html
+++ b/app/vmselect/vmui/index.html
@@ -37,9 +37,9 @@
  <meta property="og:title" content="UI for VictoriaMetrics">
  <meta property="og:url" content="https://victoriametrics.com/">
  <meta property="og:description" content="Explore and troubleshoot your VictoriaMetrics data">
-  <script type="module" crossorigin src="./assets/index-CoGukb-x.js"></script>
-  <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-COnpUsM8.js">
-  <link rel="modulepreload" crossorigin href="./assets/vendor-C8Kwp93_.js">
+  <script type="module" crossorigin src="./assets/index-CusQvJzs.js"></script>
+  <link rel="modulepreload" crossorigin href="./assets/rolldown-runtime-Cyuzqnbw.js">
+  <link rel="modulepreload" crossorigin href="./assets/vendor-B83wxFqK.js">
  <link rel="stylesheet" crossorigin href="./assets/vendor-CnsZ1jie.css">
  <link rel="stylesheet" crossorigin href="./assets/index-BBUnmLOr.css">
 </head>
--- a/apptest/tests/metricsmetadata_test.go
+++ b/apptest/tests/metricsmetadata_test.go
@@ -45,11 +45,13 @@ func TestSingleMetricsMetadata(t *testing.T) {
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_4"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_5"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_6"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
+			{Labels: []prompb.Label{{Name: "__name__", Value: `metric_name_7_!@"_suffix`}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 		},
 		Metadata: []prompb.MetricMetadata{
 			{MetricFamilyName: "metric_name_4", Help: "some help message", Type: prompb.MetricTypeSummary},
 			{MetricFamilyName: "metric_name_5", Help: "some help message", Type: prompb.MetricTypeSummary},
 			{MetricFamilyName: "metric_name_6", Help: "some help message", Type: prompb.MetricTypeStateset},
+			{MetricFamilyName: `metric_name_7_!@"_suffix`, Help: "some help message", Type: prompb.MetricTypeStateset},
 		},
 	}

@@ -59,12 +61,13 @@ func TestSingleMetricsMetadata(t *testing.T) {
 	expected := &apptest.PrometheusAPIV1Metadata{
 		Status: "success",
 		Data: map[string][]apptest.MetadataEntry{
-			"metric_name_1": {{Help: "some help message", Type: "gauge"}},
-			"metric_name_2": {{Help: "some help message", Type: "counter"}},
-			"metric_name_3": {{Help: "some help message", Type: "gauge"}},
-			"metric_name_4": {{Help: "some help message", Type: "summary"}},
-			"metric_name_5": {{Help: "some help message", Type: "summary"}},
-			"metric_name_6": {{Help: "some help message", Type: "stateset"}},
+			"metric_name_1":            {{Help: "some help message", Type: "gauge"}},
+			"metric_name_2":            {{Help: "some help message", Type: "counter"}},
+			"metric_name_3":            {{Help: "some help message", Type: "gauge"}},
+			"metric_name_4":            {{Help: "some help message", Type: "summary"}},
+			"metric_name_5":            {{Help: "some help message", Type: "summary"}},
+			"metric_name_6":            {{Help: "some help message", Type: "stateset"}},
+			`metric_name_7_!@"_suffix`: {{Help: "some help message", Type: "stateset"}},
 		},
 	}
 	gotStats := sut.PrometheusAPIV1Metadata(t, "", 0, apptest.QueryOpts{})
@@ -154,11 +157,13 @@ func TestClusterMetricsMetadata(t *testing.T) {
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_4"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_5"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 			{Labels: []prompb.Label{{Name: "__name__", Value: "metric_name_6"}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
+			{Labels: []prompb.Label{{Name: "__name__", Value: `metric_name_7_!@"_suffix`}}, Samples: []prompb.Sample{{Value: 40, Timestamp: ingestTimestamp}}},
 		},
 		Metadata: []prompb.MetricMetadata{
 			{MetricFamilyName: "metric_name_4", Help: "some help message", Type: prompb.MetricTypeSummary},
 			{MetricFamilyName: "metric_name_5", Help: "some help message", Type: prompb.MetricTypeSummary},
 			{MetricFamilyName: "metric_name_6", Help: "some help message", Type: prompb.MetricTypeStateset},
+			{MetricFamilyName: `metric_name_7_!@"_suffix`, Help: "some help message", Type: prompb.MetricTypeStateset},
 		},
 	}

@@ -171,12 +176,13 @@ func TestClusterMetricsMetadata(t *testing.T) {
 		expected := &apptest.PrometheusAPIV1Metadata{
 			Status: "success",
 			Data: map[string][]apptest.MetadataEntry{
-				"metric_name_1": {{Help: "some help message", Type: "gauge"}},
-				"metric_name_2": {{Help: "some help message", Type: "counter"}},
-				"metric_name_3": {{Help: "some help message", Type: "gauge"}},
-				"metric_name_4": {{Help: "some help message", Type: "summary"}},
-				"metric_name_5": {{Help: "some help message", Type: "summary"}},
-				"metric_name_6": {{Help: "some help message", Type: "stateset"}},
+				"metric_name_1":            {{Help: "some help message", Type: "gauge"}},
+				"metric_name_2":            {{Help: "some help message", Type: "counter"}},
+				"metric_name_3":            {{Help: "some help message", Type: "gauge"}},
+				"metric_name_4":            {{Help: "some help message", Type: "summary"}},
+				"metric_name_5":            {{Help: "some help message", Type: "summary"}},
+				"metric_name_6":            {{Help: "some help message", Type: "stateset"}},
+				`metric_name_7_!@"_suffix`: {{Help: "some help message", Type: "stateset"}},
 			},
 		}
 		gotStats := vmselect.PrometheusAPIV1Metadata(t, "", 0, apptest.QueryOpts{Tenant: tenantID})
--- a/apptest/tests/vmagent_remotewrite_test.go
+++ b/apptest/tests/vmagent_remotewrite_test.go
@@ -8,6 +8,7 @@ import (
 	"net/http/httptest"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"testing"
 	"time"

@@ -332,13 +333,11 @@ func TestSingleVMAgentDropOnOverload(t *testing.T) {
 	vmagent.APIV1ImportPrometheusNoWaitFlush(t, []string{
 		"foo_bar 1 1652169600000", // 2022-05-10T08:00:00Z
 	}, apptest.QueryOpts{})
-
 	waitFor(
 		func() bool {
 			return vmagent.RemoteWriteRequests(t, url1) == 1 && vmagent.RemoteWriteRequests(t, url2) == 1
 		},
 	)
-
 	// Send 2 more requests, the first RW endpoint should receive everything, the second should add them to the queue
 	// since worker is busy with the first request.
 	for i := range 2 {
@@ -641,3 +640,116 @@ func TestSingleVMAgentMultitenancy(t *testing.T) {
 		t.Fatalf("expected vmagent_tenant_inserted_rows_total to have value 1 for accountID=5, projectID=0")
 	}
 }
+
+func TestSingleVMAgentPriorizeRecentData(t *testing.T) {
+	tc := apptest.NewTestCase(t)
+	defer tc.Stop()
+
+	remoteWriteSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer remoteWriteSrv.Close()
+
+	var mustRW2ReturnError atomic.Bool
+	mustRW2ReturnError.Store(true)
+
+	remoteWriteSrv2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if mustRW2ReturnError.Load() {
+			w.WriteHeader(http.StatusServiceUnavailable)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer remoteWriteSrv2.Close()
+
+	vmagent := tc.MustStartDefaultRWVmagent("vmagent", []string{
+		fmt.Sprintf(`-remoteWrite.url=%s/api/v1/write`, remoteWriteSrv.URL),
+		fmt.Sprintf(`-remoteWrite.url=%s/api/v1/write`, remoteWriteSrv2.URL),
+		"-remoteWrite.disableOnDiskQueue=true",
+		// use only 1 worker to get a full queue faster
+		"-remoteWrite.queues=1",
+		"-remoteWrite.flushInterval=1ms",
+		"-remoteWrite.inmemoryQueues=1",
+		// fastqueue size is roughly memory.Allowed() / len(urls) / *maxRowsPerBlock / 100
+		// Use very large maxRowsPerBlock to get fastqueue of minimal length(2).
+		// See initRemoteWriteCtxs function in remotewrite.go for details.
+		"-remoteWrite.maxRowsPerBlock=1000000000",
+		"-remoteWrite.tmpDataPath=" + tc.Dir() + "/vmagent",
+
+		// Delay retry logic to avoid race conditions with waitFor assertions.
+		// It improves the test stability on resource-constrained runners.
+		"-remoteWrite.retryMinInterval=3s",
+		"-remoteWrite.retryMaxTime=3s",
+	})
+
+	const (
+		retries = 20
+		period  = 200 * time.Millisecond
+	)
+
+	waitFor := func(f func() bool) {
+		t.Helper()
+		for range retries {
+			if f() {
+				return
+			}
+			time.Sleep(period)
+		}
+		t.Fatalf("timed out waiting for retry #%d", retries)
+	}
+
+	// Real remote write URLs are hidden in metrics
+	url1 := "1:secret-url"
+	url2 := "2:secret-url"
+
+	// Wait until first request got flushed to remote write server
+	vmagent.APIV1ImportPrometheusNoWaitFlush(t, []string{
+		"foo_bar 1 1652169600000", // 2022-05-10T08:00:00Z
+	}, apptest.QueryOpts{})
+	waitFor(
+		func() bool {
+			return vmagent.RemoteWriteRequests(t, url1) == 1 && vmagent.RemoteWriteRequests(t, url2) == 1
+		},
+	)
+	// Wait until second request got flushed to remote write server
+	// since there are 2 independent queues (general and in-memory) with minimal capacity of 1
+	vmagent.APIV1ImportPrometheusNoWaitFlush(t, []string{
+		"foo_bar 1 1652169600000", // 2022-05-10T08:00:00Z
+	}, apptest.QueryOpts{})
+	waitFor(
+		func() bool {
+			return vmagent.RemoteWriteRequests(t, url1) == 2 && vmagent.RemoteWriteRequests(t, url2) == 2
+		},
+	)
+	// Send 2 more requests, the first RW endpoint should receive everything, the second should add them to the queue
+	// since worker is busy with the first request.
+	for i := range 2 {
+		vmagent.APIV1ImportPrometheusNoWaitFlush(t, []string{
+			"foo_bar 1 1652169600000", // 2022-05-10T08:00:00Z
+		}, apptest.QueryOpts{})
+
+		waitFor(
+			func() bool {
+				return vmagent.RemoteWriteRequests(t, url1) == 3+i && vmagent.RemoteWritePendingInmemoryBlocks(t, url2) == 1+i
+			},
+		)
+	}
+
+	// Send one more request.
+	vmagent.APIV1ImportPrometheusNoWaitFlush(t, []string{
+		"foo_bar 1 1652169600000", // 2022-05-10T08:00:00Z
+	}, apptest.QueryOpts{})
+
+	waitFor(
+		func() bool {
+			return vmagent.RemoteWriteRequests(t, url1) == 5 && vmagent.RemoteWriteSamplesDropped(t, url2) > 0
+		},
+	)
+	mustRW2ReturnError.Store(false)
+	// ensure that inmemory data correctly flushed to the remote write
+	waitFor(
+		func() bool {
+			return vmagent.RemoteWritePendingInmemoryBlocks(t, url2) == 0
+		},
+	)
+}
--- a/dashboards/vm/vmagent.json
+++ b/dashboards/vm/vmagent.json
@@ -6201,7 +6201,7 @@
            "type": "victoriametrics-metrics-datasource",
            "uid": "$ds"
          },
-          "description": "The rate of ignored samples during aggregation. \nStream aggregation will drop samples with NaN values, or samples with too old timestamps. See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples ",
+          "description": "The rate of dropped samples during aggregation. \nStream aggregation will drop samples with NaN values, too old timestamps or samples identified as duplicates during deduplication. See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples ",
          "fieldConfig": {
            "defaults": {
              "color": {
@@ -6282,14 +6282,14 @@
                "uid": "$ds"
              },
              "editorMode": "code",
-              "expr": "sum(rate(vm_streamaggr_ignored_samples_total{job=~\"$job\",instance=~\"$instance\", url=~\"$url\"}[$__rate_interval]) > 0) without (instance, pod)",
+              "expr": "sum(rate({__name__=~\"vm_streamaggr_ignored_samples_total|vm_streamaggr_dedup_dropped_samples_total\", job=~\"$job\",instance=~\"$instance\", url=~\"$url\"}[$__rate_interval]) > 0) without (instance, pod)",
              "instant": false,
              "legendFormat": "__auto",
              "range": true,
              "refId": "A"
            }
          ],
-          "title": "Ignored samples ($instance)",
+          "title": "Dropped samples ($instance)",
          "type": "timeseries"
        },
        {
--- a/dashboards/vmagent.json
+++ b/dashboards/vmagent.json
@@ -6200,7 +6200,7 @@
            "type": "prometheus",
            "uid": "$ds"
          },
-          "description": "The rate of ignored samples during aggregation. \nStream aggregation will drop samples with NaN values, or samples with too old timestamps. See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples ",
+          "description": "The rate of dropped samples during aggregation. \nStream aggregation will drop samples with NaN values, too old timestamps or samples identified as duplicates during deduplication. See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples ",
          "fieldConfig": {
            "defaults": {
              "color": {
@@ -6281,14 +6281,14 @@
                "uid": "$ds"
              },
              "editorMode": "code",
-              "expr": "sum(rate(vm_streamaggr_ignored_samples_total{job=~\"$job\",instance=~\"$instance\", url=~\"$url\"}[$__rate_interval]) > 0) without (instance, pod)",
+              "expr": "sum(rate({__name__=~\"vm_streamaggr_ignored_samples_total|vm_streamaggr_dedup_dropped_samples_total\", job=~\"$job\",instance=~\"$instance\", url=~\"$url\"}[$__rate_interval]) > 0) without (instance, pod)",
              "instant": false,
              "legendFormat": "__auto",
              "range": true,
              "refId": "A"
            }
          ],
-          "title": "Ignored samples ($instance)",
+          "title": "Dropped samples ($instance)",
          "type": "timeseries"
        },
        {
--- a/docs/victoriametrics/changelog/CHANGELOG.md
+++ b/docs/victoriametrics/changelog/CHANGELOG.md
@@ -30,16 +30,26 @@ See also [LTS releases](https://docs.victoriametrics.com/victoriametrics/lts-rel
 * FEATURE: [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): log calls to [/api/v1/admin/tsdb/delete_series](https://docs.victoriametrics.com/victoriametrics/url-examples/#apiv1admintsdbdelete_series) API handler. This should help to identify events of metrics deletion from the database. See [#11104](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11104).
 * FEATURE: [vmctl](https://docs.victoriametrics.com/victoriametrics/vmctl/): add `-vm-headers` and `-vm-bearer-token` flags for authenticating requests to the VictoriaMetrics import destination. The flags are available in `opentsdb`, `influx`, `remote-read`, `prometheus`, `mimir`, and `thanos` vmctl sub-commands. See [#8897](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8897).
 * FEATURE: [vmui](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#vmui): add the `last` value to graph legend statistics. See [#10759](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/10759).
-* FEATURE: [vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/): add `-promscrape.cluster.shardByLabels` command-line flag for selecting target labels used for sharding scrape targets among `vmagent` instances in cluster mode. See [#11044](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11044).
+* FEATURE: [stream aggregation](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/): expose `vm_streamaggr_dedup_dropped_samples_total` to allow tracking dropped old samples during [deduplication](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication).
+* FEATURE: [stream aggregation](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/): use the aggregation rule interval as the default [staleness_interval](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#staleness) instead of `2*interval`, to reduce spikes when there are gaps between received samples. See [#11102](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11102).
+* FEATURE: [vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/): add a new flag `-remoteWrite.inmemoryQueues` to prioritize recently ingested data over historical data stored at file-based [persistent queue](https://docs.victoriametrics.com/victoriametrics/vmagent/#on-disk-persistence-and-data-processing-order). See [#8833](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8833)
+*  FEATURE: [vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/): add `-promscrape.cluster.shardByLabels` command-line flag for selecting target labels used for sharding scrape targets among `vmagent` instances in cluster mode. See [#11044](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11044).
+* FEATURE: [vmctl](https://docs.victoriametrics.com/victoriametrics/vmctl/): add `-vm-headers` and `-vm-bearer-token` flags for authenticating requests to the VictoriaMetrics import destination. The flags are available in `opentsdb`, `influx`, `remote-read`, `prometheus`, `mimir`, and `thanos` vmctl sub-commands. See [#8897](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8897).
+* FEATURE: [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): log calls to [/api/v1/admin/tsdb/delete_series](https://docs.victoriametrics.com/victoriametrics/url-examples/#apiv1admintsdbdelete_series) API handler. This should help to identify events of metrics deletion from the database. See [#11104](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11104).
+* FEATURE: [vmui](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#vmui): add the `last` value to graph legend statistics. See [#10759](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/10759).

+* BUGFIX: [enterprise](https://docs.victoriametrics.com/enterprise/) [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmstorage` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): properly expose metric `vm_retention_filters_partitions_scheduled_rows`. See [#11138](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11138)
 * BUGFIX: [stream aggregation](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/): fix issue with producing aggregated samples with identical timestamps between flushes. See [#10808](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/10808).
-* BUGFIX: [vmalert](https://docs.victoriametrics.com/victoriametrics/vmalert/),[vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/),[vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/) and [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/): fix rare unbounded shutdown delay when config reload takes longer than `-configCheckInterval`. See [#11107](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11107). Thanks to @PleasingFungus for contribution.
-* BUGFIX: `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): fix corrupted metrics metadata when a response contains multiple rows. See [#11115](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11115). Thanks for @fxrlv for the contribution.
 * BUGFIX: [vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/): fix potential corruption of remote-write metadata `Unit` values. See [#11120](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11120). Thanks for @fxrlv for the contribution.
-* BUGFIX: [vmbackup](https://docs.victoriametrics.com/vmbackup/), [vmbackupmanager](https://docs.victoriametrics.com/victoriametrics/vmbackupmanager/): do not fail backup list if directory is absent while using `fs://` destination to align with other protocols. See [6c3c548d](https://github.com/VictoriaMetrics/VictoriaMetrics/commit/6c3c548ddb0385b749e731f52276f130e2a4e4a8)
-* BUGFIX: [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmstorage` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): prevent more cases of panic during directory deletion on `NFS`-based mounts. See [#11060](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11060).
+* BUGFIX: [vmalert](https://docs.victoriametrics.com/victoriametrics/vmalert/),[vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/),[vmagent](https://docs.victoriametrics.com/victoriametrics/vmagent/) and [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/): fix rare unbounded shutdown delay when config reload takes longer than `-configCheckInterval`. See [#11107](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11107). Thanks to @PleasingFungus for contribution.
+* BUGFIX: [vmbackup](https://docs.victoriametrics.com/vmbackup/), [vmbackupmanager](https://docs.victoriametrics.com/victoriametrics/vmbackupmanager/): do not fail backup list if directory is absent while using `fs://` destination to align with other protocols. See [6c3c548d](https://github.com/VictoriaMetrics/VictoriaMetrics/commit/6c3c548ddb0385b749e731f52276f130e2a4e4a8).
 * BUGFIX: [vmctl](https://docs.victoriametrics.com/victoriametrics/vmctl/): push metrics to configured `-pushmetrics.url` on shutdown when migration fails. Previously, metrics were not pushed if vmctl exited with an error. See [#11081](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11081). Thanks to @zasdaym for contribution.
 * BUGFIX: [vmrestore](https://docs.victoriametrics.com/victoriametrics/vmrestore/): disallow restoring parts outside the configured `-storageDataPath` directory. See [710c920d](https://github.com/VictoriaMetrics/VictoriaMetrics/commit/710c920d6083327042a309e449fae4383617d817).
+* BUGFIX: `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): correctly apply long tenant filters. Previously, such filters could be truncated, causing tenants to be matched incorrectly. See [#11096](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11096). Thanks for @fxrlv for the contribution.
+* BUGFIX: `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): fix corrupted metrics metadata when a response contains multiple rows. See [#11115](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11115). Thanks for @fxrlv for the contribution.
+* BUGFIX: `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): don't cache empty responses for tenant IDs discovery during [multitenant queries](https://docs.victoriametrics.com/Cluster-VictoriaMetrics.html#multitenant-reads). This problem was visible during integration tests when multitenant queries were executed before the first ingestion happened. See [#10982](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/10982)
+* BUGFIX: [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmselect` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): properly escape `metricFamilyName` at metrics metadata response. See [#11129](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11129). Thanks for @fxrlv for the contribution.
+* BUGFIX: [vmsingle](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/) and `vmstorage` in [VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/): prevent more cases of panic during directory deletion on `NFS`-based mounts. See [#11060](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11060).

 ## [v1.145.0](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v1.145.0)

--- a/docs/victoriametrics/stream-aggregation/README.md
+++ b/docs/victoriametrics/stream-aggregation/README.md
@@ -76,7 +76,7 @@ It is better to substitute the slow recording rule with the following [stream ag
  outputs: [rate_sum]
 ```

-> Field `interval` should be set to a value at least several times higher than the matched metrics collection interval. 
+> It is recommended to set the `interval` field to a value at least 2 times the matched metrics collection interval.

 This stream aggregation generates `http_request_duration_seconds_bucket:1m_without_instance_rate_sum` output series according to [output metric naming](#output-metric-names).
 Then these series can be used in [alerting rules](https://docs.victoriametrics.com/victoriametrics/vmalert/#alerting-rules):
@@ -396,7 +396,7 @@ before sending them to the configured `-remoteWrite.url`. The deduplication can

 Labels can be dropped before deduplication is applied. See [these docs](#dropping-unneeded-labels).

-Stream aggregation deduplication is applied before aggregation rules, so duplicate samples are dropped before aggregation.
+Stream aggregation deduplication is applied before aggregation rules, so duplicate samples are dropped before aggregation. The dropped old samples can be tracked with the `vm_streamaggr_dedup_dropped_samples_total` metric.

 # Relabeling

@@ -444,7 +444,9 @@ outside the current [aggregation interval](https://docs.victoriametrics.com/vict

 - To enable [aggregation windows](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#aggregation-windows).

-The dropped old samples can be tracked with the `vm_streamaggr_ignored_samples_total{reason="too_old"}` metric.
+- To enable [deduplication](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication).
+
+The dropped old samples can be tracked with the `vm_streamaggr_ignored_samples_total{reason="too_old"}` and `vm_streamaggr_dedup_dropped_samples_total` metrics.

 ## Ignore aggregation intervals on start

@@ -642,9 +644,9 @@ See also [why you shouldn't put an aggregator behind a load balancer](https://do

 # Troubleshooting

- [Unexpected spikes for `total` or `increase` outputs](#staleness).
+- [Unexpected spikes for `total` or `increase` outputs](#data-delay-and-staleness).
 - [Excessively large values for `total*`, `increase*`, and `rate*` outputs](#counter-resets).
- [Lower than expected values for `total_prometheus` and `increase_prometheus` outputs](#staleness).
+- [Lower than expected values for `total_prometheus` and `increase_prometheus` outputs](#data-delay-and-staleness).
 - [High memory usage and CPU usage](#high-resource-usage).
 - [Unexpected results in vmagent cluster mode](#cluster-mode).
 - [Inaccurate aggregation results for histograms](#aggregation-windows)
@@ -677,11 +679,19 @@ the following settings:

 If counter-specific outputs, such as `total*`, `rate*`, and `increase*`, produce values that are significantly higher than anticipated, then check the `vm_streamaggr_counter_resets_total` metric. This metric increments each time when [counter reset event](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#counter) happens and could be caused by duplication or collision of raw samples. If you observe duplication or collision, try solving this problem by either fixing the source of these metrics or by [deduplicating](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication) these samples before aggregation.

-## Staleness
+## Data delay and staleness {#staleness}

-The following outputs track the last seen per-series values in order to properly calculate output values:
+Stream aggregation processes input samples in a streaming manner and flushes results once per specified `interval`. Because of this, aggregation results can be heavily affected by data delays (see `vm_streamaggr_samples_lag_seconds_bucket` metric).
+
+In particular:
+1. Stream aggregation won't produce results if input samples are delayed for multiple aggregation intervals, causing gaps in the output.
+2. Delayed and out-of-order samples can inflate or skew correctness of aggregation results.
+
+Dropping delayed samples can result in missed observations in the results, while keeping delayed samples may inflate the results. It is up to the user to decide what they prefer in the produced results:
+1. If you prefer consistency in aggregation results and do not want delayed data to affect the next aggregation window, drop all potentially delayed samples via [ignore_old_samples](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples).
+2. If you prefer to have the accumulated changes from delayed data reflected in aggregation windows after the delay, increase `staleness_interval` in the [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config).
+This is especially important for outputs that track the last seen per-series values in order to properly calculate output values:

- [histogram_bucket](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#histogram_bucket)
 - [increase](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase)
 - [increase_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase_prometheus)
 - [rate_avg](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#rate_avg)
@@ -689,21 +699,19 @@ The following outputs track the last seen per-series values in order to properly
 - [total](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total)
 - [total_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total_prometheus)

-The last seen per-series value is dropped if no new samples are received for the given time series during two consecutive aggregations
-intervals specified in [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config) via `interval` option.
+For these outputs, the last seen per-series value is dropped if no new samples are received for the given time series during consecutive aggregation intervals specified in the [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config) via `interval` option.
 If a new sample for the existing time series is received after that, then it is treated as the first sample for a new time series.
-This may lead to the following issues:
+This may lead to the following issues when data is delayed:

- Lower than expected results for [total_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total_prometheus) and [increase_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase_prometheus) outputs,
-  since they ignore the first sample in a new time series.
- Unexpected spikes for [total](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total) and [increase](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase) outputs, since they assume that new time series start from 0.
+- [total](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total) and [increase](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase) may produce unexpected spikes, since they assume that a new time series starts from `0`.
+- [total_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#total_prometheus) and [increase_prometheus](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#increase_prometheus) may produce lower than expected results, if you expect to see the accumulated changes reflected after the delay, since they ignore the first sample in a new time series.

-These issues can be fixed in the following ways:
+These issues can be improved in the following ways:

 - By increasing the `interval` option at [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config), so it covers the expected
-  delays in data ingestion pipelines.
- By specifying the `staleness_interval` option at [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config), so it covers the expected
-  delays in data ingestion pipelines. By default, the `staleness_interval` is equal to `2 x interval`.
+  delays in data ingestion pipelines. It is recommended to set `interval` to at least 2× the scrape or push interval of the input. Set it to a higher value if the input pipeline is prone to large delays.
+- By increasing the `staleness_interval` option in the [stream aggregation config](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/configuration/#stream-aggregation-config), so it covers the expected
+  delays in data ingestion pipelines. By default, the `staleness_interval` is equal to `interval`.

 ## High resource usage

--- a/docs/victoriametrics/stream-aggregation/configuration.md
+++ b/docs/victoriametrics/stream-aggregation/configuration.md
@@ -66,6 +66,8 @@ specified individually per each `-remoteWrite.url`:

  # interval is the interval for the aggregation.
  # The aggregated stats is sent to remote storage once per interval.
+  # It is recommended to set `interval` to at least 2× the scrape or push interval of the input.
+  # Set it to a higher value if the input pipeline is prone to large delays.
  #
  interval: 1m

@@ -94,7 +96,7 @@ specified individually per each `-remoteWrite.url`:
  # - total_prometheus
  # See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#staleness for more details.
  #
-  # staleness_interval: 2m
+  # staleness_interval: 1m

  # ignore_first_sample_interval specifies the interval after which the agent begins sending samples.
  # By default, it is set to the staleness interval, and it helps reduce the initial sample load after an agent restart.
@@ -291,9 +293,6 @@ The results of `histogram_bucket` is equal to the following [MetricsQL](https://
 sum(histogram_over_time(some_histogram_bucket[interval])) by (vmrange)
 ```

-Aggregating irregular and sporadic metrics (received from [Lambdas](https://aws.amazon.com/lambda/)
-or [Cloud Functions](https://cloud.google.com/functions)) can be controlled via [staleness_interval](https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#staleness) option.
-
 See also:
 - [quantiles](#quantiles)
 - [avg](#avg)
@@ -507,6 +506,19 @@ See also:
 - [count_samples](#count_samples)
 - [count_series](#count_series)

+### `sum_samples_total`
+
+`sum_samples_total` sums input delta values into a cumulative [counter](https://docs.victoriametrics.com/victoriametrics/keyconcepts/index.html#counter) and outputs the result at the given `interval`.
+`sum_samples_total` makes sense only for aggregating delta values from clients such as [StatsD counter](https://github.com/statsd/statsd/blob/master/docs/metric_types.md#counting).
+
+The results of `sum_samples_total` is roughly equal to the following [MetricsQL](https://docs.victoriametrics.com/victoriametrics/metricsql/) query:
+
+```metricsql
+sum(running_sum(some_delta_values))
+```
+
+>Note: The aggregator will forget the cumulative counter if it has not seen input samples for `staleness_interval`(set to `interval` by default) per output result, so the output counter will start from `0` the next time it sees the input again. Increase the `staleness_interval` option if you want to extend the window to tolerate bigger gaps.
+
 ### total

 `total` generates output [counter](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#counter) by summing the input counters over the given `interval`.
--- a/docs/victoriametrics/vmagent.md
+++ b/docs/victoriametrics/vmagent.md
@@ -798,7 +798,7 @@ The `-promscrape.cluster.memberNum` can be set to a StatefulSet pod name when `v
 The pod name must end with a number in the range `0 ... promscrape.cluster.membersCount-1`. For example, `-promscrape.cluster.memberNum=vmagent-0`.

 By default, targets are sharded among `vmagent` instances by all target labels after relabeling.
-Use `-promscrape.cluster.shardByLabels` {{% available_from "#" %}} to shard targets by specified labels instead.
+Use `-promscrape.cluster.shardByLabels` {{% available_from "v1.146.0" %}} to shard targets by specified labels instead.
 For example, with `-promscrape.cluster.shardByLabels=service`, the targets with the same `service` label value will be scraped by the same `vmagent` instance, 
 which is useful when perform stream aggregation that requires all metrics with the same `service` label value to be processed on the same `vmagent` instance. 
 If none of the specified labels are present in the target labels, then all target labels will be used for sharding.
@@ -934,6 +934,29 @@ vmagent will generate the following persistent queue folders:
 2_0AAFDF53E314A72A
 ```

+### On-disk persistence and data processing order
+
+By default, vmagent processes data in FIFO order. If data has been written to the on-disk queue,
+it must be flushed to the remote storage before newly ingested data can be forwarded there.
+During long outages, vmagent may accumulate large amounts of data in the file-based queue,
+which can introduce a significant lag between the moment data is collected by vmagent and the
+moment it becomes visible at the remote storage.
+
+This behavior can be changed with the `-remoteWrite.inmemoryQueues` {{% available_from "v1.146.0" %}} command-line flag.
+When set to a non-zero value, vmagent starts the given number of additional workers,
+which send only recently ingested data from the in-memory queue, while the workers configured via `-remoteWrite.queues` drain the file-based backlog concurrently.
+This reduces the delivery lag for fresh samples after remote storage outages or slowdowns. The flag can be set individually per each `-remoteWrite.url`.
+
+Note that these workers are started in addition to the workers configured via `-remoteWrite.queues`, so the total number of concurrent connections to
+the remote storage becomes the sum of both flags. Take this into account if the remote storage limits the number of concurrent requests.
+
+This flag has the following possible limitations:
+
+* Samples may arrive at the remote storage out of order, since recent data can be delivered before the older backlogged data.
+  Do not use this option if the remote storage doesn't accept out-of-order samples.
+* Recent data isn't guaranteed to take the fast path: if the in-memory queue  is full,
+  newly ingested data is still written to the file-based queue and is delivered in FIFO order by the generic workers.
+
 ### Disabling On-disk persistence

 There are cases when it is better to disable on-disk persistence for pending data on the `vmagent` side:
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,7 @@ require (
 	github.com/VictoriaMetrics/VictoriaLogs v1.121.1-0.20260616132739-c901a1e31cb3
 	github.com/VictoriaMetrics/easyproto v1.2.0
 	github.com/VictoriaMetrics/fastcache v1.13.3
-	github.com/VictoriaMetrics/metrics v1.43.2
+	github.com/VictoriaMetrics/metrics v1.44.0
 	github.com/VictoriaMetrics/metricsql v0.87.1
 	github.com/aws/aws-sdk-go-v2 v1.42.0
 	github.com/aws/aws-sdk-go-v2/config v1.32.25
--- a/go.sum
+++ b/go.sum
@@ -62,6 +62,8 @@ github.com/VictoriaMetrics/fastcache v1.13.3 h1:rBabE0iIxcqKEMCwUmwHZ9dgEqXerg8F
 github.com/VictoriaMetrics/fastcache v1.13.3/go.mod h1:hHXhl4DA2fTL2HTZDJFXWgW0LNjo6B+4aj2Wmng3TjU=
 github.com/VictoriaMetrics/metrics v1.43.2 h1:+8pIQEGwchKS5CYFyvv3LKvNXGi7baZ9hmIV4RHqibY=
 github.com/VictoriaMetrics/metrics v1.43.2/go.mod h1:xDM82ULLYCYdFRgQ2JBxi8Uf1+8En1So9YUwlGTOqTc=
+github.com/VictoriaMetrics/metrics v1.44.0 h1:Fr8yqQSV+ZfYaDD/anqk1E8e9YPgfleSleJmAI0M0Tw=
+github.com/VictoriaMetrics/metrics v1.44.0/go.mod h1:xDM82ULLYCYdFRgQ2JBxi8Uf1+8En1So9YUwlGTOqTc=
 github.com/VictoriaMetrics/metricsql v0.87.1 h1:GdIblCDgXsrBJcBSDtFT8SLK7P+QHijdQmcr4L/f0Go=
 github.com/VictoriaMetrics/metricsql v0.87.1/go.mod h1:d4EisFO6ONP/HIGDYTAtwrejJBBeKGQYiRl095bS4QQ=
 github.com/VividCortex/ewma v1.2.0 h1:f58SaIzcDXrSy3kWaHNvuJgJ3Nmz59Zji6XoJR/q1ow=
--- a/lib/persistentqueue/fastqueue.go
+++ b/lib/persistentqueue/fastqueue.go
@@ -26,6 +26,8 @@ type FastQueue struct {
 	// isPQDisabled is set to true when pq is disabled.
 	isPQDisabled bool

+	prioritizeInMemoryData bool
+
 	// pq is file-based queue
 	pq *queue

@@ -39,6 +41,31 @@ type FastQueue struct {
 	stopDeadline uint64
 }

+// OpenFastQueueOpts defines options for FastQueue
+type OpenFastQueueOpts struct {
+	// MaxInmemoryBlocks defines amount of blocks to hold in memory before falling back to file-based persistence.
+	MaxInmemoryBlocks int
+	// MaxPendingBytes limits file-based size of the queue.
+	// If MaxPendingBytes is 0, then the queue size is unlimited.
+	// The oldest data is dropped when the queue
+	// reaches MaxPendingSize.
+	MaxPendingBytes int64
+	// IsPQDisabled defines whether file-based queue could be used.
+	// If it is set to true, then write requests that exceed in-memory buffer capacity are rejected.
+	// in-memory queue part can be stored on disk during graceful shutdown.
+	IsPQDisabled bool
+	// PrioritizeInMemoryData instructs FastQueue to write data into the in-memory queue
+	// even if the file-based queue is not empty.
+	// This is useful when data order doesn't matter and getting the most recent data
+	// as fast as possible is more important.
+	PrioritizeInmemoryData bool
+}
+
+// MustOpenFastQueueWithOpts opens persistent queue at the given path with given opts
+func MustOpenFastQueueWithOpts(path, name string, opts OpenFastQueueOpts) *FastQueue {
+	return mustOpenFastQueue(path, name, opts)
+}
+
 // MustOpenFastQueue opens persistent queue at the given path.
 //
 // It holds up to maxInmemoryBlocks in memory before falling back to file-based persistence.
@@ -49,11 +76,22 @@ type FastQueue struct {
 // if isPQDisabled is set to true, then write requests that exceed in-memory buffer capacity are rejected.
 // in-memory queue part can be stored on disk during graceful shutdown.
 func MustOpenFastQueue(path, name string, maxInmemoryBlocks int, maxPendingBytes int64, isPQDisabled bool) *FastQueue {
+	opts := OpenFastQueueOpts{
+		MaxInmemoryBlocks: maxInmemoryBlocks,
+		MaxPendingBytes:   maxPendingBytes,
+		IsPQDisabled:      isPQDisabled,
+	}
+	return mustOpenFastQueue(path, name, opts)
+}
+func mustOpenFastQueue(path, name string, opts OpenFastQueueOpts) *FastQueue {
+	maxPendingBytes := opts.MaxPendingBytes
+	isPQDisabled := opts.IsPQDisabled
 	pq := mustOpen(path, name, maxPendingBytes)
 	fq := &FastQueue{
-		pq:           pq,
-		isPQDisabled: isPQDisabled,
-		ch:           make(chan *bytesutil.ByteBuffer, maxInmemoryBlocks),
+		pq:                     pq,
+		isPQDisabled:           isPQDisabled,
+		prioritizeInMemoryData: opts.PrioritizeInmemoryData,
+		ch:                     make(chan *bytesutil.ByteBuffer, opts.MaxInmemoryBlocks),
 	}
 	fq.cond.L = &fq.mu
 	fq.lastInmemoryBlockReadTime = fasttime.UnixTimestamp()
@@ -81,7 +119,7 @@ func MustOpenFastQueue(path, name string, maxInmemoryBlocks int, maxPendingBytes
 	if isPQDisabled {
 		persistenceStatus = "disabled"
 	}
-	logger.Infof("opened fast queue at %q with maxInmemoryBlocks=%d, it contains %d pending bytes, persistence is %s", path, maxInmemoryBlocks, pendingBytes, persistenceStatus)
+	logger.Infof("opened fast queue at %q with maxInmemoryBlocks=%d, it contains %d pending bytes, persistence is %s", path, opts.MaxInmemoryBlocks, pendingBytes, persistenceStatus)
 	return fq
 }

@@ -97,7 +135,7 @@ func (fq *FastQueue) IsWriteBlocked() bool {
 	}
 	fq.mu.Lock()
 	defer fq.mu.Unlock()
-	return len(fq.ch) == cap(fq.ch) || fq.pq.GetPendingBytes() > 0
+	return len(fq.ch) == cap(fq.ch) || (fq.pq.GetPendingBytes() > 0 && !fq.prioritizeInMemoryData)
 }

 // UnblockAllReaders unblocks all the readers.
@@ -193,19 +231,24 @@ func (fq *FastQueue) tryWriteBlock(block []byte, ignoreDisabledPQ bool) bool {
 	defer fq.mu.Unlock()

 	isPQWriteAllowed := !fq.isPQDisabled || ignoreDisabledPQ
-
-	fq.flushInmemoryBlocksToFileIfNeededLocked()
-	if n := fq.pq.GetPendingBytes(); n > 0 {
-		// The file-based queue isn't drained yet. This means that in-memory queue cannot be used yet.
-		// So put the block to file-based queue.
-		if len(fq.ch) > 0 {
-			logger.Panicf("BUG: the in-memory queue must be empty when the file-based queue is non-empty; it contains %d pending bytes", n)
+	if !isPQWriteAllowed && fq.pq.GetPendingBytes() > 0 {
+		// fast path: there is pending data at file-based queue,
+		// it must be drained before in-memory queue could be used.
+		// File-based queue could be non-empty after vmagent restart
+		// and vmagent couldn't flush in-memory queue during shutdown.
+		return false
+	}
+	if !fq.prioritizeInMemoryData {
+		fq.flushInmemoryBlocksToFileIfNeededLocked()
+		if n := fq.pq.GetPendingBytes(); n > 0 {
+			// The file-based queue isn't drained yet. This means that in-memory queue cannot be used yet.
+			// So put the block to file-based queue.
+			if len(fq.ch) > 0 {
+				logger.Panicf("BUG: the in-memory queue must be empty when the file-based queue is non-empty; it contains %d pending bytes", n)
+			}
+			fq.pq.MustWriteBlock(block)
+			return true
 		}
-		if !isPQWriteAllowed {
-			return false
-		}
-		fq.pq.MustWriteBlock(block)
-		return true
 	}
 	if len(fq.ch) == cap(fq.ch) {
 		// There is no space left in the in-memory queue. Put the data to file-based queue.
@@ -216,7 +259,7 @@ func (fq *FastQueue) tryWriteBlock(block []byte, ignoreDisabledPQ bool) bool {
 		fq.pq.MustWriteBlock(block)
 		return true
 	}
-	// Fast path - put the block to in-memory queue.
+
 	bb := blockBufPool.Get()
 	bb.B = append(bb.B[:0], block...)
 	fq.ch <- bb
@@ -229,12 +272,41 @@ func (fq *FastQueue) tryWriteBlock(block []byte, ignoreDisabledPQ bool) bool {
 }

 // MustReadBlock reads the next block from fq into dst and returns it.
-// It first reads from the in-memory queue, then checks file-based queue.
+// It first reads from the file-based queue, then checks in-memory queue.
 // It blocks until a block is available or the stop deadline is exceeded, in which case it returns (dst, false).
 func (fq *FastQueue) MustReadBlock(dst []byte) ([]byte, bool) {
 	fq.mu.Lock()
 	defer fq.mu.Unlock()

+	for {
+		if fq.stopDeadline > 0 && fasttime.UnixTimestamp() > fq.stopDeadline {
+			return dst, false
+		}
+		if n := fq.pq.GetPendingBytes(); n > 0 {
+			data, ok := fq.pq.MustReadBlockNonblocking(dst)
+			if ok {
+				return data, true
+			}
+			dst = data
+		}
+		if len(fq.ch) > 0 {
+			return fq.mustReadInMemoryBlockLocked(dst), true
+		}
+		if fq.stopDeadline > 0 {
+			return dst, false
+		}
+		// There are no blocks. Wait for new block.
+		fq.pq.ResetIfEmpty()
+		fq.cond.Wait()
+	}
+}
+
+// MustReadInMemoryBlockBlocking reads the next block from the in-memory queue into dst and returns it.
+// It blocks until a block is available or the stop deadline is exceeded, in which case it returns (dst, false).
+func (fq *FastQueue) MustReadInMemoryBlockBlocking(dst []byte) ([]byte, bool) {
+	fq.mu.Lock()
+	defer fq.mu.Unlock()
+
 	for {
 		if fq.stopDeadline > 0 && fasttime.UnixTimestamp() > fq.stopDeadline {
 			return dst, false
@@ -242,19 +314,10 @@ func (fq *FastQueue) MustReadBlock(dst []byte) ([]byte, bool) {
 		if len(fq.ch) > 0 {
 			return fq.mustReadInMemoryBlockLocked(dst), true
 		}
-		if n := fq.pq.GetPendingBytes(); n > 0 {
-			data, ok := fq.pq.MustReadBlockNonblocking(dst)
-			if ok {
-				return data, true
-			}
-			dst = data
-			continue
-		}
 		if fq.stopDeadline > 0 {
 			return dst, false
 		}
 		// There are no blocks. Wait for new block.
-		fq.pq.ResetIfEmpty()
 		fq.cond.Wait()
 	}
 }
@@ -277,9 +340,6 @@ func (fq *FastQueue) mustReadInMemoryBlockLocked(dst []byte) []byte {
 	if len(fq.ch) == 0 {
 		logger.Panicf("BUG: the function must not be called when in-memory queue is empty. Caller should verify the queue len upfront")
 	}
-	if n := fq.pq.GetPendingBytes(); n > 0 {
-		logger.Panicf("BUG: the file-based queue must be empty when the in-memory queue is non-empty; it contains %d pending bytes", n)
-	}
 	bb := <-fq.ch
 	fq.pendingInmemoryBytes -= uint64(len(bb.B))
 	fq.lastInmemoryBlockReadTime = fasttime.UnixTimestamp()
--- a/lib/persistentqueue/fastqueue_test.go
+++ b/lib/persistentqueue/fastqueue_test.go
@@ -364,3 +364,64 @@ func TestFastQueueWriteReadWithIgnoreDisabledPQ(t *testing.T) {
 	fq.MustClose()
 	fs.MustRemoveDir(path)
 }
+
+func TestFastQueueWriteReadWithPrioritizeInmemory(t *testing.T) {
+	path := "fast-queue-write-read-inmemory-disabled-pq-force-write"
+	fs.MustRemoveDir(path)
+
+	capacity := 20
+	opts := OpenFastQueueOpts{
+		MaxInmemoryBlocks:      capacity,
+		PrioritizeInmemoryData: true,
+	}
+	fq := MustOpenFastQueueWithOpts(path, "foobar", opts)
+	if n := fq.GetInmemoryQueueLen(); n != 0 {
+		t.Fatalf("unexpected non-zero inmemory queue size:  %d", n)
+	}
+	var blocks []string
+	for i := range capacity {
+		block := fmt.Sprintf("block %d", i)
+		if !fq.TryWriteBlock([]byte(block)) {
+			t.Fatalf("TryWriteBlock must return true in this context")
+		}
+		blocks = append(blocks, block)
+	}
+	if n := fq.GetInmemoryQueueLen(); n != capacity {
+		t.Fatalf("unexpected non-zero inmemory queue size:  %d: %d", n, capacity)
+	}
+	for i := range capacity {
+		block := fmt.Sprintf("block %d-%d", i, i)
+		if !fq.TryWriteBlock([]byte(block)) {
+			t.Fatalf("TryWriteBlock must return true in this context")
+		}
+		blocks = append(blocks, block)
+	}
+
+	// in case of capacity exceed last element is written into file-based queue
+	if n := fq.GetInmemoryQueueLen(); n != capacity-1 {
+		t.Fatalf("unexpected non-zero inmemory queue size:  %d: %d", n, capacity)
+	}
+
+	// make sure that recently ingested elemements returned first
+	for idx := capacity + 1; idx < capacity*2; idx++ {
+		buf, ok := fq.MustReadInMemoryBlockBlocking(nil)
+		if !ok {
+			t.Fatalf("unexpected ok=false")
+		}
+		if string(buf) != blocks[idx] {
+			t.Fatalf("unexpected block read; got %q; want %q: %d", buf, blocks[idx], idx)
+		}
+	}
+	blocks = blocks[:capacity+1]
+	for _, block := range blocks {
+		buf, ok := fq.MustReadBlock(nil)
+		if !ok {
+			t.Fatalf("unexpected ok=false")
+		}
+		if string(buf) != block {
+			t.Fatalf("unexpected block read; got %q; want %q", buf, block)
+		}
+	}
+	fq.MustClose()
+	fs.MustRemoveDir(path)
+}
--- a/lib/promrelabel/debug.qtpl
+++ b/lib/promrelabel/debug.qtpl
@@ -36,12 +36,10 @@ function submitRelabelDebugForm(e) {
    <div class="container-fluid">
        <a href="https://docs.victoriametrics.com/victoriametrics/relabeling/" target="_blank">Relabeling docs</a>{% space %}

-        {% if targetID != "" %}
-          {% if targetURL != "" %}
-            <a href="metric-relabel-debug?id={%s targetID %}">Metric relabel debug</a>
-          {% else %}
-            <a href="target-relabel-debug?id={%s targetID %}">Target relabel debug</a>
-          {% endif %}
+        {% if targetURL != "" %}
+          <a href="metric-relabel-debug{% if targetID != "" %}?id={%s targetID %}{% endif %}">Metric relabel debug</a>
+        {% else %}
+          <a href="target-relabel-debug{% if targetID != "" %}?id={%s targetID %}{% endif %}">Target relabel debug</a>
        {% endif %}

        <br>
--- a/lib/promrelabel/debug.qtpl.go
+++ b/lib/promrelabel/debug.qtpl.go
@@ -80,417 +80,425 @@ func StreamRelabelDebugStepsHTML(qw422016 *qt422016.Writer, targetURL, targetID
 //line lib/promrelabel/debug.qtpl:37
 	qw422016.N().S(` `)
 //line lib/promrelabel/debug.qtpl:39
-	if targetID != "" {
+	if targetURL != "" {
+//line lib/promrelabel/debug.qtpl:39
+		qw422016.N().S(`<a href="metric-relabel-debug`)
 //line lib/promrelabel/debug.qtpl:40
-		if targetURL != "" {
+		if targetID != "" {
+//line lib/promrelabel/debug.qtpl:40
+			qw422016.N().S(`?id=`)
 //line lib/promrelabel/debug.qtpl:40
-			qw422016.N().S(`<a href="metric-relabel-debug?id=`)
-//line lib/promrelabel/debug.qtpl:41
 			qw422016.E().S(targetID)
-//line lib/promrelabel/debug.qtpl:41
-			qw422016.N().S(`">Metric relabel debug</a>`)
-//line lib/promrelabel/debug.qtpl:42
-		} else {
-//line lib/promrelabel/debug.qtpl:42
-			qw422016.N().S(`<a href="target-relabel-debug?id=`)
-//line lib/promrelabel/debug.qtpl:43
-			qw422016.E().S(targetID)
-//line lib/promrelabel/debug.qtpl:43
-			qw422016.N().S(`">Target relabel debug</a>`)
-//line lib/promrelabel/debug.qtpl:44
+//line lib/promrelabel/debug.qtpl:40
 		}
-//line lib/promrelabel/debug.qtpl:45
+//line lib/promrelabel/debug.qtpl:40
+		qw422016.N().S(`">Metric relabel debug</a>`)
+//line lib/promrelabel/debug.qtpl:41
+	} else {
+//line lib/promrelabel/debug.qtpl:41
+		qw422016.N().S(`<a href="target-relabel-debug`)
+//line lib/promrelabel/debug.qtpl:42
+		if targetID != "" {
+//line lib/promrelabel/debug.qtpl:42
+			qw422016.N().S(`?id=`)
+//line lib/promrelabel/debug.qtpl:42
+			qw422016.E().S(targetID)
+//line lib/promrelabel/debug.qtpl:42
+		}
+//line lib/promrelabel/debug.qtpl:42
+		qw422016.N().S(`">Target relabel debug</a>`)
+//line lib/promrelabel/debug.qtpl:43
 	}
-//line lib/promrelabel/debug.qtpl:45
+//line lib/promrelabel/debug.qtpl:43
 	qw422016.N().S(`<br>`)
-//line lib/promrelabel/debug.qtpl:48
+//line lib/promrelabel/debug.qtpl:46
 	if err != nil {
-//line lib/promrelabel/debug.qtpl:49
+//line lib/promrelabel/debug.qtpl:47
 		htmlcomponents.StreamErrorNotification(qw422016, err)
-//line lib/promrelabel/debug.qtpl:50
+//line lib/promrelabel/debug.qtpl:48
 	}
-//line lib/promrelabel/debug.qtpl:50
+//line lib/promrelabel/debug.qtpl:48
 	qw422016.N().S(`<div class="m-3"><form method="POST" onsubmit="submitRelabelDebugForm(event)">`)
-//line lib/promrelabel/debug.qtpl:54
+//line lib/promrelabel/debug.qtpl:52
 	streamrelabelDebugFormInputs(qw422016, metric, relabelConfigs)
-//line lib/promrelabel/debug.qtpl:55
+//line lib/promrelabel/debug.qtpl:53
 	if targetID != "" {
-//line lib/promrelabel/debug.qtpl:55
+//line lib/promrelabel/debug.qtpl:53
 		qw422016.N().S(`<input type="hidden" name="id" value="`)
-//line lib/promrelabel/debug.qtpl:56
+//line lib/promrelabel/debug.qtpl:54
 		qw422016.E().S(targetID)
-//line lib/promrelabel/debug.qtpl:56
+//line lib/promrelabel/debug.qtpl:54
 		qw422016.N().S(`" />`)
-//line lib/promrelabel/debug.qtpl:57
+//line lib/promrelabel/debug.qtpl:55
 	}
-//line lib/promrelabel/debug.qtpl:57
+//line lib/promrelabel/debug.qtpl:55
 	qw422016.N().S(`<input type="submit" value="Submit" class="btn btn-primary m-1" />`)
-//line lib/promrelabel/debug.qtpl:59
+//line lib/promrelabel/debug.qtpl:57
 	if targetID != "" {
-//line lib/promrelabel/debug.qtpl:59
+//line lib/promrelabel/debug.qtpl:57
 		qw422016.N().S(`<button type="button" onclick="location.href='?id=`)
-//line lib/promrelabel/debug.qtpl:60
+//line lib/promrelabel/debug.qtpl:58
 		qw422016.E().S(targetID)
-//line lib/promrelabel/debug.qtpl:60
+//line lib/promrelabel/debug.qtpl:58
 		qw422016.N().S(`'" class="btn btn-secondary m-1">Reset</button>`)
-//line lib/promrelabel/debug.qtpl:61
+//line lib/promrelabel/debug.qtpl:59
 	}
-//line lib/promrelabel/debug.qtpl:61
+//line lib/promrelabel/debug.qtpl:59
 	qw422016.N().S(`</form></div><div class="row"><main class="col-12">`)
-//line lib/promrelabel/debug.qtpl:67
+//line lib/promrelabel/debug.qtpl:65
 	streamrelabelDebugSteps(qw422016, dss, targetURL, targetID)
-//line lib/promrelabel/debug.qtpl:67
+//line lib/promrelabel/debug.qtpl:65
 	qw422016.N().S(`</main></div></div></body></html>`)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 }

-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 func WriteRelabelDebugStepsHTML(qq422016 qtio422016.Writer, targetURL, targetID string, dss []DebugStep, metric, relabelConfigs string, err error) {
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	StreamRelabelDebugStepsHTML(qw422016, targetURL, targetID, dss, metric, relabelConfigs, err)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 }

-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 func RelabelDebugStepsHTML(targetURL, targetID string, dss []DebugStep, metric, relabelConfigs string, err error) string {
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	WriteRelabelDebugStepsHTML(qb422016, targetURL, targetID, dss, metric, relabelConfigs, err)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 	return qs422016
-//line lib/promrelabel/debug.qtpl:73
+//line lib/promrelabel/debug.qtpl:71
 }

-//line lib/promrelabel/debug.qtpl:75
+//line lib/promrelabel/debug.qtpl:73
 func streamrelabelDebugFormInputs(qw422016 *qt422016.Writer, metric, relabelConfigs string) {
-//line lib/promrelabel/debug.qtpl:75
+//line lib/promrelabel/debug.qtpl:73
 	qw422016.N().S(`<div>Relabel configs:<br/><textarea name="relabel_configs" style="width: 100%; height: 15em; font-family: monospace" class="m-1">`)
-//line lib/promrelabel/debug.qtpl:78
+//line lib/promrelabel/debug.qtpl:76
 	qw422016.E().S(relabelConfigs)
-//line lib/promrelabel/debug.qtpl:78
+//line lib/promrelabel/debug.qtpl:76
 	qw422016.N().S(`</textarea></div><div>Labels:<br/><textarea name="metric" style="width: 100%; height: 5em; font-family: monospace" class="m-1">`)
-//line lib/promrelabel/debug.qtpl:83
+//line lib/promrelabel/debug.qtpl:81
 	qw422016.E().S(metric)
-//line lib/promrelabel/debug.qtpl:83
+//line lib/promrelabel/debug.qtpl:81
 	qw422016.N().S(`</textarea></div>`)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 }

-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 func writerelabelDebugFormInputs(qq422016 qtio422016.Writer, metric, relabelConfigs string) {
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	streamrelabelDebugFormInputs(qw422016, metric, relabelConfigs)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 }

-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 func relabelDebugFormInputs(metric, relabelConfigs string) string {
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	writerelabelDebugFormInputs(qb422016, metric, relabelConfigs)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 	return qs422016
-//line lib/promrelabel/debug.qtpl:85
+//line lib/promrelabel/debug.qtpl:83
 }

-//line lib/promrelabel/debug.qtpl:87
+//line lib/promrelabel/debug.qtpl:85
 func streamrelabelDebugSteps(qw422016 *qt422016.Writer, dss []DebugStep, targetURL, targetID string) {
-//line lib/promrelabel/debug.qtpl:88
+//line lib/promrelabel/debug.qtpl:86
 	if len(dss) > 0 {
-//line lib/promrelabel/debug.qtpl:88
+//line lib/promrelabel/debug.qtpl:86
 		qw422016.N().S(`<div class="m-3"><b>Original labels:</b> <samp>`)
-//line lib/promrelabel/debug.qtpl:90
+//line lib/promrelabel/debug.qtpl:88
 		streammustFormatLabels(qw422016, dss[0].In)
-//line lib/promrelabel/debug.qtpl:90
+//line lib/promrelabel/debug.qtpl:88
 		qw422016.N().S(`</samp></div>`)
-//line lib/promrelabel/debug.qtpl:92
+//line lib/promrelabel/debug.qtpl:90
 	}
-//line lib/promrelabel/debug.qtpl:92
+//line lib/promrelabel/debug.qtpl:90
 	qw422016.N().S(`<table class="table table-striped table-hover table-bordered table-sm"><thead><tr><th scope="col" style="width: 5%">Step</th><th scope="col" style="width: 25%">Relabeling Rule</th><th scope="col" style="width: 35%">Input Labels</th><th scope="col" stile="width: 35%">Output labels</a></tr></thead><tbody>`)
-//line lib/promrelabel/debug.qtpl:103
+//line lib/promrelabel/debug.qtpl:101
 	for i, ds := range dss {
-//line lib/promrelabel/debug.qtpl:105
+//line lib/promrelabel/debug.qtpl:103
 		inLabels, inErr := promutil.NewLabelsFromString(ds.In)
 		outLabels, outErr := promutil.NewLabelsFromString(ds.Out)
 		changedLabels := getChangedLabelNames(inLabels, outLabels)

-//line lib/promrelabel/debug.qtpl:108
+//line lib/promrelabel/debug.qtpl:106
 		qw422016.N().S(`<tr><td>`)
-//line lib/promrelabel/debug.qtpl:110
+//line lib/promrelabel/debug.qtpl:108
 		qw422016.N().D(i)
-//line lib/promrelabel/debug.qtpl:110
+//line lib/promrelabel/debug.qtpl:108
 		qw422016.N().S(`</td><td><b><pre class="m-2">`)
-//line lib/promrelabel/debug.qtpl:111
+//line lib/promrelabel/debug.qtpl:109
 		qw422016.E().S(ds.Rule)
-//line lib/promrelabel/debug.qtpl:111
+//line lib/promrelabel/debug.qtpl:109
 		qw422016.N().S(`</pre></b></td><td>`)
-//line lib/promrelabel/debug.qtpl:113
+//line lib/promrelabel/debug.qtpl:111
 		if inErr == nil {
-//line lib/promrelabel/debug.qtpl:113
+//line lib/promrelabel/debug.qtpl:111
 			qw422016.N().S(`<div class="m-2" style="font-size: 0.9em" title="deleted and updated labels highlighted in red">`)
-//line lib/promrelabel/debug.qtpl:115
+//line lib/promrelabel/debug.qtpl:113
 			streamlabelsWithHighlight(qw422016, inLabels, changedLabels, "#D15757")
+//line lib/promrelabel/debug.qtpl:113
+			qw422016.N().S(`</div>`)
 //line lib/promrelabel/debug.qtpl:115
-			qw422016.N().S(`</div>`)
-//line lib/promrelabel/debug.qtpl:117
 		} else {
-//line lib/promrelabel/debug.qtpl:117
+//line lib/promrelabel/debug.qtpl:115
 			qw422016.N().S(`<div class="m-2" style="font-size: 0.9em; color: red" title="error parsing input labels"><pre>`)
-//line lib/promrelabel/debug.qtpl:119
+//line lib/promrelabel/debug.qtpl:117
 			qw422016.E().S(inErr.Error())
+//line lib/promrelabel/debug.qtpl:117
+			qw422016.N().S(`</pre></div>`)
 //line lib/promrelabel/debug.qtpl:119
-			qw422016.N().S(`</pre></div>`)
-//line lib/promrelabel/debug.qtpl:121
 			break
-//line lib/promrelabel/debug.qtpl:122
+//line lib/promrelabel/debug.qtpl:120
 		}
-//line lib/promrelabel/debug.qtpl:122
+//line lib/promrelabel/debug.qtpl:120
 		qw422016.N().S(`</td><td>`)
-//line lib/promrelabel/debug.qtpl:125
+//line lib/promrelabel/debug.qtpl:123
 		if outErr == nil {
-//line lib/promrelabel/debug.qtpl:125
+//line lib/promrelabel/debug.qtpl:123
 			qw422016.N().S(`<div class="m-2" style="font-size: 0.9em" title="added and updated labels highlighted in blue">`)
-//line lib/promrelabel/debug.qtpl:127
+//line lib/promrelabel/debug.qtpl:125
 			streamlabelsWithHighlight(qw422016, outLabels, changedLabels, "#4495e0")
+//line lib/promrelabel/debug.qtpl:125
+			qw422016.N().S(`</div>`)
 //line lib/promrelabel/debug.qtpl:127
-			qw422016.N().S(`</div>`)
-//line lib/promrelabel/debug.qtpl:129
 		} else {
-//line lib/promrelabel/debug.qtpl:129
+//line lib/promrelabel/debug.qtpl:127
 			qw422016.N().S(`<div class="m-2" style="font-size: 0.9em; color: red" title="error parsing output labels"><pre>`)
-//line lib/promrelabel/debug.qtpl:131
+//line lib/promrelabel/debug.qtpl:129
 			qw422016.E().S(outErr.Error())
-//line lib/promrelabel/debug.qtpl:131
+//line lib/promrelabel/debug.qtpl:129
 			qw422016.N().S(`</pre></div>`)
-//line lib/promrelabel/debug.qtpl:133
+//line lib/promrelabel/debug.qtpl:131
 			break
-//line lib/promrelabel/debug.qtpl:134
+//line lib/promrelabel/debug.qtpl:132
 		}
-//line lib/promrelabel/debug.qtpl:134
+//line lib/promrelabel/debug.qtpl:132
 		qw422016.N().S(`</td></tr>`)
-//line lib/promrelabel/debug.qtpl:137
+//line lib/promrelabel/debug.qtpl:135
 	}
-//line lib/promrelabel/debug.qtpl:137
+//line lib/promrelabel/debug.qtpl:135
 	qw422016.N().S(`</tbody></table>`)
-//line lib/promrelabel/debug.qtpl:140
+//line lib/promrelabel/debug.qtpl:138
 	if len(dss) > 0 {
-//line lib/promrelabel/debug.qtpl:140
+//line lib/promrelabel/debug.qtpl:138
 		qw422016.N().S(`<div class="m-3"><b>Resulting labels:</b> <samp>`)
-//line lib/promrelabel/debug.qtpl:142
+//line lib/promrelabel/debug.qtpl:140
 		streammustFormatLabels(qw422016, dss[len(dss)-1].Out)
-//line lib/promrelabel/debug.qtpl:142
+//line lib/promrelabel/debug.qtpl:140
 		qw422016.N().S(`</samp>`)
-//line lib/promrelabel/debug.qtpl:143
+//line lib/promrelabel/debug.qtpl:141
 		if targetURL != "" {
-//line lib/promrelabel/debug.qtpl:143
+//line lib/promrelabel/debug.qtpl:141
 			qw422016.N().S(`<div><b>Target URL:</b>`)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.N().S(` `)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.N().S(`<a href="`)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.E().S(targetURL)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.N().S(`" target="_blank">`)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.E().S(targetURL)
-//line lib/promrelabel/debug.qtpl:145
+//line lib/promrelabel/debug.qtpl:143
 			qw422016.N().S(`</a>`)
-//line lib/promrelabel/debug.qtpl:146
+//line lib/promrelabel/debug.qtpl:144
 			if targetID != "" {
-//line lib/promrelabel/debug.qtpl:147
+//line lib/promrelabel/debug.qtpl:145
 				qw422016.N().S(` `)
-//line lib/promrelabel/debug.qtpl:147
+//line lib/promrelabel/debug.qtpl:145
 				qw422016.N().S(`(<a href="target_response?id=`)
-//line lib/promrelabel/debug.qtpl:148
+//line lib/promrelabel/debug.qtpl:146
 				qw422016.E().S(targetID)
-//line lib/promrelabel/debug.qtpl:148
+//line lib/promrelabel/debug.qtpl:146
 				qw422016.N().S(`" target="_blank" title="click to fetch target response on behalf of the scraper">response</a>)`)
-//line lib/promrelabel/debug.qtpl:149
+//line lib/promrelabel/debug.qtpl:147
 			}
-//line lib/promrelabel/debug.qtpl:149
+//line lib/promrelabel/debug.qtpl:147
 			qw422016.N().S(`</div>`)
-//line lib/promrelabel/debug.qtpl:151
+//line lib/promrelabel/debug.qtpl:149
 		}
-//line lib/promrelabel/debug.qtpl:151
+//line lib/promrelabel/debug.qtpl:149
 		qw422016.N().S(`</div>`)
-//line lib/promrelabel/debug.qtpl:153
+//line lib/promrelabel/debug.qtpl:151
 	}
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 }

-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 func writerelabelDebugSteps(qq422016 qtio422016.Writer, dss []DebugStep, targetURL, targetID string) {
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	streamrelabelDebugSteps(qw422016, dss, targetURL, targetID)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 }

-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 func relabelDebugSteps(dss []DebugStep, targetURL, targetID string) string {
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	writerelabelDebugSteps(qb422016, dss, targetURL, targetID)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 	return qs422016
-//line lib/promrelabel/debug.qtpl:154
+//line lib/promrelabel/debug.qtpl:152
 }

-//line lib/promrelabel/debug.qtpl:156
+//line lib/promrelabel/debug.qtpl:154
 func StreamRelabelDebugStepsJSON(qw422016 *qt422016.Writer, targetURL, targetID string, dss []DebugStep, metric, relabelConfigs string, err error) {
-//line lib/promrelabel/debug.qtpl:156
+//line lib/promrelabel/debug.qtpl:154
 	qw422016.N().S(`{`)
-//line lib/promrelabel/debug.qtpl:158
+//line lib/promrelabel/debug.qtpl:156
 	if err != nil {
-//line lib/promrelabel/debug.qtpl:158
+//line lib/promrelabel/debug.qtpl:156
 		qw422016.N().S(`"status": "error","error":`)
-//line lib/promrelabel/debug.qtpl:160
+//line lib/promrelabel/debug.qtpl:158
 		qw422016.N().Q(fmt.Sprintf("Error: %s", err))
-//line lib/promrelabel/debug.qtpl:161
+//line lib/promrelabel/debug.qtpl:159
 	} else {
-//line lib/promrelabel/debug.qtpl:162
+//line lib/promrelabel/debug.qtpl:160
 		var hasError bool

-//line lib/promrelabel/debug.qtpl:162
+//line lib/promrelabel/debug.qtpl:160
 		qw422016.N().S(`"status": "success","steps": [`)
-//line lib/promrelabel/debug.qtpl:165
+//line lib/promrelabel/debug.qtpl:163
 		for i, ds := range dss {
-//line lib/promrelabel/debug.qtpl:167
+//line lib/promrelabel/debug.qtpl:165
 			inLabels, inErr := promutil.NewLabelsFromString(ds.In)
 			outLabels, outErr := promutil.NewLabelsFromString(ds.Out)
 			changedLabels := getChangedLabelNames(inLabels, outLabels)

-//line lib/promrelabel/debug.qtpl:170
+//line lib/promrelabel/debug.qtpl:168
 			qw422016.N().S(`{"inLabels":`)
-//line lib/promrelabel/debug.qtpl:172
+//line lib/promrelabel/debug.qtpl:170
 			qw422016.N().Q(labelsWithHighlight(inLabels, changedLabels, "#D15757"))
-//line lib/promrelabel/debug.qtpl:172
+//line lib/promrelabel/debug.qtpl:170
 			qw422016.N().S(`,"outLabels":`)
-//line lib/promrelabel/debug.qtpl:173
+//line lib/promrelabel/debug.qtpl:171
 			qw422016.N().Q(labelsWithHighlight(outLabels, changedLabels, "#4495e0"))
-//line lib/promrelabel/debug.qtpl:173
+//line lib/promrelabel/debug.qtpl:171
 			qw422016.N().S(`,"rule":`)
-//line lib/promrelabel/debug.qtpl:174
+//line lib/promrelabel/debug.qtpl:172
 			qw422016.N().Q(ds.Rule)
-//line lib/promrelabel/debug.qtpl:174
+//line lib/promrelabel/debug.qtpl:172
 			qw422016.N().S(`,"errors": {`)
-//line lib/promrelabel/debug.qtpl:176
+//line lib/promrelabel/debug.qtpl:174
 			if inErr != nil {
-//line lib/promrelabel/debug.qtpl:176
+//line lib/promrelabel/debug.qtpl:174
 				qw422016.N().S(`"inLabels":`)
-//line lib/promrelabel/debug.qtpl:177
+//line lib/promrelabel/debug.qtpl:175
 				qw422016.N().Q(`<span style="color: #D15757">` + inErr.Error() + `</span>`)
-//line lib/promrelabel/debug.qtpl:177
+//line lib/promrelabel/debug.qtpl:175
 				if outErr != nil {
-//line lib/promrelabel/debug.qtpl:177
+//line lib/promrelabel/debug.qtpl:175
 					qw422016.N().S(`,`)
-//line lib/promrelabel/debug.qtpl:177
+//line lib/promrelabel/debug.qtpl:175
 				}
-//line lib/promrelabel/debug.qtpl:178
+//line lib/promrelabel/debug.qtpl:176
 				hasError = true

-//line lib/promrelabel/debug.qtpl:179
+//line lib/promrelabel/debug.qtpl:177
 			} else {
-//line lib/promrelabel/debug.qtpl:180
+//line lib/promrelabel/debug.qtpl:178
 			}
-//line lib/promrelabel/debug.qtpl:181
+//line lib/promrelabel/debug.qtpl:179
 			if outErr != nil {
-//line lib/promrelabel/debug.qtpl:181
+//line lib/promrelabel/debug.qtpl:179
 				qw422016.N().S(`"outLabels":`)
-//line lib/promrelabel/debug.qtpl:182
+//line lib/promrelabel/debug.qtpl:180
 				qw422016.N().Q(`<span style="color: #D15757">` + outErr.Error() + `</span>`)
-//line lib/promrelabel/debug.qtpl:183
+//line lib/promrelabel/debug.qtpl:181
 				hasError = true

-//line lib/promrelabel/debug.qtpl:184
+//line lib/promrelabel/debug.qtpl:182
 			}
-//line lib/promrelabel/debug.qtpl:184
+//line lib/promrelabel/debug.qtpl:182
 			qw422016.N().S(`}}`)
-//line lib/promrelabel/debug.qtpl:187
+//line lib/promrelabel/debug.qtpl:185
 			if i != len(dss)-1 {
-//line lib/promrelabel/debug.qtpl:187
+//line lib/promrelabel/debug.qtpl:185
 				qw422016.N().S(`,`)
-//line lib/promrelabel/debug.qtpl:187
+//line lib/promrelabel/debug.qtpl:185
 			}
-//line lib/promrelabel/debug.qtpl:188
+//line lib/promrelabel/debug.qtpl:186
 		}
-//line lib/promrelabel/debug.qtpl:188
+//line lib/promrelabel/debug.qtpl:186
 		qw422016.N().S(`]`)
-//line lib/promrelabel/debug.qtpl:190
+//line lib/promrelabel/debug.qtpl:188
 		if len(dss) > 0 && !hasError {
-//line lib/promrelabel/debug.qtpl:190
+//line lib/promrelabel/debug.qtpl:188
 			qw422016.N().S(`,"originalLabels":`)
-//line lib/promrelabel/debug.qtpl:192
+//line lib/promrelabel/debug.qtpl:190
 			qw422016.N().Q(mustFormatLabels(dss[0].In))
-//line lib/promrelabel/debug.qtpl:192
+//line lib/promrelabel/debug.qtpl:190
 			qw422016.N().S(`,"resultingLabels":`)
-//line lib/promrelabel/debug.qtpl:193
+//line lib/promrelabel/debug.qtpl:191
 			qw422016.N().Q(mustFormatLabels(dss[len(dss)-1].Out))
-//line lib/promrelabel/debug.qtpl:194
+//line lib/promrelabel/debug.qtpl:192
 		}
-//line lib/promrelabel/debug.qtpl:195
+//line lib/promrelabel/debug.qtpl:193
 	}
-//line lib/promrelabel/debug.qtpl:195
+//line lib/promrelabel/debug.qtpl:193
 	qw422016.N().S(`}`)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 }

-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 func WriteRelabelDebugStepsJSON(qq422016 qtio422016.Writer, targetURL, targetID string, dss []DebugStep, metric, relabelConfigs string, err error) {
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	StreamRelabelDebugStepsJSON(qw422016, targetURL, targetID, dss, metric, relabelConfigs, err)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 }

-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 func RelabelDebugStepsJSON(targetURL, targetID string, dss []DebugStep, metric, relabelConfigs string, err error) string {
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	WriteRelabelDebugStepsJSON(qb422016, targetURL, targetID, dss, metric, relabelConfigs, err)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 	return qs422016
-//line lib/promrelabel/debug.qtpl:197
+//line lib/promrelabel/debug.qtpl:195
 }

-//line lib/promrelabel/debug.qtpl:199
+//line lib/promrelabel/debug.qtpl:197
 func streamlabelsWithHighlight(qw422016 *qt422016.Writer, labels *promutil.Labels, highlight map[string]struct{}, color string) {
-//line lib/promrelabel/debug.qtpl:201
+//line lib/promrelabel/debug.qtpl:199
 	labelsList := labels.GetLabels()
 	metricName := ""
 	for i, label := range labelsList {
@@ -501,153 +509,153 @@ func streamlabelsWithHighlight(qw422016 *qt422016.Writer, labels *promutil.Label
 		}
 	}

-//line lib/promrelabel/debug.qtpl:211
+//line lib/promrelabel/debug.qtpl:209
 	if metricName != "" {
-//line lib/promrelabel/debug.qtpl:212
+//line lib/promrelabel/debug.qtpl:210
 		if _, ok := highlight["__name__"]; ok {
+//line lib/promrelabel/debug.qtpl:210
+			qw422016.N().S(`<span style="font-weight:bold;color:`)
+//line lib/promrelabel/debug.qtpl:211
+			qw422016.E().S(color)
+//line lib/promrelabel/debug.qtpl:211
+			qw422016.N().S(`">`)
+//line lib/promrelabel/debug.qtpl:211
+			qw422016.E().S(metricName)
+//line lib/promrelabel/debug.qtpl:211
+			qw422016.N().S(`</span>`)
 //line lib/promrelabel/debug.qtpl:212
-			qw422016.N().S(`<span style="font-weight:bold;color:`)
-//line lib/promrelabel/debug.qtpl:213
-			qw422016.E().S(color)
-//line lib/promrelabel/debug.qtpl:213
-			qw422016.N().S(`">`)
+		} else {
 //line lib/promrelabel/debug.qtpl:213
 			qw422016.E().S(metricName)
-//line lib/promrelabel/debug.qtpl:213
-			qw422016.N().S(`</span>`)
 //line lib/promrelabel/debug.qtpl:214
-		} else {
+		}
 //line lib/promrelabel/debug.qtpl:215
-			qw422016.E().S(metricName)
-//line lib/promrelabel/debug.qtpl:216
-		}
-//line lib/promrelabel/debug.qtpl:217
 		if len(labelsList) == 0 {
-//line lib/promrelabel/debug.qtpl:217
+//line lib/promrelabel/debug.qtpl:215
 			return
-//line lib/promrelabel/debug.qtpl:217
+//line lib/promrelabel/debug.qtpl:215
 		}
-//line lib/promrelabel/debug.qtpl:218
+//line lib/promrelabel/debug.qtpl:216
 	}
-//line lib/promrelabel/debug.qtpl:218
+//line lib/promrelabel/debug.qtpl:216
 	qw422016.N().S(`{`)
-//line lib/promrelabel/debug.qtpl:220
+//line lib/promrelabel/debug.qtpl:218
 	for i, label := range labelsList {
-//line lib/promrelabel/debug.qtpl:221
+//line lib/promrelabel/debug.qtpl:219
 		if _, ok := highlight[label.Name]; ok {
-//line lib/promrelabel/debug.qtpl:221
+//line lib/promrelabel/debug.qtpl:219
 			qw422016.N().S(`<span style="font-weight:bold;color:`)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.E().S(color)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.N().S(`">`)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.E().S(label.Name)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.N().S(`=`)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.E().Q(label.Value)
-//line lib/promrelabel/debug.qtpl:222
+//line lib/promrelabel/debug.qtpl:220
 			qw422016.N().S(`</span>`)
-//line lib/promrelabel/debug.qtpl:223
+//line lib/promrelabel/debug.qtpl:221
 		} else {
-//line lib/promrelabel/debug.qtpl:224
+//line lib/promrelabel/debug.qtpl:222
 			qw422016.E().S(label.Name)
-//line lib/promrelabel/debug.qtpl:224
+//line lib/promrelabel/debug.qtpl:222
 			qw422016.N().S(`=`)
-//line lib/promrelabel/debug.qtpl:224
+//line lib/promrelabel/debug.qtpl:222
 			qw422016.E().Q(label.Value)
-//line lib/promrelabel/debug.qtpl:225
+//line lib/promrelabel/debug.qtpl:223
 		}
-//line lib/promrelabel/debug.qtpl:226
+//line lib/promrelabel/debug.qtpl:224
 		if i < len(labelsList)-1 {
-//line lib/promrelabel/debug.qtpl:226
+//line lib/promrelabel/debug.qtpl:224
 			qw422016.N().S(`,`)
-//line lib/promrelabel/debug.qtpl:226
+//line lib/promrelabel/debug.qtpl:224
 			qw422016.N().S(` `)
-//line lib/promrelabel/debug.qtpl:226
+//line lib/promrelabel/debug.qtpl:224
 		}
-//line lib/promrelabel/debug.qtpl:227
+//line lib/promrelabel/debug.qtpl:225
 	}
-//line lib/promrelabel/debug.qtpl:227
+//line lib/promrelabel/debug.qtpl:225
 	qw422016.N().S(`}`)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 }

-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 func writelabelsWithHighlight(qq422016 qtio422016.Writer, labels *promutil.Labels, highlight map[string]struct{}, color string) {
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	streamlabelsWithHighlight(qw422016, labels, highlight, color)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 }

-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 func labelsWithHighlight(labels *promutil.Labels, highlight map[string]struct{}, color string) string {
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	writelabelsWithHighlight(qb422016, labels, highlight, color)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 	return qs422016
-//line lib/promrelabel/debug.qtpl:229
+//line lib/promrelabel/debug.qtpl:227
 }

-//line lib/promrelabel/debug.qtpl:231
+//line lib/promrelabel/debug.qtpl:229
 func streammustFormatLabels(qw422016 *qt422016.Writer, s string) {
-//line lib/promrelabel/debug.qtpl:232
+//line lib/promrelabel/debug.qtpl:230
 	labels, err := promutil.NewLabelsFromString(s)

-//line lib/promrelabel/debug.qtpl:233
+//line lib/promrelabel/debug.qtpl:231
 	if err != nil {
-//line lib/promrelabel/debug.qtpl:233
+//line lib/promrelabel/debug.qtpl:231
 		qw422016.N().S(`<span style="color: red" title="error parsing labels:`)
-//line lib/promrelabel/debug.qtpl:234
+//line lib/promrelabel/debug.qtpl:232
 		qw422016.E().S(err.Error())
-//line lib/promrelabel/debug.qtpl:234
+//line lib/promrelabel/debug.qtpl:232
 		qw422016.N().S(`">`)
-//line lib/promrelabel/debug.qtpl:234
+//line lib/promrelabel/debug.qtpl:232
 		qw422016.E().S("error parsing labels: " + err.Error())
-//line lib/promrelabel/debug.qtpl:234
+//line lib/promrelabel/debug.qtpl:232
 		qw422016.N().S(`</span>`)
-//line lib/promrelabel/debug.qtpl:235
+//line lib/promrelabel/debug.qtpl:233
 	} else {
-//line lib/promrelabel/debug.qtpl:236
+//line lib/promrelabel/debug.qtpl:234
 		streamlabelsWithHighlight(qw422016, labels, nil, "")
-//line lib/promrelabel/debug.qtpl:237
+//line lib/promrelabel/debug.qtpl:235
 	}
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 }

-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 func writemustFormatLabels(qq422016 qtio422016.Writer, s string) {
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	qw422016 := qt422016.AcquireWriter(qq422016)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	streammustFormatLabels(qw422016, s)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	qt422016.ReleaseWriter(qw422016)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 }

-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 func mustFormatLabels(s string) string {
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	qb422016 := qt422016.AcquireByteBuffer()
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	writemustFormatLabels(qb422016, s)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	qs422016 := string(qb422016.B)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	qt422016.ReleaseByteBuffer(qb422016)
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 	return qs422016
-//line lib/promrelabel/debug.qtpl:238
+//line lib/promrelabel/debug.qtpl:236
 }
--- a/lib/promrelabel/if_expression.go
+++ b/lib/promrelabel/if_expression.go
@@ -50,6 +50,17 @@ func (ie *IfExpression) Parse(s string) error {
 	return nil
 }

+// ParseFromMetricExpr parses if from given MetricExpr
+func (ie *IfExpression) ParseFromMetricExpr(me *metricsql.MetricExpr) error {
+	var ieLocal ifExpression
+	if err := ieLocal.parseFromMetricExpr(me); err != nil {
+		return err
+	}
+
+	ie.ies = []*ifExpression{&ieLocal}
+	return nil
+}
+
 // UnmarshalJSON unmarshals ie from JSON data.
 func (ie *IfExpression) UnmarshalJSON(data []byte) error {
 	var v any
@@ -182,6 +193,16 @@ func (ie *ifExpression) Parse(s string) error {
 	return nil
 }

+func (ie *ifExpression) parseFromMetricExpr(me *metricsql.MetricExpr) error {
+	lfss, err := metricExprToLabelFilterss(me)
+	if err != nil {
+		return fmt.Errorf("cannot parse series selector: %w", err)
+	}
+	ie.s = string(me.AppendString(nil))
+	ie.lfss = lfss
+	return nil
+}
+
 // UnmarshalJSON unmarshals ie from JSON data.
 func (ie *ifExpression) UnmarshalJSON(data []byte) error {
 	var s string
--- a/lib/streamaggr/dedup.go
+++ b/lib/streamaggr/dedup.go
@@ -1,6 +1,7 @@
 package streamaggr

 import (
+	"fmt"
 	"sync"
 	"sync/atomic"
 	"unsafe"
@@ -17,9 +18,10 @@ import (
 const dedupAggrShardsCount = 128

 type dedupAggr struct {
-	shards        []dedupAggrShard
-	flushDuration *metrics.Histogram
-	flushTimeouts *metrics.Counter
+	shards         []dedupAggrShard
+	flushDuration  *metrics.Histogram
+	flushTimeouts  *metrics.Counter
+	droppedSamples *metrics.Counter
 }

 type dedupAggrShard struct {
@@ -47,10 +49,20 @@ type dedupAggrSample struct {
 	timestamp int64
 }

-func newDedupAggr() *dedupAggr {
-	return &dedupAggr{
-		shards: make([]dedupAggrShard, dedupAggrShardsCount),
-	}
+func newDedupAggr(ms *metrics.Set, metricLabels string) *dedupAggr {
+	var d dedupAggr
+	d.shards = make([]dedupAggrShard, dedupAggrShardsCount)
+	_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_size_bytes{%s}`, metricLabels), func() float64 {
+		return float64(d.sizeBytes())
+	})
+	_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_items_count{%s}`, metricLabels), func() float64 {
+		return float64(d.itemsCount())
+	})
+
+	d.flushDuration = ms.NewHistogram(fmt.Sprintf(`vm_streamaggr_dedup_flush_duration_seconds{%s}`, metricLabels))
+	d.flushTimeouts = ms.NewCounter(fmt.Sprintf(`vm_streamaggr_dedup_flush_timeouts_total{%s}`, metricLabels))
+	d.droppedSamples = ms.NewCounter(fmt.Sprintf(`vm_streamaggr_dedup_dropped_samples_total{%s}`, metricLabels))
+	return &d
 }

 func (da *dedupAggr) sizeBytes() uint64 {
@@ -87,7 +99,8 @@ func (da *dedupAggr) pushSamples(samples []pushSample, _ int64, isGreen bool) {
 		if len(shardSamples) == 0 {
 			continue
 		}
-		da.shards[i].pushSamples(shardSamples, isGreen)
+		deduplicatedSamples := da.shards[i].pushSamples(shardSamples, isGreen)
+		da.droppedSamples.Add(deduplicatedSamples)
 	}
 	putPerShardSamples(pss)
 }
@@ -167,8 +180,9 @@ func putPerShardSamples(pss *perShardSamples) {

 var perShardSamplesPool sync.Pool

-func (das *dedupAggrShard) pushSamples(samples []pushSample, isGreen bool) {
+func (das *dedupAggrShard) pushSamples(samples []pushSample, isGreen bool) int {
 	var state *dedupAggrState
+	var deduplicatedSamples int

 	if isGreen {
 		state = &das.green
@@ -198,8 +212,10 @@ func (das *dedupAggrShard) pushSamples(samples []pushSample, isGreen bool) {
 			continue
 		}
 		s.timestamp, s.value = deduplicateSamples(s.timestamp, sample.timestamp, s.value, sample.value)
+		deduplicatedSamples++
 	}
 	state.samplesBuf = samplesBuf
+	return deduplicatedSamples
 }

 // deduplicateSamples returns deduplicated timestamp and value results.
--- a/lib/streamaggr/dedup_test.go
+++ b/lib/streamaggr/dedup_test.go
@@ -7,11 +7,13 @@ import (
 	"testing"
 	"time"

+	"github.com/VictoriaMetrics/metrics"
+
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/decimal"
 )

 func TestDedupAggrSerial(t *testing.T) {
-	da := newDedupAggr()
+	da := newDedupAggr(metrics.NewSet(), "")

 	const seriesCount = 100_000
 	expectedSamplesMap := make(map[string]pushSample)
@@ -59,7 +61,7 @@ func TestDedupAggrSerial(t *testing.T) {
 func TestDedupAggrConcurrent(_ *testing.T) {
 	const concurrency = 5
 	const seriesCount = 10_000
-	da := newDedupAggr()
+	da := newDedupAggr(metrics.NewSet(), "")

 	var wg sync.WaitGroup
 	for range concurrency {
--- a/lib/streamaggr/dedup_timing_test.go
+++ b/lib/streamaggr/dedup_timing_test.go
@@ -5,6 +5,8 @@ import (
 	"sync/atomic"
 	"testing"

+	"github.com/VictoriaMetrics/metrics"
+
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompb"
 )

@@ -23,7 +25,7 @@ func benchmarkDedupAggr(b *testing.B, samplesPerPush int) {

 	const loops = 2
 	benchSamples := newBenchSamples(samplesPerPush)
-	da := newDedupAggr()
+	da := newDedupAggr(metrics.NewSet(), "")

 	b.ResetTimer()
 	b.ReportAllocs()
--- a/lib/streamaggr/deduplicator.go
+++ b/lib/streamaggr/deduplicator.go
@@ -44,7 +44,6 @@ type Deduplicator struct {
 // MustStop must be called on the returned deduplicator in order to free up occupied resources.
 func NewDeduplicator(pushFunc PushFunc, enableWindows bool, interval time.Duration, dropLabels []string, alias string) *Deduplicator {
 	d := &Deduplicator{
-		da:            newDedupAggr(),
 		dropLabels:    dropLabels,
 		interval:      interval,
 		enableWindows: enableWindows,
@@ -64,16 +63,7 @@ func NewDeduplicator(pushFunc PushFunc, enableWindows bool, interval time.Durati
 	ms := d.ms

 	metricLabels := fmt.Sprintf(`name="dedup",url=%q`, alias)
-
-	_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_size_bytes{%s}`, metricLabels), func() float64 {
-		return float64(d.da.sizeBytes())
-	})
-	_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_items_count{%s}`, metricLabels), func() float64 {
-		return float64(d.da.itemsCount())
-	})
-
-	d.da.flushDuration = ms.NewHistogram(fmt.Sprintf(`vm_streamaggr_dedup_flush_duration_seconds{%s}`, metricLabels))
-	d.da.flushTimeouts = ms.NewCounter(fmt.Sprintf(`vm_streamaggr_dedup_flush_timeouts_total{%s}`, metricLabels))
+	d.da = newDedupAggr(ms, metricLabels)

 	metrics.RegisterSet(ms)

@@ -120,6 +110,7 @@ func (d *Deduplicator) Push(tss []prompb.TimeSeries) {
 		key := bytesutil.ToUnsafeString(buf[bufLen:])
 		for _, s := range ts.Samples {
 			if d.enableWindows && minDeadline > s.Timestamp {
+				d.da.droppedSamples.Inc()
 				continue
 			} else if d.enableWindows && s.Timestamp <= cs.maxDeadline == cs.isGreen {
 				ctx.green = append(ctx.green, pushSample{
--- a/lib/streamaggr/increase.go
+++ b/lib/streamaggr/increase.go
@@ -31,12 +31,16 @@ type increaseAggrValue struct {
 }

 func (av *increaseAggrValue) pushSample(c aggrConfig, sample *pushSample, key string, deleteDeadline int64) {
+	if av.total == nil {
+		av.total = new(float64)
+	}
 	ac := c.(*increaseAggrConfig)
 	currentTime := fasttime.UnixTimestamp()
 	keepFirstSample := ac.keepFirstSample && currentTime >= ac.ignoreFirstSampleDeadline
 	lv, ok := av.shared[key]
-	if av.total == nil {
-		av.total = new(float64)
+	// The last value is stale, reset it.
+	if ok && lv.deleteDeadline < int64(currentTime)*1000 {
+		ok = false
 	}
 	if ok {
 		if sample.timestamp < lv.timestamp {
--- a/lib/streamaggr/rate.go
+++ b/lib/streamaggr/rate.go
@@ -7,6 +7,7 @@ import (
 	"github.com/VictoriaMetrics/metrics"

 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
 )

 var rateAggrSharedValuePool sync.Pool
@@ -99,6 +100,12 @@ func (av *rateAggrValue) pushSample(c aggrConfig, sample *pushSample, key string
 	ac := c.(*rateAggrConfig)
 	var state *rateAggrStateValue
 	sv, ok := av.shared[key]
+	// The last value is stale, reset it.
+	if ok && sv.deleteDeadline < int64(fasttime.UnixTimestamp())*1000 {
+		delete(av.shared, key)
+		putRateAggrSharedValue(sv)
+		ok = false
+	}
 	if ok {
 		state = sv.getState(av.isGreen)
 		if sample.timestamp < state.timestamp {
--- a/lib/streamaggr/streamaggr.go
+++ b/lib/streamaggr/streamaggr.go
@@ -43,6 +43,7 @@ var supportedOutputs = []string{
 	"stddev",
 	"stdvar",
 	"sum_samples",
+	"sum_samples_total",
 	"total",
 	"total_prometheus",
 	"unique_samples",
@@ -172,12 +173,12 @@ type Config struct {
 	DedupInterval string `yaml:"dedup_interval,omitempty"`

 	// Staleness interval is interval after which the series state will be reset if no samples have been sent during it.
-	// The parameter is only relevant for outputs: total, total_prometheus, increase, increase_prometheus and histogram_bucket.
+	// The parameter is only relevant for outputs: total, total_prometheus, increase, increase_prometheus, rate_avg and rate_sum.
 	StalenessInterval string `yaml:"staleness_interval,omitempty"`

 	// IgnoreFirstSampleInterval specifies the interval after which the agent begins sending samples.
 	// By default, it is set to the staleness interval, and it helps reduce the initial sample load after an agent restart.
-	// This parameter is relevant only for the following outputs: total, total_prometheus, increase, increase_prometheus, and histogram_bucket.
+	// This parameter is relevant only for the following outputs: total, total_prometheus, increase and increase_prometheus.
 	IgnoreFirstSampleInterval string `yaml:"ignore_first_sample_interval,omitempty"`

 	// Outputs is a list of output aggregate functions to produce.
@@ -501,8 +502,9 @@ func newAggregator(cfg *Config, path string, pushFunc PushFunc, ms *metrics.Set,
 		return nil, fmt.Errorf("interval=%s must be a multiple of dedup_interval=%s", interval, dedupInterval)
 	}

-	// check cfg.StalenessInterval
-	stalenessInterval := interval * 2
+	// set the default staleness interval as the aggregation interval, to be consistent with query lookbehind window in metricsQL,
+	// see https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11102
+	stalenessInterval := interval
 	if cfg.StalenessInterval != "" {
 		stalenessInterval, err = time.ParseDuration(cfg.StalenessInterval)
 		if err != nil {
@@ -668,18 +670,7 @@ func newAggregator(cfg *Config, path string, pushFunc PushFunc, ms *metrics.Set,
 	}

 	if dedupInterval > 0 {
-		a.da = newDedupAggr()
-		a.da.flushTimeouts = ms.NewCounter(fmt.Sprintf(`vm_streamaggr_dedup_flush_timeouts_total{%s}`, metricLabels))
-		a.da.flushDuration = ms.NewHistogram(fmt.Sprintf(`vm_streamaggr_dedup_flush_duration_seconds{%s}`, metricLabels))
-
-		_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_size_bytes{%s}`, metricLabels), func() float64 {
-			n := a.da.sizeBytes()
-			return float64(n)
-		})
-		_ = ms.NewGauge(fmt.Sprintf(`vm_streamaggr_dedup_state_items_count{%s}`, metricLabels), func() float64 {
-			n := a.da.itemsCount()
-			return float64(n)
-		})
+		a.da = newDedupAggr(ms, metricLabels)
 	}

 	alignFlushToInterval := !opts.NoAlignFlushToInterval
@@ -780,7 +771,9 @@ func newOutputConfig(ms *metrics.Set, metricLabels, output string, outputsSeen m
 	case "stdvar":
 		return newStdvarAggrConfig(), nil
 	case "sum_samples":
-		return newSumSamplesAggrConfig(), nil
+		return newSumSamplesAggrConfig(true), nil
+	case "sum_samples_total":
+		return newSumSamplesAggrConfig(false), nil
 	case "total":
 		return newTotalAggrConfig(ms, metricLabels, ignoreFirstSampleIntervalSecs, true), nil
 	case "total_prometheus":
--- a/lib/streamaggr/streamaggr_synctest_test.go
+++ b/lib/streamaggr/streamaggr_synctest_test.go
@@ -1,3 +1,5 @@
+//go:build synctest
+
 package streamaggr

 import (
@@ -475,26 +477,125 @@ foo:1m_increase_prometheus{baz="qwe"} 15
  outputs: [increase_prometheus]
 `, "11111111")

-	// multiple aggregate configs
+	// increase, increase_prometheus, total, total_prometheus outputs with different staleness intervals
+	f([]string{`
+foo 5
+bar 200
+`, `
+foo 10
+bar 201
+`, ``, `
+foo 7
+bar 205
+`}, time.Minute, `bar:1m_increase 200
+bar:1m_increase 1
+bar:1m_increase 205
+bar:1m_increase_prometheus 0
+bar:1m_increase_prometheus 1
+bar:1m_increase_prometheus 0
+bar:1m_total 200
+bar:1m_total 201
+bar:1m_total 205
+bar:1m_total_prometheus 0
+bar:1m_total_prometheus 1
+bar:1m_total_prometheus 0
+bar:1m_without_non_existing_label_increase 0
+bar:1m_without_non_existing_label_increase 1
+bar:1m_without_non_existing_label_increase 4
+bar:1m_without_non_existing_label_increase_prometheus 0
+bar:1m_without_non_existing_label_increase_prometheus 1
+bar:1m_without_non_existing_label_increase_prometheus 4
+bar:1m_without_non_existing_label_total 0
+bar:1m_without_non_existing_label_total 1
+bar:1m_without_non_existing_label_total 1
+bar:1m_without_non_existing_label_total 5
+bar:1m_without_non_existing_label_total_prometheus 0
+bar:1m_without_non_existing_label_total_prometheus 1
+bar:1m_without_non_existing_label_total_prometheus 1
+bar:1m_without_non_existing_label_total_prometheus 5
+foo:1m_increase 5
+foo:1m_increase 5
+foo:1m_increase 7
+foo:1m_increase_prometheus 0
+foo:1m_increase_prometheus 5
+foo:1m_increase_prometheus 0
+foo:1m_total 5
+foo:1m_total 10
+foo:1m_total 7
+foo:1m_total_prometheus 0
+foo:1m_total_prometheus 5
+foo:1m_total_prometheus 0
+foo:1m_without_non_existing_label_increase 0
+foo:1m_without_non_existing_label_increase 5
+foo:1m_without_non_existing_label_increase 7
+foo:1m_without_non_existing_label_increase_prometheus 0
+foo:1m_without_non_existing_label_increase_prometheus 5
+foo:1m_without_non_existing_label_increase_prometheus 7
+foo:1m_without_non_existing_label_total 0
+foo:1m_without_non_existing_label_total 5
+foo:1m_without_non_existing_label_total 5
+foo:1m_without_non_existing_label_total 12
+foo:1m_without_non_existing_label_total_prometheus 0
+foo:1m_without_non_existing_label_total_prometheus 5
+foo:1m_without_non_existing_label_total_prometheus 5
+foo:1m_without_non_existing_label_total_prometheus 12
+`, `
+- interval: 1m
+  ignore_first_sample_interval: 0s
+  outputs: [increase, increase_prometheus, total, total_prometheus]
+- interval: 1m
+  staleness_interval: 2m
+  without: [non_existing_label]
+  outputs: [increase, increase_prometheus, total, total_prometheus]
+`, "111111")
+
+	// sum_sample and sum_samples_total outputs with different staleness intervals
 	f([]string{`
 foo 1
+foo 2 1
 foo{bar="baz"} 2
-foo 3.3
-`, ``, ``, ``, ``}, time.Minute, `foo:1m_count_series 1
-foo:1m_count_series{bar="baz"} 1
-foo:1m_sum_samples 0
-foo:1m_sum_samples 4.3
-foo:1m_sum_samples{bar="baz"} 0
+`, `
+foo 4
+`, ``, ``, `
+foo 6
+`, ``, ``}, time.Minute, `foo:1m_sum_samples 3
+foo:1m_sum_samples 4
+foo:1m_sum_samples 6
+foo:1m_sum_samples_total 3
+foo:1m_sum_samples_total 7
+foo:1m_sum_samples_total 6
+foo:1m_sum_samples_total{bar="baz"} 2
 foo:1m_sum_samples{bar="baz"} 2
-foo:5m_by_bar_sum_samples 4.3
+foo:1m_without_non-existing-label_sum_samples 3
+foo:1m_without_non-existing-label_sum_samples 4
+foo:1m_without_non-existing-label_sum_samples 0
+foo:1m_without_non-existing-label_sum_samples 6
+foo:1m_without_non-existing-label_sum_samples 0
+foo:1m_without_non-existing-label_sum_samples_total 3
+foo:1m_without_non-existing-label_sum_samples_total 7
+foo:1m_without_non-existing-label_sum_samples_total 7
+foo:1m_without_non-existing-label_sum_samples_total 6
+foo:1m_without_non-existing-label_sum_samples_total 6
+foo:1m_without_non-existing-label_sum_samples_total{bar="baz"} 2
+foo:1m_without_non-existing-label_sum_samples_total{bar="baz"} 2
+foo:1m_without_non-existing-label_sum_samples{bar="baz"} 2
+foo:1m_without_non-existing-label_sum_samples{bar="baz"} 0
+foo:5m_by_bar_sum_samples 13
+foo:5m_by_bar_sum_samples_total 13
+foo:5m_by_bar_sum_samples_total{bar="baz"} 2
 foo:5m_by_bar_sum_samples{bar="baz"} 2
 `, `
 - interval: 1m
-  outputs: [count_series, sum_samples]
+  staleness_interval: 1m
+  outputs: [ sum_samples, sum_samples_total]
+- interval: 1m
+  staleness_interval: 2m
+  without: [non-existing-label]
+  outputs: [ sum_samples, sum_samples_total]
 - interval: 5m
  by: [bar]
-  outputs: [sum_samples]
-`, "111")
+  outputs: [sum_samples, sum_samples_total]
+`, "11111")

 	// min and max outputs
 	f([]string{`
@@ -688,30 +789,39 @@ foo:1m_by_cde_rate_sum{cde="1"} 0.125
  outputs: [rate_sum, rate_avg]
 `, "11111")

-	// test rate_sum and rate_avg, when two aggregation intervals are empty
+	// test rate_sum and rate_avg with different staleness intervals
 	f([]string{`
 foo{abc="123", cde="1"} 1
 foo{abc="123", cde="1"} 2 1
-foo{abc="456", cde="1"} 7
-foo{abc="456", cde="1"} 8 1
-foo{abc="777", cde="1"} 8
-foo{abc="777", cde="1"} 9 1
-`, ``, ``, `
-foo{abc="123", cde="1"} 19
-foo{abc="123", cde="1"} 20 1
-foo{abc="456", cde="1"} 26
-foo{abc="456", cde="1"} 27 1
-foo{abc="777", cde="1"} 27
-foo{abc="777", cde="1"} 28 1
+foo{abc="456", cde="1"} 3
+foo{abc="456", cde="1"} 4 1
+foo{abc="777", cde="1"} 5
+foo{abc="777", cde="1"} 6 1
+`, ``, `
+foo{abc="123", cde="1"} 121
+foo{abc="123", cde="1"} 122 1
+foo{abc="456", cde="1"} 123
+foo{abc="456", cde="1"} 124 1
+foo{abc="777", cde="1"} 125
+foo{abc="777", cde="1"} 126 1
 `}, time.Minute, `foo:1m_by_cde_rate_avg{cde="1"} 1
 foo:1m_by_cde_rate_avg{cde="1"} 1
 foo:1m_by_cde_rate_sum{cde="1"} 3
 foo:1m_by_cde_rate_sum{cde="1"} 3
+foo:1m_without_abc_rate_avg{cde="1"} 1
+foo:1m_without_abc_rate_avg{cde="1"} 1
+foo:1m_without_abc_rate_sum{cde="1"} 3
+foo:1m_without_abc_rate_sum{cde="1"} 3
 `, `            
 - interval: 1m
  by: [cde]
  outputs: [rate_sum, rate_avg]
  enable_windows: true
+- interval: 1m
+  staleness_interval: 2m
+  without: [abc]
+  outputs: [rate_sum, rate_avg]
+  enable_windows: true
 `, "111111111111")

 	// rate_sum and rate_avg with duplicated events
--- a/lib/streamaggr/streamaggr_test.go
+++ b/lib/streamaggr/streamaggr_test.go
@@ -252,11 +252,15 @@ func TestAggregatorsEqual(t *testing.T) {
 }

 func timeSeriessToString(tss []prompb.TimeSeries) string {
-	a := make([]string, len(tss))
-	for i, ts := range tss {
+	sorted := make([]prompb.TimeSeries, len(tss))
+	copy(sorted, tss)
+	sort.SliceStable(sorted, func(i, j int) bool {
+		return promrelabel.LabelsToString(sorted[i].Labels) < promrelabel.LabelsToString(sorted[j].Labels)
+	})
+	a := make([]string, len(sorted))
+	for i, ts := range sorted {
 		a[i] = timeSeriesToString(ts)
 	}
-	sort.Strings(a)
 	return strings.Join(a, "")
 }

--- a/lib/streamaggr/streamaggr_timing_test.go
+++ b/lib/streamaggr/streamaggr_timing_test.go
@@ -27,6 +27,7 @@ var benchOutputs = []string{
 	"stddev",
 	"stdvar",
 	"sum_samples",
+	"sum_samples_total",
 	"total",
 	"total_prometheus",
 	"unique_samples",
--- a/lib/streamaggr/sum_samples.go
+++ b/lib/streamaggr/sum_samples.go
@@ -1,27 +1,44 @@
 package streamaggr

+import (
+	"math"
+)
+
 type sumSamplesAggrValue struct {
 	sum float64
 }

 func (av *sumSamplesAggrValue) pushSample(_ aggrConfig, sample *pushSample, _ string, _ int64) {
+	if math.Abs(av.sum) >= (1 << 53) {
+		// It is time to reset the entry, since it starts losing float64 precision
+		av.sum = 0
+	}
 	av.sum += sample.value
 }

-func (av *sumSamplesAggrValue) flush(_ aggrConfig, ctx *flushCtx, key string, _ bool) {
-	ctx.appendSeries(key, "sum_samples", av.sum)
-	av.sum = 0
+func (av *sumSamplesAggrValue) flush(c aggrConfig, ctx *flushCtx, key string, _ bool) {
+	ac := c.(*sumSamplesAggrConfig)
+	if ac.resetTotalOnFlush {
+		ctx.appendSeries(key, "sum_samples", av.sum)
+		av.sum = 0
+		return
+	}
+	ctx.appendSeries(key, "sum_samples_total", av.sum)
 }

 func (*sumSamplesAggrValue) state() any {
 	return nil
 }

-func newSumSamplesAggrConfig() aggrConfig {
-	return &sumSamplesAggrConfig{}
+func newSumSamplesAggrConfig(resetTotalOnFlush bool) aggrConfig {
+	return &sumSamplesAggrConfig{
+		resetTotalOnFlush: resetTotalOnFlush,
+	}
 }

-type sumSamplesAggrConfig struct{}
+type sumSamplesAggrConfig struct {
+	resetTotalOnFlush bool
+}

 func (*sumSamplesAggrConfig) getValue(_ any) aggrValue {
 	return &sumSamplesAggrValue{}
--- a/lib/streamaggr/total.go
+++ b/lib/streamaggr/total.go
@@ -31,7 +31,11 @@ func (av *totalAggrValue) pushSample(c aggrConfig, sample *pushSample, key strin
 	currentTime := fasttime.UnixTimestamp()
 	keepFirstSample := ac.keepFirstSample && currentTime >= ac.ignoreFirstSampleDeadline
 	lv, ok := av.shared.lastValues[key]
-	if ok || keepFirstSample {
+	// The last value is stale, reset it.
+	if ok && lv.deleteDeadline < int64(currentTime)*1000 {
+		ok = false
+	}
+	if ok {
 		if sample.timestamp < lv.timestamp {
 			// Skip out of order sample
 			return
@@ -43,6 +47,8 @@ func (av *totalAggrValue) pushSample(c aggrConfig, sample *pushSample, key strin
 			av.total += sample.value
 			ac.counterResetsTotal.Inc()
 		}
+	} else if keepFirstSample {
+		av.total += sample.value
 	}
 	lv.value = sample.value
 	lv.timestamp = sample.timestamp
--- a/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go
+++ b/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go
@@ -7,6 +7,7 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"path"
 	"strconv"
 	"strings"
 	"sync/atomic"
@@ -404,16 +405,113 @@ func readPSITotals(cgroupPath, statsName string) (uint64, uint64, error) {
 }

 func getCgroupV2Path() string {
-	data, err := ioutil.ReadFile("/proc/self/cgroup")
+	cgroupData, err := os.ReadFile("/proc/self/cgroup")
 	if err != nil {
 		return ""
 	}
-	tmp := strings.SplitN(string(data), "::", 2)
-	if len(tmp) != 2 {
+	// Read /proc/self/mountinfo with a timeout. Generating the mountinfo contents
+	// can block in the kernel when a backing filesystem (e.g. a hung NFS or FUSE
+	// mount) is unresponsive. Since this runs at program init via psiMetricsStart,
+	// a blocking read would hang startup, so fall back to disabling PSI metrics instead.
+	mountinfoData, _ := readFileWithTimeout("/proc/self/mountinfo", time.Second)
+	return getCgroupV2PathInternal(string(cgroupData), mountinfoData)
+}
+
+// readFileWithTimeout reads the file at path, returning ("", false) if the read
+// doesn't complete within timeout.
+//
+// A timed-out read leaks the reading goroutine until the read eventually unblocks
+// (if ever). This is an acceptable safeguard against a read of a pseudo-file such
+// as /proc/self/mountinfo hanging on an unresponsive mount.
+func readFileWithTimeout(path string, timeout time.Duration) (string, bool) {
+	type result struct {
+		data []byte
+		err  error
+	}
+	// The channel is buffered so the goroutine can always send and exit,
+	// even after this function has returned on timeout.
+	ch := make(chan result, 1)
+	go func() {
+		data, err := os.ReadFile(path)
+		ch <- result{data: data, err: err}
+	}()
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+	select {
+	case r := <-ch:
+		if r.err != nil {
+			return "", false
+		}
+		return string(r.data), true
+	case <-timer.C:
+		return "", false
+	}
+}
+
+func getCgroupV2PathInternal(cgroupData, mountinfoData string) string {
+	rel := getCgroupV2RelativePath(cgroupData)
+	if rel == "" {
+		// The process doesn't run under cgroup v2.
 		return ""
 	}
-	path := "/sys/fs/cgroup" + strings.TrimSpace(tmp[1])

-	// Drop trailing slash if it exsits. This prevents from '//' in the constructed paths by the caller.
-	return strings.TrimSuffix(path, "/")
+	// Determine the actual cgroup v2 mountpoint instead of assuming /sys/fs/cgroup.
+	// On systems with a hybrid cgroup hierarchy the unified cgroup v2 is mounted
+	// at a different location such as /sys/fs/cgroup/unified.
+	// See https://github.com/VictoriaMetrics/metrics/issues/127
+	mountpoint := getCgroupV2Mountpoint(mountinfoData)
+	if mountpoint == "" {
+		// fallback to assumed path
+		mountpoint = "/sys/fs/cgroup"
+	}
+	cgroupPath := path.Join(mountpoint, rel)
+	// Drop trailing slash if it exists. This prevents from '//' in the constructed paths by the caller.
+	return strings.TrimSuffix(cgroupPath, "/")
+}
+
+// getCgroupV2RelativePath returns the cgroup v2 path of the process relative to
+// the cgroup v2 mountpoint, or an empty string if the process doesn't run under cgroup v2.
+//
+// The cgroup v2 entry in /proc/self/cgroup has an empty controllers field, e.g. "0::/the/path".
+// See https://man7.org/linux/man-pages/man7/cgroups.7.html
+func getCgroupV2RelativePath(cgroupData string) string {
+	for _, line := range strings.Split(cgroupData, "\n") {
+		// Each line has the form "hierarchy-ID:controller-list:cgroup-path".
+		// The cgroup v2 line has an empty hierarchy-ID and controller-list, i.e. it starts with "0::".
+		tmp := strings.SplitN(line, "::", 2)
+		if len(tmp) == 2 && strings.HasPrefix(line, "0::") {
+			return strings.TrimSpace(tmp[1])
+		}
+	}
+	return ""
+}
+
+// getCgroupV2Mountpoint returns the mountpoint of the cgroup v2 (unified) hierarchy
+// parsed from the contents of /proc/self/mountinfo, or an empty string if cgroup v2 isn't mounted.
+func getCgroupV2Mountpoint(mountinfoData string) string {
+	for _, line := range strings.Split(mountinfoData, "\n") {
+		if !strings.Contains(line, "cgroup2") {
+			// fast path
+			continue
+		}
+		// mountinfo lines have the form:
+		//   36 35 98:0 / /sys/fs/cgroup/unified rw,... - cgroup2 cgroup2 rw,...
+		// The optional fields preceding the filesystem type are terminated by " - ".
+		// See https://man7.org/linux/man-pages/man5/proc_pid_mountinfo.5.html
+		tmp := strings.SplitN(line, " - ", 2)
+		if len(tmp) != 2 {
+			continue
+		}
+		after := strings.Fields(tmp[1])
+		if len(after) < 1 || after[0] != "cgroup2" {
+			continue
+		}
+		before := strings.Fields(tmp[0])
+		if len(before) < 5 {
+			continue
+		}
+		// before[4] is the mount point.
+		return before[4]
+	}
+	return ""
 }
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -143,7 +143,7 @@ github.com/VictoriaMetrics/easyproto
 # github.com/VictoriaMetrics/fastcache v1.13.3
 ## explicit; go 1.24.0
 github.com/VictoriaMetrics/fastcache
-# github.com/VictoriaMetrics/metrics v1.43.2
+# github.com/VictoriaMetrics/metrics v1.44.0
 ## explicit; go 1.24.0
 github.com/VictoriaMetrics/metrics
 # github.com/VictoriaMetrics/metricsql v0.87.1
Author	SHA1	Message	Date
f41gh7	9356c2111a	docs: update version to v1.146.0 Signed-off-by: f41gh7 <nik@victoriametrics.com>	2026-06-19 14:18:31 +02:00
f41gh7	45f0b87150	app/vmselect: run make vmui-update Signed-off-by: f41gh7 <nik@victoriametrics.com>	2026-06-19 14:16:01 +02:00
Nikolay	8480f6b43e	app/vmagent: prioritise recently ingested data to the queue This commit adds a new flag remoteWrite.inmemoryQueues, which starts a dedicated set of workers for processing only in-memory part of vmagent persistentqueue. It should help to mitigate an issue when stale data at file-based queue prevents from ingestion recent data. There is a downside - in case of remote storage is not reachable, it's possible to get only a part of data ingested and other part queued into file-based queue. But it should be acceptable, because there is no strong guarantees for the data ingestion order. Fixes https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8833	2026-06-19 13:47:49 +02:00
f41gh7	61668f0672	changelog: sort entries Signed-off-by: f41gh7 <nik@victoriametrics.com>	2026-06-19 13:23:01 +02:00
f41gh7	d1ebbf573c	vendor: update metrics to v1.44.0 fixes https://github.com/VictoriaMetrics/metrics/issues/127	2026-06-19 13:16:31 +02:00
Hui Wang	16422b2d14	lib/streamagrr: add `sum_sample_total` output function Add `sum_sample_total` aggregation function to sums input delta values into a cumulative [counter](https://docs.victoriametrics.com/victoriametrics/keyconcepts/index.html#counter) and outputs the result at the given `interval`. `sum_samples_total` makes sense only for aggregating delta values from clients such as [StatsD counter](https://github.com/statsd/statsd/blob/master/docs/metric_types.md#counting). >Note: The aggregator will forget the cumulative counter if it has not seen input samples for `staleness_interval`(set to `interval` by default) per output result, so the output counter will start from `0` the next time it sees the input again. Increase the `staleness_interval` option if you want to extend the window to tolerate bigger gaps. Fixes: https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11002 https://github.com/VictoriaMetrics/VictoriaMetrics/issues/4843.	2026-06-19 13:11:36 +02:00
Roman Khavronenko	0f1ca87611	app/vmselect: skip caching empty responses for tenants discovery Before, empty tenant response was cached for 5min. Making all subsequent read queries to return empty response, even if data for the tenants was properly ingested. With this change empty response won't be cached. This change is important for integration tests, where reads and writes are performed one after another. Related PR https://github.com/VictoriaMetrics/VictoriaMetrics/pull/10982/	2026-06-19 10:04:58 +02:00
Alexander Frolov	0dd2b2cee6	app/vmselect: fix tenant filtering with long tenant regexp When tenant filter is a long regexp, its content can be replaced with `...`, causing tenants to be matched incorrectly. `applyFiltersToTenants` converts tag filters using `tagFiltersToString` `c497c8c2e9/app/vmselect/netstorage/tenant_filters.go (L106-L112)` Which uses human-readable representation of `TagFilter` `c497c8c2e9/lib/storage/search.go (L390-L397)` This way I can see results from unexpected tenants. See the test, which fails with ``` --- FAIL: TestApplyFiltersToTenants (0.00s) tenant_filters_test.go:18: unexpected tenants result; got [{100 0} {116 0} {1239 0}]; want [{100 0} {108 0} {116 0}] ``` --------- Related PR https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11096	2026-06-19 09:55:04 +02:00
Hui Wang	7caec5fcb4	lib/streamaggr: expose `vm_streamaggr_dedup_dropped_samples_total` to track deduplicated samples Currently, there is no way to determine how many samples are dropped during https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication, and deduplication can also drop out-of-order samples if configured, without being captured by vm_streamaggr_ignored_samples_total{reason="too_old"}. Related PR https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11069	2026-06-19 09:49:09 +02:00
Alexander Frolov	612f8ac8d6	app/vmselect: escape metadata MetricFamilyName Follow-up for: - https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11115 - https://github.com/VictoriaMetrics/VictoriaMetrics/pull/11120 - https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11128 Under normal circumstances this is not necessary to escape `MetricFamilyName`. I have noticed a few cases when vmselect produced malformed JSON response due to corrupted `MetricFamilyName` value. On the other hand, there are pros in keeping it as is — there is a better chance that the issue would be noticed and reported.	2026-06-19 09:37:49 +02:00
Immanuel Tikhonov	6aa31a09d7	app/vmctl: fix typo in missing-field influx error `vmctl influx` returns `response doesn't contain filed "value"` when the response misses the requested field column. Related to https://github.com/VictoriaMetrics/VictoriaMetrics/issues/10892	2026-06-19 09:36:25 +02:00
Hui Wang	b6e6a50e29	lib/streamaggr: reduce the default staleness interval Reduce the default staleness_interval from `2rule_interval` to `1rule_interval`, so the lookbehind range in stream aggregation is more consistent with metricsQL query. Also add a stale sample check during sample push in case flush hasn't cleaned it in time. Fixes fixes https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11102	2026-06-19 09:35:22 +02:00
Nikolay	a6d48b6af3	lib/storage: fixes typo at vm_retention_filters_partitions_scheduled_rows Fixes https://github.com/VictoriaMetrics/VictoriaMetrics/issues/11138	2026-06-19 09:09:38 +02:00
				`@@ -1 +0,0 @@`
				var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(e&&(t=e(e=0)),t),s=(e,t)=>()=>(t\|\|e((t={exports:{}}).exports,t),t.exports),c=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n\|\|t(r,Symbol.toStringTag,{value:`Module`}),r},l=(e,i,o,s)=>{if(i&&typeof i==`object`\|\|typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))\|\|s.enumerable});return e},u=(n,r,a)=>(a=n==null?{}:e(i(n)),l(r\|\|!n\|\|!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),d=e=>a.call(e,`module.exports`)?e[`module.exports`]:l(t({},`__esModule`,{value:!0}),e);export{u as a,d as i,o as n,c as r,s as t};
				`@@ -0,0 +1 @@`
				var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(e&&(t=e(e=0)),t),s=(e,t)=>()=>(t\|\|(e((t={exports:{}}).exports,t),e=null),t.exports),c=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n\|\|t(r,Symbol.toStringTag,{value:`Module`}),r},l=(e,i,o,s)=>{if(i&&typeof i==`object`\|\|typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))\|\|s.enumerable});return e},u=(n,r,a)=>(a=n==null?{}:e(i(n)),l(r\|\|!n\|\|!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),d=e=>a.call(e,`module.exports`)?e[`module.exports`]:l(t({},`__esModule`,{value:!0}),e);export{u as a,d as i,o as n,c as r,s as t};