diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c9040d9fa9..df38bb5bba 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -37,7 +37,7 @@ jobs:
 
       - name: Setup Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: stable
           cache: false
diff --git a/.github/workflows/check-licenses.yml b/.github/workflows/check-licenses.yml
index 583b55a0a1..c93a15c052 100644
--- a/.github/workflows/check-licenses.yml
+++ b/.github/workflows/check-licenses.yml
@@ -19,7 +19,7 @@ jobs:
 
       - name: Setup Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: stable
           cache: false
diff --git a/.github/workflows/codeql-analysis-go.yml b/.github/workflows/codeql-analysis-go.yml
index 5b42aa1f61..c647ca9e40 100644
--- a/.github/workflows/codeql-analysis-go.yml
+++ b/.github/workflows/codeql-analysis-go.yml
@@ -31,7 +31,7 @@ jobs:
 
       - name: Set up Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           cache: false
           go-version: stable
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 868d9116e4..c2beb1e4c2 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -33,7 +33,7 @@ jobs:
 
       - name: Setup Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           cache: false
           go-version: stable
@@ -71,7 +71,7 @@ jobs:
 
       - name: Setup Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           cache: false
           go-version: stable
@@ -105,7 +105,7 @@ jobs:
 
       - name: Setup Go
         id: go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           cache: false
           go-version: stable
diff --git a/.github/workflows/vmui.yml b/.github/workflows/vmui.yml
index 683d3d0903..04c023bef6 100644
--- a/.github/workflows/vmui.yml
+++ b/.github/workflows/vmui.yml
@@ -33,7 +33,7 @@ jobs:
         uses: actions/checkout@v5
 
       - name: Setup Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: '24.x'
 
diff --git a/app/vlinsert/elasticsearch/elasticsearch.go b/app/vlinsert/elasticsearch/elasticsearch.go
index bcf1390711..56b6d3993c 100644
--- a/app/vlinsert/elasticsearch/elasticsearch.go
+++ b/app/vlinsert/elasticsearch/elasticsearch.go
@@ -187,7 +187,10 @@ func readBulkLine(lr *insertutil.LineReader, timeFields, msgFields []string, lmp
 		// Continue parsing next lines.
 		return true, nil
 	}
+
 	p := logstorage.GetJSONParser()
+	defer logstorage.PutJSONParser(p)
+
 	if err := p.ParseLogMessage(line); err != nil {
 		return false, fmt.Errorf("cannot parse json-encoded log entry: %w", err)
 	}
@@ -201,7 +204,6 @@ func readBulkLine(lr *insertutil.LineReader, timeFields, msgFields []string, lmp
 	}
 	logstorage.RenameField(p.Fields, msgFields, "_msg")
 	lmp.AddRow(ts, p.Fields, nil)
-	logstorage.PutJSONParser(p)
 
 	return true, nil
 }
diff --git a/app/vlinsert/opentelemetry/opentelemetry.go b/app/vlinsert/opentelemetry/opentelemetry.go
index ebee79c51d..ad1db77f88 100644
--- a/app/vlinsert/opentelemetry/opentelemetry.go
+++ b/app/vlinsert/opentelemetry/opentelemetry.go
@@ -50,7 +50,7 @@ func handleProtobuf(r *http.Request, w http.ResponseWriter) {
 
 	encoding := r.Header.Get("Content-Encoding")
 	err = protoparserutil.ReadUncompressedData(r.Body, encoding, maxRequestSize, func(data []byte) error {
-		lmp := cp.NewLogMessageProcessor("opentelelemtry_protobuf", false)
+		lmp := cp.NewLogMessageProcessor("opentelemetry_protobuf", false)
 		useDefaultStreamFields := len(cp.StreamFields) == 0
 		err := pushProtobufRequest(data, lmp, cp.MsgFields, useDefaultStreamFields)
 		lmp.MustClose()
diff --git a/app/vlinsert/syslog/syslog.go b/app/vlinsert/syslog/syslog.go
index 46b2df8db3..3fefd4241f 100644
--- a/app/vlinsert/syslog/syslog.go
+++ b/app/vlinsert/syslog/syslog.go
@@ -35,65 +35,84 @@ var (
 	syslogTimezone = flag.String("syslog.timezone", "Local", "Timezone to use when parsing timestamps in RFC3164 syslog messages. Timezone must be a valid IANA Time Zone. "+
 		"For example: America/New_York, Europe/Berlin, Etc/GMT+3 . See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
 
+	listenAddrTCP = flagutil.NewArrayString("syslog.listenAddr.tcp", "Comma-separated list of TCP addresses to listen to for Syslog messages. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
+	listenAddrUDP = flagutil.NewArrayString("syslog.listenAddr.udp", "Comma-separated list of UDP addresses to listen to for Syslog messages. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
+	listenAddrUnix = flagutil.NewArrayString("syslog.listenAddr.unix", "Comma-separated list of Unix socket filepaths to listen to for Syslog messages. "+
+		"Filepaths may be prepended with 'unixgram:'  for listening for SOCK_DGRAM sockets. By default SOCK_STREAM sockets are used. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
+
+	tlsEnable = flagutil.NewArrayBool("syslog.tls", "Whether to enable TLS for receiving syslog messages at the corresponding -syslog.listenAddr.tcp. "+
+		"The corresponding -syslog.tlsCertFile and -syslog.tlsKeyFile must be set if -syslog.tls is set. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+	tlsCertFile = flagutil.NewArrayString("syslog.tlsCertFile", "Path to file with TLS certificate for the corresponding -syslog.listenAddr.tcp if the corresponding -syslog.tls is set. "+
+		"Prefer ECDSA certs instead of RSA certs as RSA certs are slower. The provided certificate file is automatically re-read every second, so it can be dynamically updated. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+	tlsKeyFile = flagutil.NewArrayString("syslog.tlsKeyFile", "Path to file with TLS key for the corresponding -syslog.listenAddr.tcp if the corresponding -syslog.tls is set. "+
+		"The provided key file is automatically re-read every second, so it can be dynamically updated. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+	tlsCipherSuites = flagutil.NewArrayString("syslog.tlsCipherSuites", "Optional list of TLS cipher suites for -syslog.listenAddr.tcp if -syslog.tls is set. "+
+		"See the list of supported cipher suites at https://pkg.go.dev/crypto/tls#pkg-constants . "+
+		"See also https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+	tlsMinVersion = flag.String("syslog.tlsMinVersion", "TLS13", "The minimum TLS version to use for -syslog.listenAddr.tcp if -syslog.tls is set. "+
+		"Supported values: TLS10, TLS11, TLS12, TLS13. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+
 	streamFieldsTCP = flagutil.NewArrayString("syslog.streamFields.tcp", "Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.tcp. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields`)
 	streamFieldsUDP = flagutil.NewArrayString("syslog.streamFields.udp", "Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.udp. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields`)
+	streamFieldsUnix = flagutil.NewArrayString("syslog.streamFields.unix", "Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.unix. "+
+		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields`)
 
 	ignoreFieldsTCP = flagutil.NewArrayString("syslog.ignoreFields.tcp", "Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.tcp. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields`)
 	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`)
+	ignoreFieldsUnix = flagutil.NewArrayString("syslog.ignoreFields.unix", "Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.unix. "+
+		`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`)
+	decolorizeFieldsUnix = flagutil.NewArrayString("syslog.decolorizeFields.unix", "Fields to remove ANSI color codes across logs ingested via the corresponding -syslog.listenAddr.unix. "+
+		`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. "+
 		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields`)
+	extraFieldsUnix = flagutil.NewArrayString("syslog.extraFields.unix", "Fields to add to logs ingested via the corresponding -syslog.listenAddr.unix. "+
+		`See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields`)
 
 	tenantIDTCP = flagutil.NewArrayString("syslog.tenantID.tcp", "TenantID for logs ingested via the corresponding -syslog.listenAddr.tcp. "+
 		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy")
 	tenantIDUDP = flagutil.NewArrayString("syslog.tenantID.udp", "TenantID for logs ingested via the corresponding -syslog.listenAddr.udp. "+
 		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy")
-
-	listenAddrTCP = flagutil.NewArrayString("syslog.listenAddr.tcp", "Comma-separated list of TCP addresses to listen to for Syslog messages. "+
-		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
-	listenAddrUDP = flagutil.NewArrayString("syslog.listenAddr.udp", "Comma-separated list of UDP address to listen to for Syslog messages. "+
-		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/")
-
-	tlsEnable = flagutil.NewArrayBool("syslog.tls", "Whether to enable TLS for receiving syslog messages at the corresponding -syslog.listenAddr.tcp. "+
-		"The corresponding -syslog.tlsCertFile and -syslog.tlsKeyFile must be set if -syslog.tls is set. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
-	tlsCertFile = flagutil.NewArrayString("syslog.tlsCertFile", "Path to file with TLS certificate for the corresponding -syslog.listenAddr.tcp if the corresponding -syslog.tls is set. "+
-		"Prefer ECDSA certs instead of RSA certs as RSA certs are slower. The provided certificate file is automatically re-read every second, so it can be dynamically updated. "+
-		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
-	tlsKeyFile = flagutil.NewArrayString("syslog.tlsKeyFile", "Path to file with TLS key for the corresponding -syslog.listenAddr.tcp if the corresponding -syslog.tls is set. "+
-		"The provided key file is automatically re-read every second, so it can be dynamically updated. "+
-		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
-	tlsCipherSuites = flagutil.NewArrayString("syslog.tlsCipherSuites", "Optional list of TLS cipher suites for -syslog.listenAddr.tcp if -syslog.tls is set. "+
-		"See the list of supported cipher suites at https://pkg.go.dev/crypto/tls#pkg-constants . "+
-		"See also https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
-	tlsMinVersion = flag.String("syslog.tlsMinVersion", "TLS13", "The minimum TLS version to use for -syslog.listenAddr.tcp if -syslog.tls is set. "+
-		"Supported values: TLS10, TLS11, TLS12, TLS13. "+
-		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security")
+	tenantIDUnix = flagutil.NewArrayString("syslog.tenantID.unix", "TenantID for logs ingested via the corresponding -syslog.listenAddr.unix. "+
+		"See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy")
 
 	compressMethodTCP = flagutil.NewArrayString("syslog.compressMethod.tcp", "Compression method for syslog messages received at the corresponding -syslog.listenAddr.tcp. "+
 		"Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression")
 	compressMethodUDP = flagutil.NewArrayString("syslog.compressMethod.udp", "Compression method for syslog messages received at the corresponding -syslog.listenAddr.udp. "+
 		"Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression")
+	compressMethodUnix = flagutil.NewArrayString("syslog.compressMethod.unix", "Compression method for syslog messages received at the corresponding -syslog.listenAddr.unix. "+
+		"Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression")
 
 	useLocalTimestampTCP = flagutil.NewArrayBool("syslog.useLocalTimestamp.tcp", "Whether to use local timestamp instead of the original timestamp for the ingested syslog messages "+
 		"at the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps")
 	useLocalTimestampUDP = flagutil.NewArrayBool("syslog.useLocalTimestamp.udp", "Whether to use local timestamp instead of the original timestamp for the ingested syslog messages "+
 		"at the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps")
+	useLocalTimestampUnix = flagutil.NewArrayBool("syslog.useLocalTimestamp.unix", "Whether to use local timestamp instead of the original timestamp for the ingested syslog messages "+
+		"at the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps")
 
 	useRemoteIPTCP = flagutil.NewArrayBool("syslog.useRemoteIP.tcp", "Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested "+
 		"via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address")
 	useRemoteIPUDP = flagutil.NewArrayBool("syslog.useRemoteIP.udp", "Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested "+
 		"via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address")
+	useRemoteIPUnix = flagutil.NewArrayBool("syslog.useRemoteIP.unix", "Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested "+
+		"via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address")
 )
 
 // MustInit initializes syslog parser at the given -syslog.listenAddr.tcp and -syslog.listenAddr.udp ports
@@ -123,6 +142,14 @@ func MustInit() {
 		}(addr, argIdx)
 	}
 
+	for argIdx, addr := range *listenAddrUnix {
+		workersWG.Add(1)
+		go func(addr string, argIdx int) {
+			runUnixListener(addr, argIdx)
+			workersWG.Done()
+		}(addr, argIdx)
+	}
+
 	currentYear := time.Now().Year()
 	globalCurrentYear.Store(int64(currentYear))
 	workersWG.Add(1)
@@ -169,51 +196,91 @@ func MustStop() {
 	workersStopCh = nil
 }
 
-func runUDPListener(addr string, argIdx int) {
-	ln, err := net.ListenPacket(netutil.GetUDPNetwork(), addr)
+func runUnixListener(addr string, argIdx int) {
+	cfg, err := getConfigs("unix", argIdx, streamFieldsUnix, ignoreFieldsUnix, decolorizeFieldsUnix, extraFieldsUnix, tenantIDUnix, compressMethodUnix, useLocalTimestampUnix, useRemoteIPUnix)
 	if err != nil {
-		logger.Fatalf("cannot start UDP syslog server at %q: %s", addr, err)
+		logger.Fatalf("cannot parse configs for -syslog.listenAddr.unix=%q: %s", addr, err)
 	}
 
-	tenantIDStr := tenantIDUDP.GetOptionalArg(argIdx)
-	tenantID, err := logstorage.ParseTenantID(tenantIDStr)
+	laddr := getUnixSocketNetworkAndPath(addr)
+	if laddr.Net == "unix" {
+		runUnixStreamListener(laddr, cfg)
+	} else {
+		runUnixPacketListener(laddr, cfg)
+	}
+}
+
+func runUnixStreamListener(laddr *net.UnixAddr, cfg *configs) {
+	ln, err := net.ListenUnix(laddr.Net, laddr)
 	if err != nil {
-		logger.Fatalf("cannot parse -syslog.tenantID.udp=%q for -syslog.listenAddr.udp=%q: %s", tenantIDStr, addr, err)
+		logger.Fatalf("cannot start Unix socket syslog server at %q: %s", laddr, err)
 	}
 
-	compressMethod := compressMethodUDP.GetOptionalArg(argIdx)
-	checkCompressMethod(compressMethod, addr, "udp")
+	doneCh := make(chan struct{})
+	go func() {
+		serveStreamListener(ln, cfg)
+		close(doneCh)
+	}()
 
-	useLocalTimestamp := useLocalTimestampUDP.GetOptionalArg(argIdx)
-	useRemoteIP := useRemoteIPUDP.GetOptionalArg(argIdx)
+	logger.Infof("started accepting syslog messages at %q", laddr)
+	<-workersStopCh
+	if err := ln.Close(); err != nil {
+		logger.Fatalf("syslog: cannot close UDP listener at %s: %s", laddr, err)
+	}
+	<-doneCh
+	logger.Infof("finished accepting syslog messages at -syslog.listenAddr.unix=%q", laddr)
+}
 
-	streamFieldsStr := streamFieldsUDP.GetOptionalArg(argIdx)
-	streamFields, err := parseFieldsList(streamFieldsStr)
+func runUnixPacketListener(laddr *net.UnixAddr, cfg *configs) {
+	ln, err := net.ListenUnixgram(laddr.Net, laddr)
 	if err != nil {
-		logger.Fatalf("cannot parse -syslog.streamFields.udp=%q for -syslog.listenAddr.udp=%q: %s", streamFieldsStr, addr, err)
+		logger.Fatalf("cannot start Unix socket syslog server at %q: %s", laddr, err)
 	}
 
-	ignoreFieldsStr := ignoreFieldsUDP.GetOptionalArg(argIdx)
-	ignoreFields, err := parseFieldsList(ignoreFieldsStr)
-	if err != nil {
-		logger.Fatalf("cannot parse -syslog.ignoreFields.udp=%q for -syslog.listenAddr.udp=%q: %s", ignoreFieldsStr, addr, err)
+	doneCh := make(chan struct{})
+	go func() {
+		servePacketListener(ln, cfg)
+		close(doneCh)
+	}()
+
+	logger.Infof("started accepting syslog messages at %q", laddr)
+	<-workersStopCh
+	if err := ln.Close(); err != nil {
+		logger.Fatalf("syslog: cannot close UDP listener at %s: %s", laddr, err)
 	}
+	<-doneCh
+	logger.Infof("finished accepting syslog messages at %q", laddr)
+}
 
-	decolorizeFieldsStr := decolorizeFieldsUDP.GetOptionalArg(argIdx)
-	decolorizeFields, err := parseFieldsList(decolorizeFieldsStr)
+func getUnixSocketNetworkAndPath(addr string) *net.UnixAddr {
+	// An optional network such as unix or unixgram can be specified in front of addr and followed by ':'
+	n := strings.IndexByte(addr, ':')
+	if n < 0 {
+		return &net.UnixAddr{
+			Net:  "unix",
+			Name: addr,
+		}
+	}
+	return &net.UnixAddr{
+		Net:  addr[:n],
+		Name: addr[n+1:],
+	}
+}
+
+func runUDPListener(addr string, argIdx int) {
+	ln, err := net.ListenPacket(netutil.GetUDPNetwork(), addr)
 	if err != nil {
-		logger.Fatalf("cannot parse -syslog.decolorizeFields.udp=%q for -syslog.listenAddr.udp=%q: %s", decolorizeFieldsStr, addr, err)
+		logger.Fatalf("cannot start UDP syslog server at %q: %s", addr, err)
 	}
 
-	extraFieldsStr := extraFieldsUDP.GetOptionalArg(argIdx)
-	extraFields, err := parseExtraFields(extraFieldsStr)
+	cfg, err := getConfigs("udp", argIdx, streamFieldsUDP, ignoreFieldsUDP, decolorizeFieldsUDP, extraFieldsUDP, tenantIDUDP, compressMethodUDP, useLocalTimestampUDP, useRemoteIPUDP)
 	if err != nil {
-		logger.Fatalf("cannot parse -syslog.extraFields.udp=%q for -syslog.listenAddr.udp=%q: %s", extraFieldsStr, addr, err)
+		logger.Fatalf("cannot parse configs for -syslog.listenAddr.udp=%q: %s", addr, err)
 	}
 
 	doneCh := make(chan struct{})
 	go func() {
-		serveUDP(ln, tenantID, compressMethod, useLocalTimestamp, useRemoteIP, streamFields, ignoreFields, decolorizeFields, extraFields)
+		servePacketListener(ln, cfg)
 		close(doneCh)
 	}()
 
@@ -243,45 +310,14 @@ func runTCPListener(addr string, argIdx int) {
 		logger.Fatalf("syslog: cannot start TCP listener at %s: %s", addr, err)
 	}
 
-	tenantIDStr := tenantIDTCP.GetOptionalArg(argIdx)
-	tenantID, err := logstorage.ParseTenantID(tenantIDStr)
-	if err != nil {
-		logger.Fatalf("cannot parse -syslog.tenantID.tcp=%q for -syslog.listenAddr.tcp=%q: %s", tenantIDStr, addr, err)
-	}
-
-	compressMethod := compressMethodTCP.GetOptionalArg(argIdx)
-	checkCompressMethod(compressMethod, addr, "tcp")
-
-	useLocalTimestamp := useLocalTimestampTCP.GetOptionalArg(argIdx)
-	useRemoteIP := useRemoteIPTCP.GetOptionalArg(argIdx)
-
-	streamFieldsStr := streamFieldsTCP.GetOptionalArg(argIdx)
-	streamFields, err := parseFieldsList(streamFieldsStr)
-	if err != nil {
-		logger.Fatalf("cannot parse -syslog.streamFields.tcp=%q for -syslog.listenAddr.tcp=%q: %s", streamFieldsStr, addr, err)
-	}
-
-	ignoreFieldsStr := ignoreFieldsTCP.GetOptionalArg(argIdx)
-	ignoreFields, err := parseFieldsList(ignoreFieldsStr)
-	if err != nil {
-		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)
+	cfg, err := getConfigs("tcp", argIdx, streamFieldsTCP, ignoreFieldsTCP, decolorizeFieldsTCP, extraFieldsTCP, tenantIDTCP, compressMethodTCP, useLocalTimestampTCP, useRemoteIPTCP)
 	if err != nil {
-		logger.Fatalf("cannot parse -syslog.extraFields.tcp=%q for -syslog.listenAddr.tcp=%q: %s", extraFieldsStr, addr, err)
+		logger.Fatalf("cannot parse configs for -syslog.listenAddr.tcp=%q: %s", addr, err)
 	}
 
 	doneCh := make(chan struct{})
 	go func() {
-		serveTCP(ln, tenantID, compressMethod, useLocalTimestamp, useRemoteIP, streamFields, ignoreFields, decolorizeFields, extraFields)
+		serveStreamListener(ln, cfg)
 		close(doneCh)
 	}()
 
@@ -294,16 +330,7 @@ func runTCPListener(addr string, argIdx int) {
 	logger.Infof("finished accepting syslog messages at -syslog.listenAddr.tcp=%q", addr)
 }
 
-func checkCompressMethod(compressMethod, addr, protocol string) {
-	switch compressMethod {
-	case "", "none", "zstd", "gzip", "deflate":
-		return
-	default:
-		logger.Fatalf("unsupported -syslog.compressMethod.%s=%q for -syslog.listenAddr.%s=%q; supported values: 'none', 'zstd', 'gzip', 'deflate'", protocol, compressMethod, protocol, addr)
-	}
-}
-
-func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string, useLocalTimestamp bool, useRemoteIP bool, streamFields, ignoreFields, decolorizeFields []string, extraFields []logstorage.Field) {
+func servePacketListener(ln net.PacketConn, cfg *configs) {
 	gomaxprocs := cgroup.AvailableCPUs()
 	var wg sync.WaitGroup
 	localAddr := ln.LocalAddr()
@@ -311,7 +338,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, decolorizeFields, extraFields)
+			cp := insertutil.GetCommonParamsForSyslog(cfg.tenantID, cfg.streamFields, cfg.ignoreFields, cfg.decolorizeFields, cfg.extraFields)
 			var bb bytesutil.ByteBuffer
 			bb.B = bytesutil.ResizeNoCopyNoOverallocate(bb.B, 64*1024)
 			for {
@@ -323,7 +350,7 @@ func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string,
 					var ne net.Error
 					if errors.As(err, &ne) {
 						if ne.Temporary() {
-							logger.Errorf("syslog: temporary error when listening for UDP at %q: %s", localAddr, err)
+							logger.Errorf("syslog: temporary error when listening for %s at %q: %s", cfg.typ, localAddr, err)
 							time.Sleep(time.Second)
 							continue
 						}
@@ -331,16 +358,16 @@ func serveUDP(ln net.PacketConn, tenantID logstorage.TenantID, encoding string,
 							break
 						}
 					}
-					logger.Errorf("syslog: cannot read UDP data from %s at %s: %s", remoteAddr, localAddr, err)
+					logger.Errorf("syslog: cannot read %s data from %s at %s: %s", cfg.typ, remoteAddr, localAddr, err)
 					continue
 				}
 				bb.B = bb.B[:n]
 				udpRequestsTotal.Inc()
 
-				remoteIP := getRemoteIP(remoteAddr, useRemoteIP)
+				remoteIP := getRemoteIP(remoteAddr, cfg.useRemoteIP)
 
-				if err := processStream("udp", bb.NewReader(), encoding, useLocalTimestamp, remoteIP, cp); err != nil {
-					logger.Errorf("syslog: cannot process UDP data from %s at %s: %s", remoteAddr, localAddr, err)
+				if err := processStream(cfg.typ, bb.NewReader(), cfg.compressMethod, cfg.useLocalTimestamp, remoteIP, cp); err != nil {
+					logger.Errorf("syslog: cannot process %s data from %s at %s: %s", cfg.typ, remoteAddr, localAddr, err)
 				}
 			}
 		}()
@@ -348,7 +375,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, useRemoteIP bool, streamFields, ignoreFields, decolorizeFields []string, extraFields []logstorage.Field) {
+func serveStreamListener(ln net.Listener, cfg *configs) {
 	var cm ingestserver.ConnsMap
 	cm.Init("syslog")
 
@@ -360,16 +387,16 @@ func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, us
 			var ne net.Error
 			if errors.As(err, &ne) {
 				if ne.Temporary() {
-					logger.Errorf("syslog: temporary error when listening for TCP addr %q: %s", addr, err)
+					logger.Errorf("syslog: temporary error when listening for %s addr %q: %s", cfg.typ, addr, err)
 					time.Sleep(time.Second)
 					continue
 				}
 				if strings.Contains(err.Error(), "use of closed network connection") {
 					break
 				}
-				logger.Fatalf("syslog: unrecoverable error when accepting TCP connections at %q: %s", addr, err)
+				logger.Fatalf("syslog: unrecoverable error when accepting %s connections at %q: %s", cfg.typ, addr, err)
 			}
-			logger.Fatalf("syslog: unexpected error when accepting TCP connections at %q: %s", addr, err)
+			logger.Fatalf("syslog: unexpected error when accepting %s connections at %q: %s", cfg.typ, addr, err)
 		}
 		if !cm.Add(c) {
 			_ = c.Close()
@@ -378,12 +405,12 @@ func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, us
 
 		wg.Add(1)
 		go func() {
-			cp := insertutil.GetCommonParamsForSyslog(tenantID, streamFields, ignoreFields, decolorizeFields, extraFields)
+			cp := insertutil.GetCommonParamsForSyslog(cfg.tenantID, cfg.streamFields, cfg.ignoreFields, cfg.decolorizeFields, cfg.extraFields)
 
 			remoteAddr := c.RemoteAddr()
-			remoteIP := getRemoteIP(remoteAddr, useRemoteIP)
-			if err := processStream("tcp", c, encoding, useLocalTimestamp, remoteIP, cp); err != nil {
-				logger.Errorf("syslog: cannot process TCP data at %q: %s", addr, err)
+			remoteIP := getRemoteIP(remoteAddr, cfg.useRemoteIP)
+			if err := processStream(cfg.typ, c, cfg.compressMethod, cfg.useLocalTimestamp, remoteIP, cp); err != nil {
+				logger.Errorf("syslog: cannot process %s data at %q: %s", cfg.typ, addr, err)
 			}
 
 			cm.Delete(c)
@@ -397,20 +424,20 @@ func serveTCP(ln net.Listener, tenantID logstorage.TenantID, encoding string, us
 }
 
 // processStream parses a stream of syslog messages from r and ingests them into vlstorage.
-func processStream(protocol string, r io.Reader, encoding string, useLocalTimestamp bool, remoteIP string, cp *insertutil.CommonParams) error {
+func processStream(protocol string, r io.Reader, compressMethod string, useLocalTimestamp bool, remoteIP string, cp *insertutil.CommonParams) error {
 	if err := insertutil.CanWriteData(); err != nil {
 		return err
 	}
 
 	lmp := cp.NewLogMessageProcessor("syslog_"+protocol, true)
-	err := processStreamInternal(r, encoding, useLocalTimestamp, remoteIP, lmp)
+	err := processStreamInternal(r, compressMethod, useLocalTimestamp, remoteIP, lmp)
 	lmp.MustClose()
 
 	return err
 }
 
-func processStreamInternal(r io.Reader, encoding string, useLocalTimestamp bool, remoteIP string, lmp insertutil.LogMessageProcessor) error {
-	reader, err := protoparserutil.GetUncompressedReader(r, encoding)
+func processStreamInternal(r io.Reader, compressMethod string, useLocalTimestamp bool, remoteIP string, lmp insertutil.LogMessageProcessor) error {
+	reader, err := protoparserutil.GetUncompressedReader(r, compressMethod)
 	if err != nil {
 		return fmt.Errorf("cannot decode syslog data: %w", err)
 	}
@@ -647,3 +674,73 @@ func parseExtraFields(s string) ([]logstorage.Field, error) {
 	})
 	return fields, nil
 }
+
+type configs struct {
+	typ string
+
+	streamFields      []string
+	ignoreFields      []string
+	decolorizeFields  []string
+	extraFields       []logstorage.Field
+	tenantID          logstorage.TenantID
+	compressMethod    string
+	useLocalTimestamp bool
+	useRemoteIP       bool
+}
+
+func getConfigs(typ string, argIdx int, streamFieldsArg, ignoreFieldsArg, decolorizeFieldsArg, extraFieldsArg, tenantIDArg, compressMethodArg *flagutil.ArrayString,
+	useLocalTimestampArg, useRemoteIPArg *flagutil.ArrayBool) (*configs, error) {
+
+	streamFieldsStr := streamFieldsArg.GetOptionalArg(argIdx)
+	streamFields, err := parseFieldsList(streamFieldsStr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse -syslog.streamFields.%s=%q: %w", typ, streamFieldsStr, err)
+	}
+
+	ignoreFieldsStr := ignoreFieldsArg.GetOptionalArg(argIdx)
+	ignoreFields, err := parseFieldsList(ignoreFieldsStr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse -syslog.ignoreFields.%s=%q: %w", typ, ignoreFieldsStr, err)
+	}
+
+	decolorizeFieldsStr := decolorizeFieldsArg.GetOptionalArg(argIdx)
+	decolorizeFields, err := parseFieldsList(decolorizeFieldsStr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse -syslog.decolorizeFields.%s=%q: %w", typ, decolorizeFieldsStr, err)
+	}
+
+	extraFieldsStr := extraFieldsArg.GetOptionalArg(argIdx)
+	extraFields, err := parseExtraFields(extraFieldsStr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse -syslog.extraFields.%s=%q: %w", typ, extraFieldsStr, err)
+	}
+
+	tenantIDStr := tenantIDArg.GetOptionalArg(argIdx)
+	tenantID, err := logstorage.ParseTenantID(tenantIDStr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse -syslog.tenantID.%s=%q: %w", typ, tenantIDStr, err)
+	}
+
+	compressMethod := compressMethodArg.GetOptionalArg(argIdx)
+	switch compressMethod {
+	case "", "none", "zstd", "gzip", "deflate":
+		// These methods are supported
+	default:
+		return nil, fmt.Errorf("unsupported -syslog.compressMethod.%s=%q; supported values: 'none', 'zstd', 'gzip', 'deflate'", typ, compressMethod)
+	}
+
+	useLocalTimestamp := useLocalTimestampArg.GetOptionalArg(argIdx)
+	useRemoteIP := useRemoteIPArg.GetOptionalArg(argIdx)
+
+	return &configs{
+		typ:               typ,
+		streamFields:      streamFields,
+		ignoreFields:      ignoreFields,
+		decolorizeFields:  decolorizeFields,
+		extraFields:       extraFields,
+		tenantID:          tenantID,
+		compressMethod:    compressMethod,
+		useLocalTimestamp: useLocalTimestamp,
+		useRemoteIP:       useRemoteIP,
+	}, nil
+}
diff --git a/app/vlselect/internalselect/internalselect.go b/app/vlselect/internalselect/internalselect.go
index d0d10b294d..75f23863df 100644
--- a/app/vlselect/internalselect/internalselect.go
+++ b/app/vlselect/internalselect/internalselect.go
@@ -2,6 +2,7 @@ package internalselect
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -21,10 +22,42 @@ import (
 	"github.com/VictoriaMetrics/VictoriaLogs/lib/logstorage"
 )
 
+var maxConcurrentRequests = flag.Int("internalselect.maxConcurrentRequests", 100, "The limit on the number of concurrent requests to /internal/select/* endpoints; "+
+	"other requests are put into the wait queue; see https://docs.victoriametrics.com/victorialogs/cluster/")
+
 // RequestHandler processes requests to /internal/select/*
 func RequestHandler(ctx context.Context, w http.ResponseWriter, r *http.Request) {
 	startTime := time.Now()
 
+	select {
+	case concurrencyLimitCh <- struct{}{}:
+		if d := time.Since(startTime); d > 100*time.Millisecond {
+			// Measure the wait duration for requests, which hit the concurrency limit and waited for more than 100 milliseconds to be executed.
+			concurrentRequestsWaitDuration.Update(d.Seconds())
+		}
+		requestHandler(ctx, w, r, startTime)
+		<-concurrencyLimitCh
+	case <-ctx.Done():
+		// Unconditionally measure the wait time until the the request is canceled by the client.
+		concurrentRequestsWaitDuration.UpdateDuration(startTime)
+	}
+}
+
+// Init initializes internalselect package.
+func Init() {
+	concurrencyLimitCh = make(chan struct{}, *maxConcurrentRequests)
+}
+
+// Stop stops vlselect
+func Stop() {
+	concurrencyLimitCh = nil
+}
+
+var concurrencyLimitCh chan struct{}
+
+var concurrentRequestsWaitDuration = metrics.NewSummary(`vl_concurrent_internalselect_requests_wait_duration`)
+
+func requestHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, startTime time.Time) {
 	path := r.URL.Path
 	rh := requestHandlers[path]
 	if rh == nil {
@@ -277,14 +310,18 @@ type commonParams struct {
 	TenantIDs []logstorage.TenantID
 	Query     *logstorage.Query
 
+	// Whether to disable compression of the response sent to the vlselect.
 	DisableCompression bool
 
+	// Whether to allow partial response when some of vlstorage nodes are unavailable.
+	AllowPartialResponse bool
+
 	// qs contains execution statistics for the Query.
 	qs logstorage.QueryStats
 }
 
 func (cp *commonParams) NewQueryContext(ctx context.Context) *logstorage.QueryContext {
-	return logstorage.NewQueryContext(ctx, &cp.qs, cp.TenantIDs, cp.Query)
+	return logstorage.NewQueryContext(ctx, &cp.qs, cp.TenantIDs, cp.Query, cp.AllowPartialResponse)
 }
 
 func (cp *commonParams) UpdatePerQueryStatsMetrics() {
@@ -314,10 +351,14 @@ func getCommonParams(r *http.Request, expectedProtocolVersion string) (*commonPa
 		return nil, fmt.Errorf("cannot unmarshal query=%q: %w", qStr, err)
 	}
 
-	s := r.FormValue("disable_compression")
-	disableCompression, err := strconv.ParseBool(s)
-	if err != nil {
-		return nil, fmt.Errorf("cannot parse disable_compression=%q: %w", s, err)
+	disableCompression := false
+	if err := getBoolFromRequest(&disableCompression, r, "disable_compression"); err != nil {
+		return nil, err
+	}
+
+	allowPartialResponse := false
+	if err := getBoolFromRequest(&allowPartialResponse, r, "allow_partial_response"); err != nil {
+		return nil, err
 	}
 
 	cp := &commonParams{
@@ -325,6 +366,8 @@ func getCommonParams(r *http.Request, expectedProtocolVersion string) (*commonPa
 		Query:     q,
 
 		DisableCompression: disableCompression,
+
+		AllowPartialResponse: allowPartialResponse,
 	}
 	return cp, nil
 }
@@ -369,3 +412,16 @@ func getInt64FromRequest(r *http.Request, argName string) (int64, error) {
 	}
 	return n, nil
 }
+
+func getBoolFromRequest(dst *bool, r *http.Request, argName string) error {
+	s := r.FormValue(argName)
+	if s == "" {
+		return nil
+	}
+	b, err := strconv.ParseBool(s)
+	if err != nil {
+		return fmt.Errorf("cannot parse %s=%q as bool: %w", argName, s, err)
+	}
+	*dst = b
+	return nil
+}
diff --git a/app/vlselect/logsql/logsql.go b/app/vlselect/logsql/logsql.go
index 0c4ebb656f..57bc8e3170 100644
--- a/app/vlselect/logsql/logsql.go
+++ b/app/vlselect/logsql/logsql.go
@@ -17,6 +17,7 @@ import (
 
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/atomicutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httputil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
@@ -29,8 +30,12 @@ import (
 )
 
 var (
-	maxQueryTimeRange = flag.Duration("search.maxQueryTimeRange", 0, "The maximum time range, which can be set in the query sent to querying APIs. "+
+	maxQueryTimeRange = flagutil.NewExtendedDuration("search.maxQueryTimeRange", "0", "The maximum time range, which can be set in the query sent to querying APIs. "+
 		"Queries with bigger time ranges are rejected. See https://docs.victoriametrics.com/victorialogs/querying/#resource-usage-limits")
+
+	allowPartialResponseFlag = flag.Bool("search.allowPartialResponse", false, "Whether to allow returning partial responses when some of vlstorage nodes "+
+		"from the -storageNode list are unavaialbe for querying. This flag works only for cluster setup of VictoriaLogs. "+
+		"See https://docs.victoriametrics.com/victorialogs/querying/#partial-responses")
 )
 
 // ProcessFacetsRequest handles /select/logsql/facets request.
@@ -79,9 +84,19 @@ func ProcessFacetsRequest(ctx context.Context, w http.ResponseWriter, r *http.Re
 			logger.Panicf("BUG: expecting 3 columns; got %d columns", len(columns))
 		}
 
-		fieldNames := columns[0].Values
-		fieldValues := columns[1].Values
-		hits := columns[2].Values
+		// Fetch columns by name to avoid relying on column ordering at VictoriaLogs cluster.
+		// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/648
+		cFieldName := db.GetColumnByName("field_name")
+		cFieldValue := db.GetColumnByName("field_value")
+		cHits := db.GetColumnByName("hits")
+		if cFieldName == nil || cFieldValue == nil || cHits == nil {
+			logger.Panicf("BUG: missing expected columns for facets response: field_name=%v, field_value=%v, hits=%v",
+				cFieldName != nil, cFieldValue != nil, cHits != nil)
+		}
+
+		fieldNames := cFieldName.Values
+		fieldValues := cFieldValue.Values
+		hits := cHits.Values
 
 		bb := blockResultPool.Get()
 		for i := range fieldNames {
@@ -1093,6 +1108,10 @@ type commonArgs struct {
 	// tenantIDs is the list of tenantIDs to query.
 	tenantIDs []logstorage.TenantID
 
+	// Whether to allow partial response when some of vlstorage nodes are unavailable for querying.
+	// This option makes sense only for cluster setup when vlselect queries vlstorage nodes.
+	allowPartialResponse bool
+
 	// minTimestamp and maxTimestamp is the time range specified in the original query,
 	// without taking into account extra_filters and (start, end) query args.
 	minTimestamp int64
@@ -1103,7 +1122,7 @@ type commonArgs struct {
 }
 
 func (ca *commonArgs) newQueryContext(ctx context.Context) *logstorage.QueryContext {
-	return logstorage.NewQueryContext(ctx, &ca.qs, ca.tenantIDs, ca.q)
+	return logstorage.NewQueryContext(ctx, &ca.qs, ca.tenantIDs, ca.q, ca.allowPartialResponse)
 }
 
 func (ca *commonArgs) updatePerQueryStatsMetrics() {
@@ -1200,22 +1219,29 @@ func parseCommonArgs(r *http.Request) (*commonArgs, error) {
 		}
 	}
 
-	if *maxQueryTimeRange > 0 {
+	if maxRange := maxQueryTimeRange.Duration(); maxRange > 0 {
 		start, end := q.GetFilterTimeRange()
 		if end > start {
 			queryTimeRange := end - start
-			if queryTimeRange < 0 || queryTimeRange > maxQueryTimeRange.Nanoseconds() {
+			if queryTimeRange < 0 || queryTimeRange > maxRange.Nanoseconds() {
 				return nil, fmt.Errorf("too big time range selected: [%s, %s]; it cannot exceed -search.maxQueryTimeRange=%s; "+
 					"see https://docs.victoriametrics.com/victorialogs/querying/#resource-usage-limits",
-					timestampToString(start), timestampToString(end), *maxQueryTimeRange)
+					timestampToString(start), timestampToString(end), maxRange)
 			}
 		}
 	}
 
+	allowPartialResponse := *allowPartialResponseFlag
+	if err := getBoolFromRequest(&allowPartialResponse, r, "allow_partial_response"); err != nil {
+		return nil, err
+	}
+
 	ca := &commonArgs{
 		q:         q,
 		tenantIDs: tenantIDs,
 
+		allowPartialResponse: allowPartialResponse,
+
 		minTimestamp: minTimestamp,
 		maxTimestamp: maxTimestamp,
 	}
@@ -1363,6 +1389,19 @@ func getPositiveInt(r *http.Request, argName string) (int, error) {
 	return n, nil
 }
 
+func getBoolFromRequest(dst *bool, r *http.Request, argName string) error {
+	s := r.FormValue(argName)
+	if s == "" {
+		return nil
+	}
+	b, err := strconv.ParseBool(s)
+	if err != nil {
+		return fmt.Errorf("cannot parse %s=%q as bool: %w", argName, s, err)
+	}
+	*dst = b
+	return nil
+}
+
 func writeRequestDuration(h http.Header, startTime time.Time) {
 	h.Set("Access-Control-Expose-Headers", "VL-Request-Duration-Seconds")
 	h.Set("VL-Request-Duration-Seconds", fmt.Sprintf("%.3f", time.Since(startTime).Seconds()))
diff --git a/app/vlselect/main.go b/app/vlselect/main.go
index 4670d8bf3e..7b52ff23f1 100644
--- a/app/vlselect/main.go
+++ b/app/vlselect/main.go
@@ -48,10 +48,15 @@ func getDefaultMaxConcurrentRequests() int {
 // Init initializes vlselect
 func Init() {
 	concurrencyLimitCh = make(chan struct{}, *maxConcurrentRequests)
+
+	internalselect.Init()
 }
 
 // Stop stops vlselect
 func Stop() {
+	internalselect.Stop()
+
+	concurrencyLimitCh = nil
 }
 
 var concurrencyLimitCh chan struct{}
diff --git a/app/vlstorage/lastnoptimization.go b/app/vlstorage/lastnoptimization.go
index 7cee3a6832..88bf5100b8 100644
--- a/app/vlstorage/lastnoptimization.go
+++ b/app/vlstorage/lastnoptimization.go
@@ -38,10 +38,9 @@ func runOptimizedLastNResultsQuery(qctx *logstorage.QueryContext, offset, limit
 }
 
 func getLastNQueryResults(qctx *logstorage.QueryContext, limit uint64) ([]logRow, error) {
-	qOrig := qctx.Query
-	timestamp := qOrig.GetTimestamp()
+	timestamp := qctx.Query.GetTimestamp()
 
-	q := qOrig.Clone(timestamp)
+	q := qctx.Query.Clone(timestamp)
 	q.AddPipeOffsetLimit(0, 2*limit)
 	qctxLocal := qctx.WithQuery(q)
 	rows, err := getQueryResults(qctxLocal)
@@ -56,15 +55,14 @@ func getLastNQueryResults(qctx *logstorage.QueryContext, limit uint64) ([]logRow
 
 	// Slow path - use binary search for adjusting time range for selecting up to 2*limit rows.
 	start, end := q.GetFilterTimeRange()
-	d := end/2 - start/2
-	start += d
+	start += end/2 - start/2
 	n := limit
 
 	var rowsFound []logRow
 	var lastNonEmptyRows []logRow
 
 	for {
-		q = qOrig.CloneWithTimeFilter(timestamp, start, end)
+		q = qctx.Query.CloneWithTimeFilter(timestamp, start, end)
 		q.AddPipeOffsetLimit(0, 2*n)
 		qctxLocal := qctx.WithQuery(q)
 		rows, err := getQueryResults(qctxLocal)
@@ -72,45 +70,61 @@ func getLastNQueryResults(qctx *logstorage.QueryContext, limit uint64) ([]logRow
 			return nil, err
 		}
 
-		if d == 0 || start >= end {
-			// The [start ... end] time range equals to one nanosecond, e.g. it cannot be adjusted more. Return up to limit rows
-			// from the found rows and the last non-empty rows.
-			rowsFound = append(rowsFound, rows...)
+		if end/2-start/2 <= 0 {
+			// The [start ... end] time range doesn't exceed a nanosecond, e.g. it cannot be adjusted more.
+			// Return up to limit rows from the found rows and the last non-empty rows.
 			rowsFound = append(rowsFound, lastNonEmptyRows...)
+			rowsFound = append(rowsFound, rows...)
 			rowsFound = getLastNRows(rowsFound, limit)
 			return rowsFound, nil
 		}
 
-		dLastBit := d & 1
-		d /= 2
-
 		if uint64(len(rows)) >= 2*n {
 			// The number of found rows on the [start ... end] time range exceeds 2*n,
-			// so reduce the time range to further to [start+d ... end].
-			start += d
+			// so search for the rows on the adjusted time range [start+(end/2-start/2) ... end].
+			if !logstorage.CanApplyLastNResultsOptimization(start, end) {
+				// It is faster obtaining the last N logs as is on such a small time range instead of using binary search.
+				rows, err := getLogRowsLastN(qctx, start, end, n)
+				if err != nil {
+					return nil, err
+				}
+				rowsFound = append(rowsFound, rows...)
+				rowsFound = getLastNRows(rowsFound, limit)
+				return rowsFound, nil
+			}
+			start += end/2 - start/2
 			lastNonEmptyRows = rows
 			continue
 		}
-		if uint64(len(rows)) >= n {
-			// The number of found rows is in the range [n ... 2*n).
-			// This means that found rows contains the needed limit rows with the biggest timestamps.
+		if uint64(len(rowsFound)+len(rows)) >= limit {
+			// The found rows contains the needed limit rows with the biggest timestamps.
 			rowsFound = append(rowsFound, rows...)
 			rowsFound = getLastNRows(rowsFound, limit)
 			return rowsFound, nil
 		}
 
-		// The number of found rows on [start ... end] time range is below the limit.
-		// This means the time range doesn't cover the needed logs, so it must be extended.
-		// Append the found rows to rowsFound, adjust the limit, so it doesn't take into account already found rows
-		// and adjust the time range to search logs to [start-d ... start).
+		// The number of found rows is below the limit. This means the [start ... end] time range
+		// doesn't cover the needed logs, so it must be extended.
+		// Append the found rows to rowsFound, adjust n, so it doesn't take into account already found rows
+		// and adjust the time range to search logs at [start-(end/2-start/2) ... start).
 		rowsFound = append(rowsFound, rows...)
 		n -= uint64(len(rows))
 
+		d := end/2 - start/2
 		end = start - 1
-		start -= d + dLastBit
+		start -= d
 	}
 }
 
+func getLogRowsLastN(qctx *logstorage.QueryContext, start, end int64, n uint64) ([]logRow, error) {
+	timestamp := qctx.Query.GetTimestamp()
+	q := qctx.Query.CloneWithTimeFilter(timestamp, start, end)
+	q.AddPipeSortByTimeDesc()
+	q.AddPipeOffsetLimit(0, n)
+	qctxLocal := qctx.WithQuery(q)
+	return getQueryResults(qctxLocal)
+}
+
 func getQueryResults(qctx *logstorage.QueryContext) ([]logRow, error) {
 	var rowsLock sync.Mutex
 	var rows []logRow
diff --git a/app/vlstorage/main.go b/app/vlstorage/main.go
index 81035c7e59..9abf343245 100644
--- a/app/vlstorage/main.go
+++ b/app/vlstorage/main.go
@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/cgroup"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
@@ -24,6 +25,11 @@ var (
 	retentionPeriod = flagutil.NewRetentionDuration("retentionPeriod", "7d", "Log entries with timestamps older than now-retentionPeriod are automatically deleted; "+
 		"log entries with timestamps outside the retention are also rejected during data ingestion; the minimum supported retention is 1d (one day); "+
 		"see https://docs.victoriametrics.com/victorialogs/#retention ; see also -retention.maxDiskSpaceUsageBytes and -retention.maxDiskUsagePercent")
+
+	defaultParallelReaders = flag.Int("defaultParallelReaders", 2*cgroup.AvailableCPUs(), "Default number of parallel data readers to use for executing every query; "+
+		"higher number of readers may help increasing query performance on high-latency storage such as NFS or S3 at the cost of higher RAM usage; "+
+		"see https://docs.victoriametrics.com/victorialogs/logsql/#parallel_readers-query-option")
+
 	maxDiskSpaceUsageBytes = flagutil.NewBytes("retention.maxDiskSpaceUsageBytes", 0, "The maximum disk space usage at -storageDataPath before older per-day "+
 		"partitions are automatically dropped; see https://docs.victoriametrics.com/victorialogs/#retention-by-disk-space-usage ; see also -retentionPeriod")
 	maxDiskUsagePercent = flag.Int("retention.maxDiskUsagePercent", 0, "The maximum allowed disk usage percentage (1-100) for the filesystem that contains -storageDataPath before older per-day partitions are automatically dropped; mutually exclusive with -retention.maxDiskSpaceUsageBytes; see https://docs.victoriametrics.com/victorialogs/#retention-by-disk-space-usage-percent")
@@ -59,6 +65,8 @@ var (
 		"Disabled compression reduces CPU usage at the cost of higher network usage")
 
 	storageNodeUsername     = flagutil.NewArrayString("storageNode.username", "Optional basic auth username to use for the corresponding -storageNode")
+	storageNodeUsernameFile = flagutil.NewArrayString("storageNode.usernameFile", "Optional path to basic auth username to use for the corresponding -storageNode. "+
+		"The file is re-read every second")
 	storageNodePassword     = flagutil.NewArrayString("storageNode.password", "Optional basic auth password to use for the corresponding -storageNode")
 	storageNodePasswordFile = flagutil.NewArrayString("storageNode.passwordFile", "Optional path to basic auth password to use for the corresponding -storageNode. "+
 		"The file is re-read every second")
@@ -113,6 +121,7 @@ func initLocalStorage() {
 	}
 	cfg := &logstorage.StorageConfig{
 		Retention:              retentionPeriod.Duration(),
+		DefaultParallelReaders: *defaultParallelReaders,
 		MaxDiskSpaceUsageBytes: maxDiskSpaceUsageBytes.N,
 		MaxDiskUsagePercent:    *maxDiskUsagePercent,
 		FlushInterval:          *inmemoryDataFlushInterval,
@@ -163,12 +172,14 @@ func initNetworkStorage() {
 
 func newAuthConfigForStorageNode(argIdx int) *promauth.Config {
 	username := storageNodeUsername.GetOptionalArg(argIdx)
+	usernameFile := storageNodeUsernameFile.GetOptionalArg(argIdx)
 	password := storageNodePassword.GetOptionalArg(argIdx)
 	passwordFile := storageNodePasswordFile.GetOptionalArg(argIdx)
 	var basicAuthCfg *promauth.BasicAuthConfig
-	if username != "" || password != "" || passwordFile != "" {
+	if username != "" || usernameFile != "" || password != "" || passwordFile != "" {
 		basicAuthCfg = &promauth.BasicAuthConfig{
 			Username:     username,
+			UsernameFile: usernameFile,
 			Password:     promauth.NewSecret(password),
 			PasswordFile: passwordFile,
 		}
diff --git a/app/vlstorage/netinsert/netinsert.go b/app/vlstorage/netinsert/netinsert.go
index 03bef8ce14..91d4cc5865 100644
--- a/app/vlstorage/netinsert/netinsert.go
+++ b/app/vlstorage/netinsert/netinsert.go
@@ -243,7 +243,7 @@ func (sn *storageNode) sendInsertRequest(pendingData *bytesutil.ByteBuffer) erro
 	reqURL := sn.getRequestURL("/internal/insert")
 	req, err := http.NewRequestWithContext(ctx, "POST", reqURL, body)
 	if err != nil {
-		logger.Panicf("BUG: unexpected error when creating an http request: %s", err)
+		return fmt.Errorf("cannot create an http request for %q: %w", reqURL, err)
 	}
 	req.Header.Set("Content-Type", "application/octet-stream")
 	if !sn.s.disableCompression {
diff --git a/app/vlstorage/netselect/netselect.go b/app/vlstorage/netselect/netselect.go
index 6c52751f1c..0f2117e7ae 100644
--- a/app/vlstorage/netselect/netselect.go
+++ b/app/vlstorage/netselect/netselect.go
@@ -138,7 +138,7 @@ func (sn *storageNode) runQuery(qctx *logstorage.QueryContext, processBlock func
 				// The end of response stream
 				return nil
 			}
-			return fmt.Errorf("cannot read block size from %q: %w", path, err)
+			return fmt.Errorf("cannot read block size from %q: %w", reqURL, err)
 		}
 		blockLen := encoding.UnmarshalUint64(dataLenBuf[:])
 		if blockLen > math.MaxInt {
@@ -237,6 +237,7 @@ func (sn *storageNode) getCommonArgs(version string, qctx *logstorage.QueryConte
 	args.Set("query", qctx.Query.String())
 	args.Set("timestamp", fmt.Sprintf("%d", qctx.Query.GetTimestamp()))
 	args.Set("disable_compression", fmt.Sprintf("%v", sn.s.disableCompression))
+	args.Set("allow_partial_response", fmt.Sprintf("%v", qctx.AllowPartialResponse))
 	return args
 }
 
@@ -278,7 +279,7 @@ func (sn *storageNode) getResponseBodyForPathAndArgs(ctx context.Context, path s
 	reqBody := strings.NewReader(args.Encode())
 	req, err := http.NewRequestWithContext(ctx, "POST", reqURL, reqBody)
 	if err != nil {
-		logger.Panicf("BUG: unexpected error when creating a request for %q: %s", reqURL, err)
+		return nil, "", fmt.Errorf("cannot create a request for %q: %w", reqURL, err)
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	if err := sn.ac.SetHeaders(req, true); err != nil {
@@ -288,6 +289,11 @@ func (sn *storageNode) getResponseBodyForPathAndArgs(ctx context.Context, path s
 	// send the request to the storage node
 	resp, err := sn.c.Do(req)
 	if err != nil {
+		// Wrap the error into httpserver.ErrorWithStatusCode in order to return the proper status code to the client.
+		// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/576
+		//
+		// This is also used by isUnavailableBackendError() function in order to differentiate unavailable backend errors
+		// from improper configuration errors.
 		return nil, "", &httpserver.ErrorWithStatusCode{
 			Err:        fmt.Errorf("cannot connect to storage node at %q: %w", reqURL, err),
 			StatusCode: http.StatusBadGateway,
@@ -368,21 +374,12 @@ func (s *Storage) runQuery(stopCh <-chan struct{}, qctx *logstorage.QueryContext
 			err := sn.runQuery(qctxLocal, func(db *logstorage.DataBlock) {
 				writeBlock(uint(nodeIdx), db)
 			})
-			if err != nil {
-				if !errors.Is(err, context.Canceled) {
-					sn.sendErrors.Inc()
-				}
-
-				// Cancel the remaining parallel queries
-				cancel()
-			}
-
-			errs[nodeIdx] = err
+			errs[nodeIdx] = sn.handleError(ctxWithCancel, cancel, err, qctx.AllowPartialResponse)
 		}(i)
 	}
 	wg.Wait()
 
-	return getFirstNonCancelError(errs)
+	return getFirstError(errs, qctx.AllowPartialResponse)
 }
 
 // GetFieldNames executes qctx and returns field names seen in results.
@@ -459,21 +456,12 @@ func (s *Storage) getValuesWithHits(qctx *logstorage.QueryContext, limit uint64,
 			sn := s.sns[nodeIdx]
 			vhs, err := callback(ctxWithCancel, sn)
 			results[nodeIdx] = vhs
-			errs[nodeIdx] = err
-
-			if err != nil {
-				if !errors.Is(err, context.Canceled) {
-					sn.sendErrors.Inc()
-				}
-
-				// Cancel the remaining parallel requests
-				cancel()
-			}
+			errs[nodeIdx] = sn.handleError(ctxWithCancel, cancel, err, qctx.AllowPartialResponse)
 		}(i)
 	}
 	wg.Wait()
 
-	if err := getFirstNonCancelError(errs); err != nil {
+	if err := getFirstError(errs, qctx.AllowPartialResponse); err != nil {
 		return nil, err
 	}
 
@@ -482,13 +470,64 @@ func (s *Storage) getValuesWithHits(qctx *logstorage.QueryContext, limit uint64,
 	return vhs, nil
 }
 
-func getFirstNonCancelError(errs []error) error {
+func (sn *storageNode) handleError(ctx context.Context, cancel func(), err error, allowPartialResponse bool) error {
+	if err == nil {
+		// Nothing to handle.
+		return nil
+	}
+	if err := ctx.Err(); err != nil {
+		// The context error overrides all the other errors.
+		// It must be handled separately by the caller.
+		return nil
+	}
+
+	sn.sendErrors.Inc()
+
+	if !allowPartialResponse || !isUnavailableBackendError(err) {
+		// Cancel the remaining parallel queries, since the error must be returned to the client ASAP
+		// without waiting for the remaining parallel queries to other backends.
+		cancel()
+	}
+
+	return err
+}
+
+func getFirstError(errs []error, allowPartialResponse bool) error {
+	if len(errs) == 0 {
+		logger.Panicf("BUG: len(errs) must be bigger than 0")
+	}
+
+	if !allowPartialResponse {
+		for _, err := range errs {
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	// allowPartialResponse == true. Return the error only if all the backends are unavailable
+	// or if some of the backends are improperly configured.
 	for _, err := range errs {
-		if err != nil && !errors.Is(err, context.Canceled) {
-			return err
+		if err == nil {
+			// At least a single vlstorage returned full response.
+			return nil
+		}
+		if !isUnavailableBackendError(err) {
+			// Return the first error, which isn't related to the backend unavailability, to the client,
+			// since this error may point to configuration issues, which must be fixed ASAP.
+			// Hiding this error would complicate troubleshooting of improperly configured system.
+			return fmt.Errorf("the vlstorage node is available, but it returns an error, which may point to configuration issues: %w", err)
 		}
 	}
-	return nil
+
+	return fmt.Errorf("all the vlstorage nodes are unavailable for querying; a sample error: %w", errs[0])
+}
+
+func isUnavailableBackendError(err error) bool {
+	// It is expected that unavailable backend errors are wrapped into httpserver.ErrorWithStatusCode.
+	var es *httpserver.ErrorWithStatusCode
+	return errors.As(err, &es)
 }
 
 func unmarshalValuesWithHits(qctx *logstorage.QueryContext, src []byte) ([]logstorage.ValueWithHits, error) {
diff --git a/app/vmui/packages/vmui/package-lock.json b/app/vmui/packages/vmui/package-lock.json
index b57e39a9aa..66f672a907 100644
--- a/app/vmui/packages/vmui/package-lock.json
+++ b/app/vmui/packages/vmui/package-lock.json
@@ -19,7 +19,7 @@
         "react-input-mask": "^2.0.4",
         "react-router-dom": "^7.6.3",
         "uplot": "^1.6.32",
-        "vite": "^7.0.0",
+        "vite": "^7.1.7",
         "web-vitals": "^5.0.3"
       },
       "devDependencies": {
@@ -6811,13 +6811,13 @@
       "license": "MIT"
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.14",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
-      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.4.4",
-        "picomatch": "^4.0.2"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
       },
       "engines": {
         "node": ">=12.0.0"
@@ -6827,10 +6827,13 @@
       }
     },
     "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.6",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
-      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
       "peerDependencies": {
         "picomatch": "^3 || ^4"
       },
@@ -6841,9 +6844,9 @@
       }
     },
     "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -7147,17 +7150,17 @@
       "license": "MIT"
     },
     "node_modules/vite": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.4.tgz",
-      "integrity": "sha512-SkaSguuS7nnmV7mfJ8l81JGBFV7Gvzp8IzgE8A8t23+AxuNX61Q5H1Tpz5efduSN7NHC8nQXD3sKQKZAu5mNEA==",
+      "version": "7.1.7",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.1.7.tgz",
+      "integrity": "sha512-VbA8ScMvAISJNJVbRDTJdCwqQoAareR/wutevKanhR2/1EkoXVZVkkORaYm/tNVCjP/UDTKtcw3bAkwOUdedmA==",
       "license": "MIT",
       "dependencies": {
         "esbuild": "^0.25.0",
-        "fdir": "^6.4.6",
-        "picomatch": "^4.0.2",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
         "postcss": "^8.5.6",
-        "rollup": "^4.40.0",
-        "tinyglobby": "^0.2.14"
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
       },
       "bin": {
         "vite": "bin/vite.js"
@@ -7262,10 +7265,13 @@
       }
     },
     "node_modules/vite/node_modules/fdir": {
-      "version": "6.4.6",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
-      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
       "peerDependencies": {
         "picomatch": "^3 || ^4"
       },
@@ -7276,9 +7282,9 @@
       }
     },
     "node_modules/vite/node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
diff --git a/app/vmui/packages/vmui/package.json b/app/vmui/packages/vmui/package.json
index a4f260fb15..1f367a3d44 100644
--- a/app/vmui/packages/vmui/package.json
+++ b/app/vmui/packages/vmui/package.json
@@ -27,7 +27,7 @@
     "react-input-mask": "^2.0.4",
     "react-router-dom": "^7.6.3",
     "uplot": "^1.6.32",
-    "vite": "^7.0.0",
+    "vite": "^7.1.7",
     "web-vitals": "^5.0.3"
   },
   "devDependencies": {
diff --git a/deployment/docker/compose-vl-cluster.yml b/deployment/docker/compose-vl-cluster.yml
index c77455f43a..7766ff3e35 100644
--- a/deployment/docker/compose-vl-cluster.yml
+++ b/deployment/docker/compose-vl-cluster.yml
@@ -34,30 +34,30 @@ services:
     user: root
 
   vlinsert:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     command:
       - "--storageNode=vlstorage-1:9428"
       - "--storageNode=vlstorage-2:9428"
 
   vlselect-1:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     command:
       - "--storageNode=vlstorage-1:9428"
       - "--storageNode=vlstorage-2:9428"
   vlselect-2:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     command:
       - "--storageNode=vlstorage-1:9428"
       - "--storageNode=vlstorage-2:9428"
 
   vlstorage-1:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     command:
       - "--storageDataPath=/vlogs"
     volumes:
       - vldata-1:/vlogs
   vlstorage-2:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     command:
       - "--storageDataPath=/vlogs"
     volumes:
diff --git a/deployment/docker/compose-vl-single.yml b/deployment/docker/compose-vl-single.yml
index a3795b0190..5414b43264 100644
--- a/deployment/docker/compose-vl-single.yml
+++ b/deployment/docker/compose-vl-single.yml
@@ -36,7 +36,7 @@ services:
   #  VictoriaLogs instance, a single process responsible for
   #  storing logs and serving read queries.
   victorialogs:
-    image: victoriametrics/victoria-logs:v1.32.0
+    image: victoriametrics/victoria-logs:v1.34.0
     ports:
       - "9428:9428"
     command:
diff --git a/deployment/docker/victorialogs/compose-base.yml b/deployment/docker/victorialogs/compose-base.yml
index add0b058fc..1995742e6b 100644
--- a/deployment/docker/victorialogs/compose-base.yml
+++ b/deployment/docker/victorialogs/compose-base.yml
@@ -1,7 +1,7 @@
 services:
   # meta service will be ignored by compose
   .victorialogs:
-    image: docker.io/victoriametrics/victoria-logs:v1.32.0
+    image: docker.io/victoriametrics/victoria-logs:v1.34.0
     command:
       - -storageDataPath=/vlogs
       - -loggerFormat=json
diff --git a/deployment/logs-benchmark/docker-compose.yml b/deployment/logs-benchmark/docker-compose.yml
index db567db952..63ed340aec 100644
--- a/deployment/logs-benchmark/docker-compose.yml
+++ b/deployment/logs-benchmark/docker-compose.yml
@@ -3,7 +3,7 @@ version: "3"
 services:
   # Run `make package-victoria-logs` to build victoria-logs image
   vlogs:
-    image: docker.io/victoriametrics/victoria-logs:v1.27.0
+    image: docker.io/victoriametrics/victoria-logs:v1.34.0
     volumes:
       - vlogs:/vlogs
     ports:
@@ -46,7 +46,7 @@ services:
       - "--config=/config.yml"
 
   vmsingle:
-    image: victoriametrics/victoria-metrics:v1.109.0
+    image: victoriametrics/victoria-metrics:v1.125.1
     ports:
       - "8428:8428"
     command:
@@ -58,7 +58,7 @@ services:
       - ./vmsingle/promscrape.yml:/promscrape.yml
 
   grafana:
-    image: grafana/grafana:12.0.2
+    image: grafana/grafana:12.1.1
     depends_on: [vmsingle]
     ports:
       - 3000:3000
diff --git a/deployment/logs-benchmark/readme.md b/deployment/logs-benchmark/readme.md
index 72e4f45cc3..4dfe1eb555 100644
--- a/deployment/logs-benchmark/readme.md
+++ b/deployment/logs-benchmark/readme.md
@@ -24,7 +24,7 @@ For Grafana Loki suite it uses:
 
 - VictoriaLogs instance
 - vmsingle - port forwarded to `localhost:8428` to see UI
-- exporters for system metris
+- exporters for system metrics
 
 ELK suite uses [docker-compose-elk.yml](./docker-compose-elk.yml) with the following services:
 
@@ -54,7 +54,7 @@ Each filebeat than writes logs to elastic and VictoriaLogs via elasticsearch-com
 1. Download and unarchive logs by running:
 
 ```shell
-cd source_logs 
+cd source_logs
 bash download.sh
 ```
 
@@ -98,15 +98,14 @@ output.elasticsearch:
 4. Choose a suite to run.
 
    In order to run ELK suite use the following command:
-   ```
+   ```sh
    make docker-up-elk
    ```
    In order to run Loki suite use the following command:
-   ```
+   ```sh
    make docker-up-loki
    ```
 
-
 5. Navigate to `http://localhost:3000/` to see Grafana dashboards with resource usage
    comparison.
 
diff --git a/docs/victorialogs/Articles.md b/docs/victorialogs/Articles.md
index 423338ebdf..6d27055230 100644
--- a/docs/victorialogs/Articles.md
+++ b/docs/victorialogs/Articles.md
@@ -1,11 +1,11 @@
 ---
-weight: 29
+weight: 70
 title: Articles
 menu:
   docs:
     parent: 'victorialogs'
     identifier: "victorialogs-articles"
-    weight: 29
+    weight: 70
 tags: []
 ---
 
diff --git a/docs/victorialogs/CHANGELOG.md b/docs/victorialogs/CHANGELOG.md
index e1eb3801a6..ea35bfc6a6 100644
--- a/docs/victorialogs/CHANGELOG.md
+++ b/docs/victorialogs/CHANGELOG.md
@@ -1,11 +1,11 @@
 ---
-weight: 7
+weight: 101
 title: CHANGELOG
 menu:
   docs:
     identifier: "victorialogs-changelog"
     parent: "victorialogs"
-    weight: 7
+    weight: 101
     title: CHANGELOG
 tags:
   - logs
@@ -18,7 +18,52 @@ according to [these docs](https://docs.victoriametrics.com/victorialogs/quicksta
 
 ## tip
 
+* FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add [`equals_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#equals_common_case-filter) and [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter). These filters can be used as faster alternatives to [`i(...)` filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter). For example, `_msg:contains_common_case("VictoriaMetrics")` matches logs with the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) containing at least one of the following [words](https://docs.victoriametrics.com/victorialogs/logsql/#word): `VictoriaMetrics`, `victoriametrics`, `VICTORIAMETRICS`, `Victoriametrics` or `victoriaMetrics`.
+
+* BUGFIX: [`facets` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#facets-pipe): properly skip field names with more than `max_values_per_field` unique values. Previously these fields could be returned with incomplete number of hits.
+
+## [v1.34.0](https://github.com/VictoriaMetrics/VictoriaLogs/releases/tag/v1.34.0)
+
+Released at 2025-09-22
+
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): add an ability to return partial responses in [VictoriaLogs cluster setup](https://docs.victoriametrics.com/victorialogs/cluster/) when some of `vlstorage` nodes are unavailable. See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#partial-responses) for details. See [#72](https://github.com/VictoriaMetrics/VictoriaLogs/issues/72).
+* FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add an ability to configure the number of parallel readers to use during query execution for reading the queried data from storage. This may help improving query performance for high-latency storage systems such as NFS, Ceph or S3. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#parallel_readers-query-option) for details.
+* FEATURE: [vlselect](https://docs.victoriametrics.com/victorialogs/cluster/): add `-storageNode.usernameFile` command-line flag for dynamically reloading basic auth username for the corresponding `-storageNode` from the given file. See [#459](https://github.com/VictoriaMetrics/VictoriaLogs/issues/459).
+
+* BUGFIX: [`/select/logsql/query` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs) at [VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/): properly execute the query with the `limit=N` query arg. Such queries are issued by [the built-in web UI for VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/#web-ui) and by [Grafana plugin for VictoriaLogs](https://docs.victoriametrics.com/victorialogs/victorialogs-datasource/) for returning the last N logs for the given query on the given time range. Previously it could return unexpected results. The issue has been introduced in [v1.30.0](#v1.30.0) while fixing [#587](https://github.com/VictoriaMetrics/VictoriaLogs/issues/587).
+* BUGFIX: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): disallow incorrectly written filters such as `foo = bar`, `foo != bar`, `foo > bar`, etc. They must be written as `foo:=bar`, `foo:!=bar`, `foo:>bar`. See [#590](https://github.com/VictoriaMetrics/VictoriaLogs/issues/590).
+* BUGFIX: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): allow using unquoted [pipe names](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) inside [LogsQL filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, `fields.foo:bar` is allowed now, while previously it should be written as `"fields.foo":bar`. See [#669](https://github.com/VictoriaMetrics/VictoriaLogs/issues/669).
+* BUGFIX: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): properly account for `result_prefix` in [unpack_json](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe), [unpack_logfmt](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe) and [unpack_syslog](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe) when determining the list of log fields to select. See [#671](https://github.com/VictoriaMetrics/VictoriaLogs/issues/671).
+* BUGFIX: [vlselect](https://docs.victoriametrics.com/victorialogs/cluster/): avoid `unexpected number of imported shards` error in [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats) and [`count_uniq_hash`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq_hash-stats) stats functions when `vlselect` and `vlstorage` instances have different number of CPU cores. See [#682](https://github.com/VictoriaMetrics/VictoriaLogs/issues/682).
+* BUGFIX: properly detele unneeded directories at [Ossfs2 filesystem](https://www.alibabacloud.com/help/en/oss/developer-reference/ossfs-2-0/). See [#649](https://github.com/VictoriaMetrics/VictoriaLogs/issues/649). Thanks to @xiaozongyang for [the initial pull request](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/9709).
+* BUGFIX: all [Enterprise version of VictoriaLogs](https://docs.victoriametrics.com/victoriametrics/enterprise/): fix support for automatic issuing of TLS certificates for HTTPS server via Let's Encrypt service using TLS-ALPN-01 challenge. See [Automatic issuing of TLS certificates](https://docs.victoriametrics.com/victorialogs/#automatic-issuing-of-tls-certificates) for more info.
+* BUGFIX: all components: lower severity of the log message for unavailable [Pressure Stall Information (PSI) metrics](https://docs.kernel.org/accounting/psi.html) from ERROR to INFO level. See [this issue](https://github.com/VictoriaMetrics/metrics/pull/101) for details.
+* BUGFIX: all components: properly expose metadata for summaries and histograms in VictoriaMetrics components with enabled `-metrics.exposeMetadata` cmd-line flag. See [metrics#98](https://github.com/VictoriaMetrics/metrics/issues/98) for details.
+* BUGFIX: [OpenTelemetry ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/opentelemetry/): fix log processor name from "opentelelemtry_protobuf" to "opentelelemtry_protobuf". This changes the `type` label value for ingestion metrics such as `vl_rows_ingested_total`, `vl_bytes_ingested_total`, and `vl_insert_flush_duration_seconds` for OpenTelemetry data ingestion.
+
+## [v1.33.1](https://github.com/VictoriaMetrics/VictoriaLogs/releases/tag/v1.33.1)
+
+Released at 2025-09-11
+
+* FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): optimize queries containing `| offset X | limit Y` for VictoriaLogs cluster. It also improves performance of queries in vmui and Grafana when retrieving sorted logs. See [#620](https://github.com/VictoriaMetrics/VictoriaLogs/issues/620).
+
+* BUGFIX: [`/select/logsql/query` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs): properly optimize the query execution when the `limit` query arg is set, while the `offset` query arg isn't set. It wasn't addressed properly in [v1.33.0](#v1330). See [#620](https://github.com/VictoriaMetrics/VictoriaLogs/issues/620).
+* BUGFIX: [`/select/logsql/hits` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats): take into account results from the [`union` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#union-pipe) while calculating log hits. See [#641](https://github.com/VictoriaMetrics/VictoriaLogs/issues/641).
+* BUGFIX: [`/select/logsql/hits` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats): take into account results from the [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe) while calculating log hits.
+* BUGFIX: [Syslog data ingesting](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/): keep nanosecond precision when parsing RFC3339 timestamp. See [#303](https://github.com/VictoriaMetrics/VictoriaLogs/issues/303).
+
+## [v1.33.0](https://github.com/VictoriaMetrics/VictoriaLogs/releases/tag/v1.33.0)
+
+Released at 2025-09-10
+
+* FEATURE: [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe): the `<...>` placeholder now matches quoted strings in single quotes additionally to strings in double quotes and backticks. For example, the `<login>` placeholder at the `... | extact "login=<login>,"` now matches `foo,bar` for the log message with the text `login='foo,bar'`.
 * FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add [pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter) for searching logs by the given patterns such as `<DATETIME>: user_id=<N>, ip=<IP4>, trace_id=<UUID>`. These filters are needed for [#518](https://github.com/VictoriaMetrics/VictoriaLogs/issues/518).
+* FEATURE: [Syslog data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/): support for receiving Syslog messages from Unix sockets of `SOCK_STREAM` and `SOCK_DGRAM` types via `-syslog.listenAddr.unix=/path/to/socket` and `-syslog.listenAddr.unix=unixgram:/path/to/socket` command-line flags. See [#570](https://github.com/VictoriaMetrics/VictoriaLogs/issues/570).
+
+* BUGFIX: [querying](https://docs.victoriametrics.com/victorialogs/querying/): `-search.maxQueryTimeRange` command-line flag now supports day (`d`), week (`w`) and year (`y`) suffixes additionally to the supported hour (`h`), minute (`m`) and second (`s`) suffixes. See [#50](https://github.com/VictoriaMetrics/VictoriaLogs/issues/50#issuecomment-3244097676).
+* BUGFIX: [`/select/logsql/query` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs): improve query performance when the `limit` query arg is set, while the `offset` query arg is missing. The issue has been introduced in [v1.28.0](#v1280). See [#620](https://github.com/VictoriaMetrics/VictoriaLogs/issues/620).
+* BUGFIX: [`/select/logsql/facets` endpoint](https://docs.victoriametrics.com/victorialogs/querying/#querying-facets): prevent from incorrect swap of `hits` and `field_values` fields in [VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/). See [#648](https://github.com/VictoriaMetrics/VictoriaLogs/issues/648).
+* BUGFIX: [querying](https://docs.victoriametrics.com/victorialogs/querying/) in [VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/): properly handle queries with [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) executed only at the `vlstorage` side without the need to post-process at the `vlselect` side. The issue has been introduced in [v1.31.0](#v1310) while working on [#52](https://github.com/VictoriaMetrics/VictoriaLogs/issues/52).
 
 ## [v1.32.0](https://github.com/VictoriaMetrics/VictoriaLogs/releases/tag/v1.32.0)
 
@@ -30,7 +75,7 @@ Released at 2025-09-03
 * FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add an ability to sort logs returned by [`json_values` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats) via `... | stats json_values() sort by (...)` syntax. The sorting can be combined with the `limit N` in order to get top N logs. For example, the following query returns up to 3 the most recent logs per every `host` over the last 5 minutes: `_time:5m | stats json_values() sort by (_time desc) limit 3 as last_3_host_logs`.
 * FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): return errors on typical incorrectly written queries. For example, `foo=~"bar"`, `foo~="bar"`, `foo=bar`, `foo!=bar`, `foo>bar`, `foo==bar`, etc. See [#590](https://github.com/VictoriaMetrics/VictoriaLogs/issues/590).
 * FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add [substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter), which searches for logs containing the given substring. Previously the [regexp filter](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) was used instead of substring filter. The downside of the regexp filter is that it needs proper escaping of special regexp chars.
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_found_rows` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log entries found per each query.
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_found_rows` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log entries found per each query.
 
 ## [v1.31.0](https://github.com/VictoriaMetrics/VictoriaLogs/releases/tag/v1.31.0)
 
@@ -38,10 +83,10 @@ Released at 2025-08-31
 
 * FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): add `-search.maxQueryTimeRange` command-line flag, which can be used for limiting resource usage by queries with too broad [time range filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter). See [resource usage limits docs](https://docs.victoriametrics.com/victorialogs/querying/#resource-usage-limits) for details. See [#50](https://github.com/VictoriaMetrics/VictoriaLogs/issues/50#issuecomment-3043590508) and [#611](https://github.com/VictoriaMetrics/VictoriaLogs/issues/611).
 * FEATURE: [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/): add [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe) for analyzing query execution statistics. This pipe may help understanding why the given query is slow and may help optimizing slow queries. See [#52](https://github.com/VictoriaMetrics/VictoriaLogs/issues/52).
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_read_values` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log field values read per each query.
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_read_timestamps` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log timestamps read per each query.
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_uncompressed_values_processed_bytes` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the amounts of bytes processed for uncompressed field values per each query.
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_processed_rows` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log entries processed per each query.
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_read_values` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log field values read per each query.
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_read_timestamps` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log timestamps read per each query.
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_uncompressed_values_processed_bytes` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the amounts of bytes processed for uncompressed field values per each query.
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_processed_rows` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) at [`/metrics`](https://docs.victoriametrics.com/victorialogs/#monitoring) page, which shows the number of log entries processed per each query.
 * FEATURE: [web UI](https://docs.victoriametrics.com/victorialogs/querying/#web-ui): always sort field names in alphabetical order at JSON view. This simplifies exploring logs with big number of fields (such as [wide events](https://jeremymorrell.dev/blog/a-practitioners-guide-to-wide-events/)). See [#87](https://github.com/VictoriaMetrics/VictoriaLogs/issues/87).
 * FEATURE: add `/internal/partition/snapshot/create` HTTP endpoint for creating [instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282) for per-day partitions. See [these docs](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) for details.
 * FEATURE: add `/internal/partition/snapshot/list` HTTP endpoint, which returns the list of absolute paths to snapshots created via `/internal/partition/snapshot/create`. See [these docs](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) for details.
@@ -106,8 +151,8 @@ Released at 2025-08-08
 * FEATURE: [Syslog data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/): add an ability to record the remote IP address from the received syslog messages into the `remote_ip` log field. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address) for details. Thanks to @biancalana for [the pull request](https://github.com/VictoriaMetrics/VictoriaLogs/pull/527). See [#40](https://github.com/VictoriaMetrics/VictoriaLogs/issues/40).
 * FEATURE: [retention](https://docs.victoriametrics.com/victorialogs/#retention): support disk space percentage-based retention (`-retention.maxDiskUsagePercent`), which helps dynamically manage total disk space usage. Only one of `-retention.maxDiskSpaceUsageBytes` or `-retention.maxDiskUsagePercent` can be set; otherwise, the application will panic. See [#513](https://github.com/VictoriaMetrics/VictoriaLogs/issues/513).
 * FEATURE: add an ability to dynamically attach and detach per-day partitions. This simplifies creating multi-tier storage schemes when recently ingested logs are stored on a fast storage (such as NVMe or SSD), while historical logs are gradually migrated to less expensive storage with bigger capacity (such as HDD). See [these docs](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) and [#432](https://github.com/VictoriaMetrics/VictoriaLogs/issues/432).
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_processed_blocks` [histogram](https://docs.victoriametrics.com/keyconcepts/#histogram), which shows the number of data blocks processed per every query. This histogram can be used for analysing query performance issues. See [#45](https://github.com/VictoriaMetrics/VictoriaLogs/issues/45).
-* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose [histograms](https://docs.victoriametrics.com/keyconcepts/#histogram) on the number of bytes read from disk for various data types per each query (see [#45](https://github.com/VictoriaMetrics/VictoriaLogs/issues/45)):
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose `vl_storage_per_query_processed_blocks` [histogram](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram), which shows the number of data blocks processed per every query. This histogram can be used for analysing query performance issues. See [#45](https://github.com/VictoriaMetrics/VictoriaLogs/issues/45).
+* FEATURE: [querying](https://docs.victoriametrics.com/victorialogs/querying/): expose [histograms](https://docs.victoriametrics.com/victoriametrics/keyconcepts/#histogram) on the number of bytes read from disk for various data types per each query (see [#45](https://github.com/VictoriaMetrics/VictoriaLogs/issues/45)):
   * `vl_storage_per_query_total_read_bytes` - the total number of bytes read during query execution.
   * `vl_storage_per_query_values_read_bytes` - the number of bytes read for [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values.
   * `vl_storage_per_query_timestamps_read_bytes` - the number of bytes read for the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
@@ -607,7 +652,7 @@ Released at 2024-11-08
 
 * FEATURE: [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe): add an ability to add prefix to all the log field names from the joined query, by using `| join by (<by_fields>) (<query>) prefix "some_prefix"` syntax.
 * FEATURE: [`_time` filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter): allow specifying offset without time range. For example, `_time:offset 1d` matches all the logs until `now-1d` in the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field). This is useful when building graphs for time ranges with some offset in the past.
-* FEATURE: [`/select/logsql/tail` HTTP endpoint](): support for `offset` query arg, which can be used for delayed emission of matching logs during live tailing. Thanks to @Fusl for the initial idea and implementation in [this pull request](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/7428).
+* FEATURE: [`/select/logsql/tail` HTTP endpoint](https://docs.victoriametrics.com/victorialogs/querying/#http-api): support for `offset` query arg, which can be used for delayed emission of matching logs during live tailing. Thanks to @Fusl for the initial idea and implementation in [this pull request](https://github.com/VictoriaMetrics/VictoriaMetrics/pull/7428).
 * FEATURE: [vlogscli](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/): allow enabling and disabling wrapping of long lines, which do not fit screen width, with `\wrap_long_lines` command.
 * FEATURE: [syslog data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/): allow overriding default [stream fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) with the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) during data ingestion. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields). See [this feature request](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/7480).
 * FEATURE: [syslog data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/): allow adding arbitrary [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) via `[label1=value1 ... labelN=valueN]` syntax inside Syslog messages. For example, `<165>1 2024-06-03T17:42:00.000Z example.com appname 12345 ID47 [field1=value1 field2=value2] some message`.
@@ -958,7 +1003,7 @@ Released at 2024-05-28
 * FEATURE: add [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe) for mathematical calculations over [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 * FEATURE: add [`field_values` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#field_values-pipe), which returns unique values for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 * FEATURE: allow omitting `stats` prefix in [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe). For example, `_time:5m | count() rows` is a valid query now. It is equivalent to `_time:5m | stats count() as rows`.
-* FEATURE: allow omitting `filter` prefix in [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe) if the filter doesn't clash with [pipe names](#https://docs.victoriametrics.com/victorialogs/logsql/#pipes). For example, `_time:5m | stats by (host) count() rows | rows:>1000` is a valid query now. It is equivalent to `_time:5m | stats by (host) count() rows | filter rows:>1000`.
+* FEATURE: allow omitting `filter` prefix in [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe) if the filter doesn't clash with [pipe names](https://docs.victoriametrics.com/victorialogs/logsql/#pipes). For example, `_time:5m | stats by (host) count() rows | rows:>1000` is a valid query now. It is equivalent to `_time:5m | stats by (host) count() rows | filter rows:>1000`.
 * FEATURE: allow [`head` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe) without number. For example, `error | head`. In this case 10 first values are returned as `head` Unix command does by default.
 * FEATURE: allow using [comparison filters](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter) with strings. For example, `some_text_field:>="foo"` matches [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with `some_text_field` field values bigger or equal to `foo`.
 
@@ -1060,7 +1105,7 @@ Released at 2024-05-20
 Released at 2024-05-15
 
 * FEATURE: add support for optional `start` and `end` query args to [HTTP querying API](https://docs.victoriametrics.com/victorialogs/querying/#http-api), which can be used for limiting the time range for [LogsQL query](https://docs.victoriametrics.com/victorialogs/logsql/).
-* FEATURE: add ability to return the first `N` results from [`sort` pipe](#https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe). This is useful when `N` biggest or `N` smallest values must be returned from large amounts of logs.
+* FEATURE: add ability to return the first `N` results from [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe). This is useful when `N` biggest or `N` smallest values must be returned from large amounts of logs.
 * FEATURE: add [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats) and [`median`](https://docs.victoriametrics.com/victorialogs/logsql/#median-stats) [stats functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe).
 
 ## [v0.6.1](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v0.6.1-victorialogs)
diff --git a/docs/victorialogs/FAQ.md b/docs/victorialogs/FAQ.md
index 1ddecd4e2d..0b685cf8bd 100644
--- a/docs/victorialogs/FAQ.md
+++ b/docs/victorialogs/FAQ.md
@@ -1,11 +1,11 @@
 ---
-weight: 6
+weight: 13
 title: FAQ
 menu:
   docs:
     identifier: "victorialogs-faq"
     parent: "victorialogs"
-    weight: 6
+    weight: 13
     title: FAQ
 tags:
   - logs
@@ -79,7 +79,7 @@ See [this article](https://itnext.io/why-victorialogs-is-a-better-alternative-to
 ## What is the difference between VictoriaLogs and ClickHouse?
 
 ClickHouse is an extremely fast and efficient analytical database. It can be used for logs storage, analysis and processing.
-VictoriaLogs is designed solely for logs. VictoriaLogs uses [similar design ideas as ClickHouse](#how-does-victorialogs-work) for achieving high performance.
+VictoriaLogs is designed solely for logs. VictoriaLogs uses [similar design ideas as ClickHouse](https://docs.victoriametrics.com/victorialogs/faq/#how-does-victorialogs-work) for achieving high performance.
 
 - ClickHouse is good for logs if you know the set of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
   and the expected query types beforehand. Then you can create a table with a column per each log field, and use the most optimal settings for the table -
@@ -243,11 +243,11 @@ or [Grafana plugin for VictoriaLogs](https://docs.victoriametrics.com/victorialo
 then make sure the selected time range covers the last day. Otherwise, the query above returns
 results on the intersection of the last day and the selected time range.
 
-See [why the log field occupies a lot of disk space](#why-the-log-field-occupies-a-lot-of-disk-space).
+See [why the log field occupies a lot of disk space](https://docs.victoriametrics.com/victorialogs/faq/#why-the-log-field-occupies-a-lot-of-disk-space).
 
 ## Why the log field occupies a lot of disk space?
 
-See [how to determine which log fields occupy the most of disk space](#how-to-determine-which-log-fields-occupy-the-most-of-disk-space).
+See [how to determine which log fields occupy the most of disk space](https://docs.victoriametrics.com/victorialogs/faq/#how-to-determine-which-log-fields-occupy-the-most-of-disk-space).
 Log field may occupy a lot of disk space if it contains values with many unique parts (aka "random" values).
 Such values do not compress well, so they occupy a lot of disk space. If you want reducing the amounts of occupied disk space,
 then either remove the given log field from the [ingested](https://docs.victoriametrics.com/victorialogs/data-ingestion/) logs
diff --git a/docs/victorialogs/QuickStart.md b/docs/victorialogs/QuickStart.md
index 925f10e362..fe7d239bd7 100644
--- a/docs/victorialogs/QuickStart.md
+++ b/docs/victorialogs/QuickStart.md
@@ -23,10 +23,10 @@ before you start working with VictoriaLogs.
 
 There are the following options exist:
 
-- [To run pre-built binaries](#pre-built-binaries)
-- [To run Docker image](#docker-image)
-- [To run in Kubernetes with Helm charts](#helm-charts)
-- [To build VictoriaLogs from source code](#building-from-source-code)
+- [To run pre-built binaries](https://docs.victoriametrics.com/victorialogs/quickstart/#pre-built-binaries)
+- [To run Docker image](https://docs.victoriametrics.com/victorialogs/quickstart/#docker-image)
+- [To run in Kubernetes with Helm charts](https://docs.victoriametrics.com/victorialogs/quickstart/#helm-charts)
+- [To build VictoriaLogs from source code](https://docs.victoriametrics.com/victorialogs/quickstart/#building-from-source-code)
 
 ### Pre-built binaries
 
@@ -36,8 +36,8 @@ Just download archive for the needed Operating system and architecture, unpack i
 For example, the following commands download VictoriaLogs archive for Linux/amd64, unpack and run it:
 
 ```sh
-curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.32.0/victoria-logs-linux-amd64-v1.32.0.tar.gz
-tar xzf victoria-logs-linux-amd64-v1.32.0.tar.gz
+curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.34.0/victoria-logs-linux-amd64-v1.34.0.tar.gz
+tar xzf victoria-logs-linux-amd64-v1.34.0.tar.gz
 ./victoria-logs-prod -storageDataPath=victoria-logs-data
 ```
 
@@ -49,7 +49,7 @@ the needed indexes during [data ingestion](https://docs.victoriametrics.com/vict
 
 See also:
 
-- [How to configure VictoriaLogs](#how-to-configure-victorialogs)
+- [How to configure VictoriaLogs](https://docs.victoriametrics.com/victorialogs/quickstart/#how-to-configure-victorialogs)
 - [How to ingest logs into VictoriaLogs](https://docs.victoriametrics.com/victorialogs/data-ingestion/)
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/)
 
@@ -60,20 +60,20 @@ Here is the command to run VictoriaLogs in a Docker container:
 
 ```sh
 docker run --rm -it -p 9428:9428 -v ./victoria-logs-data:/victoria-logs-data \
-  docker.io/victoriametrics/victoria-logs:v1.32.0 -storageDataPath=victoria-logs-data
+  docker.io/victoriametrics/victoria-logs:v1.34.0 -storageDataPath=victoria-logs-data
 ```
 
 See also:
 
-- [How to configure VictoriaLogs](#how-to-configure-victorialogs)
+- [How to configure VictoriaLogs](https://docs.victoriametrics.com/victorialogs/quickstart/#how-to-configure-victorialogs)
 - [How to ingest logs into VictoriaLogs](https://docs.victoriametrics.com/victorialogs/data-ingestion/)
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/)
 
 ### Helm charts
 
 You can run VictoriaLogs in Kubernetes environment
-with [VictoriaLogs single](https://docs.victoriametrics.com/helm/victorialogs-single/)
-or [cluster](https://docs.victoriametrics.com/helm/victorialogs-cluster) helm charts.
+with [VictoriaLogs single](https://docs.victoriametrics.com/helm/victoria-logs-single/)
+or [cluster](https://docs.victoriametrics.com/helm/victoria-logs-cluster/) helm charts.
 
 ### Building from source code
 
@@ -121,7 +121,7 @@ This will build `victoria-logs-prod` executable inside the `bin` folder.
 
 See also:
 
-- [How to configure VictoriaLogs](#how-to-configure-victorialogs)
+- [How to configure VictoriaLogs](https://docs.victoriametrics.com/victorialogs/quickstart/#how-to-configure-victorialogs)
 - [How to ingest logs into VictoriaLogs](https://docs.victoriametrics.com/victorialogs/data-ingestion/)
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/)
 
@@ -165,6 +165,6 @@ Docker-compose demos that integrate VictoriaLogs and various log collectors:
 - [Vector demo](https://github.com/VictoriaMetrics/VictoriaLogs/tree/master/deployment/docker/victorialogs/vector)
 - [Promtail demo](https://github.com/VictoriaMetrics/VictoriaLogs/tree/master/deployment/docker/victorialogs/promtail)
 
-You can use [VictoriaLogs single](https://docs.victoriametrics.com/helm/victorialogs-single/)
-or [cluster](https://docs.victoriametrics.com/helm/victorialogs-cluster) helm charts as a demo for running Vector
+You can use [VictoriaLogs single](https://docs.victoriametrics.com/helm/victoria-logs-single/)
+or [cluster](https://docs.victoriametrics.com/helm/victoria-logs-cluster/) helm charts as a demo for running Vector
 in Kubernetes with VictoriaLogs.
diff --git a/docs/victorialogs/README.md b/docs/victorialogs/README.md
index 75caa8d4e0..9aacc850c0 100644
--- a/docs/victorialogs/README.md
+++ b/docs/victorialogs/README.md
@@ -9,19 +9,22 @@ sitemap:
 VictoriaLogs is [open source](https://github.com/VictoriaMetrics/VictoriaLogs/) user-friendly database for logs
 from [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics/).
 
+## Features
+
 VictoriaLogs provides the following features:
 
 - It is resource-efficient and fast. It uses up to 30x less RAM and up to 15x less disk space than other solutions such as Elasticsearch and Grafana Loki.
-  See [these benchmarks](#benchmarks) and [this article](https://itnext.io/how-do-open-source-solutions-for-logs-work-elasticsearch-loki-and-victorialogs-9f7097ecbc2f) for details.
-  See also [the post from a happy user, who replaced 27-node Elasticsearch with a single-node VictoriaLogs](https://aus.social/@phs/114583927679254536).
+  See [these benchmarks](https://docs.victoriametrics.com/victorialogs/#benchmarks) and [this article](https://itnext.io/how-do-open-source-solutions-for-logs-work-elasticsearch-loki-and-victorialogs-9f7097ecbc2f) for details.
+  See also [the post from a happy user, who replaced 27-node Elasticsearch with a single-node VictoriaLogs](https://aus.social/@phs/114583927679254536),
+  [this post from happy users, who replaced Loki with VictoriaLogs](https://www.truefoundry.com/blog/victorialogs-vs-loki)
+  and [this post from a happy user who replaced grep with VictoriaLogs](https://chronicles.mad-scientist.club/tales/grepping-logs-remains-terrible/).
 - VictoriaLogs' capacity and performance scales linearly with the available resources (CPU, RAM, disk IO, disk space).
   It runs smoothly on Raspberry PI and on servers with hundreds of CPU cores and terabytes of RAM.
-  It can scale horizontally to many nodes in [cluster mode](https://docs.victoriametrics.com/victorialogs/cluster/).
+  It can scale horizontally to hundreds of nodes in [cluster mode](https://docs.victoriametrics.com/victorialogs/cluster/).
 - It can accept logs from popular log collectors. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/).
-- It is much easier to set up and operate compared to Elasticsearch and Grafana Loki, since it is basically zero-config.
+- It is much easier to set up and operate compared to Elasticsearch and Grafana Loki, since it is a single zero-config executable.
   See [these docs](https://docs.victoriametrics.com/victorialogs/quickstart/).
-- It provides easy yet powerful query language with full-text search capabilities across
-  all the [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- It provides easy yet powerful query language, which supports fast full-text search, fast advanced analytics and fast data extraction and transformation at query time.
   See [LogsQL docs](https://docs.victoriametrics.com/victorialogs/logsql/).
 - It provides [built-in web UI](https://docs.victoriametrics.com/victorialogs/querying/#web-ui) for logs' exploration.
 - It provides [Grafana plugin](https://docs.victoriametrics.com/victorialogs/victorialogs-datasource/) for building arbitrary dashboards in Grafana.
@@ -30,11 +33,12 @@ VictoriaLogs provides the following features:
   See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line) for details.
 - It support [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with high cardinality (e.g. high number of unique values) such as `trace_id`, `user_id` and `ip`.
 - It is optimized for logs with hundreds of fields (aka [`wide events`](https://jeremymorrell.dev/blog/a-practitioners-guide-to-wide-events/)).
-- It supports multitenancy - see [these docs](#multitenancy).
+- It supports multitenancy - see [these docs](https://docs.victoriametrics.com/victorialogs/#multitenancy).
 - It supports out-of-order logs' ingestion aka backfilling.
 - It supports live tailing for newly ingested logs. See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#live-tailing).
 - It supports selecting surrounding logs in front and after the selected logs. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#stream_context-pipe).
 - It supports alerting - see [these docs](https://docs.victoriametrics.com/victorialogs/vmalert/).
+- It fits well [RUM](https://en.wikipedia.org/wiki/Real_user_monitoring) and [SIEM](https://en.wikipedia.org/wiki/Security_information_and_event_management) use cases.
 
 See also [articles about VictoriaLogs](https://docs.victoriametrics.com/victorialogs/articles/).
 
@@ -45,7 +49,8 @@ you can join it via [Slack Inviter](https://slack.victoriametrics.com/).
 See [quick start docs](https://docs.victoriametrics.com/victorialogs/quickstart/) for start working with VictoriaLogs.
 
 If you want playing with VictoriaLogs web UI and [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/) query language,
-then go to [VictoriaLogs demo playground](https://play-vmlogs.victoriametrics.com/) and to [Grafana plugin playground for VictoriaLogs](https://play-grafana.victoriametrics.com/d/be5zidev72m80f/k8s-logs-via-victorialogs).
+then go to [VictoriaLogs demo playground](https://play-vmlogs.victoriametrics.com/) and
+to [Grafana plugin playground for VictoriaLogs](https://play-grafana.victoriametrics.com/d/be5zidev72m80f/k8s-logs-via-victorialogs).
 
 ## Tuning
 
@@ -105,7 +110,7 @@ For example, the following command starts VictoriaLogs with the retention of 8 w
 /path/to/victoria-logs -retentionPeriod=8w
 ```
 
-See also [retention by disk space usage](#retention-by-disk-space-usage).
+See also [retention by disk space usage](https://docs.victoriametrics.com/victorialogs/#retention-by-disk-space-usage).
 
 VictoriaLogs stores the [ingested](https://docs.victoriametrics.com/victorialogs/data-ingestion/) logs in per-day partition directories.
 It automatically drops partition directories outside the configured retention.
@@ -138,8 +143,8 @@ VictoriaLogs can be configured to automatically drop older per-day partitions ba
 ### Absolute disk space limit
 
 Use the `-retention.maxDiskSpaceUsageBytes` command-line flag to set a fixed threshold. VictoriaLogs will drop old per-day partitions
-if the total size of data at [`-storageDataPath` directory](#storage) becomes bigger than the specified limit.
-For example, the following command starts VictoriaLogs, which drops old per-day partitions if the total [storage](#storage) size becomes bigger than `100GiB`:
+if the total size of data at [`-storageDataPath` directory](https://docs.victoriametrics.com/victorialogs/#storage) becomes bigger than the specified limit.
+For example, the following command starts VictoriaLogs, which drops old per-day partitions if the total [storage](https://docs.victoriametrics.com/victorialogs/#storage) size becomes bigger than `100GiB`:
 
 ```sh
 /path/to/victoria-logs -retention.maxDiskSpaceUsageBytes=100GiB
@@ -148,7 +153,7 @@ For example, the following command starts VictoriaLogs, which drops old per-day
 ### Percentage-based disk space limit
 
 Use the `-retention.maxDiskUsagePercent` command-line flag to set a dynamic threshold based on the filesystem's total capacity.
-VictoriaLogs will drop old per-day partitions if the filesystem containing the [`-storageDataPath` directory](#storage) exceeds the specified percentage usage.
+VictoriaLogs will drop old per-day partitions if the filesystem containing the [`-storageDataPath` directory](https://docs.victoriametrics.com/victorialogs/#storage) exceeds the specified percentage usage.
 For example, the following command starts VictoriaLogs, which drops old per-day partitions if the filesystem usage exceeds 80%:
 
 ```sh
@@ -168,7 +173,7 @@ VictoriaLogs keeps at least two last days of data in order to guarantee that the
 This means that the total disk space usage may exceed the configured threshold if the size of the last two days of data
 exceeds the limit.
 
-The [`-retentionPeriod`](#retention) is applied independently to the disk space usage limits. This means that
+The [`-retentionPeriod`](https://docs.victoriametrics.com/victorialogs/#retention) is applied independently to the disk space usage limits. This means that
 VictoriaLogs automatically drops logs older than 7 days by default if only a disk space usage flag is set.
 Set the `-retentionPeriod` to some big value (e.g. `100y` - 100 years) if logs shouldn't be dropped because of time-based retention.
 For example:
@@ -193,7 +198,7 @@ For example, the following command starts VictoriaLogs, which stores the data at
 ```
 
 VictoriaLogs automatically creates the `-storageDataPath` directory on the first run if it is missing. VictoriaLogs stores logs
-per every day into a spearate subdirectory (aka per-day partition). See [partitions lifecycle](#partitions-lifecycle) for details.
+per every day into a spearate subdirectory (aka per-day partition). See [partitions lifecycle](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) for details.
 
 VictoriaLogs switches to cluster mode if `-storageNode` command-line flag is specified:
 
@@ -208,7 +213,7 @@ The ingested logs are stored in per-day subdirectories (partitions) at the `<-st
 For example, the directory with the name `20250418` contains logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) values
 at April 18, 2025 UTC. This allows flexible data management.
 
-For example, old per-day data is automatically and quickly deleted according to the provided [retention policy](#retention) by removing the corresponding per-day subdirectory (partition).
+For example, old per-day data is automatically and quickly deleted according to the provided [retention policy](https://docs.victoriametrics.com/victorialogs/#retention) by removing the corresponding per-day subdirectory (partition).
 
 VictoriaLogs supports the following HTTP API endpoints at `victoria-logs:9428` address for managing partitions:
 
@@ -223,11 +228,11 @@ VictoriaLogs supports the following HTTP API endpoints at `victoria-logs:9428` a
 - `/internal/partition/list` - returns JSON-encoded list of currently active partitions, which can be passed to `/internal/partition/detach` endpoint via `name` query arg.
 - `/internal/partition/snapshot/create?name=YYYYMMDD` - creates a [snapshot](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282)
   for the partition for the given day `YYYYMMDD`. The endpoint returns a JSON string with the absolute filesystem path to the created snapshot. It is safe to make backups from
-  the created snapshots according to [these instructions](#backup-and-restore). It is safe removing the created snapshots with `rm -rf` command.
+  the created snapshots according to [these instructions](https://docs.victoriametrics.com/victorialogs/#backup-and-restore). It is safe removing the created snapshots with `rm -rf` command.
   It is recommended removing unneeded snapshots on a regular basis in order to free up storage space occupied by these snapshots.
 - `/internal/partition/snapshot/list` - returns JSON-encoded list of absolute paths to per-day partition snapshots created via `/internal/partition/snapshot/create`.
 
-These endpoints can be protected from unauthorized access via `-partitionManageAuthKey` [command-line flag](#list-of-command-line-flags).
+These endpoints can be protected from unauthorized access via `-partitionManageAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
 
 These endpoints can be used also for setting up automated multi-tier storage schemes where recently ingested logs are stored to VictoriaLogs instances
 with fast NVMe (SSD) disks, while historical logs are gradully migrated to VictoriaLogs instances with slower, but bigger and less expensive HDD disks.
@@ -255,7 +260,7 @@ merge for September 21, 2024 partition. The call to `/internal/force_merge` retu
 Forced merges may require additional CPU, disk IO and storage space resources. It is unnecessary to run forced merge under normal conditions,
 since VictoriaLogs automatically performs optimal merges in background when new data is ingested into it.
 
-The `/internal/force_merge` endpoint can be protected from unauthorized access via `-forceMergeAuthKey` [command-line flag](#list-of-command-line-flags).
+The `/internal/force_merge` endpoint can be protected from unauthorized access via `-forceMergeAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
 
 ## Forced flush
 
@@ -268,7 +273,7 @@ It isn't recommended requesting the `/internal/force_flush` HTTP endpoint on a r
 and slows down data ingestion. It is expected that the `/internal/force_flush` is requested in automated tests, which need querying
 the recently ingested data.
 
-The `/internal/force_flush` endpoint can be protected from unauthorized access via `-forceFlushAuthKey` [command-line flag](#list-of-command-line-flags).
+The `/internal/force_flush` endpoint can be protected from unauthorized access via `-forceFlushAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
 
 ## High Availability
 
@@ -302,7 +307,7 @@ VictoriaLogs stores data into independent per-day partitions. Every partition is
 
 The following steps must be performed to make a backup of the given `YYYYMMDD` partition:
 
-1. To create a snapshot for the given per-day partition via `/internal/partition/snapshot/create?name=YYYYMMDD` HTTP endpoint (see [partitions lifecycle](#partitions-lifecycle) docs).
+1. To create a snapshot for the given per-day partition via `/internal/partition/snapshot/create?name=YYYYMMDD` HTTP endpoint (see [partitions lifecycle](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) docs).
    This endpoint returns an absolute filesystem path to the created snapshot - `<path-to-snapshot>`.
 
 1. To backup the created snapshot with [`rsync`](https://en.wikipedia.org/wiki/Rsync):
@@ -319,7 +324,7 @@ The following steps must be performed to make a backup of the given `YYYYMMDD` p
 The following steps must be performed for restoring the partition data from backup:
 
 1. To stop VictoriaLogs instance or to detach the `YYYYMMDD` partition, which is going to be restored from backup,
-   from the running VictoriaLogs via `/internal/partition/detach?name=YYYYMMDD` HTTP endpoint according to [these docs](#partitions-lifecycle).
+   from the running VictoriaLogs via `/internal/partition/detach?name=YYYYMMDD` HTTP endpoint according to [these docs](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle).
 
 1. To copy the partition from backup with `rsync`:
 
@@ -330,7 +335,7 @@ The following steps must be performed for restoring the partition data from back
    The `--delete` option is required in the command above in order to ensure that the partition contains the full copy of the backup without superfluous files.
 
 1. To start VictoriaLogs instance or to attach the restored partition to the running VictoriaLogs instance via `/internal/partition/attach?name=YYYYMMDD` HTTP endpoint
-   according to [these docs](#partitions-lifecycle).
+   according to [these docs](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle).
 
 It is also possible to use **the disk snapshot** feature provided by the operating system or cloud provider in order to perform a backup.
 
@@ -389,9 +394,9 @@ or similar authorization proxies. See [Security and Load balancing docs](https:/
 
 It is recommended protecting internal HTTP endpoints from unauthorized access:
 
-- [`/internal/force_flush`](#forced-flush) - via `-forceFlushAuthKey` [command-line flag](#list-of-command-line-flags).
-- [`/internal/force_merge`](#forced-merge) - via `-forceMergeAuthKey` [command-line flag](#list-of-command-line-flags).
-- [`/internal/partition/*`](#partitions-lifecycle) - via `-partitionManageAuthKey` [command-line flag](#list-of-command-line-flags).
+- [`/internal/force_flush`](https://docs.victoriametrics.com/victorialogs/#forced-flush) - via `-forceFlushAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
+- [`/internal/force_merge`](https://docs.victoriametrics.com/victorialogs/#forced-merge) - via `-forceMergeAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
+- [`/internal/partition/*`](https://docs.victoriametrics.com/victorialogs/#partitions-lifecycle) - via `-partitionManageAuthKey` [command-line flag](https://docs.victoriametrics.com/victorialogs/#list-of-command-line-flags).
 
 ### mTLS
 
@@ -422,7 +427,7 @@ The following command-line flags must be set in order to enable automatic issuin
 
 This functionality can be evaluated for free according to [these docs](https://docs.victoriametrics.com/victoriametrics/enterprise/).
 
-See also [security recommendations](#security).
+See also [security recommendations](https://docs.victoriametrics.com/victorialogs/#security).
 
 ## Benchmarks
 
@@ -488,6 +493,8 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -defaultMsgValue string
         Default value for _msg field if the ingested log entry doesn't contain it; see https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field (default "missing _msg field; see https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field")
+  -defaultParallelReaders int
+        Default number of parallel data readers to use for executing every query; higher number of readers may help increasing query performance on high-latency storage such as NFS or S3 at the cost of higher RAM usage; see https://docs.victoriametrics.com/victorialogs/logsql/#parallel_readers-query-option (default 32)
   -elasticsearch.version string
         Elasticsearch version to report to client (default "8.9.0")
   -enableTCP6
@@ -581,6 +588,8 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Supports the following optional suffixes for size values: KB, MB, GB, TB, KiB, MiB, GiB, TiB (default 67108864)
   -internalselect.disable
         Whether to disable /internal/select/* HTTP endpoints
+  -internalselect.maxConcurrentRequests int
+        The limit on the number of concurrent requests to /internal/select/* endpoints; other requests are put into the wait queue; see https://docs.victoriametrics.com/victorialogs/cluster/ (default 100)
   -journald.ignoreFields array
         Comma-separated list of fields to ignore for logs ingested over journald protocol. See https://docs.victoriametrics.com/victorialogs/data-ingestion/journald/#dropping-fields
         Supports an array of values separated by comma or specified via multiple flags.
@@ -686,12 +695,14 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
   -retentionPeriod value
         Log entries with timestamps older than now-retentionPeriod are automatically deleted; log entries with timestamps outside the retention are also rejected during data ingestion; the minimum supported retention is 1d (one day); see https://docs.victoriametrics.com/victorialogs/#retention ; see also -retention.maxDiskSpaceUsageBytes and -retention.maxDiskUsagePercent
         The following optional suffixes are supported: s (second), h (hour), d (day), w (week), y (year). If suffix isn't set, then the duration is counted in months (default 7d)
+  -search.allowPartialResponse
+        Whether to allow returning partial responses when some of vlstorage nodes from the -storageNode list are unavaialbe for querying. This flag works only for cluster setup of VictoriaLogs. See https://docs.victoriametrics.com/victorialogs/querying/#partial-responses
   -search.maxConcurrentRequests int
         The maximum number of concurrent search requests. It shouldn't be high, since a single request can saturate all the CPU cores, while many concurrently executed requests may require high amounts of memory. See also -search.maxQueueDuration (default 16)
   -search.maxQueryDuration duration
         The maximum duration for query execution. It can be overridden to a smaller value on a per-query basis via 'timeout' query arg (default 30s)
   -search.maxQueryTimeRange duration
-        The maximum time range, which can be set in the query sent to querying APIs. Queries with bigger time ranges are rejected. See https://docs.victoriametrics.com/victorialogs/querying/#http-api
+        The maximum time range, which can be set in the query sent to querying APIs. Queries with bigger time ranges are rejected. See https://docs.victoriametrics.com/victorialogs/querying/#resource-usage-limits
   -search.maxQueueDuration duration
         The maximum time the search request waits for execution when -search.maxConcurrentRequests limit is reached; see also -search.maxQueryDuration (default 10s)
   -select.disable
@@ -751,6 +762,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Optional basic auth username to use for the corresponding -storageNode
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -storageNode.usernameFile array
+        Optional path to basic auth username to use for the corresponding -storageNode. The file is re-read every second
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.compressMethod.tcp array
         Compression method for syslog messages received at the corresponding -syslog.listenAddr.tcp. Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression
         Supports an array of values separated by comma or specified via multiple flags.
@@ -759,6 +774,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Compression method for syslog messages received at the corresponding -syslog.listenAddr.udp. Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.compressMethod.unix array
+        Compression method for syslog messages received at the corresponding -syslog.listenAddr.unix. Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.decolorizeFields.tcp array
         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
         Supports an array of values separated by comma or specified via multiple flags.
@@ -767,6 +786,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         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
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.decolorizeFields.unix array
+        Fields to remove ANSI color codes across logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#decolorizing-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.extraFields.tcp array
         Fields to add to logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
         Supports an array of values separated by comma or specified via multiple flags.
@@ -775,6 +798,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Fields to add to logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.extraFields.unix array
+        Fields to add to logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.ignoreFields.tcp array
         Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
         Supports an array of values separated by comma or specified via multiple flags.
@@ -783,12 +810,20 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.ignoreFields.unix array
+        Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.listenAddr.tcp array
         Comma-separated list of TCP addresses to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.listenAddr.udp array
-        Comma-separated list of UDP address to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
+        Comma-separated list of UDP addresses to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.listenAddr.unix array
+        Comma-separated list of Unix socket filepaths to listen to for Syslog messages. Filepaths may be prepended with 'unixgram:'  for listening for SOCK_DGRAM sockets. By default SOCK_STREAM sockets are used. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.mtls array
@@ -807,6 +842,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.streamFields.unix array
+        Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.tenantID.tcp array
         TenantID for logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
         Supports an array of values separated by comma or specified via multiple flags.
@@ -815,6 +854,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         TenantID for logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.tenantID.unix array
+        TenantID for logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.timezone string
         Timezone to use when parsing timestamps in RFC3164 syslog messages. Timezone must be a valid IANA Time Zone. For example: America/New_York, Europe/Berlin, Etc/GMT+3 . See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/ (default "Local")
   -syslog.tls array
@@ -843,6 +886,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Whether to use local timestamp instead of the original timestamp for the ingested syslog messages at the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps
         Supports array of values separated by comma or specified via multiple flags.
         Empty values are set to false.
+  -syslog.useLocalTimestamp.unix array
+        Whether to use local timestamp instead of the original timestamp for the ingested syslog messages at the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps
+        Supports array of values separated by comma or specified via multiple flags.
+        Empty values are set to false.
   -syslog.useRemoteIP.tcp array
         Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
         Supports array of values separated by comma or specified via multiple flags.
@@ -851,6 +898,10 @@ Pass `-help` to VictoriaLogs in order to see the list of supported command-line
         Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
         Supports array of values separated by comma or specified via multiple flags.
         Empty values are set to false.
+  -syslog.useRemoteIP.unix array
+        Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
+        Supports array of values separated by comma or specified via multiple flags.
+        Empty values are set to false.
   -tls array
         Whether to enable TLS for incoming HTTP requests at the given -httpListenAddr (aka https). -tlsCertFile and -tlsKeyFile must be set if -tls is set. See also -mtls
         Supports array of values separated by comma or specified via multiple flags.
diff --git a/docs/victorialogs/Release-Guide.md b/docs/victorialogs/Release-Guide.md
index 7cb8ed3025..fee046d97c 100644
--- a/docs/victorialogs/Release-Guide.md
+++ b/docs/victorialogs/Release-Guide.md
@@ -1,11 +1,11 @@
 ---
-weight: 501
-title: Release process guidance for VictoriaLogs
+weight: 100
+title: Release Process Guidance for VictoriaLogs
 menu:
   docs:
     parent: victorialogs
     identifier: victorialogs-release-process-guidance
-    weight: 501
+    weight: 100
 tags: []
 aliases:
 - /victorialogs/release-guide/index.html
diff --git a/docs/victorialogs/Roadmap.md b/docs/victorialogs/Roadmap.md
index 372812b2b1..982c8945e5 100644
--- a/docs/victorialogs/Roadmap.md
+++ b/docs/victorialogs/Roadmap.md
@@ -1,11 +1,11 @@
 ---
-weight: 8
+weight: 102
 title: Roadmap
 disableToc: true
 menu:
   docs:
     parent: "victorialogs"
-    weight: 8
+    weight: 102
     title: Roadmap
 tags:
   - logs
diff --git a/docs/victorialogs/cluster.md b/docs/victorialogs/cluster.md
index 1cb43b07cd..8859e92607 100644
--- a/docs/victorialogs/cluster.md
+++ b/docs/victorialogs/cluster.md
@@ -1,11 +1,11 @@
 ---
-weight: 20
-title: VictoriaLogs cluster
+weight: 3
+title: VictoriaLogs Cluster
 menu:
   docs:
     parent: victorialogs
     identifier: vl-cluster
-    weight: 20
+    weight: 3
     title: VictoriaLogs cluster
 tags:
   - logs
@@ -24,10 +24,10 @@ then it is preferred to do this instead of switching to cluster mode, since a si
 
 The migration path from a single-node VictoriaLogs to cluster mode is very easy - just [upgrade](https://docs.victoriametrics.com/victorialogs/#upgrading)
 a single-node VictoriaLogs executable to the [latest available release](https://docs.victoriametrics.com/victorialogs/changelog/) and add it to the list of `vlstorage` nodes
-passed via `-storageNode` command-line flag to `vlinsert` and `vlselect` components of the cluster mode. See [cluster architecture](#architecture)
+passed via `-storageNode` command-line flag to `vlinsert` and `vlselect` components of the cluster mode. See [cluster architecture](https://docs.victoriametrics.com/victorialogs/cluster/#architecture)
 for more details about VictoriaLogs cluster components.
 
-See [quick start guide](#quick-start) on how to start working with VictoriaLogs cluster.
+See [quick start guide](https://docs.victoriametrics.com/victorialogs/cluster/#quick-start) on how to start working with VictoriaLogs cluster.
 
 ## Architecture
 
@@ -69,7 +69,7 @@ sequenceDiagram
   - It handles queries from `vlselect` by retrieving and transforming the requested data locally before returning results.
 
 Each `vlstorage` node operates as a self-contained VictoriaLogs instance.  
-Refer to the [single-node and cluster mode duality](#single-node-and-cluster-mode-duality) documentation for more information.  
+Refer to the [single-node and cluster mode duality](https://docs.victoriametrics.com/victorialogs/cluster/#single-node-and-cluster-mode-duality) documentation for more information.  
 This design allows you to reuse existing single-node VictoriaLogs instances by listing them in the `-storageNode` flag for `vlselect`, enabling unified querying across all nodes.
 
 All VictoriaLogs components are horizontally scalable and can be deployed on hardware best suited to their respective workloads.  
@@ -85,30 +85,43 @@ This HTTP-based communication model allows you to use reverse proxies for author
 Use of [vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/) is recommended for managing access control.
 See [Security and Load balancing docs](https://docs.victoriametrics.com/victorialogs/security-and-lb/) for details.
 
-For advanced setups, refer to the [multi-level cluster setup](#multi-level-cluster-setup) documentation.
+For advanced setups, refer to the [multi-level cluster setup](https://docs.victoriametrics.com/victorialogs/cluster/#multi-level-cluster-setup) documentation.
 
 ## High availability
 
-In the cluster setup, the following rules apply:
-
-- The `vlselect` component requires **all relevant vlstorage nodes to be available** in order to return complete and correct query results.
-
-  - If even one of the vlstorage nodes is temporarily unavailable, `vlselect` cannot safely return a full response, since some of the required data may reside on the missing node. Rather than risk delivering partial or misleading query results, which can cause confusion, trigger false alerts, or produce incorrect metrics, VictoriaLogs chooses to return an error instead.
-
-- The `vlinsert` component continues to function normally when some vlstorage nodes are unavailable. It automatically routes new logs to the remaining available nodes to ensure that data ingestion remains uninterrupted and newly received logs are not lost.
-
-> [!NOTE] Insight  
-> In most real-world cases, `vlstorage` nodes become unavailable during planned maintenance such as upgrades, config changes, or rolling restarts. These are typically infrequent (weekly or monthly) and brief (a few minutes).  
-> A short period of query downtime during such events is acceptable and fits well within most SLAs. For example, 60 minutes of downtime per month still provides around 99.86% availability, which often outperforms complex HA setups that rely on opaque auto-recovery and may fail unpredictably.
-
-VictoriaLogs itself does not handle replication at the storage level. Instead, it relies on an external log shipper, such as [vector](https://docs.victoriametrics.com/victorialogs/data-ingestion/vector/) or [vlagent](https://docs.victoriametrics.com/victorialogs/vlagent/), to send the same log stream to multiple independent VictoriaLogs instances:
+VictoriaLogs cluster provides high availability for [data ingestion path](https://docs.victoriametrics.com/victorialogs/data-ingestion/).
+It continues accepting incoming logs if some of `vlstorage` nodes are temporarily unavailable.
+`vlinsert` evenly spreads new logs among the remaining available `vlstorage` nodes in this case, so newly ingested logs are properly stored and are available for querying
+without any delays. This allows performing maintenance tasks for `vlstorage` nodes (such as upgrades, configuration updates, etc.) without worrying of the data loss.
+Make sure that the remaining `vlstorage` nodes have enough capacity for the increased data ingestion workload, in order to avoid availability problems.
+
+VictoriaLogs cluster returns `502 Bad Gateway` errors for [incoming queries](https://docs.victoriametrics.com/victorialogs/querying/)
+if some of `vlstorage` nodes are unavailable. This guarantees consistent query responses
+(e.g. all the stored logs are taken into account during the query) during maintenance tasks at `vlstorage` nodes. Note that all the newly incoming logs are properly stored
+to the remaining `vlstorage` nodes - see the paragraph above, so they become available for querying immediately after all the `vlstorage` nodes return back to the cluster.
+
+There are practical cases when it is preferred to return partial responses instead of `502 Bad Gateway` errors if some of `vlstorage` nodes are unavailable.
+See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#partial-responses) on how to achieve this.
+
+> [!NOTE] Insight
+> In most real-world cases, `vlstorage` nodes become unavailable during planned maintenance such as upgrades, config changes, or rolling restarts.
+> These are typically infrequent (weekly or monthly) and brief (a few minutes) events.
+> A short period of query downtime during maintenance tasks is acceptable and fits well within most SLAs. For example, 43 minutes of downtime per month during maintenance tasks
+> provides ~99.9% cluster availability. This is better in practice comparing to "magic" HA schemes with opaque auto-recovery - if these schemes fail,
+> then it is impossible to debug and fix them in a timely manner, so this will likely result in a long outage, which violates SLAs.
+
+The real HA scheme for both data ingestion and querying can be built only when copies of logs are sent into independent VictoriaLogs instances (or clusters)
+located in fully independent availability zones (datacenters). If an AZ becomes unavailable, then new logs continue to be written to the remaining AZ,
+while queries return full responses from the remaining AZ. When the AZ becomes available, then the pending buffered logs can be written to it, so the AZ
+can be used for querying full responses. This HA sheme can be built with the help of [vlagent](https://docs.victoriametrics.com/victorialogs/vlagent/)
+for data replication and buffering, and [vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/) for data querying:
 
 ```mermaid
 graph TD
     subgraph "HA Solution"
         subgraph "Ingestion Layer"
             LS["Log Sources<br/>(Applications)"]
-            VECTOR["Log Collector<br/>• Buffering<br/>• Replication<br/>• Delivery Guarantees"]
+            VLAGENT["Log Collector<br/>• Buffering<br/>• Replication<br/>• Delivery Guarantees"]
         end
         
         subgraph "Storage Layer"
@@ -126,15 +139,15 @@ graph TD
             QC["Query Clients<br/>(Grafana, API)"]
         end
         
-        LS --> VECTOR
-        VECTOR -->|"Replicate logs to<br/>Zone A cluster"| VLA
-        VECTOR -->|"Replicate logs to<br/>Zone B cluster"| VLB
+        LS --> VLAGENT
+        VLAGENT -->|"Replicate logs to<br/>Zone A cluster"| VLA
+        VLAGENT -->|"Replicate logs to<br/>Zone B cluster"| VLB
         
         VLA -->|"Serve queries from<br/>Zone A cluster"| LB
         VLB -->|"Serve queries from<br/>Zone B cluster"| LB
         LB --> QC
         
-        style VECTOR fill:#e8f5e8
+        style VLAGENT fill:#e8f5e8
         style VLA fill:#d5e8d4
         style VLB fill:#d5e8d4
         style LB fill:#e1f5fe
@@ -143,18 +156,17 @@ graph TD
     end
 ```
 
-In this HA solution:
-
-- A log shipper at the top receives logs and replicates them in parallel to two VictoriaLogs clusters.
-  - If one cluster fails completely (i.e., **all** of its storage nodes become unavailable), the log shipper continues to send logs to the remaining healthy cluster and buffers any logs that cannot be delivered. When the failed cluster becomes available again, the log shipper resumes sending both buffered and new logs to it.
-- On the read path, a load balancer (e.g., [vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/)) sits in front of the VictoriaLogs clusters and routes query requests to any healthy cluster.
-  - If one cluster fails (i.e., **at least one** of its storage nodes is unavailable), the load balancer detects this and automatically redirects all query traffic to the remaining healthy cluster.
+- [vlagent](https://docs.victoriametrics.com/victorialogs/vlagent/) receives and replicates logs to two VictoriaLogs clusters.
+  If one cluster becomes unavailable, the log shipper continues sending logs to the remaining healthy cluster. It also buffers logs that cannot be delivered to the unavailable cluster.
+  When the failed cluster becomes available again, the log shipper sends the buffered logs and then resumes sending new logs to it. This guarantees that both clusters have full copies
+  of all the ingested logs.
+- [vmauth](https://docs.victoriametrics.com/victoriametrics/vmauth/) routes query requests to healthy VictoriaLogs clusters.
+  If one cluster becomes unavailable, `vmauth` detects this and automatically redirects all query traffic to the remaining healthy cluster.
 
-There's no hidden coordination logic or consensus algorithm. You can scale it horizontally and operate it safely, even in bare-metal Kubernetes clusters using local PVs,
-as long as the log shipper handles reliable replication and buffering.
+There is no magic coordination logic or consensus algorithms in this scheme. This simplifies managing and troubleshooting this HA scheme.
 
 See also [Security and Load balancing docs](https://docs.victoriametrics.com/victorialogs/security-and-lb/).
-  
+
 ## Single-node and cluster mode duality
 
 Every `vlstorage` node can be used as a single-node VictoriaLogs instance:
@@ -167,7 +179,7 @@ A single-node VictoriaLogs instance can be used as `vlstorage` node in VictoriaL
 - It accepts data ingestion requests from `vlinsert` via `/internal/insert` HTTP endpoint at the TCP port specified via `-httpListenAddr` command-line flag.
 - It accepts queries from `vlselect` via `/internal/select/*` HTTP endpoints at the TCP port specified via `-httpListenAddr` command-line flags.
 
-See also [security docs](#security).
+See also [security docs](https://docs.victoriametrics.com/victorialogs/cluster/#security).
 
 ## Multi-level cluster setup
 
@@ -177,7 +189,7 @@ See also [security docs](#security).
 - `vlselect` can send queries to other `vlselect` nodes if they are specified via `-storageNode` command-line flag.
   This allows building multi-level cluster schemes when top-level `vlselect` queries multiple lower-level clusters of VictoriaLogs.
 
-See [security docs](#security) on how to protect communications between multiple levels of `vlinsert` and `vlselect` nodes.
+See [security docs](https://docs.victoriametrics.com/victorialogs/cluster/#security) on how to protect communications between multiple levels of `vlinsert` and `vlselect` nodes.
 
 ## Security
 
@@ -239,13 +251,13 @@ It is recommended to disable select endpoints on `vlinsert` and insert endpoints
 This helps prevent sending select requests to `vlinsert` nodes or insert requests to `vlselect` nodes in case of misconfiguration in the authorization proxy
 in front of the `vlinsert` and `vlselect` nodes.
 
-See also [mTLS](#mtls).
+See also [mTLS](https://docs.victoriametrics.com/victorialogs/cluster/#mtls).
 
 ### mTLS
 
 [Enterprise version of VictoriaLogs](https://docs.victoriametrics.com/victoriametrics/enterprise/) supports the ability to verify client TLS certificates
 at the `vlstorage` side for TLS connections established from `vlinsert` and `vlselect` nodes (aka [mTLS](https://en.wikipedia.org/wiki/Mutual_authentication#mTLS)).
-See [TLS docs](#tls) for details on how to set up TLS communications between VictoriaLogs cluster nodes.
+See [TLS docs](https://docs.victoriametrics.com/victorialogs/cluster/#tls) for details on how to set up TLS communications between VictoriaLogs cluster nodes.
 
 mTLS authentication can be enabled by passing the `-mtls` command-line flag to `vlstorage` node additionally to the `-tls` command-line flag.
 In this case it verifies TLS client certificates for connections from `vlinsert` and `vlselect` at the address specified via `-httpListenAddr` command-line flag.
@@ -266,18 +278,18 @@ The following guide covers the following topics for Linux host:
 
 - How to download VictoriaLogs executable.
 - How to start VictoriaLogs cluster, which consists of two `vlstorage` nodes, a single `vlinsert` node and a single `vlselect` node
-  running on a localhost according to [cluster architecture](#architecture).
+  running on a localhost according to [cluster architecture](https://docs.victoriametrics.com/victorialogs/cluster/#architecture).
 - How to ingest logs into the cluster.
 - How to query the ingested logs.
 
 Download and unpack the latest VictoriaLogs release:
 
 ```sh
-curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.32.0/victoria-logs-linux-amd64-v1.32.0.tar.gz
-tar xzf victoria-logs-linux-amd64-v1.32.0.tar.gz
+curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.34.0/victoria-logs-linux-amd64-v1.34.0.tar.gz
+tar xzf victoria-logs-linux-amd64-v1.34.0.tar.gz
 ```
 
-Start the first [`vlstorage` node](#architecture), which accepts incoming requests at the port `9491` and stores the ingested logs at `victoria-logs-data-1` directory:
+Start the first [`vlstorage` node](https://docs.victoriametrics.com/victorialogs/cluster/#architecture), which accepts incoming requests at the port `9491` and stores the ingested logs at `victoria-logs-data-1` directory:
 
 ```sh
 ./victoria-logs-prod -httpListenAddr=:9491 -storageDataPath=victoria-logs-data-1 &
@@ -330,7 +342,7 @@ Logs also can be explored and queried via [built-in Web UI](https://docs.victori
 Open `http://localhost:9471/select/vmui/` in the web browser, select `last 7 days` time range in the top right corner and explore the ingested logs.
 See [LogsQL docs](https://docs.victoriametrics.com/victorialogs/logsql/) to familiarize yourself with the query language.
 
-Every `vlstorage` node can be queried individually because [it is equivalent to a single-node VictoriaLogs](#single-node-and-cluster-mode-duality).
+Every `vlstorage` node can be queried individually because [it is equivalent to a single-node VictoriaLogs](https://docs.victoriametrics.com/victorialogs/cluster/#single-node-and-cluster-mode-duality).
 For example, the following command returns the number of stored logs at the first `vlstorage` node started above:
 
 ```sh
@@ -339,7 +351,7 @@ curl http://localhost:9491/select/logsql/query -d 'query=* | count()'
 
 It is recommended reading [key concepts](https://docs.victoriametrics.com/victorialogs/keyconcepts/) before you start working with VictoriaLogs.
 
-See also [security docs](#security).
+See also [security docs](https://docs.victoriametrics.com/victorialogs/cluster/#security).
 
 ## Performance tuning
 
diff --git a/docs/victorialogs/data-ingestion/DataDogAgent.md b/docs/victorialogs/data-ingestion/DataDogAgent.md
index 625eb69632..8b0bbdd573 100644
--- a/docs/victorialogs/data-ingestion/DataDogAgent.md
+++ b/docs/victorialogs/data-ingestion/DataDogAgent.md
@@ -1,6 +1,6 @@
 ---
 weight: 5
-title: DataDog Agent setup
+title: DataDog Agent Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/Filebeat.md b/docs/victorialogs/data-ingestion/Filebeat.md
index 8c8b489392..4782409e5f 100644
--- a/docs/victorialogs/data-ingestion/Filebeat.md
+++ b/docs/victorialogs/data-ingestion/Filebeat.md
@@ -1,6 +1,6 @@
 ---
 weight: 1
-title: Filebeat setup
+title: Filebeat Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/Fluentbit.md b/docs/victorialogs/data-ingestion/Fluentbit.md
index 11d587595d..e3db992155 100644
--- a/docs/victorialogs/data-ingestion/Fluentbit.md
+++ b/docs/victorialogs/data-ingestion/Fluentbit.md
@@ -1,6 +1,6 @@
 ---
 weight: 2
-title: Fluentbit setup
+title: Fluentbit Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/Fluentd.md b/docs/victorialogs/data-ingestion/Fluentd.md
index 556eab676a..353205ee69 100644
--- a/docs/victorialogs/data-ingestion/Fluentd.md
+++ b/docs/victorialogs/data-ingestion/Fluentd.md
@@ -1,6 +1,6 @@
 ---
 weight: 2
-title: Fluentd setup
+title: Fluentd Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/Journald.md b/docs/victorialogs/data-ingestion/Journald.md
index 708f65d0fc..60f27c3635 100644
--- a/docs/victorialogs/data-ingestion/Journald.md
+++ b/docs/victorialogs/data-ingestion/Journald.md
@@ -1,6 +1,6 @@
 ---
 weight: 10
-title: Journald setup
+title: Journald Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/Logstash.md b/docs/victorialogs/data-ingestion/Logstash.md
index e65985070c..85cf8761ad 100644
--- a/docs/victorialogs/data-ingestion/Logstash.md
+++ b/docs/victorialogs/data-ingestion/Logstash.md
@@ -1,6 +1,6 @@
 ---
 weight: 3
-title: Logstash setup
+title: Logstash Setup
 disableToc: true
 menu:
   docs:
@@ -14,8 +14,8 @@ aliases:
 ---
 VictoriaLogs supports given below Logstash outputs:
 
-- [Elasticsearch](#elasticsearch)
-- [HTTP JSON](#http)
+- [Elasticsearch](https://docs.victoriametrics.com/victorialogs/data-ingestion/logstash/#elasticsearch)
+- [HTTP JSON](https://docs.victoriametrics.com/victorialogs/data-ingestion/logstash/#http)
 
 ## Elasticsearch
 
diff --git a/docs/victorialogs/data-ingestion/Promtail.md b/docs/victorialogs/data-ingestion/Promtail.md
index 39660cabc1..772291bbab 100644
--- a/docs/victorialogs/data-ingestion/Promtail.md
+++ b/docs/victorialogs/data-ingestion/Promtail.md
@@ -1,6 +1,6 @@
 ---
 weight: 4
-title: Promtail setup
+title: Promtail Setup
 disableToc: true
 menu:
   docs:
diff --git a/docs/victorialogs/data-ingestion/README.md b/docs/victorialogs/data-ingestion/README.md
index 40b6b03017..f6179bb562 100644
--- a/docs/victorialogs/data-ingestion/README.md
+++ b/docs/victorialogs/data-ingestion/README.md
@@ -24,20 +24,20 @@ The ingested logs can be queried according to [these docs](https://docs.victoria
 
 See also:
 
-- [Log collectors and data ingestion formats](#log-collectors-and-data-ingestion-formats).
-- [Data ingestion troubleshooting](#troubleshooting).
+- [Log collectors and data ingestion formats](https://docs.victoriametrics.com/victorialogs/data-ingestion/#log-collectors-and-data-ingestion-formats).
+- [Data ingestion troubleshooting](https://docs.victoriametrics.com/victorialogs/data-ingestion/#troubleshooting).
 
 ## HTTP APIs
 
 VictoriaLogs supports the following data ingestion HTTP APIs:
 
-- Elasticsearch bulk API. See [these docs](#elasticsearch-bulk-api).
-- JSON stream API aka [ndjson](https://jsonlines.org/). See [these docs](#json-stream-api).
-- Loki JSON API. See [these docs](#loki-json-api).
-- OpenTelemetry API. See [these docs](#opentelemetry-api).
+- Elasticsearch bulk API. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#elasticsearch-bulk-api).
+- JSON stream API aka [ndjson](https://jsonlines.org/). See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#json-stream-api).
+- Loki JSON API. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#loki-json-api).
+- OpenTelemetry API. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#opentelemetry-api).
 - Journald export format.
 
-VictoriaLogs accepts optional [HTTP parameters](#http-parameters) at data ingestion HTTP APIs.
+VictoriaLogs accepts optional [HTTP parameters](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters) at data ingestion HTTP APIs.
 
 ### Elasticsearch bulk API
 
@@ -70,7 +70,7 @@ Otherwise the timestamp field must be in one of the following formats:
 See [these docs](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) for details on fields,
 which must be present in the ingested log messages.
 
-The API accepts various http parameters, which can change the data ingestion behavior - [these docs](#http-parameters) for details.
+The API accepts various http parameters, which can change the data ingestion behavior - [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters) for details.
 
 The following command verifies that the data has been successfully ingested to VictoriaLogs by [querying](https://docs.victoriametrics.com/victorialogs/querying/) it:
 
@@ -91,8 +91,8 @@ The duration of requests to `/insert/elasticsearch/_bulk` can be monitored with
 
 See also:
 
-- [How to debug data ingestion](#troubleshooting).
-- [HTTP parameters, which can be passed to the API](#http-parameters).
+- [How to debug data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/#troubleshooting).
+- [HTTP parameters, which can be passed to the API](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters).
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/).
 
 ### JSON stream API
@@ -130,7 +130,7 @@ Otherwise the timestamp field must be in one of the following formats:
 See [these docs](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) for details on fields,
 which must be present in the ingested log messages.
 
-The API accepts various http parameters, which can change the data ingestion behavior - [these docs](#http-parameters) for details.
+The API accepts various http parameters, which can change the data ingestion behavior - [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters) for details.
 
 The following command verifies that the data has been successfully ingested into VictoriaLogs by [querying](https://docs.victoriametrics.com/victorialogs/querying/) it:
 
@@ -153,8 +153,8 @@ The duration of requests to `/insert/jsonline` can be monitored with [`vl_http_r
 
 See also:
 
-- [How to debug data ingestion](#troubleshooting).
-- [HTTP parameters, which can be passed to the API](#http-parameters).
+- [How to debug data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/#troubleshooting).
+- [HTTP parameters, which can be passed to the API](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters).
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/).
 
 ### Loki JSON API
@@ -185,7 +185,7 @@ The command should return the following response:
 The response by default contains all the [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 See [how to query specific fields](https://docs.victoriametrics.com/victorialogs/logsql/#querying-specific-fields).
 
-The `/insert/loki/api/v1/push` accepts various http parameters, which can change the data ingestion behavior - [these docs](#http-parameters) for details.
+The `/insert/loki/api/v1/push` accepts various http parameters, which can change the data ingestion behavior - [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters) for details.
 There is no need in specifying `_msg_field` and `_time_field` query args, since VictoriaLogs automatically extracts log message and timestamp from the ingested Loki data.
 
 The `_stream_fields` arg is optional. If it isn't set, then all the labels inside the `"stream":{...}` are treated
@@ -202,8 +202,8 @@ The duration of requests to `/insert/loki/api/v1/push` can be monitored with [`v
 
 See also:
 
-- [How to debug data ingestion](#troubleshooting).
-- [HTTP parameters, which can be passed to the API](#http-parameters).
+- [How to debug data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/#troubleshooting).
+- [HTTP parameters, which can be passed to the API](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters).
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/).
 
 ### Opentelemetry API
@@ -214,12 +214,12 @@ See more details [in these docs](https://docs.victoriametrics.com/victorialogs/d
 ### HTTP parameters
 
 VictoriaLogs accepts the following configuration parameters via [HTTP headers](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields)
-or via [HTTP query string args](https://en.wikipedia.org/wiki/Query_string) at [data ingestion HTTP APIs](#http-apis).
+or via [HTTP query string args](https://en.wikipedia.org/wiki/Query_string) at [data ingestion HTTP APIs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-apis).
 HTTP query string parameters have priority over HTTP Headers.
 
 #### HTTP Query string parameters
 
-All the [HTTP-based data ingestion protocols](#http-apis) support the following [HTTP query string](https://en.wikipedia.org/wiki/Query_string) args:
+All the [HTTP-based data ingestion protocols](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-apis) support the following [HTTP query string](https://en.wikipedia.org/wiki/Query_string) args:
 
 - `_msg_field` - the name of the [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
   containing [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
@@ -260,12 +260,12 @@ All the [HTTP-based data ingestion protocols](#http-apis) support the following
 - `debug` - if this arg is set to `1`, then the ingested logs aren't stored in VictoriaLogs. Instead,
   the ingested data is logged by VictoriaLogs, so it can be investigated later.
 
-See also [HTTP headers](#http-headers).
+See also [HTTP headers](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-headers).
 
 #### HTTP headers
 
-All the [HTTP-based data ingestion protocols](#http-apis) support the following [HTTP Headers](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields)
-additionally to [HTTP query args](#http-query-string-parameters):
+All the [HTTP-based data ingestion protocols](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-apis) support the following [HTTP Headers](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields)
+additionally to [HTTP query args](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-query-string-parameters):
 
 - `AccountID` - accountID of the tenant to ingest data to. See [multitenancy docs](https://docs.victoriametrics.com/victorialogs/#multitenancy) for details.
 
@@ -310,7 +310,7 @@ additionally to [HTTP query args](#http-query-string-parameters):
 - `VL-Debug` - if this parameter is set to `1`, then the ingested logs aren't stored in VictoriaLogs. Instead,
   the ingested data is logged by VictoriaLogs, so it can be investigated later.
 
-See also [HTTP Query string parameters](#http-query-string-parameters).
+See also [HTTP Query string parameters](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-query-string-parameters).
 
 ## Decolorizing
 
@@ -318,7 +318,7 @@ If the ingested logs contain [ANSI color codes](https://en.wikipedia.org/wiki/AN
 storing the logs in VictoriaLogs. This simplifies further querying and analysis of such logs.
 
 Decolorizing can be done either at the log collector / shipper side or at the VictoriaLogs side with `decolorize_fields` HTTP query arg
-and `VL-Decolorize-Fields` HTTP request header according to [these docs](#http-parameters).
+and `VL-Decolorize-Fields` HTTP request header according to [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters).
 
 ## Troubleshooting
 
@@ -343,14 +343,14 @@ VictoriaLogs provides the following command-line flags, which can help debugging
   This may help debugging [high cardinality issues](https://docs.victoriametrics.com/victorialogs/keyconcepts/#high-cardinality).
 - `-logIngestedRows` - if this flag is passed to VictoriaLogs, then it logs all the ingested
   [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-  See also `debug` [parameter](#http-parameters).
+  See also `debug` [parameter](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-parameters).
 
 VictoriaLogs exposes various [metrics](https://docs.victoriametrics.com/victorialogs/metrics/), which may help debugging data ingestion issues:
 
 - [`vl_rows_ingested_total`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_rows_ingested_total) - the number of ingested [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
   since the last VictoriaLogs restart. If this number increases over time, then logs are successfully ingested into VictoriaLogs.
   The ingested logs can be inspected in the following ways:
-  - By passing `debug=1` parameter to every request to [data ingestion APIs](#http-apis). The ingested rows aren't stored in VictoriaLogs
+  - By passing `debug=1` parameter to every request to [data ingestion APIs](https://docs.victoriametrics.com/victorialogs/data-ingestion/#http-apis). The ingested rows aren't stored in VictoriaLogs
     in this case. Instead, they are logged, so they can be investigated later.
     The [`vl_rows_dropped_total`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_rows_dropped_total) metric is incremented for each logged row.
   - By passing `-logIngestedRows` command-line flag to VictoriaLogs. In this case it logs all the ingested data, so it can be investigated later.
@@ -363,17 +363,17 @@ VictoriaLogs exposes various [metrics](https://docs.victoriametrics.com/victoria
 
 Here is the list of log collectors and their ingestion formats supported by VictoriaLogs:
 
-| How to setup the collector | Format: Elasticsearch | Format: JSON Stream | Format: Loki | Format: syslog | Format: OpenTelemetry | Format: Journald | Format: DataDog |
-|----------------------------|-----------------------|---------------------|--------------|----------------|-----------------------|------------------|-----------------|
-| [Rsyslog](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/) | [Yes](https://www.rsyslog.com/doc/configuration/modules/omelasticsearch.html) | No | No | [Yes](https://www.rsyslog.com/doc/configuration/modules/omfwd.html) | No | No | No |
-| [Syslog-ng](https://docs.victoriametrics.com/victorialogs/data-ingestion/filebeat/) | Yes, [v1](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/28#TOPIC-956489), [v2](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/29#TOPIC-956494) | No | No | [Yes](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/44#TOPIC-956553) | No | No | No |
-| [Filebeat](https://docs.victoriametrics.com/victorialogs/data-ingestion/filebeat/) | [Yes](https://www.elastic.co/guide/en/beats/filebeat/current/elasticsearch-output.html) | No | No | No | No | No | No |
-| [Fluentbit](https://docs.victoriametrics.com/victorialogs/data-ingestion/fluentbit/) | No | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/http) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/loki) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/syslog) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/opentelemetry) | No | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/datadog) |
-| [Logstash](https://docs.victoriametrics.com/victorialogs/data-ingestion/logstash/)   | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-elasticsearch.html) | No | No | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-syslog.html) | [Yes](https://github.com/paulgrav/logstash-output-opentelemetry) | No | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-datadog.html) |
-| [Vector](https://docs.victoriametrics.com/victorialogs/data-ingestion/vector/) | [Yes](https://vector.dev/docs/reference/configuration/sinks/elasticsearch/) | [Yes](https://vector.dev/docs/reference/configuration/sinks/http/) | [Yes](https://vector.dev/docs/reference/configuration/sinks/loki/) | No | No | No | [Yes](https://vector.dev/docs/reference/configuration/sinks/datadog_logs/) |
-| [Promtail](https://docs.victoriametrics.com/victorialogs/data-ingestion/promtail/)   | No | No | [Yes](https://grafana.com/docs/loki/latest/clients/promtail/configuration/#clients) | No | No | No | No |
-| [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/) | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/elasticsearchexporter) | No | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/lokiexporter) | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/syslogexporter) | [Yes](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlphttpexporter) | No | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/datadogexporter) |
-| [Telegraf](https://docs.victoriametrics.com/victorialogs/data-ingestion/telegraf/) | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/elasticsearch) | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/http) | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/loki) | [Yes](https://github.com/influxdata/telegraf/blob/master/plugins/outputs/syslog) | Yes | No | No |
-| [Fluentd](https://docs.victoriametrics.com/victorialogs/data-ingestion/fluentd/) | [Yes](https://github.com/uken/fluent-plugin-elasticsearch) | [Yes](https://docs.fluentd.org/output/http) | [Yes](https://grafana.com/docs/loki/latest/send-data/fluentd/) | [Yes](https://github.com/fluent-plugins-nursery/fluent-plugin-remote_syslog) | No | No | No |
-| [Journald](https://docs.victoriametrics.com/victorialogs/data-ingestion/journald/) | No | No | No | No | No | Yes | No |
-| [DataDog Agent](https://docs.victoriametrics.com/victorialogs/data-ingestion/datadog-agent) | No | No | No | No | No | No | Yes |
+| How to setup the collector                                                                   | Format: Elasticsearch | Format: JSON Stream | Format: Loki | Format: syslog | Format: OpenTelemetry | Format: Journald | Format: DataDog |
+|----------------------------------------------------------------------------------------------|-----------------------|---------------------|--------------|----------------|-----------------------|------------------|-----------------|
+| [Rsyslog](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/)              | [Yes](https://www.rsyslog.com/doc/configuration/modules/omelasticsearch.html) | No | No | [Yes](https://www.rsyslog.com/doc/configuration/modules/omfwd.html) | No | No | No |
+| [Syslog-ng](https://docs.victoriametrics.com/victorialogs/data-ingestion/filebeat/)          | Yes, [v1](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/28#TOPIC-956489), [v2](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/29#TOPIC-956494) | No | No | [Yes](https://support.oneidentity.com/technical-documents/syslog-ng-open-source-edition/3.16/administration-guide/44#TOPIC-956553) | No | No | No |
+| [Filebeat](https://docs.victoriametrics.com/victorialogs/data-ingestion/filebeat/)           | [Yes](https://www.elastic.co/guide/en/beats/filebeat/current/elasticsearch-output.html) | No | No | No | No | No | No |
+| [Fluentbit](https://docs.victoriametrics.com/victorialogs/data-ingestion/fluentbit/)         | No | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/http) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/loki) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/syslog) | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/opentelemetry) | No | [Yes](https://docs.fluentbit.io/manual/pipeline/outputs/datadog) |
+| [Logstash](https://docs.victoriametrics.com/victorialogs/data-ingestion/logstash/)           | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-elasticsearch.html) | No | No | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-syslog.html) | [Yes](https://github.com/paulgrav/logstash-output-opentelemetry) | No | [Yes](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-datadog.html) |
+| [Vector](https://docs.victoriametrics.com/victorialogs/data-ingestion/vector/)               | [Yes](https://vector.dev/docs/reference/configuration/sinks/elasticsearch/) | [Yes](https://vector.dev/docs/reference/configuration/sinks/http/) | [Yes](https://vector.dev/docs/reference/configuration/sinks/loki/) | No | No | No | [Yes](https://vector.dev/docs/reference/configuration/sinks/datadog_logs/) |
+| [Promtail](https://docs.victoriametrics.com/victorialogs/data-ingestion/promtail/)           | No | No | [Yes](https://grafana.com/docs/loki/latest/clients/promtail/configuration/#clients) | No | No | No | No |
+| [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/)                          | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/elasticsearchexporter) | No | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/lokiexporter) | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/syslogexporter) | [Yes](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter/otlphttpexporter) | No | [Yes](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/datadogexporter) |
+| [Telegraf](https://docs.victoriametrics.com/victorialogs/data-ingestion/telegraf/)           | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/elasticsearch) | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/http) | [Yes](https://github.com/influxdata/telegraf/tree/master/plugins/outputs/loki) | [Yes](https://github.com/influxdata/telegraf/blob/master/plugins/outputs/syslog) | Yes | No | No |
+| [Fluentd](https://docs.victoriametrics.com/victorialogs/data-ingestion/fluentd/)             | [Yes](https://github.com/uken/fluent-plugin-elasticsearch) | [Yes](https://docs.fluentd.org/output/http) | [Yes](https://grafana.com/docs/loki/latest/send-data/fluentd/) | [Yes](https://github.com/fluent-plugins-nursery/fluent-plugin-remote_syslog) | No | No | No |
+| [Journald](https://docs.victoriametrics.com/victorialogs/data-ingestion/journald/)           | No | No | No | No | No | Yes | No |
+| [DataDog Agent](https://docs.victoriametrics.com/victorialogs/data-ingestion/datadog-agent/) | No | No | No | No | No | No | Yes |
diff --git a/docs/victorialogs/data-ingestion/Telegraf.md b/docs/victorialogs/data-ingestion/Telegraf.md
index d8f377ebf9..32d70a221c 100644
--- a/docs/victorialogs/data-ingestion/Telegraf.md
+++ b/docs/victorialogs/data-ingestion/Telegraf.md
@@ -1,6 +1,6 @@
 ---
 weight: 5
-title: Telegraf setup
+title: Telegraf Setup
 disableToc: true
 menu:
   docs:
@@ -13,8 +13,8 @@ aliases:
 ---
 VictoriaLogs supports given below Telegraf outputs:
 
-- [Elasticsearch](#elasticsearch)
-- [HTTP JSON](#http)
+- [Elasticsearch](https://docs.victoriametrics.com/victorialogs/data-ingestion/telegraf/#elasticsearch)
+- [HTTP JSON](https://docs.victoriametrics.com/victorialogs/data-ingestion/telegraf/#http)
 
 ## Elasticsearch
 
diff --git a/docs/victorialogs/data-ingestion/Vector.md b/docs/victorialogs/data-ingestion/Vector.md
index 36529dfa0d..29d3fcb32d 100644
--- a/docs/victorialogs/data-ingestion/Vector.md
+++ b/docs/victorialogs/data-ingestion/Vector.md
@@ -1,6 +1,6 @@
 ---
 weight: 20
-title: Vector setup
+title: Vector Setup
 disableToc: true
 menu:
   docs:
@@ -15,8 +15,8 @@ aliases:
 
 VictoriaLogs can accept logs from [Vector](https://vector.dev/) via the following protocols:
 
-- Elasticsearch - see [these docs](#elasticsearch)
-- HTTP JSON - see [these docs](#http)
+- Elasticsearch - see [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/vector/#elasticsearch)
+- HTTP JSON - see [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/vector/#http)
 
 ## Elasticsearch
 
diff --git a/docs/victorialogs/data-ingestion/_index.md b/docs/victorialogs/data-ingestion/_index.md
index 2ba77e5fe4..e92019fd14 100644
--- a/docs/victorialogs/data-ingestion/_index.md
+++ b/docs/victorialogs/data-ingestion/_index.md
@@ -1,11 +1,11 @@
 ---
-title: Data ingestion
-weight: 3
+title: Data Ingestion
+weight: 5
 menu:
   docs:
     identifier: victorialogs-data-ingestion
     parent: "victorialogs"
-    weight: 3
+    weight: 5
 tags:
   - logs
 aliases:
diff --git a/docs/victorialogs/data-ingestion/opentelemetry.md b/docs/victorialogs/data-ingestion/opentelemetry.md
index 0614a986e2..96ad930c38 100644
--- a/docs/victorialogs/data-ingestion/opentelemetry.md
+++ b/docs/victorialogs/data-ingestion/opentelemetry.md
@@ -1,6 +1,6 @@
 ---
 weight: 4
-title: OpenTelemetry setup
+title: OpenTelemetry Setup
 disableToc: true
 menu:
   docs:
@@ -46,8 +46,8 @@ The ingested log entries can be queried according to [these docs](https://docs.v
 
 VictoriaLogs supports receiving logs from the following OpenTelemetry collectors:
 
-* [Elasticsearch](#elasticsearch)
-* [OpenTelemetry](#opentelemetry)
+* [Elasticsearch](https://docs.victoriametrics.com/victorialogs/data-ingestion/opentelemetry/#elasticsearch)
+* [OpenTelemetry](https://docs.victoriametrics.com/victorialogs/data-ingestion/opentelemetry/#opentelemetry)
 
 ### Elasticsearch
 
diff --git a/docs/victorialogs/data-ingestion/syslog.md b/docs/victorialogs/data-ingestion/syslog.md
index e52c9bb2c5..6396802b3a 100644
--- a/docs/victorialogs/data-ingestion/syslog.md
+++ b/docs/victorialogs/data-ingestion/syslog.md
@@ -1,6 +1,6 @@
 ---
 weight: 10
-title: Syslog setup
+title: Syslog Setup
 disableToc: true
 menu:
   docs:
@@ -11,8 +11,12 @@ tags:
 aliases:
    - /victorialogs/data-ingestion/syslog.html
 ---
-[VictoriaLogs](https://docs.victoriametrics.com/victorialogs/) can accept logs in [Syslog formats](https://en.wikipedia.org/wiki/Syslog) at the specified TCP and UDP addresses
-via `-syslog.listenAddr.tcp` and `-syslog.listenAddr.udp` command-line flags. The following syslog formats are supported:
+
+[VictoriaLogs](https://docs.victoriametrics.com/victorialogs/) can accept logs in [Syslog formats](https://en.wikipedia.org/wiki/Syslog) at the specified TCP, UDP or Unix socket addresses
+via `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` command-line flags. VictoriaLogs listens for `SOCK_STREAM` unix sockets by default.
+Prepend the unix socket path passed to `-syslog.listenAddr.unix` with `unixgram:` for `SOCK_DGRAM` sockets.
+
+The following syslog formats are supported:
 
 - [RFC3164](https://datatracker.ietf.org/doc/html/rfc3164) aka `<PRI>MMM DD hh:mm:ss HOSTNAME APP-NAME[PROCID]: MESSAGE`
 - [RFC5424](https://datatracker.ietf.org/doc/html/rfc5424) aka `<PRI>1 TIMESTAMP HOSTNAME APP-NAME PROCID MSGID [STRUCTURED-DATA] MESSAGE`
@@ -34,8 +38,8 @@ The following command starts VictoriaLogs, which accepts logs in Syslog format a
 
 VictoriaLogs can accept logs from the following syslog collectors:
 
-- [Rsyslog](https://www.rsyslog.com/). See [these docs](#rsyslog).
-- [Syslog-ng](https://www.syslog-ng.com/). See [these docs](#syslog-ng).
+- [Rsyslog](https://www.rsyslog.com/). See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#rsyslog).
+- [Syslog-ng](https://www.syslog-ng.com/). See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#syslog-ng).
 
 Multiple logs in Syslog format can be ingested via a single TCP connection or via a single UDP packet - just put every log on a separate line
 and delimit them with `\n` char.
@@ -43,10 +47,10 @@ and delimit them with `\n` char.
 VictoriaLogs automatically extracts the following [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 from the received Syslog lines:
 
-- [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) - log timestamp. See also [log timestamps](#log-timestamps)
+- [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) - log timestamp. See also [log timestamps](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps)
 - [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) - the `MESSAGE` field from the supported syslog formats above
 - `hostname`, `app_name` and `proc_id` - for unique identification of [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
-  It is possible to change the list of fields for log streams - see [these docs](#stream-fields).
+  It is possible to change the list of fields for log streams - see [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields).
 - `level` - string representation of the log level according to the `<PRI>` field value
 - `priority`, `facility` and `severity` - these fields are extracted from `<PRI>` field
 - `facility_keyword` - string representation of the `facility` field according to [these docs](https://en.wikipedia.org/wiki/Syslog#Facility)
@@ -73,15 +77,15 @@ curl http://localhost:9428/select/logsql/query -d 'query=_time:5m'
 
 See also:
 
-- [Log timestamps](#log-timestamps)
-- [Security](#security)
-- [Compression](#compression)
-- [Multitenancy](#multitenancy)
-- [Stream fields](#stream-fields)
-- [Dropping fields](#dropping-fields)
-- [Decolorizing fields](#decolorizing-fields)
-- [Adding extra fields](#adding-extra-fields)
-- [Capturing remote ip address](#capturing-remote-ip-address)
+- [Log timestamps](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps)
+- [Security](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security)
+- [Compression](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression)
+- [Multitenancy](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy)
+- [Stream fields](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields)
+- [Dropping fields](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields)
+- [Decolorizing fields](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#decolorizing-fields)
+- [Adding extra fields](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields)
+- [Capturing remote ip address](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address)
 - [Data ingestion troubleshooting](https://docs.victoriametrics.com/victorialogs/data-ingestion/#troubleshooting).
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/).
 
@@ -105,6 +109,13 @@ via the corresponding `-syslog.listenAddr.udp` address:
 ./victoria-logs -syslog.listenAddr.udp=:514 -syslog.useLocalTimestamp.udp
 ```
 
+The `-syslog.useLocalTimestamp.unix` command-line flag can be used for instructing VictoriaLogs to use local timestamps for the ingested logs
+via the corresponding `-syslog.listenAddr.unix` address:
+
+```sh
+./victoria-logs -syslog.listenAddr.unix=/dev/log -syslog.useLocalTimestamp.unix
+```
+
 ## Security
 
 By default VictoriaLogs accepts plaintext data at `-syslog.listenAddr.tcp` address. Run VictoriaLogs with `-syslog.tls` command-line flag
@@ -116,7 +127,7 @@ starts VictoriaLogs, which accepts TLS-encrypted syslog messages at TCP port 651
 ./victoria-logs -syslog.listenAddr.tcp=:6514 -syslog.tls -syslog.tlsCertFile=/path/to/tls/cert -syslog.tlsKeyFile=/path/to/tls/key
 ```
 
-See also [mTLS docs](#mtls).
+See also [mTLS docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#mtls).
 
 ### mTLS
 
@@ -133,8 +144,8 @@ from [the releases page](https://github.com/VictoriaMetrics/VictoriaLogs/release
 
 ## Compression
 
-By default VictoriaLogs accepts uncompressed log messages in Syslog format at `-syslog.listenAddr.tcp` and `-syslog.listenAddr.udp` addresses.
-It is possible configuring VictoriaLogs to accept compressed log messages via `-syslog.compressMethod.tcp` and `-syslog.compressMethod.udp` command-line flags.
+By default VictoriaLogs accepts uncompressed log messages in Syslog format at `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` addresses.
+It is possible configuring VictoriaLogs to accept compressed log messages via `-syslog.compressMethod.tcp`, `-syslog.compressMethod.udp` and `-syslog.compressMethod.unix` command-line flags.
 The following compression methods are supported:
 
 - `none` - no compression
@@ -151,8 +162,8 @@ For example, the following command starts VictoriaLogs, which accepts gzip-compr
 ## Multitenancy
 
 By default, the ingested logs are stored in the `(AccountID=0, ProjectID=0)` [tenant](https://docs.victoriametrics.com/victorialogs/#multitenancy).
-If you need storing logs in other tenant, then specify the needed tenant via `-syslog.tenantID.tcp` or `-syslog.tenantID.udp` command-line flags
-depending on whether TCP or UDP ports are listened for syslog messages.
+If you need storing logs in other tenant, then specify the needed tenant via `-syslog.tenantID.tcp`, `-syslog.tenantID.udp` or `-syslog.tenantID.unix` command-line flags
+depending on whether TCP, UDP or Unix sockets listened for syslog messages.
 For example, the following command starts VictoriaLogs, which writes syslog messages received at TCP port 514, to `(AccountID=12, ProjectID=34)` tenant:
 
 ```sh
@@ -162,8 +173,8 @@ For example, the following command starts VictoriaLogs, which writes syslog mess
 ## Stream fields
 
 VictoriaLogs uses `(hostname, app_name, proc_id)` fields as labels for [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) by default.
-It is possible setting other set of labels via `-syslog.streamFields.tcp` and `-syslog.streamFields.udp` command-line flags
-for logs instead via the corresponding `-syslog.listenAddr.tcp` and `-syslog.listenAddr.dup` addresses.
+It is possible setting other set of labels via `-syslog.streamFields.tcp`, `-syslog.streamFields.udp` and `-syslog.streamFields.unix` command-line flags
+for logs instead via the corresponding `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` addresses.
 For example, the following command starts VictoriaLogs, which uses `(hostname, app_name)` fields as log stream labels
 for logs received at TCP port 514:
 
@@ -173,9 +184,9 @@ for logs received at TCP port 514:
 
 ## Dropping fields
 
-VictoriaLogs supports `-syslog.ignoreFields.tcp` and `-syslog.ignoreFields.udp` command-line flags for skipping
+VictoriaLogs supports `-syslog.ignoreFields.tcp`, `-syslog.ignoreFields.udp` and `-syslog.ignoreFields.unix` command-line flags for skipping
 the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) during ingestion
-of Syslog logs into `-syslog.listenAddr.tcp` and `-syslog.listenAddr.udp` addresses.
+of Syslog logs into `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` addresses.
 For example, the following command starts VictoriaLogs, which drops `proc_id` and `msg_id` fields from logs received at TCP port 514:
 
 ```sh
@@ -187,9 +198,9 @@ are ignored during data ingestion.
 
 ## Decolorizing fields
 
-VictoriaLogs supports `-syslog.decolorizeFields.tcp` and `-syslog.decolorizeFields.udp` command-line flags,
+VictoriaLogs supports `-syslog.decolorizeFields.tcp`, `-syslog.decolorizeFields.udp` and `-syslog.decolorizeFields.unix` command-line flags,
 which can be used for removing ANSI color codes from the provided list fields during ingestion of Syslog logs
-into `-syslog.listenAddr.tcp` and `-syslog.listenAddr.upd` addresses.
+into `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` addresses.
 For example, the following command starts VictoriaLogs, which removes ANSI color codes from [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
 at logs received via TCP port 514:
 
@@ -199,9 +210,9 @@ at logs received via TCP port 514:
 
 ## Adding extra fields
 
-VictoriaLogs supports -`syslog.extraFields.tcp` and `-syslog.extraFields.udp` command-line flags for adding
+VictoriaLogs supports -`syslog.extraFields.tcp`, `-syslog.extraFields.udp` and `-syslog.extraFields.unix` command-line flags for adding
 the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) during data ingestion
-of Syslog logs into `-syslog.listenAddr.tcp` and `-syslog.listenAddr.udp` addresses.
+of Syslog logs into `-syslog.listenAddr.tcp`, `-syslog.listenAddr.udp` and `-syslog.listenAddr.unix` addresses.
 For example, the following command starts VictoriaLogs, which adds `source=foo` and `abc=def` fields to logs received at TCP port 514:
 
 ```sh
@@ -223,8 +234,8 @@ For example, the following command starts VictoriaLogs, which captures remote IP
 
 ## Multiple configs
 
-VictoriaLogs can accept syslog messages via multiple TCP and UDP ports with individual configurations for [log timestamps](#log-timestamps), [compression](#compression), [security](#security)
-and [multitenancy](#multitenancy). Specify multiple command-line flags for this. For example, the following command starts VictoriaLogs,
+VictoriaLogs can accept syslog messages via multiple TCP and UDP ports with individual configurations for [log timestamps](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps), [compression](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression), [security](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#security)
+and [multitenancy](https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy). Specify multiple command-line flags for this. For example, the following command starts VictoriaLogs,
 which accepts gzip-compressed syslog messages via TCP port 514 at localhost interface and stores them to [tenant](https://docs.victoriametrics.com/victorialogs/#multitenancy) `123:0`,
 plus it accepts TLS-encrypted syslog messages via TCP port 6514 and stores them to [tenant](https://docs.victoriametrics.com/victorialogs/#multitenancy) `567:0`:
 
diff --git a/docs/victorialogs/keyConcepts.md b/docs/victorialogs/keyConcepts.md
index 63bc6af416..1443e9312a 100644
--- a/docs/victorialogs/keyConcepts.md
+++ b/docs/victorialogs/keyConcepts.md
@@ -1,12 +1,12 @@
 ---
 weight: 2
-title: Key concepts
+title: Key Concepts
 menu:
   docs:
     identifier: vl-key-concepts
     parent: victorialogs
     weight: 2
-    title: Key concepts
+    title: Key Concepts
 tags:
   - logs
 aliases:
@@ -16,7 +16,7 @@ aliases:
 ## Data model
 
 [VictoriaLogs](https://docs.victoriametrics.com/victorialogs/) works with both structured and unstructured logs.
-Every log entry must contain at least [log message field](#message-field). Arbitrary number of additional `key=value` fields can be added to the log entry.
+Every log entry must contain at least [log message field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field). Arbitrary number of additional `key=value` fields can be added to the log entry.
 A single log entry can be expressed as a single-level [JSON](https://www.json.org/json-en.html) object with string keys and string values.
 For example:
 
@@ -32,7 +32,7 @@ For example:
 ```
 
 Empty values are treated the same as non-existing values. For example, the following log entries are equivalent,
-since they have only one identical non-empty field - [`_msg`](#message-field):
+since they have only one identical non-empty field - [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```json
 {
@@ -113,15 +113,15 @@ Unicode chars must be encoded with [UTF-8](https://en.wikipedia.org/wiki/UTF-8)
 VictoriaLogs automatically indexes all the fields in all the [ingested](https://docs.victoriametrics.com/victorialogs/data-ingestion/) logs.
 This enables [full-text search](https://docs.victoriametrics.com/victorialogs/logsql/) across all the fields.
 
-VictoriaLogs supports the following special fields additionally to arbitrary [other fields](#other-fields):
+VictoriaLogs supports the following special fields additionally to arbitrary [other fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#other-fields):
 
-- [`_msg` field](#message-field)
-- [`_time` field](#time-field)
-- [`_stream` and `_stream_id` fields](#stream-fields)
+- [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
+- [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field)
+- [`_stream` and `_stream_id` fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 
 ### Message field
 
-Every ingested [log entry](#data-model) must contain at least a `_msg` field with the actual log message. For example, this is the minimal
+Every ingested [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must contain at least a `_msg` field with the actual log message. For example, this is the minimal
 log entry for VictoriaLogs:
 
 ```json
@@ -140,7 +140,7 @@ via `-defaultMsgValue` command-line flag.
 
 ### Time field
 
-The ingested [log entries](#data-model) may contain `_time` field with the timestamp of the ingested log entry.
+The ingested [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) may contain `_time` field with the timestamp of the ingested log entry.
 This field must be in one of the following formats:
 
 - [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) or [RFC3339](https://www.rfc-editor.org/rfc/rfc3339).
@@ -151,7 +151,7 @@ This field must be in one of the following formats:
 - Unix timestamp in seconds, milliseconds, microseconds or nanoseconds. For example, `1686026893` (seconds), `1686026893735` (milliseconds),
   `1686026893735321` (microseconds) or `1686026893735321098` (nanoseconds).
 
-For example, the following [log entry](#data-model) contains valid timestamp with millisecond precision in the `_time` field:
+For example, the following [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) contains valid timestamp with millisecond precision in the `_time` field:
 
 ```json
 {
@@ -172,7 +172,7 @@ the search to the selected time range.
 
 ### Stream fields
 
-Some [structured logging](#data-model) fields may uniquely identify the application instance, which generates logs.
+Some [structured logging](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) fields may uniquely identify the application instance, which generates logs.
 This may be either a single field such as `instance="host123:456"` or a set of fields such as
 `{datacenter="...", env="...", job="...", instance="..."}` or
 `{kubernetes.namespace="...", kubernetes.node.name="...", kubernetes.pod.name="...", kubernetes.container.name="..."}`.
@@ -224,7 +224,7 @@ per-container logs into distinct streams.
 
 #### How to determine which fields must be associated with log streams?
 
-[Log streams](#stream-fields) must contain [fields](#data-model), which uniquely identify the application instance, which generates logs.
+[Log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) must contain [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model), which uniquely identify the application instance, which generates logs.
 For example, `container`, `instance` and `host` are good candidates for stream fields.
 
 Additional fields may be added to log streams if they **remain constant during application instance lifetime**.
@@ -234,15 +234,15 @@ makes sense if you are going to use these fields during search and want speeding
 There is **no need to add all the constant fields to log streams**, since this may increase resource usage during data ingestion and querying.
 
 **Never add non-constant fields to streams if these fields may change with every log entry of the same stream**.
-For example, `ip`, `user_id` and `trace_id` **must never be associated with log streams**, since this may lead to [high cardinality issues](#high-cardinality).
+For example, `ip`, `user_id` and `trace_id` **must never be associated with log streams**, since this may lead to [high cardinality issues](https://docs.victoriametrics.com/victorialogs/keyconcepts/#high-cardinality).
 
 #### High cardinality
 
-Some fields in the [ingested logs](#data-model) may contain big number of unique values across log entries.
+Some fields in the [ingested logs](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) may contain big number of unique values across log entries.
 For example, fields with names such as `ip`, `user_id` or `trace_id` tend to contain big number of unique values.
-VictoriaLogs works perfectly with such fields unless they are associated with [log streams](#stream-fields).
+VictoriaLogs works perfectly with such fields unless they are associated with [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
 
-**Never** associate high-cardinality fields with [log streams](#stream-fields), since this may lead to the following issues:
+**Never** associate high-cardinality fields with [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields), since this may lead to the following issues:
 
 - Performance degradation during [data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/)
   and [querying](https://docs.victoriametrics.com/victorialogs/querying/)
@@ -255,13 +255,13 @@ VictoriaLogs exposes `vl_streams_created_total` [metric](https://docs.victoriame
 which shows the number of created streams since the last VictoriaLogs restart. If this metric grows at a rapid rate
 during long period of time, then there are high chances of high cardinality issues mentioned above.
 VictoriaLogs can log all the newly registered streams when `-logNewStreams` command-line flag is passed to it.
-This can help narrowing down and eliminating high-cardinality fields from [log streams](#stream-fields).
+This can help narrowing down and eliminating high-cardinality fields from [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
 
 ### Other fields
 
-Every ingested log entry may contain arbitrary number of [fields](#data-model) additionally to [`_msg`](#message-field) and [`_time`](#time-field).
+Every ingested log entry may contain arbitrary number of [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) additionally to [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) and [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
 For example, `level`, `ip`, `user_id`, `trace_id`, etc. Such fields can be used for simplifying and optimizing [search queries](https://docs.victoriametrics.com/victorialogs/logsql/).
-It is usually faster to search over a dedicated `trace_id` field instead of searching for the `trace_id` inside long [log message](#message-field).
+It is usually faster to search over a dedicated `trace_id` field instead of searching for the `trace_id` inside long [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 E.g. the `trace_id:="XXXX-YYYY-ZZZZ"` query usually works faster than the `_msg:"trace_id=XXXX-YYYY-ZZZZ"` query.
 
 See [LogsQL docs](https://docs.victoriametrics.com/victorialogs/logsql/) for more details.
diff --git a/docs/victorialogs/logql-to-logsql.md b/docs/victorialogs/logql-to-logsql.md
index 4af48c2024..47ef33073c 100644
--- a/docs/victorialogs/logql-to-logsql.md
+++ b/docs/victorialogs/logql-to-logsql.md
@@ -1,10 +1,10 @@
 ---
-weight: 130
-title: How to convert Loki queries to VictoriaLogs queries
+weight: 51
+title: How To Convert Loki Queries to VictoriaLogs Queries
 menu:
   docs:
     parent: "victorialogs"
-    weight: 120
+    weight: 51
 tags:
   - logs
   - guide
@@ -16,7 +16,7 @@ query language. Both languages are optimized for querying logs. The docs below s
 ## Data model
 
 Both Loki and VictoriaLogs support log streams - these are timestamp-ordered streams of logs, where every stream may have its own set of labels. These labels can be used
-in [log stream selectors](#log-stream-selector) for quickly narrowing down the amounts of logs for further processing by the query.
+in [log stream selectors](https://docs.victoriametrics.com/victorialogs/logql-to-logsql/#log-stream-selector) for quickly narrowing down the amounts of logs for further processing by the query.
 
 The main difference is that VictoriaLogs is optimized for structured logs with big number of labels (aka [wide events](https://jeremymorrell.dev/blog/a-practitioners-guide-to-wide-events/)).
 Hundreds of labels per every log entry is OK for VictoriaLogs.
@@ -160,7 +160,7 @@ Such a query can be replaced with `{...} | unpack_logmt` at VictoriaLogs. See [t
 
 It is recommended parsing logfmt-formatted structured logs before ingesting them into VictoriaLogs, so log labels are stored separately. VictoriaLogs is optimized for storing logs
 with big number of labels (fields), and every such field may contain arbitrary big number of unique values (e.g. VictoriaLogs works great with high-cardinality labels).
-See [JSON parser](#json-parser) docs for more details.
+See [JSON parser](https://docs.victoriametrics.com/victorialogs/logql-to-logsql/#json-parser) docs for more details.
 
 ## Pattern parser
 
@@ -177,14 +177,14 @@ Such a query can be replaced with `{...} | extract_regexp "..."` at VictoriaLogs
 Loki provides the ability to format log lines with the `{...} | line_format "..."` syntax according to [these docs](https://grafana.com/docs/loki/latest/query/log_queries/#line-format-expression).
 Such a query can be replaced with `{...} | format "..."` at VictoriaLogs. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe).
 
-Note that VictoriaLogs uses `<label>` format syntax identical to [pattern parser](#pattern-parser) syntax instead of `{{.label}}` format syntax from Loki.
+Note that VictoriaLogs uses `<label>` format syntax identical to [pattern parser](https://docs.victoriametrics.com/victorialogs/logql-to-logsql/#pattern-parser) syntax instead of `{{.label}}` format syntax from Loki.
 
 ## Label formatting
 
 Loki provides the ability to format log labels with the `{...} | label_format label_name="..."` syntax according to [these docs](https://grafana.com/docs/loki/latest/query/log_queries/#labels-format-expression).
 Such a query can be replaced with `{...} | format  "..." as label_name` at VictoriaLogs. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe).
 
-Note that VictoriaLogs uses `<label>` format syntax identical to [pattern parser](#pattern-parser) syntax instead of `{{.label}}` format syntax from Loki.
+Note that VictoriaLogs uses `<label>` format syntax identical to [pattern parser](https://docs.victoriametrics.com/victorialogs/logql-to-logsql/#pattern-parser) syntax instead of `{{.label}}` format syntax from Loki.
 
 ## Dropping labels
 
diff --git a/docs/victorialogs/logsql-examples.md b/docs/victorialogs/logsql-examples.md
index a4afca2cec..5c33250823 100644
--- a/docs/victorialogs/logsql-examples.md
+++ b/docs/victorialogs/logsql-examples.md
@@ -1,10 +1,10 @@
 ---
-weight: 100
-title: LogsQL examples
+weight: 50
+title: LogsQL Examples
 menu:
   docs:
     parent: "victorialogs"
-    weight: 100
+    weight: 50
 tags:
   - logs
   - guide
@@ -36,8 +36,8 @@ _time:5m | first 10 by (_time desc)
 
 See also:
 
-- [How to count the number of matching logs?](#how-to-count-the-number-of-matching-logs)
-- [How to return last N logs for the given query?](#how-to-return-last-n-logs-for-the-given-query)
+- [How to count the number of matching logs?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-count-the-number-of-matching-logs)
+- [How to return last N logs for the given query?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-return-last-n-logs-for-the-given-query)
 
 ## How to select logs with the given word in log message?
 
@@ -75,9 +75,9 @@ error _time:1h | sort by (_time)
 
 See also:
 
-- [How to select logs with all the given words in log message?](#how-to-select-logs-with-all-the-given-words-in-log-message)
-- [How to select logs with some of the given words in log message?](#how-to-select-logs-with-some-of-the-given-words-in-log-message)
-- [How to skip logs with the given word in log message?](#how-to-skip-logs-with-the-given-word-in-log-message)
+- [How to select logs with all the given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-all-the-given-words-in-log-message)
+- [How to select logs with some of the given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-some-of-the-given-words-in-log-message)
+- [How to skip logs with the given word in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-skip-logs-with-the-given-word-in-log-message)
 - [Filtering by phrase](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
 - [Filtering by prefix](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
 - [Filtering by regular expression](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter)
@@ -117,8 +117,8 @@ sorts the selected logs by [`_time` field](https://docs.victoriametrics.com/vict
 
 See also:
 
-- [How to select logs with all the given words in log message?](#how-to-select-logs-with-all-the-given-words-in-log-message)
-- [How to select logs with some of given words in log message?](#how-to-select-logs-with-some-of-the-given-words-in-log-message)
+- [How to select logs with all the given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-all-the-given-words-in-log-message)
+- [How to select logs with some of given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-some-of-the-given-words-in-log-message)
 - [Filtering by phrase](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
 - [Filtering by prefix](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
 - [Filtering by regular expression](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter)
@@ -161,8 +161,8 @@ error kubernetes _time:1h | sort by (_time)
 
 See also:
 
-- [How to select logs with some of given words in log message?](#how-to-select-logs-with-some-of-the-given-words-in-log-message)
-- [How to skip logs with the given word in log message?](#how-to-skip-logs-with-the-given-word-in-log-message)
+- [How to select logs with some of given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-some-of-the-given-words-in-log-message)
+- [How to skip logs with the given word in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-skip-logs-with-the-given-word-in-log-message)
 - [Filtering by phrase](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
 - [Filtering by prefix](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
 - [Filtering by regular expression](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter)
@@ -205,8 +205,8 @@ sorts the selected logs by [`_time` field](https://docs.victoriametrics.com/vict
 
 See also:
 
-- [How to select logs with all the given words in log message?](#how-to-select-logs-with-all-the-given-words-in-log-message)
-- [How to skip logs with the given word in log message?](#how-to-skip-logs-with-the-given-word-in-log-message)
+- [How to select logs with all the given words in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-with-all-the-given-words-in-log-message)
+- [How to skip logs with the given word in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-skip-logs-with-the-given-word-in-log-message)
 - [Filtering by phrase](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
 - [Filtering by prefix](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
 - [Filtering by regular expression](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter)
@@ -249,8 +249,8 @@ by [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-fie
 
 See also:
 
-- [How to determine applications with the most logs?](#how-to-determine-applications-with-the-most-logs)
-- [How to skip logs with the given word in log message?](#how-to-skip-logs-with-the-given-word-in-log-message)
+- [How to determine applications with the most logs?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-determine-applications-with-the-most-logs)
+- [How to skip logs with the given word in log message?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-skip-logs-with-the-given-word-in-log-message)
 
 ## How to count the number of matching logs?
 
@@ -289,9 +289,9 @@ _time:5m | top 10 by (_stream)
 
 See also:
 
-- [How to filter out data after stats calculation?](#how-to-filter-out-data-after-stats-calculation)
-- [How to calculate the number of logs per the given interval?](#how-to-calculate-the-number-of-logs-per-the-given-interval)
-- [How to select logs from the given application instance?](#how-to-select-logs-from-the-given-application-instance)
+- [How to filter out data after stats calculation?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-filter-out-data-after-stats-calculation)
+- [How to calculate the number of logs per the given interval?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-calculate-the-number-of-logs-per-the-given-interval)
+- [How to select logs from the given application instance?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-logs-from-the-given-application-instance)
 
 ## How to parse JSON inside log message?
 
@@ -422,8 +422,8 @@ curl http://localhost:9428/select/logsql/query -d 'query=error' -d 'limit=10'
 
 See also:
 
-- [How to select recently ingested logs?](#how-to-select-recently-ingested-logs)
-- [How to return last N logs for the given query?](#how-to-return-last-n-logs-for-the-given-query)
+- [How to select recently ingested logs?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-select-recently-ingested-logs)
+- [How to return last N logs for the given query?](https://docs.victoriametrics.com/victorialogs/logsql-examples/#how-to-return-last-n-logs-for-the-given-query)
 
 ## How to calculate the share of error logs to the total number of logs?
 
diff --git a/docs/victorialogs/LogsQL.md b/docs/victorialogs/logsql.md
similarity index 55%
rename from docs/victorialogs/LogsQL.md
rename to docs/victorialogs/logsql.md
index b76f2cf512..b274417512 100644
--- a/docs/victorialogs/LogsQL.md
+++ b/docs/victorialogs/logsql.md
@@ -1,29 +1,31 @@
 ---
-weight: 5
 title: LogsQL
+weight: 7
 menu:
   docs:
+    weight: 7
+    identifier: logsql
     parent: "victorialogs"
-    weight: 5
 tags:
   - logs
 aliases:
-- /VictoriaLogs/LogsQL.html
-- /victorialogs/LogsQL.html
-- /victorialogs/LogsQL/
+  - /VictoriaLogs/LogsQL.html
+  - /victorialogs/LogsQL.html
+  - /victorialogs/LogsQL/
 ---
+
 LogsQL is a simple yet powerful query language for [VictoriaLogs](https://docs.victoriametrics.com/victorialogs/).
-See [examples](https://docs.victoriametrics.com/victorialogs/logsql-examples/), [LogsQL tutorial](#logsql-tutorial),
+See [examples](https://docs.victoriametrics.com/victorialogs/logsql-examples/), [LogsQL tutorial](https://docs.victoriametrics.com/victorialogs/logsql/#logsql-tutorial),
 [how to convert Loki queries to VictoriaLogs queries](https://docs.victoriametrics.com/victorialogs/logql-to-logsql/)
 and [SQL to LogsQL conversion guide](https://docs.victoriametrics.com/victorialogs/sql-to-logsql/).
 
 LogsQL provides the following features:
 
 - Full-text search across [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-  See [word filter](#word-filter), [phrase filter](#phrase-filter) and [prefix filter](#prefix-filter).
-- Ability to combine filters into arbitrary complex [logical filters](#logical-filter).
-- Ability to extract structured fields from unstructured logs at query time. See [these docs](#transformations).
-- Ability to calculate various stats over the selected log entries. See [these docs](#stats-pipe).
+  See [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter), [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) and [prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter).
+- Ability to combine filters into arbitrary complex [logical filters](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
+- Ability to extract structured fields from unstructured logs at query time. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#transformations).
+- Ability to calculate various stats over the selected log entries. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe).
 
 ## LogsQL tutorial
 
@@ -35,7 +37,7 @@ Then follow these docs:
 - [how to ingest data into VictoriaLogs](https://docs.victoriametrics.com/victorialogs/data-ingestion/).
 - [How to query VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/).
 
-The simplest LogsQL query is just a [word](#word), which must be found in the [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
+The simplest LogsQL query is just a [word](https://docs.victoriametrics.com/victorialogs/logsql/#word), which must be found in the [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 For example, the following query finds all the logs with `error` word:
 
 ```logsql
@@ -44,8 +46,8 @@ error
 
 It is recommended to use [vlogscli](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/) for querying VictoriaLogs.
 
-If the queried [word](#word) clashes with LogsQL keywords, then just wrap it into quotes according to [these docs](#string-literals).
-For example, the following query finds all the log messages with `and` [word](#word):
+If the queried [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) clashes with LogsQL keywords, then just wrap it into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
+For example, the following query finds all the log messages with `and` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word):
 
 ```logsql
 "and"
@@ -68,22 +70,22 @@ Queries above match logs with any [timestamp](https://docs.victoriametrics.com/v
 e.g. they may return logs from the previous year alongside recently ingested logs.
 
 Usually logs from the previous year aren't so interesting comparing to the recently ingested logs.
-So it is recommended adding [time filter](#time-filter) to the query.
-For example, the following query returns logs with the `error` [word](#word),
+So it is recommended adding [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) to the query.
+For example, the following query returns logs with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word),
 which were ingested into VictoriaLogs during the last 5 minutes:
 
 ```logsql
 error AND _time:5m
 ```
 
-This query consists of two [filters](#filters) joined with `AND` [operator](#logical-filter):
+This query consists of two [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) joined with `AND` [operator](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter):
 
-- The filter on the `error` [word](#word).
+- The filter on the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word).
 - The filter on the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
 
 The `AND` operator means that the [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must match both filters in order to be selected.
 
-Typical LogsQL query consists of multiple [filters](#filters) joined with `AND` operator. It may be tiresome typing and then reading all these `AND` words.
+Typical LogsQL query consists of multiple [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) joined with `AND` operator. It may be tiresome typing and then reading all these `AND` words.
 So LogsQL allows omitting `AND` words. For example, the following query is equivalent to the query above:
 
 ```logsql
@@ -91,7 +93,7 @@ _time:5m error
 ```
 
 The query returns logs in arbitrary order because sorting of big amounts of logs may require non-trivial amounts of CPU and RAM.
-The number of logs with `error` word over the last 5 minutes isn't usually too big (e.g. less than a few millions), so it is OK to sort them with [`sort` pipe](#sort-pipe).
+The number of logs with `error` word over the last 5 minutes isn't usually too big (e.g. less than a few millions), so it is OK to sort them with [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe).
 The following query sorts the selected logs by [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) field:
 
 ```logsql
@@ -99,14 +101,14 @@ _time:5m error | sort by (_time)
 ```
 
 It is unlikely you are going to investigate more than a few hundreds of logs returned by the query above. So you can limit the number of returned logs
-with [`limit` pipe](#limit-pipe). The following query returns the last 10 logs with the `error` word over the last 5 minutes:
+with [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe). The following query returns the last 10 logs with the `error` word over the last 5 minutes:
 
 ```logsql
 _time:5m error | sort by (_time) desc | limit 10
 ```
 
 By default VictoriaLogs returns all the [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-If you need only the given set of fields, then add [`fields` pipe](#fields-pipe) to the end of the query. For example, the following query returns only
+If you need only the given set of fields, then add [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) to the end of the query. For example, the following query returns only
 [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field), [`_stream`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 and [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) fields:
 
@@ -114,14 +116,14 @@ and [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-
 error _time:5m | fields _time, _stream, _msg
 ```
 
-Suppose the query above selects too many rows because some buggy app pushes invalid error logs to VictoriaLogs. Suppose the app adds `buggy_app` [word](#word) to every log line.
+Suppose the query above selects too many rows because some buggy app pushes invalid error logs to VictoriaLogs. Suppose the app adds `buggy_app` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) to every log line.
 Then the following query removes all the logs from the buggy app, allowing us paying attention to the real errors:
 
 ```logsql
 _time:5m error NOT buggy_app
 ```
 
-This query uses `NOT` [operator](#logical-filter) for removing log lines from the buggy app. The `NOT` operator is used frequently, so it can be substituted with `-` or `!` char
+This query uses `NOT` [operator](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for removing log lines from the buggy app. The `NOT` operator is used frequently, so it can be substituted with `-` or `!` char
 (the `!` must be used instead of `-` in front of [`=`](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
 and [`~`](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) filters like `!=` and `!~`).
 The following query is equivalent to the previous one:
@@ -130,26 +132,26 @@ The following query is equivalent to the previous one:
 _time:5m error -buggy_app
 ```
 
-Suppose another buggy app starts pushing invalid error logs to VictoriaLogs - it adds `foobar` [word](#word) to every emitted log line.
+Suppose another buggy app starts pushing invalid error logs to VictoriaLogs - it adds `foobar` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) to every emitted log line.
 No problems - just add `-foobar` to the query in order to remove these buggy logs:
 
 ```logsql
 _time:5m error -buggy_app -foobar
 ```
 
-This query can be rewritten to more clear query with the `OR` [operator](#logical-filter) inside parentheses:
+This query can be rewritten to more clear query with the `OR` [operator](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) inside parentheses:
 
 ```logsql
 _time:5m error -(buggy_app OR foobar)
 ```
 
 The parentheses are **required** here, since otherwise the query won't return the expected results.
-The query `error -buggy_app OR foobar` is interpreted as `(error AND NOT buggy_app) OR foobar` according to [priorities for AND, OR and NOT operator](#logical-filter).
-This query returns logs with `foobar` [word](#word), even if they do not contain `error` word or contain `buggy_app` word.
+The query `error -buggy_app OR foobar` is interpreted as `(error AND NOT buggy_app) OR foobar` according to [priorities for AND, OR and NOT operator](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
+This query returns logs with `foobar` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word), even if they do not contain `error` word or contain `buggy_app` word.
 So it is recommended wrapping the needed query parts into explicit parentheses if you are unsure in priority rules.
 As an additional bonus, explicit parentheses make queries easier to read and maintain.
 
-Queries above assume that the `error` [word](#word) is stored in the [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
+Queries above assume that the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) is stored in the [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 If this word is stored in other [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) such as `log.level`, then add `log.level:` prefix
 in front of the `error` word:
 
@@ -158,7 +160,7 @@ _time:5m log.level:error -(buggy_app OR foobar)
 ```
 
 The field name can be wrapped into quotes if it contains special chars or keywords, which may clash with LogsQL syntax.
-Any [word](#word) also can be wrapped into quotes according to [these docs](#string-literals). So the following query is equivalent to the previous one:
+Any [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) also can be wrapped into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals). So the following query is equivalent to the previous one:
 
 ```logsql
 "_time":"5m" "log.level":"error" -("buggy_app" OR "foobar")
@@ -179,7 +181,7 @@ _time:5m log.level:error -app:(buggy_app OR foobar)
 The `app` field uniquely identifies the application instance if a single instance runs per each unique `app`.
 In this case it is recommended associating the `app` field with [log stream fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 during [data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/). This usually improves both compression rate
-and query performance when querying the needed streams via [`_stream` filter](#stream-filter).
+and query performance when querying the needed streams via [`_stream` filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter).
 If the `app` field is associated with the log stream, then the query above can be rewritten to more performant one:
 
 ```logsql
@@ -190,16 +192,16 @@ This query skips scanning for [log messages](https://docs.victoriametrics.com/vi
 It inspects only `log.level` and [`_stream`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) labels.
 This significantly reduces disk read IO and CPU time needed for performing the query.
 
-LogsQL also provides [functions for statistics calculation](#stats-pipe) over the selected logs. For example, the following query returns the number of logs
+LogsQL also provides [functions for statistics calculation](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) over the selected logs. For example, the following query returns the number of logs
 with the `error` word for the last 5 minutes:
 
 ```logsql
 _time:5m error | stats count() logs_with_error
 ```
 
-Finally, it is recommended reading [performance tips](#performance-tips).
+Finally, it is recommended reading [performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
-Now you are familiar with LogsQL basics. See [LogsQL examples](https://docs.victoriametrics.com/victorialogs/logsql-examples/) and [query syntax](#query-syntax)
+Now you are familiar with LogsQL basics. See [LogsQL examples](https://docs.victoriametrics.com/victorialogs/logsql-examples/) and [query syntax](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax)
 if you want to continue learning LogsQL.
 
 ### Key concepts
@@ -210,12 +212,12 @@ LogsQL splits all the [log fields](https://docs.victoriametrics.com/victorialogs
 delimited by non-word chars such as whitespace, parens, punctuation chars, etc. For example, the `foo: (bar,"тест")!` string
 is split into `foo`, `bar` and `тест` words. Words can contain arbitrary [utf-8](https://en.wikipedia.org/wiki/UTF-8) chars.
 These words are taken into account by full-text search filters such as
-[word filter](#word-filter), [phrase filter](#phrase-filter) and [prefix filter](#prefix-filter).
+[word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter), [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) and [prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter).
 
 #### Query syntax
 
-LogsQL query must contain at least a single [filter](#filters) for selecting the matching logs.
-For example, the following query selects all the logs for the last 5 minutes by using [`_time` filter](#time-filter):
+LogsQL query must contain at least a single [filter](https://docs.victoriametrics.com/victorialogs/logsql/#filters) for selecting the matching logs.
+For example, the following query selects all the logs for the last 5 minutes by using [`_time` filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter):
 
 ```logsql
 _time:5m
@@ -225,28 +227,28 @@ Tip: try [`*` filter](https://docs.victoriametrics.com/victorialogs/logsql/#any-
 Do not worry - this doesn't crash VictoriaLogs, even if the query selects trillions of logs. See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line)
 if you are curious why.
 
-Additionally to filters, LogQL query may contain arbitrary mix of optional actions for processing the selected logs. These actions are delimited by `|` and are known as [`pipes`](#pipes).
-For example, the following query uses [`stats` pipe](#stats-pipe) for returning the number of [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
-with the `error` [word](#word) for the last 5 minutes:
+Additionally to filters, LogQL query may contain arbitrary mix of optional actions for processing the selected logs. These actions are delimited by `|` and are known as [`pipes`](https://docs.victoriametrics.com/victorialogs/logsql/#pipes).
+For example, the following query uses [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) for returning the number of [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
+with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) for the last 5 minutes:
 
 ```logsql
 _time:5m error | stats count() errors
 ```
 
-See [the list of supported pipes in LogsQL](#pipes).
+See [the list of supported pipes in LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/#pipes).
 
 ## Filters
 
 LogsQL supports various filters for searching for log messages (see below).
-They can be combined into arbitrary complex queries via [logical filters](#logical-filter).
+They can be combined into arbitrary complex queries via [logical filters](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
 
 Filters are applied to [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) by default.
 If the filter must be applied to other [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
-then its' name followed by the colon must be put in front of the filter. For example, if `error` [word filter](#word-filter) must be applied
+then its' name followed by the colon must be put in front of the filter. For example, if `error` [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) must be applied
 to the `log.level` field, then use `log.level:error` query.
 
 Field names and filter args can be put into quotes if they contain special chars, which may clash with LogsQL syntax. LogsQL supports quoting via double quotes `"`,
-single quotes `'` and backticks according to [these docs](#string-literals):
+single quotes `'` and backticks according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals):
 
 ```logsql
 "some 'field':123":i('some("value")') AND `other"value'`
@@ -256,38 +258,40 @@ If doubt, it is recommended quoting field names and filter args.
 
 The list of LogsQL filters:
 
-- [Time filter](#time-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given time range
-- [Day range filter](#day-range-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given per-day time range
-- [Week range filter](#week-range-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given per-week day range
-- [Stream filter](#stream-filter) - matches logs, which belong to the given [streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
-- [Word filter](#word-filter) - matches logs with the given [word](#word)
-- [Phrase filter](#phrase-filter) - matches logs with the given phrase
-- [Prefix filter](#prefix-filter) - matches logs with the given word prefix or phrase prefix
-- [Substring filter](#substring-filter) - matches logs with the given substring
-- [Pattern match filter](#pattern-match-filter) - matches logs by the given pattern
-- [Range comparison filter](#range-comparison-filter) - matches logs with field values in the provided range
-- [Empty value filter](#empty-value-filter) - matches logs without the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [Any value filter](#any-value-filter) - matches logs with the given non-empty [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [Exact filter](#exact-filter) - matches logs with the exact value for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [Exact prefix filter](#exact-prefix-filter) - matches logs starting with the given prefix for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [Multi-exact filter](#multi-exact-filter) - matches logs with one of the specified exact values for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [Subquery filter](#subquery-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values matching the results of another query
-- [`contains_all` filter](#contains_any-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) containing
-  all the provided [words](#word) / phrases
-- [`contains_any` filter](#contains_any-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) containing
-  at least one of the provided [words](#word) / phrases
-- [Case-insensitive filter](#case-insensitive-filter) - matches logs with the given case-insensitive word, phrase or prefix
-- [Sequence filter](#sequence-filter) - matches logs with the given sequence of words or phrases
-- [Regexp filter](#regexp-filter) - matches logs for the given regexp
-- [Range filter](#range-filter) - matches logs with numeric [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given range
-- [IPv4 range filter](#ipv4-range-filter) - matches logs with ip address [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given range
-- [String range filter](#string-range-filter) - matches logs with [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given string range
-- [Length range filter](#length-range-filter) - matches logs with [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of the given length range
-- [Value type filter](#value_type-filter) - matches logs with [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) stored under the given value type
-- [Fields' equality filter](#eq_field-filter) - matches logs, which contain identical values in the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-- [`Less than` filter](#lt_field-filter) - matches logs where the given field value is smaller than the other field value
-- [`Less than or equal` filter](#le_field-filter) - matches logs where the given field value doesn't exceed the other field value
-- [Logical filter](#logical-filter) - allows combining other filters
+- [Time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given time range
+- [Day range filter](https://docs.victoriametrics.com/victorialogs/logsql/#day-range-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given per-day time range
+- [Week range filter](https://docs.victoriametrics.com/victorialogs/logsql/#week-range-filter) - matches logs with [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) in the given per-week day range
+- [Stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter) - matches logs, which belong to the given [streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) - matches logs with the given [word](https://docs.victoriametrics.com/victorialogs/logsql/#word)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) - matches logs with the given phrase
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter) - matches logs with the given word prefix or phrase prefix
+- [Substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter) - matches logs with the given substring
+- [Pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter) - matches logs by the given pattern
+- [Range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter) - matches logs with field values in the provided range
+- [Empty value filter](https://docs.victoriametrics.com/victorialogs/logsql/#empty-value-filter) - matches logs without the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [Any value filter](https://docs.victoriametrics.com/victorialogs/logsql/#any-value-filter) - matches logs with the given non-empty [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter) - matches logs with the exact value for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [Exact prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-prefix-filter) - matches logs starting with the given prefix for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [Multi-exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter) - matches logs with one of the specified exact values for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [Subquery filter](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values matching the results of another query
+- [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) containing
+  all the provided [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) / phrases
+- [`contains_any` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter) - matches logs with [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) containing
+  at least one of the provided [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) / phrases
+- [Case-insensitive filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter) - matches logs with the given case-insensitive word, phrase or prefix
+- [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter) - matches logs with log fields containing the given words and phrases with cases according to the given pattern
+- [`equals_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#equals_common_case-filter) - matches logs with log fields equal to the given words and phrases with cases according to the given pattern
+- [Sequence filter](https://docs.victoriametrics.com/victorialogs/logsql/#sequence-filter) - matches logs with the given sequence of words or phrases
+- [Regexp filter](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) - matches logs for the given regexp
+- [Range filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-filter) - matches logs with numeric [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given range
+- [IPv4 range filter](https://docs.victoriametrics.com/victorialogs/logsql/#ipv4-range-filter) - matches logs with ip address [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given range
+- [String range filter](https://docs.victoriametrics.com/victorialogs/logsql/#string-range-filter) - matches logs with [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in the given string range
+- [Length range filter](https://docs.victoriametrics.com/victorialogs/logsql/#length-range-filter) - matches logs with [field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of the given length range
+- [Value type filter](https://docs.victoriametrics.com/victorialogs/logsql/#value_type-filter) - matches logs with [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) stored under the given value type
+- [Fields' equality filter](https://docs.victoriametrics.com/victorialogs/logsql/#eq_field-filter) - matches logs, which contain identical values in the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+- [`Less than` filter](https://docs.victoriametrics.com/victorialogs/logsql/#lt_field-filter) - matches logs where the given field value is smaller than the other field value
+- [`Less than or equal` filter](https://docs.victoriametrics.com/victorialogs/logsql/#le_field-filter) - matches logs where the given field value doesn't exceed the other field value
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) - allows combining other filters
 
 ### Time filter
 
@@ -296,7 +300,7 @@ It uses various optimizations in order to accelerate full scan queries without t
 but such queries can be slow if the storage contains large number of logs over long time range. The easiest way to optimize queries
 is to narrow down the search with the filter on [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
 
-For example, the following query returns logs ingested into VictoriaLogs during the last hour, which contain the `error` [word](#word)
+For example, the following query returns logs ingested into VictoriaLogs during the last hour, which contain the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word)
 at the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```logsql
@@ -305,7 +309,7 @@ _time:1h AND error
 
 The following formats are supported for `_time` filter:
 
-- `_time:duration` matches logs with timestamps on the time range `(now-duration, now]`, where `duration` can have [these values](#duration-values). Examples:
+- `_time:duration` matches logs with timestamps on the time range `(now-duration, now]`, where `duration` can have [these values](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values). Examples:
   - `_time:5m` - returns logs for the last 5 minutes
   - `_time:2.5d15m42.345s` - returns logs for the last 2.5 days, 15 minutes and 42.345 seconds
   - `_time:1y` - returns logs for the last year
@@ -341,26 +345,26 @@ It is possible to specify generic offset for the selected time range by appendin
 - `_time:2023-07Z offset 5h30m` matches logs on July, 2023 by UTC with offset 5h30m.
 - `_time:[2023-02-01Z, 2023-03-01Z) offset 1w` matches logs the week before the time range `[2023-02-01Z, 2023-03-01Z)` by UTC.
 
-See also [`time_offset` option](#query-options), which allows applying the given offset to all the filters on `_time` field without the need to modify the query.
+See also [`time_offset` option](https://docs.victoriametrics.com/victorialogs/logsql/#query-options), which allows applying the given offset to all the filters on `_time` field without the need to modify the query.
 
-See also [`time_add` pipe](#time_add-pipe), which allows adding the given duration to the given log field.
+See also [`time_add` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#time_add-pipe), which allows adding the given duration to the given log field.
 
 Performance tips:
 
 - It is recommended specifying the smallest possible time range during the search, since it reduces the amounts of log entries, which need to be scanned during the query.
   For example, `_time:1h` is usually faster than `_time:5h`.
 
-- While LogsQL supports arbitrary number of `_time:...` filters at any level of [logical filters](#logical-filter),
+- While LogsQL supports arbitrary number of `_time:...` filters at any level of [logical filters](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter),
   it is recommended specifying a single `_time` filter at the top level of the query.
 
-- See [other performance tips](#performance-tips).
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [Day range filter](#day-range-filter)
-- [Week range filter](#week-range-filter)
-- [Stream filter](#stream-filter)
-- [Word filter](#word-filter)
+- [Day range filter](https://docs.victoriametrics.com/victorialogs/logsql/#day-range-filter)
+- [Week range filter](https://docs.victoriametrics.com/victorialogs/logsql/#week-range-filter)
+- [Stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
 
 ### Day range filter
 
@@ -379,14 +383,14 @@ For example, the following query matches logs between `08:00` and `18:00`, exclu
 _time:day_range(08:00, 18:00]
 ```
 
-If the time range must be applied to other than UTC time zone, then add `offset <duration>`, where `<duration>` can have [any supported duration value](#duration-values).
+If the time range must be applied to other than UTC time zone, then add `offset <duration>`, where `<duration>` can have [any supported duration value](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
 For example, the following query selects logs between `08:00` and `18:00` at `+0200` time zone:
 
 ```logsql
 _time:day_range[08:00, 18:00) offset 2h
 ```
 
-Performance tip: it is recommended specifying regular [time filter](#time-filter) additionally to `day_range` filter. For example, the following query selects logs
+Performance tip: it is recommended specifying regular [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) additionally to `day_range` filter. For example, the following query selects logs
 between `08:00` and `20:00` every day for the last week:
 
 ```logsql
@@ -395,8 +399,8 @@ _time:1w _time:day_range[08:00, 18:00)
 
 See also:
 
-- [Week range filter](#week-range-filter)
-- [Time filter](#time-filter)
+- [Week range filter](https://docs.victoriametrics.com/victorialogs/logsql/#week-range-filter)
+- [Time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter)
 
 ### Week range filter
 
@@ -424,21 +428,21 @@ For example, the following query matches logs between Sunday and Saturday, exclu
 _time:week_range(Sun, Sat)
 ```
 
-If the day range must be applied to other than UTC time zone, then add `offset <duration>`, where `<duration>` can have [any supported duration value](#duration-values).
+If the day range must be applied to other than UTC time zone, then add `offset <duration>`, where `<duration>` can have [any supported duration value](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
 For example, the following query selects logs between Monday and Friday at `+0200` time zone:
 
 ```logsql
 _time:week_range[Mon, Fri] offset 2h
 ```
 
-The `week_range` filter can be combined with [`day_range` filter](#day-range-filter) using [logical filters](#logical-filter). For example, the following query
+The `week_range` filter can be combined with [`day_range` filter](https://docs.victoriametrics.com/victorialogs/logsql/#day-range-filter) using [logical filters](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter). For example, the following query
 selects logs between `08:00` and `18:00` every day of the week excluding Sunday and Saturday:
 
 ```logsql
 _time:week_range[Mon, Fri] _time:day_range[08:00, 18:00)
 ```
 
-Performance tip: it is recommended specifying regular [time filter](#time-filter) additionally to `week_range` filter. For example, the following query selects logs
+Performance tip: it is recommended specifying regular [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) additionally to `week_range` filter. For example, the following query selects logs
 between Monday and Friday per every week for the last 4 weeks:
 
 ```logsql
@@ -447,8 +451,8 @@ _time:4w _time:week_range[Mon, Fri]
 
 See also:
 
-- [Day range filter](#day-range-filter)
-- [Time filter](#time-filter)
+- [Day range filter](https://docs.victoriametrics.com/victorialogs/logsql/#day-range-filter)
+- [Time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter)
 
 ### Stream filter
 
@@ -463,7 +467,7 @@ with `app` field equal to `nginx`:
 {app="nginx"}
 ```
 
-This query is equivalent to the following [`exact` filter](#exact-filter) query, but the upper query usually works much faster:
+This query is equivalent to the following [`exact` filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter) query, but the upper query usually works much faster:
 
 ```logsql
 app:="nginx"
@@ -486,16 +490,16 @@ Performance tips:
 - It is recommended using the most specific `{...}` filter matching the smallest number of log streams,
   which needs to be scanned by the rest of filters in the query.
 
-- While LogsQL supports arbitrary number of `{...}` filters at any level of [logical filters](#logical-filter),
+- While LogsQL supports arbitrary number of `{...}` filters at any level of [logical filters](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter),
   it is recommended specifying a single `{...}` filter at the top level of the query.
 
-- See [other performance tips](#performance-tips).
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [`_stream_id` filter](#_stream_id-filter)
-- [Time filter](#time-filter)
-- [Exact filter](#exact-filter)
+- [`_stream_id` filter](https://docs.victoriametrics.com/victorialogs/logsql/#_stream_id-filter)
+- [Time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
 
 ### _stream_id filter
 
@@ -509,7 +513,7 @@ with `_stream_id` equal to `0000007b000001c850d9950ea6196b1a4812081265faa1c7`:
 _stream_id:0000007b000001c850d9950ea6196b1a4812081265faa1c7
 ```
 
-If the log stream contains too many logs, then it is good idea limiting the number of returned logs with [time filter](#time-filter). For example, the following
+If the log stream contains too many logs, then it is good idea limiting the number of returned logs with [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter). For example, the following
 query selects logs for the given stream for the last hour:
 
 ```logsql
@@ -523,7 +527,7 @@ _stream_id:in(0000007b000001c850d9950ea6196b1a4812081265faa1c7, 1230007b456701c8
 ```
 
 It is also possible specifying subquery inside `in(...)`, which selects the needed `_stream_id` values. For example, the following query returns
-logs for [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) containing `error` [word](#word)
+logs for [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) containing `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word)
 in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) during the last 5 minutes:
 
 ```logsql
@@ -532,13 +536,13 @@ _stream_id:in(_time:5m error | fields _stream_id)
 
 See also:
 
-- [subquery filter](#subquery-filter)
-- [stream filter](#stream-filter)
+- [subquery filter](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter)
+- [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
 
 ### Word filter
 
-The simplest LogsQL query consists of a single [word](#word) to search in log messages. For example, the following query matches
-[log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) with `error` [word](#word) inside them:
+The simplest LogsQL query consists of a single [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) to search in log messages. For example, the following query matches
+[log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) with `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) inside them:
 
 ```logsql
 error
@@ -552,12 +556,12 @@ This query matches the following [log messages](https://docs.victoriametrics.com
 
 This query doesn't match the following log messages:
 
-- `ERROR`, since the filter is case-sensitive by default. Use `i(error)` for this case. See [these docs](#case-insensitive-filter) for details.
-- `multiple errors occurred`, since the `errors` word doesn't match `error` word. Use `error*` for this case. See [these docs](#prefix-filter) for details.
+- `ERROR`, since the filter is case-sensitive by default. Use `i(error)` for this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter) for details.
+- `multiple errors occurred`, since the `errors` word doesn't match `error` word. Use `error*` for this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter) for details.
 
-By default the given [word](#word) is searched in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
+By default the given [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) is searched in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 Specify the [field name](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in front of the word and put a colon after it
-if it must be searched in the given field. For example, the following query returns log entries containing the `error` [word](#word) in the `log.level` field:
+if it must be searched in the given field. For example, the following query returns log entries containing the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) in the `log.level` field:
 
 ```logsql
 log.level:error
@@ -578,15 +582,15 @@ For example, the following query searches for the ip `1.2.3.45` in the field `ip
 
 See also:
 
-- [Phrase filter](#phrase-filter)
-- [Exact filter](#exact-filter)
-- [Prefix filter](#prefix-filter)
-- [Substring filter](#substring-filter)
-- [Logical filter](#logical-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Phrase filter
 
-Is you need to search for log messages with the specific phrase inside them, then just wrap the phrase into quotes according to [these docs](#string-literals).
+Is you need to search for log messages with the specific phrase inside them, then just wrap the phrase into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
 The phrase can contain any chars, including whitespace, punctuation, parens, etc. They are taken into account during the search.
 For example, the following query matches [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
 with `ssh: login fail` phrase inside them:
@@ -603,13 +607,13 @@ This query matches the following [log messages](https://docs.victoriametrics.com
 This query doesn't match the following log messages:
 
 - `ssh login fail`, since the message misses `:` char just after the `ssh`.
-  Use `seq("ssh", "login", "fail")` query if log messages with the sequence of these words must be found. See [these docs](#sequence-filter) for details.
+  Use `seq("ssh", "login", "fail")` query if log messages with the sequence of these words must be found. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#sequence-filter) for details.
 - `login fail: ssh error`, since the message doesn't contain the full phrase requested in the query. If you need matching a message
-  with all the [words](#word) listed in the query, then use `ssh AND login AND fail` query. See [these docs](#logical-filter) for details.
-- `ssh: login failed`, since the message ends with `failed` [word](#word) instead of `fail` word. Use `"ssh: login fail"*` query for this case.
-  See [these docs](#prefix-filter) for details.
+  with all the [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) listed in the query, then use `ssh AND login AND fail` query. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
+- `ssh: login failed`, since the message ends with `failed` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) instead of `fail` word. Use `"ssh: login fail"*` query for this case.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter) for details.
 - `SSH: login fail`, since the `SSH` word is in capital letters. Use `i("ssh: login fail")` for case-insensitive search.
-  See [these docs](#case-insensitive-filter) for details.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter) for details.
 
 If the phrase contains double quotes, then either put `\` in front of double quotes or put the phrase inside single quotes. For example, the following filter searches
 logs with `"foo":"bar"` phrase:
@@ -641,16 +645,16 @@ For example, the following query searches for the `cannot open file` phrase in t
 
 See also:
 
-- [Exact filter](#exact-filter)
-- [Word filter](#word-filter)
-- [Prefix filter](#prefix-filter)
-- [Substring filter](#substring-filter)
-- [Logical filter](#logical-filter)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Prefix filter
 
-If you need to search for log messages with [words](#word) / phrases containing some prefix, then just add `*` char to the end of the [word](#word) / phrase in the query.
-For example, the following query returns [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field), which contain [words](#word) with `err` prefix:
+If you need to search for log messages with [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) / phrases containing some prefix, then just add `*` char to the end of the [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) / phrase in the query.
+For example, the following query returns [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field), which contain [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) with `err` prefix:
 
 ```logsql
 err*
@@ -663,10 +667,10 @@ This query matches the following [log messages](https://docs.victoriametrics.com
 
 This query doesn't match the following log messages:
 
-- `Error: foobar`, since the `Error` [word](#word) starts with capital letter. Use `i(err*)` for this case. See [these docs](#case-insensitive-filter) for details.
-- `fooerror`, since the `fooerror` [word](#word) doesn't start with `err`. Use `~"err"` for this case. See [these docs](#substring-filter) for details.
+- `Error: foobar`, since the `Error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) starts with capital letter. Use `i(err*)` for this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter) for details.
+- `fooerror`, since the `fooerror` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) doesn't start with `err`. Use `~"err"` for this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter) for details.
 
-Prefix filter can be applied to [phrases](#phrase-filter) put inside quotes according to [these docs](#string-literals). For example, the following query matches
+Prefix filter can be applied to [phrases](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) put inside quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals). For example, the following query matches
 [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) containing phrases with `unexpected fail` prefix:
 
 ```logsql
@@ -680,10 +684,10 @@ This query matches the following [log messages](https://docs.victoriametrics.com
 
 This query doesn't match the following log messages:
 
-- `unexpectedly failed`, since the `unexpectedly` doesn't match `unexpected` [word](#word). Use `unexpected* AND fail*` for this case.
-  See [these docs](#logical-filter) for details.
-- `failed to open file: unexpected EOF`, since `failed` [word](#word) occurs before the `unexpected` word. Use `unexpected AND fail*` for this case.
-  See [these docs](#logical-filter) for details.
+- `unexpectedly failed`, since the `unexpectedly` doesn't match `unexpected` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word). Use `unexpected* AND fail*` for this case.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
+- `failed to open file: unexpected EOF`, since `failed` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) occurs before the `unexpected` word. Use `unexpected AND fail*` for this case.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
 
 If the prefix contains double quotes, then either put `\` in front of double quotes or put the prefix inside single quotes. For example, the following filter searches
 logs with `"foo":"bar` prefix:
@@ -700,7 +704,7 @@ in order to apply it to the given field. For example, the following query matche
 log.level:err*
 ```
 
-If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](#string-literals).
+If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
 For example, the following query matches `log:level` field containing any word with the `err` prefix.
 
 ```logsql
@@ -709,19 +713,19 @@ For example, the following query matches `log:level` field containing any word w
 
 Performance tips:
 
-- Prefer using [word filters](#word-filter) and [phrase filters](#phrase-filter) combined via [logical filter](#logical-filter)
+- Prefer using [word filters](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filters](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) combined via [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
   instead of prefix filter.
-- Prefer moving [word filters](#word-filter) and [phrase filters](#phrase-filter) in front of prefix filter when using [logical filter](#logical-filter).
-- See [other performance tips](#performance-tips).
+- Prefer moving [word filters](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filters](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) in front of prefix filter when using [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [Substring filter](#substring-filter)
-- [Exact prefix filter](#exact-prefix-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Exact-filter](#exact-filter)
-- [Logical filter](#logical-filter)
+- [Substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter)
+- [Exact prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-prefix-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Exact-filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Pattern match filter
 
@@ -739,8 +743,9 @@ The `"pattern"` must contain the text to match, plus arbitrary number of the fol
 - `<TIME>` - matches time strings such as `10:20:30`. It also captures fractional seconds such as `10:20:30.123` and `10:20:30,123`.
 - `<DATE>` - matches date strings such as `2025-10-20` and `2025/10/20`.
 - `<DATETIME>` - matches datetime strings such as `2025-10-20T08:09:11` and `2025-10-20 08:09:11`. It also captures fractional seconds and timezones.
+- `<W>` - matches any [word](#word) or any quoted string in single quotes, double quotes and backticks.
 
-Such patterns are generated by the [`collapse_nums` pipe](#collapse_nums-pipe).
+Such patterns are generated by the [`collapse_nums` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe).
 
 For example, the following filter matches `_msg` field with the `<arbitrary_prefix>user_id=123, ip=45.67.89.12, time=2025-10-20T23:32:12Z<aribtrary_suffix>` contents:
 
@@ -752,15 +757,15 @@ If you need matching the whole `_msg` field value, then use `pattern_match_full(
 
 See also:
 
-- [`collapse_nums` pipe](#collapse_nums-pipe)
-- [Sequence filter](#sequence-filter)
-- [Phrase filter](#phrase-filter)
-- [Substring filter](#substring-filter)
-- [Logical filter](#logical-filter)
+- [`collapse_nums` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe)
+- [Sequence filter](https://docs.victoriametrics.com/victorialogs/logsql/#sequence-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Substring filter
 
-If it is needed to find logs with some substring, then `*substring*` filter can be used. The substring can be but in quotes according to [these docs](#string-literals) if needed.
+If it is needed to find logs with some substring, then `*substring*` filter can be used. The substring can be but in quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals) if needed.
 For example, the following query matches log entries, which contain `ampl` text in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```logsql
@@ -772,22 +777,22 @@ It matches the following messages:
 - `Example message`
 - `This is a sample`
 
-It doesn't match `EXAMPLE message`, since `AMPL` substring here is in uppercase. Use [`~"(?i)ampl"` filter](#regexp-filter) instead. Note that case-insensitive filter
+It doesn't match `EXAMPLE message`, since `AMPL` substring here is in uppercase. Use [`~"(?i)ampl"` filter](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) instead. Note that case-insensitive filter
 may be much slower than case-sensitive one.
 
-Performance tip: prefer using [word filter](#word-filter) and [phrase filter](#phrase-filter), since substring filter may be quite slow.
+Performance tip: prefer using [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter), since substring filter may be quite slow.
 
 See also:
 
-- [Pattern match filter](#pattern-match-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Regexp filter](#regexp-filter)
+- [Pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Regexp filter](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter)
 
 ### Range comparison filter
 
 LogsQL supports `field:>X`, `field:>=X`, `field:<X` and `field:<=X` filters, where `field` is the name of [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-and `X` is [numeric value](#numeric-values), IPv4 address or a string. For example, the following query returns logs containing numeric values for the `response_size` field bigger than `10*1024`:
+and `X` is [numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values), IPv4 address or a string. For example, the following query returns logs containing numeric values for the `response_size` field bigger than `10*1024`:
 
 ```logsql
 response_size:>10KiB
@@ -801,10 +806,10 @@ username:<"John"
 
 See also:
 
-- [String range filter](#string-range-filter)
-- [Range filter](#range-filter)
-- [`le_field` filter](#le_field-filter)
-- [`lt_field` filter](#lt_field-filter)
+- [String range filter](https://docs.victoriametrics.com/victorialogs/logsql/#string-range-filter)
+- [Range filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-filter)
+- [`le_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#le_field-filter)
+- [`lt_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#lt_field-filter)
 
 ### Empty value filter
 
@@ -817,9 +822,9 @@ host.hostname:""
 
 See also:
 
-- [Any value filter](#any-value-filter)
-- [Word filter](#word-filter)
-- [Logical filter](#logical-filter)
+- [Any value filter](https://docs.victoriametrics.com/victorialogs/logsql/#any-value-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Any value filter
 
@@ -832,13 +837,13 @@ host.hostname:*
 
 See also:
 
-- [Empty value filter](#empty-value-filter)
-- [Prefix filter](#prefix-filter)
-- [Logical filter](#logical-filter)
+- [Empty value filter](https://docs.victoriametrics.com/victorialogs/logsql/#empty-value-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Exact filter
 
-The [word filter](#word-filter) and [phrase filter](#phrase-filter) return [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
+The [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) return [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
 which contain the given word or phrase inside them. The message may contain additional text other than the requested word or phrase. If you need searching for log messages
 or [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) with the exact value, then use the `exact` filter.
 For example, the following query returns log messages with the exact value `fatal error: cannot find /foo/bar`:
@@ -850,10 +855,10 @@ For example, the following query returns log messages with the exact value `fata
 The query doesn't match the following log messages:
 
 - `fatal error: cannot find /foo/bar/baz` or `some-text fatal error: cannot find /foo/bar`, since they contain an additional text
-  other than the specified in the `exact` filter. Use `"fatal error: cannot find /foo/bar"` query in this case. See [these docs](#phrase-filter) for details.
+  other than the specified in the `exact` filter. Use `"fatal error: cannot find /foo/bar"` query in this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) for details.
 
 - `FATAL ERROR: cannot find /foo/bar`, since the `exact` filter is case-sensitive. Use `i("fatal error: cannot find /foo/bar")` in this case.
-  See [these docs](#case-insensitive-filter) for details.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter) for details.
 
 By default the `exact` filter is applied to the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 Specify the [field name](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in front of the `exact` filter and put a colon after it
@@ -878,13 +883,13 @@ For example, the following query matches the `error` value in the field `log:lev
 
 See also:
 
-- [Fields' equality filter](#eq_field-filter)
-- [Exact prefix filter](#exact-prefix-filter)
-- [Multi-exact filter](#multi-exact-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Prefix filter](#prefix-filter)
-- [Logical filter](#logical-filter)
+- [Fields' equality filter](https://docs.victoriametrics.com/victorialogs/logsql/#eq_field-filter)
+- [Exact prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-prefix-filter)
+- [Multi-exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Exact prefix filter
 
@@ -903,9 +908,9 @@ This filter matches the following [log messages](https://docs.victoriametrics.co
 It doesn't match the following log messages:
 
 - `processing request foobar`, since the log message starts with lowercase `p`. Use `="processing request"* OR ="Processing request"*`
-  query in this case. See [these docs](#logical-filter) for details.
+  query in this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
 - `start: Processing request`, since the log message doesn't start with `Processing request`. Use `"Processing request"` query in this case.
-  See [these docs](#phrase-filter) for details.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) for details.
 
 By default the `exact` filter is applied to the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 Specify the [field name](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in front of the `exact` filter and put a colon after it
@@ -930,16 +935,16 @@ For example, the following query matches `log:level` values starting with `err`
 
 See also:
 
-- [Exact filter](#exact-filter)
-- [Prefix filter](#prefix-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Logical filter](#logical-filter)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Multi-exact filter
 
-Sometimes it is needed to locate log messages with a field containing one of the given values. This can be done with multiple [exact filters](#exact-filter)
-combined into a single [logical filter](#logical-filter). For example, the following query matches log messages with `log.level` field
+Sometimes it is needed to locate log messages with a field containing one of the given values. This can be done with multiple [exact filters](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+combined into a single [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter). For example, the following query matches log messages with `log.level` field
 containing either `error` or `fatal` exact values:
 
 ```logsql
@@ -954,24 +959,24 @@ log.level:in("error", "fatal")
 
 It works very fast for long lists passed to `in()`.
 
-It is possible to pass arbitrary [query](#query-syntax) inside `in(...)` filter in order to match against the results of this query.
-See [these docs](#subquery-filter) for details.
+It is possible to pass arbitrary [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) inside `in(...)` filter in order to match against the results of this query.
+See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter) for details.
 
 See also:
 
-- [`contains_any` filter](#contains_any-filter)
-- [`contains_all` filter](#contains_all-filter)
-- [Exact filter](#exact-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Prefix filter](#prefix-filter)
-- [Logical filter](#logical-filter)
+- [`contains_any` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter)
+- [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_all-filter)
+- [Exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### contains_all filter
 
-If it is needed to find logs, which contain all the given [words](#word) / phrases, then `v1 AND v2 ... AND vN` [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
+If it is needed to find logs, which contain all the given [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) / phrases, then `v1 AND v2 ... AND vN` [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 can be used. VictoriaLogs provides an alternative approach with the `contains_all(v1, v2, ..., vN)` filter. For example, the following query matches logs,
-which contain both `foo` [word](#word) and `"bar baz"` phrase in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
+which contain both `foo` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) and `"bar baz"` phrase in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```logsql
 contains_all(foo, "bar baz")
@@ -983,23 +988,23 @@ This is equivalent to the following query:
 foo AND "bar baz"
 ```
 
-It is possible to pass arbitrary [query](#query-syntax) inside `contains_all(...)` filter in order to match against the results of this query.
-See [these docs](#subquery-filter) for details.
+It is possible to pass arbitrary [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) inside `contains_all(...)` filter in order to match against the results of this query.
+See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter) for details.
 
 See also:
 
-- [`seq` filter](#sequence-filter)
-- [word filter](#word-filter)
-- [phrase filter](#phrase-filter)
-- [`in` filter](#multi-exact-filter)
-- [`contains_any` filter](#contains_any-filter)
+- [`seq` filter](https://docs.victoriametrics.com/victorialogs/logsql/#sequence-filter)
+- [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [`in` filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter)
+- [`contains_any` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter)
 
 ### contains_any filter
 
-Sometimes it is needed to find logs, which contain at least one [word](#word) or phrase out of many words / phrases.
+Sometimes it is needed to find logs, which contain at least one [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) or phrase out of many words / phrases.
 This can be done with `v1 OR v2 OR ... OR vN` [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
 VictoriaLogs provides an alternative approach with the `contains_any(v1, v2, ..., vN)` filter. For example, the following query matches logs,
-which contain `foo` [word](#word) or `"bar baz"` phrase in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
+which contain `foo` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) or `"bar baz"` phrase in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```logsql
 contains_any(foo, "bar baz")
@@ -1011,31 +1016,31 @@ This is equivalent to the following query:
 foo OR "bar baz"
 ```
 
-It is possible to pass arbitrary [query](#query-syntax) inside `contains_any(...)` filter in order to match against the results of this query.
-See [these docs](#subquery-filter) for details.
+It is possible to pass arbitrary [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) inside `contains_any(...)` filter in order to match against the results of this query.
+See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter) for details.
 
 See also:
 
-- [word filter](#word-filter)
-- [phrase filter](#phrase-filter)
-- [`in` filter](#multi-exact-filter)
-- [`contains_all` filter](#contains_all-filter)
+- [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [`in` filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter)
+- [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_all-filter)
 
 ### Subquery filter
 
 Sometimes it is needed to select logs with [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) matching values
-selected by another [query](#query-syntax) (aka subquery). LogsQL provides such an ability with the following filters:
+selected by another [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) (aka subquery). LogsQL provides such an ability with the following filters:
 
 - `field:in(<subquery>)` - it returns logs with `field` values matching the values returned by the `<subquery>`.
   For example, the following query selects all the logs for the last 5 minutes for users,
-  who visited pages with `admin` [word](#word) in the `path` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+  who visited pages with `admin` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) in the `path` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
   during the last day:
 
   ```logsql
   _time:5m AND user_id:in(_time:1d AND path:admin | fields user_id)
   ```
 
-- `field:contains_all(<subquery>)` - it returns logs with `field` values containing all the [words](#word) and phrases returned by the `<subquery>`.
+- `field:contains_all(<subquery>)` - it returns logs with `field` values containing all the [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) and phrases returned by the `<subquery>`.
   For example, the following query selects all the logs for the last 5 minutes, which contain all the `user_id` values from admin logs over the last day
   in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
@@ -1043,7 +1048,7 @@ selected by another [query](#query-syntax) (aka subquery). LogsQL provides such
   _time:5m _msg:contains_all(_time:1d is_admin:true | fields user_id)
   ```
 
-- `field:contains_any(<subquery>)` - it returns logs with the `field` values containing at least one [word](#word) or phrase returned by the `<subquery>`.
+- `field:contains_any(<subquery>)` - it returns logs with the `field` values containing at least one [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) or phrase returned by the `<subquery>`.
   For example, the following query selects all the logs for the last 5 minutes, which contain at least one `user_id` value from admin logs over the last day
   in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
@@ -1051,21 +1056,21 @@ selected by another [query](#query-syntax) (aka subquery). LogsQL provides such
   _time:5m _msg:contains_any(_time:1d is_admin:true | fields user_id)
   ```
 
-The `<subquery>` must end with either [`fields` pipe](#fields-pipe) or [`uniq` pipe](#uniq-pipe) containing a single field name,
+The `<subquery>` must end with either [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) or [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe) containing a single field name,
 so VictoriaLogs could use values of this field for matching the given filter.
 
 See also:
 
-- [`in` filter](#multi-exact-filter)
-- [`contains_all` filter](#contains_all-filter)
-- [`contains_any` filter](#contains_any-filter)
-- [`join` pipe](#join-pipe)
-- [`union` pipe](#union-pipe)
+- [`in` filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter)
+- [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_all-filter)
+- [`contains_any` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter)
+- [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe)
+- [`union` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#union-pipe)
 
 ### Case-insensitive filter
 
-Case-insensitive filter can be applied to any word, phrase or prefix by wrapping the corresponding [word filter](#word-filter),
-[phrase filter](#phrase-filter) or [prefix filter](#prefix-filter) into `i()`. For example, the following query returns
+Case-insensitive filter can be applied to any word, phrase or prefix by wrapping the corresponding [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter),
+[phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) or [prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter) into `i()`. For example, the following query returns
 log messages with `error` word in any case:
 
 ```logsql
@@ -1081,19 +1086,19 @@ The query matches the following [log messages](https://docs.victoriametrics.com/
 
 The query doesn't match the following log messages:
 
-- `FooError`, since the `FooError` [word](#word) has superfluous prefix `Foo`. Use `~"(?i)error"` for this case. See [these docs](#regexp-filter) for details.
-- `too many Errors`, since the `Errors` [word](#word) has superfluous suffix `s`. Use `i(error*)` for this case.
+- `FooError`, since the `FooError` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) has superfluous prefix `Foo`. Use `~"(?i)error"` for this case. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) for details.
+- `too many Errors`, since the `Errors` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) has superfluous suffix `s`. Use `i(error*)` for this case.
 
 By default the `i()` filter is applied to the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 Specify the needed [field name](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in front of the filter
-in order to apply it to the given field. For example, the following query matches `log.level` field containing `error` [word](#word) in any case:
+in order to apply it to the given field. For example, the following query matches `log.level` field containing `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) in any case:
 
 ```logsql
 log.level:i(error)
 ```
 
-If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](#string-literals).
-For example, the following query matches `log:level` field containing `error` [word](#word) in any case.
+If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
+For example, the following query matches `log:level` field containing `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) in any case.
 
 ```logsql
 "log:level":i("error")
@@ -1101,31 +1106,86 @@ For example, the following query matches `log:level` field containing `error` [w
 
 Performance tips:
 
-- Prefer using case-sensitive filter over case-insensitive filter.
-- Prefer moving [word filter](#word-filter), [phrase filter](#phrase-filter) and [prefix filter](#prefix-filter) in front of case-sensitive filter
-  when using [logical filter](#logical-filter).
-- See [other performance tips](#performance-tips).
+- Prefer using [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter) over case-insensitive filter.
+- Prefer using case-sensitive filters such as [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+  and [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) over case-insensitive filter.
+- Prefer moving [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter), [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) and [prefix filter](https://docs.victoriametrics.com/victorialogs/logsql/#prefix-filter) in front of case-sensitive filter
+  when using [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
+
+See also:
+
+- [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Exact-filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
+
+### equals_common_case filter
+
+The `field_name:equals_common_case(phrase1, ..., phraseN)` filter searches for logs where the `field_name` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+equals the following [phrases](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) and [words](https://docs.victoriametrics.com/victorialogs/logsql/#word):
+
+- the given phrases - `phrase1`, ..., `phraseN`
+- uppercase and lowercase phrases
+- individual phrases where every uppercase letter is independently replaced with the corresponding lowercase letter
+
+For example, `_msg:equals_common_case("VictoriaMetrics")` finds logs where the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
+equals to one of the following words [words](https://docs.victoriametrics.com/victorialogs/logsql/#word):
+
+- VictoriaMetrics
+- VICTORIAMETRICS
+- victoriametrics
+- Victoriametrics
+- victoriaMetrics
+
+If you need to find logs with log fields containing to the common case words or phrases,
+then use [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter).
+
+See also:
+
+- [case-insensitive filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter)
+- [`contains_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_common_case-filter)
+
+### contains_common_case filter
+
+The `field_name:contains_common_case(phrase1, ..., phraseN)` filter searches for logs where the `field_name` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+contains the following [phrases](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) and [words](https://docs.victoriametrics.com/victorialogs/logsql/#word):
+
+- the given phrases - `phrase1`, ..., `phraseN`
+- uppercase and lowercase phrases
+- individual phrases where every uppercase letter is independently replaced with the corresponding lowercase letter
+
+For example, `_msg:contains_common_case("VictoriaMetrics")` finds logs where the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
+contains at least one of the following words [words](https://docs.victoriametrics.com/victorialogs/logsql/#word):
+
+- VictoriaMetrics
+- VICTORIAMETRICS
+- victoriametrics
+- Victoriametrics
+- victoriaMetrics
+
+If you need to find logs with log fields equal to the common case words or phrases,
+then use [`equals_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#equals_common_case-filter).
 
 See also:
 
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Exact-filter](#exact-filter)
-- [Logical filter](#logical-filter)
+- [case-insensitive filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter)
+- [`equals_common_case` filter](https://docs.victoriametrics.com/victorialogs/logsql/#equals_common_case-filter)
 
 ### Sequence filter
 
 Sometimes it is needed to find [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
-with [words](#word) or phrases in a particular order. For example, if log messages with `error` word followed by `open file` phrase
-must be found, then the following LogsQL query can be used (every word / phrase can be quoted according to [these docs](#string-literals)):
+with [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) or phrases in a particular order. For example, if log messages with `error` word followed by `open file` phrase
+must be found, then the following LogsQL query can be used (every word / phrase can be quoted according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals)):
 
 ```logsql
 seq("error", "open file")
 ```
 
-This query matches `some error: cannot open file /foo/bar` message, since the `open file` phrase goes after the `error` [word](#word).
-The query doesn't match the `cannot open file: error` message, since the `open file` phrase is located in front of the `error` [word](#word).
-If you need matching log messages with both `error` word and `open file` phrase, then use `error AND "open file"` query. See [these docs](#logical-filter)
+This query matches `some error: cannot open file /foo/bar` message, since the `open file` phrase goes after the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word).
+The query doesn't match the `cannot open file: error` message, since the `open file` phrase is located in front of the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word).
+If you need matching log messages with both `error` word and `open file` phrase, then use `error AND "open file"` query. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 for details.
 
 By default the `seq()` filter is applied to the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
@@ -1145,17 +1205,17 @@ For example, the following query matches `event:original` field containing `(err
 
 See also:
 
-- [Pattern match filter](#pattern-match-filter)
-- [`contains_all` filter](#contains_all-filter)
-- [Word filter](#word-filter)
-- [Phrase filter](#phrase-filter)
-- [Exact-filter](#exact-filter)
-- [Logical filter](#logical-filter)
+- [Pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter)
+- [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_all-filter)
+- [Word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter)
+- [Phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+- [Exact-filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Regexp filter
 
 LogsQL supports regular expression filter with [re2 syntax](https://github.com/google/re2/wiki/Syntax) via `~"regex"` syntax.
-The `regex` can be but in one of the supported quotes according to [these docs](#string-literals).
+The `regex` can be but in one of the supported quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
 For example, the following query returns all the log messages containing `err` or `warn` susbstrings:
 
 ```logsql
@@ -1171,7 +1231,7 @@ The query matches the following [log messages](https://docs.victoriametrics.com/
 The query doesn't match the following log messages:
 
 - `ERROR: cannot open file`, since the `ERROR` word is in uppercase letters. Use `~"(?i)(err|warn)"` query for case-insensitive regexp search.
-  See [these docs](https://github.com/google/re2/wiki/Syntax) for details. See also [case-insensitive filter docs](#case-insensitive-filter).
+  See [these docs](https://github.com/google/re2/wiki/Syntax) for details. See also [case-insensitive filter docs](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter).
 - `it is warmer than usual`, since it doesn't contain neither `err` nor `warn` substrings.
 
 If the regexp contains double quotes, then either put `\` in front of double quotes or put the regexp inside single quotes. For example, the following regexp searches
@@ -1187,7 +1247,7 @@ The `\` char inside the regexp must be encoded as `\\`. For example, the followi
 ~"a\\.b"
 ```
 
-It is recommended using [substring filter](#substring-filter) when searching for some substring is needed.
+It is recommended using [substring filter](https://docs.victoriametrics.com/victorialogs/logsql/#substring-filter) when searching for some substring is needed.
 
 By default the regexp filter is applied to the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 Specify the needed [field name](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) in front of the filter
@@ -1197,7 +1257,7 @@ in order to apply it to the given field. For example, the following query matche
 event.original:~"err|warn"
 ```
 
-If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](#string-literals).
+If the field name contains special chars, which may clash with the query syntax, then it may be put into quotes according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#string-literals).
 For example, the following query matches `event:original` field containing either `err` or `warn` substrings:
 
 ```logsql
@@ -1206,18 +1266,18 @@ For example, the following query matches `event:original` field containing eithe
 
 Performance tips:
 
-- Prefer combining simple [word filter](#word-filter) with [logical filter](#logical-filter) instead of using regexp filter.
+- Prefer combining simple [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) with [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) instead of using regexp filter.
   For example, the `~"error|warning"` query can be substituted with `error OR warning` query, which usually works much faster.
-  Note that the `~"error|warning"` matches `errors` as well as `warnings` [words](#word), while `error OR warning` matches
-  only the specified [words](#word). See also [multi-exact filter](#multi-exact-filter).
-- Prefer moving the regexp filter to the end of the [logical filter](#logical-filter), so lighter filters are executed first.
-- Prefer using `="some prefix"*` instead of `~"^some prefix"`, since the [`exact` filter](#exact-prefix-filter) works much faster than the regexp filter.
-- See [other performance tips](#performance-tips).
+  Note that the `~"error|warning"` matches `errors` as well as `warnings` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word), while `error OR warning` matches
+  only the specified [words](https://docs.victoriametrics.com/victorialogs/logsql/#word). See also [multi-exact filter](https://docs.victoriametrics.com/victorialogs/logsql/#multi-exact-filter).
+- Prefer moving the regexp filter to the end of the [logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter), so lighter filters are executed first.
+- Prefer using `="some prefix"*` instead of `~"^some prefix"`, since the [`exact` filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-prefix-filter) works much faster than the regexp filter.
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [Case-insensitive filter](#case-insensitive-filter)
-- [Logical filter](#logical-filter)
+- [Case-insensitive filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Range filter
 
@@ -1229,7 +1289,7 @@ for searching for log entries with request durations exceeding 4.2 seconds:
 request.duration:range(4.2, Inf)
 ```
 
-This query can be shortened to by using [range comparison filter](#range-comparison-filter):
+This query can be shortened to by using [range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter):
 
 ```logsql
 request.duration:>4.2
@@ -1242,26 +1302,26 @@ parentheses with square brackets. For example:
 - `range(1, 10]` includes `10` in the matching range
 - `range[1, 10]` includes `1` and `10` in the matching range
 
-The range boundaries can contain any [supported numeric values](#numeric-values).
+The range boundaries can contain any [supported numeric values](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values).
 
 Note that the `range()` filter doesn't match [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 with non-numeric values alongside numeric values. For example, `range(1, 10)` doesn't match `the request took 4.2 seconds`
 [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field), since the `4.2` number is surrounded by other text.
-Extract the numeric value from the message with [`extract` pipe](#extract-pipe) and then apply the `range()` [filter pipe](#filter-pipe) to the extracted field.
+Extract the numeric value from the message with [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) and then apply the `range()` [filter pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe) to the extracted field.
 
 Performance tips:
 
 - It is better to query pure numeric [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-  instead of extracting numeric field from text field via [transformations](#transformations) at query time.
-- See [other performance tips](#performance-tips).
+  instead of extracting numeric field from text field via [transformations](https://docs.victoriametrics.com/victorialogs/logsql/#transformations) at query time.
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [Range comparison filter](#range-comparison-filter)
-- [IPv4 range filter](#ipv4-range-filter)
-- [String range filter](#string-range-filter)
-- [Length range filter](#length-range-filter)
-- [Logical filter](#logical-filter)
+- [Range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter)
+- [IPv4 range filter](https://docs.victoriametrics.com/victorialogs/logsql/#ipv4-range-filter)
+- [String range filter](https://docs.victoriametrics.com/victorialogs/logsql/#string-range-filter)
+- [Length range filter](https://docs.victoriametrics.com/victorialogs/logsql/#length-range-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### IPv4 range filter
 
@@ -1288,30 +1348,30 @@ user.ip:ipv4_range("1.2.3.4")
 
 Note that the `ipv4_range()` doesn't match a string with IPv4 address if this string contains other text. For example, `ipv4_range("127.0.0.0/24")`
 doesn't match `request from 127.0.0.1: done` [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
-since the `127.0.0.1` ip is surrounded by other text. Extract the IP from the message with [`extract` pipe](#extract-pipe)
-and then apply the `ipv4_range()` [filter pipe](#filter-pipe) to the extracted field.
+since the `127.0.0.1` ip is surrounded by other text. Extract the IP from the message with [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+and then apply the `ipv4_range()` [filter pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe) to the extracted field.
 
 Hints:
 
 - If you need searching for [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) containing the given `X.Y.Z.Q` IPv4 address,
-  then `"X.Y.Z.Q"` query can be used. See [these docs](#phrase-filter) for details.
+  then `"X.Y.Z.Q"` query can be used. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter) for details.
 - If you need searching for [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) containing
-  at least a single IPv4 address out of the given list, then `"ip1" OR "ip2" ... OR "ipN"` query can be used. See [these docs](#logical-filter) for details.
+  at least a single IPv4 address out of the given list, then `"ip1" OR "ip2" ... OR "ipN"` query can be used. See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
 - If you need finding log entries with `ip` field in multiple ranges, then use `ip:(ipv4_range(range1) OR ipv4_range(range2) ... OR ipv4_range(rangeN))` query.
-  See [these docs](#logical-filter) for details.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter) for details.
 
 Performance tips:
 
 - It is better querying pure IPv4 [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-  instead of extracting IPv4 from text field via [transformations](#transformations) at query time.
-- See [other performance tips](#performance-tips).
+  instead of extracting IPv4 from text field via [transformations](https://docs.victoriametrics.com/victorialogs/logsql/#transformations) at query time.
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 See also:
 
-- [Range filter](#range-filter)
-- [String range filter](#string-range-filter)
-- [Length range filter](#length-range-filter)
-- [Logical filter](#logical-filter)
+- [Range filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-filter)
+- [String range filter](https://docs.victoriametrics.com/victorialogs/logsql/#string-range-filter)
+- [Length range filter](https://docs.victoriametrics.com/victorialogs/logsql/#length-range-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### String range filter
 
@@ -1327,11 +1387,11 @@ For example, the `user.name:string_range(C, E)` would match `user.name` fields,
 
 See also:
 
-- [Range comparison filter](#range-comparison-filter)
-- [Range filter](#range-filter)
-- [IPv4 range filter](#ipv4-range-filter)
-- [Length range filter](#length-range-filter)
-- [Logical filter](#logical-filter)
+- [Range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter)
+- [Range filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-filter)
+- [IPv4 range filter](https://docs.victoriametrics.com/victorialogs/logsql/#ipv4-range-filter)
+- [Length range filter](https://docs.victoriametrics.com/victorialogs/logsql/#length-range-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### Length range filter
 
@@ -1376,13 +1436,13 @@ foo:len_range(10, 20)
 
 See also:
 
-- [Range filter](#range-filter)
-- [Logical filter](#logical-filter)
+- [Range filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-filter)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### value_type filter
 
 VictoriaLogs automatically detects types for the ingested [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) and stores log field values
-according to the detected type (such as `const`, `dict`, `string`, `int64`, `float64`, etc.). Value types for stored fields can be obtained via [`block_stats` pipe](#block_stats-pipe).
+according to the detected type (such as `const`, `dict`, `string`, `int64`, `float64`, etc.). Value types for stored fields can be obtained via [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe).
 
 Sometimes it is needed to select logs with fields of a particular value type. Then `value_type(type)` filter can be used.
 For example, the following filter selects logs where `user_id` field values are stored as `uint64` type:
@@ -1393,9 +1453,9 @@ user_id:value_type(uint64)
 
 See also:
 
-- [`block_stats` pipe](#block_stats-pipe)
-- [`query_stats` pipe](#query_stats-pipe)
-- [Logical filter](#logical-filter)
+- [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe)
+- [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe)
+- [Logical filter](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter)
 
 ### eq_field filter
 
@@ -1408,13 +1468,13 @@ For example, the following query matches logs with identical values at `user_id`
 user_id:eq_field(customer_id)
 ```
 
-Quick tip: use `NOT user_id:eq_field(customer_id)` for finding logs where `user_id` isn't equal to `customer_id`. It uses [`NOT` logical operator](#logical-filter).
+Quick tip: use `NOT user_id:eq_field(customer_id)` for finding logs where `user_id` isn't equal to `customer_id`. It uses [`NOT` logical operator](https://docs.victoriametrics.com/victorialogs/logsql/#logical-filter).
 
 See also:
 
-- [`exact` filter](#exact-filter)
-- [`le_field` filter](#le_field-filter)
-- [`lt_field` filter](#lt_field-filter)
+- [`exact` filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
+- [`le_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#le_field-filter)
+- [`lt_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#lt_field-filter)
 
 ### le_field filter
 
@@ -1431,9 +1491,9 @@ Quick tip: use `NOT duration:le_field(max_duration)` for finding logs where `dur
 
 See also:
 
-- [range comparison filter](#range-comparison-filter)
-- [`lt_field` filter](#lt_field-filter)
-- [`eq_field` filter](#eq_field-filter)
+- [range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter)
+- [`lt_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#lt_field-filter)
+- [`eq_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#eq_field-filter)
 
 ### lt_field filter
 
@@ -1450,27 +1510,27 @@ Quick tip: use `NOT duration:lt_field(max_duration)` for finding logs where `dur
 
 See also:
 
-- [range comparison filter](#range-comparison-filter)
-- [`le_field` filter](#le_field-filter)
-- [`eq_field` filter](#eq_field-filter)
+- [range comparison filter](https://docs.victoriametrics.com/victorialogs/logsql/#range-comparison-filter)
+- [`le_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#le_field-filter)
+- [`eq_field` filter](https://docs.victoriametrics.com/victorialogs/logsql/#eq_field-filter)
 
 ### Logical filter
 
-Basic LogsQL [filters](#filters) can be combined into more complex filters with the following logical operations:
+Basic LogsQL [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) can be combined into more complex filters with the following logical operations:
 
-- `q1 AND q2` - matches common log entries returned by both `q1` and `q2`. Arbitrary number of [filters](#filters) can be combined with `AND` operation.
+- `q1 AND q2` - matches common log entries returned by both `q1` and `q2`. Arbitrary number of [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) can be combined with `AND` operation.
   For example, `error AND file AND app` matches [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
-  which simultaneously contain `error`, `file` and `app` [words](#word).
+  which simultaneously contain `error`, `file` and `app` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word).
   The `AND` operation is frequently used in LogsQL queries, so it is allowed to skip the `AND` word.
-  For example, `error file app` is equivalent to `error AND file AND app`. See also [`contains_all` filter](#contains_all-filter).
+  For example, `error file app` is equivalent to `error AND file AND app`. See also [`contains_all` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_all-filter).
 
-- `q1 OR q2` - merges log entries returned by both `q1` and `q2`. Arbitrary number of [filters](#filters) can be combined with `OR` operation.
+- `q1 OR q2` - merges log entries returned by both `q1` and `q2`. Arbitrary number of [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) can be combined with `OR` operation.
   For example, `error OR warning OR info` matches [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
-  which contain at least one of `error`, `warning` or `info` [words](#word). See also [`contains_any` filter](#contains_any-filter).
+  which contain at least one of `error`, `warning` or `info` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word). See also [`contains_any` filter](https://docs.victoriametrics.com/victorialogs/logsql/#contains_any-filter).
 
 - `NOT q` - returns all the log entries except of those which match `q`. For example, `NOT info` returns all the
   [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
-  which do not contain `info` [word](#word). The `NOT` operation is frequently used in LogsQL queries, so it is allowed substituting `NOT` with `-` and `!` in queries.
+  which do not contain `info` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word). The `NOT` operation is frequently used in LogsQL queries, so it is allowed substituting `NOT` with `-` and `!` in queries.
   For example, `-info` and `!info` are equivalent to `NOT info`.
   The `!` must be used instead of `-` in front of [`=`](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter)
   and [`~`](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) filters like `!=` and `!~`.
@@ -1478,9 +1538,9 @@ Basic LogsQL [filters](#filters) can be combined into more complex filters with
 The `NOT` operation has the highest priority, `AND` has the middle priority and `OR` has the lowest priority.
 The priority order can be changed with parentheses. For example, `NOT info OR debug` is interpreted as `(NOT info) OR debug`,
 so it matches [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
-which do not contain `info` [word](#word), while it also matches messages with `debug` word (which may contain the `info` word).
+which do not contain `info` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word), while it also matches messages with `debug` word (which may contain the `info` word).
 This is not what most users expect. In this case the query can be rewritten to `NOT (info OR debug)`,
-which correctly returns log messages without `info` and `debug` [words](#word).
+which correctly returns log messages without `info` and `debug` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word).
 
 LogsQL supports arbitrary complex logical queries with arbitrary mix of `AND`, `OR` and `NOT` operations and parentheses.
 
@@ -1500,20 +1560,20 @@ For example, `log.level:error OR log.level:warning OR log.level:info` can be sub
 Performance tips:
 
 - VictoriaLogs executes logical operations from the left to the right, so it is recommended moving the most specific
-  and the fastest filters (such as [word filter](#word-filter) and [phrase filter](#phrase-filter)) to the left,
-  while moving less specific and the slowest filters (such as [regexp filter](#regexp-filter) and [case-insensitive filter](#case-insensitive-filter))
+  and the fastest filters (such as [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)) to the left,
+  while moving less specific and the slowest filters (such as [regexp filter](https://docs.victoriametrics.com/victorialogs/logsql/#regexp-filter) and [case-insensitive filter](https://docs.victoriametrics.com/victorialogs/logsql/#case-insensitive-filter))
   to the right. For example, if you need to find [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
   with the `error` word, which match some `/foo/(bar|baz)` regexp,
   it is better from performance PoV to use the query `error ~"/foo/(bar|baz)"` instead of `~"/foo/(bar|baz)" error`.
 
   The most specific filter means that it matches the lowest number of log entries comparing to other filters.
 
-- See [other performance tips](#performance-tips).
+- See [other performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
 
 ## Pipes
 
-Additionally to [filters](#filters), LogsQL query may contain arbitrary mix of '|'-delimited actions known as `pipes`.
-For example, the following query uses [`stats`](#stats-pipe), [`sort`](#sort-pipe) and [`limit`](#limit-pipe) pipes
+Additionally to [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters), LogsQL query may contain arbitrary mix of '|'-delimited actions known as `pipes`.
+For example, the following query uses [`stats`](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe), [`sort`](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) and [`limit`](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe) pipes
 for returning top 10 [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 with the biggest number of logs during the last 5 minutes:
 
@@ -1523,58 +1583,58 @@ _time:5m | stats by (_stream) count() per_stream_logs | sort by (per_stream_logs
 
 LogsQL supports the following pipes:
 
-- [`block_stats`](#block_stats-pipe) returns various stats for the selected blocks with logs.
-- [`blocks_count`](#blocks_count-pipe) counts the number of blocks with logs processed by the query.
-- [`collapse_nums`](#collapse_nums-pipe) replaces all the decimal and hexadecimal numbers with `<N>` in the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`copy`](#copy-pipe) copies [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`decolorize`](#decolorize-pipe) drops [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`delete`](#delete-pipe) deletes [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`drop_empty_fields`](#drop_empty_fields-pipe) drops [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with empty values.
-- [`extract`](#extract-pipe) extracts the specified text into the given log fields.
-- [`extract_regexp`](#extract_regexp-pipe) extracts the specified text into the given log fields via [RE2 regular expressions](https://github.com/google/re2/wiki/Syntax).
-- [`facets`](#facets-pipe) returns the most frequently seen [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) across the selected logs.
-- [`field_names`](#field_names-pipe) returns all the names of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`field_values`](#field_values-pipe) returns all the values for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`fields`](#fields-pipe) selects the given set of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`filter`](#filter-pipe) applies additional [filters](#filters) to results.
-- [`first`](#first-pipe) returns the first N logs after sorting them by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`format`](#format-pipe) formats output field from input [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`generate_sequence`](#generate_sequence-pipe) generates output logs with messages containing integer sequence.
-- [`join`](#join-pipe) joins query results by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`json_array_len`](#json_array_len-pipe) returns the length of JSON array stored at the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`hash`](#hash-pipe) returns the hash over the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) value.
-- [`last`](#last-pipe) returns the last N logs after sorting them by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`len`](#len-pipe) returns byte length of the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) value.
-- [`limit`](#limit-pipe) limits the number selected logs.
-- [`math`](#math-pipe) performs mathematical calculations over [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`offset`](#offset-pipe) skips the given number of selected logs.
-- [`pack_json`](#pack_json-pipe) packs [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into JSON object.
-- [`pack_logfmt`](#pack_logfmt-pipe) packs [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into [logfmt](https://brandur.org/logfmt) message.
-- [`query_stats`](#query_stats-pipe) returns query execution statistics.
-- [`rename`](#rename-pipe) renames [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`replace`](#replace-pipe) replaces substrings in the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`replace_regexp`](#replace_regexp-pipe) updates [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with regular expressions.
-- [`running_stats`](#running_stats-pipe) performs running stats calculations over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`sample`](#sample-pipe) returns a sample of the matching logs according to the provided `sample` value.
-- [`sort`](#sort-pipe) sorts logs by the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`split`](#split-pipe) splits the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into tokens by the given separator.
-- [`stats`](#stats-pipe) calculates various stats over the selected logs.
-- [`stream_context`](#stream_context-pipe) allows selecting surrounding logs in front and after the matching logs
+- [`block_stats`](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe) returns various stats for the selected blocks with logs.
+- [`blocks_count`](https://docs.victoriametrics.com/victorialogs/logsql/#blocks_count-pipe) counts the number of blocks with logs processed by the query.
+- [`collapse_nums`](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe) replaces all the decimal and hexadecimal numbers with `<N>` in the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`copy`](https://docs.victoriametrics.com/victorialogs/logsql/#copy-pipe) copies [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`decolorize`](https://docs.victoriametrics.com/victorialogs/logsql/#decolorize-pipe) drops [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`delete`](https://docs.victoriametrics.com/victorialogs/logsql/#delete-pipe) deletes [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`drop_empty_fields`](https://docs.victoriametrics.com/victorialogs/logsql/#drop_empty_fields-pipe) drops [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with empty values.
+- [`extract`](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) extracts the specified text into the given log fields.
+- [`extract_regexp`](https://docs.victoriametrics.com/victorialogs/logsql/#extract_regexp-pipe) extracts the specified text into the given log fields via [RE2 regular expressions](https://github.com/google/re2/wiki/Syntax).
+- [`facets`](https://docs.victoriametrics.com/victorialogs/logsql/#facets-pipe) returns the most frequently seen [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) across the selected logs.
+- [`field_names`](https://docs.victoriametrics.com/victorialogs/logsql/#field_names-pipe) returns all the names of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`field_values`](https://docs.victoriametrics.com/victorialogs/logsql/#field_values-pipe) returns all the values for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`fields`](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) selects the given set of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`filter`](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe) applies additional [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) to results.
+- [`first`](https://docs.victoriametrics.com/victorialogs/logsql/#first-pipe) returns the first N logs after sorting them by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`format`](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe) formats output field from input [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`generate_sequence`](https://docs.victoriametrics.com/victorialogs/logsql/#generate_sequence-pipe) generates output logs with messages containing integer sequence.
+- [`join`](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe) joins query results by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`json_array_len`](https://docs.victoriametrics.com/victorialogs/logsql/#json_array_len-pipe) returns the length of JSON array stored at the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`hash`](https://docs.victoriametrics.com/victorialogs/logsql/#hash-pipe) returns the hash over the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) value.
+- [`last`](https://docs.victoriametrics.com/victorialogs/logsql/#last-pipe) returns the last N logs after sorting them by the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`len`](https://docs.victoriametrics.com/victorialogs/logsql/#len-pipe) returns byte length of the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) value.
+- [`limit`](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe) limits the number selected logs.
+- [`math`](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe) performs mathematical calculations over [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`offset`](https://docs.victoriametrics.com/victorialogs/logsql/#offset-pipe) skips the given number of selected logs.
+- [`pack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#pack_json-pipe) packs [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into JSON object.
+- [`pack_logfmt`](https://docs.victoriametrics.com/victorialogs/logsql/#pack_logfmt-pipe) packs [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into [logfmt](https://brandur.org/logfmt) message.
+- [`query_stats`](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe) returns query execution statistics.
+- [`rename`](https://docs.victoriametrics.com/victorialogs/logsql/#rename-pipe) renames [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`replace`](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe) replaces substrings in the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`replace_regexp`](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe) updates [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with regular expressions.
+- [`running_stats`](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe) performs running stats calculations over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`sample`](https://docs.victoriametrics.com/victorialogs/logsql/#sample-pipe) returns a sample of the matching logs according to the provided `sample` value.
+- [`sort`](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) sorts logs by the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`split`](https://docs.victoriametrics.com/victorialogs/logsql/#split-pipe) splits the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into tokens by the given separator.
+- [`stats`](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) calculates various stats over the selected logs.
+- [`stream_context`](https://docs.victoriametrics.com/victorialogs/logsql/#stream_context-pipe) allows selecting surrounding logs in front and after the matching logs
   per each [log stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
-- [`time_add`](#time_add-pipe) adds the given duration to the given field containing [RFC3339 time](https://www.rfc-editor.org/rfc/rfc3339).
-- [`top`](#top-pipe) returns top `N` field sets with the maximum number of matching logs.
-- [`total_stats`](#total_stats-pipe) performs total (global) stats calculations over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`union`](#union-pipe) returns results from multiple LogsQL queries.
-- [`uniq`](#uniq-pipe) returns unique log entries.
-- [`unpack_json`](#unpack_json-pipe) unpacks JSON messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`unpack_logfmt`](#unpack_logfmt-pipe) unpacks [logfmt](https://brandur.org/logfmt) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`unpack_syslog`](#unpack_syslog-pipe) unpacks [syslog](https://en.wikipedia.org/wiki/Syslog) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`unpack_words`](#unpack_words-pipe) unpacks [words](#word) from the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`unroll`](#unroll-pipe) unrolls JSON arrays from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into separate rows.
+- [`time_add`](https://docs.victoriametrics.com/victorialogs/logsql/#time_add-pipe) adds the given duration to the given field containing [RFC3339 time](https://www.rfc-editor.org/rfc/rfc3339).
+- [`top`](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe) returns top `N` field sets with the maximum number of matching logs.
+- [`total_stats`](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe) performs total (global) stats calculations over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`union`](https://docs.victoriametrics.com/victorialogs/logsql/#union-pipe) returns results from multiple LogsQL queries.
+- [`uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe) returns unique log entries.
+- [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) unpacks JSON messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`unpack_logfmt`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe) unpacks [logfmt](https://brandur.org/logfmt) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`unpack_syslog`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe) unpacks [syslog](https://en.wikipedia.org/wiki/Syslog) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`unpack_words`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_words-pipe) unpacks [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) from the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`unroll`](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe) unrolls JSON arrays from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) into separate rows.
 
 ### block_stats pipe
 
-`<q> | block_stats` [pipe](#pipes) returns the following stats per each block processed by `<q>` [query](#query-syntax):
+`<q> | block_stats` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns the following stats per each block processed by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax):
 
 - `field` - [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) name
 - `rows` - the number of rows at the given `field`
@@ -1589,25 +1649,25 @@ The `block_stats` pipe is needed mostly for debugging purposes.
 
 See also:
 
-- [`query_stats` pipe](#query_stats-pipe)
-- [`value_type` filter](#value_type-filter)
-- [`blocks_count` pipe](#blocks_count-pipe)
-- [`len` pipe](#len-pipe)
+- [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe)
+- [`value_type` filter](https://docs.victoriametrics.com/victorialogs/logsql/#value_type-filter)
+- [`blocks_count` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#blocks_count-pipe)
+- [`len` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#len-pipe)
 
 ### blocks_count pipe
 
-`<q> | blocks_count` [pipe](#pipes) counts the number of blocks with logs processed by `<q>`. This pipe is needed mostly for debugging.
+`<q> | blocks_count` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) counts the number of blocks with logs processed by `<q>`. This pipe is needed mostly for debugging.
 
 See also:
 
-- [`query_stats` pipe](#query_stats-pipe)
-- [`block_stats` pipe](#block_stats-pipe)
-- [`len` pipe](#len-pipe)
+- [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe)
+- [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe)
+- [`len` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#len-pipe)
 
 ### collapse_nums pipe
 
 `<q> | collapse_nums at <field>` pipe replaces all the decimal and hexadecimal numbers at the given [`<field>`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-returned by the `<q>` [query](#query-syntax) with `<N>` placeholder.
+returned by the `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) with `<N>` placeholder.
 For example, if the `_msg` field contains `2024-10-20T12:34:56Z request duration 1.34s`, then it is replaced with `<N>-<N>-<N>T<N>:<N>:<N>Z request duration <N>.<N>s` by the following query:
 
 ```logsql
@@ -1623,7 +1683,7 @@ _time:5m | collapse_nums
 
 This functionality is useful for locating the most frequently seen log patterns across log messages with various decimal and hexadecimal numbers.
 This includes the following entities: timestamps, ip addresses, request durations, response sizes, [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier), trace IDs, user IDs, etc.
-Log messages with such entities become identical after applying `collapse_nums` pipe to them, so the [`top` pipe](#top-pipe) can be applied to them in order to get the most frequently
+Log messages with such entities become identical after applying `collapse_nums` pipe to them, so the [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe) can be applied to them in order to get the most frequently
 seen patterns across log messages. For example, the following query returns top 5 the most frequently seen log patterns across log messages for the last hour:
 
 ```logsql
@@ -1646,23 +1706,23 @@ when the following query is executed:
 _time:1h | collapse_nums prettify
 ```
 
-The patterns returned by `collapse_nums prettify` pipe can be used in [pattern match filter](#pattern-match-filter).
+The patterns returned by `collapse_nums prettify` pipe can be used in [pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter).
 
-`collapse_nums` can miss some numbers or can collapse unexpected numbers. In this case [conditional `collapse_nums`](#conditional-collapse_nums) can be used
-for skipping such values and pre-processing them separately with [`replace_regexp`](#replace_regexp-pipe).
+`collapse_nums` can miss some numbers or can collapse unexpected numbers. In this case [conditional `collapse_nums`](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-collapse_nums) can be used
+for skipping such values and pre-processing them separately with [`replace_regexp`](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe).
 
 See also:
 
-- [conditional `collapse_nums`](#conditional-collapse_nums)
-- [pattern match filter](#pattern-match-filter)
-- [`replace`](#replace-pipe)
-- [`replace_regexp`](#replace_regexp-pipe)
+- [conditional `collapse_nums`](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-collapse_nums)
+- [pattern match filter](https://docs.victoriametrics.com/victorialogs/logsql/#pattern-match-filter)
+- [`replace`](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe)
+- [`replace_regexp`](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe)
 
 #### Conditional collapse_nums
 
-If the [`collapse_nums` pipe](#collapse_nums-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`collapse_nums` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `collapse_nums`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query collapses nums in the `foo` field only if `user_type` field equals to `admin`:
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query collapses nums in the `foo` field only if `user_type` field equals to `admin`:
 
 ```logsql
 _time:5m | collapse_nums if (user_type:=admin) at foo
@@ -1670,7 +1730,7 @@ _time:5m | collapse_nums if (user_type:=admin) at foo
 
 ### copy pipe
 
-If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be copied, then `| copy src1 as dst1, ..., srcN as dstN` [pipe](#pipes) can be used.
+If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be copied, then `| copy src1 as dst1, ..., srcN as dstN` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used.
 For example, the following query copies `host` field to `server` for logs over the last 5 minutes, so the output contains both `host` and `server` fields:
 
 ```logsql
@@ -1698,14 +1758,14 @@ _time:5m | copy foo* as bar*
 
 See also:
 
-- [`rename` pipe](#rename-pipe)
-- [`fields` pipe](#fields-pipe)
-- [`delete` pipe](#delete-pipe)
+- [`rename` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#rename-pipe)
+- [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe)
+- [`delete` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#delete-pipe)
 
 ### decolorize pipe
 
-`<q> | decolorize <field>` [pipe](#pipes) drops [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
-from the given [`<field>`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) across all the logs returned by [`<q>` query](#query-syntax).
+`<q> | decolorize <field>` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) drops [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
+from the given [`<field>`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) across all the logs returned by [`<q>` query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 The `<field>` may be omitted if ANSI color codes must be dropped from the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field).
 For example, the following query drops ANSI color codes from all the `_msg` fields over the logs for the last 5 minutes:
@@ -1725,12 +1785,12 @@ This simplifies further querying of the logs without the need to apply `| decolo
 
 See also:
 
-- [`replace` pipe](#replace-pipe)
-- [`replace_regexp` pipe](#replace_regexp-pipe)
+- [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe)
+- [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe)
 
 ### delete pipe
 
-If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be deleted, then `| delete field1, ..., fieldN` [pipe](#pipes) can be used.
+If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be deleted, then `| delete field1, ..., fieldN` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used.
 For example, the following query deletes `host` and `app` fields from the logs over the last 5 minutes:
 
 ```logsql
@@ -1747,15 +1807,15 @@ _time:5m | delete foo*
 
 See also:
 
-- [`rename` pipe](#rename-pipe)
-- [`fields` pipe](#fields-pipe)
+- [`rename` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#rename-pipe)
+- [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe)
 
 ### drop_empty_fields pipe
 
-`<q> | drop_empty_fields` pipe drops [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with empty values from results returned by `<q>` [query](#query-syntax).
+`<q> | drop_empty_fields` pipe drops [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with empty values from results returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 It also skips log entries with zero non-empty fields.
 
-For example, the following query drops possible empty `email` field generated by [`extract` pipe](#extract-pipe) if the `foo` field doesn't contain email:
+For example, the following query drops possible empty `email` field generated by [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) if the `foo` field doesn't contain email:
 
 ```logsql
 _time:5m | extract 'email: <email>,' from foo | drop_empty_fields
@@ -1763,20 +1823,20 @@ _time:5m | extract 'email: <email>,' from foo | drop_empty_fields
 
 See also:
 
-- [`filter` pipe](#filter-pipe)
-- [`extract` pipe](#extract-pipe)
+- [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
 
 ### extract pipe
 
-`<q> | extract "pattern" from field_name` [pipe](#pipes) extracts text into output fields according to the [`pattern`](#format-for-extract-pipe-pattern) from the given
-[`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](#query-syntax).
+`<q> | extract "pattern" from field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) extracts text into output fields according to the [`pattern`](https://docs.victoriametrics.com/victorialogs/logsql/#format-for-extract-pipe-pattern) from the given
+[`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 Existing log fields remain unchanged after the `| extract ...` pipe.
 
-`extract` pipe can be useful for extracting additional fields needed for further data processing with other pipes such as [`stats` pipe](#stats-pipe) or [`sort` pipe](#sort-pipe).
+`extract` pipe can be useful for extracting additional fields needed for further data processing with other pipes such as [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) or [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe).
 
-For example, the following query selects logs with the `error` [word](#word) for the last day,
+For example, the following query selects logs with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) for the last day,
 extracts ip address from [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) into `ip` field and then calculates top 10 ip addresses
-with the biggest number of logs using [`top` pipe](#top-pipe):
+with the biggest number of logs using [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe):
 
 ```logsql
 _time:1d error | extract "ip=<ip> " from _msg | top 10 (ip)
@@ -1814,22 +1874,22 @@ For example, the following query preserves the original `ip` field value if `foo
 _time:5m | extract 'ip=<ip> ' from foo skip_empty_results
 ```
 
-Performance tip: it is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `extract`.
-See [general performance tips](#performance-tips) for details.
+Performance tip: it is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `extract`.
+See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Format for extract pipe pattern](#format-for-extract-pipe-pattern)
-- [Conditional extract](#conditional-extract)
-- [`extract_regexp` pipe](#extract_regexp-pipe)
-- [`unpack_json` pipe](#unpack_json-pipe)
-- [`unpack_logfmt` pipe](#unpack_logfmt-pipe)
-- [`split` pipe](#split-pipe)
-- [`math` pipe](#math-pipe)
+- [Format for extract pipe pattern](https://docs.victoriametrics.com/victorialogs/logsql/#format-for-extract-pipe-pattern)
+- [Conditional extract](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-extract)
+- [`extract_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract_regexp-pipe)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
+- [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe)
+- [`split` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#split-pipe)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
 
 #### Format for extract pipe pattern
 
-The `pattern` part from [`extract` pipe](#extract-pipe) has the following format:
+The `pattern` part from [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) has the following format:
 
 ```
 text1<field1>text2<field2>...textN<fieldN>textN+1
@@ -1845,7 +1905,7 @@ the corresponding matching substring to.
 Matching starts from the first occurrence of the `text1` in the input text. If the `pattern` starts with `<field1>` and doesn't contain `text1`,
 then the matching starts from the beginning of the input text. Matching is performed sequentially according to the `pattern`. If some `textX` isn't found
 in the remaining input text, then the remaining named placeholders receive empty string values and the matching finishes prematurely.
-The empty string values can be dropped with [`drop_empty_fields` pipe](#drop_empty_fields-pipe).
+The empty string values can be dropped with [`drop_empty_fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#drop_empty_fields-pipe).
 
 Matching finishes successfully when `textN+1` is found in the input text.
 If the `pattern` ends with `<fieldN>` and doesn't contain `textN+1`, then the `<fieldN>` matches the remaining input text.
@@ -1865,7 +1925,7 @@ Then the following `pattern` can be used for extracting `ip`, `path` and `user_a
 Note that the user-agent part of the log message is in double quotes. This means that it may contain special chars, including escaped double quote, e.g. `\"`.
 This may break proper matching of the string in double quotes.
 
-VictoriaLogs automatically detects quoted strings and automatically unquotes them if the first matching char in the placeholder is double quote or backtick.
+VictoriaLogs automatically detects quoted strings and automatically unquotes them if the first matching char in the placeholder is a single quote, double quote or a backtick.
 So it is better to use the following `pattern` for proper matching of quoted `user_agent` string:
 
 ```
@@ -1894,8 +1954,8 @@ For example, the following `pattern` properly matches `a < b` text by extracting
 
 #### Conditional extract
 
-If some log entries must be skipped from [`extract` pipe](#extract-pipe), then add `if (<filters>)` filter after the `extract` word.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query extracts `ip` field
+If some log entries must be skipped from [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe), then add `if (<filters>)` filter after the `extract` word.
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query extracts `ip` field
 from [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) only
 if the input [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) doesn't contain `ip` field or this field is empty:
 
@@ -1912,8 +1972,8 @@ _time:5m | extract "ip=<ip> " keep_original_fields
 
 ### extract_regexp pipe
 
-`<q> | extract_regexp "pattern" from field_name` [pipe](#pipes) extracts substrings from the [`field_name` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-returned from `<q>` [query](#query-syntax) according to the provided `pattern`, and stores them into field names according to the named fields inside the `pattern`.
+`<q> | extract_regexp "pattern" from field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) extracts substrings from the [`field_name` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+returned from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) according to the provided `pattern`, and stores them into field names according to the named fields inside the `pattern`.
 The `pattern` must contain [RE2 regular expression](https://github.com/google/re2/wiki/Syntax) with named fields (aka capturing groups) in the form `(?P<capture_field_name>...)`.
 Matching substrings are stored to the given `capture_field_name` [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 For example, the following query extracts ipv4 addresses from [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
@@ -1945,19 +2005,19 @@ For example, the following query preserves the original `ip` field value if `foo
 _time:5m | extract_regexp 'ip=(?P<ip>([0-9]+[.]){3}[0-9]+)' from foo skip_empty_results
 ```
 
-Performance tip: it is recommended using [`extract` pipe](#extract-pipe) instead of `extract_regexp` for achieving higher query performance.
+Performance tip: it is recommended using [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) instead of `extract_regexp` for achieving higher query performance.
 
 See also:
 
-- [Conditional `extract_regexp`](#conditional-extract_regexp)
-- [`extract` pipe](#extract-pipe)
-- [`replace_regexp` pipe](#replace_regexp-pipe)
-- [`unpack_json` pipe](#unpack_json-pipe)
+- [Conditional `extract_regexp`](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-extract_regexp)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+- [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
 
 #### Conditional extract_regexp
 
-If some log entries must be skipped from [`extract_regexp` pipe](#extract-pipe), then add `if (<filters>)` filter after the `extract` word.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query extracts `ip`
+If some log entries must be skipped from [`extract_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe), then add `if (<filters>)` filter after the `extract` word.
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query extracts `ip`
 from [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) only
 if the input [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) doesn't contain `ip` field or this field is empty:
 
@@ -1974,17 +2034,17 @@ _time:5m | extract_regexp "ip=(?P<ip>([0-9]+[.]){3}[0-9]+)" keep_original_fields
 
 ### facets pipe
 
-`<q> | facets` [pipe](#pipes) returns the most frequent values per every seen [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-returned by `<q>` [query](#query-syntax). It also returns an estimated number of hits per every returned `field=value` pair.
+`<q> | facets` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns the most frequent values per every seen [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax). It also returns an estimated number of hits per every returned `field=value` pair.
 
-For example, the following query returns the most frequent values per every seen log field across logs with the `error` [word](#word) over the last hour:
+For example, the following query returns the most frequent values per every seen log field across logs with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) over the last hour:
 
 ```logsql
 _time:1h error | facets
 ```
 
 It is possible specifying the number of most frequently seen values to return per each log field by using `facets N` syntax. For example,
-the following query returns up to 3 most frequently seen values per each field across logs with the `error` [word](#word) over the last hour:
+the following query returns up to 3 most frequently seen values per each field across logs with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) over the last hour:
 
 ```logsql
 _time:1h error | facets 3
@@ -2014,14 +2074,14 @@ _time:1h error | facets keep_const_fields
 
 See also:
 
-- [`top`](#top-pipe)
-- [`field_names`](#field_names-pipe)
-- [`field_values`](#field_values-pipe)
+- [`top`](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)
+- [`field_names`](https://docs.victoriametrics.com/victorialogs/logsql/#field_names-pipe)
+- [`field_values`](https://docs.victoriametrics.com/victorialogs/logsql/#field_values-pipe)
 
 ### field_names pipe
 
-`<q> | field_names` [pipe](#pipes) returns all the names of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-with an estimated number of logs per each field name returned from `<q>` [query](#query-syntax).
+`<q> | field_names` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns all the names of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+with an estimated number of logs per each field name returned from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query returns all the field names with the number of matching logs over the last 5 minutes:
 
@@ -2029,18 +2089,18 @@ For example, the following query returns all the field names with the number of
 _time:5m | field_names
 ```
 
-Field names are returned in arbitrary order. Use [`sort` pipe](#sort-pipe) in order to sort them if needed.
+Field names are returned in arbitrary order. Use [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) in order to sort them if needed.
 
 See also:
 
-- [`field_values` pipe](#field_values-pipe)
-- [`facets` pipe](#facets-pipe)
-- [`uniq` pipe](#uniq-pipe)
+- [`field_values` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#field_values-pipe)
+- [`facets` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#facets-pipe)
+- [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe)
 
 ### field_values pipe
 
-`<q> | field_values field_name` [pipe](#pipes) returns all the values for the given [`field_name` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-with the number of logs per each value returned from `<q>` [query](#query-syntax).
+`<q> | field_values field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns all the values for the given [`field_name` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+with the number of logs per each value returned from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 For example, the following query returns all the values with the number of matching logs for the field `level` over logs for the last 5 minutes:
 
 ```logsql
@@ -2058,15 +2118,15 @@ If the limit is reached, then the set of returned values is random. Also the num
 
 See also:
 
-- [`field_names` pipe](#field_names-pipe)
-- [`facets` pipe](#facets-pipe)
-- [`top` pipe](#top-pipe)
-- [`uniq` pipe](#uniq-pipe)
+- [`field_names` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#field_names-pipe)
+- [`facets` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#facets-pipe)
+- [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)
+- [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe)
 
 ### fields pipe
 
 By default all the [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) are returned in the response.
-It is possible to select the given set of log fields with `| fields field1, ..., fieldN` [pipe](#pipes). For example, the following query selects only `host`
+It is possible to select the given set of log fields with `| fields field1, ..., fieldN` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes). For example, the following query selects only `host`
 and [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) fields from logs for the last 5 minutes:
 
 ```logsql
@@ -2088,16 +2148,16 @@ _time:5m | fields foo*
 
 See also:
 
-- [`copy` pipe](#copy-pipe)
-- [`rename` pipe](#rename-pipe)
-- [`delete` pipe](#delete-pipe)
+- [`copy` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#copy-pipe)
+- [`rename` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#rename-pipe)
+- [`delete` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#delete-pipe)
 
 ### filter pipe
 
-The `<q> | filter ...` [pipe](#pipes) filters logs returned by `<q>` [query](#query-syntax) with the given [filter](#filters).
+The `<q> | filter ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) filters logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) with the given [filter](https://docs.victoriametrics.com/victorialogs/logsql/#filters).
 
 For example, the following query returns `host` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values
-if the number of log messages with the `error` [word](#word) for them over the last hour exceeds `1_000`:
+if the number of log messages with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) for them over the last hour exceeds `1_000`:
 
 ```logsql
 _time:1h error | stats by (host) count() logs_count | filter logs_count:> 1_000
@@ -2109,7 +2169,7 @@ It is allowed to use `where` prefix instead of `filter` prefix for convenience.
 _time:1h error | stats by (host) count() logs_count | where logs_count:> 1_000
 ```
 
-It is allowed to omit `filter` prefix if the used filters do not clash with [pipe names](#pipes).
+It is allowed to omit `filter` prefix if the used filters do not clash with [pipe names](https://docs.victoriametrics.com/victorialogs/logsql/#pipes).
 So the following query is equivalent to the previous one:
 
 ```logsql
@@ -2118,12 +2178,12 @@ _time:1h error | stats by (host) count() logs_count | logs_count:> 1_000
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 ### first pipe
 
-`<q> | first N by (fields)` [pipe](#pipes) returns the first `N` logs from `<q>` [query](#query-syntax) after sorting them
+`<q> | first N by (fields)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns the first `N` logs from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) after sorting them
 by the given [`fields`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the first 10 logs with the smallest value of `request_duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -2143,13 +2203,13 @@ _time:1h | first 3 by (request_duration) partition by (host)
 
 See also:
 
-- [`last` pipe](#last-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`last` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#last-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 ### format pipe
 
-`<q> | format "pattern" as result_field` [pipe](#pipes) combines [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-from `<q>` [query](#query-syntax) results according to the `pattern` and stores it into `result_field`.
+`<q> | format "pattern" as result_field` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) combines [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results according to the `pattern` and stores it into `result_field`.
 
 For example, the following query stores `request from <ip>:<port>` text into [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field),
 by substituting `<ip>` and `<port>` with the corresponding [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values:
@@ -2167,7 +2227,7 @@ _time:5m | format "request from <ip>:<port>"
 
 String fields can be formatted with the following additional formatting rules:
 
-- The number of seconds in the [duration value](#duration-values) - add `duration_seconds:` in front of the corresponding field name.
+- The number of seconds in the [duration value](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values) - add `duration_seconds:` in front of the corresponding field name.
   The formatted number is fractional if the duration value contains non-zero milliseconds, microseconds or nanoseconds.
 
 - JSON-compatible quoted string - add `q:` in front of the corresponding field name.
@@ -2217,7 +2277,7 @@ Numeric fields can be transformed into the following string representation at `f
   For example, `format "time=<time:timestamp>"`.
 
 - Human-readable duration - by adding `duration:` in front of the corresponding numeric field name containing duration in nanoseconds.
-  For example, `format "duration=<duration:duration_nsecs>"`. The duration can be converted into nanoseconds with the [`math` pipe](#math-pipe).
+  For example, `format "duration=<duration:duration_nsecs>"`. The duration can be converted into nanoseconds with the [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe).
 
 - IPv4 - by adding `ipv4:` in front of the corresponding field name containing `uint32` representation of the IPv4 address.
   For example, `format "ip=<ipv4:ip_num>"`.
@@ -2238,21 +2298,21 @@ when at least `field1` or `field2` aren't empty, while preserving the original `
 _time:5m | format "<field1><field2>" as foo skip_empty_results
 ```
 
-Performance tip: it is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `format`.
-See [general performance tips](#performance-tips) for details.
+Performance tip: it is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `format`.
+See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional format](#conditional-format)
-- [`replace` pipe](#replace-pipe)
-- [`replace_regexp` pipe](#replace_regexp-pipe)
-- [`extract` pipe](#extract-pipe)
+- [Conditional format](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-format)
+- [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe)
+- [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
 
 #### Conditional format
 
-If the [`format` pipe](#format-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` just after the `format` word.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query stores the formatted result to `message` field
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query stores the formatted result to `message` field
 only if `ip` and `host` [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) aren't empty:
 
 ```logsql
@@ -2261,7 +2321,7 @@ _time:5m | format if (ip:* and host:*) "request from <ip>:<host>" as message
 
 ### generate_sequence pipe
 
-The `<q> | generate_sequence <N>` [pipe](#pipes) skips all the `<q>` results and generates `<N>` output logs
+The `<q> | generate_sequence <N>` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) skips all the `<q>` results and generates `<N>` output logs
 with the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) containing integer sequence starting from 0 and ending at `N-1`.
 
 This pipe is useful for testing and debugging of the LogsQL pipes. For example, the following query generates 1000 random integers in the range `[0..9]`
@@ -2276,15 +2336,15 @@ and collects the statistics on the number of hits per each random number:
 
 See also:
 
-- [`rand()` function from `math` pipe](#math-pipe)
-- [`stats` pipe](#stats-pipe)
+- [`rand()` function from `math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
 
 ### join pipe
 
-The `<q1> | join by (<fields>) (<q2>)` [pipe](#pipes) joins `<q1>` [query](#query-syntax) results with the `<q2>` results by the given set of comma-separated `<fields>`.
+The `<q1> | join by (<fields>) (<q2>)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) joins `<q1>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results with the `<q2>` results by the given set of comma-separated `<fields>`.
 This pipe works in the following way:
 
-1. It executes the `<q2>` [query](#query-syntax) and remembers its' results.
+1. It executes the `<q2>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) and remembers its' results.
 1. For each input row from `<q1>` it searches for matching rows in the `<q2>` results by the given `<fields>`.
 1. If the `<q2>` results have no matching rows, then the input row is sent to the output as is.
 1. If the `<q2>` results have matching rows, then for each matching row the input row is extended
@@ -2328,18 +2388,18 @@ _time:1d {app="app1"} | stats by (user) count() app1_hits
 
 See also:
 
-- [subquery filter](#subquery-filter)
-- [`stats` pipe](#stats-pipe)
+- [subquery filter](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
 - [conditional `stats`](https://docs.victoriametrics.com/victorialogs/logsql/#stats-with-additional-filters)
-- [`filter` pipe](#filter-pipe)
+- [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe)
 
 ### json_array_len pipe
 
 `<q> | json_array_len(field) as result_field` calculates the length of JSON array at the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-and stores it into the `result_field`, for every log entry returned by `<q>` [query](#query-syntax).
+and stores it into the `result_field`, for every log entry returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query returns top 5 logs with contain [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
-with the biggest number of [words](#word) across all the logs for the last 5 minutes:
+with the biggest number of [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) across all the logs for the last 5 minutes:
 
 ```logsql
 _time:5m | unpack_words _msg as words | json_array_len (words) as words_count | first 5 (words_count desc)
@@ -2347,14 +2407,14 @@ _time:5m | unpack_words _msg as words | json_array_len (words) as words_count |
 
 See also:
 
-- [`len` pipe](#len-pipe)
-- [`unpack_words` pipe](#unpack_words-pipe)
-- [`first` pipe](#first-pipe)
+- [`len` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#len-pipe)
+- [`unpack_words` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_words-pipe)
+- [`first` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#first-pipe)
 
 ### hash pipe
 
 `<q> | hash(field) as result_field` calculates hash value for the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-and stores it into the `result_field`, for every log entry returned by `<q>` [query](#query-syntax).
+and stores it into the `result_field`, for every log entry returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query calculates the hash value over `user_id` field and stores it into `user_id_hash` field, across logs for the last 5 minutes:
 
@@ -2364,12 +2424,12 @@ _time:5m | hash(user_id) as user_id_hash
 
 See also:
 
-- [`math` pipe](#math-pipe)
-- [`filter` pipe](#filter-pipe)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
+- [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe)
 
 ### last pipe
 
-`<q> | last N by (fields)` [pipe](#pipes) returns the last `N` logs from `<q>` [query](#query-syntax) after sorting them
+`<q> | last N by (fields)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns the last `N` logs from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) after sorting them
 by the given [`fields`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the last 10 logs with the biggest value of `request_duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -2389,13 +2449,13 @@ _time:1h | last 3 by (request_duration) partition by (host)
 
 See also:
 
-- [`first` pipe](#first-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`first` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#first-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 ### len pipe
 
-`<q> | len(field) as result` [pipe](#pipes) stores byte length of the given `field` value into the `result` field
-across all the logs returned by `<q>` [query](#query-syntax).
+`<q> | len(field) as result` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) stores byte length of the given `field` value into the `result` field
+across all the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query shows top 5 log entries with the maximum byte length of `_msg` field across
 logs for the last 5 minutes:
@@ -2406,15 +2466,15 @@ _time:5m | len(_msg) as msg_len | sort by (msg_len desc) | limit 5
 
 See also:
 
-- [`json_array_len` pipe](#json_array_len-pipe)
-- [`sum_len` stats function](#sum_len-stats)
-- [`sort` pipe](#sort-pipe)
-- [`limit` pipe](#limit-pipe)
-- [`block_stats` pipe](#block_stats-pipe)
+- [`json_array_len` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#json_array_len-pipe)
+- [`sum_len` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#sum_len-stats)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
+- [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe)
+- [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe)
 
 ### limit pipe
 
-If only a subset of selected logs must be processed, then `| limit N` [pipe](#pipes) can be used, where `N` can contain any [supported integer numeric value](#numeric-values).
+If only a subset of selected logs must be processed, then `| limit N` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used, where `N` can contain any [supported integer numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values).
 For example, the following query returns up to 100 logs over the last 5 minutes:
 
 ```logsql
@@ -2430,18 +2490,18 @@ error | head
 ```
 
 By default rows are selected in arbitrary order because of performance reasons, so the query above can return different sets of logs every time it is executed.
-[`sort` pipe](#sort-pipe) can be used for making sure the logs are in the same order before applying `limit ...` to them.
+[`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) can be used for making sure the logs are in the same order before applying `limit ...` to them.
 
 See also:
 
-- [`sample` pipe](#sample-pipe)
-- [`sort` pipe](#sort-pipe)
-- [`offset` pipe](#offset-pipe)
+- [`sample` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sample-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
+- [`offset` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#offset-pipe)
 
 ### math pipe
 
-`<q> | math ...` [pipe](#pipes) performs mathematical calculations over [numeric values](#numeric-values) of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-returned by `<q>` [query](#query-syntax). It has the following format:
+`<q> | math ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) performs mathematical calculations over [numeric values](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values) of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax). It has the following format:
 
 ```
 | math
@@ -2473,7 +2533,7 @@ The following mathematical operations are supported by `math` pipe:
 - `arg1 & arg2` - returns bitwise `and` for `arg1` and `arg2`. It is expected that `arg1` and `arg2` are in the range `[0 .. 2^53-1]`
 - `arg1 or arg2` - returns bitwise `or` for `arg1` and `arg2`. It is expected that `arg1` and `arg2` are in the range `[0 .. 2^53-1]`
 - `arg1 xor arg2` - returns bitwise `xor` for `arg1` and `arg2`. It is expected that `arg1` and `arg2` are in the range `[0 .. 2^53-1]`
-- `arg1 default arg2` - returns `arg2` if `arg1` is non-[numeric](#numeric-values) or equals to `NaN`
+- `arg1 default arg2` - returns `arg2` if `arg1` is non-[numeric](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values) or equals to `NaN`
 - `abs(arg)` - returns an absolute value for the given `arg`
 - `ceil(arg)` - returns the least integer value greater than or equal to `arg`
 - `exp(arg)` - powers [`e`](https://en.wikipedia.org/wiki/E_(mathematical_constant)) by `arg`
@@ -2489,13 +2549,13 @@ The following mathematical operations are supported by `math` pipe:
 Every `argX` argument in every mathematical operation can contain one of the following values:
 
 - The name of [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). For example, `errors_total / requests_total`.
-  The log field is parsed into numeric value if it contains [supported numeric value](#numeric-values). The log field is parsed into [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time)
+  The log field is parsed into numeric value if it contains [supported numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values). The log field is parsed into [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time)
   in nanoseconds if it contains [rfc3339 time](https://www.rfc-editor.org/rfc/rfc3339). The log field is parsed into `uint32` number if it contains IPv4 address.
   The log field is parsed into `NaN` in other cases.
-- Any [supported numeric value](#numeric-values), [rfc3339 time](https://www.rfc-editor.org/rfc/rfc3339) or IPv4 address. For example, `1MiB`, `"2024-05-15T10:20:30.934324Z"` or `"12.34.56.78"`.
+- Any [supported numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values), [rfc3339 time](https://www.rfc-editor.org/rfc/rfc3339) or IPv4 address. For example, `1MiB`, `"2024-05-15T10:20:30.934324Z"` or `"12.34.56.78"`.
 - Another mathematical expression, which can be put inside `(...)`. For example, `(a + b) * c`.
 
-The parsed time, duration and IPv4 address can be converted back to string representation after math transformations with the help of [`format` pipe](#format-pipe). For example,
+The parsed time, duration and IPv4 address can be converted back to string representation after math transformations with the help of [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe). For example,
 the following query rounds the `request_duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) to seconds before converting it back to string representation:
 
 ```logsql
@@ -2511,13 +2571,13 @@ _time:5m | eval (duration_secs * 1000) as duration_msecs
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`extract` pipe](#extract-pipe)
-- [`format` pipe](#format-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+- [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe)
 
 ### offset pipe
 
-If some selected logs must be skipped after [`sort`](#sort-pipe), then `| offset N` [pipe](#pipes) can be used, where `N` can contain any [supported integer numeric value](#numeric-values).
+If some selected logs must be skipped after [`sort`](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe), then `| offset N` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used, where `N` can contain any [supported integer numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values).
 For example, the following query skips the first 100 logs over the last 5 minutes after sorting them by [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field):
 
 ```logsql
@@ -2527,17 +2587,17 @@ _time:5m | sort by (_time) | offset 100
 `skip` keyword can be used instead of `offset` keyword for convenience. For example, `_time:5m | skip 10` is equivalent to `_time:5m | offset 10`.
 
 Note that skipping rows without sorting has little sense, since they can be returned in arbitrary order because of performance reasons.
-Rows can be sorted with [`sort` pipe](#sort-pipe).
+Rows can be sorted with [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe).
 
 See also:
 
-- [`limit` pipe](#limit-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 ### pack_json pipe
 
-`<q> | pack_json as field_name` [pipe](#pipes) packs all the [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of every log
-entry returned by `<q>` [query](#query-syntax) into JSON object and stores it as a string in the given `field_name`.
+`<q> | pack_json as field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) packs all the [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of every log
+entry returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) into JSON object and stores it as a string in the given `field_name`.
 
 For example, the following query packs all the fields into JSON object and stores it into [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
 for logs over the last 5 minutes:
@@ -2567,7 +2627,7 @@ For example, the following query builds JSON with all the fields, which start wi
 _time:5m | pack_json fields (foo.*, bar.*) as baz
 ```
 
-The `pack_json` doesn't modify or delete other labels. If you do not need them, then add [`| fields ...`](#fields-pipe) after the `pack_json` pipe. For example, the following query
+The `pack_json` doesn't modify or delete other labels. If you do not need them, then add [`| fields ...`](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) after the `pack_json` pipe. For example, the following query
 leaves only the `foo` label with the original log fields packed into JSON:
 
 ```logsql
@@ -2576,13 +2636,13 @@ _time:5m | pack_json as foo | fields foo
 
 See also:
 
-- [`pack_logfmt` pipe](#pack_logfmt-pipe)
-- [`unpack_json` pipe](#unpack_json-pipe)
+- [`pack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_logfmt-pipe)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
 
 ### pack_logfmt pipe
 
-`<q> | pack_logfmt as field_name` [pipe](#pipes) packs all the [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) per every log entry
-returned by `<q>` [query](#query-syntax) into [logfmt](https://brandur.org/logfmt) message and stores it as a string in the given `field_name`.
+`<q> | pack_logfmt as field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) packs all the [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) per every log entry
+returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) into [logfmt](https://brandur.org/logfmt) message and stores it as a string in the given `field_name`.
 
 For example, the following query packs all the fields into [logfmt](https://brandur.org/logfmt) message and stores it
 into [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) for logs over the last 5 minutes:
@@ -2612,7 +2672,7 @@ For example, the following query builds `logfmt` message with all the fields, wh
 _time:5m | pack_logfmt fields (foo.*, bar.*) as baz
 ```
 
-The `pack_logfmt` doesn't modify or delete other labels. If you do not need them, then add [`| fields ...`](#fields-pipe) after the `pack_logfmt` pipe. For example, the following query
+The `pack_logfmt` doesn't modify or delete other labels. If you do not need them, then add [`| fields ...`](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) after the `pack_logfmt` pipe. For example, the following query
 leaves only the `foo` label with the original log fields packed into [logfmt](https://brandur.org/logfmt):
 
 ```logsql
@@ -2621,43 +2681,43 @@ _time:5m | pack_logfmt as foo | fields foo
 
 See also:
 
-- [`pack_json` pipe](#pack_json-pipe)
-- [`unpack_logfmt` pipe](#unpack_logfmt-pipe)
+- [`pack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_json-pipe)
+- [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe)
 
 ### query_stats pipe
 
-The `<q> | query_stats` [pipe](#pipes) returns the following execution statistics for the given [query `<q>`](#query-syntax):
+The `<q> | query_stats` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns the following execution statistics for the given [query `<q>`](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax):
 
-- `BytesReadColumnsHeaders` - the number of bytes read from disk for columns headers. Use [`fields` pipe](#fields-pipe) for reducing the number of bytes read for columns headers.
+- `BytesReadColumnsHeaders` - the number of bytes read from disk for columns headers. Use [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) for reducing the number of bytes read for columns headers.
 - `BytesReadColumnsHeaderIndexes` - the number of bytes read from disk for column header indexes.
 - `BytesReadBloomFilters` - the number of bytes read from disk for bloom filters.
 - `BytesReadValues` - the number of bytes read from disk for [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-   Use [`fields` pipe](#fields-pipe) for reducing the number of bytes read for log field values.
+   Use [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) for reducing the number of bytes read for log field values.
 - `BytesReadTimestamps` - the number of bytes read from disk for [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
 - `BytesReadBlockHeaders` - the number of bytes read from disk for block headers.
 - `BytesReadTotal` - the total number of bytes read from disk.
-- `BlocksProcessed` - the number of data blocks processed during query exectution. Use more narrow [time filter](#time-filter) and [log stream filter](#stream-filter)
+- `BlocksProcessed` - the number of data blocks processed during query exectution. Use more narrow [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) and [log stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
   for reducing the number of data blocks processed.
-- `RowsProcessed` - the number of log entries processed during query execution. Use more narrow [time filter](#time-filter) and [log stream filter](#stream-filter)
+- `RowsProcessed` - the number of log entries processed during query execution. Use more narrow [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) and [log stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
   for reducing the number of processed log entries.
 - `RowsFound` - the number of log entries found by the query.
 - `ValuesRead` - the number of [log field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) read during query processing.
-  Use [`fields` pipe](#fields-pipe) for reducing the number of field values read.
+  Use [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) for reducing the number of field values read.
 - `TimestampsRead` - the number of [`_time` fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) read during query processing.
 - `BytesProcessedUncompressedValues` - the number of uncompressed bytes for [log field values](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
   which are processed during query exection.
-- `QueryDurationNsecs` - the duration of the query in nanoseconds. It can be used for calculating various rates over the query stats with the [`math` pipe](#math-pipe).
+- `QueryDurationNsecs` - the duration of the query in nanoseconds. It can be used for calculating various rates over the query stats with the [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe).
 
 This pipe is useful for investigation and optimizing slow queries.
 
 See also:
 
-- [`block_stats` pipe](#block_stats-pipe)
-- [query troubleshooting](#troubleshooting)
+- [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe)
+- [query troubleshooting](https://docs.victoriametrics.com/victorialogs/logsql/#troubleshooting)
 
 ### rename pipe
 
-If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be renamed, then `| rename src1 as dst1, ..., srcN as dstN` [pipe](#pipes) can be used.
+If some [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) must be renamed, then `| rename src1 as dst1, ..., srcN as dstN` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used.
 For example, the following query renames `host` field to `server` for logs over the last 5 minutes, so the output contains `server` field instead of `host` field:
 
 ```logsql
@@ -2695,14 +2755,14 @@ _time:5m | rename * as foo*
 
 See also:
 
-- [`copy` pipe](#copy-pipe)
-- [`fields` pipe](#fields-pipe)
-- [`delete` pipe](#delete-pipe)
+- [`copy` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#copy-pipe)
+- [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe)
+- [`delete` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#delete-pipe)
 
 ### replace pipe
 
-`<q> | replace ("old", "new") at field` [pipe](#pipes) replaces all the occurrences of the `old` substring with the `new` substring
-in the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) over all the logs returned by `<q>` [query](#query-syntax).
+`<q> | replace ("old", "new") at field` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) replaces all the occurrences of the `old` substring with the `new` substring
+in the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) over all the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query replaces all the `secret-password` substrings with `***` in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
 for logs over the last 5 minutes:
@@ -2725,22 +2785,22 @@ at the [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#da
 _time:5m | replace ('foo', 'bar') at baz limit 1
 ```
 
-Performance tip: it is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `replace`.
-See [general performance tips](#performance-tips) for details.
+Performance tip: it is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `replace`.
+See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional replace](#conditional-replace)
-- [`replace_regexp` pipe](#replace_regexp-pipe)
-- [`collapse_nums`](#collapse_nums-pipe)
-- [`format` pipe](#format-pipe)
-- [`extract` pipe](#extract-pipe)
+- [Conditional replace](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-replace)
+- [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe)
+- [`collapse_nums`](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe)
+- [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
 
 #### Conditional replace
 
-If the [`replace` pipe](#replace-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `replace`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query replaces `secret` with `***` in the `password` field
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query replaces `secret` with `***` in the `password` field
 only if `user_type` field equals to `admin`:
 
 ```logsql
@@ -2749,8 +2809,8 @@ _time:5m | replace if (user_type:=admin) ("secret", "***") at password
 
 ### replace_regexp pipe
 
-`<q> | replace_regexp ("regexp", "replacement") at field` [pipe](#pipes) replaces all the substrings matching the given `regexp` with the given `replacement`
-in the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) over all the logs returned by `<q>` [query](#query-syntax).
+`<q> | replace_regexp ("regexp", "replacement") at field` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) replaces all the substrings matching the given `regexp` with the given `replacement`
+in the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) over all the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 The `regexp` must contain regular expression with [RE2 syntax](https://github.com/google/re2/wiki/Syntax).
 The `replacement` may contain `$N` or `${N}` placeholders, which are substituted with the `N-th` capturing group in the `regexp`.
@@ -2777,24 +2837,24 @@ _time:5m | replace_regexp ('password: [^ ]+', '') at baz limit 1
 
 Performance tips:
 
-- It is recommended using [`replace` pipe](#replace-pipe) instead of `replace_regexp` if possible, since it works faster.
-- It is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `replace`.
-  See [general performance tips](#performance-tips) for details.
+- It is recommended using [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe) instead of `replace_regexp` if possible, since it works faster.
+- It is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `replace`.
+  See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional replace_regexp](#conditional-replace_regexp)
-- [`replace` pipe](#replace-pipe)
-- [`collapse_nums` pipe](#collapse_nums-pipe)
-- [`format` pipe](#format-pipe)
-- [`extract` pipe](#extract-pipe)
-- [`decolorize` pipe](#decolorize-pipe)
+- [Conditional replace_regexp](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-replace_regexp)
+- [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe)
+- [`collapse_nums` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#collapse_nums-pipe)
+- [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+- [`decolorize` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#decolorize-pipe)
 
 #### Conditional replace_regexp
 
-If the [`replace_regexp` pipe](#replace_regexp-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `replace_regexp`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query replaces `password: ...` substrings ending with whitespace
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query replaces `password: ...` substrings ending with whitespace
 with `***` in the `foo` field only if `user_type` field equals to `admin`:
 
 ```logsql
@@ -2803,8 +2863,8 @@ _time:5m | replace_regexp if (user_type:=admin) ("password: [^ ]+", "") at foo
 
 ### running_stats pipe
 
-The `<q> | running_stats ...` [pipe](#pipes) calculates running stats (such as [running count](#count-running_stats) or [running sum](#sum-running_stats))
-over the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](#query-syntax)
+The `<q> | running_stats ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) calculates running stats (such as [running count](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats) or [running sum](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats))
+over the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax)
 and stores the stats in the specified log fields per each input log entry.
 
 The running stats is calculated over the logs sorted by time, so the `<q>` must return the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field)
@@ -2812,7 +2872,7 @@ in order to properly calculate the running stats.
 
 The `running_stats` pipe puts all the logs returned by `<q>` in memory, so make sure the `<q>` returns the limited number of logs in order to avoid high memory usage.
 
-For example, the following LogsQL query calculates [running sum](#sum-running_stats) for the `hits` field over the logs for the last 5 minutes:
+For example, the following LogsQL query calculates [running sum](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats) for the `hits` field over the logs for the last 5 minutes:
 
 ```logsql
 _time:5m | running_stats sum(hits) as running_hits
@@ -2827,13 +2887,13 @@ The `| running_stats ...` pipe has the following basic format:
   stats_funcN(...) as result_nameN
 ```
 
-Where `stats_func*` is any of the supported [running stats function](#running_stats-pipe-functions), while the `result_name*` is the name of the log field
+Where `stats_func*` is any of the supported [running stats function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions), while the `result_name*` is the name of the log field
 to store the result of the corresponding stats function. The `as` keyword is optional.
 
 For example, the following query calculates the following running stats for logs over the last 5 minutes:
 
-- the number of logs with the help of [`count` function](#count-running_stats);
-- the sum of `hits` field with the help of [`sum` function](#sum-running_stats):
+- the number of logs with the help of [`count` function](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats);
+- the sum of `hits` field with the help of [`sum` function](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats):
 
 ```logsql
 _time:5m
@@ -2842,14 +2902,14 @@ _time:5m
         sum(hits) as running_hits
 ```
 
-It is allowed omitting the result name. In this case the result name equals to the string representation of the used [running stats function](#running_stats-pipe-functions).
+It is allowed omitting the result name. In this case the result name equals to the string representation of the used [running stats function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions).
 For example, the following query returns the same stats as the previous one, but gives `count()` and `sum(hits)` names for the returned fields:
 
 ```logsql
 _time:5m | running_stats count(), sum(hits)
 ```
 
-It is useful to combine `running_stats` with [stats by time buckets](#stats-by-time-buckets). For example, the following query returns per-hour number of logs over the last day,
+It is useful to combine `running_stats` with [stats by time buckets](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets). For example, the following query returns per-hour number of logs over the last day,
 plus running number of logs.
 
 ```logsql
@@ -2860,11 +2920,11 @@ _time:1d
 
 See also:
 
-- [`running_stats` pipe functions](#running_stats-pipe-functions)
-- [`running_stats` by fields](#running_stats-by-fields)
-- [`total_stats` pipe](#total_stats-pipe)
-- [`stats` pipe](#stats-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`running_stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions)
+- [`running_stats` by fields](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-by-fields)
+- [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 #### running_stats by fields
 
@@ -2878,7 +2938,7 @@ The following LogsQL syntax can be used for calculating independent running stat
 ```
 
 This calculates `stats_func*` per each `(field1, ..., fieldM)` group of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-seen in the logs returned by `<q>` [query](#query-syntax).
+seen in the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query calculates running number of logs and running number of `hits` over the last 5 minutes,
 grouped by `(host, path)` fields:
@@ -2898,14 +2958,14 @@ _time:5m | running_stats (host, path) count() running_logs, sum(hits) running_hi
 
 See also:
 
-- [`running_stats` pipe](#running_stats-pipe)
-- [`running_stats` pipe functions](#running_stats-pipe-functions)
+- [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe)
+- [`running_stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions)
 
 
 ### sample pipe
 
-The `<q> | sample N` [pipe](#pipes) returns `1/N`th random sample of logs for the `<q>` [query](#query-syntax).
-For example, the following query returns ~1% (1/100th random sample) of logs over the last 5 minutes with the `error` [word](#word)
+The `<q> | sample N` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns `1/N`th random sample of logs for the `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
+For example, the following query returns ~1% (1/100th random sample) of logs over the last 5 minutes with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word)
 in the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
 ```logsql
@@ -2914,12 +2974,12 @@ _time:1h error | sample 100
 
 See also:
 
-- [`limit` pipe](#limit-pipe)
+- [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe)
 
 ### sort pipe
 
-By default logs are selected in arbitrary order because of performance reasons. If logs must be sorted, then `<q> | sort by (field1, ..., fieldN)` [pipe](#pipes) can be used
-for sorting logs returned by `<q>` [query](#query-syntax) by the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+By default logs are selected in arbitrary order because of performance reasons. If logs must be sorted, then `<q> | sort by (field1, ..., fieldN)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used
+for sorting logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) by the given [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 using [natural sorting](https://en.wikipedia.org/wiki/Natural_sort_order).
 
 For example, the following query returns logs for the last 5 minutes sorted by [`_stream`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
@@ -2963,7 +3023,7 @@ for the `request_duration` [field](https://docs.victoriametrics.com/victorialogs
 _time:1h | sort by (request_duration desc) limit 10
 ```
 
-This query is equivalent to the following one, which uses [`last` pipe](#last-pipe):
+This query is equivalent to the following one, which uses [`last` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#last-pipe):
 
 ```logsql
 _time:1h | last 10 by (request_duration)
@@ -2997,23 +3057,23 @@ Note that sorting of big number of logs can be slow and can consume a lot of add
 It is recommended limiting the number of logs before sorting with the following approaches:
 
 - Adding `limit N` to the end of `sort ...` pipe.
-- Reducing the selected time range with [time filter](#time-filter).
-- Using more specific [filters](#filters), so they select less logs.
-- Limiting the number of selected [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) via [`fields` pipe](#fields-pipe).
+- Reducing the selected time range with [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter).
+- Using more specific [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters), so they select less logs.
+- Limiting the number of selected [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) via [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe).
 
 See also:
 
-- [`first` pipe](#first-pipe)
-- [`last` pipe](#last-pipe)
-- [`top` pipe](#top-pipe)
-- [`stats` pipe](#stats-pipe)
-- [`limit` pipe](#limit-pipe)
-- [`offset` pipe](#offset-pipe)
+- [`first` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#first-pipe)
+- [`last` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#last-pipe)
+- [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe)
+- [`offset` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#offset-pipe)
 
 ### split pipe
 
-The `<q> | split <separator> from <src_field> as <dst_field>` [pipe](#pipes) splits `<src_field>` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-obtained from `<q>` [query](#query-syntax) results into `<dst_field>` as a JSON array, by using the given `<separator>`.
+The `<q> | split <separator> from <src_field> as <dst_field>` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) splits `<src_field>` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+obtained from `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results into `<dst_field>` as a JSON array, by using the given `<separator>`.
 
 For example, the following query splits [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) by `,` and stores the results into `items` field:
 
@@ -3034,7 +3094,7 @@ The `from <src_field>` part is optional. If it is missing, then the `_msg` field
 _time:5m | split ","
 ```
 
-It is convenient to use [`unroll` pipe](#unroll-pipe) for unrolling the JSON array with the split results.
+It is convenient to use [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe) for unrolling the JSON array with the split results.
 For example, the following query returns top 5 most frequently seen comma-separated items across [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
 for the last 5 minutes:
 
@@ -3044,14 +3104,14 @@ _time:5m | split "," as items | unroll items | top 5 (items)
 
 See also:
 
-- [`unroll` pipe](#unroll-pipe)
-- [`unpack_words` pipe](#unpack_words-pipe)
+- [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe)
+- [`unpack_words` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_words-pipe)
 
 
 ### stats pipe
 
-The `<q> | stats ...` [pipe](#pipes) calculates various stats over the logs returned by `<q>` [query](#query-syntax).
-For example, the following LogsQL query uses [`count` stats function](#count-stats) for calculating the number of logs for the last 5 minutes:
+The `<q> | stats ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) calculates various stats over the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
+For example, the following LogsQL query uses [`count` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats) for calculating the number of logs for the last 5 minutes:
 
 ```logsql
 _time:5m | stats count() as logs_total
@@ -3066,13 +3126,13 @@ The `| stats ...` pipe has the following basic format:
   stats_funcN(...) as result_nameN
 ```
 
-Where `stats_func*` is any of the supported [stats function](#stats-pipe-functions), while the `result_name*` is the name of the log field
+Where `stats_func*` is any of the supported [stats function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions), while the `result_name*` is the name of the log field
 to store the result of the corresponding stats function. The `as` keyword is optional.
 
 For example, the following query calculates the following stats for logs over the last 5 minutes:
 
-- the number of logs with the help of [`count` stats function](#count-stats);
-- the number of unique [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) with the help of [`count_uniq` stats function](#count_uniq-stats):
+- the number of logs with the help of [`count` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats);
+- the number of unique [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) with the help of [`count_uniq` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats):
 
 ```logsql
 _time:5m | stats count() logs_total, count_uniq(_stream) streams_total
@@ -3084,7 +3144,7 @@ It is allowed omitting `stats` prefix for convenience. So the following query is
 _time:5m | count() logs_total, count_uniq(_stream) streams_total
 ```
 
-It is allowed omitting the result name. In this case the result name equals to the string representation of the used [stats function](#stats-pipe-functions).
+It is allowed omitting the result name. In this case the result name equals to the string representation of the used [stats function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions).
 For example, the following query returns the same stats as the previous one, but gives `count()` and `count_uniq(_stream)` names for the returned fields:
 
 ```logsql
@@ -3093,20 +3153,20 @@ _time:5m | count(), count_uniq(_stream)
 
 See also:
 
-- [stats pipe functions](#stats-pipe-functions)
-- [stats by fields](#stats-by-fields)
-- [stats by time buckets](#stats-by-time-buckets)
-- [stats by time buckets with timezone offset](#stats-by-time-buckets-with-timezone-offset)
-- [stats by field buckets](#stats-by-field-buckets)
-- [stats by IPv4 buckets](#stats-by-ipv4-buckets)
-- [stats with additional filters](#stats-with-additional-filters)
-- [`running_stats` pipe](#running_stats-pipe)
-- [`total_stats` pipe](#total_stats-pipe)
-- [`math` pipe](#math-pipe)
-- [`sort` pipe](#sort-pipe)
-- [`uniq` pipe](#uniq-pipe)
-- [`top` pipe](#top-pipe)
-- [`join` pipe](#join-pipe)
+- [stats pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [stats by fields](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-fields)
+- [stats by time buckets](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets)
+- [stats by time buckets with timezone offset](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets-with-timezone-offset)
+- [stats by field buckets](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-field-buckets)
+- [stats by IPv4 buckets](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-ipv4-buckets)
+- [stats with additional filters](https://docs.victoriametrics.com/victorialogs/logsql/#stats-with-additional-filters)
+- [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe)
+- [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
+- [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe)
+- [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)
+- [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe)
 
 #### Stats by fields
 
@@ -3120,7 +3180,7 @@ The following LogsQL syntax can be used for calculating independent stats per gr
 ```
 
 This calculates `stats_func*` per each `(field1, ..., fieldM)` group of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-seen in the logs returned by `<q>` [query](#query-syntax).
+seen in the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query calculates the number of logs and unique ip addresses over the last 5 minutes,
 grouped by `(host, path)` fields:
@@ -3137,11 +3197,11 @@ _time:5m | stats (host, path) count() logs_total, count_uniq(ip) ips_total
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`row_min`](#row_min-stats)
-- [`row_max`](#row_max-stats)
-- [`row_any`](#row_any-stats)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats)
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats)
+- [`row_any`](https://docs.victoriametrics.com/victorialogs/logsql/#row_any-stats)
 
 #### Stats by time buckets
 
@@ -3155,14 +3215,14 @@ The following syntax can be used for calculating stats grouped by time buckets:
 ```
 
 This calculates `stats_func*` per each `step` of the [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) field
-across logs returned by `<q>` [query](#query-syntax). The `step` can have any [duration value](#duration-values).
+across logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax). The `step` can have any [duration value](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
 For example, the following LogsQL query returns per-minute number of logs and unique ip addresses over the last 5 minutes:
 
 ```logsql
 _time:5m | stats by (_time:1m) count() logs_total, count_uniq(ip) ips_total
 ```
 
-It might be useful to calculate running stats over the calculated per-time bucket stats, with the help of [`running_stats` pipe](#running_stats-pipe).
+It might be useful to calculate running stats over the calculated per-time bucket stats, with the help of [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe).
 For example, the following query adds running number of logs into `running_hits` field for the query above:
 
 ```logsql
@@ -3171,9 +3231,9 @@ _time:5m
     | running_stats sum(hits) as running_hits
 ```
 
-It might be useful to calculate total stats over the calculated per-time bucket stats, which the help of [`total_stats` pipe](#total_stats-pipe).
+It might be useful to calculate total stats over the calculated per-time bucket stats, which the help of [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe).
 for example, the following query add total number of logs into `total_hits` field and then uses this field for calculating the per-minute percentage of hits
-with the [`math` pipe](#math-pipe):
+with the [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe):
 
 ```logsql
 _time:5m
@@ -3184,24 +3244,24 @@ _time:5m
 
 Additionally, the following `step` values are supported:
 
-- `nanosecond` - equals to `1ns` [duration](#duration-values).
-- `microsecond` - equals to `1µs` [duration](#duration-values).
-- `millisecond` - equals to `1ms` [duration](#duration-values).
-- `second` - equals to `1s` [duration](#duration-values).
-- `minute` - equals to `1m` [duration](#duration-values).
-- `hour` - equals to `1h` [duration](#duration-values).
-- `day` - equals to `1d` [duration](#duration-values).
-- `week` - equals to `1w` [duration](#duration-values).
+- `nanosecond` - equals to `1ns` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `microsecond` - equals to `1µs` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `millisecond` - equals to `1ms` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `second` - equals to `1s` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `minute` - equals to `1m` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `hour` - equals to `1h` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `day` - equals to `1d` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
+- `week` - equals to `1w` [duration](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
 - `month` - equals to one month. It properly takes into account the number of days per each month.
 - `year` - equals to one year. It properly takes into account the number of days per each year.
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`running_stats` pipe](#running_stats-pipe)
-- [`total_stats` pipe](#total_stats-pipe)
-- [`math` pipe](#math-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe)
+- [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
 
 #### Stats by time buckets with timezone offset
 
@@ -3221,23 +3281,23 @@ _time:1w | stats by (_time:1d offset 2h) count() logs_total
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`math` pipe](#math-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
 
 #### Stats by field buckets
 
-Every log field inside `<q> | stats by (...)` can be bucketed in the same way as `_time` field in [this example](#stats-by-time-buckets).
-Any [numeric value](#numeric-values) can be used as `step` value for the bucket. For example, the following query calculates
+Every log field inside `<q> | stats by (...)` can be bucketed in the same way as `_time` field in [this example](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets).
+Any [numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#numeric-values) can be used as `step` value for the bucket. For example, the following query calculates
 the number of requests for the last hour, bucketed by 10KB of `request_size_bytes` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model):
 
 ```logsql
 _time:1h | stats by (request_size_bytes:10KB) count() requests
 ```
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`math` pipe](#math-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
 
 #### Stats by IPv4 buckets
 
@@ -3249,17 +3309,17 @@ extracted from the `ip` [log field](https://docs.victoriametrics.com/victorialog
 _time:5m | stats by (ip:/24) count() requests_per_subnet
 ```
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`math` pipe](#math-pipe)
-- [`ipv4_range` filter](#ipv4-range-filter)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe)
+- [`ipv4_range` filter](https://docs.victoriametrics.com/victorialogs/logsql/#ipv4-range-filter)
 
 #### Stats with additional filters
 
-Sometimes it is needed to calculate [stats](#stats-pipe) on different subsets of matching logs. This can be done by inserting `if (<any_filters>)` condition
-between [stats function](#stats-pipe-functions) and `result_name`, where `any_filter` can contain arbitrary [filters](#filters).
+Sometimes it is needed to calculate [stats](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) on different subsets of matching logs. This can be done by inserting `if (<any_filters>)` condition
+between [stats function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) and `result_name`, where `any_filter` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters).
 For example, the following query calculates individually the number of [logs messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
-with `GET`, `POST` and `PUT` [words](#word), additionally to the total number of logs over the last 5 minutes:
+with `GET`, `POST` and `PUT` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word), additionally to the total number of logs over the last 5 minutes:
 
 ```logsql
 _time:5m | stats
@@ -3273,29 +3333,29 @@ If zero input rows match the given `if (...)` filter, then zero result is return
 
 See also:
 
-- [`stats` pipe](#stats-pipe)
-- [`stats` pipe functions](#stats-pipe-functions)
-- [`join` pipe](#join-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions)
+- [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe)
 
 ### stream_context pipe
 
-`<q> | stream_context ...` [pipe](#pipes) allows selecting surrounding logs in [logs stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
-across the logs returned by `<q>` [query](#query-syntax) in the way similar to `grep -A` / `grep -B`.
+`<q> | stream_context ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) allows selecting surrounding logs in [logs stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
+across the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) in the way similar to `grep -A` / `grep -B`.
 The returned log chunks are delimited with `---` [log message](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) for easier investigation.
 
-For example, the following query returns up to 10 additional logs after every log message with the `panic` [word](#word) across all the logs for the last 5 minutes:
+For example, the following query returns up to 10 additional logs after every log message with the `panic` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) across all the logs for the last 5 minutes:
 
 ```logsql
 _time:5m panic | stream_context after 10
 ```
 
-The following query returns up to 5 additional logs in front of every log message with the `stacktrace` [word](#word) across all the logs for the last 5 minutes:
+The following query returns up to 5 additional logs in front of every log message with the `stacktrace` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) across all the logs for the last 5 minutes:
 
 ```logsql
 _time:5m stacktrace | stream_context before 5
 ```
 
-The following query returns up to 2 logs in front of the log message with the `error` [word](#word) and up to 5 logs after this log message
+The following query returns up to 2 logs in front of the log message with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) and up to 5 logs after this log message
 across all the logs for the last 5 minutes:
 
 ```logsql
@@ -3309,16 +3369,16 @@ For example, the following query searches for surrounding logs on one week windo
 _time:5m error | stream_context before 10 time_window 1w
 ```
 
-The `| stream_context` [pipe](#pipes) must go first just after the [filters](#filters).
+The `| stream_context` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) must go first just after the [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters).
 
 See also:
 
-- [stream filter](#stream-filter)
+- [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
 
 ### time_add pipe
 
 `<q> | time_add <duration>` adds the given `<duration>` to the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
-The `<duration>` can be in any format described [here](#duration-values).
+The `<duration>` can be in any format described [here](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values).
 
 For example, the following query adds one hour to `_time` field in the selected logs:
 
@@ -3341,13 +3401,13 @@ _time:5m | time_add 1w at transaction_time
 
 See also:
 
-- [`_time` filter](#time-filter).
-- [`time_offset` option](#query-options).
+- [`_time` filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter).
+- [`time_offset` option](https://docs.victoriametrics.com/victorialogs/logsql/#query-options).
 
 ### top pipe
 
-`<q> | top N by (field1, ..., fieldN)` [pipe](#pipes) returns top `N` sets for `(field1, ..., fieldN)` [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-with the maximum number of matching log entries across logs returned by `<q>` [query](#query-syntax).
+`<q> | top N by (field1, ..., fieldN)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns top `N` sets for `(field1, ..., fieldN)` [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+with the maximum number of matching log entries across logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query returns top 7 [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 with the maximum number of log entries over the last 5 minutes. The number of entries are returned in the `hits` field:
@@ -3383,18 +3443,18 @@ _time:5m | top 10 by (ip) rank as position
 
 See also:
 
-- [`first` pipe](#first-pipe)
-- [`last` pipe](#last-pipe)
-- [`facets` pipe](#facets-pipe)
-- [`uniq` pipe](#uniq-pipe)
-- [`stats` pipe](#stats-pipe)
-- [`sort` pipe](#sort-pipe)
-- [`histogram` stats function](#histogram-stats)
+- [`first` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#first-pipe)
+- [`last` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#last-pipe)
+- [`facets` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#facets-pipe)
+- [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
+- [`histogram` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#histogram-stats)
 
 ### total_stats pipe
 
-The `<q> | total_stats ...` [pipe](#pipes) calculates total (global) stats (such as [global count](#count-total_stats) or [global sum](#sum-total_stats))
-over the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](#query-syntax)
+The `<q> | total_stats ...` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) calculates total (global) stats (such as [global count](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats) or [global sum](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats))
+over the specified [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax)
 and stores this stats in the specified log fields per each input log entry.
 
 The total stats is calculated over the logs sorted by time, so the `<q>` must return the [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field)
@@ -3402,7 +3462,7 @@ in order to properly calculate the total stats.
 
 The `total_stats` pipe puts all the logs returned by `<q>` in memory, so make sure the `<q>` returns the limited number of logs in order to avoid high memory usage.
 
-For example, the following LogsQL query calculates [total sum](#sum-total_stats) for the `hits` field over the logs for the last 5 minutes:
+For example, the following LogsQL query calculates [total sum](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats) for the `hits` field over the logs for the last 5 minutes:
 
 ```logsql
 _time:5m | total_stats sum(hits) as total_hits
@@ -3417,13 +3477,13 @@ The `| total_stats ...` pipe has the following basic format:
   stats_funcN(...) as result_nameN
 ```
 
-Where `stats_func*` is any of the supported [total stats function](#total_stats-pipe-functions), while the `result_name*` is the name of the log field
+Where `stats_func*` is any of the supported [total stats function](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions), while the `result_name*` is the name of the log field
 to store the result of the corresponding stats function. The `as` keyword is optional.
 
 For example, the following query calculates the following total stats for logs over the last 5 minutes:
 
-- the number of logs with the help of [`count` function](#count-total_stats);
-- the sum of `hits` field with the help of [`sum` function](#sum-total_stats):
+- the number of logs with the help of [`count` function](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats);
+- the sum of `hits` field with the help of [`sum` function](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats):
 
 ```logsql
 _time:5m
@@ -3432,14 +3492,14 @@ _time:5m
         sum(hits) as total_hits
 ```
 
-It is allowed omitting the result name. In this case the result name equals to the string representation of the used [total stats function](#total_stats-pipe-functions).
+It is allowed omitting the result name. In this case the result name equals to the string representation of the used [total stats function](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions).
 For example, the following query returns the same stats as the previous one, but gives `count()` and `sum(hits)` names for the returned fields:
 
 ```logsql
 _time:5m | total_stats count(), sum(hits)
 ```
 
-It is useful to combine `total_stats` with [stats by time buckets](#stats-by-time-buckets). For example, the following query returns per-hour number of logs over the last day,
+It is useful to combine `total_stats` with [stats by time buckets](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets). For example, the following query returns per-hour number of logs over the last day,
 plus the total number of logs, and then calculates the per-hour percent of hits over the daily hits.
 
 ```logsql
@@ -3451,11 +3511,11 @@ _time:1d
 
 See also:
 
-- [`total_stats` pipe functions](#total_stats-pipe-functions)
-- [`total_stats` by fields](#total_stats-by-fields)
-- [`running_stats` pipe](#running_stats-pipe)
-- [`stats` pipe](#stats-pipe)
-- [`sort` pipe](#sort-pipe)
+- [`total_stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions)
+- [`total_stats` by fields](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-by-fields)
+- [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
+- [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe)
 
 #### total_stats by fields
 
@@ -3469,7 +3529,7 @@ The following LogsQL syntax can be used for calculating independent total stats
 ```
 
 This calculates `stats_func*` per each `(field1, ..., fieldM)` group of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-seen in the logs returned by `<q>` [query](#query-syntax).
+seen in the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
 
 For example, the following query calculates total number of logs and total number of `hits` over the last 5 minutes,
 grouped by `(host, path)` fields:
@@ -3489,15 +3549,15 @@ _time:5m | total_stats (host, path) count() total_logs, sum(hits) total_hits
 
 See also:
 
-- [`total_stats` pipe](#total_stats-pipe)
-- [`total_stats` pipe functions](#total_stats-pipe-functions)
+- [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe)
+- [`total_stats` pipe functions](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions)
 
 
 ### union pipe
 
-`<q1> | union (<q2>)` [pipe](#pipes) returns results of `<q1>` [query](#query-syntax) followed by results of `<q2>` [query](#query-syntax).
-It works similar to `UNION ALL` in SQL. `<q1>` and `q2` may contain arbitrary [LogsQL queries](#logsql-tutorial).
-For example, the following query returns logs with `error` [word](#word) for the last 5 minutes, plus logs with `panic` word for the last hour:
+`<q1> | union (<q2>)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns results of `<q1>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) followed by results of `<q2>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax).
+It works similar to `UNION ALL` in SQL. `<q1>` and `q2` may contain arbitrary [LogsQL queries](https://docs.victoriametrics.com/victorialogs/logsql/#logsql-tutorial).
+For example, the following query returns logs with `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) for the last 5 minutes, plus logs with `panic` word for the last hour:
 
 ```logsql
 _time:5m error | union (_time:1h panic)
@@ -3505,13 +3565,13 @@ _time:5m error | union (_time:1h panic)
 
 See also:
 
-- [`join` pipe](#join-pipe)
-- [subquery filter](#subquery-filter)
+- [`join` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#join-pipe)
+- [subquery filter](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter)
 
 ### uniq pipe
 
-`<q> | uniq by (field1, ..., fieldN)` [pipe](#pipes) returns unique values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-over the logs returned by `<q>` [query](#query-syntax). For example, the following LogsQL query
+`<q> | uniq by (field1, ..., fieldN)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) returns unique values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+over the logs returned by `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax). For example, the following LogsQL query
 returns unique values for `ip` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 over logs for the last 5 minutes:
 
@@ -3526,7 +3586,7 @@ are returned. For example, the following query returns all the unique `(host, pa
 _time:5m | uniq by (host, path)
 ```
 
-The unique entries are returned in arbitrary order. Use [`sort` pipe](#sort-pipe) in order to sort them if needed.
+The unique entries are returned in arbitrary order. Use [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) in order to sort them if needed.
 
 Add `with hits` after `uniq by (...)` in order to return the number of matching logs per each field value:
 
@@ -3552,14 +3612,14 @@ _time:5m | uniq (host, path) limit 100
 
 See also:
 
-- [`uniq_values` stats function](#uniq_values-stats)
-- [`top` pipe](#top-pipe)
-- [`stats` pipe](#stats-pipe)
+- [`uniq_values` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats)
+- [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)
+- [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe)
 
 ### unpack_json pipe
 
-`<q> | unpack_json from field_name` [pipe](#pipes) unpacks `{"k1":"v1", ..., "kN":"vN"}` JSON from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-of `<q>` [query](#query-syntax) results into `k1`, ... `kN` output field names with the corresponding `v1`, ..., `vN` values.
+`<q> | unpack_json from field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) unpacks `{"k1":"v1", ..., "kN":"vN"}` JSON from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+of `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results into `k1`, ... `kN` output field names with the corresponding `v1`, ..., `vN` values.
 It overrides existing fields with names from the `k1`, ..., `kN` list. Other fields remain untouched.
 
 Nested JSON is unpacked according to the rules defined [here](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
@@ -3600,7 +3660,7 @@ For example, the following query preserves the original `ip` and `host` field va
 _time:5m | unpack_json fields (ip, host) skip_empty_results
 ```
 
-Performance tip: if you need extracting a single field from long JSON, it is faster to use [`extract` pipe](#extract-pipe). For example, the following query extracts `"ip"` field from JSON
+Performance tip: if you need extracting a single field from long JSON, it is faster to use [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe). For example, the following query extracts `"ip"` field from JSON
 stored in [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) at the maximum speed:
 
 ```
@@ -3619,27 +3679,27 @@ Performance tips:
 
 - It is better from performance and resource usage PoV ingesting parsed JSON logs into VictoriaLogs
   according to the [supported data model](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-  instead of ingesting unparsed JSON lines into VictoriaLogs and then parsing them at query time with [`unpack_json` pipe](#unpack_json-pipe).
+  instead of ingesting unparsed JSON lines into VictoriaLogs and then parsing them at query time with [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe).
 
-- It is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `unpack_json`.
-  See [general performance tips](#performance-tips) for details.
+- It is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `unpack_json`.
+  See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional `unpack_json`](#conditional-unpack_json)
-- [`unpack_logfmt` pipe](#unpack_logfmt-pipe)
-- [`unpack_syslog` pipe](#unpack_syslog-pipe)
-- [`extract` pipe](#extract-pipe)
-- [`split` pipe](#split-pipe)
-- [`unroll` pipe](#unroll-pipe)
-- [`pack_json` pipe](#pack_json-pipe)
-- [`pack_logfmt` pipe](#pack_logfmt-pipe)
+- [Conditional `unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-unpack_json)
+- [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe)
+- [`unpack_syslog` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+- [`split` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#split-pipe)
+- [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe)
+- [`pack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_json-pipe)
+- [`pack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_logfmt-pipe)
 
 #### Conditional unpack_json
 
-If the [`unpack_json` pipe](#unpack_json-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `unpack_json`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query unpacks JSON fields from `foo` field only if `ip` field in the current log entry isn't set or empty:
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query unpacks JSON fields from `foo` field only if `ip` field in the current log entry isn't set or empty:
 
 ```logsql
 _time:5m | unpack_json if (ip:"") from foo
@@ -3647,8 +3707,8 @@ _time:5m | unpack_json if (ip:"") from foo
 
 ### unpack_logfmt pipe
 
-`<q> | unpack_logfmt from field_name` [pipe](#pipes) unpacks `k1=v1 ... kN=vN` [logfmt](https://brandur.org/logfmt) fields
-from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](#query-syntax) results into `k1`, ... `kN` field names
+`<q> | unpack_logfmt from field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) unpacks `k1=v1 ... kN=vN` [logfmt](https://brandur.org/logfmt) fields
+from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results into `k1`, ... `kN` field names
 with the corresponding `v1`, ..., `vN` values. It overrides existing fields with names from the `k1`, ..., `kN` list. Other fields remain untouched.
 
 For example, the following query unpacks [logfmt](https://brandur.org/logfmt) fields from the [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
@@ -3688,7 +3748,7 @@ For example, the following query preserves the original `ip` and `host` field va
 _time:5m | unpack_logfmt fields (ip, host) skip_empty_results
 ```
 
-Performance tip: if you need extracting a single field from long [logfmt](https://brandur.org/logfmt) line, it is faster to use [`extract` pipe](#extract-pipe).
+Performance tip: if you need extracting a single field from long [logfmt](https://brandur.org/logfmt) line, it is faster to use [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe).
 For example, the following query extracts `"ip"` field from [logfmt](https://brandur.org/logfmt) line stored
 in [`_msg` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field):
 
@@ -3708,23 +3768,23 @@ Performance tips:
 
 - It is better from performance and resource usage PoV ingesting parsed [logfmt](https://brandur.org/logfmt) logs into VictoriaLogs
   according to the [supported data model](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-  instead of ingesting unparsed logfmt lines into VictoriaLogs and then parsing them at query time with [`unpack_logfmt` pipe](#unpack_logfmt-pipe).
+  instead of ingesting unparsed logfmt lines into VictoriaLogs and then parsing them at query time with [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe).
 
-- It is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `unpack_logfmt`.
-  See [general performance tips](#performance-tips) for details.
+- It is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `unpack_logfmt`.
+  See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional unpack_logfmt](#conditional-unpack_logfmt)
-- [`unpack_json` pipe](#unpack_json-pipe)
-- [`unpack_syslog` pipe](#unpack_syslog-pipe)
-- [`extract` pipe](#extract-pipe)
+- [Conditional unpack_logfmt](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-unpack_logfmt)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
+- [`unpack_syslog` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
 
 #### Conditional unpack_logfmt
 
-If the [`unpack_logfmt` pipe](#unpack_logfmt-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `unpack_logfmt`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query unpacks logfmt fields from `foo` field
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query unpacks logfmt fields from `foo` field
 only if `ip` field in the current log entry isn't set or empty:
 
 ```logsql
@@ -3733,8 +3793,8 @@ _time:5m | unpack_logfmt if (ip:"") from foo
 
 ### unpack_syslog pipe
 
-`<q> | unpack_syslog from field_name` [pipe](#pipes) unpacks [syslog](https://en.wikipedia.org/wiki/Syslog) message
-from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](#query-syntax) results.
+`<q> | unpack_syslog from field_name` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) unpacks [syslog](https://en.wikipedia.org/wiki/Syslog) message
+from the given [`field_name`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results.
 It understands the following Syslog formats:
 
 - [RFC3164](https://datatracker.ietf.org/doc/html/rfc3164) aka `<PRI>MMM DD hh:mm:ss HOSTNAME APP-NAME[PROCID]: MESSAGE`
@@ -3801,23 +3861,23 @@ Performance tips:
 
 - It is better from performance and resource usage PoV ingesting parsed [syslog](https://en.wikipedia.org/wiki/Syslog) messages into VictoriaLogs
   according to the [supported data model](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-  instead of ingesting unparsed syslog lines into VictoriaLogs and then parsing them at query time with [`unpack_syslog` pipe](#unpack_syslog-pipe).
+  instead of ingesting unparsed syslog lines into VictoriaLogs and then parsing them at query time with [`unpack_syslog` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe).
 
-- It is recommended using more specific [log filters](#filters) in order to reduce the number of log entries, which are passed to `unpack_syslog`.
-  See [general performance tips](#performance-tips) for details.
+- It is recommended using more specific [log filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) in order to reduce the number of log entries, which are passed to `unpack_syslog`.
+  See [general performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips) for details.
 
 See also:
 
-- [Conditional unpack_syslog](#conditional-unpack_syslog)
-- [`unpack_json` pipe](#unpack_json-pipe)
-- [`unpack_logfmt` pipe](#unpack_logfmt-pipe)
-- [`extract` pipe](#extract-pipe)
+- [Conditional unpack_syslog](https://docs.victoriametrics.com/victorialogs/logsql/#conditional-unpack_syslog)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
+- [`unpack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
 
 #### Conditional unpack_syslog
 
-If the [`unpack_syslog` pipe](#unpack_syslog-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`unpack_syslog` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `unpack_syslog`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query unpacks syslog message fields from `foo` field
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query unpacks syslog message fields from `foo` field
 only if `hostname` field in the current log entry isn't set or empty:
 
 ```logsql
@@ -3826,9 +3886,9 @@ _time:5m | unpack_syslog if (hostname:"") from foo
 
 ### unpack_words pipe
 
-The `<q> | unpack_words from <src_field> as <dst_field>` [pipe](#pipes) unpacks [words](#word) from the given
+The `<q> | unpack_words from <src_field> as <dst_field>` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) unpacks [words](https://docs.victoriametrics.com/victorialogs/logsql/#word) from the given
 `<src_field>` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-of `<q>` [query](#query-syntax) results into `<dst_field>` as a JSON array.
+of `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results into `<dst_field>` as a JSON array.
 
 For example, the following query unpacks words from [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) into `words` field:
 
@@ -3856,7 +3916,7 @@ For example, the following query extracts only unique words from every `text` fi
 _time:5m | unpack_words from text as words drop_duplicates
 ```
 
-It is convenient to use [`unroll` pipe](#unroll-pipe) for unrolling the JSON array with unpacked words from the destination field.
+It is convenient to use [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe) for unrolling the JSON array with unpacked words from the destination field.
 For example, the following query returns top 5 most frequently seen words across [log messages](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) for the last 5 minutes:
 
 ```logsql
@@ -3865,13 +3925,13 @@ _time:5m | unpack_words as words | unroll words | top 5 (words)
 
 See also:
 
-- [`unroll` pipe](#unroll-pipe)
-- [`split` pipe](#split-pipe)
+- [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe)
+- [`split` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#split-pipe)
 
 ### unroll pipe
 
-`<q> | unroll by (field1, ..., fieldN)` [pipe](#pipes) can be used for unrolling JSON arrays from `field1`, ..., `fieldN`
-[log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](#query-syntax) results into separate rows.
+`<q> | unroll by (field1, ..., fieldN)` [pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) can be used for unrolling JSON arrays from `field1`, ..., `fieldN`
+[log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) of `<q>` [query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) results into separate rows.
 
 For example, the following query unrolls `timestamp` and `value` [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) from logs for the last 5 minutes:
 
@@ -3879,22 +3939,22 @@ For example, the following query unrolls `timestamp` and `value` [log fields](ht
 _time:5m | unroll (timestamp, value)
 ```
 
-If the unrolled JSON array contains JSON objects, then it may be handy using [`unpack_json`](#unpack_json-pipe) for unpacking
+If the unrolled JSON array contains JSON objects, then it may be handy using [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) for unpacking
 the unrolled array items into separate fields for further processing.
 
 See also:
 
-- [`unpack_json` pipe](#unpack_json-pipe)
-- [`unpack_words` pipe](#unpack_words-pipe)
-- [`extract` pipe](#extract-pipe)
-- [`uniq_values` stats function](#uniq_values-stats)
-- [`values` stats function](#values-stats)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
+- [`unpack_words` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_words-pipe)
+- [`extract` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe)
+- [`uniq_values` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats)
+- [`values` stats function](https://docs.victoriametrics.com/victorialogs/logsql/#values-stats)
 
 #### Conditional unroll
 
-If the [`unroll` pipe](#unroll-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
+If the [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe) must be applied only to some [log entries](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model),
 then add `if (<filters>)` after `unroll`.
-The `<filters>` can contain arbitrary [filters](#filters). For example, the following query unrolls `value` field only if `value_type` field equals to `json_array`:
+The `<filters>` can contain arbitrary [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters). For example, the following query unrolls `value` field only if `value_type` field equals to `json_array`:
 
 ```logsql
 _time:5m | unroll if (value_type:="json_array") (value)
@@ -3902,16 +3962,16 @@ _time:5m | unroll if (value_type:="json_array") (value)
 
 ## running_stats pipe functions
 
-LogsQL supports the following functions for [`running_stats` pipe](#running_stats-pipe):
+LogsQL supports the following functions for [`running_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe):
 
-- [`count`](#count-running_stats) returns the number of log entries.
-- [`max`](#max-running_stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`min`](#min-running_stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`sum`](#sum-running_stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats) returns the number of log entries.
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-running_stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-running_stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 ### count running_stats
 
-`count()` [`running_stats` pipe function](#running_stats-pipe-functions) calculates running number of selected logs.
+`count()` [`running_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions) calculates running number of selected logs.
 
 For example, the following query adds the `running_logs` field to the selected logs over the last 5 minutes:
 
@@ -3943,13 +4003,13 @@ _time:5m | running_stats count(foo*)
 
 See also:
 
-- [`sum`](#sum-running_stats)
-- [`min`](#min-running_stats)
-- [`max`](#max-running_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-running_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-running_stats)
 
 ### max running_stats
 
-`max(field1, ..., fieldN)` [`running_stats` pipe function](#running_stats-pipe-functions) returns running maximum across
+`max(field1, ..., fieldN)` [`running_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions) returns running maximum across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns running maximum for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -3963,13 +4023,13 @@ It is possible to calculate running maximum value across all the fields with com
 
 See also:
 
-- [`min`](#min-running_stats)
-- [`sum`](#sum-running_stats)
-- [`count`](#count-running_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-running_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats)
 
 ### min running_stats
 
-`min(field1, ..., fieldN)` [`running_stats` pipe function](#running_stats-pipe-functions) returns running minimum across
+`min(field1, ..., fieldN)` [`running_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions) returns running minimum across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns running minimum for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -3983,13 +4043,13 @@ It is possible to find running minimum across all the fields with common prefix
 
 See also:
 
-- [`max`](#max-running_stats)
-- [`sum`](#sum-running_stats)
-- [`count`](#count-running_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-running_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-running_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats)
 
 ### sum running_stats
 
-`sum(field1, ..., fieldN)` [`running_stats` pipe function](#running_stats-pipe-functions) calculates running sum of numeric values across
+`sum(field1, ..., fieldN)` [`running_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions) calculates running sum of numeric values across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 Non-numeric values are skipped. If all the values across `field1`, ..., `fieldN` are non-numeric, then `NaN` is returned.
 
@@ -4004,22 +4064,22 @@ It is possible to find running sum for all the fields with common prefix via `su
 
 See also:
 
-- [`count`](#count-running_stats)
-- [`max`](#max-running_stats)
-- [`min`](#min-running_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-running_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-running_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-running_stats)
 
 ## total_stats pipe functions
 
-LogsQL supports the following functions for [`total_stats` pipe](#running_stats-pipe):
+LogsQL supports the following functions for [`total_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe):
 
-- [`count`](#count-total_stats) returns the number of log entries.
-- [`max`](#max-total_stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`min`](#min-total_stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`sum`](#sum-total_stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats) returns the number of log entries.
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-total_stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-total_stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 ### count total_stats
 
-`count()` [`total_stats` pipe function](#total_stats-pipe-functions) calculates the total number of selected logs.
+`count()` [`total_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions) calculates the total number of selected logs.
 
 For example, the following query adds the `total_logs` field to the selected logs over the last 5 minutes:
 
@@ -4051,13 +4111,13 @@ _time:5m | total_stats count(foo*)
 
 See also:
 
-- [`sum`](#sum-total_stats)
-- [`min`](#min-total_stats)
-- [`max`](#max-total_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-total_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-total_stats)
 
 ### max total_stats
 
-`max(field1, ..., fieldN)` [`total_stats` pipe function](#total_stats-pipe-functions) returns the total maximum across
+`max(field1, ..., fieldN)` [`total_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions) returns the total maximum across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the total maximum for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4071,13 +4131,13 @@ It is possible to calculate the total maximum value across all the fields with c
 
 See also:
 
-- [`min`](#min-total_stats)
-- [`sum`](#sum-total_stats)
-- [`count`](#count-total_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-total_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats)
 
 ### min total_stats
 
-`min(field1, ..., fieldN)` [`total_stats` pipe function](#running_stats-pipe-functions) returns the total minimum across
+`min(field1, ..., fieldN)` [`total_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#running_stats-pipe-functions) returns the total minimum across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the total minimum for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4091,13 +4151,13 @@ It is possible to find the total minimum across all the fields with common prefi
 
 See also:
 
-- [`max`](#max-total_stats)
-- [`sum`](#sum-total_stats)
-- [`count`](#count-total_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-total_stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-total_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats)
 
 ### sum total_stats
 
-`sum(field1, ..., fieldN)` [`total_stats` pipe function](#total_stats-pipe-functions) calculates the total sum of numeric values across
+`sum(field1, ..., fieldN)` [`total_stats` pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#total_stats-pipe-functions) calculates the total sum of numeric values across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 Non-numeric values are skipped. If all the values across `field1`, ..., `fieldN` are non-numeric, then `NaN` is returned.
 
@@ -4112,38 +4172,38 @@ It is possible to find the total sum for all the fields with common prefix via `
 
 See also:
 
-- [`count`](#count-total_stats)
-- [`max`](#max-total_stats)
-- [`min`](#min-total_stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-total_stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-total_stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-total_stats)
 
 ## stats pipe functions
 
-LogsQL supports the following functions for [`stats` pipe](#stats-pipe):
-
-- [`avg`](#avg-stats) returns the average value over the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`count`](#count-stats) returns the number of log entries.
-- [`count_empty`](#count_empty-stats) returns the number logs with empty [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`count_uniq`](#count_uniq-stats) returns the number of unique non-empty values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`count_uniq_hash`](#count_uniq_hash-stats) returns the number of unique hashes for non-empty values at the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`histogram`](#histogram-stats) returns [VictoriaMetrics histogram](https://valyala.medium.com/improving-histogram-usability-for-prometheus-and-grafana-bc7e5df0e350) for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`json_values`](#json_values-stats) returns JSON-encoded logs as JSON array.
-- [`max`](#max-stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`median`](#median-stats) returns the [median](https://en.wikipedia.org/wiki/Median) value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`min`](#min-stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`quantile`](#quantile-stats) returns the given quantile for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`rate`](#rate-stats) returns the average per-second rate of matching logs on the selected time range.
-- [`rate_sum`](#rate_sum-stats) returns the average per-second rate of sum for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`row_any`](#row_any-stats) returns a sample [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) per each selected [stats group](#stats-by-fields).
-- [`row_max`](#row_max-stats) returns the [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with the minimum value at the given field.
-- [`row_min`](#row_min-stats) returns the [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with the maximum value at the given field.
-- [`sum`](#sum-stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`sum_len`](#sum_len-stats) returns the sum of lengths for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`uniq_values`](#uniq_values-stats) returns unique non-empty values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-- [`values`](#values-stats) returns all the values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+LogsQL supports the following functions for [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe):
+
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats) returns the average value over the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats) returns the number of log entries.
+- [`count_empty`](https://docs.victoriametrics.com/victorialogs/logsql/#count_empty-stats) returns the number logs with empty [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats) returns the number of unique non-empty values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`count_uniq_hash`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq_hash-stats) returns the number of unique hashes for non-empty values at the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`histogram`](https://docs.victoriametrics.com/victorialogs/logsql/#histogram-stats) returns [VictoriaMetrics histogram](https://valyala.medium.com/improving-histogram-usability-for-prometheus-and-grafana-bc7e5df0e350) for the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`json_values`](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats) returns JSON-encoded logs as JSON array.
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats) returns the maximum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`median`](https://docs.victoriametrics.com/victorialogs/logsql/#median-stats) returns the [median](https://en.wikipedia.org/wiki/Median) value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats) returns the minimum value over the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats) returns the given quantile for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`rate`](https://docs.victoriametrics.com/victorialogs/logsql/#rate-stats) returns the average per-second rate of matching logs on the selected time range.
+- [`rate_sum`](https://docs.victoriametrics.com/victorialogs/logsql/#rate_sum-stats) returns the average per-second rate of sum for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`row_any`](https://docs.victoriametrics.com/victorialogs/logsql/#row_any-stats) returns a sample [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) per each selected [stats group](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-fields).
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats) returns the [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with the minimum value at the given field.
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats) returns the [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) with the maximum value at the given field.
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-stats) returns the sum for the given numeric [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`sum_len`](https://docs.victoriametrics.com/victorialogs/logsql/#sum_len-stats) returns the sum of lengths for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`uniq_values`](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats) returns unique non-empty values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
+- [`values`](https://docs.victoriametrics.com/victorialogs/logsql/#values-stats) returns all the values for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 ### avg stats
 
-`avg(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the average value across
+`avg(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the average value across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 Non-numeric values are ignored. If all the values are non-numeric, then `NaN` is returned.
 
@@ -4163,16 +4223,16 @@ _time:5m | stats avg(foo*)
 
 See also:
 
-- [`median`](#median-stats)
-- [`quantile`](#quantile-stats)
-- [`min`](#min-stats)
-- [`max`](#max-stats)
-- [`sum`](#sum-stats)
-- [`count`](#count-stats)
+- [`median`](https://docs.victoriametrics.com/victorialogs/logsql/#median-stats)
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
 
 ### count stats
 
-`count()` [stats pipe function](#stats-pipe-functions) calculates the number of selected logs.
+`count()` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the number of selected logs.
 
 For example, the following query returns the number of logs over the last 5 minutes:
 
@@ -4204,16 +4264,16 @@ _time:5m | stats count(foo*)
 
 See also:
 
-- [`rate`](#rate-stats)
-- [`rate_sum`](#rate_sum-stats)
-- [`count_uniq`](#count_uniq-stats)
-- [`count_empty`](#count_empty-stats)
-- [`sum`](#sum-stats)
-- [`avg`](#avg-stats)
+- [`rate`](https://docs.victoriametrics.com/victorialogs/logsql/#rate-stats)
+- [`rate_sum`](https://docs.victoriametrics.com/victorialogs/logsql/#rate_sum-stats)
+- [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)
+- [`count_empty`](https://docs.victoriametrics.com/victorialogs/logsql/#count_empty-stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
 
 ### count_empty stats
 
-`count_empty(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the number of logs with empty `(field1, ..., fieldN)` tuples.
+`count_empty(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the number of logs with empty `(field1, ..., fieldN)` tuples.
 
 For example, the following query calculates the number of logs with empty `username` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 during the last 5 minutes:
@@ -4231,12 +4291,12 @@ _time:5m | stats count_empty(foo*)
 
 See also:
 
-- [`count`](#count-stats)
-- [`count_uniq`](#count_uniq-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
+- [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)
 
 ### count_uniq stats
 
-`count_uniq(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the number of unique non-empty `(field1, ..., fieldN)` tuples.
+`count_uniq(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the number of unique non-empty `(field1, ..., fieldN)` tuples.
 
 For example, the following query returns the number of unique non-empty values for `ip` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 over the last 5 minutes:
@@ -4261,18 +4321,18 @@ up to `1_000_000` unique values for the `ip` field:
 _time:5m | stats count_uniq(ip) limit 1_000_000 as ips_1_000_000
 ```
 
-If it is OK to count an estimated number of unique values, then [`count_uniq_hash`](#count_uniq_hash-stats) can be used as faster alternative to `count_uniq`.
+If it is OK to count an estimated number of unique values, then [`count_uniq_hash`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq_hash-stats) can be used as faster alternative to `count_uniq`.
 
 See also:
 
-- [`count_uniq_hash`](#count_uniq_hash-stats)
-- [`uniq_values`](#uniq_values-stats)
-- [`count`](#count-stats)
+- [`count_uniq_hash`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq_hash-stats)
+- [`uniq_values`](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
 
 ### count_uniq_hash stats
 
-`count_uniq_hash(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the number of unique hashes for non-empty `(field1, ..., fieldN)` tuples.
-This is a good estimation for the number of unique values in general case, while it works faster and uses less memory than [`count_uniq`](#count_uniq-stats)
+`count_uniq_hash(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the number of unique hashes for non-empty `(field1, ..., fieldN)` tuples.
+This is a good estimation for the number of unique values in general case, while it works faster and uses less memory than [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)
 when counting big number of unique values.
 
 For example, the following query returns an estimated number of unique non-empty values for `ip` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4291,13 +4351,13 @@ _time:5m | stats count_uniq_hash(host, path) unique_host_path_pairs
 
 See also:
 
-- [`count_uniq`](#count_uniq-stats)
-- [`uniq_values`](#uniq_values-stats)
-- [`count`](#count-stats)
+- [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)
+- [`uniq_values`](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
 
 ### histogram stats
 
-`histogram(field)` [stats pipe function](#stats-pipe-functions) returns [VictoriaMetrics histogram buckets](https://valyala.medium.com/improving-histogram-usability-for-prometheus-and-grafana-bc7e5df0e350)
+`histogram(field)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns [VictoriaMetrics histogram buckets](https://valyala.medium.com/improving-histogram-usability-for-prometheus-and-grafana-bc7e5df0e350)
 for the given [`field`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns histogram buckets for the `response_size` field grouped by `host` field, across logs for the last 5 minutes:
@@ -4306,9 +4366,9 @@ For example, the following query returns histogram buckets for the `response_siz
 _time:5m | stats by (host) histogram(response_size)
 ```
 
-If the field contains [duration value](#duration-values), then `histogram` normalizes it to nanoseconds. For example, `1.25ms` is normalized to `1_250_000`.
+If the field contains [duration value](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values), then `histogram` normalizes it to nanoseconds. For example, `1.25ms` is normalized to `1_250_000`.
 
-If the field contains [short numeric value](#short-numeric-values), then `histogram` normalizes it to numeric value without any suffixes. For example, `1KiB` is converted to `1024`.
+If the field contains [short numeric value](https://docs.victoriametrics.com/victorialogs/logsql/#short-numeric-values), then `histogram` normalizes it to numeric value without any suffixes. For example, `1KiB` is converted to `1024`.
 
 Histogram buckets are returned as the following JSON array:
 
@@ -4321,7 +4381,7 @@ while `hits` contains the number of values, which hit the given bucket.
 
 It may be handy to unroll the returned histogram buckets for further processing during the query. For example, the following query
 calculates a histogram over the `response_size` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-and then unrolls it into distinct rows with `vmrange` and `hits` fields with the help of [`unroll`](#unroll-pipe) and [`unpack_json`](#unpack_json-pipe) pipes:
+and then unrolls it into distinct rows with `vmrange` and `hits` fields with the help of [`unroll`](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe) and [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) pipes:
 
 ```logsql
 _time:5m
@@ -4332,14 +4392,14 @@ _time:5m
 
 See also:
 
-- [`quantile`](#quantile-stats)
-- [`unroll` pipe](#unroll-pipe)
-- [`unpack_json` pipe](#unpack_json-pipe)
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats)
+- [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe)
+- [`unpack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe)
 
 ### json_values stats
 
-`json_values(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) packs the given fields into JSON per every log entry and returns JSON array,
-which can be unrolled with [`unroll` pipe](#unroll-pipe).
+`json_values(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) packs the given fields into JSON per every log entry and returns JSON array,
+which can be unrolled with [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe).
 
 For example, the following query returns per-`app` JSON arrays containing [`_time`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field)
 and [`_msg`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field) fields for the last 5 minutes:
@@ -4379,15 +4439,15 @@ _time:5m | stats by (host) json_values() sort by (_time desc) limit 3 as json_lo
 
 See also:
 
-- [`unroll` pipe](#unroll-pipe)
-- [`row_min`](#row_min-stats)
-- [`row_max`](#row_max-stats)
-- [`row_any`](#row_any-stats)
-- [`values`](#values-stats)
+- [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe)
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats)
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats)
+- [`row_any`](https://docs.victoriametrics.com/victorialogs/logsql/#row_any-stats)
+- [`values`](https://docs.victoriametrics.com/victorialogs/logsql/#values-stats)
 
 ### max stats
 
-`max(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) returns the maximum value across
+`max(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns the maximum value across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the maximum value for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4399,18 +4459,18 @@ _time:5m | stats max(duration) max_duration
 
 It is possible to calculate the maximum value across all the fields with common prefix via `max(prefix*)` syntax.
 
-[`row_max`](#row_max-stats) function can be used for obtaining other fields with the maximum duration.
+[`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats) function can be used for obtaining other fields with the maximum duration.
 
 See also:
 
-- [`row_max`](#row_max-stats)
-- [`min`](#min-stats)
-- [`quantile`](#quantile-stats)
-- [`avg`](#avg-stats)
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats)
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
 
 ### median stats
 
-`median(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the estimated [median](https://en.wikipedia.org/wiki/Median) value across
+`median(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the estimated [median](https://en.wikipedia.org/wiki/Median) value across
 the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query return median for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4424,12 +4484,12 @@ It is possible to calculate the median across all the fields with common prefix
 
 See also:
 
-- [`quantile`](#quantile-stats)
-- [`avg`](#avg-stats)
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
 
 ### min stats
 
-`min(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) returns the minimum value across
+`min(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns the minimum value across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the minimum value for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4441,18 +4501,18 @@ _time:5m | stats min(duration) min_duration
 
 It is possible to find the minimum across all the fields with common prefix via `min(prefix*)` syntax.
 
-[`row_min`](#row_min-stats) function can be used for obtaining other fields with the minimum duration.
+[`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats) function can be used for obtaining other fields with the minimum duration.
 
 See also:
 
-- [`row_min`](#row_min-stats)
-- [`max`](#max-stats)
-- [`quantile`](#quantile-stats)
-- [`avg`](#avg-stats)
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats)
+- [`quantile`](https://docs.victoriametrics.com/victorialogs/logsql/#quantile-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
 
 ### quantile stats
 
-`quantile(phi, field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates an estimated `phi` [percentile](https://en.wikipedia.org/wiki/Percentile) over values
+`quantile(phi, field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates an estimated `phi` [percentile](https://en.wikipedia.org/wiki/Percentile) over values
 for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). The `phi` must be in the range `0 ... 1`, where `0` means `0th` percentile,
 while `1` means `100th` percentile.
 
@@ -4470,17 +4530,17 @@ It is possible to calculate the quantile across all the fields with common prefi
 
 See also:
 
-- [`histogram`](#histogram-stats)
-- [`min`](#min-stats)
-- [`max`](#max-stats)
-- [`median`](#median-stats)
-- [`avg`](#avg-stats)
+- [`histogram`](https://docs.victoriametrics.com/victorialogs/logsql/#histogram-stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats)
+- [`median`](https://docs.victoriametrics.com/victorialogs/logsql/#median-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
 
 ### rate stats
 
-`rate()` [stats pipe function](#stats-pipe-functions) returns the average per-second rate of matching logs on the selected time range.
+`rate()` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns the average per-second rate of matching logs on the selected time range.
 
-For example, the following query returns the average per-second rate of logs with the `error` [word](#word) over the last 5 minutes:
+For example, the following query returns the average per-second rate of logs with the `error` [word](https://docs.victoriametrics.com/victorialogs/logsql/#word) over the last 5 minutes:
 
 ```logsql
 _time:5m error | stats rate()
@@ -4488,12 +4548,12 @@ _time:5m error | stats rate()
 
 See also:
 
-- [`rate_sum`](#rate_sum-stats)
-- [`count`](#count-stats)
+- [`rate_sum`](https://docs.victoriametrics.com/victorialogs/logsql/#rate_sum-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
 
 ### rate_sum stats
 
-`rate_sum(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) returns the average per-second rate of the sum over the given
+`rate_sum(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns the average per-second rate of the sum over the given
 numeric [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the average per-second rate of the sum of `bytes_sent` [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4507,13 +4567,13 @@ It is possible to calculate the average per-second rate of the sum over all the
 
 See also:
 
-- [`sum`](#sum-stats)
-- [`rate`](#rate-stats)
+- [`sum`](https://docs.victoriametrics.com/victorialogs/logsql/#sum-stats)
+- [`rate`](https://docs.victoriametrics.com/victorialogs/logsql/#rate-stats)
 
 ### row_any stats
 
-`row_any()` [stats pipe function](#stats-pipe-functions) returns arbitrary [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
-(aka sample) per each selected [stats group](#stats-by-fields). Log entry is returned as JSON-encoded dictionary with all the fields from the original log.
+`row_any()` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns arbitrary [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+(aka sample) per each selected [stats group](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-fields). Log entry is returned as JSON-encoded dictionary with all the fields from the original log.
 
 For example, the following query returns a sample log entry per each [`_stream`](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields)
 across logs for the last 5 minutes:
@@ -4522,7 +4582,7 @@ across logs for the last 5 minutes:
 _time:5m | stats by (_stream) row_any() as sample_row
 ```
 
-Fields from the returned values can be decoded with [`unpack_json`](#unpack_json-pipe) or [`extract`](#extract-pipe) pipes.
+Fields from the returned values can be decoded with [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) or [`extract`](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) pipes.
 
 If only the specific fields are needed, then they can be enumerated inside `row_any(...)`.
 For example, the following query returns only `_time` and `path` fields from a sample log entry for logs over the last 5 minutes:
@@ -4535,13 +4595,13 @@ It is possible to return all the fields starting with particular prefix by using
 
 See also:
 
-- [`row_max`](#row_max-stats)
-- [`row_min`](#row_min-stats)
-- [`json_values`](#json_values-stats)
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats)
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats)
+- [`json_values`](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats)
 
 ### row_max stats
 
-`row_max(field)` [stats pipe function](#stats-pipe-functions) returns [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+`row_max(field)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 with the maximum value for the given `field`. Log entry is returned as JSON-encoded dictionary with all the fields from the original log.
 
 For example, the following query returns log entry with the maximum value for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4551,7 +4611,7 @@ across logs for the last 5 minutes:
 _time:5m | stats row_max(duration) as log_with_max_duration
 ```
 
-Fields from the returned values can be decoded with [`unpack_json`](#unpack_json-pipe) or [`extract`](#extract-pipe) pipes.
+Fields from the returned values can be decoded with [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) or [`extract`](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) pipes.
 
 If only the specific fields are needed from the returned log entry, then they can be enumerated inside `row_max(...)`.
 For example, the following query returns only `_time`, `path` and `duration` fields from the log entry with the maximum `duration` over the last 5 minutes:
@@ -4564,14 +4624,14 @@ It is possible to return all the fields starting with particular prefix by using
 
 See also:
 
-- [`max`](#max-stats)
-- [`row_min`](#row_min-stats)
-- [`row_any`](#row_any-stats)
-- [`json_values`](#json_values-stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats)
+- [`row_min`](https://docs.victoriametrics.com/victorialogs/logsql/#row_min-stats)
+- [`row_any`](https://docs.victoriametrics.com/victorialogs/logsql/#row_any-stats)
+- [`json_values`](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats)
 
 ### row_min stats
 
-`row_min(field)` [stats pipe function](#stats-pipe-functions) returns [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
+`row_min(field)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns [log entry](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
 with the minimum value for the given `field`. Log entry is returned as JSON-encoded dictionary with all the fields from the original log.
 
 For example, the following query returns log entry with the minimum value for the `duration` [field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model)
@@ -4581,7 +4641,7 @@ across logs for the last 5 minutes:
 _time:5m | stats row_min(duration) as log_with_min_duration
 ```
 
-Fields from the returned values can be decoded with [`unpack_json`](#unpack_json-pipe) or [`extract`](#extract-pipe) pipes.
+Fields from the returned values can be decoded with [`unpack_json`](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe) or [`extract`](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) pipes.
 
 If only the specific fields are needed from the returned log entry, then they can be enumerated inside `row_max(...)`.
 For example, the following query returns only `_time`, `path` and `duration` fields from the log entry with the minimum `duration` over the last 5 minutes:
@@ -4594,14 +4654,14 @@ It is possible to return all the fields starting with particular prefix by using
 
 See also:
 
-- [`min`](#min-stats)
-- [`row_max`](#row_max-stats)
-- [`row_any`](#row_any-stats)
-- [`json_values`](#json_values-stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats)
+- [`row_max`](https://docs.victoriametrics.com/victorialogs/logsql/#row_max-stats)
+- [`row_any`](https://docs.victoriametrics.com/victorialogs/logsql/#row_any-stats)
+- [`json_values`](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats)
 
 ### sum stats
 
-`sum(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the sum of numeric values across
+`sum(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the sum of numeric values across
 all the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 Non-numeric values are skipped. If all the values across `field1`, ..., `fieldN` are non-numeric, then `NaN` is returned.
 
@@ -4616,14 +4676,14 @@ It is possible to find the sum for all the fields with common prefix via `sum(pr
 
 See also:
 
-- [`count`](#count-stats)
-- [`avg`](#avg-stats)
-- [`max`](#max-stats)
-- [`min`](#min-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
+- [`avg`](https://docs.victoriametrics.com/victorialogs/logsql/#avg-stats)
+- [`max`](https://docs.victoriametrics.com/victorialogs/logsql/#max-stats)
+- [`min`](https://docs.victoriametrics.com/victorialogs/logsql/#min-stats)
 
 ### sum_len stats
 
-`sum_len(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) calculates the sum of byte lengths of all the values
+`sum_len(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) calculates the sum of byte lengths of all the values
 for the given [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 
 For example, the following query returns the sum of byte lengths of [`_msg` fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#message-field)
@@ -4637,12 +4697,12 @@ It is possible to find the sum of byte lengths for all the fields with common pr
 
 See also:
 
-- [`count`](#count-stats)
-- [`len` pipe](#len-pipe)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
+- [`len` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#len-pipe)
 
 ### uniq_values stats
 
-`uniq_values(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) returns the unique non-empty values across
+`uniq_values(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns the unique non-empty values across
 the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 The returned values are encoded in sorted JSON array.
 
@@ -4653,7 +4713,7 @@ over logs for the last 5 minutes:
 _time:5m | stats uniq_values(ip) unique_ips
 ```
 
-The returned unique ip addresses can be unrolled into distinct log entries with [`unroll` pipe](#unroll-pipe).
+The returned unique ip addresses can be unrolled into distinct log entries with [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe).
 
 Every unique value is stored in memory during query execution. Big number of unique values may require a lot of memory. Sometimes it is enough to return
 only a subset of unique values. In this case add `limit N` after `uniq_values(...)` in order to limit the number of returned unique values to `N`,
@@ -4671,15 +4731,15 @@ It is possible to find unique values for all the fields with common prefix via `
 
 See also:
 
-- [`uniq` pipe](#uniq-pipe)
-- [`values`](#values-stats)
-- [`count_uniq`](#count_uniq-stats)
-- [`count_uniq_hash`](#count_uniq_hash-stats)
-- [`count`](#count-stats)
+- [`uniq` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#uniq-pipe)
+- [`values`](https://docs.victoriametrics.com/victorialogs/logsql/#values-stats)
+- [`count_uniq`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)
+- [`count_uniq_hash`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq_hash-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
 
 ### values stats
 
-`values(field1, ..., fieldN)` [stats pipe function](#stats-pipe-functions) returns all the values (including empty values)
+`values(field1, ..., fieldN)` [stats pipe function](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe-functions) returns all the values (including empty values)
 for the mentioned [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
 The returned values are encoded in JSON array.
 
@@ -4690,68 +4750,68 @@ over logs for the last 5 minutes:
 _time:5m | stats values(ip) ips
 ```
 
-The returned ip addresses can be unrolled into distinct log entries with [`unroll` pipe](#unroll-pipe).
+The returned ip addresses can be unrolled into distinct log entries with [`unroll` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#unroll-pipe).
 
 It is possible to get values for all the fields with common prefix via `values(prefix*)` syntax.
 
 See also:
 
-- [`json_values`](#json_values-stats)
-- [`uniq_values`](#uniq_values-stats)
-- [`count`](#count-stats)
-- [`count_empty`](#count_empty-stats)
+- [`json_values`](https://docs.victoriametrics.com/victorialogs/logsql/#json_values-stats)
+- [`uniq_values`](https://docs.victoriametrics.com/victorialogs/logsql/#uniq_values-stats)
+- [`count`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats)
+- [`count_empty`](https://docs.victoriametrics.com/victorialogs/logsql/#count_empty-stats)
 
 ## Stream context
 
-See [`stream_context` pipe](#stream_context-pipe).
+See [`stream_context` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stream_context-pipe).
 
 ## Transformations
 
-LogsQL supports the following transformations on the log entries selected with [filters](#filters):
+LogsQL supports the following transformations on the log entries selected with [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters):
 
 - Extracting arbitrary text from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) according to the provided pattern.
-  See [these docs](#extract-pipe) for details.
-- Unpacking JSON fields from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](#unpack_json-pipe).
-- Unpacking [logfmt](https://brandur.org/logfmt) fields from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](#unpack_logfmt-pipe).
-- Unpacking [Syslog](https://en.wikipedia.org/wiki/Syslog) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](#unpack_syslog-pipe).
-- Creating a new field from existing [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) according to the provided format. See [`format` pipe](#format-pipe).
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#extract-pipe) for details.
+- Unpacking JSON fields from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_json-pipe).
+- Unpacking [logfmt](https://brandur.org/logfmt) fields from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_logfmt-pipe).
+- Unpacking [Syslog](https://en.wikipedia.org/wiki/Syslog) messages from [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#unpack_syslog-pipe).
+- Creating a new field from existing [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) according to the provided format. See [`format` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#format-pipe).
 - Replacing substrings in the given [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model).
-  See [`replace` pipe](#replace-pipe) and [`replace_regexp` pipe](#replace_regexp-pipe) docs.
-- Creating a new field according to math calculations over existing [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [`math` pipe](#math-pipe).
+  See [`replace` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace-pipe) and [`replace_regexp` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#replace_regexp-pipe) docs.
+- Creating a new field according to math calculations over existing [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model). See [`math` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#math-pipe).
 
-See also [other pipes](#pipes), which can be applied to the selected logs.
+See also [other pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes), which can be applied to the selected logs.
 
-It is also possible to perform various transformations on the [selected log entries](#filters) at client side
+It is also possible to perform various transformations on the [selected log entries](https://docs.victoriametrics.com/victorialogs/logsql/#filters) at client side
 with `jq`, `awk`, `cut`, etc. Unix commands according to [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line).
 
 ## Post-filters
 
-Post-filtering of query results can be performed at any step by using [`filter` pipe](#filter-pipe).
+Post-filtering of query results can be performed at any step by using [`filter` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#filter-pipe).
 
-It is also possible to perform post-filtering of the [selected log entries](#filters) at client side with `grep` and similar Unix commands
+It is also possible to perform post-filtering of the [selected log entries](https://docs.victoriametrics.com/victorialogs/logsql/#filters) at client side with `grep` and similar Unix commands
 according to [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line).
 
 ## Stats
 
-Stats over the selected logs can be calculated via [`stats` pipe](#stats-pipe).
+Stats over the selected logs can be calculated via [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe).
 
-It is also possible to perform stats calculations on the [selected log entries](#filters) at client side with `sort`, `uniq`, etc. Unix commands
+It is also possible to perform stats calculations on the [selected log entries](https://docs.victoriametrics.com/victorialogs/logsql/#filters) at client side with `sort`, `uniq`, etc. Unix commands
 according to [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line).
 
 ## Sorting
 
-By default VictoriaLogs doesn't sort the returned results because of performance reasons. Use [`sort` pipe](#sort-pipe) for sorting the results.
+By default VictoriaLogs doesn't sort the returned results because of performance reasons. Use [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) for sorting the results.
 
 ## Limiters
 
-LogsQL provides the following [pipes](#pipes) for limiting the number of returned log entries:
+LogsQL provides the following [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) for limiting the number of returned log entries:
 
-- [`fields`](#fields-pipe) and [`delete`](#delete-pipe) pipes allow limiting the set of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) to return.
-- [`limit` pipe](#limit-pipe) allows limiting the number of log entries to return.
+- [`fields`](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) and [`delete`](https://docs.victoriametrics.com/victorialogs/logsql/#delete-pipe) pipes allow limiting the set of [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) to return.
+- [`limit` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#limit-pipe) allows limiting the number of log entries to return.
 
 ## Querying specific fields
 
-Specific log fields can be queried via [`fields` pipe](#fields-pipe).
+Specific log fields can be queried via [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe).
 
 ## String literals
 
@@ -4780,8 +4840,8 @@ LogsQL accepts numeric values in the following formats:
 
 - regular integers like `12345` or `-12345`
 - regular floating point numbers like `0.123` or `-12.34`
-- [short numeric format](#short-numeric-values)
-- [duration format](#duration-values)
+- [short numeric format](https://docs.victoriametrics.com/victorialogs/logsql/#short-numeric-values)
+- [duration format](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values)
 
 ### Short numeric values
 
@@ -4819,58 +4879,108 @@ Internally duration values are converted into nanoseconds.
 
 ## Performance tips
 
-- It is highly recommended specifying [time filter](#time-filter) in order to narrow down the search to specific time range.
-- It is highly recommended specifying [stream filter](#stream-filter) in order to narrow down the search
+- It is highly recommended specifying [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) in order to narrow down the search to specific time range.
+- It is highly recommended specifying [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter) in order to narrow down the search
   to specific [log streams](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
 - It is recommended specifying [log fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) you need in query results
-  with the [`fields` pipe](#fields-pipe), if the selected log entries contain big number of fields, which aren't interesting to you.
+  with the [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe), if the selected log entries contain big number of fields, which aren't interesting to you.
   This saves disk read IO and CPU time needed for reading and unpacking all the log fields from disk.
-- Move faster filters such as [word filter](#word-filter) and [phrase filter](#phrase-filter) to the beginning of the query.
-  This rule doesn't apply to [time filter](#time-filter) and [stream filter](#stream-filter), which can be put at any place of the query.
+- Move faster filters such as [word filter](https://docs.victoriametrics.com/victorialogs/logsql/#word-filter) and [phrase filter](https://docs.victoriametrics.com/victorialogs/logsql/#phrase-filter)
+  to the beginning of the query.
+  This rule doesn't apply to [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) and [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter),
+  which can be put at any place of the query.
 - Move more specific filters, which match lower number of log entries, to the beginning of the query.
-  This rule doesn't apply to [time filter](#time-filter) and [stream filter](#stream-filter), which can be put at any place of the query.
-- If the selected logs are passed to [pipes](#pipes) for further transformations and statistics' calculations, then it is recommended
-  reducing the number of selected logs by using more specific [filters](#filters), which return lower number of logs to process by [pipes](#pipes).
+  This rule doesn't apply to [time filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) and [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter),
+  which can be put at any place of the query.
+- If the selected logs are passed to [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) for further transformations and statistics' calculations, then it is recommended
+  reducing the number of selected logs by using more specific [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters),
+  which return lower number of logs to process by [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes).
+- If the logs are stored at high-latency storage systems such as NFS or S3, then increasing the number of parallel readers can help improving query performance.
+  See [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#parallel_readers-query-option) for details.
 
 ## Query options
 
-VictoriaLogs supports the following options, which can be passed in the beginning of [LogsQL query](#query-syntax) `<q>` via `options(opt1=v1, ..., optN=vN) <q>` syntax:
+VictoriaLogs supports the following options, which can be passed in the beginning of [LogsQL query](https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax) `<q>`
+via `options(opt1=v1, ..., optN=vN) <q>` syntax:
 
-- `concurrency` - query concurrency. By default the query is executed in parallel on all the available CPU cores.
-  This usually provides the best query performance. Sometimes it is needed to reduce the number of used CPU cores,
-  in order to reduce RAM usage and/or CPU usage.
-  This can be done by setting `concurrency` option to the value smaller than the number of available CPU cores.
-  For example, the following query executes on at max 2 CPU cores:
+### `concurrency` query option
 
-  ```logsql
-  options(concurrency=2) _time:1d | count_uniq(user_id)
-  ```
+VictoriaLogs executes each query on all the available CPU cores in parallel.
+This usually provides the best query performance. Sometimes it is needed to reduce the number of used CPU cores,
+in order to reduce RAM usage and/or CPU usage.
+This can be done by setting `concurrency` option to the value smaller than the number of available CPU cores.
+For example, the following query executes on at max 2 CPU cores:
 
-- `time_offset` – subtracts the given offset from all the [time filters](#time-filter) in the query,
-  and then adds the given offset to the selected [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) values
-  before passing them to query [pipes](#pipes). Allows comparing query results for the same duration at different offsets.
-  Accepts any [duration value](#duration-values) like `12h`, `1d`, `1y`. For example, the following query returns the number of logs with `error` [words](#word)
-  over the last hour 7 days ago.
+```logsql
+options(concurrency=2) _time:1d | count_uniq(user_id)
+```
 
-  ```logsql
-  options(time_offset=7d) _time:1h error | stats count() as 'errors_7d_ago'
-  ```
+The `concurrency` option is applied individually to every `vlstorage` node in [VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/).
 
-- `ignore_global_time_filter` - allows ignoring time filter from `start` and `end` args of [HTTP querying API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
-  for the given (sub)query. For example, the following query returns the number of logs with `user_id` values seen in logs during December 2024, on the `[start...end]`
-  time range passed to [`/api/v1/query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs):
+See also [`parallel_readers` query option](https://docs.victoriametrics.com/victorialogs/logsql/#parallel_readers-query-option).
 
-  ```logsql
-  user_id:in(options(ignore_global_time_filter=true) _time:2024-12Z | keep user_id) | count()
-  ```
+### `parallel_readers` query option
 
-  The `in(...)` [subquery](#subquery-filter) without `options(ignore_global_time_filter=true)`
-  takes into account only `user_id` values on the intersection of December 2024 and `[start...end]` time range passed
-  to [`/api/v1/query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs):
+VictoriaLogs uses parallel data readers for query execution. The default number of parallel readers fits the majority of practical use cases.
+Sometimes it may be needed to configure it on a per-query basis (for example, to increase query performance by increasing the number of parallel readers
+when the logs are stored on the persistent storage with high read latency such as NFS or S3).
+This can be done via `parallel_readers` query option. For example, the following query uses 100 parallel readers:
 
-  ```logsql
-  user_id:in(_time:2024-12Z | keep user_id) | count()
-  ```
+```logsql
+options(parallel_readers=100) _time:1d error | count()
+```
+
+If the `parallel_readers` option isn't set, while [`concurrency` option](https://docs.victoriametrics.com/victorialogs/logsql/#concurrency-query-option) is set
+then the number of parallel readers equals to the `concurrency`.
+
+The default number of parallel readers can be configured via `-defaultParallelReaders` command-line flag.
+
+The `parallel_readers` option is applied individually to every `vlstorage` node in [VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/).
+
+Note that too big number of parallel readers may result in excess usage of RAM and CPU.
+
+### `time_offset` query option
+
+`time_offset` query option subtracts the given offset from all the [time filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) in the query,
+and then adds the given offset to the selected [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field) values
+before passing them to query [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes). Allows comparing query results for the same duration at different offsets.
+Accepts [duration values](https://docs.victoriametrics.com/victorialogs/logsql/#duration-values) like `12h`, `1d`, `1y`.
+For example, the following query returns the number of logs with `error` [words](https://docs.victoriametrics.com/victorialogs/logsql/#word)
+over the last hour 7 days ago.
+
+```logsql
+options(time_offset=7d) _time:1h error | stats count() as 'errors_7d_ago'
+```
+
+### `ignore_global_time_filter` query option
+
+`ignore_global_time_filter` query option allows ignoring time filter from `start` and `end` args of [HTTP querying API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
+for the given (sub)query. For example, the following query returns the number of logs with `user_id` values seen in logs during December 2024, on the `[start...end]`
+time range passed to [`/api/v1/query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs):
+
+```logsql
+user_id:in(options(ignore_global_time_filter=true) _time:2024-12Z | keep user_id) | count()
+```
+
+The `in(...)` [subquery](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter) without `options(ignore_global_time_filter=true)`
+takes into account only `user_id` values on the intersection of December 2024 and `[start...end]` time range passed
+to [`/api/v1/query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs):
+
+```logsql
+user_id:in(_time:2024-12Z | keep user_id) | count()
+```
+
+### `allow_partial_response` query option
+
+`allow_partial_response` query option can be used in [VictoriaLogs cluster setup](https://docs.victoriametrics.com/victorialogs/cluster/)
+for allowing partial responses when some of `vlstorage` nodes are unavailable for querying. For example, the following query returns
+logs for the last 5 minutes when some of the `vlstorage` nodes are unavailable (so the response may miss some logs, which are stored on the unavailable `vlstorage` nodes):
+
+```logsql
+options(allow_partial_response=true) _time:5m
+```
+
+See also [partial response docs](https://docs.victoriametrics.com/victorialogs/querying/#partial-responses).
 
 ## Troubleshooting
 
@@ -4881,7 +4991,7 @@ Use these steps to help you understand your query and improve its speed.
 
 ### Check how many logs your query matches
 
-You can do this by putting the [`| count()`](#count-stats) after every filter or pipe that might change the number of rows.
+You can do this by putting the [`| count()`](https://docs.victoriametrics.com/victorialogs/logsql/#count-stats) after every filter or pipe that might change the number of rows.
 
 Suppose you have the following query, which executes slowly:
 
@@ -4889,7 +4999,7 @@ Suppose you have the following query, which executes slowly:
 _time:5m host:"api-" level:error "database" | stats by (app) count()
 ```
 
-Substitute all the [pipes](#pipes) in the query with `| count()` and
+Substitute all the [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) in the query with `| count()` and
 run the updated query to see the total number of matching logs:
 
 ```logsql
@@ -4927,15 +5037,15 @@ _time:5m host:"api-" | count()
 _time:5m "database" | count()
 ```
 
-The [`_time` filter](#time-filter) is the essential one - if it is missing, then VictoriaLogs literally scans all the logs stored in the database.
+The [`_time` filter](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) is the essential one - if it is missing, then VictoriaLogs literally scans all the logs stored in the database.
 The `_time` filter allows reducing the amounts of logs to scan to the given time range only. Note that [Web UI for VictoriaLogs](https://docs.victoriametrics.com/victorialogs/querying/#web-ui)
 and [Grafana plugin for VictoriaLogs](https://docs.victoriametrics.com/victorialogs/victorialogs-datasource/) automatically set the `_time` filter to the actually selected time range,
 so there is no need in specifying it manually in the query.
 
 ### Test stream filters in the query
 
-If the query doesn't contain [log stream filters](#stream-filter), VictoriaLogs needs to read and scan all the data blocks on the selected time range.
-If you add a [log stream filter](#stream-filter), like this:
+If the query doesn't contain [log stream filters](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter), VictoriaLogs needs to read and scan all the data blocks on the selected time range.
+If you add a [log stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter), like this:
 
 ```logsql
 {app="nginx"}
@@ -4949,8 +5059,8 @@ However, if your [log stream](https://docs.victoriametrics.com/victorialogs/keyc
 app:=nginx
 ```
 
-Then VictoriaLogs treats it as a regular ["exact match" filter](#exact-filter) and scans all the data blocks, so it will not be as fast as the corresponding stream filter.
-Make sure to use the correct stream filter syntax. See [stream filters docs](#stream-filter) for details.
+Then VictoriaLogs treats it as a regular ["exact match" filter](https://docs.victoriametrics.com/victorialogs/logsql/#exact-filter) and scans all the data blocks, so it will not be as fast as the corresponding stream filter.
+Make sure to use the correct stream filter syntax. See [stream filters docs](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter) for details.
 
 ### Check the number of unique log streams
 
@@ -4959,7 +5069,7 @@ Log stream filters can help improving query performance, but they are not a magi
 - If you have too many log streams, and each stream only covers a few logs, query performance can drop significantly.
 - If the log stream you are searching in covers big number of logs (e.g. hundreds of millions and more), searching in that stream can be slow.
 
-To check the number of log streams on the given time range, keep only the time filter and add `| count_uniq(_stream_id)` at the end of the query (see [`count_uniq` docs](#count_uniq-stats)).
+To check the number of log streams on the given time range, keep only the time filter and add `| count_uniq(_stream_id)` at the end of the query (see [`count_uniq` docs](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats)).
 For example, to see how many log streams you have in the last day:
 
 ```logsql
@@ -4976,13 +5086,13 @@ The result could be:
 
 This means that the logs over the last day contain 954 unique log streams.
 
-The following query returns top 10 log streams with the biggest number of streams (it uses [`top` pipe](#top-pipe)):
+The following query returns top 10 log streams with the biggest number of streams (it uses [`top` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#top-pipe)):
 
 ```logsql
 _time:1d | top 10 by (_stream)
 ```
 
-The following query returns the number of unique log streams and the number of logs for the `{app="nginx"}` [stream filter](#stream-filter) over the last day:
+The following query returns the number of unique log streams and the number of logs for the `{app="nginx"}` [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter) over the last day:
 
 ```logsql
 _time:1d {app="nginx"}
@@ -4991,14 +5101,14 @@ _time:1d {app="nginx"}
       count() as logs
 ```
 
-It uses [`stats` pipe](#stats-pipe).
+It uses [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe).
 
 Streams with small number of logs usually happen when one or more stream fields have too many different values.
 In these cases it is better to remove those fields from the set of log stream fields - see [these docs](https://docs.victoriametrics.com/victorialogs/keyconcepts/#high-cardinality).
 
 ### Identify the most costly parts of the query
 
-To see which parts of your logs take up the most space or slow down searches, you can use the [`block_stats` pipe](#block_stats-pipe).
+To see which parts of your logs take up the most space or slow down searches, you can use the [`block_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#block_stats-pipe).
 It returns detailed per-block statistics for your data.
 
 Start with your usual query. Then add the pipe `| keep <field list> | block_stats`:
@@ -5007,10 +5117,10 @@ Start with your usual query. Then add the pipe `| keep <field list> | block_stat
 _time:1d | keep kubernetes.pod_name, kubernetes.pod_namespace | block_stats
 ```
 
-The [`keep` pipe](#fields-pipe) keeps only the enumerated log fields and removes the others, so you get statistics just for the fields you care about.
-Include every field that appears in [filters](#filters) or [pipes](#pipes) of the analyzed query.
+The [`keep` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) keeps only the enumerated log fields and removes the others, so you get statistics just for the fields you care about.
+Include every field that appears in [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters) or [pipes](https://docs.victoriametrics.com/victorialogs/logsql/#pipes) of the analyzed query.
 
-Sometimes, the raw numbers returned by `stats` pipe are still too detailed to be useful. You can add the [`stats` pipe](#stats-pipe) to summarize the numbers:
+Sometimes, the raw numbers returned by `stats` pipe are still too detailed to be useful. You can add the [`stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-pipe) to summarize the numbers:
 
 ```logsql
 _time:1d
@@ -5035,7 +5145,7 @@ When you know which fields are expensive, you can decide whether to drop the noi
 
 You can find more details here: [How to determine which log fields occupy the most of disk space?](https://docs.victoriametrics.com/victorialogs/faq/#how-to-determine-which-log-fields-occupy-the-most-of-disk-space).
 
-It might be useful to add the [`query_stats` pipe](#query_stats-pipe) to the end of the query in order to understand how much data of different types the query reads and processes.
+It might be useful to add the [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe) to the end of the query in order to understand how much data of different types the query reads and processes.
 
 ### Profile pipes incrementally
 
@@ -5110,11 +5220,11 @@ _time:5m error contains_any("access denied", "unauthorized", "403") "user_id=("
 
 If the query becomes slow or starts using a lot of RAM after adding the next filter or pipe, you will know exactly which part of the query to fix.
 
-It might be useful to add the [`query_stats` pipe](#query_stats-pipe) to the end of the query in order to understand how much data of different types the query reads and processes.
+It might be useful to add the [`query_stats` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#query_stats-pipe) to the end of the query in order to understand how much data of different types the query reads and processes.
 
 If you find a slow filter or pipe, try these ideas:
 
-- Regex matching and JSON parsing are expensive. Use faster alternatives if you can. See [performance tips](#performance-tips).
-- Sorting without a limit with [`sort` pipe](#sort-pipe) stores all logs in memory. Add a `limit` or reduce the input number of logs.
-- High-cardinality functions like [`count_uniq()`](#count_uniq-stats) track every unique value in memory. Think how to reduce the number of unique values to track.
-- Large group counts in [`stats by (...)`](#stats-by-fields) can use a lot of memory. Filter or transform your data to reduce the number of groups.
+- Regex matching and JSON parsing are expensive. Use faster alternatives if you can. See [performance tips](https://docs.victoriametrics.com/victorialogs/logsql/#performance-tips).
+- Sorting without a limit with [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) stores all logs in memory. Add a `limit` or reduce the input number of logs.
+- High-cardinality functions like [`count_uniq()`](https://docs.victoriametrics.com/victorialogs/logsql/#count_uniq-stats) track every unique value in memory. Think how to reduce the number of unique values to track.
+- Large group counts in [`stats by (...)`](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-fields) can use a lot of memory. Filter or transform your data to reduce the number of groups.
diff --git a/docs/victorialogs/metrics.md b/docs/victorialogs/metrics.md
index 4028d30cbe..89b74c5819 100644
--- a/docs/victorialogs/metrics.md
+++ b/docs/victorialogs/metrics.md
@@ -1,12 +1,12 @@
 ---
-weight: 10
-title: VictoriaLogs metrics
+weight: 20
+title: Metrics of VictoriaLogs
 menu:
   docs:
     parent: victorialogs
     identifier: victorialogs-metrics
-    weight: 10
-    title: VictoriaLogs metrics
+    weight: 20
+    title: Metrics of VictoriaLogs
 tags:
   - logs
   - metrics
@@ -21,17 +21,17 @@ These metrics follow the Prometheus exposition format and can be used for monito
 
 ## Table of Contents
 
-- [HTTP Request Metrics](#http-request-metrics)
-- [Data Ingestion Metrics](#data-ingestion-metrics)
-- [Storage System Metrics](#storage-system-metrics)
-- [Merge Operation Metrics](#merge-operation-metrics)
-- [Query Performance Metrics](#query-performance-metrics)
-- [Concurrency and Resource Metrics](#concurrency-and-resource-metrics)
-- [Stream and Index Metrics](#stream-and-index-metrics)
-- [System Resource Metrics](#system-resource-metrics)
-- [Cluster Remote Operation Metrics](#cluster-remote-operation-metrics)
-- [Specialized Metrics](#specialized-metrics)
-- [Error and Network Metrics](#error-and-network-metrics)
+- [HTTP Request Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#http-request-metrics)
+- [Data Ingestion Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#data-ingestion-metrics)
+- [Storage System Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#storage-system-metrics)
+- [Merge Operation Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#merge-operation-metrics)
+- [Query Performance Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#query-performance-metrics)
+- [Concurrency and Resource Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#concurrency-and-resource-metrics)
+- [Stream and Index Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#stream-and-index-metrics)
+- [System Resource Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#system-resource-metrics)
+- [Cluster Remote Operation Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#cluster-remote-operation-metrics)
+- [Specialized Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#specialized-metrics)
+- [Error and Network Metrics](https://docs.victoriametrics.com/victorialogs/metrics/#error-and-network-metrics)
 
 ## HTTP Request Metrics
 
@@ -183,11 +183,11 @@ These metrics follow the Prometheus exposition format and can be used for monito
 
 ### vl_storage_per_query_values_read_bytes
 **Type:** Histogram
-**Description:** Bytes read from disk for log field values during query execution. The query engine reads compressed log values from disk to match search filters. Higher values suggest queries are accessing log fields, which occupy a lot of disk space. See also [`vl_storage_per_query_uncompressed_values_processed_bytes`](#vl_storage_per_query_uncompressed_values_processed_bytes) and [`vl_storage_per_query_read_values`](#vl_storage_per_query_read_values).
+**Description:** Bytes read from disk for log field values during query execution. The query engine reads compressed log values from disk to match search filters. Higher values suggest queries are accessing log fields, which occupy a lot of disk space. See also [`vl_storage_per_query_uncompressed_values_processed_bytes`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_uncompressed_values_processed_bytes) and [`vl_storage_per_query_read_values`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_read_values).
 
 ### vl_storage_per_query_timestamps_read_bytes
 **Type:** Histogram
-**Description:** Bytes read from disk for `_time` field during query execution. See also [`vl_storage_per_query_read_timestamps`](#vl_storage_per_query_read_timestamps).
+**Description:** Bytes read from disk for `_time` field during query execution. See also [`vl_storage_per_query_read_timestamps`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_read_timestamps).
 
 ### vl_storage_per_query_bloom_filters_read_bytes
 **Type:** Histogram
@@ -207,23 +207,23 @@ These metrics follow the Prometheus exposition format and can be used for monito
 
 ### vl_storage_per_query_processed_blocks
 **Type:** Histogram
-**Description:** The number of data blocks processed during query execution. This counts all the blocks that pass initial filtering for further query processing. High values suggest queries are scanning many blocks and may need more narrow [time filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) or [log stream filters](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter). See also [`vl_storage_per_query_processed_rows`](#vl_storage_per_query_processed_rows).
+**Description:** The number of data blocks processed during query execution. This counts all the blocks that pass initial filtering for further query processing. High values suggest queries are scanning many blocks and may need more narrow [time filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) or [log stream filters](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter). See also [`vl_storage_per_query_processed_rows`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_processed_rows).
 
 ### vl_storage_per_query_processed_rows
 **Type:** Histogram
-**Description:** The number of log entries processed during query execution. This counts all the rows that pass initial filtering for further query processing. High values suggest queries are scanning many rows and may need more narrow [time filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) or [log stream filters](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter). See also [`vl_storage_per_query_processed_blocks`](#vl_storage_per_query_processed_blocks).
+**Description:** The number of log entries processed during query execution. This counts all the rows that pass initial filtering for further query processing. High values suggest queries are scanning many rows and may need more narrow [time filters](https://docs.victoriametrics.com/victorialogs/logsql/#time-filter) or [log stream filters](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter). See also [`vl_storage_per_query_processed_blocks`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_processed_blocks).
 
 ### vl_storage_per_query_read_values
 **Type:** Histogram
-**Description:** The number of field values read during query execution. Select only the needed fields with the [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) in order to reduce the number of values read during query. See also [`vl_storage_per_query_values_read_bytes`](#vl_storage_per_query_values_read_bytes) and [`vl_storage_per_query_uncompressed_values_processed_bytes`](#vl_storage_per_query_uncompressed_values_processed_bytes).
+**Description:** The number of field values read during query execution. Select only the needed fields with the [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) in order to reduce the number of values read during query. See also [`vl_storage_per_query_values_read_bytes`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_values_read_bytes) and [`vl_storage_per_query_uncompressed_values_processed_bytes`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_uncompressed_values_processed_bytes).
 
 ### vl_storage_per_query_read_timestamps
 **Type:** Histogram
-**Description:** The number of timestamps read during query execution. See also [`vl_storage_per_query_timestamps_read_bytes`](#vl_storage_per_query_timestamps_read_bytes)
+**Description:** The number of timestamps read during query execution. See also [`vl_storage_per_query_timestamps_read_bytes`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_timestamps_read_bytes)
 
 ### vl_storage_per_query_uncompressed_values_processed_bytes
 **Type:** Histogram
-**Description:** Uncompressed bytes processed when reading field values during query exection. See also [`vl_storage_per_query_values_read_bytes`](#vl_storage_per_query_values_read_bytes) and [`vl_storage_per_query_read_values`](#vl_storage_per_query_read_values).
+**Description:** Uncompressed bytes processed when reading field values during query exection. See also [`vl_storage_per_query_values_read_bytes`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_values_read_bytes) and [`vl_storage_per_query_read_values`](https://docs.victoriametrics.com/victorialogs/metrics/#vl_storage_per_query_read_values).
 
 
 ## Concurrency and Resource Metrics
@@ -244,6 +244,10 @@ These metrics follow the Prometheus exposition format and can be used for monito
 **Type:** Gauge
 **Description:** Current number of queries actively executing. Real-time query processing load when the system approaches the `-search.maxConcurrentRequests` capacity limit.
 
+### vl_concurrent_internalselect_requests_wait_duration
+**Type:** Summary
+**Description:** The wait time for requests to [`/internal/select/*` at `vlstorage` nodes](https://docs.victoriametrics.com/victorialogs/cluster/) because of reaching the limit on the number of concurrently executed requests.
+
 ### vl_insert_processors_count
 **Type:** Gauge
 **Description:** Number of active processors currently handling data ingestion from different sources. Current ingestion pipeline utilization as streams start and finish processing.
diff --git a/docs/victorialogs/querying/README.md b/docs/victorialogs/querying/README.md
index b9ed56d4ae..3ca8ca21c4 100644
--- a/docs/victorialogs/querying/README.md
+++ b/docs/victorialogs/querying/README.md
@@ -10,32 +10,32 @@ sitemap:
 via the following ways:
 
 - [vlogscli](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/)
-- [Command-line interface](#command-line)
-- [HTTP API](#http-api)
-- [Web UI](#web-ui) - a web-based UI for querying logs
-- [Grafana plugin](#visualization-in-grafana)
+- [Command-line interface](https://docs.victoriametrics.com/victorialogs/querying/#command-line)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
+- [Web UI](https://docs.victoriametrics.com/victorialogs/querying/#web-ui) - a web-based UI for querying logs
+- [Grafana plugin](https://docs.victoriametrics.com/victorialogs/querying/#visualization-in-grafana)
 
 ## HTTP API
 
 VictoriaLogs provides the following HTTP endpoints:
 
-- [`/select/logsql/query`](#querying-logs) for querying logs.
-- [`/select/logsql/tail`](#live-tailing) for live tailing of query results.
-- [`/select/logsql/hits`](#querying-hits-stats) for querying log hits stats over the given time range.
-- [`/select/logsql/facets`](#querying-facets) for querying the most frequent values per each field seen in the selected logs.
-- [`/select/logsql/stats_query`](#querying-log-stats) for querying log stats at the given time.
-- [`/select/logsql/stats_query_range`](#querying-log-range-stats) for querying log stats over the given time range.
-- [`/select/logsql/stream_ids`](#querying-stream_ids) for querying `_stream_id` values of [log streams](#https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
-- [`/select/logsql/streams`](#querying-streams) for querying [log streams](#https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
-- [`/select/logsql/stream_field_names`](#querying-stream-field-names) for querying [log stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) field names.
-- [`/select/logsql/stream_field_values`](#querying-stream-field-values) for querying [log stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) field values.
-- [`/select/logsql/field_names`](#querying-field-names) for querying [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) names.
-- [`/select/logsql/field_values`](#querying-field-values) for querying [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values.
+- [`/select/logsql/query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs) for querying logs.
+- [`/select/logsql/tail`](https://docs.victoriametrics.com/victorialogs/querying/#live-tailing) for live tailing of query results.
+- [`/select/logsql/hits`](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats) for querying log hits stats over the given time range.
+- [`/select/logsql/facets`](https://docs.victoriametrics.com/victorialogs/querying/#querying-facets) for querying the most frequent values per each field seen in the selected logs.
+- [`/select/logsql/stats_query`](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats) for querying log stats at the given time.
+- [`/select/logsql/stats_query_range`](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-range-stats) for querying log stats over the given time range.
+- [`/select/logsql/stream_ids`](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream_ids) for querying `_stream_id` values of [log streams](https://docs.victoriametrics.com/victorialogs/querying/#https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
+- [`/select/logsql/streams`](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams) for querying [log streams](https://docs.victoriametrics.com/victorialogs/querying/#https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
+- [`/select/logsql/stream_field_names`](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-names) for querying [log stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) field names.
+- [`/select/logsql/stream_field_values`](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-values) for querying [log stream](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields) field values.
+- [`/select/logsql/field_names`](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-names) for querying [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) names.
+- [`/select/logsql/field_values`](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-values) for querying [log field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) values.
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Resource usage limits](#resource-usage-limits)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Resource usage limits](https://docs.victoriametrics.com/victorialogs/querying/#resource-usage-limits)
 
 ### Querying logs
 
@@ -49,7 +49,7 @@ curl http://localhost:9428/select/logsql/query -d 'query=error'
 
 This command returns all the logs with the `error` word, which are stored in the VictoriaLogs running at `localhost:9428`.
 There are no limits on the number of returned logs - the command above may return billions of logs without any issues.
-See [these docs](#command-line) for details.
+See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line) for details.
 
 The response by default contains all the [fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#data-model) for the selected logs.
 Use [`fields` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) for selecting only the needed fields.
@@ -103,14 +103,14 @@ Logs lines are sent to the response stream as soon as they are found in Victoria
 This means that the returned response may contain billions of lines for queries matching too many log entries.
 The response can be interrupted at any time by closing the connection to VictoriaLogs server.
 This allows post-processing the returned lines at the client side with the usual Unix commands such as `grep`, `jq`, `less`, `head`, etc.,
-without worrying about resource usage at VictoriaLogs side. See [these docs](#command-line) for more details.
+without worrying about resource usage at VictoriaLogs side. See [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line) for more details.
 
 The returned lines aren't sorted by default, since sorting disables the ability to send matching log entries to response stream as soon as they are found.
 Query results can be sorted in the following ways:
 
 - By passing `limit=N` query arg to `/select/logsql/query`. The up to `N` most recent matching log entries are returned in the response.
 - By adding [`sort` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#sort-pipe) to the query.
-- By using Unix `sort` command at client side according to [these docs](#command-line).
+- By using Unix `sort` command at client side according to [these docs](https://docs.victoriametrics.com/victorialogs/querying/#command-line).
 
 The maximum query execution time is limited by `-search.maxQueryDuration` command-line flag value. This limit can be overridden to smaller values
 on a per-query basis by passing the needed timeout via `timeout` query arg. For example, the following command limits query execution time
@@ -136,16 +136,16 @@ The `/select/logsql/query` returns `VL-Request-Duration-Seconds` HTTP header in
 See also:
 
 - [vlogscli](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/)
-- [Extra filters](#extra-filters)
-- [Live tailing](#live-tailing)
-- [Querying hits stats](#querying-hits-stats)
-- [Querying log stats](#querying-log-stats)
-- [Querying log range stats](#querying-log-range-stats)
-- [Querying streams](#querying-streams)
-- [Querying stream field names](#querying-stream-field-names)
-- [Querying stream field values](#querying-stream-field-values)
-- [Querying field names](#querying-field-names)
-- [Querying field values](#querying-field-values)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Live tailing](https://docs.victoriametrics.com/victorialogs/querying/#live-tailing)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [Querying log stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats)
+- [Querying log range stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-range-stats)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [Querying stream field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-names)
+- [Querying stream field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-values)
+- [Querying field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-names)
+- [Querying field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-values)
 
 ### Live tailing
 
@@ -216,9 +216,9 @@ with [`vl_live_tailing_requests`](https://docs.victoriametrics.com/victorialogs/
 See also:
 
 - [Live tailing in vlogscli](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#live-tailing)
-- [Extra filters](#extra-filters)
-- [Querying logs](#querying-logs)
-- [Querying streams](#querying-streams)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
 
 ### Querying hits stats
 
@@ -336,13 +336,13 @@ The `/select/logsql/hits` returns `VL-Request-Duration-Seconds` HTTP header in t
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying facets](#querying-facets)
-- [Querying logs](#querying-logs)
-- [Querying log stats](#querying-log-stats)
-- [Querying log range stats](#querying-log-range-stats)
-- [Querying streams](#querying-streams)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying facets](https://docs.victoriametrics.com/victorialogs/querying/#querying-facets)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying log stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats)
+- [Querying log range stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-range-stats)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying facets
 
@@ -432,9 +432,9 @@ The `/select/logsql/facets` returns `VL-Request-Duration-Seconds` HTTP header in
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying hits stats](#querying-hits-stats)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying log stats
 
@@ -504,11 +504,11 @@ The `/select/logsql/stats_query` returns `VL-Request-Duration-Seconds` HTTP head
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying log range stats](#querying-log-range-stats)
-- [Querying logs](#querying-logs)
-- [Querying hits stats](#querying-hits-stats)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying log range stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-range-stats)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying log range stats
 
@@ -600,11 +600,11 @@ The `/select/logsql/stats_query_range` returns `VL-Request-Duration-Seconds` HTT
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying log stats](#querying-log-stats)
-- [Querying logs](#querying-logs)
-- [Querying hits stats](#querying-hits-stats)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying log stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying stream_ids
 
@@ -661,11 +661,11 @@ The `/select/logsql/stream_ids` returns `VL-Request-Duration-Seconds` HTTP heade
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying streams](#querying-streams)
-- [Querying logs](#querying-logs)
-- [Querying hits stats](#querying-hits-stats)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying streams
 
@@ -721,11 +721,11 @@ The `/select/logsql/streams` returns `VL-Request-Duration-Seconds` HTTP header i
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying stream_ids](#querying-stream_ids)
-- [Querying logs](#querying-logs)
-- [Querying hits stats](#querying-hits-stats)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying stream_ids](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream_ids)
+- [Querying logs](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs)
+- [Querying hits stats](https://docs.victoriametrics.com/victorialogs/querying/#querying-hits-stats)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying stream field names
 
@@ -778,11 +778,11 @@ The `/select/logsql/stream_field_names` returns `VL-Request-Duration-Seconds` HT
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying stream field names](#querying-stream-field-names)
-- [Querying field values](#querying-field-values)
-- [Querying streams](#querying-streams)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying stream field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-names)
+- [Querying field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-values)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying stream field values
 
@@ -834,11 +834,11 @@ The `/select/logsql/stream_field_values` returns `VL-Request-Duration-Seconds` H
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying stream field values](#querying-stream-field-values)
-- [Querying field names](#querying-field-names)
-- [Querying streams](#querying-streams)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying stream field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-values)
+- [Querying field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-names)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying field names
 
@@ -890,11 +890,11 @@ The `/select/logsql/field_names` returns `VL-Request-Duration-Seconds` HTTP head
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying stream field names](#querying-stream-field-names)
-- [Querying field values](#querying-field-values)
-- [Querying streams](#querying-streams)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying stream field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-names)
+- [Querying field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-values)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ### Querying field values
 
@@ -951,15 +951,15 @@ The `/select/logsql/field_values` returns `VL-Request-Duration-Seconds` HTTP hea
 
 See also:
 
-- [Extra filters](#extra-filters)
-- [Querying stream field values](#querying-stream-field-values)
-- [Querying field names](#querying-field-names)
-- [Querying streams](#querying-streams)
-- [HTTP API](#http-api)
+- [Extra filters](https://docs.victoriametrics.com/victorialogs/querying/#extra-filters)
+- [Querying stream field values](https://docs.victoriametrics.com/victorialogs/querying/#querying-stream-field-values)
+- [Querying field names](https://docs.victoriametrics.com/victorialogs/querying/#querying-field-names)
+- [Querying streams](https://docs.victoriametrics.com/victorialogs/querying/#querying-streams)
+- [HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#http-api)
 
 ## Extra filters
 
-All the [HTTP querying APIs](#http-api) provided by VictoriaLogs support the following optional query args:
+All the [HTTP querying APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api) provided by VictoriaLogs support the following optional query args:
 
 - `extra_filters` - this arg may contain extra [filters](https://docs.victoriametrics.com/victorialogs/logsql/#filters), which must be applied
   to the `query` before returning the results. Multiple `extra_filters` args may be passed in a single request.
@@ -971,7 +971,7 @@ All the [HTTP querying APIs](#http-api) provided by VictoriaLogs support the fol
 The `extra_filters` and `extra_stream_filters` values can have the following format:
 
 - JSON object with `"field":"value"` entries. For example, the following JSON applies `namespace:=my-app and env:=prod` filter to the `query`
-  passed to [HTTP querying APIs](#http-api): `extra_filters={"namespace":"my-app","env":"prod"}` .
+  passed to [HTTP querying APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api): `extra_filters={"namespace":"my-app","env":"prod"}` .
 
   The following JSON applies `{namespace="my-app",env="prod"}` [stream filter](https://docs.victoriametrics.com/victorialogs/logsql/#stream-filter)
   to the `query`: `extra_stream_filters={"namespace":"my-app","env":"prod"}` .
@@ -984,6 +984,20 @@ The `extra_filters` may contain also arbitrary [LogsQL filter](https://docs.vict
 
 The arg passed to `extra_filters` and `extra_stream_filters` must be properly encoded with [percent encoding](https://en.wikipedia.org/wiki/Percent-encoding).
 
+## Partial responses
+
+[VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/) returns `502 Bad Gateway` response if some of the configured `vlstorage` nodes are unavailable.
+This guarantees consistent query responses. There are practical cases where it is preferred to return partial responses (which may be inconsistent) if some of `vlstorage` nodes
+are unavailable in the cluster. This can be done by the following ways:
+
+- To pass `-search.allowPartialResponse` command-line flag to `vlselect`.
+- To pass `allow_partial_response=1` query arg to [http querying APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api).
+  This option overrides the `-search.allowPartialResponse` command-line flag.
+- To pass `allow_partial_response` option to the query according to [these docs](https://docs.victoriametrics.com/victorialogs/logsql/#query-options).
+  This option overrides the `allow_partial_response=1` query arg.
+
+See [high availability docs for VictoriaLogs cluster](https://docs.victoriametrics.com/victorialogs/cluster/#high-availability) for more details.
+
 ## Resource usage limits
 
 VictoriaLogs provides the following options to limit resource usage by the executed queries:
@@ -993,7 +1007,7 @@ VictoriaLogs provides the following options to limit resource usage by the execu
   which select logs on time ranges bigger than one day.
 
 - `-search.maxQueryDuration` command-line flag limits the maximum execution time for a single query. For example, `-search.maxQueryDuration=10s` limits the maximum
-  query execution time to 10 seconds. The maximum query duration can be set to lower values via `timeout` query arg, which can be passed to all the [HTTP querying APIs](#http-api).
+  query execution time to 10 seconds. The maximum query duration can be set to lower values via `timeout` query arg, which can be passed to all the [HTTP querying APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api).
 
 - `-search.maxConcurrentRequests` command-line flag limits the number of concurrently executed queries. It isn't recommended setting it to too big values,
   since this usually results in the increased RAM usage and slowdown for the concurrently executed queries. VictoriaLogs waits for up to `-search.maxQueueDuration`
@@ -1008,10 +1022,10 @@ There are three modes of displaying query results:
 
 - `Group` - results are displayed as a table with rows grouped by [stream fields](https://docs.victoriametrics.com/victorialogs/keyconcepts/#stream-fields).
 - `Table` - displays query results as a table.
-- `JSON` - displays raw JSON response from [`/select/logsql/query` HTTP API](#querying-logs).
-- `Live` - displays [live tailing](#live-tailing) results for the given query.
+- `JSON` - displays raw JSON response from [`/select/logsql/query` HTTP API](https://docs.victoriametrics.com/victorialogs/querying/#querying-logs).
+- `Live` - displays [live tailing](https://docs.victoriametrics.com/victorialogs/querying/#live-tailing) results for the given query.
 
-See also [command line interface](#command-line).
+See also [command line interface](https://docs.victoriametrics.com/victorialogs/querying/#command-line).
 
 ## Visualization in Grafana
 
diff --git a/docs/victorialogs/querying/_index.md b/docs/victorialogs/querying/_index.md
index 722da9a43b..95ac88bdfc 100644
--- a/docs/victorialogs/querying/_index.md
+++ b/docs/victorialogs/querying/_index.md
@@ -1,11 +1,11 @@
 ---
 title: Querying
-weight: 4
+weight: 6
 menu:
   docs:
     identifier: victorialogs-querying
     parent: "victorialogs"
-    weight: 4
+    weight: 6
 tags:
   - logs
 aliases:
diff --git a/docs/victorialogs/querying/vlogscli.md b/docs/victorialogs/querying/vlogscli.md
index 890418496b..2ffc583c3d 100644
--- a/docs/victorialogs/querying/vlogscli.md
+++ b/docs/victorialogs/querying/vlogscli.md
@@ -13,11 +13,11 @@ tags:
 `vlogsqcli` is an interactive command-line tool for querying [VictoriaLogs](https://docs.victoriametrics.com/victorialogs/).
 It has the following features:
 
-- It supports scrolling and searching over query results in the same way as `less` command does - see [these docs](#scrolling-query-results).
+- It supports scrolling and searching over query results in the same way as `less` command does - see [these docs](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#scrolling-query-results).
 - It supports canceling long-running queries at any time via `Ctrl+C`.
-- It supports query history - see [these docs](#query-history).
-- It supports different formats for query results (JSON, logfmt, compact, etc.) - see [these docs](#output-modes).
-- It supports live tailing - see [these docs](#live-tailing).
+- It supports query history - see [these docs](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#query-history).
+- It supports different formats for query results (JSON, logfmt, compact, etc.) - see [these docs](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#output-modes).
+- It supports live tailing - see [these docs](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#live-tailing).
 
 This tool can be obtained from the linked release pages at the [changelog](https://docs.victoriametrics.com/victorialogs/changelog/)
 or from docker images at [Docker Hub](https://hub.docker.com/r/victoriametrics/vlogscli/tags) and [Quay](https://quay.io/repository/victoriametrics/vlogscli?tab=tags).
@@ -25,8 +25,8 @@ or from docker images at [Docker Hub](https://hub.docker.com/r/victoriametrics/v
 ### Running `vlogscli` from release binary
 
 ```sh
-curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.32.0/vlutils-linux-amd64-v1.32.0.tar.gz
-tar xzf vlutils-linux-amd64-v1.32.0.tar.gz
+curl -L -O https://github.com/VictoriaMetrics/VictoriaLogs/releases/download/v1.34.0/vlutils-linux-amd64-v1.34.0.tar.gz
+tar xzf vlutils-linux-amd64-v1.34.0.tar.gz
 ./vlogscli-prod
 ```
 
@@ -85,10 +85,10 @@ then just wrap it into quotes: `"q"` or `'q'`).
 
 See also:
 
-- [output modes](#output-modes)
-- [query history](#query-history)
-- [scrolling query results](#scrolling-query-results)
-- [live tailing](#live-tailing)
+- [output modes](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#output-modes)
+- [query history](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#query-history)
+- [scrolling query results](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#scrolling-query-results)
+- [live tailing](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#live-tailing)
 
 ## Scrolling query results
 
@@ -121,7 +121,7 @@ in real time:
 By default `vlogscli` derives [the URL for live tailing](https://docs.victoriametrics.com/victorialogs/querying/#live-tailing) from the `-datasource.url` command-line flag
 by replacing `/query` with `/tail` at the end of `-datasource.url`. The URL for live tailing can be specified explicitly via `-tail.url` command-line flag.
 
-Live tailing can show query results in different formats - see [these docs](#output-modes).
+Live tailing can show query results in different formats - see [these docs](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#output-modes).
 
 ## Query history
 
@@ -149,7 +149,7 @@ Fields in every JSON object are sorted in alphabetical order. This simplifies lo
   This mode shows field values as is if the response contains a single field
   (for example if [`fields _msg` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#fields-pipe) is used)
   plus optional [`_time` field](https://docs.victoriametrics.com/victorialogs/keyconcepts/#time-field).
-  See also [docs about ANSI colors](#ansi-colors).
+  See also [docs about ANSI colors](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#ansi-colors).
 - [Logfmt output](https://brandur.org/logfmt). Type `\logfmt` and press `enter` for this mode.
 
 ## Wrapping long lines
@@ -162,7 +162,7 @@ Type `\wrap_long_lines` in the prompt and press enter in order to toggle automat
 
 ## ANSI colors
 
-By default `vlogscli` doesn't display colored text in the compact [output mode](#output-modes) if the returned logs contain [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code).
+By default `vlogscli` doesn't display colored text in the compact [output mode](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#output-modes) if the returned logs contain [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code).
 It shows the ANSI color codes instead. Type `\enable_colors` for enabling colored text. Type `\disable_color` for disabling colored text.
 
 ANSI colors make harder analyzing the logs, so it is recommended stripping ANSI colors at data ingestion stage
@@ -178,7 +178,7 @@ according to [these docs](https://docs.victoriametrics.com/victorialogs/data-ing
 - `-tlsKeyFile` - optional path to client-side TLS certificate key to use when connecting to the `-datasource.url`.
 - `-tlsServerName` -  optional TLS server name to use for connections to the `-datasource.url`. By default, the server name from `-datasource.url` is used.
 
-See also [auth options](#auth-options).
+See also [auth options](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#auth-options).
 
 ## Auth options
 
@@ -191,7 +191,7 @@ See also [auth options](#auth-options).
 The `-bearerToken` and `-password` command-line flags may refer local files or remote files via http(s). In this case the corresponding value of the flag is read from the file.
 For example, `-bearerToken=file:///abs/path/to/file`, `-bearerToken=file://./relative/path/to/file`, `-bearerToken=http://host/path` or `-bearerToken=https://host/path`.
 
-See also [TLS options](#tls-options).
+See also [TLS options](https://docs.victoriametrics.com/victorialogs/querying/vlogscli/#tls-options).
 
 ## Command-line flags
 
diff --git a/docs/victorialogs/security-and-lb.md b/docs/victorialogs/security-and-lb.md
index f552cf54a3..45d78bfadc 100644
--- a/docs/victorialogs/security-and-lb.md
+++ b/docs/victorialogs/security-and-lb.md
@@ -1,9 +1,9 @@
 ---
-weight: 5
+weight: 12
 menu:
   docs:
     parent: victorialogs
-    weight: 5
+    weight: 12
 title: Security and LoadBalancing
 tags:
   - logs
@@ -157,7 +157,7 @@ unauthorized_user:
     - "AccountID: 0"
 ```
 
-See also [tenant-based data ingestion request proxying](#tenant-based-proxying-of-data-ingestion-requests).
+See also [tenant-based data ingestion request proxying](https://docs.victoriametrics.com/victorialogs/security-and-lb/#tenant-based-proxying-of-data-ingestion-requests).
 
 This allows building VictoriaLogs storage system with distinct per-tenant retention configs
 similar to [this one](https://github.com/VictoriaMetrics/VictoriaLogs/issues/15#issuecomment-3043557052).
diff --git a/docs/victorialogs/sql-to-logsql.md b/docs/victorialogs/sql-to-logsql.md
index 3e2d3d7670..0efef0ae4e 100644
--- a/docs/victorialogs/sql-to-logsql.md
+++ b/docs/victorialogs/sql-to-logsql.md
@@ -1,10 +1,10 @@
 ---
-weight: 120
-title: SQL to LogsQL tutorial
+weight: 52
+title: SQL to LogsQL Tutorial
 menu:
   docs:
     parent: "victorialogs"
-    weight: 120
+    weight: 52
 tags:
   - logs
   - guide
@@ -61,7 +61,7 @@ and then pushes the resulting rows to the next stage. This simplifies reading an
 to the end in order to understand what does it do at every stage.
 
 LogsQL pipes cover all the functionality from SQL: aggregations, calculations, transformations, subqueries, joins, post-filters, sorting, etc.
-See the [conversion rules](#conversion-rules) on how to convert SQL to LogsQL.
+See the [conversion rules](https://docs.victoriametrics.com/victorialogs/sql-to-logsql/#conversion-rules) on how to convert SQL to LogsQL.
 
 ## conversion rules
 
diff --git a/docs/victorialogs/victorialogs-datasource.md b/docs/victorialogs/victorialogs-datasource.md
index 9fe83ea9c7..fae94871ce 100644
--- a/docs/victorialogs/victorialogs-datasource.md
+++ b/docs/victorialogs/victorialogs-datasource.md
@@ -1,12 +1,12 @@
 ---
-weight: 9
-title: Grafana datasource
+weight: 11
+title: Grafana Datasource
 editLink: https://github.com/VictoriaMetrics/victorialogs-datasource/blob/main/README.md
 menu:
   docs:
     identifier: victorialogs-grafana-datasource
     parent: victorialogs
-    weight: 9
+    weight: 11
 tags:
   - logs
 aliases:
diff --git a/docs/victorialogs/vlagent-metrics.md b/docs/victorialogs/vlagent-metrics.md
index cf8e94f657..a7e52d5d3d 100644
--- a/docs/victorialogs/vlagent-metrics.md
+++ b/docs/victorialogs/vlagent-metrics.md
@@ -1,12 +1,12 @@
 ---
-weight: 11
-title: vlagent metrics
+weight: 21
+title: Metrics of vlagent
 menu:
   docs:
     parent: victorialogs
     identifier: vlagent-metrics
-    weight: 11
-    title: vlagent metrics
+    weight: 21
+    title: Metrics of vlagent
 tags:
   - logs
   - metrics
diff --git a/docs/victorialogs/vlagent.md b/docs/victorialogs/vlagent.md
index 3b22aa0bf0..a90387f94f 100644
--- a/docs/victorialogs/vlagent.md
+++ b/docs/victorialogs/vlagent.md
@@ -1,10 +1,11 @@
 ---
-weight: 3
+title: vlagent
+weight: 4
 menu:
   docs:
-    parent: victorialogs
-    weight: 3
-title: vlagent
+    weight: 4
+    parent: "victorialogs"
+    identifier: vlagent
 tags:
   - logs
 aliases:
@@ -19,7 +20,7 @@ aliases:
 
 - `vlagent` can accept logs from popular log collectors in the same way as VictoriaLogs does. See [these docs](https://docs.victoriametrics.com/victorialogs/data-ingestion/).
   It accepts logs over HTTP-based protocols at the TCP port `9429` by default. The port can be changed via `-httpListenAddr` command-line flag.
-- `vlagent` can replicate collected logs among multiple VictoriaLogs instances - see [these docs](#replication-and-high-availability).
+- `vlagent` can replicate collected logs among multiple VictoriaLogs instances - see [these docs](https://docs.victoriametrics.com/victorialogs/vlagent/#replication-and-high-availability).
 - `vlagent` works smoothly in environments with unstable connections to VictoriaLogs instances. If the remote storage is unavailable, the collected logs
   are buffered at the directory specified via `-remoteWrite.tmpDataPath` command-line flag. The buffered logs are sent to remote storage as soon as the connection
   to the remote storage is repaired. The maximum disk usage for the buffer can be limited with `-remoteWrite.maxDiskUsagePerURL` command-line flag.
@@ -31,7 +32,7 @@ Please download and unpack `vlutils` archive from [releases page](https://github
 and [Quay](https://quay.io/repository/victoriametrics/vlagent?tab=tags)), then pass the following command-line flags to the `vlagent-prod` binary:
 
 - `-remoteWrite.url` - the VictoriaLogs endpoint for sending the accepted logs to. It must end with `/internal/insert`.
-  The `-remoteWrite.url` may refer to [DNS SRV](https://en.wikipedia.org/wiki/SRV_record) address. See [these docs](#srv-urls) for details.
+  The `-remoteWrite.url` may refer to [DNS SRV](https://en.wikipedia.org/wiki/SRV_record) address. See [these docs](https://docs.victoriametrics.com/victorialogs/vlagent/#srv-urls) for details.
 
 Example command, which starts `vlagent` for accepting logs over HTTP-based [supported protocols](https://docs.victoriametrics.com/victorialogs/data-ingestion/)
 at the port `9429` and sends the collected logs to VictoriaLogs instance at `victoria-logs-host:9428`:
@@ -40,7 +41,7 @@ at the port `9429` and sends the collected logs to VictoriaLogs instance at `vic
 /path/to/vlagent-prod -remoteWrite.url=http://victoria-logs-host:9428/internal/insert
 ```
 
-Pass `-help` to `vlagent` in order to see [the full list of supported command-line flags with their descriptions](#advanced-usage).
+Pass `-help` to `vlagent` in order to see [the full list of supported command-line flags with their descriptions](https://docs.victoriametrics.com/victorialogs/vlagent/#advanced-usage).
 
 ### Replication and high availability
 
@@ -73,9 +74,9 @@ If you have suggestions for improvements or have found a bug - please open an is
 
 ## Troubleshooting
 
-- It is recommended [setting up the official Grafana dashboard](#monitoring) in order to monitor the state of `vlagent`.
+- It is recommended [setting up the official Grafana dashboard](https://docs.victoriametrics.com/victorialogs/vlagent/#monitoring) in order to monitor the state of `vlagent`.
 
-- It is recommended increasing `-remoteWrite.queues` if `vlagent_remotewrite_pending_data_bytes` [metric](#monitoring)
+- It is recommended increasing `-remoteWrite.queues` if `vlagent_remotewrite_pending_data_bytes` [metric](https://docs.victoriametrics.com/victorialogs/vlagent/#monitoring)
   grows constantly. This can improve data ingestion performance to the configured remote storage systems at the cost of higher memory usage.
 
 - If you see gaps in the data pushed by `vlagent` to remote storage when `-remoteWrite.maxDiskUsagePerURL` is set,
@@ -83,7 +84,7 @@ If you have suggestions for improvements or have found a bug - please open an is
   Therefore, it starts dropping the buffered data if the on-disk buffer size exceeds `-remoteWrite.maxDiskUsagePerURL`.
 
 - `vlagent` drops data blocks if remote storage replies with `400 Bad Request` and `404 Not Found` HTTP responses.
-  The number of dropped blocks can be monitored via `vlagent_remotewrite_packets_dropped_total` metric exported at [/metrics page](#monitoring).
+  The number of dropped blocks can be monitored via `vlagent_remotewrite_packets_dropped_total` metric exported at [/metrics page](https://docs.victoriametrics.com/victorialogs/vlagent/#monitoring).
 
 - `vlagent` buffers the collected logs at the `-remoteWrite.tmpDataPath` directory until they are sent to the `-remoteWrite.url`.
   The directory can grow large when the remote storage is unavailable for extended periods of time and if the maximum directory size isn't limited
@@ -155,7 +156,8 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Whether to disable fadvise() syscall when reading large data files. The fadvise() syscall prevents from eviction of recently accessed data from OS page cache during background merges and backups. In some rare cases it is better to disable the syscall if it uses too much CPU
   -flagsAuthKey value
         Auth key for /flags endpoint. It must be passed via authKey query arg. It overrides -httpAuth.*
-        Flag value can be read from the given file when using -flagsAuthKey=file:///abs/path/to/file or -flagsAuthKey=file://./relative/path/to/file . Flag value can be read from the given http/https url when using -flagsAuthKey=http://host/path or -flagsAuthKey=https://host/path
+        Flag value can be read from the given file when using -flagsAuthKey=file:///abs/path/to/file or -flagsAuthKey=file://./relative/path/to/file.
+        Flag value can be read from the given http/https url when using -flagsAuthKey=http://host/path or -flagsAuthKey=https://host/path
   -fs.disableMmap
         Whether to use pread() instead of mmap() for reading data files. By default, mmap() is used for 64-bit arches and pread() is used for 32-bit arches, since they cannot read data files bigger than 2^32 bytes in memory. mmap() is usually faster for reading small data chunks than pread()
   -http.connTimeout duration
@@ -182,7 +184,8 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Optional delay before http server shutdown. During this delay, the server returns non-OK responses from /health page, so load balancers can route new requests to other servers
   -httpAuth.password value
         Password for HTTP server's Basic Auth. The authentication is disabled if -httpAuth.username is empty
-        Flag value can be read from the given file when using -httpAuth.password=file:///abs/path/to/file or -httpAuth.password=file://./relative/path/to/file . Flag value can be read from the given http/https url when using -httpAuth.password=http://host/path or -httpAuth.password=https://host/path
+        Flag value can be read from the given file when using -httpAuth.password=file:///abs/path/to/file or -httpAuth.password=file://./relative/path/to/file.
+        Flag value can be read from the given http/https url when using -httpAuth.password=http://host/path or -httpAuth.password=https://host/path
   -httpAuth.username string
         Username for HTTP server's Basic Auth. The authentication is disabled if empty. See also -httpAuth.password
   -httpListenAddr array
@@ -269,7 +272,8 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Whether to expose TYPE and HELP metadata at the /metrics page, which is exposed at -httpListenAddr . The metadata may be needed when the /metrics page is consumed by systems, which require this information. For example, Managed Prometheus in Google Cloud - https://cloud.google.com/stackdriver/docs/managed-prometheus/troubleshooting#missing-metric-type
   -metricsAuthKey value
         Auth key for /metrics endpoint. It must be passed via authKey query arg. It overrides -httpAuth.*
-        Flag value can be read from the given file when using -metricsAuthKey=file:///abs/path/to/file or -metricsAuthKey=file://./relative/path/to/file . Flag value can be read from the given http/https url when using -metricsAuthKey=http://host/path or -metricsAuthKey=https://host/path
+        Flag value can be read from the given file when using -metricsAuthKey=file:///abs/path/to/file or -metricsAuthKey=file://./relative/path/to/file.
+        Flag value can be read from the given http/https url when using -metricsAuthKey=http://host/path or -metricsAuthKey=https://host/path
   -mtls array
         Whether to require valid client certificate for https requests to the corresponding -httpListenAddr . This flag works only if -tls flag is set. See also -mtlsCAFile . This flag is available only in Enterprise binaries. See https://docs.victoriametrics.com/victoriametrics/enterprise/
         Supports array of values separated by comma or specified via multiple flags.
@@ -283,7 +287,8 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Supports the following optional suffixes for size values: KB, MB, GB, TB, KiB, MiB, GiB, TiB (default 67108864)
   -pprofAuthKey value
         Auth key for /debug/pprof/* endpoints. It must be passed via authKey query arg. It overrides -httpAuth.*
-        Flag value can be read from the given file when using -pprofAuthKey=file:///abs/path/to/file or -pprofAuthKey=file://./relative/path/to/file . Flag value can be read from the given http/https url when using -pprofAuthKey=http://host/path or -pprofAuthKey=https://host/path
+        Flag value can be read from the given file when using -pprofAuthKey=file:///abs/path/to/file or -pprofAuthKey=file://./relative/path/to/file.
+        Flag value can be read from the given http/https url when using -pprofAuthKey=http://host/path or -pprofAuthKey=https://host/path
   -pushmetrics.disableCompression
         Whether to disable request body compression when pushing metrics to every -pushmetrics.url
   -pushmetrics.extraLabel array
@@ -420,6 +425,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Compression method for syslog messages received at the corresponding -syslog.listenAddr.udp. Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.compressMethod.unix array
+        Compression method for syslog messages received at the corresponding -syslog.listenAddr.unix. Supported values: none, gzip, deflate. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#compression
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.decolorizeFields.tcp array
         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
         Supports an array of values separated by comma or specified via multiple flags.
@@ -428,6 +437,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         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
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.decolorizeFields.unix array
+        Fields to remove ANSI color codes across logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#decolorizing-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.extraFields.tcp array
         Fields to add to logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
         Supports an array of values separated by comma or specified via multiple flags.
@@ -436,6 +449,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Fields to add to logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.extraFields.unix array
+        Fields to add to logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#adding-extra-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.ignoreFields.tcp array
         Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
         Supports an array of values separated by comma or specified via multiple flags.
@@ -444,12 +461,20 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.ignoreFields.unix array
+        Fields to ignore at logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#dropping-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.listenAddr.tcp array
         Comma-separated list of TCP addresses to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.listenAddr.udp array
-        Comma-separated list of UDP address to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
+        Comma-separated list of UDP addresses to listen to for Syslog messages. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.listenAddr.unix array
+        Comma-separated list of Unix socket filepaths to listen to for Syslog messages. Filepaths may be prepended with 'unixgram:'  for listening for SOCK_DGRAM sockets. By default SOCK_STREAM sockets are used. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.mtls array
@@ -468,6 +493,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.streamFields.unix array
+        Fields to use as log stream labels for logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#stream-fields
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.tenantID.tcp array
         TenantID for logs ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
         Supports an array of values separated by comma or specified via multiple flags.
@@ -476,6 +505,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         TenantID for logs ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
         Supports an array of values separated by comma or specified via multiple flags.
         Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
+  -syslog.tenantID.unix array
+        TenantID for logs ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#multitenancy
+        Supports an array of values separated by comma or specified via multiple flags.
+        Value can contain comma inside single-quoted or double-quoted string, {}, [] and () braces.
   -syslog.timezone string
         Timezone to use when parsing timestamps in RFC3164 syslog messages. Timezone must be a valid IANA Time Zone. For example: America/New_York, Europe/Berlin, Etc/GMT+3 . See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/ (default "Local")
   -syslog.tls array
@@ -504,6 +537,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Whether to use local timestamp instead of the original timestamp for the ingested syslog messages at the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps
         Supports array of values separated by comma or specified via multiple flags.
         Empty values are set to false.
+  -syslog.useLocalTimestamp.unix array
+        Whether to use local timestamp instead of the original timestamp for the ingested syslog messages at the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#log-timestamps
+        Supports array of values separated by comma or specified via multiple flags.
+        Empty values are set to false.
   -syslog.useRemoteIP.tcp array
         Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.tcp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
         Supports array of values separated by comma or specified via multiple flags.
@@ -512,6 +549,10 @@ See the docs at https://docs.victoriametrics.com/victorialogs/vlagent/ .
         Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.udp. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
         Supports array of values separated by comma or specified via multiple flags.
         Empty values are set to false.
+  -syslog.useRemoteIP.unix array
+        Whether to add remote ip address as 'remote_ip' log field for syslog messages ingested via the corresponding -syslog.listenAddr.unix. See https://docs.victoriametrics.com/victorialogs/data-ingestion/syslog/#capturing-remote-ip-address
+        Supports array of values separated by comma or specified via multiple flags.
+        Empty values are set to false.
   -tls array
         Whether to enable TLS for incoming HTTP requests at the given -httpListenAddr (aka https). -tlsCertFile and -tlsKeyFile must be set if -tls is set. See also -mtls
         Supports array of values separated by comma or specified via multiple flags.
diff --git a/docs/victorialogs/vmalert.md b/docs/victorialogs/vmalert.md
index 51e7a590d1..054d873182 100644
--- a/docs/victorialogs/vmalert.md
+++ b/docs/victorialogs/vmalert.md
@@ -1,10 +1,10 @@
 ---
-weight: 10
-title: vmalert
+weight: 9
+title: Alerting with Logs
 menu:
   docs:
     parent: "victorialogs"
-    weight: 10
+    weight: 9
     identifier: "victorialogs-vmalert"
 tags:
    - logs
@@ -18,7 +18,7 @@ and [`/select/logsql/stats_query_range`](https://docs.victoriametrics.com/victor
 These endpoints return the log stats in a format compatible with [Prometheus querying API](https://prometheus.io/docs/prometheus/latest/querying/api/#instant-queries).
 It allows using VictoriaLogs as the datasource in vmalert, creating alerting and recording rules via [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/).
 
-_Note: This page provides only integration instructions for vmalert and VictoriaLogs. See the full textbook for vmalert [here](https://docs.victoriametrics.com/victoriametrics/vmalert/).
+> This page provides only integration instructions for vmalert and VictoriaLogs. See the full textbook for vmalert [here](https://docs.victoriametrics.com/victoriametrics/vmalert/).
 
 ## Quick Start
 
@@ -33,11 +33,11 @@ Run vmalert with the following settings:
 ```
 
 > Note: By default, vmalert assumes all configured rules have `prometheus` type and will validate them accordingly.
-> For rules in [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/) specify `type: vlogs` on [Group level](#groups).
+> For rules in [LogsQL](https://docs.victoriametrics.com/victorialogs/logsql/) specify `type: vlogs` on [Group level](https://docs.victoriametrics.com/victorialogs/vmalert/#groups).
 > Or set `-rule.defaultRuleType=vlogs` cmd-line flag to change the default rule type.
 
 Each `-rule` file may contain arbitrary number of [groups](https://docs.victoriametrics.com/victoriametrics/vmalert/#groups).
-See examples in [Groups](#groups) section. See the full list of configuration flags and their descriptions in [configuration](#configuration) section.
+See examples in [Groups](https://docs.victoriametrics.com/victorialogs/vmalert/#groups) section. See the full list of configuration flags and their descriptions in [configuration](https://docs.victoriametrics.com/victorialogs/vmalert/#configuration) section.
 
 With configuration example above, vmalert will perform the following interactions:
 ![vmalert](vmalert_victorialogs.webp)
@@ -170,7 +170,7 @@ groups:
            description: "Connection from address {{$labels.ip}} has {{$value}}% failed requests in last 10 minutes"
 ```
 
-_Please note, vmalert doesn't support [backfilling](#rules-backfilling) for rules with a customized time filter now. (Might be added in future)._
+_Please note, vmalert doesn't support [backfilling](https://docs.victoriametrics.com/victorialogs/vmalert/#rules-backfilling) for rules with a customized time filter now. (Might be added in future)._
 
 ## Rules backfilling
 
diff --git a/go.mod b/go.mod
index 860cb082ae..a285a96701 100644
--- a/go.mod
+++ b/go.mod
@@ -3,9 +3,9 @@ module github.com/VictoriaMetrics/VictoriaLogs
 go 1.25.0
 
 require (
-	github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250829235354-7967ad661e76
+	github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250917082640-2c72ef0f3871
 	github.com/VictoriaMetrics/easyproto v0.1.4
-	github.com/VictoriaMetrics/metrics v1.39.1
+	github.com/VictoriaMetrics/metrics v1.40.1
 	github.com/cespare/xxhash/v2 v2.3.0
 	github.com/ergochat/readline v0.1.3
 	github.com/golang/snappy v1.0.0
@@ -18,7 +18,7 @@ require (
 )
 
 require (
-	github.com/VictoriaMetrics/metricsql v0.84.7 // indirect
+	github.com/VictoriaMetrics/metricsql v0.84.8 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/valyala/gozstd v1.23.2 // indirect
diff --git a/go.sum b/go.sum
index 07e4870d4c..765a2b38e4 100644
--- a/go.sum
+++ b/go.sum
@@ -1,11 +1,11 @@
-github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250829235354-7967ad661e76 h1:HyLFTlZN3UY84HQPWIZT4hSS7537618ALvMla3bV2hI=
-github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250829235354-7967ad661e76/go.mod h1:mRRUzTxEuernAU9h20/UeZs11dJA2J8LaP9DxbtCag0=
+github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250917082640-2c72ef0f3871 h1:5G3BS+OSqN6Lie30l+VoNbV8Ks0irHGzvrPmIpijG+A=
+github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250917082640-2c72ef0f3871/go.mod h1:Lrd9cpKD2edJ+uoXTGEcHMZwnI+vyomJrINld69Z8h4=
 github.com/VictoriaMetrics/easyproto v0.1.4 h1:r8cNvo8o6sR4QShBXQd1bKw/VVLSQma/V2KhTBPf+Sc=
 github.com/VictoriaMetrics/easyproto v0.1.4/go.mod h1:QlGlzaJnDfFd8Lk6Ci/fuLxfTo3/GThPs2KH23mv710=
-github.com/VictoriaMetrics/metrics v1.39.1 h1:AT7jz7oSpAK9phDl5O5Tmy06nXnnzALwqVnf4ros3Ow=
-github.com/VictoriaMetrics/metrics v1.39.1/go.mod h1:XE4uudAAIRaJE614Tl5HMrtoEU6+GDZO4QTnNSsZRuA=
-github.com/VictoriaMetrics/metricsql v0.84.7 h1:zMONjtEULMbwEYU/qL4Hkc3GDfTTrv1bO+a9lmJf3do=
-github.com/VictoriaMetrics/metricsql v0.84.7/go.mod h1:d4EisFO6ONP/HIGDYTAtwrejJBBeKGQYiRl095bS4QQ=
+github.com/VictoriaMetrics/metrics v1.40.1 h1:FrF5uJRpIVj9fayWcn8xgiI+FYsKGMslzPuOXjdeyR4=
+github.com/VictoriaMetrics/metrics v1.40.1/go.mod h1:XE4uudAAIRaJE614Tl5HMrtoEU6+GDZO4QTnNSsZRuA=
+github.com/VictoriaMetrics/metricsql v0.84.8 h1:5JXrvPJiYkYNqJVT7+hMZmpAwRHd3txBdlVIw4rJ1VM=
+github.com/VictoriaMetrics/metricsql v0.84.8/go.mod h1:d4EisFO6ONP/HIGDYTAtwrejJBBeKGQYiRl095bS4QQ=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/ergochat/readline v0.1.3 h1:/DytGTmwdUJcLAe3k3VJgowh5vNnsdifYT6uVaf4pSo=
diff --git a/lib/logstorage/consts.go b/lib/logstorage/consts.go
index 03aa3bb24f..6024aa2e1e 100644
--- a/lib/logstorage/consts.go
+++ b/lib/logstorage/consts.go
@@ -1,5 +1,10 @@
 package logstorage
 
+// maxParallelReaders is the maximum parallel readers to use when executing a query.
+//
+// bigger number of parallel readers may help increasing query performance on high-latency storage such as S3 and NFS.
+const maxParallelReaders = 2_000
+
 // partFormatLatestVersion is the latest format version for parts.
 //
 // See partHeader.FormatVersion for details.
diff --git a/lib/logstorage/filter_contains_common_case.go b/lib/logstorage/filter_contains_common_case.go
new file mode 100644
index 0000000000..3eaa6b35cd
--- /dev/null
+++ b/lib/logstorage/filter_contains_common_case.go
@@ -0,0 +1,114 @@
+package logstorage
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/VictoriaMetrics/VictoriaLogs/lib/prefixfilter"
+)
+
+// filterContainsCommonCase matches words and phrases where every captial letter
+// can be replaced with a small letter, plus all capital words.
+//
+// Example LogsQL: `contains_common_case("Error")` is equivalent to contains_any("Error", "error", "ERROR")
+type filterContainsCommonCase struct {
+	phrases []string
+
+	containsAny *filterContainsAny
+}
+
+func newFilterContainsCommonCase(fieldName string, phrases []string) (*filterContainsCommonCase, error) {
+	commonCasePhrases, err := getCommonCasePhrases(phrases)
+	if err != nil {
+		return nil, err
+	}
+
+	fi := &filterContainsCommonCase{
+		phrases: phrases,
+		containsAny: &filterContainsAny{
+			fieldName: fieldName,
+		},
+	}
+	fi.containsAny.values.values = commonCasePhrases
+
+	return fi, nil
+}
+
+func (fi *filterContainsCommonCase) String() string {
+	a := make([]string, len(fi.phrases))
+	for i, phrase := range fi.phrases {
+		a[i] = quoteTokenIfNeeded(phrase)
+	}
+	phrases := strings.Join(a, ",")
+	return fmt.Sprintf("%scontains_common_case(%s)", quoteFieldNameIfNeeded(fi.containsAny.fieldName), phrases)
+}
+
+func (fi *filterContainsCommonCase) updateNeededFields(pf *prefixfilter.Filter) {
+	fi.containsAny.updateNeededFields(pf)
+}
+
+func (fi *filterContainsCommonCase) applyToBlockResult(br *blockResult, bm *bitmap) {
+	fi.containsAny.applyToBlockResult(br, bm)
+}
+
+func (fi *filterContainsCommonCase) applyToBlockSearch(bs *blockSearch, bm *bitmap) {
+	fi.containsAny.applyToBlockSearch(bs, bm)
+}
+
+func getCommonCasePhrases(phrases []string) ([]string, error) {
+	var dst []string
+	for _, phrase := range phrases {
+		upper := countUpperRunes(phrase)
+		if upper > 10 {
+			return nil, fmt.Errorf("too many common_case combinations for the %q; reduce the number of uppercase letters here", phrase)
+		}
+		dst = appendCommonCasePhrases(dst, "", phrase)
+		dst = append(dst, strings.ToUpper(phrase))
+	}
+
+	// Deduplicate dst
+	m := make(map[string]struct{}, len(dst))
+	for _, s := range dst {
+		m[s] = struct{}{}
+	}
+
+	dst = dst[:0]
+	for s := range m {
+		dst = append(dst, s)
+	}
+	sort.Strings(dst)
+
+	return dst, nil
+}
+
+func countUpperRunes(s string) int {
+	upper := 0
+	for _, c := range s {
+		if unicode.IsUpper(c) {
+			upper++
+		}
+	}
+	return upper
+}
+
+func appendCommonCasePhrases(dst []string, prefix, phrase string) []string {
+	dst = append(dst, prefix+phrase)
+
+	for off, c := range phrase {
+		if !unicode.IsUpper(c) {
+			continue
+		}
+		charLen := utf8.RuneLen(c)
+		if charLen == -1 {
+			continue
+		}
+
+		phraseTail := phrase[off+charLen:]
+		dst = appendCommonCasePhrases(dst, prefix+phrase[:off]+string(unicode.ToLower(c)), phraseTail)
+		dst = appendCommonCasePhrases(dst, prefix+phrase[:off+charLen], phraseTail)
+	}
+	return dst
+}
diff --git a/lib/logstorage/filter_contains_common_case_test.go b/lib/logstorage/filter_contains_common_case_test.go
new file mode 100644
index 0000000000..5c485180f9
--- /dev/null
+++ b/lib/logstorage/filter_contains_common_case_test.go
@@ -0,0 +1,47 @@
+package logstorage
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestGetCommonCasePhrases_Success(t *testing.T) {
+	f := func(phrases, resultExpected []string) {
+		t.Helper()
+
+		result, err := getCommonCasePhrases(phrases)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if !reflect.DeepEqual(result, resultExpected) {
+			t.Fatalf("unexpected result\ngot\n%q\nwant\n%q", result, resultExpected)
+		}
+	}
+
+	f(nil, nil)
+	f([]string{""}, []string{""})
+	f([]string{"foo"}, []string{"FOO", "foo"})
+	f([]string{"Foo"}, []string{"FOO", "Foo", "foo"})
+	f([]string{"foo", "Foo"}, []string{"FOO", "Foo", "foo"})
+	f([]string{"FOO"}, []string{"FOO", "FOo", "FoO", "Foo", "fOO", "fOo", "foO", "foo"})
+
+	f([]string{"FooBar"}, []string{"FOOBAR", "FooBar", "Foobar", "fooBar", "foobar"})
+}
+
+func TestGetCommonCasePhrases_Failure(t *testing.T) {
+	f := func(phrases []string) {
+		t.Helper()
+
+		result, err := getCommonCasePhrases(phrases)
+		if err == nil {
+			t.Fatalf("expecting non-nil error")
+		}
+		if result != nil {
+			t.Fatalf("expecting nil result; got %q", result)
+		}
+	}
+
+	// More than 10 uppercase chars
+	f([]string{"FOOBARBAZAB"})
+	f([]string{"FoOOBbARrBAZzABsdf"})
+}
diff --git a/lib/logstorage/filter_equals_common_case.go b/lib/logstorage/filter_equals_common_case.go
new file mode 100644
index 0000000000..3f676dcb51
--- /dev/null
+++ b/lib/logstorage/filter_equals_common_case.go
@@ -0,0 +1,56 @@
+package logstorage
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaLogs/lib/prefixfilter"
+)
+
+// filterEqualsCommonCase matches words and phrases where every captial letter
+// can be replaced with a small letter, plus all capital words.
+//
+// Example LogsQL: `equals_common_case("Error")` is equivalent to in("Error", "error", "ERROR")
+type filterEqualsCommonCase struct {
+	phrases []string
+
+	equalsAny *filterIn
+}
+
+func newFilterEqualsCommonCase(fieldName string, phrases []string) (*filterEqualsCommonCase, error) {
+	commonCasePhrases, err := getCommonCasePhrases(phrases)
+	if err != nil {
+		return nil, err
+	}
+
+	fi := &filterEqualsCommonCase{
+		phrases: phrases,
+		equalsAny: &filterIn{
+			fieldName: fieldName,
+		},
+	}
+	fi.equalsAny.values.values = commonCasePhrases
+
+	return fi, nil
+}
+
+func (fi *filterEqualsCommonCase) String() string {
+	a := make([]string, len(fi.phrases))
+	for i, phrase := range fi.phrases {
+		a[i] = quoteTokenIfNeeded(phrase)
+	}
+	phrases := strings.Join(a, ",")
+	return fmt.Sprintf("%sequals_common_case(%s)", quoteFieldNameIfNeeded(fi.equalsAny.fieldName), phrases)
+}
+
+func (fi *filterEqualsCommonCase) updateNeededFields(pf *prefixfilter.Filter) {
+	fi.equalsAny.updateNeededFields(pf)
+}
+
+func (fi *filterEqualsCommonCase) applyToBlockResult(br *blockResult, bm *bitmap) {
+	fi.equalsAny.applyToBlockResult(br, bm)
+}
+
+func (fi *filterEqualsCommonCase) applyToBlockSearch(bs *blockSearch, bm *bitmap) {
+	fi.equalsAny.applyToBlockSearch(bs, bm)
+}
diff --git a/lib/logstorage/filter_test.go b/lib/logstorage/filter_test.go
index c62bde6328..632281640a 100644
--- a/lib/logstorage/filter_test.go
+++ b/lib/logstorage/filter_test.go
@@ -207,7 +207,7 @@ func testFilterMatchForStorage(t *testing.T, s *Storage, tenantID TenantID, f fi
 	var results []result
 
 	const workersCount = 3
-	s.search(workersCount, so, qs, nil, func(_ uint, br *blockResult) {
+	s.searchParallel(workersCount, so, qs, nil, func(_ uint, br *blockResult) {
 		// Verify columns
 		cs := br.getColumns()
 		if len(cs) != 2 {
diff --git a/lib/logstorage/if_filter.go b/lib/logstorage/if_filter.go
index 7a8024d437..d2158cee52 100644
--- a/lib/logstorage/if_filter.go
+++ b/lib/logstorage/if_filter.go
@@ -33,7 +33,7 @@ func parseIfFilter(lex *lexer) (*ifFilter, error) {
 		return iff, nil
 	}
 
-	f, err := parseFilter(lex)
+	f, err := parseFilter(lex, true)
 	if err != nil {
 		return nil, fmt.Errorf("cannot parse 'if' filter: %w", err)
 	}
diff --git a/lib/logstorage/net_query_runner.go b/lib/logstorage/net_query_runner.go
index 67a5ffcfd6..834d9fa02d 100644
--- a/lib/logstorage/net_query_runner.go
+++ b/lib/logstorage/net_query_runner.go
@@ -105,8 +105,8 @@ func getRemoteAndLocalPipes(q *Query) ([]pipe, []pipe) {
 
 		pipesLocal = append(pipesLocal, psLocal...)
 		pipesLocal = append(pipesLocal, q.pipes[i+1:]...)
-		return pipesRemote, pipesLocal
+		break
 	}
 
-	return nil, nil
+	return pipesRemote, pipesLocal
 }
diff --git a/lib/logstorage/net_query_runner_test.go b/lib/logstorage/net_query_runner_test.go
new file mode 100644
index 0000000000..65cad71b8d
--- /dev/null
+++ b/lib/logstorage/net_query_runner_test.go
@@ -0,0 +1,95 @@
+package logstorage
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSplitQueryToRemoteAndLocal(t *testing.T) {
+	f := func(qStr, remoteQueryExpected, localPipesExpected string) {
+		t.Helper()
+
+		q, err := ParseQuery(qStr)
+		if err != nil {
+			t.Fatalf("cannot parse query: %s", err)
+		}
+
+		qRemote, pipesLocal := splitQueryToRemoteAndLocal(q)
+
+		remoteQuery := qRemote.String()
+		if remoteQuery != remoteQueryExpected {
+			t.Fatalf("unexpected remote query\ngot\n%s\nwant\n%s", remoteQuery, remoteQueryExpected)
+		}
+
+		a := make([]string, len(pipesLocal))
+		for i, p := range pipesLocal {
+			a[i] = p.String()
+		}
+		localPipes := strings.Join(a, " | ")
+		if localPipes != localPipesExpected {
+			t.Fatalf("unexpected local pipes\ngot\n%s\nwant\n%s", localPipes, localPipesExpected)
+		}
+	}
+
+	f("*", "*", "")
+	f(`* | format "foo<bar>" | count() x`, `* | format "foo<bar>" | stats_remote count(*) as x | fields x`, `stats_local import_state(x) as x`)
+	f(`foo | sort by (_time desc) | limit 30 | keep a, _time`, `foo | sort by (_time desc) limit 30 | fields _time, a`, `sort by (_time desc) limit 30 | fields a, _time`)
+	f(`foo | sort by (_time desc) | limit 0 | keep a, _time`, `foo | limit 0 | fields _time, a`, `limit 0 | fields a, _time`)
+	f(`foo | sort by (_time desc) | offset 0 | limit 30 | keep a, _time`, `foo | sort by (_time desc) limit 30 | fields _time, a`, `sort by (_time desc) limit 30 | fields a, _time`)
+	f(`foo | sort by (_time desc) | offset 10 | limit 30 | keep a, _time`, `foo | sort by (_time desc) limit 40 | fields _time, a`, `sort by (_time desc) offset 10 limit 30 | fields a, _time`)
+
+	f(`foo | blocks_count`, `foo | blocks_count | fields "blocks_count"`, `stats sum("blocks_count") as "blocks_count"`)
+	f(`foo | block_stats`, `foo | block_stats`, ``)
+	f(`foo | collapse_nums`, `foo | collapse_nums`, ``)
+	f(`foo | copy a as b`, `foo | copy a as b`, ``)
+	f(`foo | decolorize`, `foo | decolorize`, ``)
+	f(`foo | delete x`, `foo | delete x`, ``)
+	f(`foo | drop_empty_fields`, `foo | drop_empty_fields`, ``)
+	f(`foo | extract "foo<bar>baz"`, `foo | extract "foo<bar>baz"`, ``)
+	f(`foo | extract_regexp "foo(?P<ip>[^;]+)"`, `foo | extract_regexp "foo(?P<ip>[^;]+)"`, ``)
+	f(`foo | facets`, `foo | facets 18446744073709551615 | fields field_name, field_value, hits`, `stats by (field_name, field_value) sum(hits) as hits | total_stats by (field_name) count(*) as field_values_count | filter field_values_count:<=1000 | sort by (hits desc) partition by (field_name) limit 10 | sort by (field_name, hits desc)`)
+	f(`foo | field_names`, `foo | field_names | fields hits, name`, `stats by (name) sum(hits) as hits`)
+	f(`foo | field_values x`, `foo | field_values x | fields hits, x`, `field_values_local x`)
+	f(`foo | fields x, y`, `foo | fields x, y`, ``)
+	f(`foo | filter a:b`, `foo a:b`, ``)
+	f(`foo | first 10 by (x)`, `foo | sort by (x) limit 10`, `sort by (x) limit 10`)
+	f(`foo | format "x<y>"`, `foo | format "x<y>"`, ``)
+	f(`foo | generate_sequence 10`, `foo | delete *`, `generate_sequence 10`)
+	f(`foo | join by (x) (bar)`, `foo`, `join by (x) (bar)`)
+	f(`foo | json_array_len (x) y`, `foo | json_array_len(x) as y`, ``)
+	f(`foo | hash(x) as y`, `foo | hash(x) as y`, ``)
+	f(`foo | last 10 by (x)`, `foo | sort by (x) desc limit 10`, `sort by (x) desc limit 10`)
+	f(`foo | len(x) as y`, `foo | len(x) as y`, ``)
+	f(`foo | limit 10`, `foo | limit 10`, `limit 10`)
+	f(`foo | math x+y as z`, `foo | math (x + y) as z`, ``)
+	f(`foo | offset 10`, `foo`, `offset 10`)
+	f(`foo | pack_json`, `foo | pack_json`, ``)
+	f(`foo | pack_logfmt`, `foo | pack_logfmt`, ``)
+	f(`foo | query_stats`, `foo | query_stats`, `query_stats_local`)
+	f(`foo | rename x as y`, `foo | rename x as y`, ``)
+	f(`foo | replace ("x", "y")`, `foo | replace (x, y)`, ``)
+	f(`foo | replace_regexp ("x", "y")`, `foo | replace_regexp (x, y)`, ``)
+	f(`foo | running_stats by (x) sum(y) as z`, `foo | delete z`, `running_stats by (x) sum(y) as z`)
+	f(`foo | sample 10`, `foo | sample 10`, ``)
+	f(`foo | split ","`, `foo | split ","`, ``)
+	f(`foo | stats by (x) count() as y`, `foo | stats_remote by (x) count(*) as y | fields x, y`, `stats_local by (x) import_state(y) as y`)
+	f(`foo | stream_context before 10 after 3`, `foo`, `stream_context before 10 after 3`)
+	f(`foo | time_add 1h`, `foo | time_add 1h`, ``)
+	f(`foo | top 10 by (x)`, `foo | stats by (x) count(*) as hits | fields hits, x`, `stats by (x) sum(hits) as hits | first 10 by (hits desc, x)`)
+	f(`foo | total_stats by (x) sum(y) as z`, `foo | delete z`, `total_stats by (x) sum(y) as z`)
+	f(`foo | union (bar)`, `foo`, `union (bar)`)
+	f(`foo | uniq by (x)`, `foo | uniq by (x) | fields x`, `uniq by (x)`)
+	f(`foo | unpack_json`, `foo | unpack_json`, ``)
+	f(`foo | unpack_logfmt`, `foo | unpack_logfmt`, ``)
+	f(`foo | unpack_syslog`, `foo | unpack_syslog`, ``)
+	f(`foo | unpack_words`, `foo | unpack_words`, ``)
+	f(`foo | unroll by (x)`, `foo | unroll by (x)`, ``)
+
+	// Special cases with 'offset 0'
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/620#issuecomment-3276624504
+	f(`foo | offset 0`, `foo`, ``)
+	f(`foo | offset 0 | limit 10`, `foo | limit 10`, `limit 10`)
+
+	f(`foo | offset 5 | limit 10`, `foo | limit 15`, `limit 15 | offset 5`)
+	f(`foo | limit 15 | offset 10 | offset 20 | limit 7`, `foo | limit 15`, `limit 15 | offset 10 | limit 27 | offset 20`)
+}
diff --git a/lib/logstorage/parser.go b/lib/logstorage/parser.go
index a1706609f3..02ddcc7474 100644
--- a/lib/logstorage/parser.go
+++ b/lib/logstorage/parser.go
@@ -122,6 +122,10 @@ func (lex *lexer) nextCompoundTokenExt(stopTokens []string) (string, error) {
 		return s, nil
 	}
 
+	if !lex.isSkippedSpace && lex.isKeywordAny(deniedFirstCompoundTokens) && isWord(lex.prevRawToken) {
+		return "", fmt.Errorf("missing whitespace between %q and %q", lex.prevRawToken, lex.token)
+	}
+
 	if !lex.isAllowedCompoundToken(stopTokens) {
 		return "", fmt.Errorf("compound token cannot start with %q; put it into quotes if needed", lex.token)
 	}
@@ -165,7 +169,14 @@ func (lex *lexer) isAllowedCompoundToken(stopTokens []string) bool {
 	}
 
 	// Regular word token is allowed to be a part of compound token.
-	for _, r := range lex.token {
+	return isWord(lex.token)
+}
+
+func isWord(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
 		if !isTokenRune(r) {
 			return false
 		}
@@ -173,6 +184,13 @@ func (lex *lexer) isAllowedCompoundToken(stopTokens []string) bool {
 	return true
 }
 
+// deniedFirstCompoundTokens contains disallowed starting tokens for compound tokens without the whitespace in front of these tokens.
+var deniedFirstCompoundTokens = []string{
+	"/",
+	".",
+	"$",
+}
+
 // glueCompoundTokens contains tokens allowed inside unquoted compound tokens.
 var glueCompoundTokens = []string{
 	"+", // Seen in time formats: 2025-07-20T10:20:30+03:00
@@ -190,7 +208,7 @@ var mathStopCompoundTokens = []string{
 	"/",
 }
 
-func (lex *lexer) isPrevRawToken(tokens ...string) bool {
+func (lex *lexer) isPrevRawToken(tokens []string) bool {
 	prevTokenLower := strings.ToLower(lex.prevRawToken)
 	for _, token := range tokens {
 		if token == prevTokenLower {
@@ -205,8 +223,8 @@ func (lex *lexer) checkPrevAdjacentToken(tokens ...string) error {
 		return nil
 	}
 
-	if !lex.isPrevRawToken(tokens...) {
-		return fmt.Errorf("missing whitespace or ':' between %q and %q; propbably, the whole string must be put into quotes", lex.prevRawToken, lex.token)
+	if !lex.isPrevRawToken(tokens) {
+		return fmt.Errorf("missing whitespace or ':' between %q and %q; probably, the whole string must be put into quotes", lex.prevRawToken, lex.token)
 	}
 
 	return nil
@@ -317,7 +335,7 @@ again:
 				return
 			}
 			b = utf8.AppendRune(b, ch)
-			size += len(s[size:]) - len(newTail)
+			size = len(s) - len(newTail)
 		}
 		size++
 		lex.token = string(b)
@@ -360,14 +378,22 @@ type queryOptions struct {
 	// needPrint is set to true if the queryOptions must be printed in the queryOptions.String().
 	needPrint bool
 
-	// concurrency is the number of concurrent workers to use for query execution on every.
+	// concurrency is the number of concurrent CPU-bound workers to use for a single query execution.
 	//
 	// By default the number of concurrent workers equals to the number of available CPU cores.
 	concurrency uint
 
+	// parallelReaders is the number of concurrent IO-bound data readers to use for a single query execution.
+	//
+	// By default the number of parallel readers equals to concurrency.
+	parallelReaders uint
+
 	// if ignoreGlobalTimeFilter is set, then Query.AddTimeFilter doesn't add the time filter to the query and to all its subqueries.
 	ignoreGlobalTimeFilter *bool
 
+	// allowPartialResponse allows returning partial responses in VictoriaLogs cluster setup when some of vlstorage nodes are temporarily unavailable.
+	allowPartialResponse *bool
+
 	// timeOffset is the number of nanoseconds to subtracts from all time filters in the query.
 	//
 	// The timeOffset is also added to the selected _time field values before being passed to query pipes.
@@ -388,6 +414,9 @@ func (opts *queryOptions) String() string {
 	if opts.ignoreGlobalTimeFilter != nil {
 		a = append(a, fmt.Sprintf("ignore_global_time_filter=%v", *opts.ignoreGlobalTimeFilter))
 	}
+	if opts.allowPartialResponse != nil {
+		a = append(a, fmt.Sprintf("allow_partial_response=%v", *opts.allowPartialResponse))
+	}
 	if opts.timeOffsetStr != "" {
 		a = append(a, fmt.Sprintf("time_offset=%s", opts.timeOffsetStr))
 	}
@@ -413,6 +442,24 @@ func (q *Query) String() string {
 	return s
 }
 
+// GetParallelReaders returns the number of parallel readers to use for executing the given query.
+func (q *Query) GetParallelReaders(defaultParallelReaders int) int {
+	n := int(q.opts.parallelReaders)
+	if n <= 0 {
+		n = int(q.opts.concurrency)
+	}
+	if n <= 0 {
+		n = defaultParallelReaders
+	}
+	if n <= 0 {
+		n = 2 * cgroup.AvailableCPUs()
+	}
+	if n > maxParallelReaders {
+		n = maxParallelReaders
+	}
+	return n
+}
+
 // GetConcurrency returns concurrency for the q.
 //
 // See https://docs.victoriametrics.com/victorialogs/logsql/#query-options
@@ -511,7 +558,7 @@ func (q *Query) AddFacetsPipe(limit, maxValuesPerField, maxValueLen int, keepCon
 // AddCountByTimePipe adds '| stats by (_time:step offset off, field1, ..., fieldN) count() hits' to the end of q.
 func (q *Query) AddCountByTimePipe(step, off int64, fields []string) {
 	// Drop pipes from q, which modify or delete _time field, since they make impossible to calculate stats grouped by _time.
-	q.dropTimeModificationPipes()
+	q.dropPipesUnsafeForHits()
 
 	{
 		// add 'stats by (_time:step offset off, fields) count() hits'
@@ -541,10 +588,11 @@ func (q *Query) AddCountByTimePipe(step, off int64, fields []string) {
 	}
 }
 
-// dropTimeModificationPipes drops pipes from q, which modify
-func (q *Query) dropTimeModificationPipes() {
+// dropPipesUnsafeForHits drops trailing pipes from q, which are unsafe
+// for calculating hits grouped by _time.
+func (q *Query) dropPipesUnsafeForHits() {
 	for i, p := range q.pipes {
-		if !p.canReturnLastNResults() {
+		if !isPipeSafeForHits(p) {
 			// Drop the rest of the pipes, including the current pipe,
 			// since it modified or deletes the _time field.
 			q.pipes = q.pipes[:i]
@@ -553,6 +601,25 @@ func (q *Query) dropTimeModificationPipes() {
 	}
 }
 
+func isPipeSafeForHits(p pipe) bool {
+	if p.canReturnLastNResults() {
+		return true
+	}
+
+	switch t := p.(type) {
+	case *pipeUnion:
+		// Allow union pipes, but drop pipes unsafe for hits inside them.
+		// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/641
+		t.q.dropPipesUnsafeForHits()
+		return true
+	case *pipeJoin:
+		// Allow join pipes, since they do not drop _time field.
+		return true
+	default:
+		return false
+	}
+}
+
 // Clone returns a copy of q at the given timestamp.
 func (q *Query) Clone(timestamp int64) *Query {
 	qStr := q.String()
@@ -579,6 +646,12 @@ func (q *Query) CloneWithTimeFilter(timestamp, start, end int64) *Query {
 //
 // The returned query is nil if q cannot be used for optimized querying of the last N results.
 func (q *Query) GetLastNResultsQuery() (qOpt *Query, offset uint64, limit uint64) {
+	start, end := q.GetFilterTimeRange()
+	if !CanApplyLastNResultsOptimization(start, end) {
+		// It is faster to execute the query as is on such a small time range.
+		return nil, 0, 0
+	}
+
 	pipes := q.pipes
 
 	// Remember the trailing 'fields' and 'delete' pipes - they are moved in front of `sort` pipe below.
@@ -624,6 +697,11 @@ func (q *Query) GetLastNResultsQuery() (qOpt *Query, offset uint64, limit uint64
 	return qCopy, offset, limit
 }
 
+// CanApplyLastNResultsOptimization returns true if there is sense for applying 'last N' optimization for the query on the time range [start, end]
+func CanApplyLastNResultsOptimization(start, end int64) bool {
+	return end/2-start/2 > nsecsPerSecond
+}
+
 func getOffsetLimitFromPipe(p pipe) (uint64, uint64, bool) {
 	switch t := p.(type) {
 	case *pipeSort:
@@ -714,14 +792,22 @@ func (q *Query) addTimeFilterNoSubqueries(start, end int64) {
 
 	timeOffset := q.opts.timeOffset
 
+	// use nanosecond precision for [start, end] time range in order to avoid
+	// automatic adjustement of timestamps for its' string representation.
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/587
+	//
+	// Do not use numeric representation of timestamps, since they are improperly parsed
+	// for negative timestamps (they are parsed as relative to the current time)
+	// and for timestamps with less than 15 decimal digits (they are parsed as microsends,
+	// milliseconds or seconds depending on the number of decimal digit).
+	startStr := marshalTimestampRFC3339NanoPreciseString(nil, start)
+	endStr := marshalTimestampRFC3339NanoPreciseString(nil, end)
+
 	ft := &filterTime{
 		minTimestamp: subNoOverflowInt64(start, timeOffset),
 		maxTimestamp: subNoOverflowInt64(end, timeOffset),
 
-		// use nanosecond representation in the query here in order to avoid
-		// automatic adjustement of the end timestamp for its' string representation.
-		// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/587
-		stringRepr: fmt.Sprintf("[%d,%d]", start, end),
+		stringRepr: fmt.Sprintf("[%s,%s]", startStr, endStr),
 	}
 
 	fa, ok := q.f.(*filterAnd)
@@ -790,8 +876,7 @@ func (q *Query) AddPipeOffsetLimit(offset, limit uint64) {
 	q.mustAppendPipe(limitStr)
 
 	// optimize the query, so the `offset` and `limit` pipes could be joined with the preceding `sort` pipe.
-	q.pipes = optimizeSortOffsetPipes(q.pipes)
-	q.pipes = optimizeSortLimitPipes(q.pipes)
+	q.pipes = optimizeOffsetLimitPipes(q.pipes)
 }
 
 func (q *Query) mustAppendPipe(s string) {
@@ -808,8 +893,7 @@ func (q *Query) optimize() {
 }
 
 func (q *Query) optimizeNoSubqueries() {
-	q.pipes = optimizeSortOffsetPipes(q.pipes)
-	q.pipes = optimizeSortLimitPipes(q.pipes)
+	q.pipes = optimizeOffsetLimitPipes(q.pipes)
 	q.pipes = optimizeUniqLimitPipes(q.pipes)
 	q.pipes = optimizeFilterPipes(q.pipes)
 
@@ -1325,22 +1409,115 @@ func removeStarFilters(f filter) filter {
 	return f
 }
 
-func optimizeSortOffsetPipes(pipes []pipe) []pipe {
-	// Merge 'sort ... | offset ...' into 'sort ... offset ...'
+func optimizeOffsetLimitPipes(pipes []pipe) []pipe {
+	for {
+		pipesLen := len(pipes)
+		pipes = optimizeOffsetLimitPipesInternal(pipes)
+		if len(pipes) == pipesLen {
+			return pipes
+		}
+	}
+}
+
+func optimizeOffsetLimitPipesInternal(pipes []pipe) []pipe {
+	// Replace '| offset X | limit Y' with '| limit X+Y | offset X'.
+	// This reduces the number of rows processed by remote storage.
+	// See: https://github.com/VictoriaMetrics/VictoriaLogs/issues/620#issuecomment-3276624504
+	for i := 0; i < len(pipes)-1; i++ {
+		po, ok := pipes[i].(*pipeOffset)
+		if !ok {
+			continue
+		}
+		pl, ok := pipes[i+1].(*pipeLimit)
+		if !ok {
+			continue
+		}
+
+		pl.limit += po.offset
+		pipes[i] = pl
+		pipes[i+1] = po
+	}
+
+	// Merge 'offset X | offset Y' into 'offset X+Y'.
 	i := 1
+	for i < len(pipes) {
+		po1, ok1 := pipes[i-1].(*pipeOffset)
+		po2, ok2 := pipes[i].(*pipeOffset)
+		if !ok1 || !ok2 {
+			i++
+			continue
+		}
+
+		po1.offset += po2.offset
+		pipes = append(pipes[:i], pipes[i+1:]...)
+	}
+
+	// Merge 'limit N | limit M' into 'limit min(N, M)'.
+	i = 1
+	for i < len(pipes) {
+		pl1, ok1 := pipes[i-1].(*pipeLimit)
+		pl2, ok2 := pipes[i].(*pipeLimit)
+		if !ok1 || !ok2 {
+			i++
+			continue
+		}
+
+		pl1.limit = min(pl1.limit, pl2.limit)
+		pipes = append(pipes[:i], pipes[i+1:]...)
+	}
+
+	// Replace '| limit X | offset Y' with 'limit 0' if Y >= X.
+	i = 1
+	for i < len(pipes) {
+		pl, ok1 := pipes[i-1].(*pipeLimit)
+		po, ok2 := pipes[i].(*pipeOffset)
+		if !ok1 || !ok2 || po.offset < pl.limit {
+			i++
+			continue
+		}
+
+		pl.limit = 0
+		pipes = append(pipes[:i], pipes[i+1:]...)
+	}
+
+	// Remove `offset 0`.
+	i = 0
 	for i < len(pipes) {
 		po, ok := pipes[i].(*pipeOffset)
-		if !ok {
+		if !ok || po.offset != 0 {
 			i++
 			continue
 		}
-		ps, ok := pipes[i-1].(*pipeSort)
-		if !ok {
+		pipes = append(pipes[:i], pipes[i+1:]...)
+	}
+
+	// Merge '| sort ... | offset ... | limit ...' into '| sort ... offset ... limit ...'.
+	pipes = optimizeSortOffsetPipes(pipes)
+	pipes = optimizeSortLimitPipes(pipes)
+
+	return pipes
+}
+
+func optimizeSortOffsetPipes(pipes []pipe) []pipe {
+	// Merge 'sort ... | offset ...' into 'sort ... offset ...'
+	i := 1
+	for i < len(pipes) {
+		ps, ok1 := pipes[i-1].(*pipeSort)
+		po, ok2 := pipes[i].(*pipeOffset)
+		if !ok1 || !ok2 {
 			i++
 			continue
 		}
-		if ps.offset == 0 && ps.limit == 0 {
-			ps.offset = po.offset
+
+		if ps.limit > 0 && po.offset >= ps.limit {
+			pipes[i-1] = &pipeLimit{}
+			pipes = append(pipes[:i], pipes[i+1:]...)
+			continue
+		}
+
+		ps.offset += po.offset
+		if ps.limit > 0 {
+			ps.limit -= po.offset
 		}
 		pipes = append(pipes[:i], pipes[i+1:]...)
 	}
@@ -1351,14 +1528,15 @@ func optimizeSortLimitPipes(pipes []pipe) []pipe {
 	// Merge 'sort ... | limit ...' into 'sort ... limit ...'
 	i := 1
 	for i < len(pipes) {
-		pl, ok := pipes[i].(*pipeLimit)
-		if !ok {
+		ps, ok1 := pipes[i-1].(*pipeSort)
+		pl, ok2 := pipes[i].(*pipeLimit)
+		if !ok1 || !ok2 {
 			i++
 			continue
 		}
-		ps, ok := pipes[i-1].(*pipeSort)
-		if !ok {
-			i++
+
+		if pl.limit == 0 {
+			pipes = append(pipes[:i-1], pipes[i:]...)
 			continue
 		}
 		if ps.limit == 0 || pl.limit < ps.limit {
@@ -1561,7 +1739,7 @@ func parseQuery(lex *lexer) (*Query, error) {
 	lex.pushQueryOptions(&q.opts)
 	defer lex.popQueryOptions()
 
-	f, err := parseFilter(lex)
+	f, err := parseFilter(lex, true)
 	if err != nil {
 		return nil, fmt.Errorf("%w; context: [%s]", err, lex.context())
 	}
@@ -1647,12 +1825,15 @@ func parseQueryOptions(dstOpts *queryOptions, lex *lexer) error {
 			if !ok {
 				return fmt.Errorf("cannot parse 'concurrency=%q' option as unsigned integer", v)
 			}
-			if n > 1024 {
-				// There is zero sense in running too many workers.
-				n = 1024
-			}
 			dstOpts.concurrency = uint(n)
 			dstOpts.needPrint = true
+		case "parallel_readers":
+			n, ok := tryParseUint64(v)
+			if !ok {
+				return fmt.Errorf("cannot parse 'parallel_readers=%q' option as unsigned integer", v)
+			}
+			dstOpts.parallelReaders = uint(n)
+			dstOpts.needPrint = true
 		case "ignore_global_time_filter":
 			ignoreGlobalTimeFilter, err := strconv.ParseBool(v)
 			if err != nil {
@@ -1660,6 +1841,13 @@ func parseQueryOptions(dstOpts *queryOptions, lex *lexer) error {
 			}
 			dstOpts.ignoreGlobalTimeFilter = &ignoreGlobalTimeFilter
 			dstOpts.needPrint = true
+		case "allow_partial_response":
+			allowPartialResponse, err := strconv.ParseBool(v)
+			if err != nil {
+				return fmt.Errorf("cannot parse 'allow_partial_response=%q' option as boolean: %w", v, err)
+			}
+			dstOpts.allowPartialResponse = &allowPartialResponse
+			dstOpts.needPrint = true
 		case "time_offset":
 			timeOffset, ok := tryParseDuration(v)
 			if !ok {
@@ -1702,16 +1890,18 @@ func parseKeyValuePair(lex *lexer) (string, string, error) {
 	return k, v, nil
 }
 
-func parseFilter(lex *lexer) (filter, error) {
+func parseFilter(lex *lexer, allowPipeKeywords bool) (filter, error) {
 	if lex.isKeyword("|", ")", "") {
 		return nil, fmt.Errorf("missing query")
 	}
 
-	// Verify the first token in the filter doesn't match pipe names.
-	firstToken := strings.ToLower(lex.rawToken)
-	if firstToken == "by" || isPipeName(firstToken) || isStatsFuncName(firstToken) {
-		return nil, fmt.Errorf("query filter cannot start with pipe keyword %q; see https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax; "+
-			"please put the first word of the filter into quotes", firstToken)
+	if !allowPipeKeywords {
+		// Verify the first token in the filter doesn't match pipe names.
+		firstToken := strings.ToLower(lex.rawToken)
+		if firstToken == "by" || isPipeName(firstToken) || isStatsFuncName(firstToken) {
+			return nil, fmt.Errorf("query filter cannot start with pipe keyword %q; see https://docs.victoriametrics.com/victorialogs/logsql/#query-syntax; "+
+				"please put the first word of the filter into quotes", firstToken)
+		}
 	}
 
 	fo, err := parseFilterOr(lex, "")
@@ -1805,8 +1995,12 @@ func parseFilterGeneric(lex *lexer, fieldName string) (filter, error) {
 		return parseFilterContainsAll(lex, fieldName)
 	case lex.isKeyword("contains_any"):
 		return parseFilterContainsAny(lex, fieldName)
+	case lex.isKeyword("contains_common_case"):
+		return parseFilterContainsCommonCase(lex, fieldName)
 	case lex.isKeyword("eq_field"):
 		return parseFilterEqField(lex, fieldName)
+	case lex.isKeyword("equals_common_case"):
+		return parseFilterEqualsCommonCase(lex, fieldName)
 	case lex.isKeyword("exact"):
 		return parseFilterExact(lex, fieldName)
 	case lex.isKeyword("i"):
@@ -2112,6 +2306,36 @@ func parseFilterIn(lex *lexer, fieldName string) (filter, error) {
 	return parseInValues(lex, fieldName, fi, &fi.values)
 }
 
+func parseFilterContainsCommonCase(lex *lexer, fieldName string) (filter, error) {
+	lex.nextToken()
+
+	phrases, err := parseArgsInParens(lex)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse 'contains_common_case(...)' args: %w", err)
+	}
+
+	fi, err := newFilterContainsCommonCase(fieldName, phrases)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse 'contains_common_case(...)': %w", err)
+	}
+	return fi, nil
+}
+
+func parseFilterEqualsCommonCase(lex *lexer, fieldName string) (filter, error) {
+	lex.nextToken()
+
+	phrases, err := parseArgsInParens(lex)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse 'equals_common_case(...)' args: %w", err)
+	}
+
+	fi, err := newFilterEqualsCommonCase(fieldName, phrases)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse 'equals_common_case(...)': %w", err)
+	}
+	return fi, nil
+}
+
 func parseInValues(lex *lexer, fieldName string, f filter, iv *inValues) (filter, error) {
 	// Try parsing in(arg1, ..., argN) at first
 	lexState := lex.backupState()
@@ -2276,12 +2500,18 @@ func parseFilterStar(lex *lexer, fieldName string) (filter, error) {
 }
 
 func parseFilterTilda(lex *lexer, fieldName string) (filter, error) {
+	op := lex.token
 	lex.nextToken()
 
 	if lex.isKeyword("-") {
 		return nil, fmt.Errorf("regexp, which start with %q, must be put in quotes", lex.token)
 	}
 
+	if lex.isSkippedSpace && fieldName == "" {
+		// Deny invalid filters `foo ~ bar` and `foo !~ bar`. They must be written as `foo:~bar` and `foo:!~bar`
+		return nil, fmt.Errorf("missing ':' in front of %q; see https://docs.victoriametrics.com/victorialogs/logsql/#filters", op)
+	}
+
 	arg, err := lex.nextCompoundToken()
 	if err != nil {
 		return nil, fmt.Errorf("cannot read regexp for field %q: %w", getCanonicalColumnName(fieldName), err)
@@ -2304,6 +2534,10 @@ func parseFilterNotTilda(lex *lexer, fieldName string) (filter, error) {
 func parseFilterEQ(lex *lexer, fieldName string) (filter, error) {
 	op := lex.token
 	lex.nextToken()
+	if lex.isSkippedSpace && fieldName == "" {
+		// Deny invalid filters 'foo = bar`. It must be written as `foo:=bar`
+		return nil, fmt.Errorf("missing ':' in front of %q; see https://docs.victoriametrics.com/victorialogs/logsql/#filters", op)
+	}
 
 	phrase, err := lex.nextCompoundToken()
 	if err != nil {
@@ -2341,12 +2575,17 @@ func parseFilterGT(lex *lexer, fieldName string) (filter, error) {
 
 	includeMinValue := false
 	op := ">"
-	if lex.isKeyword("=") {
+	if !lex.isSkippedSpace && lex.isKeyword("=") {
 		lex.nextToken()
 		includeMinValue = true
 		op = ">="
 	}
 
+	if lex.isSkippedSpace && fieldName == "" {
+		// Deny invalid filters 'foo > bar' and 'foo >= bar'. They must be written as 'foo:>bar` and `foo:>=bar`
+		return nil, fmt.Errorf("missing ':' in front of %q; see https://docs.victoriametrics.com/victorialogs/logsql/#filters", op)
+	}
+
 	lexState := lex.backupState()
 	minValue, fStr, err := parseNumber(lex)
 	if err != nil {
@@ -2376,12 +2615,17 @@ func parseFilterLT(lex *lexer, fieldName string) (filter, error) {
 
 	includeMaxValue := false
 	op := "<"
-	if lex.isKeyword("=") {
+	if !lex.isSkippedSpace && lex.isKeyword("=") {
 		lex.nextToken()
 		includeMaxValue = true
 		op = "<="
 	}
 
+	if lex.isSkippedSpace && fieldName == "" {
+		// Deny invalid filters 'foo < bar' and 'foo <= bar'. They must be written as 'foo:<bar' and 'foo:<=bar'
+		return nil, fmt.Errorf("missing ':' in front of %q; see https://docs.victoriametrics.com/victorialogs/logsql/#filters", op)
+	}
+
 	lexState := lex.backupState()
 	maxValue, fStr, err := parseNumber(lex)
 	if err != nil {
@@ -3547,7 +3791,9 @@ var reservedKeywords = func() map[string]struct{} {
 		// functions
 		"contains_all",
 		"contains_any",
+		"contains_common_case",
 		"eq_field",
+		"equals_common_case",
 		"exact",
 		"i",
 		"in",
diff --git a/lib/logstorage/parser_test.go b/lib/logstorage/parser_test.go
index 9ab85c08df..0a3711645a 100644
--- a/lib/logstorage/parser_test.go
+++ b/lib/logstorage/parser_test.go
@@ -197,64 +197,68 @@ func TestQuery_AddTimeFilter(t *testing.T) {
 	}
 
 	// star filter
-	f(`*`, `_time:[1735138603000000000,1736772334999999999]`)
+	f(`*`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z]`)
 
 	// or, plus non-query in(...)
-	f(`foo or bar:in(baz)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:in(baz))`)
-	f(`foo or bar:contains_any(baz)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_any(baz))`)
-	f(`foo or bar:contains_all(baz)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_all(baz))`)
+	f(`foo or bar:in(baz)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:in(baz))`)
+	f(`foo or bar:contains_any(baz)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_any(baz))`)
+	f(`foo or bar:contains_all(baz)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_all(baz))`)
 
 	// or, plus query in(...)
-	f(`foo or bar:in(baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:in(_time:[1735138603000000000,1736772334999999999] baz | fields bar))`)
-	f(`foo or bar:contains_any(baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_any(_time:[1735138603000000000,1736772334999999999] baz | fields bar))`)
-	f(`foo or bar:contains_all(baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_all(_time:[1735138603000000000,1736772334999999999] baz | fields bar))`)
+	f(`foo or bar:in(baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:in(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] baz | fields bar))`)
+	f(`foo or bar:contains_any(baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_any(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] baz | fields bar))`)
+	f(`foo or bar:contains_all(baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_all(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] baz | fields bar))`)
 
 	// ignore global time filter
 	f(`options(ignore_global_time_filter=true) foo or bar:in(baz | fields bar)`, `options(ignore_global_time_filter=true) foo or bar:in(baz | fields bar)`)
-	f(`foo or bar:in(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:in(options(ignore_global_time_filter=true) baz | fields bar))`)
+	f(`foo or bar:in(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:in(options(ignore_global_time_filter=true) baz | fields bar))`)
 	f(`options(ignore_global_time_filter=true) foo or bar:contains_any(baz | fields bar)`, `options(ignore_global_time_filter=true) foo or bar:contains_any(baz | fields bar)`)
-	f(`foo or bar:contains_any(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_any(options(ignore_global_time_filter=true) baz | fields bar))`)
+	f(`foo or bar:contains_any(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_any(options(ignore_global_time_filter=true) baz | fields bar))`)
 	f(`options(ignore_global_time_filter=true) foo or bar:contains_all(baz | fields bar)`, `options(ignore_global_time_filter=true) foo or bar:contains_all(baz | fields bar)`)
-	f(`foo or bar:contains_all(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[1735138603000000000,1736772334999999999] (foo or bar:contains_all(options(ignore_global_time_filter=true) baz | fields bar))`)
+	f(`foo or bar:contains_all(options(ignore_global_time_filter=true) baz | fields bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] (foo or bar:contains_all(options(ignore_global_time_filter=true) baz | fields bar))`)
+
+	// allow_partial_response option
+	f(`options(allow_partial_response=true) * | count() x`, `options(allow_partial_response=true) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) as x`)
+	f(`options(allow_partial_response=false) * | count() x`, `options(allow_partial_response=false) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) as x`)
 
 	// time_offset option
-	f(`options(time_offset=1d3h534ms) *`, `options(time_offset=1d3h534ms) _time:[1735138603000000000,1736772334999999999]`)
-	f(`options(time_offset = -1.5h) _time:2024Z`, `options(time_offset=-1.5h) _time:[1735138603000000000,1736772334999999999] _time:2024Z`)
-	f(`options(time_offset = -1.5h) _time:2025Z offset 3.5h`, `options(time_offset=-1.5h) _time:[1735138603000000000,1736772334999999999] _time:2025Z offset 3.5h`)
-	f(`options(time_offset = -1.5h) _time:2025Z offset -3.5h`, `options(time_offset=-1.5h) _time:[1735138603000000000,1736772334999999999] _time:2025Z offset -3.5h`)
-	f(`options(time_offset=1h) id:in(_time:2025Z | keep id)`, `options(time_offset=1h) _time:[1735138603000000000,1736772334999999999] id:in(_time:[1735138603000000000,1736772334999999999] _time:2025Z | fields id)`)
-	f(`id:in(options(time_offset=1h) _time:2025Z | keep id)`, `_time:[1735138603000000000,1736772334999999999] id:in(options(time_offset=1h) _time:[1735138603000000000,1736772334999999999] _time:2025Z | fields id)`)
-	f(`options(time_offset=1d) id:in(options(time_offset=1h) _time:2025Z | keep id)`, `options(time_offset=1d) _time:[1735138603000000000,1736772334999999999] id:in(options(time_offset=1h) _time:[1735138603000000000,1736772334999999999] _time:2025Z | fields id)`)
+	f(`options(time_offset=1d3h534ms) *`, `options(time_offset=1d3h534ms) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z]`)
+	f(`options(time_offset = -1.5h) _time:2024Z`, `options(time_offset=-1.5h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2024Z`)
+	f(`options(time_offset = -1.5h) _time:2025Z offset 3.5h`, `options(time_offset=-1.5h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2025Z offset 3.5h`)
+	f(`options(time_offset = -1.5h) _time:2025Z offset -3.5h`, `options(time_offset=-1.5h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2025Z offset -3.5h`)
+	f(`options(time_offset=1h) id:in(_time:2025Z | keep id)`, `options(time_offset=1h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] id:in(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2025Z | fields id)`)
+	f(`id:in(options(time_offset=1h) _time:2025Z | keep id)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] id:in(options(time_offset=1h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2025Z | fields id)`)
+	f(`options(time_offset=1d) id:in(options(time_offset=1h) _time:2025Z | keep id)`, `options(time_offset=1d) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] id:in(options(time_offset=1h) _time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] _time:2025Z | fields id)`)
 
 	// join pipe
-	f(`foo | join by (x) (bar)`, `_time:[1735138603000000000,1736772334999999999] foo | join by (x) (_time:[1735138603000000000,1736772334999999999] bar)`)
-	f(`foo | join by (x) (options(ignore_global_time_filter=true) bar)`, `_time:[1735138603000000000,1736772334999999999] foo | join by (x) (options(ignore_global_time_filter=true) bar)`)
+	f(`foo | join by (x) (bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] foo | join by (x) (_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] bar)`)
+	f(`foo | join by (x) (options(ignore_global_time_filter=true) bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] foo | join by (x) (options(ignore_global_time_filter=true) bar)`)
 
 	// union pipe
-	f(`foo | union (bar)`, `_time:[1735138603000000000,1736772334999999999] foo | union (_time:[1735138603000000000,1736772334999999999] bar)`)
-	f(`foo | union (options(ignore_global_time_filter=true) bar)`, `_time:[1735138603000000000,1736772334999999999] foo | union (options(ignore_global_time_filter=true) bar)`)
+	f(`foo | union (bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] foo | union (_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] bar)`)
+	f(`foo | union (options(ignore_global_time_filter=true) bar)`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] foo | union (options(ignore_global_time_filter=true) bar)`)
 	f(`options(ignore_global_time_filter=1) foo | union (bar)`, `options(ignore_global_time_filter=true) foo | union (bar)`)
 
 	// stats pipe with if conditions
-	f(`* | count() if (x:in(y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:in(_time:[1735138603000000000,1736772334999999999] y | fields x) abc) as a, count(*) as b`)
-	f(`* | count() if (x:in(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:in(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
-	f(`* | count() if (x:contains_any(y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:contains_any(_time:[1735138603000000000,1736772334999999999] y | fields x) abc) as a, count(*) as b`)
-	f(`* | count() if (x:contains_any(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:contains_any(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
-	f(`* | count() if (x:contains_all(y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:contains_all(_time:[1735138603000000000,1736772334999999999] y | fields x) abc) as a, count(*) as b`)
-	f(`* | count() if (x:contains_all(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[1735138603000000000,1736772334999999999] | stats count(*) if (x:contains_all(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:in(y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:in(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:in(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:in(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:contains_any(y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:contains_any(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:contains_any(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:contains_any(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:contains_all(y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:contains_all(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x) abc) as a, count(*) as b`)
+	f(`* | count() if (x:contains_all(options(ignore_global_time_filter=true) y | keep x) abc) a, count() b`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats count(*) if (x:contains_all(options(ignore_global_time_filter=true) y | fields x) abc) as a, count(*) as b`)
 
 	// other pipes with if conditions
-	f(`* | format if (x:in(y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:in(_time:[1735138603000000000,1736772334999999999] y | fields x)) foo`)
-	f(`* | format if (x:in(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:in(options(ignore_global_time_filter=true) y | fields x)) foo`)
-	f(`* | format if (x:contains_any(y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:contains_any(_time:[1735138603000000000,1736772334999999999] y | fields x)) foo`)
-	f(`* | format if (x:contains_any(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:contains_any(options(ignore_global_time_filter=true) y | fields x)) foo`)
-	f(`* | format if (x:contains_all(y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:contains_all(_time:[1735138603000000000,1736772334999999999] y | fields x)) foo`)
-	f(`* | format if (x:contains_all(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[1735138603000000000,1736772334999999999] | format if (x:contains_all(options(ignore_global_time_filter=true) y | fields x)) foo`)
+	f(`* | format if (x:in(y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:in(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x)) foo`)
+	f(`* | format if (x:in(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:in(options(ignore_global_time_filter=true) y | fields x)) foo`)
+	f(`* | format if (x:contains_any(y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:contains_any(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x)) foo`)
+	f(`* | format if (x:contains_any(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:contains_any(options(ignore_global_time_filter=true) y | fields x)) foo`)
+	f(`* | format if (x:contains_all(y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:contains_all(_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] y | fields x)) foo`)
+	f(`* | format if (x:contains_all(options(ignore_global_time_filter=true) y | keep x)) "foo"`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | format if (x:contains_all(options(ignore_global_time_filter=true) y | fields x)) foo`)
 
 	// queries with rate and sum_rate (the time filter must propagate to them)
-	f(`* | rate() x`, `_time:[1735138603000000000,1736772334999999999] | stats rate() as x`)
-	f(`* | rate_sum(requests) x`, `_time:[1735138603000000000,1736772334999999999] | stats rate_sum(requests) as x`)
-	f(`* | join on (x) (* | rate() y) | rate() z`, `_time:[1735138603000000000,1736772334999999999] | join by (x) (_time:[1735138603000000000,1736772334999999999] | stats rate() as y) | stats rate() as z`)
+	f(`* | rate() x`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats rate() as x`)
+	f(`* | rate_sum(requests) x`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats rate_sum(requests) as x`)
+	f(`* | join on (x) (* | rate() y) | rate() z`, `_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | join by (x) (_time:[2024-12-25T14:56:43.000000000Z,2025-01-13T12:45:34.999999999Z] | stats rate() as y) | stats rate() as z`)
 }
 
 func TestQuery_AddTimeFilter_StepPropagation(t *testing.T) {
@@ -355,6 +359,63 @@ func TestQuery_AddTimeFilter_StepPropagation(t *testing.T) {
 	})
 }
 
+func TestParseQuery_OptimizeOffsetLimitPipes(t *testing.T) {
+	f := func(s, resultExpected string) {
+		t.Helper()
+
+		q, err := ParseQuery(s)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		result := q.String()
+		if result != resultExpected {
+			t.Fatalf("unexpected result; got\n%s\nwant\n%s", result, resultExpected)
+		}
+	}
+
+	f(`* | sort by (x) | limit 30`, `* | sort by (x) limit 30`)
+	f(`* | sort by (x) | offset 10`, `* | sort by (x) offset 10`)
+	f(`* | sort by (x) | offset 10 | limit 30`, `* | sort by (x) offset 10 limit 30`)
+	f(`* | sort by (x) | offset 0`, `* | sort by (x)`)
+	f(`* | sort by (x) | offset 0 | fields a, b`, `* | sort by (x) | fields a, b`)
+	f(`* | sort by (x) | limit 0`, `* | limit 0`)
+	f(`* | sort by (x) | limit 0 | keep a, b`, `* | limit 0 | fields a, b`)
+
+	f(`* | sort by (x) | limit 30 | limit 20`, `* | sort by (x) limit 20`)
+	f(`* | sort by (x) offset 5 | offset 10 | limit 30`, `* | sort by (x) offset 15 limit 30`)
+	f(`* | sort by (x) limit 12 | offset 10 | limit 30`, `* | sort by (x) offset 10 limit 2`)
+	f(`* | sort by (x) offset 3 limit 12 | offset 10 | limit 30 | fields x`, `* | sort by (x) offset 13 limit 2 | fields x`)
+	f(`* | sort by (x) offset 3 limit 10 | offset 10 | limit 30 | fields x`, `* | limit 0 | fields x`)
+	f(`* | sort by (x) | limit 30 | limit 20 | offset 4`, `* | sort by (x) offset 4 limit 16`)
+	f(`* | sort by (x) | limit 30 | limit 20 | offset 4 | offset 5`, `* | sort by (x) offset 9 limit 11`)
+	f(`* | sort by (x) | limit 30 | limit 20 | offset 4 | offset 5 | fields x`, `* | sort by (x) offset 9 limit 11 | fields x`)
+
+	// Verify the case without 'sort' pipe and with 'offset 0' pipes.
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/620#issuecomment-3276624504
+	f(`* | offset 0`, `*`)
+	f(`* | offset 0 | limit 10`, `* | limit 10`)
+
+	// 'ofset N | limit M' without preceding 'sort' pipe
+	f(`* | offset 10 | limit 30`, `* | limit 40 | offset 10`)
+	f(`* | offset 10 | limit 30 | fields x`, `* | limit 40 | offset 10 | fields x`)
+
+	// 'limit N | offset M' where M >= N
+	f(`* | limit 10 | offset 20`, `* | limit 0`)
+
+	// Multiple offset pipes
+	f(`* | offset 10 | offset 30 | offset 50`, `* | offset 90`)
+
+	// Multiple limit pipes
+	f(`* | limit 50 | limit 5 | limit 20`, `* | limit 5`)
+
+	// Mix of limit and offset pipes
+	f(`* | offset 3 | limit 10 | offset 5 | limit 30 | limit 5`, `* | limit 13 | offset 8`)
+	f(`* | offset 3 | limit 10 | offset 5 | limit 30 | limit 15`, `* | limit 13 | offset 8`)
+	f(`* | offset 3 | limit 10 | offset 5 | limit 30 | limit 4`, `* | limit 12 | offset 8`)
+	f(`* | offset 3 | limit 10 | offset 5 | limit 30 | limit 1`, `* | limit 9 | offset 8`)
+	f(`* | offset 3 | limit 10 | offset 5 | limit 30 | limit 0`, `* | limit 0`)
+}
+
 func TestParseQuery_OptimizeStarFilters(t *testing.T) {
 	f := func(s, resultExpected string) {
 		t.Helper()
@@ -1171,10 +1232,10 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`foo :  :bar`, `foo:":bar"`)
 	f(`foo:(:bar)`, `foo:":bar"`)
 	f(`foo : ( :bar )`, `foo:":bar"`)
-	f(`foo:::: bar`, `foo:":::" bar`)
-	f(`1 = 2`, `1 =2`)
+	f(`foo: ::: bar`, `foo:":::" bar`)
+	f(`1 =2`, `1 =2`)
 	f(`1 - 2`, `1 !2`)
-	f(`1 ~ 2`, `1 ~2`)
+	f(`1 ~2`, `1 ~2`)
 	f(`1* 2`, `1* 2`)
 	f(`1 * 2`, `1 2`)
 	f(`"" bar`, `"" bar`)
@@ -1442,6 +1503,16 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`_time`, `_time`)
 	f(`x:_time`, `x:_time`)
 
+	// contains_common_case filter
+	f("contains_common_case(foo)", "contains_common_case(foo)")
+	f("contains_common_case(foo, 'bar,baz')", `contains_common_case(foo,"bar,baz")`)
+	f("foo:contains_common_case(foo, 'bar,baz')", `foo:contains_common_case(foo,"bar,baz")`)
+
+	// equals_common_case filter
+	f("equals_common_case(foo)", "equals_common_case(foo)")
+	f("equals_common_case(foo, 'bar,baz')", `equals_common_case(foo,"bar,baz")`)
+	f("foo:equals_common_case(foo, 'bar,baz')", `foo:equals_common_case(foo,"bar,baz")`)
+
 	// eq_field filter
 	f("eq_field(foo)", "eq_field(foo)")
 	f(`"a":eq_field('b')`, "a:eq_field(b)")
@@ -1734,7 +1805,7 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`foo | head 10K`, `foo | limit 10000`)
 
 	// multiple limit pipes
-	f(`foo | limit 100 | limit 10 | limit 234`, `foo | limit 100 | limit 10 | limit 234`)
+	f(`foo | limit 100 | limit 10 | limit 234`, `foo | limit 10`)
 
 	// offset and skip pipe
 	f(`foo | skip 10`, `foo | offset 10`)
@@ -1742,7 +1813,7 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`foo | skip 12_345M`, `foo | offset 12345000000`)
 
 	// multiple offset pipes
-	f(`foo | offset 10 | offset 100`, `foo | offset 10 | offset 100`)
+	f(`foo | offset 10 | offset 100`, `foo | offset 110`)
 
 	// query_stats pipe
 	f(`* | query_stats`, `* | query_stats`)
@@ -2006,7 +2077,7 @@ func TestParseQuery_Success(t *testing.T) {
 
 	// multiple different pipes
 	f(`* | fields foo, bar | limit 100 | stats by(foo,bar) count(baz) as qwert`, `* | fields foo, bar | limit 100 | stats by (foo, bar) count(baz) as qwert`)
-	f(`* | skip 100 | head 20 | skip 10`, `* | offset 100 | limit 20 | offset 10`)
+	f(`* | skip 100 | head 20 | skip 10`, `* | limit 120 | offset 110`)
 
 	// comments
 	f(`* # some comment | foo bar`, `*`)
@@ -2023,6 +2094,7 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`options (concurrency=10) foo | count() c`, `options(concurrency=10) foo | stats count(*) as c`)
 	f(`options (concurrency=10, concurrency =   42,) foo | count() c`, `options(concurrency=42) foo | stats count(*) as c`)
 	f(`options (concurrency=0) *`, `*`)
+	f(`options (parallel_readers=10) *`, `*`)
 	f(`options(ignore_global_time_filter=true) *`, `options(ignore_global_time_filter=true) *`)
 	f(`options(time_offset=1h) *`, `options(time_offset=1h) *`)
 	f(`options(time_offset=1h) _time:1d`, `options(time_offset=1h) _time:1d`)
@@ -2065,6 +2137,21 @@ func TestParseQuery_Success(t *testing.T) {
 	f(`-~a`, `!~a`)
 	f(`foo-bar.baz/x+z$`, `"foo-bar.baz/x+z$"`)
 	f(`foo:bar:baz:x-z`, `foo:"bar:baz:x-z"`)
+
+	// pipe names without quotes
+	f(`filter foo:bar`, `"filter" foo:bar`)
+	f(`stats count`, `"stats" "count"`)
+	f(`count`, `"count"`)
+	f(`fields.foo:bar`, `fields.foo:bar`)
+	f(`fields.foo`, `fields.foo`)
+
+	f(`foo | filter stats`, `foo "stats"`)
+	f(`foo | limit 1 | filter stats`, `foo | limit 1 | filter "stats"`)
+	f(`foo | filter fields`, `foo "fields"`)
+	f(`foo | filter by`, `foo "by"`)
+	f(`foo | filter count`, `foo "count"`)
+	f(`foo | * bar`, `foo bar`)
+	f(`foo | -bar`, `foo !bar`)
 }
 
 func TestParseQuery_Failure(t *testing.T) {
@@ -2106,22 +2193,37 @@ func TestParseQuery_Failure(t *testing.T) {
 	f(`foo=bar`)
 	f(`==foo`)
 	f(`foo==bar`)
+	f(`foo == bar`)
 	f(`foo!=bar`)
+	f(`foo != bar`)
 	f(`foo!~bar`)
+	f(`foo !~ bar`)
 	f(`foo~=bar`)
+	f(`foo ~= bar`)
 	f(`foo~!bar`)
+	f(`foo ~! bar`)
 	f(`foo=~bar`)
+	f(`foo =~ bar`)
 	f(`foo~:bar`)
+	f(`foo ~: bar`)
 	f(`foo>bar`)
+	f(`foo > bar`)
 	f(`foo>=bar`)
+	f(`foo >= bar`)
 	f(`foo<bar`)
+	f(`foo < bar`)
 	f(`foo<=bar`)
+	f(`foo <= bar`)
 	f(`foo,bar`)
+	f(`foo , bar`)
 	f(`foo:1*1`)
 	f(`1*1`)
 	f(`foo:~=bar`)
+	f(`foo : ~= bar`)
 	f(`foo:~-bar`)
+	f(`foo : ~- bar`)
 	f(`foo:~!bar`)
+	f(`foo : ~! bar`)
 	f(`foo!b`)
 	f(`foo;bar`)
 	f(`foo(bar)`)
@@ -2139,17 +2241,14 @@ func TestParseQuery_Failure(t *testing.T) {
 	f(`1*2`)
 	f(`1 == 2`)
 	f(`1 ~~ 2`)
+	f(`foo = bar`)
+	f(`foo ~ bar`)
 
 	// Invalid substring filters
 	f(`*foo *`)
 	f(`foo *bar`)
 	f(`*foo;bar*`)
 
-	// pipe names without quotes
-	f(`filter foo:bar`)
-	f(`stats count()`)
-	f(`count()`)
-
 	// invalid parens
 	f("(")
 	f("foo (bar ")
@@ -2270,6 +2369,14 @@ func TestParseQuery_Failure(t *testing.T) {
 	// unknown function
 	f(`unknown_function(foo)`)
 
+	// invalid contains_common_case
+	f(`contains_common_case(`)
+	f(`contains_common_case(foo bar)`)
+
+	// invalid equals_common_case
+	f(`equals_common_case(`)
+	f(`equals_common_case(foo bar)`)
+
 	// invalid eq_field
 	f(`eq_field(`)
 	f(`eq_field(foo bar)`)
@@ -2684,11 +2791,9 @@ func TestParseQuery_Failure(t *testing.T) {
 	f(`foo | filter (`)
 	f(`foo | filter )`)
 
-	f(`foo | filter stats`)
-	f(`foo | filter fields`)
-	f(`foo | filter by`)
 	f(`foo | count`)
-	f(`foo | filter count`)
+	f(`foo | by`)
+	f(`foo | stats`)
 	f(`foo | (`)
 	f(`foo | )`)
 
@@ -2732,13 +2837,64 @@ func TestParseQuery_Failure(t *testing.T) {
 	f(`options(foo=123)`)
 	f(`options(abc)`)
 	f(`options(concurrency=qwe)`)
+	f(`options(parallel_readers=-123)`)
 	f(`options(time_offset=)`)
 	f(`options(time_offset=foo)`)
 	f(`options(ignore_global_time_filter=123)`)
+	f(`options(allow_partial_response=123)`)
 
 	// valid options, but missing query filter
 	f(`options(concurrency=12)`)
 	f(`options(concurrency=12) | count()`)
+
+	// pipe names without whitespace after the pipe name
+	f(`* | block_stats.x`)
+	f(`* | blocks_count.x`)
+	f(`* | collapse_nums.at x`)
+	f(`* | copy.x as y`)
+	f(`* | decolorize.x`)
+	f(`* | delete.x`)
+	f(`* | drop_empty_fields.x`)
+	f(`* | extract.x from y`)
+	f(`* | extract_regexp.x from y`)
+	f(`* | facets.max_value_len 3`)
+	f(`* | field_names.x`)
+	f(`* | field_values.x`)
+	f(`* | fields.x`)
+	f(`* | filter.x`)
+	f(`* | first.10 by (x)`)
+	f(`* | format.x as y`)
+	f(`* | generate_sequence.100`)
+	f(`* | join.by(x) (y)`)
+	f(`* | json_array_len.x`)
+	f(`* | hash.x`)
+	f(`* | last.10 by (x)`)
+	f(`* | len.x`)
+	f(`* | limit.10`)
+	f(`* | math.x + y`)
+	f(`* | offset.10`)
+	f(`* | pack_json.x`)
+	f(`* | pack_logfmt.x`)
+	f(`* | query_stats.x`)
+	f(`* | rename.x as y`)
+	f(`* | replace.x y`)
+	f(`* | replace_regexp.x y`)
+	f(`* | running_stats.count()`)
+	f(`* | sample.10`)
+	f(`* | sort.by (x)`)
+	f(`* | split.x from y as z`)
+	f(`* | stats.count()`)
+	f(`* | stream_context.before 10`)
+	f(`* | time_add.5h`)
+	f(`* | top.5 by (x)`)
+	f(`* | total_stats.count()`)
+	f(`* | union.x`)
+	f(`* | uniq.x`)
+	f(`* | unpack_json.x`)
+	f(`* | unpack_logfmt.x`)
+	f(`* | unpack_syslog.x`)
+	f(`* | unpack_words.x`)
+	f(`* | unroll.x`)
 }
 
 func TestQueryGetNeededColumns(t *testing.T) {
@@ -3900,6 +4056,14 @@ func TestQuery_AddCountByTimePipe(t *testing.T) {
 	// pipes, which do not change _time field
 	f("* | extract 'abc<de>fg' | filter de:='qwer'", nsecsPerMinute, 0, nil, `* | extract "abc<de>fg" | filter de:=qwer | stats by (_time:1m) count(*) as hits | sort by (_time)`)
 
+	// union pipe is allowed. See https://github.com/VictoriaMetrics/VictoriaLogs/issues/641
+	f(`foo | union (bar)`, nsecsPerMinute, 0, nil, `foo | union (bar) | stats by (_time:1m) count(*) as hits | sort by (_time)`)
+	f(`foo | union (bar) | stats count()`, nsecsPerMinute, 0, nil, `foo | union (bar) | stats by (_time:1m) count(*) as hits | sort by (_time)`)
+	f(`foo | union (bar | stats count())`, nsecsPerMinute, 0, nil, `foo | union (bar) | stats by (_time:1m) count(*) as hits | sort by (_time)`)
+
+	// join pipe is allowed
+	f(`foo | join by (x) (y)`, nsecsPerMinute, 0, nil, `foo | join by (x) (y) | stats by (_time:1m) count(*) as hits | sort by (_time)`)
+
 	// pipes, which change _time field
 	f("* | extract 'abc<de>fg' | filter de:='qwer' | stats count()", nsecsPerMinute, 0, nil, `* | extract "abc<de>fg" | filter de:=qwer | stats by (_time:1m) count(*) as hits | sort by (_time)`)
 	f("* | extract 'abc<de>fg' | sort by (x)", nsecsPerMinute, 0, nil, `* | extract "abc<de>fg" | stats by (_time:1m) count(*) as hits | sort by (_time)`)
diff --git a/lib/logstorage/pattern.go b/lib/logstorage/pattern.go
index e10fa4a542..5d2b8436c7 100644
--- a/lib/logstorage/pattern.go
+++ b/lib/logstorage/pattern.go
@@ -5,6 +5,7 @@ import (
 	"html"
 	"strconv"
 	"strings"
+	"unicode/utf8"
 
 	"github.com/VictoriaMetrics/VictoriaLogs/lib/prefixfilter"
 )
@@ -161,18 +162,34 @@ func tryUnquoteString(s, opt string) (string, int) {
 	if len(s) == 0 {
 		return "", -1
 	}
-	if s[0] != '"' && s[0] != '`' {
-		return "", -1
-	}
-	qp, err := strconv.QuotedPrefix(s)
-	if err != nil {
-		return "", -1
-	}
-	us, err := strconv.Unquote(qp)
-	if err != nil {
+
+	switch s[0] {
+	case '"', '`':
+		qp, err := strconv.QuotedPrefix(s)
+		if err != nil {
+			return "", -1
+		}
+		us, err := strconv.Unquote(qp)
+		if err != nil {
+			return "", -1
+		}
+		return us, len(qp)
+	case '\'':
+		sOrig := s
+		var b []byte
+		s = s[1:]
+		for !strings.HasPrefix(s, "'") {
+			ch, _, tail, err := strconv.UnquoteChar(s, '\'')
+			if err != nil {
+				return "", -1
+			}
+			b = utf8.AppendRune(b, ch)
+			s = tail
+		}
+		return string(b), len(sOrig) - len(s) + 1
+	default:
 		return "", -1
 	}
-	return us, len(qp)
 }
 
 func parsePatternSteps(s string) ([]patternStep, error) {
diff --git a/lib/logstorage/pattern_matcher.go b/lib/logstorage/pattern_matcher.go
index 9fdfe26351..b0fb6cca21 100644
--- a/lib/logstorage/pattern_matcher.go
+++ b/lib/logstorage/pattern_matcher.go
@@ -1,6 +1,7 @@
 package logstorage
 
 import (
+	"strconv"
 	"strings"
 
 	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
@@ -34,6 +35,7 @@ const (
 	patternMatcherPlaceholderTime     = 4
 	patternMatcherPlaceholderDate     = 5
 	patternMatcherPlaceholderDateTime = 6
+	patternMatcherPlaceholderWord     = 7
 )
 
 func getPatternMatcherPlaceholder(s string) patternMatcherPlaceholder {
@@ -50,6 +52,8 @@ func getPatternMatcherPlaceholder(s string) patternMatcherPlaceholder {
 		return patternMatcherPlaceholderDate
 	case "<DATETIME>":
 		return patternMatcherPlaceholderDateTime
+	case "<W>":
+		return patternMatcherPlaceholderWord
 	default:
 		return patternMatcherPlaceholderUnknown
 	}
@@ -71,6 +75,8 @@ func (ph patternMatcherPlaceholder) String() string {
 		return "<DATE>"
 	case patternMatcherPlaceholderDateTime:
 		return "<DATETIME>"
+	case patternMatcherPlaceholderWord:
+		return "<W>"
 	default:
 		logger.Panicf("BUG: unexpected placeholder=%d", ph)
 		return ""
@@ -150,9 +156,15 @@ func (pm *patternMatcher) indexPatternStart(s string, offset int) int {
 	if firstSep := pm.separators[0]; firstSep != "" {
 		return strings.Index(s[offset:], firstSep)
 	}
-	if len(pm.placeholders) == 0 {
+
+	placeholders := pm.placeholders
+	if len(placeholders) == 0 {
 		return 0
 	}
+
+	if placeholders[0] == patternMatcherPlaceholderWord {
+		return indexWordStart(s, offset)
+	}
 	return indexNumStart(s, offset)
 }
 
@@ -194,6 +206,8 @@ func (ph patternMatcherPlaceholder) indexEnd(s string, start int) int {
 		return indexPlaceholderDateEnd(s, start)
 	case patternMatcherPlaceholderDateTime:
 		return indexPlaceholderDateTimeEnd(s, start)
+	case patternMatcherPlaceholderWord:
+		return indexPlaceholderWordEnd(s, start)
 	default:
 		logger.Panicf("BUG: unexpected patternMatcherPlaceholder=%d", ph)
 		return -1
@@ -278,6 +292,59 @@ func indexPlaceholderDateTimeEnd(s string, start int) int {
 	return end
 }
 
+func indexPlaceholderWordEnd(s string, start int) int {
+	// <W> is a word or a quoted string
+	if start >= len(s) {
+		return -1
+	}
+	if s[start] == '"' || s[start] == '\'' || s[start] == '`' {
+		return indexQuotedStringEnd(s, start)
+	}
+	return indexWordEnd(s, start)
+}
+
+func indexWordEnd(s string, start int) int {
+	for off, r := range s[start:] {
+		if !isTokenRune(r) {
+			return start + off
+		}
+	}
+	return len(s)
+}
+
+func indexWordStart(s string, offset int) int {
+	for off, r := range s[offset:] {
+		if isTokenRune(r) {
+			return offset + off
+		}
+	}
+	return -1
+}
+
+func indexQuotedStringEnd(s string, start int) int {
+	switch s[start] {
+	case '"', '`':
+		qp, err := strconv.QuotedPrefix(s[start:])
+		if err != nil {
+			return -1
+		}
+		return start + len(qp)
+	case '\'':
+		end := start + 1
+		for !strings.HasPrefix(s[end:], "'") {
+			_, _, tail, err := strconv.UnquoteChar(s[end:], '\'')
+			if err != nil {
+				return -1
+			}
+			end = len(s) - len(tail)
+		}
+		return end + 1
+	default:
+		logger.Panicf("BUG: unexpected starting char for quoted string: %c", s[start])
+		return -1
+	}
+}
+
 func indexTimezoneEnd(s string, start int) int {
 	// Timezone is <N>:<N>
 	return indexGenericPlaceholderEnd(s, start, 2, ':')
diff --git a/lib/logstorage/pattern_matcher_test.go b/lib/logstorage/pattern_matcher_test.go
index 54911e9a51..582131b7a2 100644
--- a/lib/logstorage/pattern_matcher_test.go
+++ b/lib/logstorage/pattern_matcher_test.go
@@ -29,13 +29,14 @@ func TestNewPatternMatcher(t *testing.T) {
 	f("<N>", []string{"", ""}, []patternMatcherPlaceholder{patternMatcherPlaceholderNum})
 	f("foo<N>", []string{"foo", ""}, []patternMatcherPlaceholder{patternMatcherPlaceholderNum})
 	f("<N>foo", []string{"", "foo"}, []patternMatcherPlaceholder{patternMatcherPlaceholderNum})
-	f("<N><UUID>foo<IP4><TIME>bar<DATETIME><DATE>", []string{"", "", "foo", "", "bar", "", ""}, []patternMatcherPlaceholder{
+	f("<N><UUID>foo<IP4><TIME>bar<DATETIME><DATE><W>", []string{"", "", "foo", "", "bar", "", "", ""}, []patternMatcherPlaceholder{
 		patternMatcherPlaceholderNum,
 		patternMatcherPlaceholderUUID,
 		patternMatcherPlaceholderIP4,
 		patternMatcherPlaceholderTime,
 		patternMatcherPlaceholderDateTime,
 		patternMatcherPlaceholderDate,
+		patternMatcherPlaceholderWord,
 	})
 
 	// unknown placeholders
@@ -91,12 +92,12 @@ func TestPatternMatcherMatch(t *testing.T) {
 	f("<N> <DATE> foo", "123 456 foo", false, false)
 
 	// verify all the placeholders
-	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, end",
-		"n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, end", false, true)
-	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, end",
-		"n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, end", true, true)
-	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, end",
-		"some 123 prefix 10:20:30, n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, end", false, true)
+	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, user: <W>, end",
+		"n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, user: '`\"\\', end', end", false, true)
+	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, user: <W>, end",
+		"n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, user: `f\"'oo`, end", true, true)
+	f("n: <N>.<N>, uuid: <UUID>, ip4: <IP4>, time: <TIME>, date: <DATE>, datetime: <DATETIME>, user: <W>, end",
+		"some 123 prefix 10:20:30, n: 123.324, uuid: 2edfed59-3e98-4073-bbb2-28d321ca71a7, ip4: 123.45.67.89, time: 10:20:30, date: 2025-10-20, datetime: 2025-10-20T10:20:30Z, user: \"f\\\"o'\", end", false, true)
 
 	// verify different cases for DATE
 	f("<DATE>, <DATE>", "foo 2025/10/20, 2025-10-20 bar", false, true)
@@ -107,4 +108,16 @@ func TestPatternMatcherMatch(t *testing.T) {
 
 	// verify different cases for DATETIME
 	f("<DATETIME>, <DATETIME>, <DATETIME>, <DATETIME>", "foo 2025-09-20T10:20:30Z, 2025/10/20 10:20:30.2343, 2025-10-20T30:40:50-05:10, 2025-10-20T30:40:50.1324+05:00 bar", false, true)
+
+	// verify different cases for W
+	f("email: <W>@<W>", "email: foo@bar.com", false, true)
+	f("email: <W>@<W>", "email: foo@bar.com", true, false)
+	f("email: <W>@<W>.<W>", "email: foo@bar.com", true, true)
+	f("email: <W>@<W>", "a email: foo@bar.com", true, false)
+	f("<W> foo", " foo", false, false)
+	f("<W> foo", ",,, foo", false, false)
+	f("<W> foo", ",,,abc foo", false, true)
+
+	f(`"foo":<W>`, `{"foo":"bar", "baz": 123}`, false, true)
+	f(`"foo":<W>`, `{"foo":"bar", "baz": 123}`, true, false)
 }
diff --git a/lib/logstorage/pattern_test.go b/lib/logstorage/pattern_test.go
index 626dda7433..1421936049 100644
--- a/lib/logstorage/pattern_test.go
+++ b/lib/logstorage/pattern_test.go
@@ -61,6 +61,7 @@ func TestPatternApply(t *testing.T) {
 	f(`"msg":<msg>,`, `{"foo":"bar","msg":"foo,b\"ar\n\t","baz":"x"}`, []string{`foo,b"ar` + "\n\t"})
 	f(`foo=<bar>`, "foo=`bar baz,abc` def", []string{"bar baz,abc"})
 	f(`foo=<bar> `, "foo=`bar baz,abc` def", []string{"bar baz,abc"})
+	f(`foo=<bar> `, "foo='bar baz,abc' def", []string{"bar baz,abc"})
 	f(`<foo>`, `"foo,\"bar"`, []string{`foo,"bar`})
 	f(`<foo>,"bar`, `"foo,\"bar"`, []string{`foo,"bar`})
 
diff --git a/lib/logstorage/pipe.go b/lib/logstorage/pipe.go
index 3aec9a69ab..2a4b4cb7a5 100644
--- a/lib/logstorage/pipe.go
+++ b/lib/logstorage/pipe.go
@@ -88,17 +88,26 @@ type pipeProcessor interface {
 	flush() error
 }
 
-type noopPipeProcessor func(workerID uint, br *blockResult)
+type noopPipeProcessor struct {
+	stopCh          <-chan struct{}
+	writeBlockFinal func(workerID uint, br *blockResult)
+}
 
-func newNoopPipeProcessor(writeBlock func(workerID uint, br *blockResult)) pipeProcessor {
-	return noopPipeProcessor(writeBlock)
+func newNoopPipeProcessor(stopCh <-chan struct{}, writeBlock func(workerID uint, br *blockResult)) pipeProcessor {
+	return &noopPipeProcessor{
+		stopCh:          stopCh,
+		writeBlockFinal: writeBlock,
+	}
 }
 
-func (npp noopPipeProcessor) writeBlock(workerID uint, br *blockResult) {
-	npp(workerID, br)
+func (npp *noopPipeProcessor) writeBlock(workerID uint, br *blockResult) {
+	if needStop(npp.stopCh) {
+		return
+	}
+	npp.writeBlockFinal(workerID, br)
 }
 
-func (npp noopPipeProcessor) flush() error {
+func (npp *noopPipeProcessor) flush() error {
 	logger.Panicf("BUG: mustn't be called!")
 	return nil
 }
diff --git a/lib/logstorage/pipe_collapse_nums.go b/lib/logstorage/pipe_collapse_nums.go
index b10e0a0740..59e451f7b0 100644
--- a/lib/logstorage/pipe_collapse_nums.go
+++ b/lib/logstorage/pipe_collapse_nums.go
@@ -147,7 +147,7 @@ func appendCollapseNums(dst []byte, s string) []byte {
 
 func indexNumStart(s string, offset int) int {
 	// It is safe iterating by chars instead of Unicode runes, since decimal and hex chars are ASCII
-	// and they cannot clash with utf-8 encoded Unicde runes.
+	// and they cannot clash with utf-8 encoded Unicode runes.
 	n := offset
 	for n < len(s) {
 		if !isDecimalOrHexChar(s[n]) {
@@ -167,7 +167,7 @@ func indexNumStart(s string, offset int) int {
 
 func indexNumEnd(s string, offset int) int {
 	// It is safe iterating by chars instead of Unicode runes, since decimal and hex chars are ASCII
-	// and they cannot clash with utf-8 encoded Unicde runes.
+	// and they cannot clash with utf-8 encoded Unicode runes.
 	n := offset
 	for n < len(s) && isDecimalOrHexChar(s[n]) {
 		n++
diff --git a/lib/logstorage/pipe_facets.go b/lib/logstorage/pipe_facets.go
index d35a4dcfc1..99c0e677da 100644
--- a/lib/logstorage/pipe_facets.go
+++ b/lib/logstorage/pipe_facets.go
@@ -63,7 +63,11 @@ func (pf *pipeFacets) splitToRemoteAndLocal(timestamp int64) (pipe, []pipe) {
 	pRemote := *pf
 	pRemote.limit = math.MaxUint64
 
-	psLocalStr := fmt.Sprintf("stats by (field_name, field_value) sum(hits) as hits | sort by (hits desc) limit %d partition by (field_name) | sort by (field_name, hits desc)", pf.limit)
+	psLocalStr := fmt.Sprintf(`stats by (field_name, field_value) sum(hits) as hits
+	        | total_stats by (field_name) count() as field_values_count
+		| filter field_values_count:<=%d
+		| sort by (hits desc) limit %d partition by (field_name)
+		| sort by (field_name, hits desc)`, pf.maxValuesPerField, pf.limit)
 	psLocal := mustParsePipes(psLocalStr, timestamp)
 
 	return &pRemote, psLocal
@@ -351,6 +355,7 @@ func (pfp *pipeFacetsProcessor) flush() error {
 		return nil
 	}
 
+	ignoreFields := make(map[string]bool)
 	hmasByFieldName := make(map[string][]*hitsMapAdaptive)
 	rowsTotal := uint64(0)
 	for _, shard := range shards {
@@ -358,7 +363,12 @@ func (pfp *pipeFacetsProcessor) flush() error {
 			return nil
 		}
 		for fieldName, fhs := range shard.m {
+			if ignoreFields[fieldName] {
+				continue
+			}
 			if fhs.mustIgnore {
+				ignoreFields[fieldName] = true
+				delete(hmasByFieldName, fieldName)
 				continue
 			}
 			hmasByFieldName[fieldName] = append(hmasByFieldName[fieldName], &fhs.m)
diff --git a/lib/logstorage/pipe_facets_test.go b/lib/logstorage/pipe_facets_test.go
index 2be6daae16..b5f2a85e12 100644
--- a/lib/logstorage/pipe_facets_test.go
+++ b/lib/logstorage/pipe_facets_test.go
@@ -68,6 +68,28 @@ func TestPipeFacets(t *testing.T) {
 		},
 	})
 
+	f("facets max_values_per_field 2", [][]Field{
+		{
+			{"a", `2`},
+			{"b", `asd54`},
+		},
+		{
+			{"a", "2"},
+			{"b", "3"},
+		},
+		{
+			{"a", `2`},
+			{"b", `54`},
+			{"c", "d"},
+		},
+	}, [][]Field{
+		{
+			{"field_name", "c"},
+			{"field_value", "d"},
+			{"hits", "1"},
+		},
+	})
+
 	f("facets 1 keep_const_fields", [][]Field{
 		{
 			{"a", `2`},
diff --git a/lib/logstorage/pipe_filter.go b/lib/logstorage/pipe_filter.go
index 27f4e69b3e..52c35cb18d 100644
--- a/lib/logstorage/pipe_filter.go
+++ b/lib/logstorage/pipe_filter.go
@@ -120,7 +120,7 @@ func parsePipeFilterExt(lex *lexer, needFilterKeyword bool) (pipe, error) {
 		lex.nextToken()
 	}
 
-	f, err := parseFilter(lex)
+	f, err := parseFilter(lex, needFilterKeyword)
 	if err != nil {
 		return nil, fmt.Errorf("cannot parse 'filter': %w", err)
 	}
diff --git a/lib/logstorage/pipe_offset.go b/lib/logstorage/pipe_offset.go
index fa20e14cf1..1e3742d019 100644
--- a/lib/logstorage/pipe_offset.go
+++ b/lib/logstorage/pipe_offset.go
@@ -19,6 +19,10 @@ func (po *pipeOffset) String() string {
 }
 
 func (po *pipeOffset) splitToRemoteAndLocal(_ int64) (pipe, []pipe) {
+	if po.offset == 0 {
+		// Special case - `offset 0` is safe to push to the remote side.
+		return po, nil
+	}
 	return nil, []pipe{po}
 }
 
diff --git a/lib/logstorage/pipe_stream_context.go b/lib/logstorage/pipe_stream_context.go
index 2bdec0bc52..bc2426f788 100644
--- a/lib/logstorage/pipe_stream_context.go
+++ b/lib/logstorage/pipe_stream_context.go
@@ -34,8 +34,8 @@ type pipeStreamContext struct {
 	// timeWindow is the time window in nanoseconds for searching for surrounding logs
 	timeWindow int64
 
-	// qs, runQuery and fieldsFilter must be initialized via withRunQuery().
-	qs           *QueryStats
+	// qctx, runQuery and fieldsFilter must be initialized via withRunQuery().
+	qctx         *QueryContext
 	runQuery     runQueryFunc
 	fieldsFilter *prefixfilter.Filter
 }
@@ -69,9 +69,9 @@ func (pc *pipeStreamContext) canReturnLastNResults() bool {
 	return false
 }
 
-func (pc *pipeStreamContext) withRunQuery(qs *QueryStats, runQuery runQueryFunc, fieldsFilter *prefixfilter.Filter) pipe {
+func (pc *pipeStreamContext) withRunQuery(qctx *QueryContext, runQuery runQueryFunc, fieldsFilter *prefixfilter.Filter) pipe {
 	pcNew := *pc
-	pcNew.qs = qs
+	pcNew.qctx = qctx
 	pcNew.runQuery = runQuery
 	pcNew.fieldsFilter = fieldsFilter
 	return &pcNew
@@ -322,7 +322,7 @@ func (pcp *pipeStreamContextProcessor) executeQuery(streamID, qStr string, neede
 	if !ok {
 		logger.Panicf("BUG: cannot obtain tenantID from streamID %q", streamID)
 	}
-	qctx := NewQueryContext(ctxWithCancel, pcp.pc.qs, []TenantID{tenantID}, q)
+	qctx := NewQueryContext(ctxWithCancel, pcp.pc.qctx.QueryStats, []TenantID{tenantID}, q, pcp.pc.qctx.AllowPartialResponse)
 	if err := pcp.pc.runQuery(qctx, writeBlock); err != nil {
 		return nil, 0, err
 	}
diff --git a/lib/logstorage/pipe_unpack.go b/lib/logstorage/pipe_unpack.go
index 2d636f01b9..9bf6a1753d 100644
--- a/lib/logstorage/pipe_unpack.go
+++ b/lib/logstorage/pipe_unpack.go
@@ -7,7 +7,7 @@ import (
 	"github.com/VictoriaMetrics/VictoriaLogs/lib/prefixfilter"
 )
 
-func updateNeededFieldsForUnpackPipe(fromField string, outFieldFilters []string, keepOriginalFields, skipEmptyResults bool, iff *ifFilter, pf *prefixfilter.Filter) {
+func updateNeededFieldsForUnpackPipe(fromField, outFieldPrefix string, outFieldFilters []string, keepOriginalFields, skipEmptyResults bool, iff *ifFilter, pf *prefixfilter.Filter) {
 	if pf.MatchNothing() {
 		if iff != nil {
 			pf.AddAllowFilters(iff.allowFilters)
@@ -17,7 +17,7 @@ func updateNeededFieldsForUnpackPipe(fromField string, outFieldFilters []string,
 
 	needFromField := len(outFieldFilters) == 0
 	for _, f := range outFieldFilters {
-		if pf.MatchStringOrWildcard(f) {
+		if pf.MatchStringOrWildcard(outFieldPrefix + f) {
 			needFromField = true
 			break
 		}
@@ -25,7 +25,7 @@ func updateNeededFieldsForUnpackPipe(fromField string, outFieldFilters []string,
 	if !keepOriginalFields && !skipEmptyResults {
 		for _, f := range outFieldFilters {
 			if !prefixfilter.IsWildcardFilter(f) {
-				pf.AddDenyFilter(f)
+				pf.AddDenyFilter(outFieldPrefix + f)
 			}
 		}
 	}
diff --git a/lib/logstorage/pipe_unpack_json.go b/lib/logstorage/pipe_unpack_json.go
index 1f59d72f5a..3eca50b2ca 100644
--- a/lib/logstorage/pipe_unpack_json.go
+++ b/lib/logstorage/pipe_unpack_json.go
@@ -67,7 +67,7 @@ func (pu *pipeUnpackJSON) canReturnLastNResults() bool {
 }
 
 func (pu *pipeUnpackJSON) updateNeededFields(pf *prefixfilter.Filter) {
-	updateNeededFieldsForUnpackPipe(pu.fromField, pu.fieldFilters, pu.keepOriginalFields, pu.skipEmptyResults, pu.iff, pf)
+	updateNeededFieldsForUnpackPipe(pu.fromField, pu.resultPrefix, pu.fieldFilters, pu.keepOriginalFields, pu.skipEmptyResults, pu.iff, pf)
 }
 
 func (pu *pipeUnpackJSON) hasFilterInWithQuery() bool {
diff --git a/lib/logstorage/pipe_unpack_json_test.go b/lib/logstorage/pipe_unpack_json_test.go
index ef25a80051..401b38ca57 100644
--- a/lib/logstorage/pipe_unpack_json_test.go
+++ b/lib/logstorage/pipe_unpack_json_test.go
@@ -387,4 +387,12 @@ func TestPipeUnpackJSONUpdateNeededFields(t *testing.T) {
 	f("unpack_json if (y:z) from x fields (x)", "f2,x", "", "f2,x,y", "")
 	f("unpack_json if (y:z) from x fields (x) skip_empty_results", "f2,x", "", "f2,x,y", "")
 	f("unpack_json if (y:z) from x fields (x) keep_original_fields", "f2,x", "", "f2,x,y", "")
+
+	// query contains 'result_prefix'
+	f("unpack_json from x result_prefix foo_", "y", "", "y", "")
+	f("unpack_json from x result_prefix foo_", "foo*", "", "foo*,x", "")
+	f("unpack_json from x fields (f1,f2) result_prefix foo_", "*", "", "*", "foo_f1,foo_f2")
+	f("unpack_json from x fields (f1) result_prefix foo_ keep_original_fields", "*", "", "*", "")
+	f("unpack_json from x fields (f1) result_prefix foo_ skip_empty_results", "*", "", "*", "")
+	f("unpack_json if (y:z) from x fields (f1) result_prefix foo_", "*", "", "*", "foo_f1")
 }
diff --git a/lib/logstorage/pipe_unpack_logfmt.go b/lib/logstorage/pipe_unpack_logfmt.go
index 2ee5fe62b6..ba59ed880c 100644
--- a/lib/logstorage/pipe_unpack_logfmt.go
+++ b/lib/logstorage/pipe_unpack_logfmt.go
@@ -64,7 +64,7 @@ func (pu *pipeUnpackLogfmt) canReturnLastNResults() bool {
 }
 
 func (pu *pipeUnpackLogfmt) updateNeededFields(pf *prefixfilter.Filter) {
-	updateNeededFieldsForUnpackPipe(pu.fromField, pu.fieldFilters, pu.keepOriginalFields, pu.skipEmptyResults, pu.iff, pf)
+	updateNeededFieldsForUnpackPipe(pu.fromField, pu.resultPrefix, pu.fieldFilters, pu.keepOriginalFields, pu.skipEmptyResults, pu.iff, pf)
 }
 
 func (pu *pipeUnpackLogfmt) hasFilterInWithQuery() bool {
diff --git a/lib/logstorage/pipe_unpack_logfmt_test.go b/lib/logstorage/pipe_unpack_logfmt_test.go
index 4a56468f17..1267a64bbc 100644
--- a/lib/logstorage/pipe_unpack_logfmt_test.go
+++ b/lib/logstorage/pipe_unpack_logfmt_test.go
@@ -324,4 +324,10 @@ func TestPipeUnpackLogfmtUpdateNeededFields(t *testing.T) {
 	f("unpack_logfmt from x", "f*,x*", "", "f*,x*", "")
 	f("unpack_logfmt if (y:z) from x", "f2,x", "", "f2,x,y", "")
 	f("unpack_logfmt if (f2:z y:qwe) from x", "f2,x", "", "f2,x,y", "")
+
+	// query contains 'result_prefix'
+	f("unpack_logfmt from x result_prefix foo_", "foo*", "", "foo*,x", "")
+	f("unpack_logfmt from x fields (f1,f2) result_prefix foo_", "*", "", "*", "foo_f1,foo_f2")
+	f("unpack_logfmt from x fields (f1) result_prefix foo_ keep_original_fields", "*", "", "*", "")
+	f("unpack_logfmt from x fields (f1) result_prefix foo_ skip_empty_results", "*", "", "*", "")
 }
diff --git a/lib/logstorage/pipe_unpack_syslog.go b/lib/logstorage/pipe_unpack_syslog.go
index 7709b0fd84..7e1fc95a99 100644
--- a/lib/logstorage/pipe_unpack_syslog.go
+++ b/lib/logstorage/pipe_unpack_syslog.go
@@ -61,7 +61,7 @@ func (pu *pipeUnpackSyslog) canReturnLastNResults() bool {
 }
 
 func (pu *pipeUnpackSyslog) updateNeededFields(pf *prefixfilter.Filter) {
-	updateNeededFieldsForUnpackPipe(pu.fromField, nil, pu.keepOriginalFields, false, pu.iff, pf)
+	updateNeededFieldsForUnpackPipe(pu.fromField, pu.resultPrefix, nil, pu.keepOriginalFields, false, pu.iff, pf)
 }
 
 func (pu *pipeUnpackSyslog) hasFilterInWithQuery() bool {
diff --git a/lib/logstorage/pipe_unpack_syslog_test.go b/lib/logstorage/pipe_unpack_syslog_test.go
index fe2ba2480a..3c31e3a845 100644
--- a/lib/logstorage/pipe_unpack_syslog_test.go
+++ b/lib/logstorage/pipe_unpack_syslog_test.go
@@ -288,4 +288,9 @@ func TestPipeUnpackSyslogUpdateNeededFields(t *testing.T) {
 	f("unpack_syslog from x", "f2,x", "", "f2,x", "")
 	f("unpack_syslog if (y:z) from x", "f2,x", "", "f2,x,y", "")
 	f("unpack_syslog if (f2:z y:qwe) from x", "f2,x", "", "f2,x,y", "")
+
+	// query contains 'result_prefix'
+	f("unpack_syslog from x result_prefix foo_", "*", "", "*", "")
+	f("unpack_syslog from x result_prefix foo_ keep_original_fields", "*", "", "*", "")
+	f("unpack_syslog if (y:z) from x result_prefix foo_", "*", "", "*", "")
 }
diff --git a/lib/logstorage/stats_count_uniq.go b/lib/logstorage/stats_count_uniq.go
index 28f4cf86a7..f2c0e2ebb5 100644
--- a/lib/logstorage/stats_count_uniq.go
+++ b/lib/logstorage/stats_count_uniq.go
@@ -638,10 +638,6 @@ func (sup *statsCountUniqProcessor) importState(src []byte, stopCh <-chan struct
 		return stateSize, nil
 	}
 
-	if shardsLen != uint64(sup.concurrency) {
-		return 0, fmt.Errorf("unexpected number of imported shards: %d; want %d", shardsLen, sup.concurrency)
-	}
-
 	shards := make([]statsCountUniqSet, shardsLen)
 	stateSizeIncrease := int(unsafe.Sizeof(shards[0])) * len(shards)
 	for i := range shards {
@@ -656,11 +652,46 @@ func (sup *statsCountUniqProcessor) importState(src []byte, stopCh <-chan struct
 	if len(src) > 0 {
 		return 0, fmt.Errorf("unexpected tail left after importing shards' state; len(tail)=%d", len(src))
 	}
-	sup.shards = shards
+
+	stateSizeIncrease = sup.importShards(shards, stateSizeIncrease)
 
 	return stateSizeIncrease, nil
 }
 
+func (sup *statsCountUniqProcessor) importShards(shards []statsCountUniqSet, stateSizeIncrease int) int {
+	if uint(len(shards)) == sup.concurrency {
+		// Fast path - nothing to reshard
+		sup.shards = shards
+		return stateSizeIncrease
+	}
+
+	// Slow path - reshard shards in order to align len(shards) with sup.concurrency.
+	// This case is possible when the remote side has different concurrency than the sup.concurrency.
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/682
+	stateSizeIncrease = 0
+	for i := range shards {
+		stateSizeIncrease += sup.importShard(&shards[i])
+	}
+	return stateSizeIncrease
+}
+
+func (sup *statsCountUniqProcessor) importShard(shard *statsCountUniqSet) int {
+	stateSizeIncrease := 0
+	for ts := range shard.timestamps {
+		stateSizeIncrease += sup.updateStateTimestamp(int64(ts))
+	}
+	for n := range shard.u64 {
+		stateSizeIncrease += sup.updateStateUint64(n)
+	}
+	for n := range shard.negative64 {
+		stateSizeIncrease += sup.updateStateNegativeInt64(int64(n))
+	}
+	for s := range shard.strings {
+		stateSizeIncrease += sup.updateStateString(bytesutil.ToUnsafeBytes(s))
+	}
+	return stateSizeIncrease
+}
+
 func (sup *statsCountUniqProcessor) finalizeStats(sf statsFunc, dst []byte, stopCh <-chan struct{}) []byte {
 	sup.mergeShardssParallel(stopCh)
 
diff --git a/lib/logstorage/stats_count_uniq_hash.go b/lib/logstorage/stats_count_uniq_hash.go
index 6c739de694..a985e1a56d 100644
--- a/lib/logstorage/stats_count_uniq_hash.go
+++ b/lib/logstorage/stats_count_uniq_hash.go
@@ -466,10 +466,6 @@ func (sup *statsCountUniqHashProcessor) importState(src []byte, stopCh <-chan st
 		return stateSize, nil
 	}
 
-	if shardsLen != uint64(sup.concurrency) {
-		return 0, fmt.Errorf("unexpected number of imported shards: %d; want %d", shardsLen, sup.concurrency)
-	}
-
 	shards := make([]statsCountUniqHashSet, shardsLen)
 	stateSizeIncrease := int(unsafe.Sizeof(shards[0])) * len(shards)
 	for i := range shards {
@@ -484,11 +480,46 @@ func (sup *statsCountUniqHashProcessor) importState(src []byte, stopCh <-chan st
 	if len(src) > 0 {
 		return 0, fmt.Errorf("unexpected tail left after importing shards' state; len(tail)=%d", len(src))
 	}
-	sup.shards = shards
+
+	stateSizeIncrease = sup.importShards(shards, stateSizeIncrease)
 
 	return stateSizeIncrease, nil
 }
 
+func (sup *statsCountUniqHashProcessor) importShards(shards []statsCountUniqHashSet, stateSizeIncrease int) int {
+	if uint(len(shards)) == sup.concurrency {
+		// Fast path - nothing to reshard
+		sup.shards = shards
+		return stateSizeIncrease
+	}
+
+	// Slow path - reshard shards in order to align len(shards) with sup.concurrency.
+	// This case is possible when the remote side has different concurrency than the sup.concurrency.
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/682
+	stateSizeIncrease = 0
+	for i := range shards {
+		stateSizeIncrease += sup.importShard(&shards[i])
+	}
+	return stateSizeIncrease
+}
+
+func (sup *statsCountUniqHashProcessor) importShard(shard *statsCountUniqHashSet) int {
+	stateSizeIncrease := 0
+	for ts := range shard.timestamps {
+		stateSizeIncrease += sup.updateStateTimestamp(int64(ts))
+	}
+	for n := range shard.u64 {
+		stateSizeIncrease += sup.updateStateUint64(n)
+	}
+	for n := range shard.negative64 {
+		stateSizeIncrease += sup.updateStateNegativeInt64(int64(n))
+	}
+	for h := range shard.strings {
+		stateSizeIncrease += sup.updateStateStringHash(h)
+	}
+	return stateSizeIncrease
+}
+
 func (sup *statsCountUniqHashProcessor) finalizeStats(sf statsFunc, dst []byte, stopCh <-chan struct{}) []byte {
 	sup.mergeShardssParallel(stopCh)
 
@@ -567,6 +598,10 @@ func (sup *statsCountUniqHashProcessor) updateStateInt64(n int64) int {
 
 func (sup *statsCountUniqHashProcessor) updateStateString(v []byte) int {
 	h := xxhash.Sum64(v)
+	return sup.updateStateStringHash(h)
+}
+
+func (sup *statsCountUniqHashProcessor) updateStateStringHash(h uint64) int {
 	if sup.shards == nil {
 		stateSizeIncrease := sup.uniqValues.updateStateStringHash(h)
 		if stateSizeIncrease > 0 {
@@ -574,10 +609,6 @@ func (sup *statsCountUniqHashProcessor) updateStateString(v []byte) int {
 		}
 		return stateSizeIncrease
 	}
-	return sup.updateStateStringHash(h)
-}
-
-func (sup *statsCountUniqHashProcessor) updateStateStringHash(h uint64) int {
 	sus := sup.getShardByStringHash(h)
 	return sus.updateStateStringHash(h)
 }
diff --git a/lib/logstorage/stats_count_uniq_hash_test.go b/lib/logstorage/stats_count_uniq_hash_test.go
index 2e1da9354b..762502a9ff 100644
--- a/lib/logstorage/stats_count_uniq_hash_test.go
+++ b/lib/logstorage/stats_count_uniq_hash_test.go
@@ -513,3 +513,65 @@ func TestStatsCountUniqHash_ExportImportState(t *testing.T) {
 	}
 	f(sup, 105, 12)
 }
+
+func TestStatsCountUniqHash_ExportImportState_DistinctConcurrency(t *testing.T) {
+	var a chunkedAllocator
+	newStatsCountUniqHashProcessor := func(concurrency uint) *statsCountUniqHashProcessor {
+		sup := a.newStatsCountUniqHashProcessor()
+		sup.a = &a
+		sup.concurrency = concurrency
+		return sup
+	}
+
+	f := func(remoteConcurrency, localConcurrency uint) {
+		t.Helper()
+
+		supRemote := newStatsCountUniqHashProcessor(remoteConcurrency)
+		supLocal := newStatsCountUniqHashProcessor(localConcurrency)
+
+		supRemote.shards = []statsCountUniqHashSet{
+			{
+				timestamps: map[uint64]struct{}{
+					123: {},
+					0:   {},
+				},
+				u64: map[uint64]struct{}{
+					43: {},
+				},
+				negative64: map[uint64]struct{}{
+					8234932: {},
+				},
+				strings: map[uint64]struct{}{
+					8934:   {},
+					432443: {},
+				},
+			},
+			{
+				timestamps: map[uint64]struct{}{
+					10:      {},
+					1123:    {},
+					3234324: {},
+				},
+				u64: map[uint64]struct{}{
+					42: {},
+				},
+			},
+		}
+		remoteEntriesCount := supRemote.entriesCount()
+
+		data := supRemote.exportState(nil, nil)
+		_, err := supLocal.importState(data, nil)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+
+		localEntriesCount := supLocal.entriesCount()
+		if localEntriesCount != remoteEntriesCount {
+			t.Fatalf("unexpected number of entries; got %d; want %d", localEntriesCount, remoteEntriesCount)
+		}
+	}
+
+	f(2, 3)
+	f(2, 1)
+	f(2, 100)
+}
diff --git a/lib/logstorage/stats_count_uniq_test.go b/lib/logstorage/stats_count_uniq_test.go
index c52ad6ddbc..045fc0d9c5 100644
--- a/lib/logstorage/stats_count_uniq_test.go
+++ b/lib/logstorage/stats_count_uniq_test.go
@@ -542,3 +542,65 @@ func TestStatsCountUniq_ExportImportState(t *testing.T) {
 	}
 	f(sup, 42, 7)
 }
+
+func TestStatsCountUniq_ExportImportState_DistinctConcurrency(t *testing.T) {
+	var a chunkedAllocator
+	newStatsCountUniqProcessor := func(concurrency uint) *statsCountUniqProcessor {
+		sup := a.newStatsCountUniqProcessor()
+		sup.a = &a
+		sup.concurrency = concurrency
+		return sup
+	}
+
+	f := func(remoteConcurrency, localConcurrency uint) {
+		t.Helper()
+
+		supRemote := newStatsCountUniqProcessor(remoteConcurrency)
+		supLocal := newStatsCountUniqProcessor(localConcurrency)
+
+		supRemote.shards = []statsCountUniqSet{
+			{
+				timestamps: map[uint64]struct{}{
+					123: {},
+					0:   {},
+				},
+				u64: map[uint64]struct{}{
+					43: {},
+				},
+				negative64: map[uint64]struct{}{
+					8234932: {},
+				},
+				strings: map[string]struct{}{
+					"foo": {},
+					"bar": {},
+				},
+			},
+			{
+				timestamps: map[uint64]struct{}{
+					10:      {},
+					1123:    {},
+					3234324: {},
+				},
+				u64: map[uint64]struct{}{
+					42: {},
+				},
+			},
+		}
+		remoteEntriesCount := supRemote.entriesCount()
+
+		data := supRemote.exportState(nil, nil)
+		_, err := supLocal.importState(data, nil)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+
+		localEntriesCount := supLocal.entriesCount()
+		if localEntriesCount != remoteEntriesCount {
+			t.Fatalf("unexpected number of entries; got %d; want %d", localEntriesCount, remoteEntriesCount)
+		}
+	}
+
+	f(2, 3)
+	f(2, 1)
+	f(2, 100)
+}
diff --git a/lib/logstorage/storage.go b/lib/logstorage/storage.go
index bfd9561925..b1d7aa1cd9 100644
--- a/lib/logstorage/storage.go
+++ b/lib/logstorage/storage.go
@@ -51,6 +51,11 @@ type StorageConfig struct {
 	// Older data is automatically deleted.
 	Retention time.Duration
 
+	// DefaultParallelReaders is the default number of parallel readers to use per each query execution.
+	//
+	// Higher value can help improving query performance on storage with high disk read latency such as S3.
+	DefaultParallelReaders int
+
 	// MaxDiskSpaceUsageBytes is an optional maximum disk space logs can use.
 	//
 	// The oldest per-day partitions are automatically dropped if the total disk space usage exceeds this limit.
@@ -97,6 +102,11 @@ type Storage struct {
 	// older data is automatically deleted
 	retention time.Duration
 
+	// defaultParallelReaders is the default number of parallel IO-bound readers to use for query execution.
+	//
+	// Higher number of readers may help increasing query performance on storage with high read latency such as S3.
+	defaultParallelReaders int
+
 	// maxDiskSpaceUsageBytes is an optional maximum disk space logs can use.
 	//
 	// The oldest per-day partitions are automatically dropped if the total disk space usage exceeds this limit.
@@ -444,6 +454,7 @@ func MustOpenStorage(path string, cfg *StorageConfig) *Storage {
 	s := &Storage{
 		path:                   path,
 		retention:              retention,
+		defaultParallelReaders: cfg.DefaultParallelReaders,
 		maxDiskSpaceUsageBytes: cfg.MaxDiskSpaceUsageBytes,
 		maxDiskUsagePercent:    cfg.MaxDiskUsagePercent,
 		flushInterval:          flushInterval,
diff --git a/lib/logstorage/storage_search.go b/lib/logstorage/storage_search.go
index 75f4c3954f..d171e5d1ad 100644
--- a/lib/logstorage/storage_search.go
+++ b/lib/logstorage/storage_search.go
@@ -34,6 +34,9 @@ type QueryContext struct {
 	// Query is the query to execute.
 	Query *Query
 
+	// AllowPartialResponse indicates whether to allow partial response. This flag is used only in cluster setup when vlselect queries vlstorage nodes.
+	AllowPartialResponse bool
+
 	// startTime is creation time for the QueryContext.
 	//
 	// It is used for calculating query druation.
@@ -41,24 +44,24 @@ type QueryContext struct {
 }
 
 // NewQueryContext returns new context for the given query.
-func NewQueryContext(ctx context.Context, qs *QueryStats, tenantIDs []TenantID, q *Query) *QueryContext {
+func NewQueryContext(ctx context.Context, qs *QueryStats, tenantIDs []TenantID, q *Query, allowPartialResponse bool) *QueryContext {
 	startTime := time.Now()
-	return newQueryContext(ctx, qs, tenantIDs, q, startTime)
+	return newQueryContext(ctx, qs, tenantIDs, q, allowPartialResponse, startTime)
 }
 
 // WithQuery returns new QueryContext with the given q, while preserving other fields from qctx.
 func (qctx *QueryContext) WithQuery(q *Query) *QueryContext {
-	return newQueryContext(qctx.Context, qctx.QueryStats, qctx.TenantIDs, q, qctx.startTime)
+	return newQueryContext(qctx.Context, qctx.QueryStats, qctx.TenantIDs, q, qctx.AllowPartialResponse, qctx.startTime)
 }
 
 // WithContext returns new QueryContext with the given ctx, while preserving other fields from qctx.
 func (qctx *QueryContext) WithContext(ctx context.Context) *QueryContext {
-	return newQueryContext(ctx, qctx.QueryStats, qctx.TenantIDs, qctx.Query, qctx.startTime)
+	return newQueryContext(ctx, qctx.QueryStats, qctx.TenantIDs, qctx.Query, qctx.AllowPartialResponse, qctx.startTime)
 }
 
 // WithContextAndQuery returns new QueryContext with the given ctx and q, while preserving other fields from qctx.
 func (qctx *QueryContext) WithContextAndQuery(ctx context.Context, q *Query) *QueryContext {
-	return newQueryContext(ctx, qctx.QueryStats, qctx.TenantIDs, q, qctx.startTime)
+	return newQueryContext(ctx, qctx.QueryStats, qctx.TenantIDs, q, qctx.AllowPartialResponse, qctx.startTime)
 }
 
 // QueryDurationNsecs returns the duration in nanoseconds since the NewQueryContext call.
@@ -66,13 +69,21 @@ func (qctx *QueryContext) QueryDurationNsecs() int64 {
 	return time.Since(qctx.startTime).Nanoseconds()
 }
 
-func newQueryContext(ctx context.Context, qs *QueryStats, tenantIDs []TenantID, q *Query, startTime time.Time) *QueryContext {
+func newQueryContext(ctx context.Context, qs *QueryStats, tenantIDs []TenantID, q *Query, allowPartialResponse bool, startTime time.Time) *QueryContext {
+	if q.opts.allowPartialResponse != nil {
+		// query options override other settings for allowPartialResponse.
+		allowPartialResponse = *q.opts.allowPartialResponse
+	}
+
 	return &QueryContext{
 		Context:    ctx,
 		QueryStats: qs,
 		TenantIDs:  tenantIDs,
 		Query:      q,
-		startTime:  startTime,
+
+		AllowPartialResponse: allowPartialResponse,
+
+		startTime: startTime,
 	}
 }
 
@@ -192,21 +203,22 @@ func (s *Storage) runQuery(qctx *QueryContext, writeBlock writeBlockResultFunc)
 		timeOffset:   -q.opts.timeOffset,
 	}
 
-	workersCount := q.GetConcurrency()
-
 	search := func(stopCh <-chan struct{}, writeBlockToPipes writeBlockResultFunc) error {
-		s.search(workersCount, so, qctx.QueryStats, stopCh, writeBlockToPipes)
+		workersCount := q.GetParallelReaders(s.defaultParallelReaders)
+		s.searchParallel(workersCount, so, qctx.QueryStats, stopCh, writeBlockToPipes)
 		return nil
 	}
 
-	return runPipes(qctx, q.pipes, search, writeBlock, workersCount)
+	concurrency := q.GetConcurrency()
+	return runPipes(qctx, q.pipes, search, writeBlock, concurrency)
 }
 
 // searchFunc must perform search and pass its results to writeBlock.
 type searchFunc func(stopCh <-chan struct{}, writeBlock writeBlockResultFunc) error
 
 func runPipes(qctx *QueryContext, pipes []pipe, search searchFunc, writeBlock writeBlockResultFunc, concurrency int) error {
-	ctx := qctx.Context
+	ctx, topCancel := context.WithCancel(qctx.Context)
+	defer topCancel()
 
 	stopCh := ctx.Done()
 	if len(pipes) == 0 {
@@ -214,7 +226,7 @@ func runPipes(qctx *QueryContext, pipes []pipe, search searchFunc, writeBlock wr
 		return search(stopCh, writeBlock)
 	}
 
-	pp := newNoopPipeProcessor(writeBlock)
+	pp := newNoopPipeProcessor(stopCh, writeBlock)
 	cancels := make([]func(), len(pipes))
 	pps := make([]pipeProcessor, len(pipes))
 
@@ -231,6 +243,10 @@ func runPipes(qctx *QueryContext, pipes []pipe, search searchFunc, writeBlock wr
 	}
 
 	errSearch := search(stopCh, pp.writeBlock)
+	if errSearch != nil {
+		// Cancel the whole query in order to free up resources occupied by pipes.
+		topCancel()
+	}
 
 	var errFlush error
 	for i, pp := range pps {
@@ -242,6 +258,9 @@ func runPipes(qctx *QueryContext, pipes []pipe, search searchFunc, writeBlock wr
 		}
 
 		if err := pp.flush(); err != nil && errFlush == nil {
+			// Cancel the whole query in order to free up resources occupied by the remaining pipes.
+			topCancel()
+
 			errFlush = err
 		}
 		cancel := cancels[i]
@@ -631,10 +650,10 @@ func initSubqueries(qctx *QueryContext, runQuery runQueryFunc, keepInSubquery bo
 	}
 	qNew = initUnionQueries(qNew, runUnionQuery)
 
-	return initStreamContextPipes(qctx.QueryStats, qNew, runQuery)
+	return initStreamContextPipes(qctx, qNew, runQuery)
 }
 
-func initStreamContextPipes(qs *QueryStats, q *Query, runQuery runQueryFunc) (*Query, error) {
+func initStreamContextPipes(qctx *QueryContext, q *Query, runQuery runQueryFunc) (*Query, error) {
 	pipes := q.pipes
 
 	if len(pipes) == 0 {
@@ -652,7 +671,7 @@ func initStreamContextPipes(qs *QueryStats, q *Query, runQuery runQueryFunc) (*Q
 		fieldsFilter := getNeededColumns(pipes)
 
 		pipesNew := append([]pipe{}, pipes...)
-		pipesNew[0] = pc.withRunQuery(qs, runQuery, fieldsFilter)
+		pipesNew[0] = pc.withRunQuery(qctx, runQuery, fieldsFilter)
 		qNew := q.cloneShallow()
 		qNew.pipes = pipesNew
 		return qNew, nil
@@ -1123,8 +1142,8 @@ func (db *DataBlock) initFromBlockResult(br *blockResult) {
 
 // search searches for the matching rows according to so.
 //
-// It calls writeBlock for each matching block.
-func (s *Storage) search(workersCount int, so *genericSearchOptions, qs *QueryStats, stopCh <-chan struct{}, writeBlock writeBlockResultFunc) {
+// It uses workersCount parallel workers for the search and calls writeBlock for each matching block.
+func (s *Storage) searchParallel(workersCount int, so *genericSearchOptions, qs *QueryStats, stopCh <-chan struct{}, writeBlock writeBlockResultFunc) {
 	// Spin up workers
 	var wgWorkers sync.WaitGroup
 	workCh := make(chan *blockSearchWorkBatch, workersCount)
diff --git a/lib/logstorage/storage_search_test.go b/lib/logstorage/storage_search_test.go
index 224d80e668..c2e5bbb4f2 100644
--- a/lib/logstorage/storage_search_test.go
+++ b/lib/logstorage/storage_search_test.go
@@ -1075,7 +1075,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, _ *blockResult) {
 			panic(fmt.Errorf("unexpected match"))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 	})
 	t.Run("missing-tenant-bigger-than-existing", func(_ *testing.T) {
 		tenantID := TenantID{
@@ -1090,7 +1090,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, _ *blockResult) {
 			panic(fmt.Errorf("unexpected match"))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 	})
 	t.Run("missing-tenant-middle", func(_ *testing.T) {
 		tenantID := TenantID{
@@ -1105,7 +1105,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, _ *blockResult) {
 			panic(fmt.Errorf("unexpected match"))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 	})
 	t.Run("matching-tenant-id", func(t *testing.T) {
 		for i := 0; i < tenantsCount; i++ {
@@ -1122,7 +1122,7 @@ func TestStorageSearch(t *testing.T) {
 			processBlock := func(_ uint, br *blockResult) {
 				rowsCountTotal.Add(uint32(br.rowsLen))
 			}
-			s.search(workersCount, so, qs, nil, processBlock)
+			s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 			expectedRowsCount := streamsPerTenant * blocksPerStream * rowsPerBlock
 			if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1140,7 +1140,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, br *blockResult) {
 			rowsCountTotal.Add(uint32(br.rowsLen))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 		expectedRowsCount := tenantsCount * streamsPerTenant * blocksPerStream * rowsPerBlock
 		if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1157,7 +1157,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, _ *blockResult) {
 			panic(fmt.Errorf("unexpected match"))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 	})
 	t.Run("matching-stream-id", func(t *testing.T) {
 		for i := 0; i < streamsPerTenant; i++ {
@@ -1175,7 +1175,7 @@ func TestStorageSearch(t *testing.T) {
 			processBlock := func(_ uint, br *blockResult) {
 				rowsCountTotal.Add(uint32(br.rowsLen))
 			}
-			s.search(workersCount, so, qs, nil, processBlock)
+			s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 			expectedRowsCount := blocksPerStream * rowsPerBlock
 			if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1198,7 +1198,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, br *blockResult) {
 			rowsCountTotal.Add(uint32(br.rowsLen))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 		expectedRowsCount := streamsPerTenant * blocksPerStream * rowsPerBlock
 		if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1229,7 +1229,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, br *blockResult) {
 			rowsCountTotal.Add(uint32(br.rowsLen))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 		expectedRowsCount := streamsPerTenant * blocksPerStream * 2
 		if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1251,7 +1251,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, br *blockResult) {
 			rowsCountTotal.Add(uint32(br.rowsLen))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 
 		expectedRowsCount := blocksPerStream
 		if n := rowsCountTotal.Load(); n != uint32(expectedRowsCount) {
@@ -1272,7 +1272,7 @@ func TestStorageSearch(t *testing.T) {
 		processBlock := func(_ uint, _ *blockResult) {
 			panic(fmt.Errorf("unexpected match"))
 		}
-		s.search(workersCount, so, qs, nil, processBlock)
+		s.searchParallel(workersCount, so, qs, nil, processBlock)
 	})
 
 	s.MustClose()
@@ -1438,5 +1438,5 @@ func TestDataBlock_MarshalUnmarshal(t *testing.T) {
 
 func newTestQueryContext(tenantIDs []TenantID, q *Query) *QueryContext {
 	qs := &QueryStats{}
-	return NewQueryContext(context.Background(), qs, tenantIDs, q)
+	return NewQueryContext(context.Background(), qs, tenantIDs, q, false)
 }
diff --git a/lib/logstorage/syslog_parser.go b/lib/logstorage/syslog_parser.go
index 54b297ddab..5a202ef268 100644
--- a/lib/logstorage/syslog_parser.go
+++ b/lib/logstorage/syslog_parser.go
@@ -421,38 +421,26 @@ func (p *SyslogParser) parseRFC3164(s string) {
 		return
 	}
 
-	t, err := time.Parse(time.Stamp, s[:n])
-	if err != nil {
-		// Fallback to RFC3339 timestamp
-		spaceIdx := strings.IndexByte(s, ' ')
-		if spaceIdx <= 0 {
+	if s[len("2006-01-02")] != 'T' {
+		// Parse RFC3164 timestamp.
+		if !p.tryParseTimestampRFC3164(s[:n]) {
 			p.AddField("message", s)
 			return
 		}
-		nsecs, ok := TryParseTimestampRFC3339Nano(s[:spaceIdx])
-		if !ok {
+	} else {
+		// Parse RFC3339 timestamp.
+		// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/303
+		n = strings.IndexByte(s, ' ')
+		if n < 0 {
 			p.AddField("message", s)
 			return
 		}
-
-		bufLen := len(p.buf)
-		p.buf = marshalTimestampISO8601String(p.buf, nsecs)
-		p.AddField("timestamp", bytesutil.ToUnsafeString(p.buf[bufLen:]))
-		// Preserve leading space so that subsequent parsing of hostname and tag fields works correctly.
-		s = s[spaceIdx:]
-	} else {
-		// Handle standard RFC3164 timestamp format
-		s = s[n:]
-		t = t.UTC()
-		t = time.Date(p.currentYear, t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), p.timezone)
-		if uint64(t.Unix())-24*3600 > fasttime.UnixTimestamp() {
-			// Adjust time to the previous year
-			t = time.Date(t.Year()-1, t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), p.timezone)
+		if !p.tryParseTimestampRFC3339Nano(s[:n]) {
+			p.AddField("message", s)
+			return
 		}
-		bufLen := len(p.buf)
-		p.buf = marshalTimestampISO8601String(p.buf, t.UnixNano())
-		p.AddField("timestamp", bytesutil.ToUnsafeString(p.buf[bufLen:]))
 	}
+	s = s[n:]
 
 	if len(s) == 0 || s[0] != ' ' {
 		// Missing space after the time field
@@ -518,3 +506,33 @@ func (p *SyslogParser) parseRFC3164(s string) {
 		p.AddField("message", s)
 	}
 }
+
+func (p *SyslogParser) tryParseTimestampRFC3164(s string) bool {
+	t, err := time.Parse(time.Stamp, s)
+	if err != nil {
+		return false
+	}
+
+	t = t.UTC()
+	t = time.Date(p.currentYear, t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), p.timezone)
+	if uint64(t.Unix())-24*3600 > fasttime.UnixTimestamp() {
+		// Adjust time to the previous year
+		t = time.Date(t.Year()-1, t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), p.timezone)
+	}
+	bufLen := len(p.buf)
+	p.buf = marshalTimestampRFC3339NanoString(p.buf, t.UnixNano())
+	p.AddField("timestamp", bytesutil.ToUnsafeString(p.buf[bufLen:]))
+	return true
+}
+
+func (p *SyslogParser) tryParseTimestampRFC3339Nano(s string) bool {
+	nsecs, ok := TryParseTimestampRFC3339Nano(s)
+	if !ok {
+		return false
+	}
+
+	bufLen := len(p.buf)
+	p.buf = marshalTimestampRFC3339NanoString(p.buf, nsecs)
+	p.AddField("timestamp", bytesutil.ToUnsafeString(p.buf[bufLen:]))
+	return true
+}
diff --git a/lib/logstorage/syslog_parser_test.go b/lib/logstorage/syslog_parser_test.go
index d32328fee9..31cf16624e 100644
--- a/lib/logstorage/syslog_parser_test.go
+++ b/lib/logstorage/syslog_parser_test.go
@@ -22,21 +22,21 @@ func TestSyslogParser(t *testing.T) {
 
 	// RFC 3164
 	f("Jun  3 12:08:33 abcd systemd[1]: Starting Update the local ESM caches...", time.UTC,
-		`format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=systemd proc_id=1 message="Starting Update the local ESM caches..."`)
+		`format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=systemd proc_id=1 message="Starting Update the local ESM caches..."`)
 	f("<165>Jun  3 12:08:33 abcd systemd[1]: Starting Update the local ESM caches...", time.UTC,
-		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=systemd proc_id=1 message="Starting Update the local ESM caches..."`)
+		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=systemd proc_id=1 message="Starting Update the local ESM caches..."`)
 	f("Mar 13 12:08:33 abcd systemd: Starting Update the local ESM caches...", time.UTC,
-		`format=rfc3164 timestamp=2024-03-13T12:08:33.000Z hostname=abcd app_name=systemd message="Starting Update the local ESM caches..."`)
+		`format=rfc3164 timestamp=2024-03-13T12:08:33Z hostname=abcd app_name=systemd message="Starting Update the local ESM caches..."`)
 	f("Jun  3 12:08:33 abcd - Starting Update the local ESM caches...", time.UTC,
-		`format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=- message="Starting Update the local ESM caches..."`)
+		`format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=- message="Starting Update the local ESM caches..."`)
 	f("Jun  3 12:08:33 - - Starting Update the local ESM caches...", time.UTC,
-		`format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=- app_name=- message="Starting Update the local ESM caches..."`)
+		`format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=- app_name=- message="Starting Update the local ESM caches..."`)
 
 	// RFC 3164: missing hostname, first token is tag (FreeBSD syslogd over UDP)
 	f("Jun  3 12:08:33 sshd-session[14308]: Received disconnect from 192.168.0.1 port 22:11: disconnected by user", time.UTC,
-		`format=rfc3164 timestamp=2024-06-03T12:08:33.000Z app_name=sshd-session proc_id=14308 message="Received disconnect from 192.168.0.1 port 22:11: disconnected by user"`)
+		`format=rfc3164 timestamp=2024-06-03T12:08:33Z app_name=sshd-session proc_id=14308 message="Received disconnect from 192.168.0.1 port 22:11: disconnected by user"`)
 	f("Jun  3 12:08:33 sshd-session: foo", time.UTC,
-		`format=rfc3164 timestamp=2024-06-03T12:08:33.000Z app_name=sshd-session message=foo`)
+		`format=rfc3164 timestamp=2024-06-03T12:08:33Z app_name=sshd-session message=foo`)
 
 	// RFC 5424
 	f(`<134>1 2024-12-09T18:25:35.401631+00:00 ps999 account-server - - [sd@51059 project="secret" ] 1.2.3.4 - - [09/Dec/2024:18:25:35 +0000] "PUT someurl" 201 - "-" "-" "container-updater 1283500" 0.0010 "-" 1531 0`, time.UTC, `priority=134 facility_keyword=local0 level=info facility=16 severity=6 format=rfc5424 timestamp=2024-12-09T18:25:35.401631+00:00 hostname=ps999 app_name=account-server proc_id=- msg_id=- sd@51059.project=secret message="1.2.3.4 - - [09/Dec/2024:18:25:35 +0000] \"PUT someurl\" 201 - \"-\" \"-\" \"container-updater 1283500\" 0.0010 \"-\" 1531 0"`)
@@ -44,23 +44,23 @@ func TestSyslogParser(t *testing.T) {
 		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc5424 timestamp=2023-06-03T17:42:32.123456789Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 message="This is a test message with structured data."`)
 	f(`1 2023-06-03T17:42:32.123456789Z mymachine.example.com appname 12345 ID47 - This is a test message with structured data.`, time.UTC,
 		`format=rfc5424 timestamp=2023-06-03T17:42:32.123456789Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 message="This is a test message with structured data."`)
-	f(`<165>1 2023-06-03T17:42:00.000Z mymachine.example.com appname 12345 ID47 [exampleSDID@32473 iut="3" eventSource="Application 123 = ] 56" eventID="11211"] This is a test message with structured data.`, time.UTC,
-		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc5424 timestamp=2023-06-03T17:42:00.000Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 exampleSDID@32473.iut=3 exampleSDID@32473.eventSource="Application 123 = ] 56" exampleSDID@32473.eventID=11211 message="This is a test message with structured data."`)
-	f(`<165>1 2023-06-03T17:42:00.000Z mymachine.example.com appname 12345 ID47 [foo@123 iut="3"][bar@456 eventID="11211"][abc=def][x=y z=a q="]= "] This is a test message with structured data.`, time.UTC,
-		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc5424 timestamp=2023-06-03T17:42:00.000Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 foo@123.iut=3 bar@456.eventID=11211 abc=def x=y z=a q="]= " message="This is a test message with structured data."`)
+	f(`<165>1 2023-06-03T17:42:00Z mymachine.example.com appname 12345 ID47 [exampleSDID@32473 iut="3" eventSource="Application 123 = ] 56" eventID="11211"] This is a test message with structured data.`, time.UTC,
+		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc5424 timestamp=2023-06-03T17:42:00Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 exampleSDID@32473.iut=3 exampleSDID@32473.eventSource="Application 123 = ] 56" exampleSDID@32473.eventID=11211 message="This is a test message with structured data."`)
+	f(`<165>1 2023-06-03T17:42:00Z mymachine.example.com appname 12345 ID47 [foo@123 iut="3"][bar@456 eventID="11211"][abc=def][x=y z=a q="]= "] This is a test message with structured data.`, time.UTC,
+		`priority=165 facility_keyword=local4 level=notice facility=20 severity=5 format=rfc5424 timestamp=2023-06-03T17:42:00Z hostname=mymachine.example.com app_name=appname proc_id=12345 msg_id=ID47 foo@123.iut=3 bar@456.eventID=11211 abc=def x=y z=a q="]= " message="This is a test message with structured data."`)
 	f(`<14>1 2025-02-11T12:31:28+01:00 synology Connection - - [synolog@6574 event_id="0x0001" synotype="Connection" username="synouser" luser="synouser" event="User [synouser\] from [192.168.0.10\] logged in successfully via [SSH\]." arg_1="synouser" arg_2="1027" arg_3="192.168.0.10" arg_4="SSH"][meta sequenceId="7"] User [synouser] from [192.168.0.10] logged in successfully via [SSH].`, time.UTC,
 		`priority=14 facility_keyword=user level=info facility=1 severity=6 format=rfc5424 timestamp=2025-02-11T12:31:28+01:00 hostname=synology app_name=Connection proc_id=- msg_id=- synolog@6574.event_id=0x0001 synolog@6574.synotype=Connection synolog@6574.username=synouser synolog@6574.luser=synouser synolog@6574.event="User [synouser] from [192.168.0.10] logged in successfully via [SSH]." synolog@6574.arg_1=synouser synolog@6574.arg_2=1027 synolog@6574.arg_3=192.168.0.10 synolog@6574.arg_4=SSH meta.sequenceId=7 message="User [synouser] from [192.168.0.10] logged in successfully via [SSH]."`)
 	f(`<14>1 2025-02-18T11:37:42+02:00 localhost Test - - [test event="quote \"test\""] Test message`, time.UTC, `priority=14 facility_keyword=user level=info facility=1 severity=6 format=rfc5424 timestamp=2025-02-18T11:37:42+02:00 hostname=localhost app_name=Test proc_id=- msg_id=- test.event="quote \"test\"" message="Test message"`)
 
 	// Incomplete RFC 3164
 	f("", time.UTC, ``)
-	f("Jun  3 12:08:33", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33.000Z`)
+	f("Jun  3 12:08:33", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33Z`)
 	f("Foo  3 12:08:33", time.UTC, `format=rfc3164 message="Foo  3 12:08:33"`)
 	f("Foo  3 12:08:33bar", time.UTC, `format=rfc3164 message="Foo  3 12:08:33bar"`)
-	f("Jun  3 12:08:33 abcd", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd`)
-	f("Jun  3 12:08:33 abcd sudo", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=sudo`)
-	f("Jun  3 12:08:33 abcd sudo[123]", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=sudo proc_id=123`)
-	f("Jun  3 12:08:33 abcd sudo foobar", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33.000Z hostname=abcd app_name=sudo message=foobar`)
+	f("Jun  3 12:08:33 abcd", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd`)
+	f("Jun  3 12:08:33 abcd sudo", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=sudo`)
+	f("Jun  3 12:08:33 abcd sudo[123]", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=sudo proc_id=123`)
+	f("Jun  3 12:08:33 abcd sudo foobar", time.UTC, `format=rfc3164 timestamp=2024-06-03T12:08:33Z hostname=abcd app_name=sudo message=foobar`)
 	f(`foo bar baz`, time.UTC, `format=rfc3164 message="foo bar baz"`)
 
 	// Incomplete RFC 5424
@@ -74,23 +74,23 @@ func TestSyslogParser(t *testing.T) {
 
 	// RFC 3164 with RFC3339/ISO8601 timestamp (rsyslog RSYSLOG_ForwardFormat)
 	f(`2025-01-23T12:15:23.965512+01:00 example rsyslogd: start`, time.UTC,
-		`format=rfc3164 timestamp=2025-01-23T11:15:23.965Z hostname=example app_name=rsyslogd message=start`)
+		`format=rfc3164 timestamp=2025-01-23T11:15:23.965512Z hostname=example app_name=rsyslogd message=start`)
 	f(`<46>2025-01-23T12:15:23.965512+01:00 example rsyslogd: start`, time.UTC,
-		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-01-23T11:15:23.965Z hostname=example app_name=rsyslogd message=start`)
+		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-01-23T11:15:23.965512Z hostname=example app_name=rsyslogd message=start`)
 	f(`2025-01-23T11:15:23Z example rsyslogd: start`, time.UTC,
-		`format=rfc3164 timestamp=2025-01-23T11:15:23.000Z hostname=example app_name=rsyslogd message=start`)
+		`format=rfc3164 timestamp=2025-01-23T11:15:23Z hostname=example app_name=rsyslogd message=start`)
 	f(`<46>2025-01-23T11:15:23+00:00 example rsyslogd: start`, time.UTC,
-		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-01-23T11:15:23.000Z hostname=example app_name=rsyslogd message=start`)
+		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-01-23T11:15:23Z hostname=example app_name=rsyslogd message=start`)
 	f(`2025-06-15T10:15:23-07:00 example rsyslogd: start`, time.UTC,
-		`format=rfc3164 timestamp=2025-06-15T17:15:23.000Z hostname=example app_name=rsyslogd message=start`)
+		`format=rfc3164 timestamp=2025-06-15T17:15:23Z hostname=example app_name=rsyslogd message=start`)
 	f(`<46>2025-03-01T00:05:00+05:30 example rsyslogd: start`, time.UTC,
-		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-02-28T18:35:00.000Z hostname=example app_name=rsyslogd message=start`)
+		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-02-28T18:35:00Z hostname=example app_name=rsyslogd message=start`)
 	f(`2025-08-12T09:00:00+07:00 example rsyslogd: start`, time.UTC,
-		`format=rfc3164 timestamp=2025-08-12T02:00:00.000Z hostname=example app_name=rsyslogd message=start`)
+		`format=rfc3164 timestamp=2025-08-12T02:00:00Z hostname=example app_name=rsyslogd message=start`)
 	f(`2025-01-01T00:00:00.123+01:00 example rsyslogd: start`, time.UTC,
 		`format=rfc3164 timestamp=2024-12-31T23:00:00.123Z hostname=example app_name=rsyslogd message=start`)
 	f(`<46>2025-04-05T22:10:59.500000-04:00 example rsyslogd: start`, time.UTC,
-		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-04-06T02:10:59.500Z hostname=example app_name=rsyslogd message=start`)
+		`priority=46 facility_keyword=syslog level=info facility=5 severity=6 format=rfc3164 timestamp=2025-04-06T02:10:59.5Z hostname=example app_name=rsyslogd message=start`)
 	f(`2025-10-10T10:10:10.999000Z example rsyslogd: start`, time.UTC,
 		`format=rfc3164 timestamp=2025-10-10T10:10:10.999Z hostname=example app_name=rsyslogd message=start`)
 }
diff --git a/lib/logstorage/values_encoder.go b/lib/logstorage/values_encoder.go
index 62db9f85c5..8e91f200e5 100644
--- a/lib/logstorage/values_encoder.go
+++ b/lib/logstorage/values_encoder.go
@@ -1427,3 +1427,8 @@ const iso8601Timestamp = "2006-01-02T15:04:05.000Z"
 func marshalTimestampRFC3339NanoString(dst []byte, nsecs int64) []byte {
 	return time.Unix(0, nsecs).UTC().AppendFormat(dst, time.RFC3339Nano)
 }
+
+// marshalTimestampRFC3339NanoPreciseString appends RFC3339-formatted nsecs with nanosecond precision to dst and returns the result.
+func marshalTimestampRFC3339NanoPreciseString(dst []byte, nsecs int64) []byte {
+	return time.Unix(0, nsecs).UTC().AppendFormat(dst, "2006-01-02T15:04:05.000000000Z07:00")
+}
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/appmetrics/appmetrics.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/appmetrics/appmetrics.go
index de446167df..fe9af54d14 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/appmetrics/appmetrics.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/appmetrics/appmetrics.go
@@ -4,7 +4,6 @@ import (
 	"flag"
 	"fmt"
 	"io"
-	"regexp"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -28,8 +27,6 @@ func initExposeMetadata() {
 	metrics.ExposeMetadata(*exposeMetadata)
 }
 
-var versionRe = regexp.MustCompile(`v\d+\.\d+\.\d+(?:-enterprise)?(?:-cluster)?`)
-
 // WritePrometheusMetrics writes all the registered metrics to w in Prometheus exposition format.
 func WritePrometheusMetrics(w io.Writer) {
 	exposeMetadataOnce.Do(initExposeMetadata)
@@ -58,7 +55,7 @@ func writePrometheusMetrics(w io.Writer) {
 	metrics.WritePrometheus(w, true)
 	metrics.WriteFDMetrics(w)
 
-	metrics.WriteGaugeUint64(w, fmt.Sprintf("vm_app_version{version=%q, short_version=%q}", buildinfo.Version, versionRe.FindString(buildinfo.Version)), 1)
+	metrics.WriteGaugeUint64(w, fmt.Sprintf("vm_app_version{version=%q, short_version=%q}", buildinfo.Version, buildinfo.ShortVersion()), 1)
 	metrics.WriteGaugeUint64(w, "vm_allowed_memory_bytes", uint64(memory.Allowed()))
 	metrics.WriteGaugeUint64(w, "vm_available_memory_bytes", uint64(memory.Allowed()+memory.Remaining()))
 	metrics.WriteGaugeUint64(w, "vm_available_cpu_cores", uint64(cgroup.AvailableCPUs()))
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo/version.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo/version.go
index 21b63d4619..a54483bf93 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo/version.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo/version.go
@@ -4,6 +4,7 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"regexp"
 )
 
 var version = flag.Bool("version", false, "Show VictoriaMetrics version")
@@ -11,6 +12,13 @@ var version = flag.Bool("version", false, "Show VictoriaMetrics version")
 // Version must be set via -ldflags '-X'
 var Version string
 
+var shortVersionRe = regexp.MustCompile(`v\d+\.\d+\.\d+(?:-enterprise)?(?:-cluster)?`)
+
+// ShortVersion returns a shortened version
+func ShortVersion() string {
+	return shortVersionRe.FindString(Version)
+}
+
 // Init must be called after flag.Parse call.
 func Init() {
 	if *version {
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil/duration.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil/duration.go
index e63940e9a8..64d6ff34eb 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil/duration.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil/duration.go
@@ -106,5 +106,96 @@ func (d *RetentionDuration) Set(value string) error {
 	return nil
 }
 
+// NewExtendedDuration returns new `duration` flag with the given name, defaultValue and description.
+//
+// Requires explicit unit suffixes (s, m, h, d, w, y). Bare numbers without units will cause errors (except 0).
+func NewExtendedDuration(name string, defaultValue string, description string) *ExtendedDuration {
+	description += "\nThe following unit suffixes are required: s (second), m (minute), h (hour), d (day), w (week), y (year). " +
+		"Bare numbers without units are not allowed (except 0)"
+	d := &ExtendedDuration{}
+	if err := d.Set(defaultValue); err != nil {
+		panic(fmt.Sprintf("BUG: can not parse default value %s for flag %s", defaultValue, name))
+	}
+	flag.Var(d, name, description)
+	return d
+}
+
+// ExtendedDuration is a flag for specifying time durations with explicit unit suffixes.
+// Unlike RetentionDuration, it requires explicit unit suffixes and doesn't treat bare numbers as months.
+// Supported units: s (seconds), m (minutes), h (hours), d (days), w (weeks), y (years).
+type ExtendedDuration struct {
+	// msecs contains parsed duration in milliseconds.
+	msecs int64
+
+	valueString string
+}
+
+var (
+	_ json.Marshaler   = (*ExtendedDuration)(nil)
+	_ json.Unmarshaler = (*ExtendedDuration)(nil)
+)
+
+// MarshalJSON implements json.Marshaler interface
+func (d *ExtendedDuration) MarshalJSON() ([]byte, error) {
+	return json.Marshal(d.valueString)
+}
+
+// UnmarshalJSON implements json.Unmarshaler interface
+func (d *ExtendedDuration) UnmarshalJSON(data []byte) error {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	return d.Set(s)
+}
+
+// Duration returns d as time.Duration
+func (d *ExtendedDuration) Duration() time.Duration {
+	return time.Millisecond * time.Duration(d.msecs)
+}
+
+// Milliseconds returns d in milliseconds
+func (d *ExtendedDuration) Milliseconds() int64 {
+	return d.msecs
+}
+
+// String implements flag.Value interface
+func (d *ExtendedDuration) String() string {
+	return d.valueString
+}
+
+// Set implements flag.Value interface
+// It requires explicit unit suffixes and rejects bare numbers (except 0).
+func (d *ExtendedDuration) Set(value string) error {
+	if value == "" {
+		d.msecs = 0
+		d.valueString = ""
+		return nil
+	}
+
+	// Check for bare numbers first
+	if f, err := strconv.ParseFloat(value, 64); err == nil {
+		// It's a bare number
+		if f != 0 {
+			return fmt.Errorf("duration value must have a unit suffix (s, m, h, d, w, y); got bare number %q (0 is allowed)", value)
+		}
+		// Allow 0 as it's unambiguous
+		d.msecs = 0
+		d.valueString = value
+		return nil
+	}
+
+	// Parse duration with units using metricsql
+	value = strings.ToLower(value)
+	msecs, err := metricsql.PositiveDurationValue(value, 0)
+	if err != nil {
+		return fmt.Errorf("cannot parse duration %q: %w", value, err)
+	}
+
+	d.msecs = msecs
+	d.valueString = value
+	return nil
+}
+
 const maxMonths = 12 * 100
 const msecsPer31Days = 31 * 24 * 3600 * 1000
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/fs/dir_remover.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/fs/dir_remover.go
index 4e74bf9d24..ad96bb4a83 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/fs/dir_remover.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/fs/dir_remover.go
@@ -76,9 +76,15 @@ func MustRemoveDir(dirPath string) {
 	// so they are no longer visible after unclean shutdown.
 	MustSyncPath(dirPath)
 
-	// Remove the deleteDirFilename file
+	// Remove the deleteDirFilename file, since there are no other entries left in the directory.
 	MustRemovePath(deleteFilePath)
 
+	// Sync the directory after the removing deletDirFilename file in order to make sure
+	// all the metadata files are removed at some exotic filesystems such as OSSFS2.
+	// See https://github.com/VictoriaMetrics/VictoriaLogs/issues/649
+	// and https://github.com/VictoriaMetrics/VictoriaMetrics/pull/9709
+	MustSyncPath(dirPath)
+
 	// Remove the dirPath itself
 	MustRemovePath(dirPath)
 
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool/timerpool.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool/timerpool.go
index 746f458e00..1b2c78e51e 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool/timerpool.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool/timerpool.go
@@ -25,13 +25,7 @@ func Get(d time.Duration) *time.Timer {
 //
 // t cannot be accessed after returning to the pool.
 func Put(t *time.Timer) {
-	if !t.Stop() {
-		// Drain t.C if it wasn't obtained by the caller yet.
-		select {
-		case <-t.C:
-		default:
-		}
-	}
+	t.Stop()
 	timerPool.Put(t)
 }
 
diff --git a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/writeconcurrencylimiter/concurrencylimiter.go b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/writeconcurrencylimiter/concurrencylimiter.go
index 580540850b..f0ddf335a0 100644
--- a/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/writeconcurrencylimiter/concurrencylimiter.go
+++ b/vendor/github.com/VictoriaMetrics/VictoriaMetrics/lib/writeconcurrencylimiter/concurrencylimiter.go
@@ -115,12 +115,11 @@ func incConcurrency() bool {
 
 	concurrencyLimitReached.Inc()
 	t := timerpool.Get(*maxQueueDuration)
+	defer timerpool.Put(t)
 	select {
 	case concurrencyLimitCh <- struct{}{}:
-		timerpool.Put(t)
 		return true
 	case <-t.C:
-		timerpool.Put(t)
 		concurrencyLimitTimeout.Inc()
 		return false
 	}
diff --git a/vendor/github.com/VictoriaMetrics/metrics/metrics.go b/vendor/github.com/VictoriaMetrics/metrics/metrics.go
index 3af670541d..fc121f81bf 100644
--- a/vendor/github.com/VictoriaMetrics/metrics/metrics.go
+++ b/vendor/github.com/VictoriaMetrics/metrics/metrics.go
@@ -338,6 +338,10 @@ func WriteMetadataIfNeeded(w io.Writer, metricName, metricType string) {
 		return
 	}
 	metricFamily := getMetricFamily(metricName)
+	writeMetadata(w, metricFamily, metricType)
+}
+
+func writeMetadata(w io.Writer, metricFamily, metricType string) {
 	fmt.Fprintf(w, "# HELP %s\n", metricFamily)
 	fmt.Fprintf(w, "# TYPE %s %s\n", metricFamily, metricType)
 }
diff --git a/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go b/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go
index df79a2e92a..6c07cecb69 100644
--- a/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go
+++ b/vendor/github.com/VictoriaMetrics/metrics/process_metrics_linux.go
@@ -240,7 +240,6 @@ func writeProcessMemMetrics(w io.Writer) {
 	WriteGaugeUint64(w, "process_resident_memory_anon_bytes", ms.rssAnon)
 	WriteGaugeUint64(w, "process_resident_memory_file_bytes", ms.rssFile)
 	WriteGaugeUint64(w, "process_resident_memory_shared_bytes", ms.rssShmem)
-
 }
 
 func getMemStats(path string) (*memStats, error) {
@@ -321,7 +320,7 @@ func psiTotalSecs(microsecs uint64) float64 {
 var psiMetricsStart = func() *psiMetrics {
 	m, err := getPSIMetrics()
 	if err != nil {
-		log.Printf("ERROR: metrics: disable exposing PSI metrics because of failed init: %s", err)
+		log.Printf("INFO: metrics: disable exposing PSI metrics because of failed init: %s", err)
 		return nil
 	}
 	return m
diff --git a/vendor/github.com/VictoriaMetrics/metrics/set.go b/vendor/github.com/VictoriaMetrics/metrics/set.go
index 31f9f69cac..ffe7b9fcab 100644
--- a/vendor/github.com/VictoriaMetrics/metrics/set.go
+++ b/vendor/github.com/VictoriaMetrics/metrics/set.go
@@ -37,6 +37,25 @@ func (s *Set) WritePrometheus(w io.Writer) {
 	// Collect all the metrics in in-memory buffer in order to prevent from long locking due to slow w.
 	var bb bytes.Buffer
 	lessFunc := func(i, j int) bool {
+		// the sorting must be stable.
+		// see edge cases why we can't simply do `s.a[i].name < s.a[j].name` here:
+		// https://github.com/VictoriaMetrics/metrics/pull/99#issuecomment-3277072175
+
+		// sort by metric family name first, to group the same metric family in one place.
+		fName1, fName2 := getMetricFamily(s.a[i].name), getMetricFamily(s.a[j].name)
+		if fName1 != fName2 {
+			return fName1 < fName2
+		}
+
+		mType1 := s.a[i].metric.metricType()
+		mType2 := s.a[j].metric.metricType()
+
+		// stabilize the order for summary and quantiles.
+		if mType1 != mType2 {
+			return mType1 < mType2
+		}
+
+		// lastly by metric names, which is for quantiles and histogram buckets.
 		return s.a[i].name < s.a[j].name
 	}
 	s.mu.Lock()
@@ -50,18 +69,34 @@ func (s *Set) WritePrometheus(w io.Writer) {
 	metricsWriters := s.metricsWriters
 	s.mu.Unlock()
 
-	prevMetricFamily := ""
+	// metricsWithMetadataBuf is used to hold marshalTo temporary, and decide whether metadata is needed.
+	// it will be written to `bb` at the end and then reset for next *namedMetric in for-loop.
+	var metricsWithMetadataBuf bytes.Buffer
+	var prevMetricFamily string
 	for _, nm := range sa {
+		if !isMetadataEnabled() {
+			// Call marshalTo without the global lock, since certain metric types such as Gauge
+			// can call a callback, which, in turn, can try calling s.mu.Lock again.
+			nm.metric.marshalTo(nm.name, &bb)
+			continue
+		}
+
+		metricsWithMetadataBuf.Reset()
+		// Call marshalTo without the global lock, since certain metric types such as Gauge
+		// can call a callback, which, in turn, can try calling s.mu.Lock again.
+		nm.metric.marshalTo(nm.name, &metricsWithMetadataBuf)
+		if metricsWithMetadataBuf.Len() == 0 {
+			continue
+		}
+
 		metricFamily := getMetricFamily(nm.name)
 		if metricFamily != prevMetricFamily {
-			// write meta info only once per metric family
+			// write metadata only once per metric family
 			metricType := nm.metric.metricType()
-			WriteMetadataIfNeeded(&bb, nm.name, metricType)
+			writeMetadata(&bb, metricFamily, metricType)
 			prevMetricFamily = metricFamily
 		}
-		// Call marshalTo without the global lock, since certain metric types such as Gauge
-		// can call a callback, which, in turn, can try calling s.mu.Lock again.
-		nm.metric.marshalTo(nm.name, &bb)
+		bb.Write(metricsWithMetadataBuf.Bytes())
 	}
 	w.Write(bb.Bytes())
 
diff --git a/vendor/github.com/VictoriaMetrics/metrics/summary.go b/vendor/github.com/VictoriaMetrics/metrics/summary.go
index 0469b98348..1b62988bba 100644
--- a/vendor/github.com/VictoriaMetrics/metrics/summary.go
+++ b/vendor/github.com/VictoriaMetrics/metrics/summary.go
@@ -201,6 +201,10 @@ func (qv *quantileValue) marshalTo(prefix string, w io.Writer) {
 }
 
 func (qv *quantileValue) metricType() string {
+	// this metricsType should not be printed, because summary (sum and count) of the same metric family will be printed first,
+	// and if metadata is needed, the metadata from summary should be used.
+	// quantile will be printed later, so its metrics type won't be printed as metadata.
+	// See: https://github.com/VictoriaMetrics/metrics/pull/99
 	return "unsupported"
 }
 
diff --git a/vendor/github.com/VictoriaMetrics/metricsql/utils.go b/vendor/github.com/VictoriaMetrics/metricsql/utils.go
index bbc6a95d51..a0fb91346c 100644
--- a/vendor/github.com/VictoriaMetrics/metricsql/utils.go
+++ b/vendor/github.com/VictoriaMetrics/metricsql/utils.go
@@ -141,7 +141,8 @@ func checkSupportedFunctions(e Expr) error {
 		if !ok {
 			return
 		}
-		if !IsRollupFunc(fe.Name) && !IsTransformFunc(fe.Name) {
+
+		if !IsSupportedFunction(fe.Name) {
 			err = fmt.Errorf("unsupported function %q", fe.Name)
 		}
 	})
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 9d427cdc02..902db3efde 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,4 +1,4 @@
-# github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250829235354-7967ad661e76
+# github.com/VictoriaMetrics/VictoriaMetrics v0.0.0-20250917082640-2c72ef0f3871
 ## explicit; go 1.25.0
 github.com/VictoriaMetrics/VictoriaMetrics/lib/appmetrics
 github.com/VictoriaMetrics/VictoriaMetrics/lib/atomicutil
@@ -47,10 +47,10 @@ github.com/VictoriaMetrics/VictoriaMetrics/lib/writeconcurrencylimiter
 # github.com/VictoriaMetrics/easyproto v0.1.4
 ## explicit; go 1.18
 github.com/VictoriaMetrics/easyproto
-# github.com/VictoriaMetrics/metrics v1.39.1
+# github.com/VictoriaMetrics/metrics v1.40.1
 ## explicit; go 1.18
 github.com/VictoriaMetrics/metrics
-# github.com/VictoriaMetrics/metricsql v0.84.7
+# github.com/VictoriaMetrics/metricsql v0.84.8
 ## explicit; go 1.24.2
 github.com/VictoriaMetrics/metricsql
 github.com/VictoriaMetrics/metricsql/binaryop