app/vmui: add command to run VictoriaLogs with playground env (#8910)

### Describe Your Changes

Added npm command `npm run start:logs:playground` to run VictoriaLogs UI
with playground env.

### Checklist

The following checks are **mandatory**:

- [ ] My change adheres to [VictoriaMetrics contributing
guidelines](https://docs.victoriametrics.com/victoriametrics/contributing/).

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -5,10 +5,10 @@ body:
   - type: markdown
     attributes:
       value: |
-        Before filling a bug report it would be great to [upgrade](https://docs.victoriametrics.com/#how-to-upgrade) 
+        Before filling a bug report it would be great to [upgrade](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-upgrade) 
         to [the latest available release](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/latest)
         and verify whether the bug is reproducible there.
-        It's also recommended to read the [troubleshooting docs](https://docs.victoriametrics.com/troubleshooting/) first.
+        It's also recommended to read the [troubleshooting docs](https://docs.victoriametrics.com/victoriametrics/troubleshooting/) first.
   - type: textarea
     id: describe-the-bug
     attributes:
@@ -64,8 +64,8 @@ body:
           * [Grafana dashboard for VictoriaMetrics cluster](https://grafana.com/grafana/dashboards/11176)
         
         See how to setup monitoring here:
-          * [monitoring for single-node VictoriaMetrics](https://docs.victoriametrics.com/#monitoring)
-          * [monitoring for VictoriaMetrics cluster](https://docs.victoriametrics.com/cluster-victoriametrics/#monitoring)
+          * [monitoring for single-node VictoriaMetrics](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#monitoring)
+          * [monitoring for VictoriaMetrics cluster](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/#monitoring)
     validations:
       required: false
   - type: textarea

.github/ISSUE_TEMPLATE/question.yml

@@ -24,9 +24,9 @@ body:
       label: Troubleshooting docs
       description: I am familiar with the following troubleshooting docs
       options:
-        - label: General - https://docs.victoriametrics.com/troubleshooting/
+        - label: General - https://docs.victoriametrics.com/victoriametrics/troubleshooting/
           required: false
-        - label: vmagent - https://docs.victoriametrics.com/vmagent/#troubleshooting
+        - label: vmagent - https://docs.victoriametrics.com/victoriametrics/vmagent/#troubleshooting
           required: false
-        - label: vmalert - https://docs.victoriametrics.com/vmalert/#troubleshooting
+        - label: vmalert - https://docs.victoriametrics.com/victoriametrics/vmalert/#troubleshooting
           required: false

.github/pull_request_template.md

@@ -6,4 +6,4 @@ Please provide a brief description of the changes you made. Be as specific as po
 
 The following checks are **mandatory**:
 
-- [ ] My change adheres to [VictoriaMetrics contributing guidelines](https://docs.victoriametrics.com/contributing/).
+- [ ] My change adheres to [VictoriaMetrics contributing guidelines](https://docs.victoriametrics.com/victoriametrics/contributing/).

CONTRIBUTING.md

@@ -1 +1 @@
-The document has been moved [here](https://docs.victoriametrics.com/contributing/).
+The document has been moved [here](https://docs.victoriametrics.com/victoriametrics/contributing/).

Makefile

@@ -541,7 +541,7 @@ benchmark-pure:
 vendor-update:
 	go get -u ./lib/...
 	go get -u ./app/...
-	go mod tidy -compat=1.23
+	go mod tidy -compat=1.24
 	go mod vendor
 
 app-local:

README.md

@@ -11,9 +11,9 @@
 ![Reddit](https://img.shields.io/reddit/subreddit-subscribers/VictoriaMetrics?style=flat&label=Join&labelColor=red&logoColor=white&logo=reddit&link=https%3A%2F%2Fwww.reddit.com%2Fr%2FVictoriaMetrics)
 
 <picture>
-  <source srcset="docs/logo_white.webp" media="(prefers-color-scheme: dark)">
-  <source srcset="docs/logo.webp" media="(prefers-color-scheme: light)">
-  <img src="docs/logo.webp" width="300" alt="VictoriaMetrics logo">
+  <source srcset="docs/victoriametrics/logo_white.webp" media="(prefers-color-scheme: dark)">
+  <source srcset="docs/victoriametrics/logo.webp" media="(prefers-color-scheme: light)">
+  <img src="docs/victoriametrics/logo.webp" width="300" alt="VictoriaMetrics logo">
 </picture>
 
 VictoriaMetrics is a fast, cost-saving, and scalable solution for monitoring and managing time series data. It delivers high performance and reliability, making it an ideal choice for businesses of all sizes.
@@ -21,10 +21,10 @@ VictoriaMetrics is a fast, cost-saving, and scalable solution for monitoring and
 Here are some resources and information about VictoriaMetrics:
 
 - Documentation: [docs.victoriametrics.com](https://docs.victoriametrics.com)
-- Case studies: [Grammarly, Roblox, Wix,...](https://docs.victoriametrics.com/casestudies/).
+- Case studies: [Grammarly, Roblox, Wix,...](https://docs.victoriametrics.com/victoriametrics/casestudies/).
 - Available: [Binary releases](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/latest), docker images [Docker Hub](https://hub.docker.com/r/victoriametrics/victoria-metrics/) and [Quay](https://quay.io/repository/victoriametrics/victoria-metrics), [Source code](https://github.com/VictoriaMetrics/VictoriaMetrics)
-- Deployment types: [Single-node version](https://docs.victoriametrics.com/), [Cluster version](https://docs.victoriametrics.com/cluster-victoriametrics/), and [Enterprise version](https://docs.victoriametrics.com/enterprise/)
-- Changelog: [CHANGELOG](https://docs.victoriametrics.com/changelog/), and [How to upgrade](https://docs.victoriametrics.com/#how-to-upgrade-victoriametrics)
+- Deployment types: [Single-node version](https://docs.victoriametrics.com/), [Cluster version](https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/), and [Enterprise version](https://docs.victoriametrics.com/victoriametrics/enterprise/)
+- Changelog: [CHANGELOG](https://docs.victoriametrics.com/victoriametrics/changelog/), and [How to upgrade](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-upgrade-victoriametrics)
 - Community: [Slack](https://slack.victoriametrics.com/), [X (Twitter)](https://x.com/VictoriaMetrics), [LinkedIn](https://www.linkedin.com/company/victoriametrics/), [YouTube](https://www.youtube.com/@VictoriaMetrics)
 
 Yes, we open-source both the single-node VictoriaMetrics and the cluster version.
@@ -35,22 +35,22 @@ VictoriaMetrics is optimized for timeseries data, even when old time series are
 
 * **Long-term storage for Prometheus** or as a drop-in replacement for Prometheus and Graphite in Grafana.
 * **Powerful stream aggregation**: Can be used as a StatsD alternative.
-* **Ideal for big data**: Works well with large amounts of time series data from APM, Kubernetes, IoT sensors, connected cars, industrial telemetry, financial data and various [Enterprise workloads](https://docs.victoriametrics.com/enterprise/).
+* **Ideal for big data**: Works well with large amounts of time series data from APM, Kubernetes, IoT sensors, connected cars, industrial telemetry, financial data and various [Enterprise workloads](https://docs.victoriametrics.com/victoriametrics/enterprise/).
 * **Query language**: Supports both PromQL and the more performant MetricsQL.
 * **Easy to setup**: No dependencies, single [small binary](https://medium.com/@valyala/stripping-dependency-bloat-in-victoriametrics-docker-image-983fb5912b0d), configuration through command-line flags, but the default is also fine-tuned; backup and restore with [instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282).
 * **Global query view**: Multiple Prometheus instances or any other data sources may ingest data into VictoriaMetrics and queried via a single query.
 * **Various Protocols**: Support metric scraping, ingestion and backfilling in various protocol.
-    * [Prometheus exporters](https://docs.victoriametrics.com/#how-to-scrape-prometheus-exporters-such-as-node-exporter), [Prometheus remote write API](https://docs.victoriametrics.com/#prometheus-setup), [Prometheus exposition format](https://docs.victoriametrics.com/#how-to-import-data-in-prometheus-exposition-format).
-    * [InfluxDB line protocol](https://docs.victoriametrics.com/#how-to-send-data-from-influxdb-compatible-agents-such-as-telegraf) over HTTP, TCP and UDP.
-    * [Graphite plaintext protocol](https://docs.victoriametrics.com/#how-to-send-data-from-graphite-compatible-agents-such-as-statsd) with [tags](https://graphite.readthedocs.io/en/latest/tags.html#carbon).
-    * [OpenTSDB put message](https://docs.victoriametrics.com/#sending-data-via-telnet-put-protocol).
-    * [HTTP OpenTSDB /api/put requests](https://docs.victoriametrics.com/#sending-opentsdb-data-via-http-apiput-requests).
-    * [JSON line format](https://docs.victoriametrics.com/#how-to-import-data-in-json-line-format).
-    * [Arbitrary CSV data](https://docs.victoriametrics.com/#how-to-import-csv-data).
-    * [Native binary format](https://docs.victoriametrics.com/#how-to-import-data-in-native-format).
-    * [DataDog agent or DogStatsD](https://docs.victoriametrics.com/#how-to-send-data-from-datadog-agent).
-    * [NewRelic infrastructure agent](https://docs.victoriametrics.com/#how-to-send-data-from-newrelic-agent).
-    * [OpenTelemetry metrics format](https://docs.victoriametrics.com/#sending-data-via-opentelemetry).
+    * [Prometheus exporters](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-scrape-prometheus-exporters-such-as-node-exporter), [Prometheus remote write API](https://docs.victoriametrics.com/victoriametrics/integrations/prometheus), [Prometheus exposition format](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-import-data-in-prometheus-exposition-format).
+    * [InfluxDB line protocol](https://docs.victoriametrics.com/victoriametrics/integrations/influxdb) over HTTP, TCP and UDP.
+    * [Graphite plaintext protocol](https://docs.victoriametrics.com/victoriametrics/integrations/graphite/#ingesting) with [tags](https://graphite.readthedocs.io/en/latest/tags.html#carbon).
+    * [OpenTSDB put message](https://docs.victoriametrics.com/victoriametrics/integrations/opentsdb#sending-data-via-telnet).
+    * [HTTP OpenTSDB /api/put requests](https://docs.victoriametrics.com/victoriametrics/integrations/opentsdb#sending-data-via-http).
+    * [JSON line format](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-import-data-in-json-line-format).
+    * [Arbitrary CSV data](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-import-csv-data).
+    * [Native binary format](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-import-data-in-native-format).
+    * [DataDog agent or DogStatsD](https://docs.victoriametrics.com/victoriametrics/integrations/datadog).
+    * [NewRelic infrastructure agent](https://docs.victoriametrics.com/victoriametrics/integrations/newrelic#sending-data-from-agent).
+    * [OpenTelemetry metrics format](https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#sending-data-via-opentelemetry).
 * **NFS-based storages**: Supports storing data on NFS-based storages such as Amazon EFS, Google Filestore.
 * And many other features such as metrics relabeling, cardinality limiter, etc.
 
@@ -62,9 +62,9 @@ In addition, the Enterprise version includes extra features:
 - **Backup automation**: Automates regular backup procedures.
 - **Multiple retentions**: Reducing storage costs by specifying different retentions for different datasets.
 - **Downsampling**: Reducing storage costs and increasing performance for queries over historical data.
-- **Stable releases** with long-term support lines ([LTS](https://docs.victoriametrics.com/lts-releases/)).
+- **Stable releases** with long-term support lines ([LTS](https://docs.victoriametrics.com/victoriametrics/lts-releases/)).
 - **Comprehensive support**: First-class consulting, feature requests and technical support provided by the core VictoriaMetrics dev team.
-- Many other features, which you can read about on [the Enterprise page](https://docs.victoriametrics.com/enterprise/).
+- Many other features, which you can read about on [the Enterprise page](https://docs.victoriametrics.com/victoriametrics/enterprise/).
 
 [Contact us](mailto:info@victoriametrics.com) if you need enterprise support for VictoriaMetrics. Or you can request a free trial license [here](https://victoriametrics.com/products/enterprise/trial/), downloaded Enterprise binaries are available at [Github Releases](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/latest).
 
@@ -77,7 +77,7 @@ Some good benchmarks VictoriaMetrics achieved:
 * **Minimal memory footprint**: handling millions of unique timeseries with [10x less RAM](https://medium.com/@valyala/insert-benchmarks-with-inch-influxdb-vs-victoriametrics-e31a41ae2893) than InfluxDB, up to [7x less RAM](https://valyala.medium.com/prometheus-vs-victoriametrics-benchmark-on-node-exporter-metrics-4ca29c75590f) than Prometheus, Thanos or Cortex.
 * **Highly scalable and performance** for [data ingestion](https://medium.com/@valyala/high-cardinality-tsdb-benchmarks-victoriametrics-vs-timescaledb-vs-influxdb-13e6ee64dd6b) and [querying](https://medium.com/@valyala/when-size-matters-benchmarking-victoriametrics-vs-timescale-and-influxdb-6035811952d4), [20x outperforms](https://medium.com/@valyala/insert-benchmarks-with-inch-influxdb-vs-victoriametrics-e31a41ae2893) InfluxDB and TimescaleDB.
 * **High data compression**: [70x more data points](https://medium.com/@valyala/when-size-matters-benchmarking-victoriametrics-vs-timescale-and-influxdb-6035811952d4) may be stored into limited storage than TimescaleDB, [7x less storage](https://valyala.medium.com/prometheus-vs-victoriametrics-benchmark-on-node-exporter-metrics-4ca29c75590f) space is required than Prometheus, Thanos or Cortex.
-* **Reducing storage costs**: [10x more effective](https://docs.victoriametrics.com/casestudies/#grammarly) than Graphite according to the Grammarly case study.
+* **Reducing storage costs**: [10x more effective](https://docs.victoriametrics.com/victoriametrics/casestudies/#grammarly) than Graphite according to the Grammarly case study.
 * **A single-node VictoriaMetrics** can replace medium-sized clusters built with competing solutions such as Thanos, M3DB, Cortex, InfluxDB or TimescaleDB. See [VictoriaMetrics vs Thanos](https://medium.com/@valyala/comparing-thanos-to-victoriametrics-cluster-b193bea1683), [Measuring vertical scalability](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae), [Remote write storage wars - PromCon 2019](https://promcon.io/2019-munich/talks/remote-write-storage-wars/).
 * **Optimized for storage**: [Works well with high-latency IO](https://medium.com/@valyala/high-cardinality-tsdb-benchmarks-victoriametrics-vs-timescaledb-vs-influxdb-13e6ee64dd6b) and low IOPS (HDD and network storage in AWS, Google Cloud, Microsoft Azure, etc.).
 
@@ -93,7 +93,7 @@ Feel free asking any questions regarding VictoriaMetrics:
 * [Telegram-ru](https://t.me/VictoriaMetrics_ru1)
 * [Mastodon](https://mastodon.social/@victoriametrics/)
 
-If you like VictoriaMetrics and want to contribute, then please [read these docs](https://docs.victoriametrics.com/contributing/).
+If you like VictoriaMetrics and want to contribute, then please [read these docs](https://docs.victoriametrics.com/victoriametrics/contributing/).
 
 ## VictoriaMetrics Logo
 

SECURITY.md

@@ -6,9 +6,9 @@ The following versions of VictoriaMetrics receive regular security fixes:
 
 | Version | Supported          |
 |---------|--------------------|
-| [latest release](https://docs.victoriametrics.com/changelog/) | :white_check_mark: |
-| v1.102.x [LTS line](https://docs.victoriametrics.com/lts-releases/) | :white_check_mark: |
-| v1.110.x [LTS line](https://docs.victoriametrics.com/lts-releases/) | :white_check_mark: |
+| [latest release](https://docs.victoriametrics.com/victoriametrics/changelog/) | :white_check_mark: |
+| v1.102.x [LTS line](https://docs.victoriametrics.com/victoriametrics/lts-releases/) | :white_check_mark: |
+| v1.110.x [LTS line](https://docs.victoriametrics.com/victoriametrics/lts-releases/) | :white_check_mark: |
 | other releases  | :x:                |
 
 See [this page](https://victoriametrics.com/security/) for more details.

app/victoria-logs/main.go

@@ -46,7 +46,9 @@ func main() {
 	vlselect.Init()
 	vlinsert.Init()
 
-	go httpserver.Serve(listenAddrs, useProxyProtocol, requestHandler)
+	go httpserver.Serve(listenAddrs, requestHandler, httpserver.ServeOptions{
+		UseProxyProtocol: useProxyProtocol,
+	})
 	logger.Infof("started VictoriaLogs in %.3f seconds; see https://docs.victoriametrics.com/victorialogs/", time.Since(startTime).Seconds())
 
 	pushmetrics.Init()

app/victoria-metrics/main.go

@@ -32,7 +32,7 @@ var (
 		"See https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt . "+
 		"With enabled proxy protocol http server cannot serve regular /metrics endpoint. Use -pushmetrics.url for metrics pushing")
 	minScrapeInterval = flag.Duration("dedup.minScrapeInterval", 0, "Leave only the last sample in every time series per each discrete interval "+
-		"equal to -dedup.minScrapeInterval > 0. See also -streamAggr.dedupInterval and https://docs.victoriametrics.com/#deduplication")
+		"equal to -dedup.minScrapeInterval > 0. See also -streamAggr.dedupInterval and https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#deduplication")
 	dryRun = flag.Bool("dryRun", false, "Whether to check config files without running VictoriaMetrics. The following config files are checked: "+
 		"-promscrape.config, -relabelConfig and -streamAggr.config. Unknown config entries aren't allowed in -promscrape.config by default. "+
 		"This can be changed with -promscrape.config.strictParse=false command-line flag")
@@ -45,7 +45,7 @@ var (
 	finalDedupScheduleInterval = flag.Duration("storage.finalDedupScheduleCheckInterval", time.Hour, "The interval for checking when final deduplication process should be started."+
 		"Storage unconditionally adds 25% jitter to the interval value on each check evaluation."+
 		" Changing the interval to the bigger values may delay downsampling, deduplication for historical data."+
-		" See also https://docs.victoriametrics.com/#deduplication")
+		" See also https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#deduplication")
 )
 
 func main() {
@@ -101,7 +101,9 @@ func main() {
 
 	startSelfScraper()
 
-	go httpserver.Serve(listenAddrs, useProxyProtocol, requestHandler)
+	go httpserver.Serve(listenAddrs, requestHandler, httpserver.ServeOptions{
+		UseProxyProtocol: useProxyProtocol,
+	})
 	logger.Infof("started VictoriaMetrics in %.3f seconds", time.Since(startTime).Seconds())
 
 	pushmetrics.Init()

app/victoria-metrics/main_test.go

@@ -1,619 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"math/rand"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-
-	testutil "github.com/VictoriaMetrics/VictoriaMetrics/app/victoria-metrics/test"
-	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert"
-	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect"
-	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/promql"
-	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
-	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
-	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
-	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
-)
-
-const (
-	testFixturesDir            = "testdata"
-	testStorageSuffix          = "vm-test-storage"
-	testHTTPListenAddr         = ":7654"
-	testStatsDListenAddr       = ":2003"
-	testOpenTSDBListenAddr     = ":4242"
-	testOpenTSDBHTTPListenAddr = ":4243"
-	testLogLevel               = "INFO"
-)
-
-const (
-	testReadHTTPPath           = "http://127.0.0.1" + testHTTPListenAddr
-	testWriteHTTPPath          = "http://127.0.0.1" + testHTTPListenAddr + "/write"
-	testOpenTSDBWriteHTTPPath  = "http://127.0.0.1" + testOpenTSDBHTTPListenAddr + "/api/put"
-	testPromWriteHTTPPath      = "http://127.0.0.1" + testHTTPListenAddr + "/api/v1/write"
-	testImportCSVWriteHTTPPath = "http://127.0.0.1" + testHTTPListenAddr + "/api/v1/import/csv"
-
-	testHealthHTTPPath = "http://127.0.0.1" + testHTTPListenAddr + "/health"
-)
-
-const (
-	testStorageInitTimeout = 10 * time.Second
-)
-
-var (
-	storagePath   string
-	insertionTime = time.Now().UTC()
-)
-
-type test struct {
-	Name                     string   `json:"name"`
-	Data                     []string `json:"data"`
-	InsertQuery              string   `json:"insert_query"`
-	Query                    []string `json:"query"`
-	ResultMetrics            []Metric `json:"result_metrics"`
-	ResultSeries             Series   `json:"result_series"`
-	ResultQuery              Query    `json:"result_query"`
-	Issue                    string   `json:"issue"`
-	ExpectedResultLinesCount int      `json:"expected_result_lines_count"`
-}
-
-type Metric struct {
-	Metric     map[string]string `json:"metric"`
-	Values     []float64         `json:"values"`
-	Timestamps []int64           `json:"timestamps"`
-}
-
-func (r *Metric) UnmarshalJSON(b []byte) error {
-	type plain Metric
-	return json.Unmarshal(testutil.PopulateTimeTpl(b, insertionTime), (*plain)(r))
-}
-
-type Series struct {
-	Status string              `json:"status"`
-	Data   []map[string]string `json:"data"`
-}
-
-type Query struct {
-	Status string `json:"status"`
-	Data   struct {
-		ResultType string          `json:"resultType"`
-		Result     json.RawMessage `json:"result"`
-	} `json:"data"`
-}
-
-const rtVector, rtMatrix = "vector", "matrix"
-
-func (q *Query) metrics() ([]Metric, error) {
-	switch q.Data.ResultType {
-	case rtVector:
-		var r QueryInstant
-		if err := json.Unmarshal(q.Data.Result, &r.Result); err != nil {
-			return nil, err
-		}
-		return r.metrics()
-	case rtMatrix:
-		var r QueryRange
-		if err := json.Unmarshal(q.Data.Result, &r.Result); err != nil {
-			return nil, err
-		}
-		return r.metrics()
-	default:
-		return nil, fmt.Errorf("unknown result type %q", q.Data.ResultType)
-	}
-}
-
-type QueryInstant struct {
-	Result []struct {
-		Labels map[string]string `json:"metric"`
-		TV     [2]any            `json:"value"`
-	} `json:"result"`
-}
-
-func (q QueryInstant) metrics() ([]Metric, error) {
-	result := make([]Metric, len(q.Result))
-	for i, res := range q.Result {
-		f, err := strconv.ParseFloat(res.TV[1].(string), 64)
-		if err != nil {
-			return nil, fmt.Errorf("metric %v, unable to parse float64 from %s: %w", res, res.TV[1], err)
-		}
-		var m Metric
-		m.Metric = res.Labels
-		m.Timestamps = append(m.Timestamps, int64(res.TV[0].(float64)))
-		m.Values = append(m.Values, f)
-		result[i] = m
-	}
-	return result, nil
-}
-
-type QueryRange struct {
-	Result []struct {
-		Metric map[string]string `json:"metric"`
-		Values [][]any           `json:"values"`
-	} `json:"result"`
-}
-
-func (q QueryRange) metrics() ([]Metric, error) {
-	var result []Metric
-	for i, res := range q.Result {
-		var m Metric
-		for _, tv := range res.Values {
-			f, err := strconv.ParseFloat(tv[1].(string), 64)
-			if err != nil {
-				return nil, fmt.Errorf("metric %v, unable to parse float64 from %s: %w", res, tv[1], err)
-			}
-			m.Values = append(m.Values, f)
-			m.Timestamps = append(m.Timestamps, int64(tv[0].(float64)))
-		}
-		if len(m.Values) < 1 || len(m.Timestamps) < 1 {
-			return nil, fmt.Errorf("metric %v contains no values", res)
-		}
-		m.Metric = q.Result[i].Metric
-		result = append(result, m)
-	}
-	return result, nil
-}
-
-func (q *Query) UnmarshalJSON(b []byte) error {
-	type plain Query
-	return json.Unmarshal(testutil.PopulateTimeTpl(b, insertionTime), (*plain)(q))
-}
-
-func TestMain(m *testing.M) {
-	setUp()
-	code := m.Run()
-	tearDown()
-	os.Exit(code)
-}
-
-func setUp() {
-	storagePath = filepath.Join(os.TempDir(), testStorageSuffix)
-	processFlags()
-	logger.Init()
-	vmstorage.Init(promql.ResetRollupResultCacheIfNeeded)
-	vmselect.Init()
-	vminsert.Init()
-	go httpserver.Serve(*httpListenAddrs, useProxyProtocol, requestHandler)
-	readyStorageCheckFunc := func() bool {
-		resp, err := http.Get(testHealthHTTPPath)
-		if err != nil {
-			return false
-		}
-		_ = resp.Body.Close()
-		return resp.StatusCode == 200
-	}
-	if err := waitFor(testStorageInitTimeout, readyStorageCheckFunc); err != nil {
-		log.Fatalf("http server can't start for %s seconds, err %s", testStorageInitTimeout, err)
-	}
-}
-
-func processFlags() {
-	flag.Parse()
-	for _, fv := range []struct {
-		flag  string
-		value string
-	}{
-		{flag: "storageDataPath", value: storagePath},
-		{flag: "httpListenAddr", value: testHTTPListenAddr},
-		{flag: "graphiteListenAddr", value: testStatsDListenAddr},
-		{flag: "opentsdbListenAddr", value: testOpenTSDBListenAddr},
-		{flag: "loggerLevel", value: testLogLevel},
-		{flag: "opentsdbHTTPListenAddr", value: testOpenTSDBHTTPListenAddr},
-	} {
-		// panics if flag doesn't exist
-		if err := flag.Lookup(fv.flag).Value.Set(fv.value); err != nil {
-			log.Fatalf("unable to set %q with value %q, err: %v", fv.flag, fv.value, err)
-		}
-	}
-}
-
-func waitFor(timeout time.Duration, f func() bool) error {
-	fraction := timeout / 10
-	for i := fraction; i < timeout; i += fraction {
-		if f() {
-			return nil
-		}
-		time.Sleep(fraction)
-	}
-	return fmt.Errorf("timeout")
-}
-
-func tearDown() {
-	if err := httpserver.Stop(*httpListenAddrs); err != nil {
-		log.Printf("cannot stop the webservice: %s", err)
-	}
-	vminsert.Stop()
-	vmstorage.Stop()
-	vmselect.Stop()
-	fs.MustRemoveAll(storagePath)
-}
-
-func TestWriteRead(t *testing.T) {
-	t.Run("write", testWrite)
-	time.Sleep(500 * time.Millisecond)
-	vmstorage.Storage.DebugFlush()
-	time.Sleep(1500 * time.Millisecond)
-	t.Run("read", testRead)
-}
-
-func testWrite(t *testing.T) {
-	t.Run("prometheus", func(t *testing.T) {
-		for _, test := range readIn("prometheus", insertionTime) {
-			if test.Data == nil {
-				continue
-			}
-			r := testutil.WriteRequest{}
-			testData := strings.Join(test.Data, "\n")
-			if err := json.Unmarshal([]byte(testData), &r.Timeseries); err != nil {
-				panic(fmt.Errorf("BUG: cannot unmarshal TimeSeries: %s\ntest data\n%s", err, testData))
-			}
-			if n := len(r.Timeseries); n <= 0 {
-				panic(fmt.Errorf("BUG: expecting non-empty Timeseries in test data:\n%s", testData))
-			}
-			data := testutil.Compress(r)
-			httpWrite(t, testPromWriteHTTPPath, test.InsertQuery, bytes.NewBuffer(data))
-		}
-	})
-	t.Run("csv", func(t *testing.T) {
-		for _, test := range readIn("csv", insertionTime) {
-			if test.Data == nil {
-				continue
-			}
-			httpWrite(t, testImportCSVWriteHTTPPath, test.InsertQuery, bytes.NewBuffer([]byte(strings.Join(test.Data, "\n"))))
-		}
-	})
-
-	t.Run("influxdb", func(t *testing.T) {
-		for _, x := range readIn("influxdb", insertionTime) {
-			test := x
-			t.Run(test.Name, func(t *testing.T) {
-				t.Parallel()
-				httpWrite(t, testWriteHTTPPath, test.InsertQuery, bytes.NewBufferString(strings.Join(test.Data, "\n")))
-			})
-		}
-	})
-	t.Run("graphite", func(t *testing.T) {
-		for _, x := range readIn("graphite", insertionTime) {
-			test := x
-			t.Run(test.Name, func(t *testing.T) {
-				t.Parallel()
-				tcpWrite(t, "127.0.0.1"+testStatsDListenAddr, strings.Join(test.Data, "\n"))
-			})
-		}
-	})
-	t.Run("opentsdb", func(t *testing.T) {
-		for _, x := range readIn("opentsdb", insertionTime) {
-			test := x
-			t.Run(test.Name, func(t *testing.T) {
-				t.Parallel()
-				tcpWrite(t, "127.0.0.1"+testOpenTSDBListenAddr, strings.Join(test.Data, "\n"))
-			})
-		}
-	})
-	t.Run("opentsdbhttp", func(t *testing.T) {
-		for _, x := range readIn("opentsdbhttp", insertionTime) {
-			test := x
-			t.Run(test.Name, func(t *testing.T) {
-				t.Parallel()
-				logger.Infof("writing %s", test.Data)
-				httpWrite(t, testOpenTSDBWriteHTTPPath, test.InsertQuery, bytes.NewBufferString(strings.Join(test.Data, "\n")))
-			})
-		}
-	})
-}
-
-func testRead(t *testing.T) {
-	for _, engine := range []string{"csv", "prometheus", "graphite", "opentsdb", "influxdb", "opentsdbhttp"} {
-		t.Run(engine, func(t *testing.T) {
-			for _, x := range readIn(engine, insertionTime) {
-				test := x
-				t.Run(test.Name, func(t *testing.T) {
-					t.Parallel()
-					for _, q := range test.Query {
-						q = testutil.PopulateTimeTplString(q, insertionTime)
-						if test.Issue != "" {
-							test.Issue = "\nRegression in " + test.Issue
-						}
-						switch {
-						case strings.HasPrefix(q, "/api/v1/export/csv"):
-							data := strings.Split(string(httpReadData(t, testReadHTTPPath, q)), "\n")
-							if len(data) == test.ExpectedResultLinesCount {
-								t.Fatalf("not expected number of csv lines want=%d\ngot=%d test=%s.%s\n\response=%q", len(data), test.ExpectedResultLinesCount, q, test.Issue, strings.Join(data, "\n"))
-							}
-						case strings.HasPrefix(q, "/api/v1/export"):
-							if err := checkMetricsResult(httpReadMetrics(t, testReadHTTPPath, q), test.ResultMetrics); err != nil {
-								t.Fatalf("Export. %s fails with error %s.%s", q, err, test.Issue)
-							}
-						case strings.HasPrefix(q, "/api/v1/series"):
-							s := Series{}
-							httpReadStruct(t, testReadHTTPPath, q, &s)
-							if err := checkSeriesResult(s, test.ResultSeries); err != nil {
-								t.Fatalf("Series. %s fails with error %s.%s", q, err, test.Issue)
-							}
-						case strings.HasPrefix(q, "/api/v1/query"):
-							queryResult := Query{}
-							httpReadStruct(t, testReadHTTPPath, q, &queryResult)
-							gotMetrics, err := queryResult.metrics()
-							if err != nil {
-								t.Fatalf("failed to parse query response: %s", err)
-							}
-							expMetrics, err := test.ResultQuery.metrics()
-							if err != nil {
-								t.Fatalf("failed to parse expected response: %s", err)
-							}
-							if err := checkMetricsResult(gotMetrics, expMetrics); err != nil {
-								t.Fatalf("%q fails with error %s.%s", q, err, test.Issue)
-							}
-						default:
-							t.Fatalf("unsupported read query %s", q)
-						}
-					}
-				})
-			}
-		})
-	}
-}
-
-func readIn(readFor string, insertTime time.Time) []test {
-	testDir := filepath.Join(testFixturesDir, readFor)
-	var tt []test
-	err := filepath.Walk(testDir, func(path string, _ os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if filepath.Ext(path) != ".json" {
-			return nil
-		}
-		b, err := os.ReadFile(path)
-		if err != nil {
-			panic(fmt.Errorf("BUG: cannot read %s: %s", path, err))
-		}
-		item := test{}
-		if err := json.Unmarshal(b, &item); err != nil {
-			panic(fmt.Errorf("cannot parse %T from %s: %s; data:\n%s", &item, path, err, b))
-		}
-		for i := range item.Data {
-			item.Data[i] = testutil.PopulateTimeTplString(item.Data[i], insertTime)
-		}
-		tt = append(tt, item)
-		return nil
-	})
-	if err != nil {
-		panic(fmt.Errorf("BUG: cannot read test data at %s: %w", testDir, err))
-	}
-	if len(tt) == 0 {
-		panic(fmt.Errorf("BUG: no tests found in %s", testDir))
-	}
-	return tt
-}
-
-func httpWrite(t *testing.T, address, query string, r io.Reader) {
-	t.Helper()
-
-	requestURL := address + query
-	resp, err := http.Post(requestURL, "", r)
-	if err != nil {
-		t.Fatalf("cannot send request to %s: %s", requestURL, err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode != 204 {
-		t.Fatalf("unexpected status code received from %s; got %d; want 204", requestURL, resp.StatusCode)
-	}
-}
-
-func tcpWrite(t *testing.T, address, data string) {
-	t.Helper()
-
-	conn, err := net.Dial("tcp", address)
-	if err != nil {
-		t.Fatalf("cannot dial %s: %s", address, err)
-	}
-	defer func() {
-		_ = conn.Close()
-	}()
-	n, err := conn.Write([]byte(data))
-	if err != nil {
-		t.Fatalf("cannot write %d bytes to %s: %s", len(data), address, err)
-	}
-	if n != len(data) {
-		panic(fmt.Errorf("BUG: conn.Write() returned unexpected number of written bytes to %s; got %d; want %d", address, n, len(data)))
-	}
-}
-
-func httpReadMetrics(t *testing.T, address, query string) []Metric {
-	t.Helper()
-
-	requestURL := address + query
-	resp, err := http.Get(requestURL)
-	if err != nil {
-		t.Fatalf("cannot send request to %s: %s", requestURL, err)
-	}
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-	if resp.StatusCode != 200 {
-		t.Fatalf("unexpected status code received from %s; got %d; want 200", requestURL, resp.StatusCode)
-	}
-
-	var rows []Metric
-	dec := json.NewDecoder(resp.Body)
-	for {
-		var row Metric
-		err := dec.Decode(&row)
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				return rows
-			}
-			t.Fatalf("cannot decode %T from response received from %s: %s", &row, requestURL, err)
-		}
-		rows = append(rows, row)
-	}
-}
-
-func httpReadStruct(t *testing.T, address, query string, dst any) {
-	t.Helper()
-
-	requestURL := address + query
-	resp, err := http.Get(requestURL)
-	if err != nil {
-		t.Fatalf("cannot send request to %s: %s", requestURL, err)
-	}
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-	if resp.StatusCode != 200 {
-		t.Fatalf("unexpected status code received from %s; got %d; want 200", requestURL, resp.StatusCode)
-	}
-	err = json.NewDecoder(resp.Body).Decode(dst)
-	if err != nil {
-		t.Fatalf("cannot decode %T from response received from %s: %s", dst, requestURL, err)
-	}
-}
-
-func httpReadData(t *testing.T, address, query string) []byte {
-	t.Helper()
-
-	requestURL := address + query
-	resp, err := http.Get(requestURL)
-	if err != nil {
-		t.Fatalf("cannot send request to %s: %s", requestURL, err)
-	}
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-	if resp.StatusCode != 200 {
-		t.Fatalf("unexpected status code received from %s; got %d; want 200", requestURL, resp.StatusCode)
-	}
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		t.Fatalf("cannot read response from %s: %s", requestURL, err)
-	}
-	return data
-}
-
-func checkMetricsResult(got, want []Metric) error {
-	for _, r := range append([]Metric(nil), got...) {
-		want = removeIfFoundMetrics(r, want)
-	}
-	if len(want) > 0 {
-		return fmt.Errorf("expected metrics %+v not found in %+v", want, got)
-	}
-	return nil
-}
-
-func removeIfFoundMetrics(r Metric, contains []Metric) []Metric {
-	for i, item := range contains {
-		if reflect.DeepEqual(r.Metric, item.Metric) && reflect.DeepEqual(r.Values, item.Values) &&
-			reflect.DeepEqual(r.Timestamps, item.Timestamps) {
-			contains[i] = contains[len(contains)-1]
-			return contains[:len(contains)-1]
-		}
-	}
-	return contains
-}
-
-func checkSeriesResult(got, want Series) error {
-	if got.Status != want.Status {
-		return fmt.Errorf("status mismatch %q - %q", want.Status, got.Status)
-	}
-	wantData := append([]map[string]string(nil), want.Data...)
-	for _, r := range got.Data {
-		wantData = removeIfFoundSeries(r, wantData)
-	}
-	if len(wantData) > 0 {
-		return fmt.Errorf("expected seria(s) %+v not found in %+v", wantData, got.Data)
-	}
-	return nil
-}
-
-func removeIfFoundSeries(r map[string]string, contains []map[string]string) []map[string]string {
-	for i, item := range contains {
-		if reflect.DeepEqual(r, item) {
-			contains[i] = contains[len(contains)-1]
-			return contains[:len(contains)-1]
-		}
-	}
-	return contains
-}
-
-func TestImportJSONLines(t *testing.T) {
-	f := func(labelsCount, labelLen int) {
-		t.Helper()
-
-		reqURL := fmt.Sprintf("http://localhost%s/api/v1/import", testHTTPListenAddr)
-		line := generateJSONLine(labelsCount, labelLen)
-		req, err := http.NewRequest("POST", reqURL, bytes.NewBufferString(line))
-		if err != nil {
-			t.Fatalf("cannot create request: %s", err)
-		}
-		resp, err := http.DefaultClient.Do(req)
-		if err != nil {
-			t.Fatalf("cannot perform request for labelsCount=%d, labelLen=%d: %s", labelsCount, labelLen, err)
-		}
-		if resp.StatusCode != 204 {
-			t.Fatalf("unexpected statusCode for labelsCount=%d, labelLen=%d; got %d; want 204", labelsCount, labelLen, resp.StatusCode)
-		}
-	}
-
-	// labels with various lengths
-	for i := 0; i < 500; i++ {
-		f(10, i*5)
-	}
-
-	// Too many labels
-	f(1000, 100)
-
-	// Too long labels
-	f(1, 100_000)
-	f(10, 100_000)
-	f(10, 10_000)
-}
-
-func generateJSONLine(labelsCount, labelLen int) string {
-	m := make(map[string]string, labelsCount)
-	m["__name__"] = generateSizedRandomString(labelLen)
-	for j := 1; j < labelsCount; j++ {
-		labelName := generateSizedRandomString(labelLen)
-		labelValue := generateSizedRandomString(labelLen)
-		m[labelName] = labelValue
-	}
-
-	type jsonLine struct {
-		Metric     map[string]string `json:"metric"`
-		Values     []float64         `json:"values"`
-		Timestamps []int64           `json:"timestamps"`
-	}
-	line := &jsonLine{
-		Metric:     m,
-		Values:     []float64{1.34},
-		Timestamps: []int64{time.Now().UnixNano() / 1e6},
-	}
-	data, err := json.Marshal(&line)
-	if err != nil {
-		panic(fmt.Errorf("cannot marshal JSON: %w", err))
-	}
-	data = append(data, '\n')
-	return string(data)
-}
-
-const alphabetSample = `qwertyuiopasdfghjklzxcvbnm`
-
-func generateSizedRandomString(size int) string {
-	dst := make([]byte, size)
-	for i := range dst {
-		dst[i] = alphabetSample[rand.Intn(len(alphabetSample))]
-	}
-	return string(dst)
-}

app/victoria-metrics/multiarch/Dockerfile

@@ -9,4 +9,5 @@ COPY --from=certs /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certifica
 EXPOSE 8428
 ENTRYPOINT ["/victoria-metrics-prod"]
 ARG TARGETARCH
-COPY victoria-metrics-linux-${TARGETARCH}-prod ./victoria-metrics-prod
+ARG BINARY_SUFFIX=non-existing
+COPY victoria-metrics-linux-${TARGETARCH}-prod${BINARY_SUFFIX} ./victoria-metrics-prod

app/victoria-metrics/testdata/csv/basic.json

@@ -1,14 +0,0 @@
-{
-  "name": "csv export",
-  "data": [
-    "rfc3339,4,{TIME_MS}",
-    "rfc3339milli,6,{TIME_MS}",
-    "ts,8,{TIME_MS}",
-    "tsms,10,{TIME_MS},"
-  ],
-  "insert_query": "?format=1:label:tfmt,2:metric:test_csv,3:time:unix_ms",
-  "query": [
-    "/api/v1/export/csv?format=__name__,tfmt,__value__,__timestamp__:rfc3339&match[]={__name__=\"test_csv\"}&step=30s&start={TIME_MS-180s}"
-  ],
-  "expected_result_lines_count": 4
-}

app/victoria-metrics/testdata/csv/with_extra_labels.json

@@ -1,14 +0,0 @@
-{
-  "name": "csv export with extra_labels",
-  "data": [
-    "location-1,4,{TIME_MS}",
-    "location-2,6,{TIME_MS}",
-    "location-3,8,{TIME_MS}",
-    "location-4,10,{TIME_MS},"
-  ],
-  "insert_query": "?format=1:label:location,2:metric:test_csv_labels,3:time:unix_ms&extra_label=location=location-1",
-  "query": [
-    "/api/v1/export/csv?format=__name__,location,__value__,__timestamp__:unix_ms&match[]={__name__=\"test_csv\"}&step=30s&start={TIME_MS-180s}"
-  ],
-  "expected_result_lines_count": 4
-}

app/victoria-metrics/testdata/graphite/basic.json

@@ -1,8 +0,0 @@
-{
-  "name": "basic_insertion",
-  "data": ["graphite.foo.bar.baz;tag1=value1;tag2=value2 123 {TIME_S}"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"graphite.foo.bar.baz","tag1":"value1","tag2":"value2"},"values":[123], "timestamps": ["{TIME_MSZ}"]}
-  ]
-}

app/victoria-metrics/testdata/graphite/comparison-not-inf-not-nan.json

@@ -1,16 +0,0 @@
-{
-  "name": "comparison-not-inf-not-nan",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/150",
-  "data": [
-    "not_nan_not_inf;item=x 1 {TIME_S-1m}",
-    "not_nan_not_inf;item=x 1 {TIME_S-2m}",
-    "not_nan_not_inf;item=y 3 {TIME_S-1m}",
-    "not_nan_not_inf;item=y 1 {TIME_S-2m}"],
-  "query": ["/api/v1/query_range?query=1/(not_nan_not_inf-1)!=inf!=nan&start={TIME_S-3m}&end={TIME_S}&step=60"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"matrix",
-      "result":[
-	      {"metric":{"item":"y"},"values":[["{TIME_S-1m}","0.5"], ["{TIME_S}","0.5"]]}
-      ]}}
-}

app/victoria-metrics/testdata/graphite/empty-label-match.json

@@ -1,16 +0,0 @@
-{
-  "name": "empty-label-match",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/395",
-  "data": [
-    "empty_label_match 1 {TIME_S-1m}",
-    "empty_label_match;foo=bar 2 {TIME_S-1m}",
-    "empty_label_match;foo=baz 3 {TIME_S-1m}"],
-  "query": ["/api/v1/query_range?query=empty_label_match{foo=~'bar|'}&start={TIME_S-1m}&end={TIME_S}&step=60"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"matrix",
-      "result":[
-	      {"metric":{"__name__":"empty_label_match"},"values":[["{TIME_S-1m}","1"],["{TIME_S}","1"]]},
-	      {"metric":{"__name__":"empty_label_match","foo":"bar"},"values":[["{TIME_S-1m}","2"],["{TIME_S}","2"]]}
-      ]}}
-}

app/victoria-metrics/testdata/graphite/graphite-selector.json

@@ -1,17 +0,0 @@
-{
-  "name": "graphite-selector",
-  "issue": "",
-  "data": [
-    "graphite-selector.bar.baz 1 {TIME_S-1m}",
-    "graphite-selector.xxx.yy  2 {TIME_S-1m}",
-    "graphite-selector.bb.cc 3 {TIME_S-1m}",
-    "graphite-selector.a.baz 4 {TIME_S-1m}"],
-  "query": ["/api/v1/query?query=sort({__graphite__='graphite-selector.*.baz'})&time={TIME_S-1m}"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"vector","result":[
-	    {"metric":{"__name__":"graphite-selector.bar.baz"},"value":["{TIME_S-1m}","1"]},
-	    {"metric":{"__name__":"graphite-selector.a.baz"},"value":["{TIME_S-1m}","4"]}
-    ]}
-  }
-}

app/victoria-metrics/testdata/graphite/max_lookback_set.json

@@ -1,23 +0,0 @@
-{
-  "name": "max_lookback_set",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/209",
-  "data": [
-    "max_lookback_set 1 {TIME_S-30s}",
-    "max_lookback_set 2 {TIME_S-60s}",
-    "max_lookback_set 3 {TIME_S-120s}",
-    "max_lookback_set 4 {TIME_S-150s}"
-  ],
-  "query": ["/api/v1/query_range?query=max_lookback_set&start={TIME_S-150s}&end={TIME_S}&step=10s&max_lookback=1s"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"matrix",
-      "result":[{"metric":{"__name__":"max_lookback_set"},"values":[
-	      ["{TIME_S-150s}","4"],
-	      ["{TIME_S-120s}","3"],
-	      ["{TIME_S-60s}","2"],
-	      ["{TIME_S-30s}","1"],
-	      ["{TIME_S-20s}","1"],
-	      ["{TIME_S-10s}","1"],
-	      ["{TIME_S-0s}","1"]
-      ]}]}}
-}

app/victoria-metrics/testdata/graphite/max_lookback_unset.json

@@ -1,31 +0,0 @@
-{
-  "name": "max_lookback_unset",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/209",
-  "data": [
-    "max_lookback_unset 1 {TIME_S-30s}",
-    "max_lookback_unset 2 {TIME_S-60s}",
-    "max_lookback_unset 3 {TIME_S-120s}",
-    "max_lookback_unset 4 {TIME_S-150s}"
-  ],
-  "query": ["/api/v1/query_range?query=max_lookback_unset&start={TIME_S-150s}&end={TIME_S}&step=10s"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"matrix",
-      "result":[{"metric":{"__name__":"max_lookback_unset"},"values":[
-	      ["{TIME_S-150s}","4"],
-	      ["{TIME_S-140s}","4"],
-	      ["{TIME_S-130s}","4"],
-	      ["{TIME_S-120s}","3"],
-	      ["{TIME_S-110s}","3"],
-	      ["{TIME_S-100s}","3"],
-	      ["{TIME_S-90s}","3"],
-	      ["{TIME_S-80s}","3"],
-	      ["{TIME_S-60s}","2"],
-	      ["{TIME_S-50s}","2"],
-	      ["{TIME_S-40s}","2"],
-	      ["{TIME_S-30s}","1"],
-	      ["{TIME_S-20s}","1"],
-	      ["{TIME_S-10s}","1"],
-	      ["{TIME_S-0s}","1"]
-      ]}]}}
-}

app/victoria-metrics/testdata/graphite/name-plus-negative-filter.json

@@ -1,16 +0,0 @@
-{
-  "name": "name-plus-negative-filter",
-  "issue": "",
-  "data": [
-    "name-plus-negative-filter;foo=123 1 {TIME_S-1m}",
-    "name-plus-negative-filter;bar=123 2 {TIME_S-1m}",
-    "name-plus-negative-filter;foo=qwe 3 {TIME_S-1m}"
-  ],
-  "query": ["/api/v1/query?query={__name__='name-plus-negative-filter',foo!='123'}&time={TIME_S-1m}"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"vector","result":[
-	    {"metric":{"__name__":"name-plus-negative-filter","foo":"qwe"},"value":["{TIME_S-1m}","3"]}
-    ]}
-  }
-}

app/victoria-metrics/testdata/graphite/not-nan-as-missing-data.json

@@ -1,18 +0,0 @@
-{
-  "name": "not-nan-as-missing-data",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/153",
-  "data": [
-    "not_nan_as_missing_data;item=x 2 {TIME_S-2m}",
-    "not_nan_as_missing_data;item=x 1 {TIME_S-1m}",
-    "not_nan_as_missing_data;item=y 4 {TIME_S-2m}",
-    "not_nan_as_missing_data;item=y 3 {TIME_S-1m}"
-  ],
-  "query": ["/api/v1/query_range?query=not_nan_as_missing_data>1&start={TIME_S-2m}&end={TIME_S}&step=60"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"matrix",
-      "result":[
-	      {"metric":{"__name__":"not_nan_as_missing_data","item":"x"},"values":[["{TIME_S-2m}","2"]]},
-	      {"metric":{"__name__":"not_nan_as_missing_data","item":"y"},"values":[["{TIME_S-2m}","4"],["{TIME_S-1m}","3"],["{TIME_S}", "3"]]}
-      ]}}
-}

app/victoria-metrics/testdata/graphite/subquery-aggregation.json

@@ -1,14 +0,0 @@
-{
-  "name": "subquery-aggregation",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/184",
-  "data": [
-    "forms_daily_count;item=x 1 {TIME_S-59s}",
-    "forms_daily_count;item=x 2 {TIME_S-1m59s}",
-    "forms_daily_count;item=y 3 {TIME_S-59s}",
-    "forms_daily_count;item=y 4 {TIME_S-1m59s}"],
-  "query": ["/api/v1/query?query=min%20by%20(item)%20(min_over_time(forms_daily_count[10m:1m]))&time={TIME_S-1m}&latency_offset=1ms"],
-  "result_query": {
-    "status":"success",
-    "data":{"resultType":"vector","result":[{"metric":{"item":"x"},"value":["{TIME_S-1m}","2"]},{"metric":{"item":"y"},"value":["{TIME_S-1m}","4"]}]}
-  }
-}

app/victoria-metrics/testdata/influxdb/basic.json

@@ -1,9 +0,0 @@
-{
-  "name": "basic_insertion",
-  "data": ["measurement,tag1=value1,tag2=value2 field1=1.23,field2=123 {TIME_NS}"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"measurement_field2","tag1":"value1","tag2":"value2"},"values":[123], "timestamps": ["{TIME_MS}"]},
-    {"metric":{"__name__":"measurement_field1","tag1":"value1","tag2":"value2"},"values":[1.23], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/influxdb/with_extra_labels.json

@@ -1,10 +0,0 @@
-{
-  "name": "insert_with_extra_labels",
-  "data": ["measurement,tag1=value1,tag2=value2 field6=1.23,field5=123 {TIME_NS}"],
-  "insert_query": "?extra_label=job=test&extra_label=tag2=value10",
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"measurement_field5","tag1":"value1","job": "test","tag2":"value10"},"values":[123], "timestamps": ["{TIME_MS}"]},
-    {"metric":{"__name__":"measurement_field6","tag1":"value1","job": "test","tag2":"value10"},"values":[1.23], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/opentsdb/basic.json

@@ -1,8 +0,0 @@
-{
-  "name": "basic_insertion",
-  "data": ["put openstdb.foo.bar.baz {TIME_S} 123 tag1=value1 tag2=value2"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"openstdb.foo.bar.baz","tag1":"value1","tag2":"value2"},"values":[123], "timestamps": ["{TIME_MSZ}"]}
-  ]
-}

app/victoria-metrics/testdata/opentsdbhttp/basic.json

@@ -1,8 +0,0 @@
-{
-  "name": "basic_insertion",
-  "data": ["{\"metric\": \"opentsdbhttp.foo\", \"value\": 1001, \"timestamp\": {TIME_S}, \"tags\": {\"bar\":\"baz\", \"x\": \"y\"}}"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"opentsdbhttp.foo","bar":"baz","x":"y"},"values":[1001], "timestamps": ["{TIME_MSZ}"]}
-  ]
-}

app/victoria-metrics/testdata/opentsdbhttp/multi_line.json

@@ -1,9 +0,0 @@
-{
-  "name": "multiline",
-  "data": ["[{\"metric\": \"opentsdbhttp.multiline1\", \"value\": 1001, \"timestamp\": \"{TIME_S}\", \"tags\": {\"bar\":\"baz\", \"x\": \"y\"}}, {\"metric\": \"opentsdbhttp.multiline2\", \"value\": 1002, \"timestamp\": {TIME_S}}]"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"opentsdbhttp.multiline1","bar":"baz","x":"y"},"values":[1001], "timestamps": ["{TIME_MSZ}"]},
-    {"metric":{"__name__":"opentsdbhttp.multiline2"},"values":[1002], "timestamps": ["{TIME_MSZ}"]}
-  ]
-}

app/victoria-metrics/testdata/opentsdbhttp/with_extra_labels.json

@@ -1,9 +0,0 @@
-{
-  "name": "insert_with_extra_labels",
-  "data": ["{\"metric\": \"opentsdbhttp.foobar\", \"value\": 1001, \"timestamp\": {TIME_S}, \"tags\": {\"bar\":\"baz\", \"x\": \"y\"}}"],
-  "insert_query": "?extra_label=job=open-test&extra_label=x=z",
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"opentsdbhttp.foobar","bar":"baz","x":"z","job": "open-test"},"values":[1001], "timestamps": ["{TIME_MSZ}"]}
-  ]
-}

app/victoria-metrics/testdata/prometheus/basic.json

@@ -1,8 +0,0 @@
-{
-  "name": "basic_insertion",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.bar\"},{\"name\":\"baz\",\"value\":\"qux\"}],\"samples\":[{\"value\":100000,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"prometheus.bar","baz":"qux"},"values":[100000], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/prometheus/case-sensitive-regex.json

@@ -1,10 +0,0 @@
-{
-  "name": "case-sensitive-regex",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/161",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.sensitiveRegex\"},{\"name\":\"label\",\"value\":\"sensitiveRegex\"}],\"samples\":[{\"value\":2,\"timestamp\":\"{TIME_MS}\"}]},{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.sensitiveRegex\"},{\"name\":\"label\",\"value\":\"SensitiveRegex\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/export?match={label=~'(?i)sensitiveregex'}"],
-  "result_metrics": [
-    {"metric":{"__name__":"prometheus.sensitiveRegex","label":"sensitiveRegex"},"values":[2], "timestamps": ["{TIME_MS}"]},
-    {"metric":{"__name__":"prometheus.sensitiveRegex","label":"SensitiveRegex"},"values":[1], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/prometheus/duplicate-label.json

@@ -1,9 +0,0 @@
-{
-  "name": "duplicate_label",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/172",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.duplicate_label\"},{\"name\":\"duplicate\",\"value\":\"label\"},{\"name\":\"duplicate\",\"value\":\"label\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"prometheus.duplicate_label","duplicate":"label"},"values":[1], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/prometheus/instant-matrix.json

@@ -1,12 +0,0 @@
-{
-  "name": "instant query with look-behind window",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"foo\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS-60s}\"}]}]"],
-  "query": ["/api/v1/query?query=foo[5m]"],
-  "result_query": {
-      "status": "success",
-      "data":{
-        "resultType":"matrix",
-        "result":[{"metric":{"__name__":"foo"},"values":[["{TIME_S-60s}", "1"]]}]
-      }
-    }
-}

app/victoria-metrics/testdata/prometheus/instant-scalar.json

@@ -1,11 +0,0 @@
-{
-  "name": "instant scalar query",
-  "query": ["/api/v1/query?query=42&time={TIME_S}"],
-  "result_query": {
-      "status": "success",
-      "data":{
-        "resultType":"vector",
-        "result":[{"metric":{},"value":["{TIME_S}", "42"]}]
-      }
-    }
-}

app/victoria-metrics/testdata/prometheus/issue-5553-too-big-lookback.json

@@ -1,13 +0,0 @@
-{
-  "name": "too big look-behind window",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/5553",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"foo\"},{\"name\":\"issue\",\"value\":\"5553\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS-60s}\"}]}]"],
-  "query": ["/api/v1/query?query=foo{issue=\"5553\"}[100y]"],
-  "result_query": {
-      "status": "success",
-      "data":{
-        "resultType":"matrix",
-        "result":[{"metric":{"__name__":"foo", "issue": "5553"},"values":[["{TIME_S-60s}", "1"]]}]
-      }
-    }
-}

app/victoria-metrics/testdata/prometheus/match-series.json

@@ -1,15 +0,0 @@
-{
-  "name": "match_series",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/155",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"MatchSeries\"},{\"name\":\"db\",\"value\":\"TenMinute\"},{\"name\":\"TurbineType\",\"value\":\"V112\"},{\"name\":\"Park\",\"value\":\"1\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]},{\"labels\":[{\"name\":\"__name__\",\"value\":\"MatchSeries\"},{\"name\":\"db\",\"value\":\"TenMinute\"},{\"name\":\"TurbineType\",\"value\":\"V112\"},{\"name\":\"Park\",\"value\":\"2\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]},{\"labels\":[{\"name\":\"__name__\",\"value\":\"MatchSeries\"},{\"name\":\"db\",\"value\":\"TenMinute\"},{\"name\":\"TurbineType\",\"value\":\"V112\"},{\"name\":\"Park\",\"value\":\"3\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]},{\"labels\":[{\"name\":\"__name__\",\"value\":\"MatchSeries\"},{\"name\":\"db\",\"value\":\"TenMinute\"},{\"name\":\"TurbineType\",\"value\":\"V112\"},{\"name\":\"Park\",\"value\":\"4\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/series?match[]={__name__='MatchSeries'}", "/api/v1/series?match[]={__name__=~'MatchSeries.*'}"],
-  "result_series": {
-    "status": "success",
-    "data": [
-      {"__name__":"MatchSeries","db":"TenMinute","Park":"1","TurbineType":"V112"},
-      {"__name__":"MatchSeries","db":"TenMinute","Park":"2","TurbineType":"V112"},
-      {"__name__":"MatchSeries","db":"TenMinute","Park":"3","TurbineType":"V112"},
-      {"__name__":"MatchSeries","db":"TenMinute","Park":"4","TurbineType":"V112"}
-    ]
-  }
-}

app/victoria-metrics/testdata/prometheus/query-range.json

@@ -1,18 +0,0 @@
-{
-  "name": "query range",
-  "issue": "https://github.com/VictoriaMetrics/VictoriaMetrics/issues/5553",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"bar\"}],\"samples\":[{\"value\":1,\"timestamp\":\"{TIME_MS-60s}\"}, {\"value\":2,\"timestamp\":\"{TIME_MS-120s}\"}, {\"value\":1,\"timestamp\":\"{TIME_MS-180s}\"}]}]"],
-  "query": ["/api/v1/query_range?query=bar&step=30s&start={TIME_MS-180s}"],
-  "result_query": {
-      "status": "success",
-      "data":{
-        "resultType":"matrix",
-        "result":[
-          {
-            "metric":{"__name__":"bar"},
-            "values":[["{TIME_S-180s}", "1"],["{TIME_S-150s}", "1"],["{TIME_S-120s}", "2"],["{TIME_S-90s}", "2"], ["{TIME_S-60s}", "1"], ["{TIME_S-30s}", "1"], ["{TIME_S}", "1"]]
-          }
-        ]
-      }
-    }
-}

app/victoria-metrics/testdata/prometheus/with_extra_labels.json

@@ -1,9 +0,0 @@
-{
-  "name": "basic_insertion_with_extra_labels",
-  "insert_query": "?extra_label=job=prom-test&extra_label=baz=bar",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.foobar\"},{\"name\":\"baz\",\"value\":\"qux\"}],\"samples\":[{\"value\":100000,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/export?match={__name__!=''}"],
-  "result_metrics": [
-    {"metric":{"__name__":"prometheus.foobar","baz":"bar","job": "prom-test"},"values":[100000], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/victoria-metrics/testdata/prometheus/with_request_extra_filter.json

@@ -1,8 +0,0 @@
-{
-  "name": "basic_select_with_extra_labels",
-  "data": ["[{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.tenant.limits\"},{\"name\":\"baz\",\"value\":\"qux\"},{\"name\":\"tenant\",\"value\":\"dev\"}],\"samples\":[{\"value\":100000,\"timestamp\":\"{TIME_MS}\"}]},{\"labels\":[{\"name\":\"__name__\",\"value\":\"prometheus.up\"},{\"name\":\"baz\",\"value\":\"qux\"}],\"samples\":[{\"value\":100000,\"timestamp\":\"{TIME_MS}\"}]}]"],
-  "query": ["/api/v1/export?match={__name__!=''}&extra_label=tenant=dev"],
-  "result_metrics": [
-    {"metric":{"__name__":"prometheus.tenant.limits","baz":"qux","tenant": "dev"},"values":[100000], "timestamps": ["{TIME_MS}"]}
-  ]
-}

app/vlinsert/elasticsearch/elasticsearch.go

@@ -102,7 +102,7 @@ func RequestHandler(path string, w http.ResponseWriter, r *http.Request) bool {
 		lmp := cp.NewLogMessageProcessor("elasticsearch_bulk", true)
 		encoding := r.Header.Get("Content-Encoding")
 		streamName := fmt.Sprintf("remoteAddr=%s, requestURI=%q", httpserver.GetQuotedRemoteAddr(r), r.RequestURI)
-		n, err := readBulkRequest(streamName, r.Body, encoding, cp.TimeField, cp.MsgFields, lmp)
+		n, err := readBulkRequest(streamName, r.Body, encoding, cp.TimeFields, cp.MsgFields, lmp)
 		lmp.MustClose()
 		if err != nil {
 			logger.Warnf("cannot decode log message #%d in /_bulk request: %s, stream fields: %s", n, err, cp.StreamFields)
@@ -131,7 +131,7 @@ var (
 	bulkRequestDuration = metrics.NewHistogram(`vl_http_request_duration_seconds{path="/insert/elasticsearch/_bulk"}`)
 )
 
-func readBulkRequest(streamName string, r io.Reader, encoding string, timeField string, msgFields []string, lmp insertutil.LogMessageProcessor) (int, error) {
+func readBulkRequest(streamName string, r io.Reader, encoding string, timeFields, msgFields []string, lmp insertutil.LogMessageProcessor) (int, error) {
 	// See https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html
 
 	reader, err := protoparserutil.GetUncompressedReader(r, encoding)
@@ -147,7 +147,7 @@ func readBulkRequest(streamName string, r io.Reader, encoding string, timeField
 
 	n := 0
 	for {
-		ok, err := readBulkLine(lr, timeField, msgFields, lmp)
+		ok, err := readBulkLine(lr, timeFields, msgFields, lmp)
 		wcr.DecConcurrency()
 		if err != nil || !ok {
 			return n, err
@@ -156,7 +156,7 @@ func readBulkRequest(streamName string, r io.Reader, encoding string, timeField
 	}
 }
 
-func readBulkLine(lr *insertutil.LineReader, timeField string, msgFields []string, lmp insertutil.LogMessageProcessor) (bool, error) {
+func readBulkLine(lr *insertutil.LineReader, timeFields, msgFields []string, lmp insertutil.LogMessageProcessor) (bool, error) {
 	var line []byte
 
 	// Read the command, must be "create" or "index"
@@ -190,7 +190,7 @@ func readBulkLine(lr *insertutil.LineReader, timeField string, msgFields []strin
 		return false, fmt.Errorf("cannot parse json-encoded log entry: %w", err)
 	}
 
-	ts, err := extractTimestampFromFields(timeField, p.Fields)
+	ts, err := extractTimestampFromFields(timeFields, p.Fields)
 	if err != nil {
 		return false, fmt.Errorf("cannot parse timestamp: %w", err)
 	}
@@ -204,18 +204,20 @@ func readBulkLine(lr *insertutil.LineReader, timeField string, msgFields []strin
 	return true, nil
 }
 
-func extractTimestampFromFields(timeField string, fields []logstorage.Field) (int64, error) {
-	for i := range fields {
-		f := &fields[i]
-		if f.Name != timeField {
-			continue
+func extractTimestampFromFields(timeFields []string, fields []logstorage.Field) (int64, error) {
+	for _, timeField := range timeFields {
+		for i := range fields {
+			f := &fields[i]
+			if f.Name != timeField {
+				continue
+			}
+			timestamp, err := parseElasticsearchTimestamp(f.Value)
+			if err != nil {
+				return 0, err
+			}
+			f.Value = ""
+			return timestamp, nil
 		}
-		timestamp, err := parseElasticsearchTimestamp(f.Value)
-		if err != nil {
-			return 0, err
-		}
-		f.Value = ""
-		return timestamp, nil
 	}
 	return 0, nil
 }

app/vlinsert/elasticsearch/elasticsearch_test.go

@@ -19,7 +19,7 @@ func TestReadBulkRequest_Failure(t *testing.T) {
 
 		tlp := &insertutil.TestLogMessageProcessor{}
 		r := bytes.NewBufferString(data)
-		rows, err := readBulkRequest("test", r, "", "_time", []string{"_msg"}, tlp)
+		rows, err := readBulkRequest("test", r, "", []string{"_time"}, []string{"_msg"}, tlp)
 		if err == nil {
 			t.Fatalf("expecting non-empty error")
 		}
@@ -40,12 +40,13 @@ func TestReadBulkRequest_Success(t *testing.T) {
 	f := func(data, encoding, timeField, msgField string, timestampsExpected []int64, resultExpected string) {
 		t.Helper()
 
+		timeFields := []string{"non_existing_foo", timeField, "non_existing_bar"}
 		msgFields := []string{"non_existing_foo", msgField, "non_exiting_bar"}
 		tlp := &insertutil.TestLogMessageProcessor{}
 
 		// Read the request without compression
 		r := bytes.NewBufferString(data)
-		rows, err := readBulkRequest("test", r, "", timeField, msgFields, tlp)
+		rows, err := readBulkRequest("test", r, "", timeFields, msgFields, tlp)
 		if err != nil {
 			t.Fatalf("unexpected error: %s", err)
 		}
@@ -62,7 +63,7 @@ func TestReadBulkRequest_Success(t *testing.T) {
 			data = compressData(data, encoding)
 		}
 		r = bytes.NewBufferString(data)
-		rows, err = readBulkRequest("test", r, encoding, timeField, msgFields, tlp)
+		rows, err = readBulkRequest("test", r, encoding, timeFields, msgFields, tlp)
 		if err != nil {
 			t.Fatalf("unexpected error: %s", err)
 		}
@@ -111,7 +112,7 @@ func compressData(s string, encoding string) string {
 	case "zstd":
 		zw, _ = zstd.NewWriter(&bb)
 	case "snappy":
-		zw = snappy.NewBufferedWriter(&bb)
+		return string(snappy.Encode(nil, []byte(s)))
 	case "deflate":
 		zw = zlib.NewWriter(&bb)
 	default:

app/vlinsert/elasticsearch/elasticsearch_timing_test.go

@@ -40,7 +40,7 @@ func benchmarkReadBulkRequest(b *testing.B, encoding string) {
 	}
 	dataBytes := bytesutil.ToUnsafeBytes(data)
 
-	timeField := "@timestamp"
+	timeFields := []string{"@timestamp"}
 	msgFields := []string{"message"}
 	blp := &insertutil.BenchmarkLogMessageProcessor{}
 
@@ -50,7 +50,7 @@ func benchmarkReadBulkRequest(b *testing.B, encoding string) {
 		r := &bytes.Reader{}
 		for pb.Next() {
 			r.Reset(dataBytes)
-			_, err := readBulkRequest("test", r, encoding, timeField, msgFields, blp)
+			_, err := readBulkRequest("test", r, encoding, timeFields, msgFields, blp)
 			if err != nil {
 				panic(fmt.Errorf("unexpected error: %w", err))
 			}

app/vlinsert/insertutil/common_params.go

@@ -28,12 +28,13 @@ var (
 //
 // See https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters
 type CommonParams struct {
-	TenantID     logstorage.TenantID
-	TimeField    string
-	MsgFields    []string
-	StreamFields []string
-	IgnoreFields []string
-	ExtraFields  []logstorage.Field
+	TenantID         logstorage.TenantID
+	TimeFields       []string
+	MsgFields        []string
+	StreamFields     []string
+	IgnoreFields     []string
+	DecolorizeFields []string
+	ExtraFields      []logstorage.Field
 
 	Debug           bool
 	DebugRequestURI string
@@ -48,14 +49,15 @@ func GetCommonParams(r *http.Request) (*CommonParams, error) {
 		return nil, err
 	}
 
-	timeField := "_time"
-	if tf := httputil.GetRequestValue(r, "_time_field", "VL-Time-Field"); tf != "" {
-		timeField = tf
+	timeFields := []string{"_time"}
+	if tfs := httputil.GetArray(r, "_time_field", "VL-Time-Field"); len(tfs) > 0 {
+		timeFields = tfs
 	}
 
 	msgFields := httputil.GetArray(r, "_msg_field", "VL-Msg-Field")
 	streamFields := httputil.GetArray(r, "_stream_fields", "VL-Stream-Fields")
 	ignoreFields := httputil.GetArray(r, "ignore_fields", "VL-Ignore-Fields")
+	decolorizeFields := httputil.GetArray(r, "decolorize_fields", "VL-Decolorize-Fields")
 
 	extraFields, err := getExtraFields(r)
 	if err != nil {
@@ -77,15 +79,16 @@ func GetCommonParams(r *http.Request) (*CommonParams, error) {
 	}
 
 	cp := &CommonParams{
-		TenantID:        tenantID,
-		TimeField:       timeField,
-		MsgFields:       msgFields,
-		StreamFields:    streamFields,
-		IgnoreFields:    ignoreFields,
-		ExtraFields:     extraFields,
-		Debug:           debug,
-		DebugRequestURI: debugRequestURI,
-		DebugRemoteAddr: debugRemoteAddr,
+		TenantID:         tenantID,
+		TimeFields:       timeFields,
+		MsgFields:        msgFields,
+		StreamFields:     streamFields,
+		IgnoreFields:     ignoreFields,
+		DecolorizeFields: decolorizeFields,
+		ExtraFields:      extraFields,
+		Debug:            debug,
+		DebugRequestURI:  debugRequestURI,
+		DebugRemoteAddr:  debugRemoteAddr,
 	}
 
 	return cp, nil
@@ -112,7 +115,7 @@ func getExtraFields(r *http.Request) ([]logstorage.Field, error) {
 }
 
 // GetCommonParamsForSyslog returns common params needed for parsing syslog messages and storing them to the given tenantID.
-func GetCommonParamsForSyslog(tenantID logstorage.TenantID, streamFields, ignoreFields []string, extraFields []logstorage.Field) *CommonParams {
+func GetCommonParamsForSyslog(tenantID logstorage.TenantID, streamFields, ignoreFields, decolorizeFields []string, extraFields []logstorage.Field) *CommonParams {
 	// See https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe
 	if streamFields == nil {
 		streamFields = []string{
@@ -122,14 +125,17 @@ func GetCommonParamsForSyslog(tenantID logstorage.TenantID, streamFields, ignore
 		}
 	}
 	cp := &CommonParams{
-		TenantID:  tenantID,
-		TimeField: "timestamp",
+		TenantID: tenantID,
+		TimeFields: []string{
+			"timestamp",
+		},
 		MsgFields: []string{
 			"message",
 		},
-		StreamFields: streamFields,
-		IgnoreFields: ignoreFields,
-		ExtraFields:  extraFields,
+		StreamFields:     streamFields,
+		IgnoreFields:     ignoreFields,
+		DecolorizeFields: decolorizeFields,
+		ExtraFields:      extraFields,
 	}
 
 	return cp
@@ -276,7 +282,7 @@ func (lmp *logMessageProcessor) MustClose() {
 //
 // MustClose() must be called on the returned LogMessageProcessor when it is no longer needed.
 func (cp *CommonParams) NewLogMessageProcessor(protocolName string, isStreamMode bool) LogMessageProcessor {
-	lr := logstorage.GetLogRows(cp.StreamFields, cp.IgnoreFields, cp.ExtraFields, *defaultMsgValue)
+	lr := logstorage.GetLogRows(cp.StreamFields, cp.IgnoreFields, cp.DecolorizeFields, cp.ExtraFields, *defaultMsgValue)
 	rowsIngestedTotal := metrics.GetOrCreateCounter(fmt.Sprintf("vl_rows_ingested_total{type=%q}", protocolName))
 	bytesIngestedTotal := metrics.GetOrCreateCounter(fmt.Sprintf("vl_bytes_ingested_total{type=%q}", protocolName))
 	lmp := &logMessageProcessor{

app/vlinsert/insertutil/timestamp.go

@@ -10,27 +10,29 @@ import (
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logstorage"
 )
 
-// ExtractTimestampFromFields extracts timestamp in nanoseconds from the field with the name timeField at fields.
+// ExtractTimestampFromFields extracts timestamp in nanoseconds from the first field the name from timeFields at fields.
 //
-// The value for the timeField is set to empty string after returning from the function,
+// The value for the corresponding timeFields is set to empty string after returning from the function,
 // so it could be ignored during data ingestion.
 //
 // The current timestamp is returned if fields do not contain a field with timeField name or if the timeField value is empty.
-func ExtractTimestampFromFields(timeField string, fields []logstorage.Field) (int64, error) {
-	for i := range fields {
-		f := &fields[i]
-		if f.Name != timeField {
-			continue
+func ExtractTimestampFromFields(timeFields []string, fields []logstorage.Field) (int64, error) {
+	for _, timeField := range timeFields {
+		for i := range fields {
+			f := &fields[i]
+			if f.Name != timeField {
+				continue
+			}
+			nsecs, err := parseTimestamp(f.Value)
+			if err != nil {
+				return 0, fmt.Errorf("cannot parse timestamp from field %q: %s", f.Name, err)
+			}
+			f.Value = ""
+			if nsecs == 0 {
+				nsecs = time.Now().UnixNano()
+			}
+			return nsecs, nil
 		}
-		nsecs, err := parseTimestamp(f.Value)
-		if err != nil {
-			return 0, fmt.Errorf("cannot parse timestamp from field %q: %s", timeField, err)
-		}
-		f.Value = ""
-		if nsecs == 0 {
-			nsecs = time.Now().UnixNano()
-		}
-		return nsecs, nil
 	}
 	return time.Now().UnixNano(), nil
 }

app/vlinsert/insertutil/timestamp_test.go

@@ -67,7 +67,7 @@ func TestExtractTimestampFromFields_Success(t *testing.T) {
 	f := func(timeField string, fields []logstorage.Field, nsecsExpected int64) {
 		t.Helper()
 
-		nsecs, err := ExtractTimestampFromFields(timeField, fields)
+		nsecs, err := ExtractTimestampFromFields([]string{timeField}, fields)
 		if err != nil {
 			t.Fatalf("unexpected error: %s", err)
 		}
@@ -140,7 +140,7 @@ func TestExtractTimestampFromFields_Error(t *testing.T) {
 		fields := []logstorage.Field{
 			{Name: "time", Value: s},
 		}
-		nsecs, err := ExtractTimestampFromFields("time", fields)
+		nsecs, err := ExtractTimestampFromFields([]string{"time"}, fields)
 		if err == nil {
 			t.Fatalf("expecting non-nil error")
 		}

app/vlinsert/journald/journald.go

@@ -53,8 +53,8 @@ func getCommonParams(r *http.Request) (*insertutil.CommonParams, error) {
 		}
 		cp.TenantID = tenantID
 	}
-	if cp.TimeField != "" {
-		cp.TimeField = *journaldTimeField
+	if len(cp.TimeFields) == 0 {
+		cp.TimeFields = []string{*journaldTimeField}
 	}
 	if len(cp.StreamFields) == 0 {
 		cp.StreamFields = *journaldStreamFields
@@ -207,7 +207,7 @@ func parseJournaldRequest(data []byte, lmp insertutil.LogMessageProcessor, cp *i
 		if !allowedJournaldEntryNameChars.MatchString(name) {
 			return fmt.Errorf("journald entry name should consist of `A-Z0-9_` characters and must start from non-digit symbol")
 		}
-		if name == cp.TimeField {
+		if slices.Contains(cp.TimeFields, name) {
 			n, err := strconv.ParseInt(value, 10, 64)
 			if err != nil {
 				return fmt.Errorf("failed to parse Journald timestamp, %w", err)

app/vlinsert/journald/journald_test.go

@@ -11,8 +11,8 @@ func TestPushJournaldOk(t *testing.T) {
 		t.Helper()
 		tlp := &insertutil.TestLogMessageProcessor{}
 		cp := &insertutil.CommonParams{
-			TimeField: "__REALTIME_TIMESTAMP",
-			MsgFields: []string{"MESSAGE"},
+			TimeFields: []string{"__REALTIME_TIMESTAMP"},
+			MsgFields:  []string{"MESSAGE"},
 		}
 		if err := parseJournaldRequest([]byte(src), tlp, cp); err != nil {
 			t.Fatalf("unexpected error: %s", err)
@@ -46,8 +46,8 @@ func TestPushJournald_Failure(t *testing.T) {
 		t.Helper()
 		tlp := &insertutil.TestLogMessageProcessor{}
 		cp := &insertutil.CommonParams{
-			TimeField: "__REALTIME_TIMESTAMP",
-			MsgFields: []string{"MESSAGE"},
+			TimeFields: []string{"__REALTIME_TIMESTAMP"},
+			MsgFields:  []string{"MESSAGE"},
 		}
 		if err := parseJournaldRequest([]byte(data), tlp, cp); err == nil {
 			t.Fatalf("expected non nil error")

app/vlinsert/jsonline/jsonline.go

@@ -48,34 +48,49 @@ func RequestHandler(w http.ResponseWriter, r *http.Request) {
 
 	lmp := cp.NewLogMessageProcessor("jsonline", true)
 	streamName := fmt.Sprintf("remoteAddr=%s, requestURI=%q", httpserver.GetQuotedRemoteAddr(r), r.RequestURI)
-	processStreamInternal(streamName, reader, cp.TimeField, cp.MsgFields, lmp)
+	err = processStreamInternal(streamName, reader, cp.TimeFields, cp.MsgFields, lmp)
 	lmp.MustClose()
+	if err != nil {
+		httpserver.Errorf(w, r, "cannot process jsonline request; error: %s", err)
+		return
+	}
 
 	requestDuration.UpdateDuration(startTime)
 }
 
-func processStreamInternal(streamName string, r io.Reader, timeField string, msgFields []string, lmp insertutil.LogMessageProcessor) {
+func processStreamInternal(streamName string, r io.Reader, timeFields, msgFields []string, lmp insertutil.LogMessageProcessor) error {
 	wcr := writeconcurrencylimiter.GetReader(r)
 	defer writeconcurrencylimiter.PutReader(wcr)
 
 	lr := insertutil.NewLineReader(streamName, wcr)
 
 	n := 0
+	errors := 0
+	var lastError error
 	for {
-		ok, err := readLine(lr, timeField, msgFields, lmp)
+		ok, err := readLine(lr, timeFields, msgFields, lmp)
 		wcr.DecConcurrency()
 		if err != nil {
-			errorsTotal.Inc()
+			lastError = err
+			errors++
 			logger.Warnf("jsonline: cannot read line #%d in /jsonline request: %s", n, err)
 		}
 		if !ok {
-			return
+			break
 		}
 		n++
 	}
+	errorsTotal.Add(errors)
+
+	if errors > 0 && n == errors {
+		// Return an error if no logs were processed and there were errors
+		return lastError
+	}
+
+	return nil
 }
 
-func readLine(lr *insertutil.LineReader, timeField string, msgFields []string, lmp insertutil.LogMessageProcessor) (bool, error) {
+func readLine(lr *insertutil.LineReader, timeFields, msgFields []string, lmp insertutil.LogMessageProcessor) (bool, error) {
 	var line []byte
 	for len(line) == 0 {
 		if !lr.NextLine() {
@@ -89,11 +104,11 @@ func readLine(lr *insertutil.LineReader, timeField string, msgFields []string, l
 	defer logstorage.PutJSONParser(p)
 
 	if err := p.ParseLogMessage(line); err != nil {
-		return true, fmt.Errorf("cannot parse json-encoded line: %w; line contents: %q", err, line)
+		return true, fmt.Errorf("%s; line contents: %q", err, line)
 	}
-	ts, err := insertutil.ExtractTimestampFromFields(timeField, p.Fields)
+	ts, err := insertutil.ExtractTimestampFromFields(timeFields, p.Fields)
 	if err != nil {
-		return true, fmt.Errorf("cannot get timestamp from json-encoded line: %w; line contents: %q", err, line)
+		return true, fmt.Errorf("%s; line contents: %q", err, line)
 	}
 	logstorage.RenameField(p.Fields, msgFields, "_msg")
 	lmp.AddRow(ts, p.Fields, nil)

app/vlinsert/jsonline/jsonline_test.go

@@ -2,19 +2,23 @@ package jsonline
 
 import (
 	"bytes"
+	"strings"
 	"testing"
 
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vlinsert/insertutil"
 )
 
-func TestProcessStreamInternal(t *testing.T) {
+func TestProcessStreamInternalSuccess(t *testing.T) {
 	f := func(data, timeField, msgField string, timestampsExpected []int64, resultExpected string) {
 		t.Helper()
 
+		timeFields := []string{timeField}
 		msgFields := []string{msgField}
 		tlp := &insertutil.TestLogMessageProcessor{}
 		r := bytes.NewBufferString(data)
-		processStreamInternal("test", r, timeField, msgFields, tlp)
+		if err := processStreamInternal("test", r, timeFields, msgFields, tlp); err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
 
 		if err := tlp.Verify(timestampsExpected, resultExpected); err != nil {
 			t.Fatal(err)
@@ -44,22 +48,6 @@ func TestProcessStreamInternal(t *testing.T) {
 {"message":"baz"}`
 	f(data, timeField, msgField, timestampsExpected, resultExpected)
 
-	// invalid json
-	data = "foobar"
-	timeField = "@timestamp"
-	msgField = "aaa"
-	timestampsExpected = nil
-	resultExpected = ``
-	f(data, timeField, msgField, timestampsExpected, resultExpected)
-
-	// invalid timestamp field
-	data = `{"time":"foobar"}`
-	timeField = "time"
-	msgField = "abc"
-	timestampsExpected = nil
-	resultExpected = ``
-	f(data, timeField, msgField, timestampsExpected, resultExpected)
-
 	// invalid lines among valid lines
 	data = `
 dsfodmasd
@@ -77,3 +65,33 @@ asbsdf
 {"_msg":"baz"}`
 	f(data, timeField, msgField, timestampsExpected, resultExpected)
 }
+
+func TestProcessStreamInternalFailure(t *testing.T) {
+	f := func(data string) {
+		t.Helper()
+
+		tlp := &insertutil.TestLogMessageProcessor{}
+		r := strings.NewReader(data)
+		if err := processStreamInternal("test", r, []string{"time"}, nil, tlp); err == nil {
+			t.Fatalf("expected error, got nil")
+		}
+
+		if err := tlp.Verify(nil, ""); err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+	}
+
+	// invalid json
+	f("foobar")
+
+	f(`foo
+bar`)
+
+	f(`
+foo
+
+`)
+
+	// invalid timestamp field
+	f(`{"time":"foobar"}`)
+}

app/vlinsert/opentelemetry/opentelemetry_test.go

@@ -41,6 +41,26 @@ func TestPushProtoOk(t *testing.T) {
 		`{"_msg":"log-line-message","severity":"Trace"}`,
 	)
 
+	// severities mapping
+	f([]pb.ResourceLogs{
+		{
+			ScopeLogs: []pb.ScopeLogs{
+				{
+					LogRecords: []pb.LogRecord{
+						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1234, SeverityNumber: 1, Body: pb.AnyValue{StringValue: ptrTo("log-line-message")}},
+						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1234, SeverityNumber: 13, Body: pb.AnyValue{StringValue: ptrTo("log-line-message")}},
+						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1234, SeverityNumber: 24, Body: pb.AnyValue{StringValue: ptrTo("log-line-message")}},
+					},
+				},
+			},
+		},
+	},
+		[]int64{1234, 1234, 1234},
+		`{"_msg":"log-line-message","severity":"Trace"}
+{"_msg":"log-line-message","severity":"Warn"}
+{"_msg":"log-line-message","severity":"Fatal4"}`,
+	)
+
 	// multi-line with resource attributes
 	f([]pb.ResourceLogs{
 		{
@@ -60,7 +80,7 @@ func TestPushProtoOk(t *testing.T) {
 				{
 					LogRecords: []pb.LogRecord{
 						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1234, SeverityNumber: 1, Body: pb.AnyValue{StringValue: ptrTo("log-line-message")}},
-						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1235, SeverityNumber: 21, Body: pb.AnyValue{StringValue: ptrTo("log-line-message-msg-2")}},
+						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1235, SeverityNumber: 25, Body: pb.AnyValue{StringValue: ptrTo("log-line-message-msg-2")}},
 						{Attributes: []*pb.KeyValue{}, TimeUnixNano: 1236, SeverityNumber: -1, Body: pb.AnyValue{StringValue: ptrTo("log-line-message-msg-2")}},
 					},
 				},

app/vlinsert/syslog/syslog.go

@@ -45,6 +45,11 @@ var (
 	ignoreFieldsUDP = flagutil.NewArrayString("syslog.ignoreFields.udp", "Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.udp. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields`)
 
+	decolorizeFieldsTCP = flagutil.NewArrayString("syslog.decolorizeFields.tcp", "Fields to remove ANSI color codes across logs ingested via the corresponding -syslog.listenAddr.tcp. "+
+		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#decolorizing-fields`)
+	decolorizeFieldsUDP = flagutil.NewArrayString("syslog.decolorizeFields.udp", "Fields to remove ANSI color codes across logs ingested via the corresponding -syslog.listenAddr.udp. "+
+		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#decolorizing-fields`)
+
 	extraFieldsTCP = flagutil.NewArrayString("syslog.extraFields.tcp", "Fields to add to logs ingested via the corresponding -syslog.listenAddr.tcp. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields`)
 	extraFieldsUDP = flagutil.NewArrayString("syslog.extraFields.udp", "Fields to add to logs ingested via the corresponding -syslog.listenAddr.udp. "+
@@ -188,6 +193,12 @@ func runUDPListener(addr string, argIdx int) {
 		logger.Fatalf("cannot parse -syslog.ignoreFields.udp=%q for -syslog.listenAddr.udp=%q: %s", ignoreFieldsStr, addr, err)
 	}
 
+	decolorizeFieldsStr := decolorizeFieldsUDP.GetOptionalArg(argIdx)
+	decolorizeFields, err := parseFieldsList(decolorizeFieldsStr)
+	if err != nil {
+		logger.Fatalf("cannot parse -syslog.decolorizeFields.udp=%q for -syslog.listenAddr.udp=%q: %s", decolorizeFieldsStr, addr, err)
+	}
+
 	extraFieldsStr := extraFieldsUDP.GetOptionalArg(argIdx)
 	extraFields, err := parseExtraFields(extraFieldsStr)
 	if err != nil {
@@ -196,7 +207,7 @@ func runUDPListener(addr string, argIdx int) {
 
 	doneCh := make(chan struct{})
 	go func() {
-		serveUDP(ln, tenantID, compressMethod, useLocalTimestamp, streamFields, ignoreFields, extraFields)
+		serveUDP(ln, tenantID, compressMethod, useLocalTimestamp, streamFields, ignoreFields, decolorizeFields, extraFields)
 		close(doneCh)
 	}()
 
@@ -249,6 +260,12 @@ func runTCPListener(addr string, argIdx int) {
 		logger.Fatalf("cannot parse -syslog.ignoreFields.tcp=%q for -syslog.listenAddr.tcp=%q: %s", ignoreFieldsStr, addr, err)
 	}
 
+	decolorizeFieldsStr := decolorizeFieldsTCP.GetOptionalArg(argIdx)
+	decolorizeFields, err := parseFieldsList(decolorizeFieldsStr)
+	if err != nil {
+		logger.Fatalf("cannot parse -syslog.decolorizeFields.tcp=%q for -syslog.listenAddr.tcp=%q: %s", decolorizeFieldsStr, addr, err)
+	}
+
 	extraFieldsStr := extraFieldsTCP.GetOptionalArg(argIdx)
 	extraFields, err := parseExtraFields(extraFieldsStr)
 	if err != nil {
@@ -257,7 +274,7 @@ func runTCPListener(addr string, argIdx int) {
 
 	doneCh := make(chan struct{})
 	go func() {
-		serveTCP(ln, tenantID, compressMethod, useLocalTimestamp, streamFields, ignoreFields, extraFields)
+		serveTCP(ln, tenantID, compressMethod, useLocalTimestamp, streamFields, ignoreFields, decolorizeFields, extraFields)
 		close(doneCh)
 	}()
 
@@ -279,7 +296,7 @@ func checkCompressMethod(compressMethod, addr, protocol string) {
 	}
 }
 
-func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string, useLocalTimestamp bool, streamFields, ignoreFields []string, extraFields []logstorage.Field) {
+func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string, useLocalTimestamp bool, streamFields, ignoreFields, decolorizeFields []string, extraFields []logstorage.Field) {
 	gomaxprocs := cgroup.AvailableCPUs()
 	var wg sync.WaitGroup
 	localAddr := ln.LocalAddr()
@@ -287,7 +304,7 @@ func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string,
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			cp := insertutil.GetCommonParamsForSyslog(tenantID, streamFields, ignoreFields, extraFields)
+			cp := insertutil.GetCommonParamsForSyslog(tenantID, streamFields, ignoreFields, decolorizeFields, extraFields)
 			var bb bytesutil.ByteBuffer
 			bb.B = bytesutil.ResizeNoCopyNoOverallocate(bb.B, 64*1024)
 			for {
@@ -321,7 +338,7 @@ func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string,
 	wg.Wait()
 }
 
-func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, useLocalTimestamp bool, streamFields, ignoreFields []string, extraFields []logstorage.Field) {
+func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, useLocalTimestamp bool, streamFields, ignoreFields, decolorizeFields []string, extraFields []logstorage.Field) {
 	var cm ingestserver.ConnsMap
 	cm.Init("syslog")
 
@@ -351,7 +368,7 @@ func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, us
 
 		wg.Add(1)
 		go func() {
-			cp := insertutil.GetCommonParamsForSyslog(tenantID, streamFields, ignoreFields, extraFields)
+			cp := insertutil.GetCommonParamsForSyslog(tenantID, streamFields, ignoreFields, decolorizeFields, extraFields)
 			if err := processStream("tcp", c, encoding, useLocalTimestamp, cp); err != nil {
 				logger.Errorf("syslog: cannot process TCP data at %q: %s", addr, err)
 			}
@@ -535,7 +552,7 @@ func processLine(line []byte, currentYear int, timezone *time.Location, useLocal
 	if useLocalTimestamp {
 		ts = time.Now().UnixNano()
 	} else {
-		nsecs, err := insertutil.ExtractTimestampFromFields("timestamp", p.Fields)
+		nsecs, err := insertutil.ExtractTimestampFromFields(timeFields, p.Fields)
 		if err != nil {
 			return fmt.Errorf("cannot get timestamp from syslog line %q: %w", line, err)
 		}
@@ -548,6 +565,7 @@ func processLine(line []byte, currentYear int, timezone *time.Location, useLocal
 	return nil
 }
 
+var timeFields = []string{"timestamp"}
 var msgFields = []string{"message"}
 
 var (

app/vlogscli/less_wrapper.go

@@ -17,7 +17,7 @@ func isTerminal() bool {
 	return isatty.IsTerminal(os.Stdout.Fd()) && isatty.IsTerminal(os.Stderr.Fd())
 }
 
-func readWithLess(r io.Reader, wrapLongLines bool) error {
+func readWithLess(r io.Reader, disableColors, wrapLongLines bool) error {
 	if !isTerminal() {
 		// Just write everything to stdout if no terminal is available.
 		_, err := io.Copy(os.Stdout, r)
@@ -49,6 +49,9 @@ func readWithLess(r io.Reader, wrapLongLines bool) error {
 		return fmt.Errorf("cannot find 'less' command: %w", err)
 	}
 	opts := []string{"less", "-F", "-X"}
+	if !disableColors {
+		opts = append(opts, "-R")
+	}
 	if !wrapLongLines {
 		opts = append(opts, "-S")
 	}

app/vlogscli/main.go

@@ -91,6 +91,7 @@ func runReadlineLoop(rl *readline.Instance, incompleteLine *string) {
 	}
 
 	outputMode := outputModeJSONMultiline
+	disableColors := true
 	wrapLongLines := false
 	s := ""
 	for {
@@ -100,7 +101,7 @@ func runReadlineLoop(rl *readline.Instance, incompleteLine *string) {
 			case io.EOF:
 				if s != "" {
 					// This is non-interactive query execution.
-					executeQuery(context.Background(), rl, s, outputMode, wrapLongLines)
+					executeQuery(context.Background(), rl, s, outputMode, disableColors, wrapLongLines)
 				}
 				return
 			case readline.ErrInterrupt:
@@ -176,6 +177,24 @@ func runReadlineLoop(rl *readline.Instance, incompleteLine *string) {
 			s = ""
 			continue
 		}
+		if s == `\disable_colors` {
+			if !disableColors {
+				disableColors = true
+				fmt.Fprintf(rl, `disabled colors in compact output mode; enter \enable_colors for enabling it`+"\n")
+			}
+			historyLines = pushToHistory(rl, historyLines, s)
+			s = ""
+			continue
+		}
+		if s == `\enable_colors` {
+			if disableColors {
+				disableColors = false
+				fmt.Fprintf(rl, `enabled colors in compact output mode; type \disable_colors for disabling it`+"\n")
+			}
+			historyLines = pushToHistory(rl, historyLines, s)
+			s = ""
+			continue
+		}
 		if line != "" && !strings.HasSuffix(line, ";") {
 			// Assume the query is incomplete and allow the user finishing the query on the next line
 			s += "\n"
@@ -185,7 +204,7 @@ func runReadlineLoop(rl *readline.Instance, incompleteLine *string) {
 
 		// Execute the query
 		ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
-		executeQuery(ctx, rl, s, outputMode, wrapLongLines)
+		executeQuery(ctx, rl, s, outputMode, disableColors, wrapLongLines)
 		cancel()
 
 		historyLines = pushToHistory(rl, historyLines, s)
@@ -273,13 +292,15 @@ func printCommandsHelp(w io.Writer) {
 \c - compact output mode
 \logfmt - logfmt output mode
 \wrap_long_lines - toggles wrapping long lines
+\enable_colors - enable ANSI colors in compact output mode
+\disable_colors - disable ANSI colors in compact output mode
 \tail <query> - live tail <query> results
 
 See https://docs.victoriametrics.com/victorialogs/querying/vlogscli/ for more details
 `)
 }
 
-func executeQuery(ctx context.Context, output io.Writer, qStr string, outputMode outputMode, wrapLongLines bool) {
+func executeQuery(ctx context.Context, output io.Writer, qStr string, outputMode outputMode, disableColors, wrapLongLines bool) {
 	if strings.HasPrefix(qStr, `\tail `) {
 		tailQuery(ctx, output, qStr, outputMode)
 		return
@@ -293,7 +314,7 @@ func executeQuery(ctx context.Context, output io.Writer, qStr string, outputMode
 		_ = respBody.Close()
 	}()
 
-	if err := readWithLess(respBody, wrapLongLines); err != nil {
+	if err := readWithLess(respBody, disableColors, wrapLongLines); err != nil {
 		fmt.Fprintf(output, "error when reading query response: %s\n", err)
 		return
 	}

app/vlogsgenerator/main.go

@@ -25,8 +25,8 @@ var (
 	addr    = flag.String("addr", "stdout", "HTTP address to push the generated logs to; if it is set to stdout, then logs are generated to stdout")
 	workers = flag.Int("workers", 1, "The number of workers to use to push logs to -addr")
 
-	start         = newTimeFlag("start", "-1d", "Generated logs start from this time; see https://docs.victoriametrics.com/#timestamp-formats")
-	end           = newTimeFlag("end", "0s", "Generated logs end at this time; see https://docs.victoriametrics.com/#timestamp-formats")
+	start         = newTimeFlag("start", "-1d", "Generated logs start from this time; see https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#timestamp-formats")
+	end           = newTimeFlag("end", "0s", "Generated logs end at this time; see https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#timestamp-formats")
 	activeStreams = flag.Int("activeStreams", 100, "The number of active log streams to generate; see https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields")
 	totalStreams  = flag.Int("totalStreams", 0, "The number of total log streams; if -totalStreams > -activeStreams, then some active streams are substituted with new streams "+
 		"during data generation")

app/vlselect/internalselect/internalselect.go

@@ -133,7 +133,7 @@ func processQueryRequest(ctx context.Context, w http.ResponseWriter, r *http.Req
 	}
 
 	// Send the remaining data
-	for _, bb := range bufs.GetSlice() {
+	for _, bb := range bufs.All() {
 		if err := sendBuf(bb); err != nil {
 			return err
 		}

app/vlselect/logsql/logsql.go

@@ -887,7 +887,7 @@ func ProcessQueryRequest(ctx context.Context, w http.ResponseWriter, r *http.Req
 		shard.sw = sw
 	}
 	defer func() {
-		shards := bwShards.GetSlice()
+		shards := bwShards.All()
 		for _, shard := range shards {
 			shard.FlushIgnoreErrors()
 		}
@@ -1157,20 +1157,22 @@ func parseCommonArgs(r *http.Request) (*logstorage.Query, []logstorage.TenantID,
 	}
 
 	// Parse optional extra_filters
-	extraFiltersStr := r.FormValue("extra_filters")
-	extraFilters, err := parseExtraFilters(extraFiltersStr)
-	if err != nil {
-		return nil, nil, err
+	for _, extraFiltersStr := range r.Form["extra_filters"] {
+		extraFilters, err := parseExtraFilters(extraFiltersStr)
+		if err != nil {
+			return nil, nil, err
+		}
+		q.AddExtraFilters(extraFilters)
 	}
-	q.AddExtraFilters(extraFilters)
 
 	// Parse optional extra_stream_filters
-	extraStreamFiltersStr := r.FormValue("extra_stream_filters")
-	extraStreamFilters, err := parseExtraStreamFilters(extraStreamFiltersStr)
-	if err != nil {
-		return nil, nil, err
+	for _, extraStreamFiltersStr := range r.Form["extra_stream_filters"] {
+		extraStreamFilters, err := parseExtraStreamFilters(extraStreamFiltersStr)
+		if err != nil {
+			return nil, nil, err
+		}
+		q.AddExtraFilters(extraStreamFilters)
 	}
-	q.AddExtraFilters(extraStreamFilters)
 
 	return q, tenantIDs, nil
 }

app/vlselect/vmui/index.html

@@ -35,10 +35,10 @@
   <meta property="og:title" content="UI for VictoriaLogs">
   <meta property="og:url" content="https://victoriametrics.com/products/victorialogs/">
   <meta property="og:description" content="Explore your log data with VictoriaLogs UI">
-  <script type="module" crossorigin src="./assets/index-BMcUMlYJ.js"></script>
-  <link rel="modulepreload" crossorigin href="./assets/vendor-BSp13qCn.js">
+  <script type="module" crossorigin src="./assets/index-DfcWONVQ.js"></script>
+  <link rel="modulepreload" crossorigin href="./assets/vendor-C-vZmbyg.js">
   <link rel="stylesheet" crossorigin href="./assets/vendor-D1GxaB_c.css">
-  <link rel="stylesheet" crossorigin href="./assets/index-sXHL6qTd.css">
+  <link rel="stylesheet" crossorigin href="./assets/index-Brup_hCI.css">
 </head>
 <body>
 <noscript>You need to enable JavaScript to run this app.</noscript>

app/vlstorage/main.go

@@ -41,7 +41,10 @@ var (
 	minFreeDiskSpaceBytes = flagutil.NewBytes("storage.minFreeDiskSpaceBytes", 10e6, "The minimum free disk space at -storageDataPath after which "+
 		"the storage stops accepting new data")
 
-	forceMergeAuthKey = flagutil.NewPassword("forceMergeAuthKey", "authKey, which must be passed in query string to /internal/force_merge pages. It overrides -httpAuth.*")
+	forceMergeAuthKey = flagutil.NewPassword("forceMergeAuthKey", "authKey, which must be passed in query string to /internal/force_merge . It overrides -httpAuth.* . "+
+		"See https://docs.victoriametrics.com/victorialogs/#forced-merge")
+	forceFlushAuthKey = flagutil.NewPassword("forceFlushAuthKey", "authKey, which must be passed in query string to /internal/force_flush . It overrides -httpAuth.* . "+
+		"See https://docs.victoriametrics.com/victorialogs/#forced-flush")
 
 	storageNodeAddrs = flagutil.NewArrayString("storageNode", "Comma-separated list of TCP addresses for storage nodes to route the ingested logs to and to send select queries to. "+
 		"If the list is empty, then the ingested logs are stored and queried locally from -storageDataPath")
@@ -203,8 +206,11 @@ func Stop() {
 // RequestHandler is a storage request handler.
 func RequestHandler(w http.ResponseWriter, r *http.Request) bool {
 	path := r.URL.Path
-	if path == "/internal/force_merge" {
+	switch path {
+	case "/internal/force_merge":
 		return processForceMerge(w, r)
+	case "/internal/force_flush":
+		return processForceFlush(w, r)
 	}
 	return false
 }
@@ -232,6 +238,21 @@ func processForceMerge(w http.ResponseWriter, r *http.Request) bool {
 	return true
 }
 
+func processForceFlush(w http.ResponseWriter, r *http.Request) bool {
+	if localStorage == nil {
+		// Force merge isn't supported by non-local storage
+		return false
+	}
+
+	if !httpserver.CheckAuthFlag(w, r, forceFlushAuthKey) {
+		return true
+	}
+
+	logger.Infof("flushing storage to make pending data available for reading")
+	localStorage.DebugFlush()
+	return true
+}
+
 // CanWriteData returns non-nil error if it cannot write data to vlstorage
 func CanWriteData() error {
 	if localStorage == nil {

app/vmagent/README.md

@@ -1,3 +1,3 @@
-See vmagent docs [here](https://docs.victoriametrics.com/vmagent/).
+See vmagent docs [here](https://docs.victoriametrics.com/victoriametrics/vmagent/).
 
-vmagent docs can be edited at [docs/vmagent.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/vmagent.md).
+vmagent docs can be edited at [docs/vmagent.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/victoriametrics/vmagent.md).

app/vmagent/main.go

@@ -165,7 +165,9 @@ func main() {
 
 	promscrape.Init(remotewrite.PushDropSamplesOnFailure)
 
-	go httpserver.Serve(listenAddrs, useProxyProtocol, requestHandler)
+	go httpserver.Serve(listenAddrs, requestHandler, httpserver.ServeOptions{
+		UseProxyProtocol: useProxyProtocol,
+	})
 	logger.Infof("started vmagent in %.3f seconds", time.Since(startTime).Seconds())
 
 	pushmetrics.Init()
@@ -242,7 +244,7 @@ func requestHandler(w http.ResponseWriter, r *http.Request) bool {
 		}
 		w.Header().Add("Content-Type", "text/html; charset=utf-8")
 		fmt.Fprintf(w, "<h2>vmagent</h2>")
-		fmt.Fprintf(w, "See docs at <a href='https://docs.victoriametrics.com/vmagent/'>https://docs.victoriametrics.com/vmagent/</a></br>")
+		fmt.Fprintf(w, "See docs at <a href='https://docs.victoriametrics.com/victoriametrics/vmagent/'>https://docs.victoriametrics.com/victoriametrics/vmagent/</a></br>")
 		fmt.Fprintf(w, "Useful endpoints:</br>")
 		httpserver.WriteAPIHelp(w, [][2]string{
 			{"targets", "status for discovered active targets"},
@@ -752,7 +754,7 @@ func usage() {
 	const s = `
 vmagent collects metrics data via popular data ingestion protocols and routes it to VictoriaMetrics.
 
-See the docs at https://docs.victoriametrics.com/vmagent/ .
+See the docs at https://docs.victoriametrics.com/victoriametrics/vmagent/ .
 `
 	flagutil.Usage(s)
 }

app/vmagent/multiarch/Dockerfile

@@ -9,4 +9,5 @@ COPY --from=certs /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certifica
 EXPOSE 8429
 ENTRYPOINT ["/vmagent-prod"]
 ARG TARGETARCH
-COPY vmagent-linux-${TARGETARCH}-prod ./vmagent-prod
+ARG BINARY_SUFFIX=non-existing
+COPY vmagent-linux-${TARGETARCH}-prod${BINARY_SUFFIX} ./vmagent-prod

app/vmagent/remotewrite/client.go

@@ -30,9 +30,9 @@ import (
 
 var (
 	forcePromProto = flagutil.NewArrayBool("remoteWrite.forcePromProto", "Whether to force Prometheus remote write protocol for sending data "+
-		"to the corresponding -remoteWrite.url . See https://docs.victoriametrics.com/vmagent/#victoriametrics-remote-write-protocol")
+		"to the corresponding -remoteWrite.url . See https://docs.victoriametrics.com/victoriametrics/vmagent/#victoriametrics-remote-write-protocol")
 	forceVMProto = flagutil.NewArrayBool("remoteWrite.forceVMProto", "Whether to force VictoriaMetrics remote write protocol for sending data "+
-		"to the corresponding -remoteWrite.url . See https://docs.victoriametrics.com/vmagent/#victoriametrics-remote-write-protocol")
+		"to the corresponding -remoteWrite.url . See https://docs.victoriametrics.com/victoriametrics/vmagent/#victoriametrics-remote-write-protocol")
 
 	rateLimit = flagutil.NewArrayInt("remoteWrite.rateLimit", 0, "Optional rate limit in bytes per second for data sent to the corresponding -remoteWrite.url. "+
 		"By default, the rate limit is disabled. It can be useful for limiting load on remote storage when big amounts of buffered data "+
@@ -418,7 +418,7 @@ again:
 		if retryDuration > maxRetryDuration {
 			retryDuration = maxRetryDuration
 		}
-		logger.Warnf("couldn't send a block with size %d bytes to %q: %s; re-sending the block in %.3f seconds",
+		remoteWriteRetryLogger.Warnf("couldn't send a block with size %d bytes to %q: %s; re-sending the block in %.3f seconds",
 			len(block), c.sanitizedURL, err, retryDuration.Seconds())
 		t := timerpool.Get(retryDuration)
 		select {
@@ -458,13 +458,13 @@ again:
 	} else if statusCode == 415 || statusCode == 400 {
 		if c.canDowngradeVMProto.Swap(false) {
 			logger.Infof("received unsupported media type or bad request from remote storage at %q. Downgrading protocol from VictoriaMetrics to Prometheus remote write for all future requests. "+
-				"See https://docs.victoriametrics.com/vmagent/#victoriametrics-remote-write-protocol", c.sanitizedURL)
+				"See https://docs.victoriametrics.com/victoriametrics/vmagent/#victoriametrics-remote-write-protocol", c.sanitizedURL)
 			c.useVMProto.Store(false)
 		}
 
 		if encoding.IsZstd(block) {
 			logger.Infof("received unsupported media type or bad request from remote storage at %q. Re-packing the block to Prometheus remote write and retrying."+
-				"See https://docs.victoriametrics.com/vmagent/#victoriametrics-remote-write-protocol", c.sanitizedURL)
+				"See https://docs.victoriametrics.com/victoriametrics/vmagent/#victoriametrics-remote-write-protocol", c.sanitizedURL)
 
 			block = mustRepackBlockFromZstdToSnappy(block)
 
@@ -509,6 +509,7 @@ again:
 }
 
 var remoteWriteRejectedLogger = logger.WithThrottler("remoteWriteRejected", 5*time.Second)
+var remoteWriteRetryLogger = logger.WithThrottler("remoteWriteRetry", 5*time.Second)
 
 // getRetryDuration returns retry duration.
 // retryAfterDuration has the highest priority.

app/vmagent/remotewrite/pendingseries.go

@@ -29,7 +29,7 @@ var (
 	maxRowsPerBlock      = flag.Int("remoteWrite.maxRowsPerBlock", 10000, "The maximum number of samples to send in each block to remote storage. Higher number may improve performance at the cost of the increased memory usage. See also -remoteWrite.maxBlockSize")
 	vmProtoCompressLevel = flag.Int("remoteWrite.vmProtoCompressLevel", 0, "The compression level for VictoriaMetrics remote write protocol. "+
 		"Higher values reduce network traffic at the cost of higher CPU usage. Negative values reduce CPU usage at the cost of increased network traffic. "+
-		"See https://docs.victoriametrics.com/vmagent/#victoriametrics-remote-write-protocol")
+		"See https://docs.victoriametrics.com/victoriametrics/vmagent/#victoriametrics-remote-write-protocol")
 )
 
 type pendingSeries struct {

app/vmagent/remotewrite/relabel.go

@@ -7,10 +7,13 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompbmarshal"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/promrelabel"
+
+	"github.com/VictoriaMetrics/metrics"
 )
 
 var (
@@ -19,10 +22,10 @@ var (
 	relabelConfigPathGlobal = flag.String("remoteWrite.relabelConfig", "", "Optional path to file with relabeling configs, which are applied "+
 		"to all the metrics before sending them to -remoteWrite.url. See also -remoteWrite.urlRelabelConfig. "+
 		"The path can point either to local file or to http url. "+
-		"See https://docs.victoriametrics.com/vmagent/#relabeling")
+		"See https://docs.victoriametrics.com/victoriametrics/vmagent/#relabeling")
 	relabelConfigPaths = flagutil.NewArrayString("remoteWrite.urlRelabelConfig", "Optional path to relabel configs for the corresponding -remoteWrite.url. "+
 		"See also -remoteWrite.relabelConfig. The path can point either to local file or to http url. "+
-		"See https://docs.victoriametrics.com/vmagent/#relabeling")
+		"See https://docs.victoriametrics.com/victoriametrics/vmagent/#relabeling")
 
 	usePromCompatibleNaming = flag.Bool("usePromCompatibleNaming", false, "Whether to replace characters unsupported by Prometheus with underscores "+
 		"in the ingested metric names and label names. For example, foo.bar{a.b='c'} is transformed into foo_bar{a_b='c'} during data ingestion if this flag is set. "+
@@ -31,12 +34,59 @@ var (
 
 var labelsGlobal []prompbmarshal.Label
 
+var (
+	relabelConfigReloads      *metrics.Counter
+	relabelConfigReloadErrors *metrics.Counter
+	relabelConfigSuccess      *metrics.Gauge
+	relabelConfigTimestamp    *metrics.Counter
+)
+
+func initRelabelMetrics() {
+	relabelConfigReloads = metrics.NewCounter(`vmagent_relabel_config_reloads_total`)
+	relabelConfigReloadErrors = metrics.NewCounter(`vmagent_relabel_config_reloads_errors_total`)
+	relabelConfigSuccess = metrics.NewGauge(`vmagent_relabel_config_last_reload_successful`, nil)
+	relabelConfigTimestamp = metrics.NewCounter(`vmagent_relabel_config_last_reload_success_timestamp_seconds`)
+}
+
 // CheckRelabelConfigs checks -remoteWrite.relabelConfig and -remoteWrite.urlRelabelConfig.
 func CheckRelabelConfigs() error {
 	_, err := loadRelabelConfigs()
 	return err
 }
 
+func initRelabelConfigs() {
+	rcs, err := loadRelabelConfigs()
+	if err != nil {
+		logger.Fatalf("cannot initialize relabel configs: %s", err)
+	}
+	allRelabelConfigs.Store(rcs)
+	if rcs.isSet() {
+		initRelabelMetrics()
+		relabelConfigSuccess.Set(1)
+		relabelConfigTimestamp.Set(fasttime.UnixTimestamp())
+	}
+}
+
+func reloadRelabelConfigs() {
+	rcs := allRelabelConfigs.Load()
+	if !rcs.isSet() {
+		return
+	}
+	relabelConfigReloads.Inc()
+	logger.Infof("reloading relabel configs pointed by -remoteWrite.relabelConfig and -remoteWrite.urlRelabelConfig")
+	rcs, err := loadRelabelConfigs()
+	if err != nil {
+		relabelConfigReloadErrors.Inc()
+		relabelConfigSuccess.Set(0)
+		logger.Errorf("cannot reload relabel configs; preserving the previous configs; error: %s", err)
+		return
+	}
+	allRelabelConfigs.Store(rcs)
+	relabelConfigSuccess.Set(1)
+	relabelConfigTimestamp.Set(fasttime.UnixTimestamp())
+	logger.Infof("successfully reloaded relabel configs")
+}
+
 func loadRelabelConfigs() (*relabelConfigs, error) {
 	var rcs relabelConfigs
 	if *relabelConfigPathGlobal != "" {
@@ -70,6 +120,21 @@ type relabelConfigs struct {
 	perURL []*promrelabel.ParsedConfigs
 }
 
+func (rcs *relabelConfigs) isSet() bool {
+	if rcs != nil {
+		return false
+	}
+	if rcs.global.Len() > 0 {
+		return true
+	}
+	for _, pc := range rcs.perURL {
+		if pc.Len() > 0 {
+			return true
+		}
+	}
+	return false
+}
+
 // initLabelsGlobal must be called after parsing command-line flags.
 func initLabelsGlobal() {
 	labelsGlobal = nil

app/vmagent/remotewrite/remotewrite.go

@@ -15,7 +15,7 @@ import (
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bloomfilter"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/cgroup"
-	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fasttime"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/consistenthash"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
@@ -39,22 +39,21 @@ var (
 		"Pass multiple -remoteWrite.url options in order to replicate the collected data to multiple remote storage systems. "+
 		"The data can be sharded among the configured remote storage systems if -remoteWrite.shardByURL flag is set")
 	enableMultitenantHandlers = flag.Bool("enableMultitenantHandlers", false, "Whether to process incoming data via multitenant insert handlers according to "+
-		"https://docs.victoriametrics.com/cluster-victoriametrics/#url-format . By default incoming data is processed via single-node insert handlers "+
-		"according to https://docs.victoriametrics.com/#how-to-import-time-series-data ."+
-		"See https://docs.victoriametrics.com/vmagent/#multitenancy for details")
+		"https://docs.victoriametrics.com/victoriametrics/cluster-victoriametrics/#url-format . By default incoming data is processed via single-node insert handlers "+
+		"according to https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-import-time-series-data ."+
+		"See https://docs.victoriametrics.com/victoriametrics/vmagent/#multitenancy for details")
 
-	shardByURL = flag.Bool("remoteWrite.shardByURL", false, "Whether to shard outgoing series across all the remote storage systems enumerated via -remoteWrite.url . "+
-		"By default the data is replicated across all the -remoteWrite.url . See https://docs.victoriametrics.com/vmagent/#sharding-among-remote-storages . "+
+	shardByURL = flag.Bool("remoteWrite.shardByURL", false, "Whether to shard outgoing series across all the remote storage systems enumerated via -remoteWrite.url. "+
+		"By default the data is replicated across all the -remoteWrite.url . See https://docs.victoriametrics.com/victoriametrics/vmagent/#sharding-among-remote-storages . "+
 		"See also -remoteWrite.shardByURLReplicas")
 	shardByURLReplicas = flag.Int("remoteWrite.shardByURLReplicas", 1, "How many copies of data to make among remote storage systems enumerated via -remoteWrite.url "+
-		"when -remoteWrite.shardByURL is set. See https://docs.victoriametrics.com/vmagent/#sharding-among-remote-storages")
+		"when -remoteWrite.shardByURL is set. See https://docs.victoriametrics.com/victoriametrics/vmagent/#sharding-among-remote-storages")
 	shardByURLLabels = flagutil.NewArrayString("remoteWrite.shardByURL.labels", "Optional list of labels, which must be used for sharding outgoing samples "+
 		"among remote storage systems if -remoteWrite.shardByURL command-line flag is set. By default all the labels are used for sharding in order to gain "+
 		"even distribution of series over the specified -remoteWrite.url systems. See also -remoteWrite.shardByURL.ignoreLabels")
 	shardByURLIgnoreLabels = flagutil.NewArrayString("remoteWrite.shardByURL.ignoreLabels", "Optional list of labels, which must be ignored when sharding outgoing samples "+
 		"among remote storage systems if -remoteWrite.shardByURL command-line flag is set. By default all the labels are used for sharding in order to gain "+
 		"even distribution of series over the specified -remoteWrite.url systems. See also -remoteWrite.shardByURL.labels")
-
 	tmpDataPath = flag.String("remoteWrite.tmpDataPath", "vmagent-remotewrite-data", "Path to directory for storing pending data, which isn't sent to the configured -remoteWrite.url . "+
 		"See also -remoteWrite.maxDiskUsagePerURL and -remoteWrite.disableOnDiskQueue")
 	keepDanglingQueues = flag.Bool("remoteWrite.keepDanglingQueues", false, "Keep persistent queues contents at -remoteWrite.tmpDataPath in case there are no matching -remoteWrite.url. "+
@@ -81,28 +80,30 @@ var (
 		`For example, if m{k1="v1",k2="v2"} may be sent as m{k2="v2",k1="v1"}`+
 		`Enabled sorting for labels can slow down ingestion performance a bit`)
 	maxHourlySeries = flag.Int("remoteWrite.maxHourlySeries", 0, "The maximum number of unique series vmagent can send to remote storage systems during the last hour. "+
-		"Excess series are logged and dropped. This can be useful for limiting series cardinality. See https://docs.victoriametrics.com/vmagent/#cardinality-limiter")
+		"Excess series are logged and dropped. This can be useful for limiting series cardinality. See https://docs.victoriametrics.com/victoriametrics/vmagent/#cardinality-limiter")
 	maxDailySeries = flag.Int("remoteWrite.maxDailySeries", 0, "The maximum number of unique series vmagent can send to remote storage systems during the last 24 hours. "+
-		"Excess series are logged and dropped. This can be useful for limiting series churn rate. See https://docs.victoriametrics.com/vmagent/#cardinality-limiter")
+		"Excess series are logged and dropped. This can be useful for limiting series churn rate. See https://docs.victoriametrics.com/victoriametrics/vmagent/#cardinality-limiter")
 	maxIngestionRate = flag.Int("maxIngestionRate", 0, "The maximum number of samples vmagent can receive per second. Data ingestion is paused when the limit is exceeded. "+
 		"By default there are no limits on samples ingestion rate. See also -remoteWrite.rateLimit")
 
 	disableOnDiskQueue = flagutil.NewArrayBool("remoteWrite.disableOnDiskQueue", "Whether to disable storing pending data to -remoteWrite.tmpDataPath "+
 		"when the remote storage system at the corresponding -remoteWrite.url cannot keep up with the data ingestion rate. "+
-		"See https://docs.victoriametrics.com/vmagent#disabling-on-disk-persistence . See also -remoteWrite.dropSamplesOnOverload")
+		"See https://docs.victoriametrics.com/victoriametrics/vmagent/#disabling-on-disk-persistence . See also -remoteWrite.dropSamplesOnOverload")
 	dropSamplesOnOverload = flag.Bool("remoteWrite.dropSamplesOnOverload", false, "Whether to drop samples when -remoteWrite.disableOnDiskQueue is set and if the samples "+
-		"cannot be pushed into the configured -remoteWrite.url systems in a timely manner. See https://docs.victoriametrics.com/vmagent#disabling-on-disk-persistence")
+		"cannot be pushed into the configured -remoteWrite.url systems in a timely manner. See https://docs.victoriametrics.com/victoriametrics/vmagent/#disabling-on-disk-persistence")
 )
 
 var (
 	// rwctxsGlobal contains statically populated entries when -remoteWrite.url is specified.
-	rwctxsGlobal []*remoteWriteCtx
+	rwctxsGlobal              []*remoteWriteCtx
+	rwctxsGlobalIdx           []int
+	rwctxConsistentHashGlobal *consistenthash.ConsistentHash
 
 	// ErrQueueFullHTTPRetry must be returned when TryPush() returns false.
 	ErrQueueFullHTTPRetry = &httpserver.ErrorWithStatusCode{
 		Err: fmt.Errorf("remote storage systems cannot keep up with the data ingestion rate; retry the request later " +
 			"or remove -remoteWrite.disableOnDiskQueue from vmagent command-line flags, so it could save pending data to -remoteWrite.tmpDataPath; " +
-			"see https://docs.victoriametrics.com/vmagent/#disabling-on-disk-persistence"),
+			"see https://docs.victoriametrics.com/victoriametrics/vmagent/#disabling-on-disk-persistence"),
 		StatusCode: http.StatusTooManyRequests,
 	}
 
@@ -183,7 +184,7 @@ func Init() {
 
 	if len(*shardByURLLabels) > 0 && len(*shardByURLIgnoreLabels) > 0 {
 		logger.Fatalf("-remoteWrite.shardByURL.labels and -remoteWrite.shardByURL.ignoreLabels cannot be set simultaneously; " +
-			"see https://docs.victoriametrics.com/vmagent/#sharding-among-remote-storages")
+			"see https://docs.victoriametrics.com/victoriametrics/vmagent/#sharding-among-remote-storages")
 	}
 	shardByURLLabelsMap = newMapFromStrings(*shardByURLLabels)
 	shardByURLIgnoreLabelsMap = newMapFromStrings(*shardByURLIgnoreLabels)
@@ -195,17 +196,11 @@ func Init() {
 	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/1240
 	sighupCh := procutil.NewSighupChan()
 
-	rcs, err := loadRelabelConfigs()
-	if err != nil {
-		logger.Fatalf("cannot load relabel configs: %s", err)
-	}
-	allRelabelConfigs.Store(rcs)
-	relabelConfigSuccess.Set(1)
-	relabelConfigTimestamp.Set(fasttime.UnixTimestamp())
+	initRelabelConfigs()
 
 	initStreamAggrConfigGlobal()
 
-	rwctxsGlobal = newRemoteWriteCtxs(*remoteWriteURLs)
+	initRemoteWriteCtxs(*remoteWriteURLs)
 
 	disableOnDiskQueues := []bool(*disableOnDiskQueue)
 	disableOnDiskQueueAny = slices.Contains(disableOnDiskQueues, true)
@@ -267,30 +262,7 @@ func dropDanglingQueues() {
 	}
 }
 
-func reloadRelabelConfigs() {
-	relabelConfigReloads.Inc()
-	logger.Infof("reloading relabel configs pointed by -remoteWrite.relabelConfig and -remoteWrite.urlRelabelConfig")
-	rcs, err := loadRelabelConfigs()
-	if err != nil {
-		relabelConfigReloadErrors.Inc()
-		relabelConfigSuccess.Set(0)
-		logger.Errorf("cannot reload relabel configs; preserving the previous configs; error: %s", err)
-		return
-	}
-	allRelabelConfigs.Store(rcs)
-	relabelConfigSuccess.Set(1)
-	relabelConfigTimestamp.Set(fasttime.UnixTimestamp())
-	logger.Infof("successfully reloaded relabel configs")
-}
-
-var (
-	relabelConfigReloads      = metrics.NewCounter(`vmagent_relabel_config_reloads_total`)
-	relabelConfigReloadErrors = metrics.NewCounter(`vmagent_relabel_config_reloads_errors_total`)
-	relabelConfigSuccess      = metrics.NewGauge(`vmagent_relabel_config_last_reload_successful`, nil)
-	relabelConfigTimestamp    = metrics.NewCounter(`vmagent_relabel_config_last_reload_success_timestamp_seconds`)
-)
-
-func newRemoteWriteCtxs(urls []string) []*remoteWriteCtx {
+func initRemoteWriteCtxs(urls []string) {
 	if len(urls) == 0 {
 		logger.Panicf("BUG: urls must be non-empty")
 	}
@@ -306,6 +278,7 @@ func newRemoteWriteCtxs(urls []string) []*remoteWriteCtx {
 		maxInmemoryBlocks = 2
 	}
 	rwctxs := make([]*remoteWriteCtx, len(urls))
+	rwctxIdx := make([]int, len(urls))
 	for i, remoteWriteURLRaw := range urls {
 		remoteWriteURL, err := url.Parse(remoteWriteURLRaw)
 		if err != nil {
@@ -316,8 +289,19 @@ func newRemoteWriteCtxs(urls []string) []*remoteWriteCtx {
 			sanitizedURL = fmt.Sprintf("%d:%s", i+1, remoteWriteURL)
 		}
 		rwctxs[i] = newRemoteWriteCtx(i, remoteWriteURL, maxInmemoryBlocks, sanitizedURL)
+		rwctxIdx[i] = i
 	}
-	return rwctxs
+
+	if *shardByURL {
+		consistentHashNodes := make([]string, 0, len(urls))
+		for i, url := range urls {
+			consistentHashNodes = append(consistentHashNodes, fmt.Sprintf("%d:%s", i+1, url))
+		}
+		rwctxConsistentHashGlobal = consistenthash.NewConsistentHash(consistentHashNodes, 0)
+	}
+
+	rwctxsGlobal = rwctxs
+	rwctxsGlobalIdx = rwctxIdx
 }
 
 var (
@@ -501,6 +485,10 @@ func tryPush(at *auth.Token, wr *prompbmarshal.WriteRequest, forceDropSamplesOnF
 	return true
 }
 
+// getEligibleRemoteWriteCtxs checks whether writes to configured remote storage systems are blocked and
+// returns only the unblocked rwctx.
+//
+// calculateHealthyRwctxIdx will rely on the order of rwctx to be in ascending order.
 func getEligibleRemoteWriteCtxs(tss []prompbmarshal.TimeSeries, forceDropSamplesOnFailure bool) ([]*remoteWriteCtx, bool) {
 	if !disableOnDiskQueueAny {
 		return rwctxsGlobal, true
@@ -517,6 +505,12 @@ func getEligibleRemoteWriteCtxs(tss []prompbmarshal.TimeSeries, forceDropSamples
 				return nil, false
 			}
 			rowsCount := getRowsCount(tss)
+			if *shardByURL {
+				// Todo: When shardByURL is enabled, the following metrics won't be 100% accurate. Because vmagent don't know
+				// which rwctx should data be pushed to yet. Let's consider the hashing algorithm fair and will distribute
+				// data to all rwctxs evenly.
+				rowsCount = rowsCount / len(rwctxsGlobal)
+			}
 			rwctx.rowsDroppedOnPushFailure.Add(rowsCount)
 		}
 	}
@@ -528,6 +522,7 @@ func pushToRemoteStoragesTrackDropped(tss []prompbmarshal.TimeSeries) {
 	if len(rwctxs) == 0 {
 		return
 	}
+
 	if !tryPushBlockToRemoteStorages(rwctxs, tss, true) {
 		logger.Panicf("BUG: tryPushBlockToRemoteStorages() must return true when forceDropSamplesOnFailure=true")
 	}
@@ -578,42 +573,7 @@ func tryShardingBlockAmongRemoteStorages(rwctxs []*remoteWriteCtx, tssBlock []pr
 	defer putTSSShards(x)
 
 	shards := x.shards
-	tmpLabels := promutil.GetLabels()
-	for _, ts := range tssBlock {
-		hashLabels := ts.Labels
-		if len(shardByURLLabelsMap) > 0 {
-			hashLabels = tmpLabels.Labels[:0]
-			for _, label := range ts.Labels {
-				if _, ok := shardByURLLabelsMap[label.Name]; ok {
-					hashLabels = append(hashLabels, label)
-				}
-			}
-			tmpLabels.Labels = hashLabels
-		} else if len(shardByURLIgnoreLabelsMap) > 0 {
-			hashLabels = tmpLabels.Labels[:0]
-			for _, label := range ts.Labels {
-				if _, ok := shardByURLIgnoreLabelsMap[label.Name]; !ok {
-					hashLabels = append(hashLabels, label)
-				}
-			}
-			tmpLabels.Labels = hashLabels
-		}
-		h := getLabelsHash(hashLabels)
-		idx := h % uint64(len(shards))
-		i := 0
-		for {
-			shards[idx] = append(shards[idx], ts)
-			i++
-			if i >= replicas {
-				break
-			}
-			idx++
-			if idx >= uint64(len(shards)) {
-				idx = 0
-			}
-		}
-	}
-	promutil.PutLabels(tmpLabels)
+	shardAmountRemoteWriteCtx(tssBlock, shards, rwctxs, replicas)
 
 	// Push sharded samples to remote storage systems in parallel in order to reduce
 	// the time needed for sending the data to multiple remote storage systems.
@@ -636,6 +596,86 @@ func tryShardingBlockAmongRemoteStorages(rwctxs []*remoteWriteCtx, tssBlock []pr
 	return !anyPushFailed.Load()
 }
 
+// calculateHealthyRwctxIdx returns the index of healthyRwctxs in rwctxsGlobal.
+// It relies on the order of rwctx in healthyRwctxs, which is appended by getEligibleRemoteWriteCtxs.
+func calculateHealthyRwctxIdx(healthyRwctxs []*remoteWriteCtx) ([]int, []int) {
+	// fast path: all rwctxs are healthy.
+	if len(healthyRwctxs) == len(rwctxsGlobal) {
+		return rwctxsGlobalIdx, nil
+	}
+
+	unhealthyIdx := make([]int, 0, len(rwctxsGlobal))
+	healthyIdx := make([]int, 0, len(rwctxsGlobal))
+
+	var i int
+	for j := range rwctxsGlobal {
+		if i < len(healthyRwctxs) && rwctxsGlobal[j].idx == healthyRwctxs[i].idx {
+			healthyIdx = append(healthyIdx, j)
+			i++
+		} else {
+			unhealthyIdx = append(unhealthyIdx, j)
+		}
+	}
+
+	return healthyIdx, unhealthyIdx
+}
+
+// shardAmountRemoteWriteCtx distribute time series to shards by consistent hashing.
+func shardAmountRemoteWriteCtx(tssBlock []prompbmarshal.TimeSeries, shards [][]prompbmarshal.TimeSeries, rwctxs []*remoteWriteCtx, replicas int) {
+	tmpLabels := promutil.GetLabels()
+	defer promutil.PutLabels(tmpLabels)
+
+	healthyIdx, unhealthyIdx := calculateHealthyRwctxIdx(rwctxs)
+
+	// shardsIdxMap is a map to find which the shard idx by rwctxs idx.
+	// rwctxConsistentHashGlobal will tell which the rwctxs idx a time series should be written to.
+	// And this time series should be appended to the shards by correct shard idx.
+	shardsIdxMap := make(map[int]int, len(healthyIdx))
+	for idx, rwctxsIdx := range healthyIdx {
+		shardsIdxMap[rwctxsIdx] = idx
+	}
+
+	for _, ts := range tssBlock {
+		hashLabels := ts.Labels
+		if len(shardByURLLabelsMap) > 0 {
+			hashLabels = tmpLabels.Labels[:0]
+			for _, label := range ts.Labels {
+				if _, ok := shardByURLLabelsMap[label.Name]; ok {
+					hashLabels = append(hashLabels, label)
+				}
+			}
+			tmpLabels.Labels = hashLabels
+		} else if len(shardByURLIgnoreLabelsMap) > 0 {
+			hashLabels = tmpLabels.Labels[:0]
+			for _, label := range ts.Labels {
+				if _, ok := shardByURLIgnoreLabelsMap[label.Name]; !ok {
+					hashLabels = append(hashLabels, label)
+				}
+			}
+			tmpLabels.Labels = hashLabels
+		}
+		h := getLabelsHash(hashLabels)
+
+		// Get the rwctxIdx through consistent hashing and then map it to the index in shards.
+		// The rwctxIdx is not always equal to the shardIdx, for example, when some rwctx are not available.
+		rwctxIdx := rwctxConsistentHashGlobal.GetNodeIdx(h, unhealthyIdx)
+		shardIdx := shardsIdxMap[rwctxIdx]
+
+		replicated := 0
+		for {
+			shards[shardIdx] = append(shards[shardIdx], ts)
+			replicated++
+			if replicated >= replicas {
+				break
+			}
+			shardIdx++
+			if shardIdx >= len(shards) {
+				shardIdx = 0
+			}
+		}
+	}
+}
+
 type tssShards struct {
 	shards [][]prompbmarshal.TimeSeries
 }

app/vmagent/remotewrite/remotewrite_test.go

@@ -4,14 +4,17 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"strconv"
 	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/consistenthash"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompbmarshal"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/promrelabel"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/protoparser/prometheus"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/streamaggr"
+
 	"github.com/VictoriaMetrics/metrics"
 )
 
@@ -174,3 +177,173 @@ metric{env="dev"} 15
 metric{env="bar"} 25
 `)
 }
+
+func TestShardAmountRemoteWriteCtx(t *testing.T) {
+	// 1. distribute 100000 series to n nodes.
+	// 2. remove the last node from healthy list.
+	// 3. distribute the same 10000 series to (n-1) node again.
+	// 4. check active time series change rate:
+	// change rate must < (3/total nodes). e.g. +30% if 10 you have 10 nodes.
+
+	f := func(remoteWriteCount int, healthyIdx []int, replicas int) {
+		t.Helper()
+		defer func() {
+			rwctxsGlobal = nil
+			rwctxsGlobalIdx = nil
+			rwctxConsistentHashGlobal = nil
+		}()
+
+		rwctxsGlobal = make([]*remoteWriteCtx, remoteWriteCount)
+		rwctxsGlobalIdx = make([]int, remoteWriteCount)
+		rwctxs := make([]*remoteWriteCtx, 0, len(healthyIdx))
+
+		for i := range remoteWriteCount {
+			rwCtx := &remoteWriteCtx{
+				idx: i,
+			}
+			rwctxsGlobalIdx[i] = i
+
+			if i >= len(healthyIdx) {
+				rwctxsGlobal[i] = rwCtx
+				continue
+			}
+			hIdx := healthyIdx[i]
+			if hIdx != i {
+				rwctxs = append(rwctxs, &remoteWriteCtx{
+					idx: hIdx,
+				})
+			} else {
+				rwctxs = append(rwctxs, rwCtx)
+			}
+			rwctxsGlobal[i] = rwCtx
+		}
+
+		seriesCount := 100000
+		// build 1000000 series
+		tssBlock := make([]prompbmarshal.TimeSeries, 0, seriesCount)
+		for i := 0; i < seriesCount; i++ {
+			tssBlock = append(tssBlock, prompbmarshal.TimeSeries{
+				Labels: []prompbmarshal.Label{
+					{
+						Name:  "label",
+						Value: strconv.Itoa(i),
+					},
+				},
+				Samples: []prompbmarshal.Sample{
+					{
+						Timestamp: 0,
+						Value:     0,
+					},
+				},
+			})
+		}
+
+		// build consistent hash for x remote write context
+		// build active time series set
+		nodes := make([]string, 0, remoteWriteCount)
+		activeTimeSeriesByNodes := make([]map[string]struct{}, remoteWriteCount)
+		for i := 0; i < remoteWriteCount; i++ {
+			nodes = append(nodes, fmt.Sprintf("node%d", i))
+			activeTimeSeriesByNodes[i] = make(map[string]struct{})
+		}
+		rwctxConsistentHashGlobal = consistenthash.NewConsistentHash(nodes, 0)
+
+		// create shards
+		x := getTSSShards(len(rwctxs))
+		shards := x.shards
+
+		// execute
+		shardAmountRemoteWriteCtx(tssBlock, shards, rwctxs, replicas)
+
+		for i, nodeIdx := range healthyIdx {
+			for _, ts := range shards[i] {
+				// add it to node[nodeIdx]'s active time series
+				activeTimeSeriesByNodes[nodeIdx][prompbmarshal.LabelsToString(ts.Labels)] = struct{}{}
+			}
+		}
+
+		totalActiveTimeSeries := 0
+		for _, activeTimeSeries := range activeTimeSeriesByNodes {
+			totalActiveTimeSeries += len(activeTimeSeries)
+		}
+		avgActiveTimeSeries1 := totalActiveTimeSeries / remoteWriteCount
+		putTSSShards(x)
+
+		// removed last node
+		rwctxs = rwctxs[:len(rwctxs)-1]
+		healthyIdx = healthyIdx[:len(healthyIdx)-1]
+
+		x = getTSSShards(len(rwctxs))
+		shards = x.shards
+
+		// execute
+		shardAmountRemoteWriteCtx(tssBlock, shards, rwctxs, replicas)
+		for i, nodeIdx := range healthyIdx {
+			for _, ts := range shards[i] {
+				// add it to node[nodeIdx]'s active time series
+				activeTimeSeriesByNodes[nodeIdx][prompbmarshal.LabelsToString(ts.Labels)] = struct{}{}
+			}
+		}
+
+		totalActiveTimeSeries = 0
+		for _, activeTimeSeries := range activeTimeSeriesByNodes {
+			totalActiveTimeSeries += len(activeTimeSeries)
+		}
+		avgActiveTimeSeries2 := totalActiveTimeSeries / remoteWriteCount
+
+		changed := math.Abs(float64(avgActiveTimeSeries2-avgActiveTimeSeries1) / float64(avgActiveTimeSeries1))
+		threshold := 3 / float64(remoteWriteCount)
+
+		if changed >= threshold {
+			t.Fatalf("average active time series before: %d, after: %d, changed: %.2f. threshold: %.2f", avgActiveTimeSeries1, avgActiveTimeSeries2, changed, threshold)
+		}
+
+	}
+
+	f(5, []int{0, 1, 2, 3, 4}, 1)
+
+	f(5, []int{0, 1, 2, 3, 4}, 2)
+
+	f(10, []int{0, 1, 2, 3, 4, 5, 6, 7, 9}, 1)
+
+	f(10, []int{0, 1, 2, 3, 4, 5, 6, 7, 9}, 3)
+}
+
+func TestCalculateHealthyRwctxIdx(t *testing.T) {
+	f := func(total int, healthyIdx []int, unhealthyIdx []int) {
+		t.Helper()
+
+		healthyMap := make(map[int]bool)
+		for _, idx := range healthyIdx {
+			healthyMap[idx] = true
+		}
+		rwctxsGlobal = make([]*remoteWriteCtx, total)
+		rwctxsGlobalIdx = make([]int, total)
+		rwctxs := make([]*remoteWriteCtx, 0, len(healthyIdx))
+		for i := range rwctxsGlobal {
+			rwctx := &remoteWriteCtx{idx: i}
+			rwctxsGlobal[i] = rwctx
+			if healthyMap[i] {
+				rwctxs = append(rwctxs, rwctx)
+			}
+			rwctxsGlobalIdx[i] = i
+		}
+
+		gotHealthyIdx, gotUnhealthyIdx := calculateHealthyRwctxIdx(rwctxs)
+		if !reflect.DeepEqual(healthyIdx, gotHealthyIdx) {
+			t.Errorf("calculateHealthyRwctxIdx want healthyIdx = %v, got %v", healthyIdx, gotHealthyIdx)
+		}
+		if !reflect.DeepEqual(unhealthyIdx, gotUnhealthyIdx) {
+			t.Errorf("calculateHealthyRwctxIdx want unhealthyIdx = %v, got %v", unhealthyIdx, gotUnhealthyIdx)
+		}
+	}
+
+	f(5, []int{0, 1, 2, 3, 4}, nil)
+	f(5, []int{0, 1, 2, 4}, []int{3})
+	f(5, []int{2, 4}, []int{0, 1, 3})
+	f(5, []int{0, 2, 4}, []int{1, 3})
+	f(5, []int{}, []int{0, 1, 2, 3, 4})
+	f(5, []int{4}, []int{0, 1, 2, 3})
+	f(1, []int{0}, nil)
+	f(1, []int{}, []int{0})
+}

app/vmagent/remotewrite/streamaggr.go

@@ -16,55 +16,55 @@ import (
 var (
 	// Global config
 	streamAggrGlobalConfig = flag.String("streamAggr.config", "", "Optional path to file with stream aggregation config. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/ . "+
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/ . "+
 		"See also -streamAggr.keepInput, -streamAggr.dropInput and -streamAggr.dedupInterval")
 	streamAggrGlobalKeepInput = flag.Bool("streamAggr.keepInput", false, "Whether to keep all the input samples after the aggregation "+
 		"with -streamAggr.config. By default, only aggregates samples are dropped, while the remaining samples "+
-		"are written to remote storages write. See also -streamAggr.dropInput and https://docs.victoriametrics.com/stream-aggregation/")
+		"are written to remote storages write. See also -streamAggr.dropInput and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/")
 	streamAggrGlobalDropInput = flag.Bool("streamAggr.dropInput", false, "Whether to drop all the input samples after the aggregation "+
 		"with -remoteWrite.streamAggr.config. By default, only aggregates samples are dropped, while the remaining samples "+
-		"are written to remote storages write. See also -streamAggr.keepInput and https://docs.victoriametrics.com/stream-aggregation/")
+		"are written to remote storages write. See also -streamAggr.keepInput and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/")
 	streamAggrGlobalDedupInterval = flag.Duration("streamAggr.dedupInterval", 0, "Input samples are de-duplicated with this interval on "+
 		"aggregator before optional aggregation with -streamAggr.config . "+
-		"See also -dedup.minScrapeInterval and https://docs.victoriametrics.com/stream-aggregation/#deduplication")
+		"See also -dedup.minScrapeInterval and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication")
 	streamAggrGlobalIgnoreOldSamples = flag.Bool("streamAggr.ignoreOldSamples", false, "Whether to ignore input samples with old timestamps outside the "+
 		"current aggregation interval for aggregator. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#ignoring-old-samples")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples")
 	streamAggrGlobalIgnoreFirstIntervals = flag.Int("streamAggr.ignoreFirstIntervals", 0, "Number of aggregation intervals to skip after the start for "+
 		"aggregator. Increase this value if you observe incorrect aggregation results after vmagent restarts. It could be caused by receiving unordered delayed data from "+
-		"clients pushing data into the vmagent. See https://docs.victoriametrics.com/stream-aggregation/#ignore-aggregation-intervals-on-start")
+		"clients pushing data into the vmagent. See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignore-aggregation-intervals-on-start")
 	streamAggrGlobalDropInputLabels = flagutil.NewArrayString("streamAggr.dropInputLabels", "An optional list of labels to drop from samples for aggregator "+
-		"before stream de-duplication and aggregation . See https://docs.victoriametrics.com/stream-aggregation/#dropping-unneeded-labels")
+		"before stream de-duplication and aggregation . See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#dropping-unneeded-labels")
 	streamAggrGlobalEnableWindows = flag.Bool("streamAggr.enableWindows", false, "Enables aggregation within fixed windows for all global aggregators. "+
 		"This allows to get more precise results, but impacts resource usage as it requires twice more memory to store two states. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#aggregation-windows.")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#aggregation-windows.")
 
 	// Per URL config
 	streamAggrConfig = flagutil.NewArrayString("remoteWrite.streamAggr.config", "Optional path to file with stream aggregation config for the corresponding -remoteWrite.url. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/ . "+
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/ . "+
 		"See also -remoteWrite.streamAggr.keepInput, -remoteWrite.streamAggr.dropInput and -remoteWrite.streamAggr.dedupInterval")
 	streamAggrDropInput = flagutil.NewArrayBool("remoteWrite.streamAggr.dropInput", "Whether to drop all the input samples after the aggregation "+
 		"with -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. By default, only aggregates samples are dropped, while the remaining samples "+
-		"are written to the corresponding -remoteWrite.url . See also -remoteWrite.streamAggr.keepInput and https://docs.victoriametrics.com/stream-aggregation/")
+		"are written to the corresponding -remoteWrite.url . See also -remoteWrite.streamAggr.keepInput and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/")
 	streamAggrKeepInput = flagutil.NewArrayBool("remoteWrite.streamAggr.keepInput", "Whether to keep all the input samples after the aggregation "+
 		"with -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. By default, only aggregates samples are dropped, while the remaining samples "+
-		"are written to the corresponding -remoteWrite.url . See also -remoteWrite.streamAggr.dropInput and https://docs.victoriametrics.com/stream-aggregation/")
+		"are written to the corresponding -remoteWrite.url . See also -remoteWrite.streamAggr.dropInput and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/")
 	streamAggrDedupInterval = flagutil.NewArrayDuration("remoteWrite.streamAggr.dedupInterval", 0, "Input samples are de-duplicated with this interval before optional aggregation "+
-		"with -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. See also -dedup.minScrapeInterval and https://docs.victoriametrics.com/stream-aggregation/#deduplication")
+		"with -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. See also -dedup.minScrapeInterval and https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#deduplication")
 	streamAggrIgnoreOldSamples = flagutil.NewArrayBool("remoteWrite.streamAggr.ignoreOldSamples", "Whether to ignore input samples with old timestamps outside the current "+
 		"aggregation interval for the corresponding -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#ignoring-old-samples")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignoring-old-samples")
 	streamAggrIgnoreFirstIntervals = flagutil.NewArrayInt("remoteWrite.streamAggr.ignoreFirstIntervals", 0, "Number of aggregation intervals to skip after the start "+
 		"for the corresponding -remoteWrite.streamAggr.config at the corresponding -remoteWrite.url. Increase this value if "+
 		"you observe incorrect aggregation results after vmagent restarts. It could be caused by receiving buffered delayed data from clients pushing data into the vmagent. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#ignore-aggregation-intervals-on-start")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#ignore-aggregation-intervals-on-start")
 	streamAggrDropInputLabels = flagutil.NewArrayString("remoteWrite.streamAggr.dropInputLabels", "An optional list of labels to drop from samples "+
 		"before stream de-duplication and aggregation with -remoteWrite.streamAggr.config and -remoteWrite.streamAggr.dedupInterval at the corresponding -remoteWrite.url. "+
 		"Multiple labels per remoteWrite.url must be delimited by '^^': -remoteWrite.streamAggr.dropInputLabels='replica^^az,replica'. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#dropping-unneeded-labels")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#dropping-unneeded-labels")
 	streamAggrEnableWindows = flagutil.NewArrayBool("remoteWrite.streamAggr.enableWindows", "Enables aggregation within fixed windows for all remote write's aggregators. "+
 		"This allows to get more precise results, but impacts resource usage as it requires twice more memory to store two states. "+
-		"See https://docs.victoriametrics.com/stream-aggregation/#aggregation-windows.")
+		"See https://docs.victoriametrics.com/victoriametrics/stream-aggregation/#aggregation-windows.")
 )
 
 // CheckStreamAggrConfigs checks -remoteWrite.streamAggr.config and -streamAggr.config.

app/vmalert-tool/README.md

@@ -1,3 +1,3 @@
-See vmalert-tool docs [here](https://docs.victoriametrics.com/vmalert-tool.html).
+See vmalert-tool docs [here](https://docs.victoriametrics.com/victoriametrics/vmalert-tool/).
 
-vmalert-tool docs can be edited at [docs/vmalert-tool.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/vmalert-tool.md).
+vmalert-tool docs can be edited at [docs/vmalert-tool.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/victoriametrics/vmalert-tool.md).

app/vmalert-tool/main.go

@@ -17,13 +17,13 @@ func main() {
 	app := &cli.App{
 		Name:      "vmalert-tool",
 		Usage:     "VMAlert command-line tool",
-		UsageText: "More info in https://docs.victoriametrics.com/vmalert-tool.html",
+		UsageText: "More info in https://docs.victoriametrics.com/victoriametrics/vmalert-tool/",
 		Version:   buildinfo.Version,
 		Commands: []*cli.Command{
 			{
 				Name:      "unittest",
 				Usage:     "Run unittest for alerting and recording rules.",
-				UsageText: "More info in https://docs.victoriametrics.com/vmalert-tool.html#Unit-testing-for-rules",
+				UsageText: "More info in https://docs.victoriametrics.com/victoriametrics/vmalert-tool/#unit-testing-for-rules",
 				Flags: []cli.Flag{
 					&cli.StringSliceFlag{
 						Name: "files",

app/vmalert-tool/multiarch/Dockerfile

@@ -9,4 +9,5 @@ COPY --from=certs /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certifica
 EXPOSE 8429
 ENTRYPOINT ["/vmalert-tool-prod"]
 ARG TARGETARCH
-COPY vmalert-tool-linux-${TARGETARCH}-prod ./vmalert-tool-prod
+ARG BINARY_SUFFIX=non-existing
+COPY vmalert-tool-linux-${TARGETARCH}-prod${BINARY_SUFFIX} ./vmalert-tool-prod

app/vmalert-tool/unittest/input.go

@@ -18,7 +18,7 @@ import (
 	"github.com/VictoriaMetrics/metricsql"
 )
 
-var numReg = regexp.MustCompile(`\D?\d*\.?\d*\D?`)
+var numReg = regexp.MustCompile(`(?i)[+x-]?(?:\d+(?:\.\d*)?|\.\d+|inf|nan|_)(?:e[+-]?\d+)?[+x-]?`)
 
 // series holds input_series defined in the test file
 type series struct {
@@ -94,12 +94,18 @@ func parseInputSeries(input []series, interval *promutil.Duration, startStamp ti
 // parseInputValue support input like "1", "1+1x1 _ -4 3+20x1", see more examples in test.
 func parseInputValue(input string, origin bool) ([]sequenceValue, error) {
 	var res []sequenceValue
-	items := strings.Split(input, " ")
+	items := strings.Fields(input)
+	if len(items) == 0 {
+		return nil, fmt.Errorf("values cannot be an empty string")
+	}
 	for _, item := range items {
 		if item == "stale" {
 			res = append(res, sequenceValue{Value: decimal.StaleNaN})
 			continue
 		}
+		if strings.Contains(item, "stale") {
+			return nil, fmt.Errorf("stale metric doesn't support operations")
+		}
 		vals := numReg.FindAllString(item, -1)
 		switch len(vals) {
 		case 1:

app/vmalert-tool/unittest/input_test.go

@@ -1,6 +1,7 @@
 package unittest
 
 import (
+	"math"
 	"testing"
 	"time"
 
@@ -12,17 +13,20 @@ func TestParseInputValue_Failure(t *testing.T) {
 	f := func(input string) {
 		t.Helper()
 
-		_, err := parseInputValue(input, true)
+		val, err := parseInputValue(input, true)
 		if err == nil {
-			t.Fatalf("expecting non-nil error")
+			t.Fatalf("expecting non-nil error, got value %+v", val)
 		}
 	}
 
 	f("")
+	f("x4")
 	f("testfailed")
 
 	// stale doesn't support operations
 	f("stalex3")
+
+	f("1+stalex3")
 }
 
 func TestParseInputValue_Success(t *testing.T) {
@@ -42,7 +46,8 @@ func TestParseInputValue_Success(t *testing.T) {
 				t.Fatalf("unexpected Omitted field in the output\ngot\n%v\nwant\n%v", output, outputExpected)
 			}
 			if outputExpected[i].Value != output[i].Value {
-				if decimal.IsStaleNaN(outputExpected[i].Value) && decimal.IsStaleNaN(output[i].Value) {
+				if (math.IsNaN(outputExpected[i].Value) && math.IsNaN(output[i].Value)) ||
+					(decimal.IsStaleNaN(outputExpected[i].Value) && decimal.IsStaleNaN(output[i].Value)) {
 					continue
 				}
 				t.Fatalf("unexpected Value field in the output\ngot\n%v\nwant\n%v", output, outputExpected)
@@ -56,6 +61,8 @@ func TestParseInputValue_Success(t *testing.T) {
 
 	f("stale", []sequenceValue{{Value: decimal.StaleNaN}})
 
+	f(" stale    2", []sequenceValue{{Value: decimal.StaleNaN}, {Value: 2}})
+
 	f("-4x1", []sequenceValue{{Value: -4}, {Value: -4}})
 
 	f("_x1", []sequenceValue{{Omitted: true}})
@@ -65,6 +72,14 @@ func TestParseInputValue_Success(t *testing.T) {
 	f("2-1x4", []sequenceValue{{Value: 2}, {Value: 1}, {Value: 0}, {Value: -1}, {Value: -2}})
 
 	f("1+1x1 _ -4 stale 3+20x1", []sequenceValue{{Value: 1}, {Value: 2}, {Omitted: true}, {Value: -4}, {Value: decimal.StaleNaN}, {Value: 3}, {Value: 23}})
+
+	f("Inf +Inf -Inf", []sequenceValue{{Value: math.Inf(1)}, {Value: math.Inf(1)}, {Value: math.Inf(-1)}})
+
+	f("Nan Infx2", []sequenceValue{{Value: math.NaN()}, {Value: math.Inf(1)}, {Value: math.Inf(1)}, {Value: math.Inf(1)}})
+
+	f("NaNx2", []sequenceValue{{Value: math.NaN()}, {Value: math.NaN()}, {Value: math.NaN()}})
+
+	f("4e9+1x2 -3e-2x2 1e-2-1x1", []sequenceValue{{Value: 4000000000}, {Value: 4000000001}, {Value: 4000000002}, {Value: -0.03}, {Value: -0.03}, {Value: -0.03}, {Value: 0.01}, {Value: -0.99}})
 }
 
 func TestParseInputSeries_Success(t *testing.T) {

app/vmalert/Makefile

@@ -74,7 +74,7 @@ test-vmalert:
 	go test -v -race -cover ./app/vmalert/notifier
 	go test -v -race -cover ./app/vmalert/config
 	go test -v -race -cover ./app/vmalert/remotewrite
-	go test -v -race -cover ./app/vmalert/utils
+	go test -v -race -cover ./app/vmalert/vmalertutil
 
 run-vmalert: vmalert
 	./bin/vmalert -rule=app/vmalert/config/testdata/rules/rules2-good.rules \

app/vmalert/README.md

@@ -1,3 +1,3 @@
-See vmalert docs [here](https://docs.victoriametrics.com/vmalert/).
+See vmalert docs [here](https://docs.victoriametrics.com/victoriametrics/vmalert/).
 
-vmalert docs can be edited at [docs/vmalert.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/vmalert.md).
+vmalert docs can be edited at [docs/vmalert.md](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/docs/victoriametrics/vmalert.md).

app/vmalert/config/config.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"bytes"
-	"crypto/md5"
 	"flag"
 	"fmt"
 	"hash/fnv"
@@ -11,15 +10,16 @@ import (
 	"sort"
 	"strings"
 
+	"gopkg.in/yaml.v2"
+
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmalert/config/log"
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmalert/vmalertutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/envtemplate"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/promutil"
-	"gopkg.in/yaml.v2"
 )
 
 var (
-	defaultRuleType = flag.String("rule.defaultRuleType", "prometheus", `Default type for rule expressions, can be overridden via "type" parameter on the group level, see https://docs.victoriametrics.com/vmalert/#groups. Supported values: "graphite", "prometheus" and "vlogs".`)
+	defaultRuleType = flag.String("rule.defaultRuleType", "prometheus", `Default type for rule expressions, can be overridden via "type" parameter on the group level, see https://docs.victoriametrics.com/victoriametrics/vmalert/#groups. Supported values: "graphite", "prometheus" and "vlogs".`)
 )
 
 // Group contains list of Rules grouped into
@@ -50,6 +50,8 @@ type Group struct {
 	NotifierHeaders []Header `yaml:"notifier_headers,omitempty"`
 	// EvalAlignment will make the timestamp of group query requests be aligned with interval
 	EvalAlignment *bool `yaml:"eval_alignment,omitempty"`
+	// Debug enables debug logs for the group
+	Debug bool `yaml:"debug,omitempty"`
 	// Catches all undefined fields and must be empty after parsing.
 	XXX map[string]any `yaml:",inline"`
 }
@@ -67,7 +69,7 @@ func (g *Group) UnmarshalYAML(unmarshal func(any) error) error {
 	if g.Type.Get() == "" {
 		g.Type = NewRawType(*defaultRuleType)
 	}
-	h := md5.New()
+	h := fnv.New64a()
 	h.Write(b)
 	g.Checksum = fmt.Sprintf("%x", h.Sum(nil))
 	return nil
@@ -143,7 +145,7 @@ type Rule struct {
 	KeepFiringFor *promutil.Duration `yaml:"keep_firing_for,omitempty"`
 	Labels        map[string]string  `yaml:"labels,omitempty"`
 	Annotations   map[string]string  `yaml:"annotations,omitempty"`
-	Debug         bool               `yaml:"debug,omitempty"`
+	Debug         *bool              `yaml:"debug,omitempty"`
 	// UpdateEntriesLimit defines max number of rule's state updates stored in memory.
 	// Overrides `-rule.updateEntriesLimit`.
 	UpdateEntriesLimit *int `yaml:"update_entries_limit,omitempty"`

app/vmalert/main.go

@@ -44,7 +44,7 @@ Enterprise version of vmalert supports S3 and GCS paths to rules.
 For example: gs://bucket/path/to/rules, s3://bucket/path/to/rules
 S3 and GCS paths support only matching by prefix, e.g. s3://bucket/dir/rule_ matches
 all files with prefix rule_ in folder dir.
-See https://docs.victoriametrics.com/vmalert/#reading-rules-from-object-storage
+See https://docs.victoriametrics.com/victoriametrics/vmalert/#reading-rules-from-object-storage
 `)
 
 	ruleTemplatesPath = flagutil.NewArrayString("rule.templates", `Path or glob pattern to location with go template definitions `+
@@ -71,7 +71,7 @@ absolute path to all .tpl files in root.
 	externalURL         = flag.String("external.url", "", "External URL is used as alert's source for sent alerts to the notifier. By default, hostname is used as address.")
 	externalAlertSource = flag.String("external.alert.source", "", `External Alert Source allows to override the Source link for alerts sent to AlertManager `+
 		`for cases where you want to build a custom link to Grafana, Prometheus or any other service. `+
-		`Supports templating - see https://docs.victoriametrics.com/vmalert/#templating . `+
+		`Supports templating - see https://docs.victoriametrics.com/victoriametrics/vmalert/#templating . `+
 		`For example, link to Grafana: -external.alert.source='explore?orgId=1&left={"datasource":"VictoriaMetrics","queries":[{"expr":{{.Expr|jsonEscape|queryEscape}},"refId":"A"}],"range":{"from":"now-1h","to":"now"}}'. `+
 		`Link to VMUI: -external.alert.source='vmui/#/?g0.expr={{.Expr|queryEscape}}'. `+
 		`If empty 'vmalert/alert?group_id={{.GroupID}}&alert_id={{.AlertID}}' is used.`)
@@ -182,7 +182,9 @@ func main() {
 		listenAddrs = []string{":8880"}
 	}
 	rh := &requestHandler{m: manager}
-	go httpserver.Serve(listenAddrs, useProxyProtocol, rh.handler)
+	go httpserver.Serve(listenAddrs, rh.handler, httpserver.ServeOptions{
+		UseProxyProtocol: useProxyProtocol,
+	})
 
 	pushmetrics.Init()
 	sig := procutil.WaitForSigterm()
@@ -318,7 +320,7 @@ func usage() {
 	const s = `
 vmalert processes alerts and recording rules.
 
-See the docs at https://docs.victoriametrics.com/vmalert/ .
+See the docs at https://docs.victoriametrics.com/victoriametrics/vmalert/ .
 `
 	flagutil.Usage(s)
 }

app/vmalert/multiarch/Dockerfile

@@ -9,4 +9,5 @@ COPY --from=certs /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certifica
 EXPOSE 8880
 ENTRYPOINT ["/vmalert-prod"]
 ARG TARGETARCH
-COPY vmalert-linux-${TARGETARCH}-prod ./vmalert-prod
+ARG BINARY_SUFFIX=non-existing
+COPY vmalert-linux-${TARGETARCH}-prod${BINARY_SUFFIX} ./vmalert-prod

app/vmalert/notifier/alert.go

@@ -21,6 +21,8 @@ type Alert struct {
 	GroupID uint64
 	// Name represents Alert name
 	Name string
+	// Type defines the datasource type of the Alert
+	Type string
 	// Labels is the list of label-value pairs attached to the Alert
 	Labels map[string]string
 	// Annotations is the list of annotations generated on Alert evaluation
@@ -78,6 +80,7 @@ func (as AlertState) String() string {
 
 // AlertTplData is used to execute templating
 type AlertTplData struct {
+	Type     string
 	Labels   map[string]string
 	Value    float64
 	Expr     string
@@ -89,6 +92,7 @@ type AlertTplData struct {
 
 var tplHeaders = []string{
 	"{{ $value := .Value }}",
+	"{{ $type := .Type }}",
 	"{{ $labels := .Labels }}",
 	"{{ $expr := .Expr }}",
 	"{{ $externalLabels := .ExternalLabels }}",
@@ -106,6 +110,7 @@ var tplHeaders = []string{
 func (a *Alert) ExecTemplate(q templates.QueryFn, labels, annotations map[string]string) (map[string]string, error) {
 	tplData := AlertTplData{
 		Value:    a.Value,
+		Type:     a.Type,
 		Labels:   labels,
 		Expr:     a.Expr,
 		AlertID:  a.ID,

app/vmalert/notifier/alert_test.go

@@ -61,7 +61,7 @@ func TestAlertExecTemplate(t *testing.T) {
 		for k := range tplExpected {
 			got, exp := tpl[k], tplExpected[k]
 			if got != exp {
-				t.Fatalf("unexpected template for key=%q; got %q; want %q", k, got, exp)
+				t.Fatalf("unexpected template for key=%q; \ngot %q; \nwant %q", k, got, exp)
 			}
 		}
 	}
@@ -200,6 +200,16 @@ func TestAlertExecTemplate(t *testing.T) {
 	}, map[string]string{
 		"grafana_url": "vm-grafana.com?from=1660944898&to=1660937698",
 	})
+
+	// Datasource type
+	f(&Alert{
+		Type: "vlogs",
+		Expr: "up",
+	}, map[string]string{
+		"grafana_url": `vm-grafana.com/explore?left={"datasource":"{{ if eq .Type "vlogs" }}VictoriaLogs{{ else }}VictoriaMetrics{{ end }}","queries":[{"expr":"{{ .Expr }}"}]}`,
+	}, map[string]string{
+		"grafana_url": `vm-grafana.com/explore?left={"datasource":"VictoriaLogs","queries":[{"expr":"up"}]}`,
+	})
 }
 
 func TestAlert_toPromLabels(t *testing.T) {

app/vmalert/notifier/config.go

@@ -1,8 +1,8 @@
 package notifier
 
 import (
-	"crypto/md5"
 	"fmt"
+	"hash/fnv"
 	"net/url"
 	"os"
 	"path"
@@ -99,7 +99,7 @@ func (cfg *Config) UnmarshalYAML(unmarshal func(any) error) error {
 	if err != nil {
 		return fmt.Errorf("failed to marshal configuration for checksum: %w", err)
 	}
-	h := md5.New()
+	h := fnv.New64a()
 	h.Write(b)
 	cfg.Checksum = fmt.Sprintf("%x", h.Sum(nil))
 	return nil

app/vmalert/remotewrite/client.go

@@ -146,8 +146,13 @@ func (c *Client) Close() error {
 		return fmt.Errorf("client is already closed")
 	}
 	close(c.input)
+
+	start := time.Now()
+	logger.Infof("shutting down remote write client: flushing remained series")
 	close(c.doneCh)
 	c.wg.Wait()
+	logger.Infof("shutting down remote write client: finished in %v", time.Since(start))
+
 	return nil
 }
 
@@ -156,21 +161,16 @@ func (c *Client) run(ctx context.Context) {
 	wr := &prompbmarshal.WriteRequest{}
 	shutdown := func() {
 		lastCtx, cancel := context.WithTimeout(context.Background(), defaultWriteTimeout)
-		logger.Infof("shutting down remote write client and flushing remained series")
 
-		shutdownFlushCnt := 0
 		for ts := range c.input {
 			wr.Timeseries = append(wr.Timeseries, ts)
 			if len(wr.Timeseries) >= c.maxBatchSize {
-				shutdownFlushCnt += len(wr.Timeseries)
 				c.flush(lastCtx, wr)
 			}
 		}
 		// flush the last batch. `flush` will re-check and avoid flushing empty batch.
-		shutdownFlushCnt += len(wr.Timeseries)
 		c.flush(lastCtx, wr)
 
-		logger.Infof("shutting down remote write client flushed %d series", shutdownFlushCnt)
 		cancel()
 	}
 	c.wg.Add(1)

app/vmalert/replay.go

@@ -24,7 +24,7 @@ var (
 			"and processing need to wait for previous rule results to be persisted by remote storage before evaluating the next rule."+
 			"Keep it equal or bigger than -remoteWrite.flushInterval.")
 	replayMaxDatapoints = flag.Int("replay.maxDatapointsPerQuery", 1e3,
-		"Max number of data points expected in one request. It affects the max time range for every `/query_range` request during the replay. The higher the value, the less requests will be made during replay.")
+		"Max number of data points expected in one request. It affects the max time range for every '/query_range' request during the replay. The higher the value, the less requests will be made during replay.")
 	replayRuleRetryAttempts = flag.Int("replay.ruleRetryAttempts", 5,
 		"Defines how many retries to make before giving up on rule if request for it returns an error.")
 	disableProgressBar = flag.Bool("replay.disableProgressBar", false, "Whether to disable rendering progress bars during the replay. "+

app/vmalert/rule/alerting.go

@@ -124,6 +124,10 @@ func (arm *alertingRuleMetrics) close() {
 
 // NewAlertingRule creates a new AlertingRule
 func NewAlertingRule(qb datasource.QuerierBuilder, group *Group, cfg config.Rule) *AlertingRule {
+	debug := group.Debug
+	if cfg.Debug != nil {
+		debug = *cfg.Debug
+	}
 	ar := &AlertingRule{
 		Type:          group.Type,
 		RuleID:        cfg.ID,
@@ -137,14 +141,14 @@ func NewAlertingRule(qb datasource.QuerierBuilder, group *Group, cfg config.Rule
 		GroupName:     group.Name,
 		File:          group.File,
 		EvalInterval:  group.Interval,
-		Debug:         cfg.Debug,
+		Debug:         debug,
 		q: qb.BuildWithParams(datasource.QuerierParams{
 			DataSourceType:            group.Type.String(),
 			ApplyIntervalAsTimeFilter: setIntervalAsTimeFilter(group.Type.String(), cfg.Expr),
 			EvaluationInterval:        group.Interval,
 			QueryParams:               group.Params,
 			Headers:                   group.Headers,
-			Debug:                     cfg.Debug,
+			Debug:                     debug,
 		}),
 		alerts: make(map[uint64]*notifier.Alert),
 	}
@@ -537,6 +541,7 @@ func (ar *AlertingRule) expandTemplates(m datasource.Metric, qFn templates.Query
 
 	tplData := notifier.AlertTplData{
 		Value:    m.Values[0],
+		Type:     ar.Type.String(),
 		Labels:   ls.origin,
 		Expr:     ar.Expr,
 		AlertID:  hash(ls.processed),
@@ -597,6 +602,7 @@ func (ar *AlertingRule) newAlert(m datasource.Metric, start time.Time, labels, a
 	return &notifier.Alert{
 		GroupID:     ar.GroupID,
 		Name:        ar.Name,
+		Type:        ar.Type.String(),
 		Expr:        ar.Expr,
 		For:         ar.For,
 		ActiveAt:    start,

app/vmalert/rule/alerting_test.go

@@ -653,6 +653,7 @@ func TestAlertingRuleExecRange(t *testing.T) {
 		hash(map[string]string{"alertname": "for-pending"}): {
 			GroupID:     fakeGroup.GetID(),
 			Name:        "for-pending",
+			Type:        config.NewPrometheusType().String(),
 			Labels:      map[string]string{"alertname": "for-pending"},
 			Annotations: map[string]string{"activeAt": "5000"},
 			State:       notifier.StatePending,
@@ -672,6 +673,7 @@ func TestAlertingRuleExecRange(t *testing.T) {
 		hash(map[string]string{"alertname": "for-firing"}): {
 			GroupID:     fakeGroup.GetID(),
 			Name:        "for-firing",
+			Type:        config.NewPrometheusType().String(),
 			Labels:      map[string]string{"alertname": "for-firing"},
 			Annotations: map[string]string{"activeAt": "1000"},
 			State:       notifier.StateFiring,
@@ -692,6 +694,7 @@ func TestAlertingRuleExecRange(t *testing.T) {
 		hash(map[string]string{"alertname": "for-hold-pending"}): {
 			GroupID:     fakeGroup.GetID(),
 			Name:        "for-hold-pending",
+			Type:        config.NewPrometheusType().String(),
 			Labels:      map[string]string{"alertname": "for-hold-pending"},
 			Annotations: map[string]string{"activeAt": "5000"},
 			State:       notifier.StatePending,
@@ -747,6 +750,7 @@ func TestAlertingRuleExecRange(t *testing.T) {
 		hash(map[string]string{"alertname": "multi-series"}): {
 			GroupID:     fakeGroup.GetID(),
 			Name:        "multi-series",
+			Type:        config.NewPrometheusType().String(),
 			Labels:      map[string]string{"alertname": "multi-series"},
 			Annotations: map[string]string{},
 			State:       notifier.StateFiring,
@@ -758,6 +762,7 @@ func TestAlertingRuleExecRange(t *testing.T) {
 		hash(map[string]string{"alertname": "multi-series", "foo": "bar"}): {
 			GroupID:     fakeGroup.GetID(),
 			Name:        "multi-series",
+			Type:        config.NewPrometheusType().String(),
 			Labels:      map[string]string{"alertname": "multi-series", "foo": "bar"},
 			Annotations: map[string]string{},
 			State:       notifier.StatePending,

app/vmalert/rule/group.go

@@ -30,8 +30,8 @@ var (
 	resendDelay        = flag.Duration("rule.resendDelay", 0, "MiniMum amount of time to wait before resending an alert to notifier.")
 	maxResolveDuration = flag.Duration("rule.maxResolveDuration", 0, "Limits the maxiMum duration for automatic alert expiration, "+
 		"which by default is 4 times evaluationInterval of the parent group")
-	evalDelay = flag.Duration("rule.evalDelay", 30*time.Second, "Adjustment of the `time` parameter for rule evaluation requests to compensate intentional data delay from the datasource. "+
-		"Normally, should be equal to `-search.latencyOffset` (cmd-line flag configured for VictoriaMetrics single-node or vmselect). "+
+	evalDelay = flag.Duration("rule.evalDelay", 30*time.Second, "Adjustment of the 'time' parameter for rule evaluation requests to compensate intentional data delay from the datasource. "+
+		"Normally, should be equal to '-search.latencyOffset' (cmd-line flag configured for VictoriaMetrics single-node or vmselect). "+
 		"This doesn't apply to groups with eval_offset specified.")
 	disableAlertGroupLabel = flag.Bool("disableAlertgroupLabel", false, "Whether to disable adding group's Name as label to generated alerts and time series.")
 	remoteReadLookBack     = flag.Duration("remoteRead.lookback", time.Hour, "Lookback defines how far to look into past for alerts timeseries. "+
@@ -57,6 +57,7 @@ type Group struct {
 	// checksum stores the hash of yaml definition for this group.
 	checksum       string
 	LastEvaluation time.Time
+	Debug          bool
 
 	Labels          map[string]string
 	Params          url.Values
@@ -118,6 +119,7 @@ func NewGroup(cfg config.Group, qb datasource.QuerierBuilder, defaultInterval ti
 		Headers:         make(map[string]string),
 		NotifierHeaders: make(map[string]string),
 		Labels:          cfg.Labels,
+		Debug:           cfg.Debug,
 		evalAlignment:   cfg.EvalAlignment,
 
 		doneCh:     make(chan struct{}),
@@ -271,6 +273,7 @@ func (g *Group) updateWith(newGroup *Group) error {
 	g.Limit = newGroup.Limit
 	g.checksum = newGroup.checksum
 	g.Rules = newRules
+	g.Debug = newGroup.Debug
 	return nil
 }
 
@@ -471,6 +474,7 @@ func (g *Group) DeepCopy() *Group {
 	newG := Group{}
 	_ = json.Unmarshal(data, &newG)
 	newG.Rules = g.Rules
+	newG.id = g.id
 	return &newG
 }
 

app/vmalert/rule/group_test.go

@@ -36,144 +36,206 @@ func TestMain(m *testing.M) {
 }
 
 func TestUpdateWith(t *testing.T) {
-	f := func(currentRules, newRules []config.Rule) {
+	f := func(oldG, newG config.Group) {
 		t.Helper()
 
 		ns := metrics.NewSet()
-		g := &Group{
-			Name:    "test",
-			metrics: &groupMetrics{set: ns},
-		}
 		qb := &datasource.FakeQuerier{}
-		for _, r := range currentRules {
-			r.ID = config.HashRule(r)
-			g.Rules = append(g.Rules, g.newRule(qb, r))
+		for i := range oldG.Rules {
+			oldG.Rules[i].ID = config.HashRule(oldG.Rules[i])
+		}
+		for i := range newG.Rules {
+			newG.Rules[i].ID = config.HashRule(newG.Rules[i])
 		}
 
-		ng := &Group{
-			Name: "test",
-		}
-		for _, r := range newRules {
-			r.ID = config.HashRule(r)
-			ng.Rules = append(ng.Rules, ng.newRule(qb, r))
-		}
+		g := NewGroup(oldG, qb, 0, nil)
+		g.metrics = &groupMetrics{set: ns}
+		expect := NewGroup(newG, qb, 0, nil)
 
-		err := g.updateWith(ng)
+		err := g.updateWith(expect)
 		if err != nil {
 			t.Fatalf("cannot update rule: %s", err)
 		}
 
-		if len(g.Rules) != len(newRules) {
-			t.Fatalf("expected to have %d rules; got: %d", len(g.Rules), len(newRules))
+		if len(g.Rules) != len(expect.Rules) {
+			t.Fatalf("expected to have %d rules; got: %d", len(expect.Rules), len(g.Rules))
 		}
 		sort.Slice(g.Rules, func(i, j int) bool {
 			return g.Rules[i].ID() < g.Rules[j].ID()
 		})
-		sort.Slice(ng.Rules, func(i, j int) bool {
-			return ng.Rules[i].ID() < ng.Rules[j].ID()
+		sort.Slice(expect.Rules, func(i, j int) bool {
+			return expect.Rules[i].ID() < expect.Rules[j].ID()
 		})
 		for i, r := range g.Rules {
-			got, want := r, ng.Rules[i]
+			got, want := r, expect.Rules[i]
 			if got.ID() != want.ID() {
 				t.Fatalf("expected to have rule %q; got %q", want, got)
 			}
 			if err := CompareRules(t, got, want); err != nil {
-				t.Fatalf("comparison error: %s", err)
+				t.Fatalf("comparison1 error: %s", err)
 			}
 		}
+		if g.Debug != expect.Debug {
+			t.Fatalf("expected to have debug %v; got %v", expect.Debug, g.Debug)
+		}
 	}
 
 	// new rule
-	f(nil, []config.Rule{
-		{Alert: "bar"},
-	})
+	f(config.Group{}, config.Group{
+		Rules: []config.Rule{
+			{Alert: "bar"},
+		}})
 
 	// update alerting rule
-	f([]config.Rule{
-		{
-			Alert: "foo",
-			Expr:  "up > 0",
-			For:   promutil.NewDuration(time.Second),
+	f(config.Group{
+		Rules: []config.Rule{
+			{
+				Alert: "foo",
+				Expr:  "up > 0",
+				For:   promutil.NewDuration(time.Second),
+				Labels: map[string]string{
+					"bar": "baz",
+				},
+				Annotations: map[string]string{
+					"summary":     "{{ $value|humanize }}",
+					"description": "{{$labels}}",
+				},
+			},
+			{
+				Alert: "bar",
+				Expr:  "up > 0",
+				For:   promutil.NewDuration(time.Second),
+				Labels: map[string]string{
+					"bar": "baz",
+				},
+			},
+		}}, config.Group{
+		Rules: []config.Rule{
+			{
+				Alert: "foo",
+				Expr:  "up > 10",
+				For:   promutil.NewDuration(time.Second),
+				Labels: map[string]string{
+					"baz": "bar",
+				},
+				Annotations: map[string]string{
+					"summary": "none",
+				},
+			},
+			{
+				Alert:         "bar",
+				Expr:          "up > 0",
+				For:           promutil.NewDuration(2 * time.Second),
+				KeepFiringFor: promutil.NewDuration(time.Minute),
+				Labels: map[string]string{
+					"bar": "baz",
+				},
+			},
+		}})
+
+	// update recording rule
+	debug := true
+	f(config.Group{
+		Rules: []config.Rule{{
+			Record: "foo",
+			Expr:   "max(up)",
 			Labels: map[string]string{
 				"bar": "baz",
 			},
-			Annotations: map[string]string{
-				"summary":     "{{ $value|humanize }}",
-				"description": "{{$labels}}",
-			},
-		},
-		{
-			Alert: "bar",
-			Expr:  "up > 0",
-			For:   promutil.NewDuration(time.Second),
-			Labels: map[string]string{
-				"bar": "baz",
-			},
-		},
-	}, []config.Rule{
-		{
-			Alert: "foo",
-			Expr:  "up > 10",
-			For:   promutil.NewDuration(time.Second),
+		}}}, config.Group{
+		Rules: []config.Rule{{
+			Record: "foo",
+			Expr:   "min(up)",
+			Debug:  &debug,
 			Labels: map[string]string{
 				"baz": "bar",
 			},
-			Annotations: map[string]string{
-				"summary": "none",
-			},
-		},
-		{
-			Alert:         "bar",
-			Expr:          "up > 0",
-			For:           promutil.NewDuration(2 * time.Second),
-			KeepFiringFor: promutil.NewDuration(time.Minute),
-			Labels: map[string]string{
-				"bar": "baz",
-			},
-		},
-	})
+		}}})
 
-	// update recording rule
-	f([]config.Rule{{
-		Record: "foo",
-		Expr:   "max(up)",
-		Labels: map[string]string{
-			"bar": "baz",
-		},
-	}}, []config.Rule{{
-		Record: "foo",
-		Expr:   "min(up)",
-		Debug:  true,
-		Labels: map[string]string{
-			"baz": "bar",
-		},
-	}})
+	// update debug
+	f(config.Group{
+		Rules: []config.Rule{
+			{
+				Record: "foo",
+				Expr:   "max(up)",
+			},
+			{
+				Alert: "foo",
+				Expr:  "up > 0",
+				Debug: &debug,
+				For:   promutil.NewDuration(time.Second),
+			},
+		}}, config.Group{
+		Rules: []config.Rule{
+			{
+				Record: "foo",
+				Expr:   "max(up)",
+				Debug:  &debug,
+			},
+			{
+				Alert: "foo",
+				Expr:  "up > 0",
+				For:   promutil.NewDuration(time.Second),
+			},
+		}})
 
 	// empty rule
-	f([]config.Rule{{Alert: "foo"}, {Record: "bar"}}, nil)
+	f(config.Group{
+		Rules: []config.Rule{{Alert: "foo"}, {Record: "bar"}}}, config.Group{})
 
 	// multiple rules
-	f([]config.Rule{
-		{Alert: "bar"},
-		{Alert: "baz"},
-		{Alert: "foo"},
-	}, []config.Rule{
-		{Alert: "baz"},
-		{Record: "foo"},
-	})
+	f(config.Group{
+		Rules: []config.Rule{
+			{Alert: "bar"},
+			{Alert: "baz"},
+			{Alert: "foo"},
+		}}, config.Group{
+		Rules: []config.Rule{
+			{Alert: "baz"},
+			{Record: "foo"},
+		}})
 
 	// replace rule
-	f([]config.Rule{{Alert: "foo1"}}, []config.Rule{{Alert: "foo2"}})
+	f(config.Group{
+		Rules: []config.Rule{{Alert: "foo1"}}}, config.Group{
+		Rules: []config.Rule{{Alert: "foo2"}}})
 
 	// replace multiple rules
-	f([]config.Rule{
-		{Alert: "foo1"},
-		{Record: "foo2"},
-		{Alert: "foo3"},
-	}, []config.Rule{
-		{Alert: "foo3"},
-		{Alert: "foo4"},
-		{Record: "foo5"},
+	f(config.Group{
+		Rules: []config.Rule{
+			{Alert: "foo1"},
+			{Record: "foo2"},
+			{Alert: "foo3"},
+		}}, config.Group{
+		Rules: []config.Rule{
+			{Alert: "foo3"},
+			{Alert: "foo4"},
+			{Record: "foo5"},
+		}})
+
+	f(config.Group{Debug: false}, config.Group{Debug: true})
+	f(config.Group{
+		Debug: false,
+		Rules: []config.Rule{
+			{Alert: "foo1"},
+		},
+	}, config.Group{
+		Debug: true,
+		Rules: []config.Rule{
+			{Alert: "foo1"},
+		},
+	})
+
+	f(config.Group{
+		Debug: false,
+		Rules: []config.Rule{
+			{Alert: "foo1"},
+		},
+	}, config.Group{
+		Debug: false,
+		Rules: []config.Rule{
+			{Alert: "foo1", Debug: &debug},
+		},
 	})
 }
 
@@ -276,6 +338,7 @@ func TestGroupStart(t *testing.T) {
           summary: "{{ $value }}"
 `
 	)
+
 	var groups []config.Group
 	err := yaml.Unmarshal([]byte(rules), &groups)
 	if err != nil {
@@ -476,6 +539,7 @@ func TestCloseWithEvalInterruption(t *testing.T) {
           summary: "{{ $value }}"
 `
 	)
+
 	var groups []config.Group
 	err := yaml.Unmarshal([]byte(rules), &groups)
 	if err != nil {

app/vmalert/rule/recording.go

@@ -83,6 +83,10 @@ func (rr *RecordingRule) ID() uint64 {
 
 // NewRecordingRule creates a new RecordingRule
 func NewRecordingRule(qb datasource.QuerierBuilder, group *Group, cfg config.Rule) *RecordingRule {
+	debug := group.Debug
+	if cfg.Debug != nil {
+		debug = *cfg.Debug
+	}
 	rr := &RecordingRule{
 		Type:      group.Type,
 		RuleID:    cfg.ID,
@@ -92,14 +96,14 @@ func NewRecordingRule(qb datasource.QuerierBuilder, group *Group, cfg config.Rul
 		GroupID:   group.GetID(),
 		GroupName: group.Name,
 		File:      group.File,
-		Debug:     cfg.Debug,
+		Debug:     debug,
 		q: qb.BuildWithParams(datasource.QuerierParams{
 			DataSourceType:            group.Type.String(),
 			ApplyIntervalAsTimeFilter: setIntervalAsTimeFilter(group.Type.String(), cfg.Expr),
 			EvaluationInterval:        group.Interval,
 			QueryParams:               group.Params,
 			Headers:                   group.Headers,
-			Debug:                     cfg.Debug,
+			Debug:                     debug,
 		}),
 	}
 
@@ -278,6 +282,7 @@ func (rr *RecordingRule) updateWith(r Rule) error {
 	rr.Expr = nr.Expr
 	rr.Labels = nr.Labels
 	rr.q = nr.q
+	rr.Debug = nr.Debug
 	return nil
 }
 

app/vmalert/rule/rule.go

@@ -35,7 +35,7 @@ type Rule interface {
 	registerMetrics(set *metrics.Set)
 }
 
-var errDuplicate = errors.New("result contains metrics with the same labelset during evaluation. See https://docs.victoriametrics.com/vmalert/#series-with-the-same-labelset for details")
+var errDuplicate = errors.New("result contains metrics with the same labelset during evaluation. See https://docs.victoriametrics.com/victoriametrics/vmalert/#series-with-the-same-labelset for details")
 
 type ruleState struct {
 	sync.RWMutex

app/vmalert/static/css/custom.css

@@ -0,0 +1,101 @@
+html {
+  scroll-padding-top: 60px;
+}
+
+.nav-link svg {
+  fill: var(--bs-navbar-color);
+}
+
+.nav-link.active svg {
+  fill: var(--bs-navbar-active-color);
+}
+
+.nav-link:not(.active):hover svg {
+  fill: var(--bs-nav-link-hover-color);
+}
+
+.dropdown-menu {
+  --bs-dropdown-link-active-color: #000;
+  --bs-dropdown-link-active-bg: #e9e9e9;
+  & .dropdown-item.active {
+    font-weight: 700;
+  }
+}
+
+.dropdown-menu {
+  min-width: 0;
+}
+
+#search {
+  max-width: 400px;
+}
+
+body {
+  padding-top: 4.5rem;
+}
+
+.group-items {
+  cursor: pointer;
+  padding: 5px;
+  margin-top: 5px;
+  position: relative;
+}
+
+.btn svg, .dropdown-item svg {
+  fill: #000;
+  stroke: #000;
+}
+
+.btn:hover svg, .btn.show svg {
+  fill: #fff;
+  stroke: #fff;
+}
+
+.btn:has(svg) {
+  height: 38px;
+}
+
+.group-items:not(:has(.sub-item:not(.d-none))) {
+  display: none !important;
+}
+
+.group-items:hover {
+  background-color: #f8f9fa!important;
+}
+
+.table {
+  table-layout: fixed;
+}
+
+.table .error-cell {
+  word-break: break-word;
+  font-size: 14px;
+}
+
+pre {
+  overflow: scroll;
+  min-height: 30px;
+  max-width: 100%;
+}
+
+pre::-webkit-scrollbar {
+  -webkit-appearance: none;
+  width: 0px;
+  height: 5px;
+}
+
+pre::-webkit-scrollbar-thumb {
+  border-radius: 5px;
+  background-color: rgba(0,0,0,.5);
+  -webkit-box-shadow: 0 0 1px rgba(255,255,255,.5);
+}
+
+textarea.curl-area {
+  width: 100%;
+  line-height: 1;
+  font-size: 12px;
+  border: none;
+  margin: 0;
+  padding: 0;
+  overflow: scroll;
+}

app/vmalert/static/icons/icons.svg

@@ -0,0 +1,37 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="vm" viewBox="0 0 464.61 533.89">
+    <path d="M192.16 234.72c9 7.67 24.12 13.49 39.3 13.69h1.68c15.18-.2 30.31-6 39.3-13.69 47.43-40.45 184.65-166.24 184.65-166.24C493.93 34.21 391.45.2 233.14.01h-1.68C73.15.2-29.33 34.21 7.46 68.48c.05 0 137.27 125.79 184.7 166.24"/><path d="M272.4 302.83c-9 7.67-24.12 13.5-39.3 13.7h-1.6c-15.18-.2-30.31-6-39.3-13.7-32.81-28-148.56-132.93-192.16-172.7v60.74c0 6.67 2.55 15.52 7.09 19.68 29.64 27.18 143.94 131.8 185.07 166.88 9 7.67 24.12 13.49 39.3 13.69h1.6c15.18-.2 30.31-6 39.3-13.69 41.13-35.08 155.43-139.7 185.07-166.88 4.54-4.16 7.09-13 7.09-19.68v-60.74c-43.6 39.82-159.35 144.72-192.16 172.7"/><path d="M272.4 445.59c-9 7.67-24.12 13.49-39.3 13.69h-1.6c-15.18-.2-30.31-6-39.3-13.69-32.81-28-148.56-132.94-192.16-172.7v60.73c0 6.67 2.55 15.53 7.09 19.69 29.64 27.17 143.94 131.8 185.07 166.87 9 7.67 24.12 13.5 39.3 13.7h1.6c15.18-.2 30.31-6 39.3-13.7 41.13-35.07 155.43-139.7 185.07-166.87 4.54-4.16 7.09-13 7.09-19.69v-60.73c-43.6 39.76-159.35 144.72-192.16 172.7"/>
+  </symbol>
+
+  <symbol id="collapse" viewBox="3 2 42 44">
+    <path d="M22.6 15.4a1.9 1.9 0 0 0 2.8 0l6-5.9a2.1 2.1 0 0 0 .2-2.7 1.9 1.9 0 0 0-3-.2L26 9.2V4a2 2 0 0 0-4 0v5.2l-2.6-2.6a1.9 1.9 0 0 0-3 .2 2.1 2.1 0 0 0 .2 2.7Zm2.8 17.2a1.9 1.9 0 0 0-2.8 0l-6 5.9a2.1 2.1 0 0 0-.2 2.7 1.9 1.9 0 0 0 3 .2l2.6-2.6V44a2 2 0 0 0 4 0v-5.2l2.6 2.6a1.9 1.9 0 0 0 3-.2 2.1 2.1 0 0 0-.2-2.7ZM6 22h36a2 2 0 0 0 0-4H6a2 2 0 0 0 0 4m36 4H6a2 2 0 0 0 0 4h36a2 2 0 0 0 0-4"/>
+  </symbol>
+
+  <symbol id="expand" viewBox="205.701 131.84 40.006 44.045">
+    <path d="M224.163 175.27a1.9 1.9 0 0 0 2.8 0l6-5.9a2.1 2.1 0 0 0 .2-2.7 1.9 1.9 0 0 0-3-.2l-2.6 2.6v-5.2c0-1.54-1.667-2.502-3-1.732-.619.357-1 1.017-1 1.732v5.2l-2.6-2.6a1.9 1.9 0 0 0-3 .2 2.1 2.1 0 0 0 .2 2.7zm-16.459-23.297h36c1.54 0 2.502-1.667 1.732-3a2 2 0 0 0-1.732-1h-36c-1.54 0-2.502 1.667-1.732 3 .357.619 1.017 1 1.732 1m36 4h-36c-1.54 0-2.502 1.667-1.732 3 .357.619 1.017 1 1.732 1h36c1.54 0 2.502-1.667 1.732-3a2 2 0 0 0-1.732-1m-16.59-23.517a1.9 1.9 0 0 0-2.8 0l-6 5.9a2.1 2.1 0 0 0-.2 2.7 1.9 1.9 0 0 0 3 .2l2.6-2.6v5.2c0 1.54 1.667 2.502 3 1.732.619-.357 1-1.017 1-1.732v-5.2l2.6 2.6a1.9 1.9 0 0 0 3-.2 2.1 2.1 0 0 0-.2-2.7z"/>
+  </symbol>
+
+  <symbol id="filter" viewBox="-10 -10 320 310">
+    <path d="M288.953 0h-277c-5.522 0-10 4.478-10 10v49.531c0 5.522 4.478 10 10 10h12.372l91.378 107.397v113.978a10 10 0 0 0 15.547 8.32l49.5-33a10 10 0 0 0 4.453-8.32v-80.978l91.378-107.397h12.372c5.522 0 10-4.478 10-10V10c0-5.522-4.477-10-10-10M167.587 166.77a10 10 0 0 0-2.384 6.48v79.305l-29.5 19.666V173.25a10 10 0 0 0-2.384-6.48L50.585 69.531h199.736zM278.953 49.531h-257V20h257z"/>
+  </symbol>
+
+  <symbol id="search" viewBox="0 0 490.4 490.4">
+    <path d="m484.1 454.796-110.5-110.6c29.8-36.3 47.6-82.8 47.6-133.4 0-116.3-94.3-210.6-210.6-210.6S0 94.496 0 210.796s94.3 210.6 210.6 210.6c50.8 0 97.4-18 133.8-48l110.5 110.5c12.9 11.8 25 4.2 29.2 0 8.4-8.3 8.4-20.8 0-29.1m-443-244c0-93.6 75.9-169.5 169.5-169.5s169.6 75.9 169.6 169.5-75.9 169.5-169.5 169.5-169.6-75.9-169.6-169.5"/>
+  </symbol>
+
+  <symbol id="all" viewBox="-10 -10 320 310">
+    <path d="M288.953 0h-277c-5.522 0-10 4.478-10 10v49.531c0 5.522 4.478 10 10 10h12.372l91.378 107.397v113.978a10 10 0 0 0 15.547 8.32l49.5-33a10 10 0 0 0 4.453-8.32v-80.978l91.378-107.397h12.372c5.522 0 10-4.478 10-10V10c0-5.522-4.477-10-10-10M167.587 166.77a10 10 0 0 0-2.384 6.48v79.305l-29.5 19.666V173.25a10 10 0 0 0-2.384-6.48L50.585 69.531h199.736zM278.953 49.531h-257V20h257z"/><path stroke-width="20" stroke="#000" d="m-10-10 310 310"/>
+  </symbol>
+
+  <symbol id="nomatch" viewBox="0 0 116.623 116.623">
+    <path d="M99.114 89.251H57.783l19.181-41.797h22.149a5.971 5.971 0 1 0 0-11.942H82.444L94.591 9.049a5.97 5.97 0 0 0-2.938-7.917 5.97 5.97 0 0 0-7.918 2.936L69.304 35.513H41.662c-2.289-.458-17.685-4.48-17.685-29.542a5.97 5.97 0 1 0-11.942 0c0 18.536 7.157 29.533 14.93 35.514-7.774 5.981-14.93 16.978-14.93 35.514a5.971 5.971 0 1 0 11.942 0c0-25.007 14.886-29.013 17.677-29.542h22.17L44.643 89.253H17.509a5.972 5.972 0 0 0 0 11.943h21.653l-3.196 6.965a5.972 5.972 0 1 0 10.856 4.981l5.479-11.943h46.812a5.975 5.975 0 0 0 .001-11.948"/>
+  </symbol>
+
+  <symbol id="exclamation" viewBox="0 0 16 16">
+    <path d="M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16zm.93-9.412-1 4.705c-.07.34.029.533.304.533.194 0 .487-.07.686-.246l-.088.416c-.287.346-.92.598-1.465.598-.703 0-1.002-.422-.808-1.319l.738-3.468c.064-.293.006-.399-.287-.47l-.451-.081.082-.381 2.29-.287zM8 5.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2z"/>
+  </symbol>
+
+  <symbol id="unhealthy" viewBox="0 0 14 14">
+    <circle cx="7" cy="7" r="6.5" stroke="#000" fill="none"/><path stroke-linecap="round" stroke="#000" stroke-width="1.5" d="m5 5 4 4M5 9l4-4"/>
+  </symbol>
+</svg>

app/vmalert/static/js/custom.js

@@ -1,38 +1,32 @@
-function expandAll() {
-    $('.group-heading').each(function () {
-        let style = $(this).attr("style")
-        // display only elements that are currently visible
-        if (style === "display: none;") {
-            return
+function actionAll(isCollapse) {
+    document.querySelectorAll('.collapse').forEach((collapse) => {
+        if (isCollapse) {
+            collapse.classList.remove('show');
+        } else {
+            collapse.classList.add('show');
         }
-        $(this).next().addClass('show')
     });
 }
 
-function collapseAll() {
-    $('.collapse').removeClass('show');
-}
-
-function showByID(id) {
-    if (!id) {
-        return
-    }
-    let parent = $("#" + id).parent();
-    if (!parent) {
-        return
-    }
-    let target = $("#" + parent.attr("data-bs-target"));
-    if (target.length > 0) {
-        target.addClass('show');
+function groupFilter(key) {
+    if (key) {
+        location.href = `?filter=${key}`;
+    } else {
+        window.location = window.location.pathname;
     }
 }
 
-function toggleByID(id) {
-    if (id) {
-        let el = $("#" + id);
-        if (el.length > 0) {
-            el.click();
-        }
+function showBySelector(selector) {
+    if (!selector) {
+        return
+    }
+    const control = document.querySelector(`${selector} [data-bs-target]`);
+    if (!control) {
+        return
+    }
+    let target = document.getElementById(control.getAttribute('data-bs-target').slice(1));
+    if (target) {
+        target.classList.add('show');
     }
 }
 
@@ -46,28 +40,16 @@ function debounce(func, delay) {
     };
 }
 
-$('#search').on("keyup", debounce(search, 500));
-
 // search shows or hides groups&rules that satisfy the search phrase.
 // case-insensitive, respects GET param `search`.
 function search() {
-    $(".rule").show();
-
-    let groupHeader = $(".group-heading")
-    let searchPhrase = $("#search").val().toLowerCase()
-    if (searchPhrase.length === 0) {
-        groupHeader.show()
-        setParamURL('search', '')
-        return
+    let searchBox = document.getElementById('search');
+    if (!searchBox) {
+        return;
     }
+    const searchPhrase = searchBox.value.toLowerCase();
 
-    $(".rule-table").removeClass('show');
-    groupHeader.hide()
-
-    searchPhrase = searchPhrase.toLowerCase()
-    filterRuleByName(searchPhrase);
-    filterRuleByLabels(searchPhrase);
-    filterGroupsByName(searchPhrase);
+    filterRules(searchPhrase);
 
     setParamURL('search', searchPhrase)
 }
@@ -83,81 +65,51 @@ function getParamURL(key) {
     return url.searchParams.get(key)
 }
 
-function filterGroupsByName(searchPhrase) {
-    $(".group-heading").each(function () {
-        const groupName = $(this).attr('data-group-name').toLowerCase();
-        const hasValue = groupName.indexOf(searchPhrase) >= 0
-
-        if (!hasValue) {
-            return
-        }
-
-        const target = $(this).attr("data-bs-target");
-        $(`div[id="${target}"] .rule`).show();
-        $(this).show();
-    });
-}
-
-function filterRuleByName(searchPhrase) {
-    $(".rule").each(function () {
-        const ruleName = $(this).attr("data-rule-name").toLowerCase();
-        const hasValue = ruleName.indexOf(searchPhrase) >= 0
-        if (!hasValue) {
-            $(this).hide();
-            return
-        }
-
-        const target = $(this).attr('data-bs-target')
-        $(`#rules-${target}`).addClass('show');
-        $(`div[data-bs-target='rules-${target}']`).show();
-        $(this).show();
-    });
-}
-
-function filterRuleByLabels(searchPhrase) {
-    $(".rule").each(function () {
-        const matches = $(".label", this).filter(function () {
-            const label = $(this).text().toLowerCase();
-            return label.indexOf(searchPhrase) >= 0;
-        }).length;
-
-        if (matches > 0) {
-            const target = $(this).attr('data-bs-target')
-            $(`#rules-${target}`).addClass('show');
-            $(`div[data-bs-target='rules-${target}']`).show();
-            $(this).show();
-        }
-    });
-}
-
-$(document).ready(function () {
-    $(".group-heading a").click(function (e) {
-        e.stopPropagation(); // prevent collapse logic on link click
-        let target = $(this).attr('href');
-        if (target.length > 0) {
-            toggleByID(target.substr(1));
-        }
-    });
-
-    $(".group-heading").click(function (e) {
-        let target = $(this).attr('data-bs-target');
-        let el = $("#" + target);
-        new bootstrap.Collapse(el, {
-            toggle: true
+function filterRules(searchPhrase) {
+    document.querySelectorAll('.sub-items').forEach((rules) => {
+        let found = false;
+        rules.querySelectorAll('.sub-item').forEach((rule) => {
+            if (searchPhrase) {
+                const ruleName = rule.innerText.toLowerCase();
+                const matches = []
+                const hasValue = ruleName.indexOf(searchPhrase) >= 0;
+                rule.querySelectorAll('.label').forEach((label) => {
+                    const text = label.innerText.toLowerCase();
+                    if (text.indexOf(searchPhrase) >= 0) {
+                        matches.push(text);
+                    }
+                });
+                if (!matches.length && !hasValue) {
+                    rule.classList.add('d-none');
+                    return;
+                }
+            }
+            rule.classList.remove('d-none');
+            found = true;
         });
+        if (found && searchPhrase || !searchPhrase) {
+            rules.classList.remove('d-none');
+        } else {
+            rules.classList.add('d-none');
+        }
     });
+}
 
+document.addEventListener('DOMContentLoaded', () => {
     // update search element with value from URL, if any
-    let searchPhrase = getParamURL('search')
-    $("#search").val(searchPhrase)
+    const searchPhrase = getParamURL('search')
+    const searchBox = document.getElementById('search');
+    if (searchBox) {
+        searchBox.addEventListener('keyup', debounce(search, 500));
+        searchBox.value = searchPhrase;
+    }
 
     // apply filtering by search phrase
     search()
 
-    let hash = window.location.hash.substr(1);
-    showByID(hash);
-});
+    showBySelector(window.location.hash);
 
-$(document).ready(function () {
-    $('[data-bs-toggle="tooltip"]').tooltip();
+    document.querySelectorAll('[data-bs-toggle="tooltip"]').forEach((tooltip) => {
+        new bootstrap.Tooltip(tooltip);
+    });
 });

app/vmalert/tpl/footer.qtpl

@@ -1,16 +1,10 @@
 {% import (
     "net/http"
-
-    "github.com/VictoriaMetrics/VictoriaMetrics/app/vmalert/vmalertutil"
 ) %}
 
 
 {% func Footer(r *http.Request) %}
-    {%code prefix := vmalertutil.Prefix(r.URL.Path) %}
         </main>
-        <script src="{%s prefix %}static/js/jquery-3.6.0.min.js" type="text/javascript"></script>
-        <script src="{%s prefix %}static/js/bootstrap.bundle.min.js" type="text/javascript"></script>
-        <script src="{%s prefix %}static/js/custom.js" type="text/javascript"></script>
     </body>
 </html>
 {% endfunc %}