app/vmctl: remove unused channel

Signed-off-by: hagen1778 <roman@victoriametrics.com>

app/vlinsert/opentelemetry/opentelemetry.go

@@ -101,7 +101,7 @@ func pushProtobufRequest(data []byte, lmp insertutils.LogMessageProcessor, useDe
 		commonFields = slicesutil.SetLength(commonFields, len(attributes))
 		for i, attr := range attributes {
 			commonFields[i].Name = attr.Key
-			commonFields[i].Value = attr.Value.FormatString()
+			commonFields[i].Value = attr.Value.FormatString(true)
 		}
 		commonFieldsLen := len(commonFields)
 		for _, sc := range rl.ScopeLogs {
@@ -118,12 +118,12 @@ func pushFieldsFromScopeLogs(sc *pb.ScopeLogs, commonFields []logstorage.Field,
 		fields = fields[:len(commonFields)]
 		fields = append(fields, logstorage.Field{
 			Name:  "_msg",
-			Value: lr.Body.FormatString(),
+			Value: lr.Body.FormatString(true),
 		})
 		for _, attr := range lr.Attributes {
 			fields = append(fields, logstorage.Field{
 				Name:  attr.Key,
-				Value: attr.Value.FormatString(),
+				Value: attr.Value.FormatString(true),
 			})
 		}
 		if len(lr.TraceID) > 0 {

app/vlinsert/opentelemetry/opentelemetry_test.go

@@ -66,9 +66,9 @@ func TestPushProtoOk(t *testing.T) {
 		},
 	},
 		[]int64{1234, 1235, 1236},
-		`{"logger":"context","instance_id":"10","node_taints":"[{\"Key\":\"role\",\"Value\":{\"StringValue\":\"dev\",\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":null,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}},{\"Key\":\"cluster_load_percent\",\"Value\":{\"StringValue\":null,\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":0.55,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}}]","_msg":"log-line-message","severity":"Trace"}
-{"logger":"context","instance_id":"10","node_taints":"[{\"Key\":\"role\",\"Value\":{\"StringValue\":\"dev\",\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":null,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}},{\"Key\":\"cluster_load_percent\",\"Value\":{\"StringValue\":null,\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":0.55,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}}]","_msg":"log-line-message-msg-2","severity":"Unspecified"}
-{"logger":"context","instance_id":"10","node_taints":"[{\"Key\":\"role\",\"Value\":{\"StringValue\":\"dev\",\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":null,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}},{\"Key\":\"cluster_load_percent\",\"Value\":{\"StringValue\":null,\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":0.55,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}}]","_msg":"log-line-message-msg-2","severity":"Unspecified"}`,
+		`{"logger":"context","instance_id":"10","node_taints":"{\"role\":\"dev\",\"cluster_load_percent\":0.55}","_msg":"log-line-message","severity":"Trace"}
+{"logger":"context","instance_id":"10","node_taints":"{\"role\":\"dev\",\"cluster_load_percent\":0.55}","_msg":"log-line-message-msg-2","severity":"Unspecified"}
+{"logger":"context","instance_id":"10","node_taints":"{\"role\":\"dev\",\"cluster_load_percent\":0.55}","_msg":"log-line-message-msg-2","severity":"Unspecified"}`,
 	)
 
 	// multi-scope with resource attributes and multi-line
@@ -113,8 +113,8 @@ func TestPushProtoOk(t *testing.T) {
 		},
 	},
 		[]int64{1234, 1235, 2345, 2346, 2347, 2348},
-		`{"logger":"context","instance_id":"10","node_taints":"[{\"Key\":\"role\",\"Value\":{\"StringValue\":\"dev\",\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":null,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}},{\"Key\":\"cluster_load_percent\",\"Value\":{\"StringValue\":null,\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":0.55,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}}]","_msg":"log-line-message","severity":"Trace"}
-{"logger":"context","instance_id":"10","node_taints":"[{\"Key\":\"role\",\"Value\":{\"StringValue\":\"dev\",\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":null,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}},{\"Key\":\"cluster_load_percent\",\"Value\":{\"StringValue\":null,\"BoolValue\":null,\"IntValue\":null,\"DoubleValue\":0.55,\"ArrayValue\":null,\"KeyValueList\":null,\"BytesValue\":null}}]","_msg":"log-line-message-msg-2","severity":"Debug"}
+		`{"logger":"context","instance_id":"10","node_taints":"{\"role\":\"dev\",\"cluster_load_percent\":0.55}","_msg":"log-line-message","severity":"Trace"}
+{"logger":"context","instance_id":"10","node_taints":"{\"role\":\"dev\",\"cluster_load_percent\":0.55}","_msg":"log-line-message-msg-2","severity":"Debug"}
 {"_msg":"log-line-resource-scope-1-0-0","severity":"Info2"}
 {"_msg":"log-line-resource-scope-1-0-1","severity":"Info2"}
 {"_msg":"log-line-resource-scope-1-1-0","severity":"Info4"}

app/vmctl/influx.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"log"
@@ -37,7 +38,7 @@ func newInfluxProcessor(ic *influx.Client, im *vm.Importer, cc int, separator st
 	}
 }
 
-func (ip *influxProcessor) run() error {
+func (ip *influxProcessor) run(ctx context.Context) error {
 	series, err := ip.ic.Explore()
 	if err != nil {
 		return fmt.Errorf("explore query failed: %s", err)
@@ -67,7 +68,7 @@ func (ip *influxProcessor) run() error {
 		go func() {
 			defer wg.Done()
 			for s := range seriesCh {
-				if err := ip.do(s); err != nil {
+				if err := ip.do(ctx, s); err != nil {
 					errCh <- fmt.Errorf("request failed for %q.%q: %s", s.Measurement, s.Field, err)
 					return
 				}
@@ -110,7 +111,7 @@ const dbLabel = "db"
 const nameLabel = "__name__"
 const valueField = "value"
 
-func (ip *influxProcessor) do(s *influx.Series) error {
+func (ip *influxProcessor) do(ctx context.Context, s *influx.Series) error {
 	cr, err := ip.ic.FetchDataPoints(s)
 	if err != nil {
 		return fmt.Errorf("failed to fetch datapoints: %s", err)
@@ -163,7 +164,7 @@ func (ip *influxProcessor) do(s *influx.Series) error {
 			Timestamps: time,
 			Values:     values,
 		}
-		if err := ip.im.Input(&ts); err != nil {
+		if err := ip.im.Input(ctx, &ts); err != nil {
 			return err
 		}
 	}

app/vmctl/main.go

@@ -97,7 +97,7 @@ func main() {
 					}
 
 					otsdbProcessor := newOtsdbProcessor(otsdbClient, importer, c.Int(otsdbConcurrency), c.Bool(globalVerbose))
-					return otsdbProcessor.run()
+					return otsdbProcessor.run(ctx)
 				},
 			},
 			{
@@ -158,7 +158,7 @@ func main() {
 						c.Bool(influxSkipDatabaseLabel),
 						c.Bool(influxPrometheusMode),
 						c.Bool(globalVerbose))
-					return processor.run()
+					return processor.run(ctx)
 				},
 			},
 			{
@@ -261,7 +261,7 @@ func main() {
 						cc:        c.Int(promConcurrency),
 						isVerbose: c.Bool(globalVerbose),
 					}
-					return pp.run()
+					return pp.run(ctx)
 				},
 			},
 			{

app/vmctl/opentsdb.go

@@ -1,14 +1,16 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"sync"
 	"time"
 
+	"github.com/cheggaaa/pb/v3"
+
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmctl/opentsdb"
 	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmctl/vm"
-	"github.com/cheggaaa/pb/v3"
 )
 
 type otsdbProcessor struct {
@@ -37,7 +39,7 @@ func newOtsdbProcessor(oc *opentsdb.Client, im *vm.Importer, otsdbcc int, verbos
 	}
 }
 
-func (op *otsdbProcessor) run() error {
+func (op *otsdbProcessor) run(ctx context.Context) error {
 	log.Println("Loading all metrics from OpenTSDB for filters: ", op.oc.Filters)
 	var metrics []string
 	for _, filter := range op.oc.Filters {
@@ -93,7 +95,7 @@ func (op *otsdbProcessor) run() error {
 			go func() {
 				defer wg.Done()
 				for s := range seriesCh {
-					if err := op.do(s); err != nil {
+					if err := op.do(ctx, s); err != nil {
 						errCh <- fmt.Errorf("couldn't retrieve series for %s : %s", metric, err)
 						return
 					}
@@ -148,7 +150,7 @@ func (op *otsdbProcessor) run() error {
 	return nil
 }
 
-func (op *otsdbProcessor) do(s queryObj) error {
+func (op *otsdbProcessor) do(ctx context.Context, s queryObj) error {
 	start := s.StartTime - s.Tr.Start
 	end := s.StartTime - s.Tr.End
 	data, err := op.oc.GetData(s.Series, s.Rt, start, end, op.oc.MsecsTime)
@@ -168,5 +170,5 @@ func (op *otsdbProcessor) do(s queryObj) error {
 		Timestamps: data.Timestamps,
 		Values:     data.Values,
 	}
-	return op.im.Input(&ts)
+	return op.im.Input(ctx, &ts)
 }

app/vmctl/prometheus.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"sync"
@@ -30,7 +31,7 @@ type prometheusProcessor struct {
 	isVerbose bool
 }
 
-func (pp *prometheusProcessor) run() error {
+func (pp *prometheusProcessor) run(ctx context.Context) error {
 	blocks, err := pp.cl.Explore()
 	if err != nil {
 		return fmt.Errorf("explore failed: %s", err)
@@ -59,7 +60,7 @@ func (pp *prometheusProcessor) run() error {
 		go func() {
 			defer wg.Done()
 			for br := range blockReadersCh {
-				if err := pp.do(br); err != nil {
+				if err := pp.do(ctx, br); err != nil {
 					errCh <- fmt.Errorf("read failed for block %q: %s", br.Meta().ULID, err)
 					return
 				}
@@ -100,7 +101,7 @@ func (pp *prometheusProcessor) run() error {
 	return nil
 }
 
-func (pp *prometheusProcessor) do(b tsdb.BlockReader) error {
+func (pp *prometheusProcessor) do(ctx context.Context, b tsdb.BlockReader) error {
 	ss, err := pp.cl.Read(b)
 	if err != nil {
 		return fmt.Errorf("failed to read block: %s", err)
@@ -150,7 +151,7 @@ func (pp *prometheusProcessor) do(b tsdb.BlockReader) error {
 			Timestamps: timestamps,
 			Values:     values,
 		}
-		if err := pp.im.Input(&ts); err != nil {
+		if err := pp.im.Input(ctx, &ts); err != nil {
 			return err
 		}
 	}

app/vmctl/prometheus_test.go

@@ -160,7 +160,7 @@ func TestPrometheusProcessorRun(t *testing.T) {
 				go tt.fields.closer(importer)
 			}
 
-			if err := pp.run(); (err != nil) != tt.wantErr {
+			if err := pp.run(context.Background()); (err != nil) != tt.wantErr {
 				t.Fatalf("run() error = %v, wantErr %v", err, tt.wantErr)
 			}
 		})

app/vmctl/remoteread.go

@@ -112,7 +112,7 @@ func (rrp *remoteReadProcessor) run(ctx context.Context) error {
 
 func (rrp *remoteReadProcessor) do(ctx context.Context, filter *remoteread.Filter) error {
 	return rrp.src.Read(ctx, filter, func(series *vm.TimeSeries) error {
-		if err := rrp.dst.Input(series); err != nil {
+		if err := rrp.dst.Input(ctx, series); err != nil {
 			return fmt.Errorf(
 				"failed to read data for time range start: %d, end: %d, %s",
 				filter.StartTimestampMs, filter.EndTimestampMs, err)

app/vmctl/vm/vm.go

@@ -69,7 +69,6 @@ type Importer struct {
 	user       string
 	password   string
 
-	close  chan struct{}
 	input  chan *TimeSeries
 	errors chan *ImportError
 
@@ -143,7 +142,6 @@ func NewImporter(ctx context.Context, cfg Config) (*Importer, error) {
 		user:       cfg.User,
 		password:   cfg.Password,
 		rl:         limiter.NewLimiter(cfg.RateLimit),
-		close:      make(chan struct{}),
 		input:      make(chan *TimeSeries, cfg.Concurrency*4),
 		errors:     make(chan *ImportError, cfg.Concurrency),
 		backoff:    cfg.Backoff,
@@ -189,10 +187,10 @@ func (im *Importer) Errors() chan *ImportError { return im.errors }
 
 // Input returns a channel for sending timeseries
 // that need to be imported
-func (im *Importer) Input(ts *TimeSeries) error {
+func (im *Importer) Input(ctx context.Context, ts *TimeSeries) error {
 	select {
-	case <-im.close:
-		return fmt.Errorf("importer is closed")
+	case <-ctx.Done():
+		return ctx.Err()
 	case im.input <- ts:
 		return nil
 	case err := <-im.errors:
@@ -207,7 +205,6 @@ func (im *Importer) Input(ts *TimeSeries) error {
 // and waits until they are finished
 func (im *Importer) Close() {
 	im.once.Do(func() {
-		close(im.close)
 		close(im.input)
 		im.wg.Wait()
 		close(im.errors)
@@ -220,24 +217,34 @@ func (im *Importer) startWorker(ctx context.Context, bar barpool.Bar, batchSize,
 	var waitForBatch time.Time
 	for {
 		select {
-		case <-im.close:
+		case <-ctx.Done():
 			for ts := range im.input {
 				ts = roundTimeseriesValue(ts, significantFigures, roundDigits)
 				batch = append(batch, ts)
+				exitErr := &ImportError{
+					Batch: batch,
+				}
+				retryableFunc := func() error { return im.Import(batch) }
+				_, err := im.backoff.Retry(ctx, retryableFunc)
+				if err != nil {
+					exitErr.Err = err
+				}
+				im.errors <- exitErr
 			}
-			exitErr := &ImportError{
-				Batch: batch,
-			}
-			retryableFunc := func() error { return im.Import(batch) }
-			_, err := im.backoff.Retry(ctx, retryableFunc)
-			if err != nil {
-				exitErr.Err = err
-			}
-			im.errors <- exitErr
 			return
 		case ts, ok := <-im.input:
 			if !ok {
-				continue
+				// drain all batches before exit
+				exitErr := &ImportError{
+					Batch: batch,
+				}
+				retryableFunc := func() error { return im.Import(batch) }
+				_, err := im.backoff.Retry(ctx, retryableFunc)
+				if err != nil {
+					exitErr.Err = err
+				}
+				im.errors <- exitErr
+				return
 			}
 			// init waitForBatch when first
 			// value was received

app/vmui/packages/vmui/src/pages/DownsamplingFilters/hooks/useDebugDownsamplingFilters.ts

@@ -9,7 +9,7 @@ export const useDebugDownsamplingFilters = () => {
   const { serverUrl } = useAppState();
   const [searchParams, setSearchParams] = useSearchParams();
 
-  const [data, setData] = useState<Map<string, string[]>>(new Map());
+  const [data, setData] = useState<Map<string, string[] | null>>(new Map());
   const [loading, setLoading] = useState(false);
   const [metricsError, setMetricsError] = useState<ErrorTypes | string>();
   const [flagsError, setFlagsError] = useState<ErrorTypes | string>();

app/vmui/packages/vmui/src/pages/DownsamplingFilters/index.tsx

@@ -7,6 +7,7 @@ import { PlayIcon, WikiIcon } from "../../components/Main/Icons";
 import { useDebugDownsamplingFilters } from "./hooks/useDebugDownsamplingFilters";
 import Spinner from "../../components/Main/Spinner/Spinner";
 import { useSearchParams } from "react-router-dom";
+import classNames from "classnames";
 
 const example = {
   flags: `-downsampling.period={env="dev"}:7d:5m,{env="dev"}:30d:30m
@@ -54,7 +55,14 @@ const DownsamplingFilters: FC = () => {
   for (const [key, value] of data) {
     rows.push(<tr className="vm-table__row">
       <td className="vm-table-cell">{key}</td>
-      <td className="vm-table-cell">{value.join(" ")}</td>
+      <td
+        className={classNames({
+          "vm-table-cell": true,
+          "vm-table-cell_empty": !value,
+        })}
+      >
+        {value ? value.join(" ") : "No matching rules found!"}
+      </td>
     </tr>);
   }
   return (

app/vmui/packages/vmui/src/styles/components/table.scss

@@ -94,6 +94,11 @@
       white-space: nowrap;
       width: 100px;
     }
+
+    &_empty {
+      color: $color-text-secondary;
+      font-style: italic;
+    }
   }
 
   &__sort-icon {

deployment/docker/vmanomaly/vmanomaly-integration/docker-compose.yml

@@ -72,7 +72,7 @@ services:
     restart: always
   vmanomaly:
     container_name: vmanomaly
-    image: victoriametrics/vmanomaly:v1.19.2
+    image: victoriametrics/vmanomaly:v1.20.0
     depends_on:
       - "victoriametrics"
     ports:

docs/VictoriaLogs/CHANGELOG.md

@@ -22,12 +22,13 @@ Released at 2025-02-27
 
 * FEATURE: [`pack_json` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_json-pipe): allow packing fields, which start with the given prefixes. For example, `pack_json fields (foo.*, bar.*)` creates a JSON containing all the fields, which start with either `foo.` or `bar.`.
 * FEATURE: [`pack_logfmt` pipe](https://docs.victoriametrics.com/victorialogs/logsql/#pack_logfmt-pipe): allow packing fields, which start with the given prefixes. For example, `pack_logfmt fields (foo.*, bar.*)` creates [logfmt](https://brandur.org/logfmt) message containing all the fields, which start with either `foo.` or `bar.`.
-* FEATURE: expose `vl_request_duration_seconds` [summaries](https://docs.victoriametrics.com/keyconcepts/#summary) for [select APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api) at the [/metrics](https://docs.victoriametrics.com/victorialogs/#monitoring) page.
+* FEATURE: expose `vl_http_request_duration_seconds` [summaries](https://docs.victoriametrics.com/keyconcepts/#summary) for [select APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api) at the [/metrics](https://docs.victoriametrics.com/victorialogs/#monitoring) page.
 * FEATURE: allow passing `*` as a subquery inside [`in(*)`, `contains_any(*)` and `contains_all(*)` filters](https://docs.victoriametrics.com/victorialogs/logsql/#subquery-filter). Such filters are treated as `match all` aka `*`. This is going to be used by [Grafana plugin for VictoriaLogs](https://docs.victoriametrics.com/victorialogs/victorialogs-datasource/). See [this issue](https://github.com/VictoriaMetrics/victorialogs-datasource/issues/238#issuecomment-2685447673).
 * FEATURE: [victorialogs dashboard](https://grafana.com/grafana/dashboards/22084-victorialogs/): add panels to display amount of ingested logs in bytes, latency of [select APIs](https://docs.victoriametrics.com/victorialogs/querying/#http-api) calls, troubleshooting panels.
 * FEATURE: provide alternative registry for all VictoriaLogs components at [Quay.io](https://quay.io/organization/victoriametrics): [VictoriaLogs](https://quay.io/repository/victoriametrics/victoria-logs?tab=tags) and [vlogscli](https://quay.io/repository/victoriametrics/vlogscli?tab=tags).
 
 * BUGFIX: do not treat a string containing leading zeros as a number during data ingestion and querying. For example, `00123` string shouldn't be treated as `123` number. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8361).
+* BUGFIX: [data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/): Properly convert nested OpenTelemetry attributes into JSON. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8384).
 
 ## [v1.14.0](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v1.14.0-victorialogs)
 

docs/VictoriaLogs/README.md

@@ -289,7 +289,10 @@ or similar authorization proxies.
 
 ## Benchmarks
 
-See [the comparison of VictoriaLogs with Elasticsearch, MongoDB, TimescaleDB, PostgreSQL, MySQL and SQLite](https://benchmark.clickhouse.com/#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).
+See the following benchmark results:
+
+- [JSONBench: the comparison of VictoriaLogs with Elasticsearch, MongoDB, DuckDB and PostgreSQL](https://jsonbench.com/#eyJzeXN0ZW0iOnsiQ2xpY2tIb3VzZSAobHo0KSI6ZmFsc2UsIkNsaWNrSG91c2UgKHpzdGQpIjpmYWxzZSwiRHVja0RCIjp0cnVlLCJFbGFzdGljc2VhcmNoIChubyBzb3VyY2UsIGJlc3QgY29tcHJlc3Npb24pIjpmYWxzZSwiRWxhc3RpY3NlYXJjaCAobm8gc291cmNlLCBkZWZhdWx0KSI6ZmFsc2UsIkVsYXN0aWNzZWFyY2ggKGJlc3QgY29tcHJlc3Npb24pIjpmYWxzZSwiRWxhc3RpY3NlYXJjaCAoZGVmYXVsdCkiOnRydWUsIkVsYXN0aWNzZWFyY2giOmZhbHNlLCJNb25nb0RCIChzbmFwcHksIGNvdmVyZWQgaW5kZXgpIjpmYWxzZSwiTW9uZ29EQiAoenN0ZCwgY292ZXJlZCBpbmRleCkiOmZhbHNlLCJNb25nb0RCIChzbmFwcHkpIjpmYWxzZSwiTW9uZ29EQiAoenN0ZCkiOnRydWUsIlBvc3RncmVTUUwgKGx6NCkiOnRydWUsIlBvc3RncmVTUUwgKHBnbHopIjpmYWxzZSwiVmljdG9yaWFMb2dzIjp0cnVlfSwic2NhbGUiOjEwMDAwMDAwMDAsIm1ldHJpYyI6ImhvdCIsInF1ZXJpZXMiOlt0cnVlLHRydWUsdHJ1ZSx0cnVlLHRydWVdfQ==). The benchmark can be reproduced by running `main.sh` file inside `victorialogs` directory of the [JSONBench repository](https://github.com/ClickHouse/JSONBench).
+- [ClickBench: the comparison of VictoriaLogs with Elasticsearch, MongoDB, TimescaleDB, PostgreSQL, MySQL and SQLite](https://benchmark.clickhouse.com/#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). The benchmark can be reproduced by running `benchmark.sh` file inside `victorialogs` directory of the [ClickBench repository](https://github.com/ClickHouse/ClickBench/).
 
 Here is a [benchmark suite](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/master/deployment/logs-benchmark) for comparing data ingestion performance
 and resource usage between VictoriaLogs and Elasticsearch or Loki.

docs/anomaly-detection/CHANGELOG.md

@@ -11,6 +11,15 @@ aliases:
 ---
 Please find the changelog for VictoriaMetrics Anomaly Detection below.
 
+## v1.20.0
+Released: 2025-03-03
+
+- FEATURE: The `scale` argument is now a [common argument](https://docs.victoriametrics.com/anomaly-detection/components/models/#scale), previously supported only by [`ProphetModel`](https://docs.victoriametrics.com/anomaly-detection/components/models/#prophet) and [`OnlineQuantileModel`](https://docs.victoriametrics.com/anomaly-detection/components/models/#online-seasonal-quantile). Additionally, `scale` is now **two-sided**, represented as `[scale_lb, scale_ub]`. The previous format (`scale: x`) remains supported and will be automatically converted to `scale: [x, x]`.
+  
+- FEATURE: Introduced a post-processing step to clip `yhat`, `yhat_lower`, and `yhat_upper` to the configured `data_range` [values](https://docs.victoriametrics.com/anomaly-detection/components/reader/?highlight=data_range#config-parameters) in `VmReader`, if defined. This feature is disabled by default for backward compatibility. It can be enabled for models that generate predictions and estimates, such as [`ProphetModel`](https://docs.victoriametrics.com/anomaly-detection/components/models/#prophet), by setting the [common argument](https://docs.victoriametrics.com/anomaly-detection/components/models/#clip-predictions) `clip_predictions` to `True`.
+
+- IMPROVEMENT: Introduced the `anomaly_score_outside_data_range` [parameter](https://docs.victoriametrics.com/anomaly-detection/components/models/#score-outside-data-range) to allow overriding the default anomaly score (`1.01`) assigned when input values (`y`) fall outside the defined `data_range` (data domain violation). It improves flexibility for alerting rules and enables clearer visual distinction between different anomaly scenarios. Override can be configured at the **service level** (`settings`) or per **model instance** (`models.model_xxx`), with model-level values taking priority. If not explicitly set, the default anomaly score remains `1.01` for backward compatibility.
+
 ## v1.19.2
 Released: 2025-01-27
 

docs/anomaly-detection/FAQ.md

@@ -93,16 +93,74 @@ To visualize and interact with both [self-monitoring metrics](https://docs.victo
 
 
 ## Choosing the right model for vmanomaly
-Selecting the best model for `vmanomaly` depends on the data's nature and the [types of anomalies](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-2/#categories-of-anomalies) to detect. For instance, [Z-score](https://docs.victoriametrics.com/anomaly-detection/components/models#z-score) is suitable for data without trends or seasonality, while more complex patterns might require models like [Prophet](https://docs.victoriametrics.com/anomaly-detection/components/models#prophet).
+Selecting the best model for `vmanomaly` depends on the data's nature and the [types of anomalies](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-2/#categories-of-anomalies) to detect. For instance, [Z-score](https://docs.victoriametrics.com/anomaly-detection/components/models#online-z-score) is suitable for data without trends or seasonality, while more complex patterns might require models like [Prophet](https://docs.victoriametrics.com/anomaly-detection/components/models#prophet).
 
-Also, it's possible to auto-tune the most important params of selected model class {{% available_from "v1.12.0" anomaly %}}, find [the details here](https://docs.victoriametrics.com/anomaly-detection/components/models#autotuned).
+Also, there is an option to auto-tune the most important (hyper)parameters of selected model class {{% available_from "v1.12.0" anomaly %}}, find [the details here](https://docs.victoriametrics.com/anomaly-detection/components/models#autotuned).
 
 Please refer to [respective blogpost on anomaly types and alerting heuristics](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-2/) for more details.
 
 Still not 100% sure what to use? We are [here to help](https://docs.victoriametrics.com/anomaly-detection/#get-in-touch).
 
+## Incorporating domain knowledge
+
+Anomaly detection models can significantly improve when incorporating business-specific assumptions about the data and what constitutes an anomaly. `vmanomaly` supports various [business-side configuration parameters](https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args) across all built-in models to **reduce [false positives](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#false-positive)** and **align model behavior with business needs**, for example:
+
+- **Setting `detection_direction`** – use [`detection_direction`](https://docs.victoriametrics.com/anomaly-detection/components/models/#detection-direction) to specify whether anomalies occur **above or below expectations**:
+  - Set to `above_expected` for metrics like error rates, where spikes indicate anomalies.
+  - Set to `below_expected` for metrics like customer satisfaction scores or SLAs, where drops indicate anomalies.
+
+- **Defining a `data_range`** – configure [`data_range`](https://docs.victoriametrics.com/anomaly-detection/components/reader/?highlight=data_range#config-parameters) for the model’s input query to **automatically assign anomaly scores > 1** for values (`y`) that fall outside the defined range.
+
+- **Filtering minor fluctuations with `min_dev_from_expected`** – use [`min_dev_from_expected`](https://docs.victoriametrics.com/anomaly-detection/components/models/#minimal-deviation-from-expected) to **ignore insignificant deviations** and prevent small fluctuations from triggering [false positives](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#false-positive).
+
+- **Applying `scale` for asymmetric confidence adjustments** – use [`scale`](https://docs.victoriametrics.com/anomaly-detection/components/models/#scale) to adjust confidence intervals **differently for spikes and drops**, ensuring more appropriate anomaly detection.
+
+**Example:**
+
+Consider a metric tracking the percentage of HTTP 4xx status codes for a specific endpoint. Hypothetical business expectations for anomaly detection may be defined as follows:
+
+- **Expected data range**: The percentage naturally falls between `0%` and `100%` (`[0, 1]`).
+- **Threshold-based anomaly detection**: If the error rate exceeds `5%`, it should be **automatically flagged as an anomaly** ([anomaly score](#what-is-anomaly-score) > 1), encouraging an incident investigation.
+- **Regime shift detection**: A **continuous increase** in error rates (e.g., from `1.5%` to `3%`) should also be considered **anomalous**, as regime change may indicate underlying system problem, e.g. with a new release.
+- **Avoiding false positives**: **Small, infrequent deviations** (e.g., from `1%` to `1.3%`) should **not** trigger alerts to **prevent unnecessary SRE escalations**. Let it be on the level of 0.5%.
+
+Then, the following config may be used to benefit from incorporating domain knowledge into model behavior:
+
+```yaml
+# other sections, like writer, monitoring ...
+schedulers:
+  periodic_http:
+    class: periodic
+    fit_every: 12w
+    fit_window: 1w
+    infer_every: 1m
+  # other schedulers ...
+reader:
+  # other reader args, like datasource_url, tenant_id ...
+  queries:
+    percentage_4xx:
+      expr: respective_metricsQL_expr
+      data_range: [0, 0.05]  # to automatically trigger anomaly score > 1 for error rates > 5%
+      step: 1m
+models:
+  # other models ...
+  zscore:  # let it be online Z-score, for simplicity
+    class: zscore_online  # online model update itself each infer call, resulting in resource-efficient setups
+    z_threshold: 3.0
+    schedulers: ['periodic_http']
+    queries: ['percentage_4xx']
+    detection_direction: 'above_expected'  # as interested only in spikes, drops are OK
+    min_dev_from_expected: 0.005  # <0.5% deviations vs expected values should be neglected, generating anomaly score == 0
+    # to align predictions to be within [0, 5%] interval, defined in reader.queries.percentage_4xx.data_range
+    clip_predictions: True
+    # specify output series produced by vmanomaly to be written to VictoriaMetrics in `writer`
+    provide_series: ['anomaly_score', 'y', 'yhat', 'yhat_lower', 'yhat_upper']
+```
+
 ## Alert generation in vmanomaly
-While `vmanomaly` detects anomalies and produces scores, it *does not directly generate alerts*. The anomaly scores are written back to VictoriaMetrics, where an external alerting tool, like [`vmalert`](https://docs.victoriametrics.com/vmalert), can be used to create alerts based on these scores for integrating it with your alerting management system.
+While `vmanomaly` detects anomalies and produces scores, it *does not directly generate alerts*. The anomaly scores are written back to VictoriaMetrics, where respective alerting tool, like [`vmalert`](https://docs.victoriametrics.com/vmalert), can be used to create alerts based on these scores for integrating it with your alerting management system. See an example diagram of how `vmanomaly` integrates into observability pipeline for anomaly detection on `node_exporter` metrics:
+
+<img src="https://docs.victoriametrics.com/anomaly-detection/guides/guide-vmanomaly-vmalert/guide-vmanomaly-vmalert_overview.webp" alt="node_exporter_example_diagram" style="width:60%"/>
 
 ## Preventing alert fatigue
 Produced anomaly scores are designed in such a way that values from 0.0 to 1.0 indicate non-anomalous data, while a value greater than 1.0 is generally classified as an anomaly. However, there are no perfect models for anomaly detection, that's why reasonable defaults expressions like `anomaly_score > 1` may not work 100% of the time. However, anomaly scores, produced by `vmanomaly` are written back as metrics to VictoriaMetrics, where tools like [`vmalert`](https://docs.victoriametrics.com/vmalert) can use [MetricsQL](https://docs.victoriametrics.com/metricsql/) expressions to fine-tune alerting thresholds and conditions, balancing between avoiding [false negatives](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#false-negative) and reducing [false positives](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#false-positive).
@@ -166,7 +224,7 @@ services:
   # ...
   vmanomaly:
     container_name: vmanomaly
-    image: victoriametrics/vmanomaly:v1.19.2
+    image: victoriametrics/vmanomaly:v1.20.0
     # ...
     ports:
       - "8490:8490"
@@ -339,7 +397,7 @@ For **horizontal** scalability, `vmanomaly` can be deployed as multiple independ
 
 - Splitting by **queries** [defined in the reader section](https://docs.victoriametrics.com/anomaly-detection/components/reader#vm-reader) and assigning each subset to a separate service instance should be used when having *a single query returning a large number of timeseries*. This can be further split by applying global MetricsQL filters using the `extra_filters` [parameter in the reader](https://docs.victoriametrics.com/anomaly-detection/components/reader?highlight=extra_filters#vm-reader). See example below.
 
-- Spliting by **models** should be used when running multiple models on the same query. This is commonly done to reduce false positives by alerting only if multiple models detect an anomaly. See the `queries` argument in the [model configuration](https://docs.victoriametrics.com/anomaly-detection/components/models#queries). Additionally, this approach is useful when you just have a large set of resource-intensive independent models.
+- Spliting by **models** should be used when running multiple models on the same query. This is commonly done to reduce [false positives](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#false-positive) by alerting only if multiple models detect an anomaly. See the `queries` argument in the [model configuration](https://docs.victoriametrics.com/anomaly-detection/components/models#queries). Additionally, this approach is useful when you just have a large set of resource-intensive independent models.
 
 - Splitting by **schedulers** should be used when the same models needs to be trained or inferred under different schedules. Refer to the `schedulers` argument in the [model section](https://docs.victoriametrics.com/anomaly-detection/components/models#schedulers) and the `scheduler` [component documentation](https://docs.victoriametrics.com/anomaly-detection/components/scheduler).
 
@@ -373,7 +431,7 @@ options:
 Here’s an example of using the config splitter to divide configurations based on the `extra_filters` argument from the reader section:
 
 ```sh
-docker pull victoriametrics/vmanomaly:v1.19.2 && docker image tag victoriametrics/vmanomaly:v1.19.2 vmanomaly
+docker pull victoriametrics/vmanomaly:v1.20.0 && docker image tag victoriametrics/vmanomaly:v1.20.0 vmanomaly
 ```
 
 ```sh

docs/anomaly-detection/QuickStart.md

@@ -1,15 +1,17 @@
 ---
 weight: 1
-title: VictoriaMetrics Anomaly Detection Quick Start
+title: Quick Start
 menu:
   docs:
     parent: "anomaly-detection"
+    identifier: "vmanomaly-quick-start"
     weight: 1
     title: Quick Start
 aliases:
 - /anomaly-detection/QuickStart.html
 ---
 For a broader overview please visit the [navigation page](https://docs.victoriametrics.com/anomaly-detection/).
+
 ## How to install and run vmanomaly
 
 > To run `vmanomaly`, you need to have VictoriaMetrics Enterprise license. You can get a trial license key [**here**](https://victoriametrics.com/products/enterprise/trial/).
@@ -19,15 +21,13 @@ The following options are available:
 - [To run Docker image](#docker)
 - [To run in Kubernetes with Helm charts](#kubernetes-with-helm-charts)
 
-> **Note**: Starting from [v1.13.0](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1130) there is a mode to keep anomaly detection models on host filesystem after `fit` stage (instead of keeping them in-memory by default); This may lead to **noticeable reduction of RAM used** on bigger setups. See instructions [here](https://docs.victoriametrics.com/anomaly-detection/faq/#on-disk-mode).
-
-> **Note**: Starting from [v1.16.0](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1160), a similar optimization is available for data read from VictoriaMetrics TSDB. See instructions [here](https://docs.victoriametrics.com/anomaly-detection/faq/#on-disk-mode).
+> **Note**: There is a mode {{% available_from "v1.13.0" anomaly %}} to keep anomaly detection models on host filesystem after `fit` stage (instead of keeping them in-memory by default); This may lead to **noticeable reduction of RAM used** on bigger setups. Similar optimization {{% available_from "v1.16.0" anomaly %}} can be set for data read from VictoriaMetrics TSDB. See instructions [here](https://docs.victoriametrics.com/anomaly-detection/faq/#on-disk-mode).
 
 ### Command-line arguments
 
 The `vmanomaly` service supports several command-line arguments to configure its behavior, including options for licensing, logging levels, and more. These arguments can be passed when starting the service via Docker or any other setup. Below is the list of available options:
 
-> **Note**: Starting from [v1.18.5](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1185) `vmanomaly` support running on config *directories*, see the `config` positional arg description in help message below.
+> **Note**: `vmanomaly` support {{% available_from "v1.18.5" anomaly %}} running on config *directories*, see the `config` positional arg description in help message below.
 
 ```shellhelp
 usage: vmanomaly.py [-h] [--license STRING | --licenseFile PATH] [--license.forceOffline] [--loggerLevel {INFO,DEBUG,ERROR,WARNING,FATAL}] [--watch] config [config ...]
@@ -51,6 +51,7 @@ options:
 ```
 
 You can specify these options when running `vmanomaly` to fine-tune logging levels or handle licensing configurations, as per your requirements.
+
 ### Licensing
 
 The license key can be passed via the following command-line flags: `--license`, `--licenseFile`, `--license.forceOffline`
@@ -94,20 +95,29 @@ groups:
 ```
 ### Docker
 
-> To run `vmanomaly`, you need to have VictoriaMetrics Enterprise license. You can get a trial license key [**here**](https://victoriametrics.com/products/enterprise/trial/).
+> To run `vmanomaly`, you need to have VictoriaMetrics Enterprise license. You can get a trial license key [**here**](https://victoriametrics.com/products/enterprise/trial/). <br><br>
+> Due to the upcoming [DockerHub pull limits](https://docs.docker.com/docker-hub/usage/pulls), an additional image registry, **Quay.io**, has been introduced for VictoriaMetrics images, including [`vmanomaly`](https://quay.io/repository/victoriametrics/vmanomaly). If you encounter pull rate limits, switch from:  
+> ```
+> docker pull victoriametrics/vmanomaly:vX.Y.Z
+> ```
+> to:  
+> ```
+> docker pull quay.io/victoriametrics/vmanomaly:vX.Y.Z
+> ```
+
 
 Below are the steps to get `vmanomaly` up and running inside a Docker container:
 
 1. Pull Docker image:
 
 ```sh
-docker pull victoriametrics/vmanomaly:v1.19.2
+docker pull victoriametrics/vmanomaly:v1.20.0
 ```
 
 2. (Optional step) tag the `vmanomaly` Docker image:
 
 ```sh
-docker image tag victoriametrics/vmanomaly:v1.19.2 vmanomaly
+docker image tag victoriametrics/vmanomaly:v1.20.0 vmanomaly
 ```
 
 3. Start the `vmanomaly` Docker container with a *license file*, use the command below.
@@ -141,7 +151,7 @@ docker run -it --user 1000:1000 \
 services:
   # ...
   vmanomaly:
-    image: victoriametrics/vmanomaly:v1.19.2
+    image: victoriametrics/vmanomaly:v1.20.0
     volumes:
         $YOUR_LICENSE_FILE_PATH:/license
         $YOUR_CONFIG_FILE_PATH:/config.yml
@@ -165,6 +175,10 @@ See also:
 
 > To run `vmanomaly`, you need to have VictoriaMetrics Enterprise license. You can get a trial license key [**here**](https://victoriametrics.com/products/enterprise/trial/).
 
+> With the forthcoming [DockerHub pull limits](https://docs.docker.com/docker-hub/usage/pulls) additional image registry was introduced (quay.io) for VictoriaMetric images, [vmanomaly images in particular](https://quay.io/repository/victoriametrics/vmanomaly).
+If hitting pull limits, try switching your `docker pull quay.io/victoriametrics/vmanomaly:vX.Y.Z` to `docker pull quay.io/victoriametrics/vmanomaly:vX.Y.Z`
+```
+
 You can run `vmanomaly` in Kubernetes environment
 with [these Helm charts](https://github.com/VictoriaMetrics/helm-charts/blob/master/charts/victoria-metrics-anomaly/README.md).
 
@@ -219,20 +233,22 @@ writer:
 ### Recommended steps
 
 **Schedulers**:
-- Define how often to run and make inferences in the [scheduler](https://docs.victoriametrics.com/anomaly-detection/components/scheduler/) section of a config file.
+- Configure the **inference frequency** in the [scheduler](https://docs.victoriametrics.com/anomaly-detection/components/scheduler/) section of the configuration file.  
+- Ensure that `infer_every` aligns with your **minimum required alerting frequency**.  
+  - For example, if receiving **alerts every 15 minutes** is sufficient (when `anomaly_score > 1`), set `infer_every` to match `reader.sampling_period` or override it per query via `reader.queries.query_xxx.step` for an optimal setup.  
 
 **Reader**:
-- Setup the datasource to read data from in the [reader](https://docs.victoriametrics.com/anomaly-detection/components/reader/) section. Include tenant ID if using a [cluster version of VictoriaMetrics](https://docs.victoriametrics.com/cluster-victoriametrics/) for reading the data.
-- Define queries for input data using [MetricsQL](https://docs.victoriametrics.com/metricsql/) under `reader.queries` section.
+- Setup the datasource to read data from in the [reader](https://docs.victoriametrics.com/anomaly-detection/components/reader/) section. Include tenant ID if using a [cluster version of VictoriaMetrics](https://docs.victoriametrics.com/cluster-victoriametrics/) (`multitenant` value {{% available_from "v1.16.2" anomaly %}} can be also used here).
+- Define queries for input data using [MetricsQL](https://docs.victoriametrics.com/metricsql/) under `reader.queries` section. Note, it's possible to override reader-level arguments at query level for increased flexibility, e.g. specifying per-query timezone, data frequency, data range, etc.
 
 **Writer**:
 - Specify where and how to store anomaly detection metrics in the [writer](https://docs.victoriametrics.com/anomaly-detection/components/writer/) section.
 - Include tenant ID if using a [cluster version of VictoriaMetrics](https://docs.victoriametrics.com/cluster-victoriametrics/) for writing the results.
-- Adding `for` label to `metric_format` argument is recommended for smoother visual experience in the [anomaly score dashboard](https://docs.victoriametrics.com/anomaly-detection/presets/#default).
+- Adding `for` label to `metric_format` argument is recommended for smoother visual experience in the [anomaly score dashboard](https://docs.victoriametrics.com/anomaly-detection/presets/#default). Please refer to `metric_format` argument description [here](https://docs.victoriametrics.com/anomaly-detection/components/writer/?highlight=metric_format#config-parameters).
 
 **Models**:
-- Configure built-in models parameters according to your needs in the [models](https://docs.victoriametrics.com/anomaly-detection/components/models/) section. 
-- (Optionally) Develop or integrate your [custom models](https://docs.victoriametrics.com/anomaly-detection/components/models/#custom-model-guide) with `vmanomaly`.
+- Configure built-in models parameters according to your needs in the [models](https://docs.victoriametrics.com/anomaly-detection/components/models/) section. Where possible, incorporate [domain knowledge](https://docs.victoriametrics.com/anomaly-detection/faq/#incorporating-domain-knowledge) for optimal results.
+- (Optional) Develop or integrate your [custom models](https://docs.victoriametrics.com/anomaly-detection/components/models/#custom-model-guide) with `vmanomaly`.
 - Adding `y` to `provide_series` arg values is recommended for smoother visual experience in the [anomaly score dashboard](https://docs.victoriametrics.com/anomaly-detection/presets/#default). Also, other `vmanomaly` [output](https://docs.victoriametrics.com/anomaly-detection/components/models#vmanomaly-output) can be used in `provide_series`. <br>**Note:** Only [univariate models](https://docs.victoriametrics.com/anomaly-detection/components/models/#univariate-models) support the generation of such output.
 
 ## Check also

docs/anomaly-detection/README.md

@@ -1,41 +1,68 @@
-In the dynamic and complex world of system monitoring, [VictoriaMetrics Anomaly Detection](https://victoriametrics.com/products/enterprise/anomaly-detection/) (or shortly, `vmanomaly`), being a part of our [Enterprise offering](https://victoriametrics.com/products/enterprise/), stands as a pivotal tool for achieving advanced observability. It empowers SREs and DevOps teams by automating the identification of abnormal behavior in time-series data. It goes beyond traditional threshold-based alerting, utilizing machine learning techniques to not only detect anomalies but also minimize false positives, thus reducing alert fatigue. By providing simplified alerting mechanisms atop of [unified anomaly scores](https://docs.victoriametrics.com/anomaly-detection/components/models/#vmanomaly-output), it enables teams to spot and address potential issues faster, ensuring system reliability and operational efficiency.
+In today's fast-paced and complex landscape of system monitoring, [VictoriaMetrics Anomaly Detection](https://victoriametrics.com/products/enterprise/anomaly-detection/) (`vmanomaly`), part of our [Enterprise offering](https://victoriametrics.com/products/enterprise/), serves as a **powerful observability tool** for SREs and DevOps teams. It **automates the detection of anomalies in time-series data**, reducing manual efforts required to identify abnormal system behavior.
+
+Unlike traditional threshold-based alerting, which relies on **raw metric values** and requires constant tuning and maintenance of thresholds and alerting rules, `vmanomaly` introduces a **unified, interpretable [anomaly score](https://docs.victoriametrics.com/anomaly-detection/faq/#what-is-anomaly-score)** - a **de-trended, de-seasonalized metric** generated through machine learning. This approach eliminates the need for frequent manual adjustments by enabling **stable, long-term static thresholds (as simple as `anomaly_score > 1`)** that remain effective over time through continuous model retraining.
+
+By shifting to anomaly-based detection, teams can **identify and respond to potential issues faster**, enhancing system reliability and operational efficiency while significantly **reducing the engineering effort spent on maintaining alerting rules**.
+
 
 ## What does it do?
-- Designed to periodically scan new data points across selected metrics, it forecasts unified [anomaly scores](https://docs.victoriametrics.com/anomaly-detection/faq/#what-is-anomaly-score).
-- Scores are recorded back to VictoriaMetrics TSDB for utilization in subsequent applications, such as alerting services.
-- Simplified alerting rules can be established and observability insights received, enhancing your operational efficiency.
+
+`vmanomaly` is designed to **periodically analyze new data points** across selected metrics, generating a **unified metric** called [anomaly score](https://docs.victoriametrics.com/anomaly-detection/faq/#what-is-anomaly-score). 
+
+Key functions:
+- **Automated anomaly detection** – continuously scans time-series data to identify deviations from expected behavior.
+- **Seamless integration** – anomaly scores are stored in VictoriaMetrics TSDB for use in **alerting, visualization, and downstream analytics**.
+
+The diagram below illustrates how `vmanomaly` fits into an observability setup, such as detecting anomalies in metrics collected by `node_exporter`:
+
+<img src="https://docs.victoriametrics.com/anomaly-detection/guides/guide-vmanomaly-vmalert/guide-vmanomaly-vmalert_overview.webp" alt="node_exporter_example_diagram" style="width:60%"/>
 
 ## How does it work?
-At its core, VictoriaMetrics Anomaly Detection autonomously re-trains either pre-defined machine learning models or custom models tailored to your business needs on your data.
 
-- ML models are employed to calculate anomaly scores for newly collected data points, as per a predefined schedule.
-- Alerts can be triggered based on simplified thresholds (i.e. anomaly_score > 1) that simplify and automate your observability setup.
-- Ongoing evaluations, presented either as specific point estimates or as ranges of confidence intervals, are designed to integrate seamlessly with downstream applications.
+VictoriaMetrics Anomaly Detection **continuously re-fit and apply machine learning models** - either [built-in](https://docs.victoriametrics.com/anomaly-detection/components/models/#built-in-models) or [custom](https://docs.victoriametrics.com/anomaly-detection/components/models/#custom-model-guide), specific to your business needs — on your [input](https://docs.victoriametrics.com/anomaly-detection/components/reader) data. This ensures that the default cut-off threshold (`anomaly score == 1`), which differentiates **normal** (`≤ 1`) from **anomalous** (`> 1`) data points, remains **relevant over time**.
 
-## Practical Guides and Installation
+- **Automated anomaly scoring** - ML models calculate [anomaly scores](https://docs.victoriametrics.com/anomaly-detection/faq/#what-is-anomaly-score) for new data points based on a predefined [schedule](https://docs.victoriametrics.com/anomaly-detection/components/scheduler/).
+- **Simplified alerting** - alerts can be triggered using **straightforward thresholds** (e.g., `anomaly_score > 1`), reducing complexity in observability setups.
+- **Additional model outputs** - beyond anomaly scores, models provide [supplementary outputs](https://docs.victoriametrics.com/anomaly-detection/components/models/#vmanomaly-output), including:
+  - **Point estimates** (`yhat`)  
+  - **Confidence intervals** (`[yhat_lower, yhat_upper]`)  
+  These outputs integrate seamlessly into downstream applications, making it easier to **visually inspect anomalies**, e.g. in respective [Grafana dashboards](https://docs.victoriametrics.com/anomaly-detection/presets/#grafana-dashboard).
 
-Get started with VictoriaMetrics Anomaly Detection efficiently by following our guides and installation options:
+<img src="https://docs.victoriametrics.com/anomaly-detection/components/vmanomaly-components.webp" alt="node_exporter_example_diagram" style="width:80%"/>
+
+## Key benefits
+
+`vmanomaly` is designed to **reduce MTTR (Mean Time to Resolution)** in observability workflows by **automating anomaly detection** and **eliminating the need for manual threshold tuning**. It is particularly beneficial for:
+
+- **Reducing alerting rule maintenance** – shifts from manually maintaining static thresholds on raw metric values to a **stable anomaly score threshold** that remains **reliable and interpretable over time**.
+  
+- **Handling complex metrics** – effectively detects anomalies in **trending, seasonal, or dynamically scaling data**, where **fixed thresholds and simpler models usually fail**.
+
+- **Detecting anomalies in interconnected metrics** – supports **[multivariate anomaly detection](http://docs.victoriametrics.com/anomaly-detection/components/models#multivariate-models)**, identifying patterns across **related metrics** instead of treating them in isolation as [univariate metrics](http://docs.victoriametrics.com/anomaly-detection/components/models#univariate-models).
+
+## Practical guides and installation
+
+Get started with VictoriaMetrics Anomaly Detection by following our guides and installation options:
 
 - **Quickstart**: Learn how to quickly set up `vmanomaly` by following the [Quickstart Guide](https://docs.victoriametrics.com/anomaly-detection/quickstart/).
 - **Integration**: Integrate anomaly detection into your existing observability stack. Find detailed steps [here](https://docs.victoriametrics.com/anomaly-detection/guides/guide-vmanomaly-vmalert/).
-- **Anomaly Detection Presets**: Enable anomaly detection on predefined sets of metrics that require frequent static threshold changes for alerting. Learn more [here](https://docs.victoriametrics.com/anomaly-detection/presets/).
+- **Anomaly Detection Presets**: Enable anomaly detection on predefined sets of metrics. Learn more [here](https://docs.victoriametrics.com/anomaly-detection/presets/).
 
 - **Installation Options**: Choose the installation method that best fits your infrastructure:
     - **Docker Installation**: Ideal for containerized environments. Follow the [Docker Installation Guide](https://docs.victoriametrics.com/anomaly-detection/quickstart/#docker).
     - **Helm Chart Installation**: Recommended for Kubernetes deployments. See our [Helm charts](https://github.com/VictoriaMetrics/helm-charts/tree/master/charts/victoria-metrics-anomaly).
 
-- **Self-Monitoring**: Ensure `vmanomaly` is functioning optimally with built-in self-monitoring capabilities. Use the provided Grafana dashboards and alerting rules to track service health and operational metrics. Find the complete docs [here](https://docs.victoriametrics.com/anomaly-detection/self-monitoring/).
+- **Self-Monitoring**: Ensure `vmanomaly` is functioning optimally, using provided Grafana dashboards and alerting rules to track service health and operational metrics. Find the guide [here](https://docs.victoriametrics.com/anomaly-detection/self-monitoring/).
 
 > **Note**: starting from [v1.5.0](https://docs.victoriametrics.com/anomaly-detection/changelog/#v150) `vmanomaly` requires a [license key](https://docs.victoriametrics.com/anomaly-detection/quickstart/#licensing) to run. You can obtain a trial license key [**here**](https://victoriametrics.com/products/enterprise/trial/).
 
 ## Key Components
-Explore the integral components that configure VictoriaMetrics Anomaly Detection:
-* [Explore components and their interation](https://docs.victoriametrics.com/anomaly-detection/components/)
-    - [Models](https://docs.victoriametrics.com/anomaly-detection/components/models/)
-    - [Reader](https://docs.victoriametrics.com/anomaly-detection/components/reader/)
-    - [Scheduler](https://docs.victoriametrics.com/anomaly-detection/components/scheduler/)
-    - [Writer](https://docs.victoriametrics.com/anomaly-detection/components/writer/)
-    - [Monitoring](https://docs.victoriametrics.com/anomaly-detection/components/monitoring/)
+Explore the [integral components](https://docs.victoriametrics.com/anomaly-detection/components/) that define VictoriaMetrics Anomaly Detection:
+- [Models](https://docs.victoriametrics.com/anomaly-detection/components/models/)
+- [Reader](https://docs.victoriametrics.com/anomaly-detection/components/reader/)
+- [Scheduler](https://docs.victoriametrics.com/anomaly-detection/components/scheduler/)
+- [Writer](https://docs.victoriametrics.com/anomaly-detection/components/writer/)
+- [Monitoring](https://docs.victoriametrics.com/anomaly-detection/components/monitoring/)
 
 ## Deep Dive into Anomaly Detection
 Enhance your knowledge with our handbook on Anomaly Detection & Root Cause Analysis and stay updated:

docs/anomaly-detection/_index.md

@@ -1,5 +1,5 @@
 ---
-title: VictoriaMetrics Anomaly Detection
+title: Anomaly Detection
 weight: 50
 menu:
   docs:

docs/anomaly-detection/components/models.md

@@ -226,7 +226,7 @@ models:
     queries: ['normal_behavior']  # use the default where it's not needed
 ```
 
-### Group By
+### Group by
 
 > **Note**: The `groupby` argument works only in combination with [multivariate models](#multivariate-models).
 
@@ -264,6 +264,135 @@ models:
     groupby: [host]
 ```
 
+### Scale
+
+Previously available only to [ProphetModel](#prophet) and [OnlineQuantileModel](#online-seasonal-quantile),  the `scale` {{% available_from "v1.20.0" anomaly %}} parameter is now applicable to all models that support generating predictions (`yhat`, `yhat_lower`, `yhat_upper`). Also, it is **two-sided** now, represented as a list of two positive float values, allowing separate scaling for the intervals `[yhat, yhat_upper]` and `[yhat_lower, yhat]`. The new margins are calculated as:
+
+- **Upper margin:** `|yhat_upper - yhat| * scale_upper`
+- **Lower margin:** `|yhat - yhat_lower| * scale_lower`
+
+For backward compatibility, the previous format (`scale: x`) remains supported and will be automatically converted to `scale: [x, x]`.
+
+For example, setting `scale: [1.2, 0.75]` for particular model will:
+- **Increase** the width of the lower confidence interval by **20%**.
+- **Decrease** the width of the upper confidence boundary by **25%**.
+
+The most common **use case** is when there is a preference to **widen one side** to blacklist smaller false positives (which otherwise would have [anomaly scores](https://docs.victoriametrics.com/anomaly-detection/faq/#how-is-anomaly-score-calculated) **only slightly higher than 1.0**, still making such data points **anomalous**), while **tightening the other side** to avoid missing true positives due to an overly loose margin (leading to [anomaly scores](https://docs.victoriametrics.com/anomaly-detection/faq/#how-is-anomaly-score-calculated) being slightly less than 1.0, making such data points **non-anomalous**).
+
+```yaml
+# other components like reader, writer, schedulers, monitoring ...
+models:
+  zscore_no_scale:
+    class: 'zscore' # or 'model.zscore.ZscoreModel' until v1.13.0
+    z_threshold: 3
+    # if not set, equals to [1.0, 1.0], meaning no scaling is applied
+    # scale: [1.0, 1.0]
+  zscore_scaled:
+    class: 'zscore' # or 'model.zscore.ZscoreModel' until v1.13.0
+    z_threshold: 3
+    # vs `zscore_no_scale`, increase lower confidence interval width by 1.2x, decrease upper confidence width by 25%
+    scale: [1.2, 0.75]
+```
+
+### Clip predictions
+
+A post-processing step to **clip model predictions** (`yhat`, `yhat_lower`, and `yhat_upper` series) to the configured [`data_range` values](https://docs.victoriametrics.com/anomaly-detection/components/reader/?highlight=data_range#config-parameters) in `VmReader` is available.
+
+This behavior is controlled by the boolean argument `clip_predictions` {{% available_from "v1.20.0" anomaly %}}:
+- **Disabled by default** for backward compatibility.
+- **Works** for models that generate predictions and estimates (e.g., [`ProphetModel`](#prophet)) by setting `clip_predictions` to `True` for respective model in `models` section.
+
+The primary use case is to **align domain knowledge** about data behavior (defined via `data_range`) with what is shown in visualizations, such as in the [Grafana dashboard](https://docs.victoriametrics.com/anomaly-detection/presets/#grafana-dashboard). This ensures that predictions (`yhat`, `yhat_lower`, `yhat_upper`) are plotted consistently alongside real metric values (`y`) and remain within reasonable expected bounds.
+
+> Note: This parameter does not impact the generation of anomaly scores > 1 for datapoints where `y` falls outside the defined `data_range`.
+
+```yaml
+# other components like writer, schedulers, monitoring ...
+reader:
+  # ...
+  queries:
+    q1_clipped: 
+      expr: 'q1_metricsql'
+      data_range: [0, "inf"]
+    q2_no_clip:
+      expr: 'q2_metricsql'
+      # if no data range defined, it will be implicitly converted to ["-inf", "inf"]
+models:
+  zscore_mixed:
+    class: 'zscore' # or 'model.zscore.ZscoreModel' until v1.13.0
+    z_threshold: 3
+    clip_predictions: True
+    queries: [
+      # `yhat`, `yhat_lower`, `yhat_upper` will be within [0, inf]
+      # for all `zscore_mixed` instances that are fit on series returned by `q1_clipped` query
+      # anomaly scores > 1 will still be produced for `y` outside of data_range
+      'q1_clipped',
+      # there will be no (explicit) clip of `yhat`, `yhat_lower`, `yhat_upper`
+      # for all `zscore_mixed` instances that are fit on series returned by `q2_no_clip` query
+      # even when `clip_predictions` arg is set, because data_range was not set for `q2_no_clip`
+      'q2_no_clip',
+    ]
+  zscore_no_clip:
+    class: 'zscore' # or 'model.zscore.ZscoreModel' until v1.13.0
+    z_threshold: 3
+    # if not set, by default resolved to `clip_predictions: False`
+    queries: [
+      # `yhat`, `yhat_lower`, `yhat_upper` won't be clipped to [0, inf] 
+      # even though `data_range` for `q1_clipped` is set
+      # however, anomaly scores > 1 will still be produced for y outside of data_range
+      'q1_clipped',
+      # there will be no (explicit) clip of yhat, yhat_lower, yhat_upper  
+      # for all `zscore_mixed` instances that are fit on series returned by `q2_no_clip` query
+      # as `clip_predictions` arg is not set, regardless of data_range for `q2_no_clip`
+      'q2_no_clip',
+    ]
+```
+
+### Score outside data range
+
+The `anomaly_score_outside_data_range` {{% available_from "v1.20.0" anomaly %}} parameter allows overriding the default **anomaly score (`1.01`)** assigned when actual values (`y`) fall **outside the defined `data_range` if defined in [reader](https://docs.victoriametrics.com/anomaly-detection/components/reader/)**. This provides greater flexibility for **alerting rule configurations** and enables **clearer visual differentiation** between different types of anomalies:
+
+- By default, `y` values **outside `data_range`** trigger an anomaly score of `1.01`, which serves as a basic alerting rule.
+- However, some users may require **higher anomaly scores** (e.g., `> 1.2`) to **trigger alerts reliably** in their monitoring setups.
+
+**How it works**
+- If **not set**, the **default value (`1.01`)** is used for backward compatibility.
+- If defined at the **service level** (`settings`), it applies to all models **unless overridden at the model level**.
+- If set **per model**, it takes **priority over the global setting**.
+
+**Example (override)**
+
+```yaml
+settings:
+  # other parameters ...
+  # all the models in `models` section will inherit this value unless overridden at the model level
+  anomaly_score_outside_data_range: 1.2
+
+models:
+  model_score_override:
+    class: 'zscore_online'
+    # explicitly set, takes priority over `settings`'s value
+    anomaly_score_outside_data_range: 1.5
+  model_score_from_settings_level:
+    class: 'zscore_online'
+    # inherits from `settings`, will be `1.2`, same as setting
+    # anomaly_score_outside_data_range: 1.2
+```
+
+**Example (default vs custom)**
+
+```yaml
+models:
+  model_default_score:
+    class: 'zscore_online'
+    # default anomaly score (1.01) is applied when y is outside data_range, same as setting
+    # anomaly_score_outside_data_range: 1.01
+  model_higher_out_of_data_range_score:
+    class: 'zscore_online'
+    # explicitly set, takes priority over `settings`'s value
+    anomaly_score_outside_data_range: 3.0  
+```
+
 
 ## Model types
 
@@ -276,7 +405,7 @@ Each of these models can be of type
 - [Rolling](#rolling-models)
 - [Non-rolling](#non-rolling-models)
 
-Moreover, starting from [v1.15.0](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1150), there exist **[online (incremental) models](#online-models)** subclass. Please refer to the [correspondent section](#online-models) for more details.
+Moreover, {{% available_from "v1.15.0" anomaly %}}, there exist **[online (incremental) models](#online-models)** subclass. Please refer to the [correspondent section](#online-models) for more details.
 
 ### Univariate Models
 
@@ -299,7 +428,7 @@ For a multivariate type, **one shared model** is fit/used for inference on **all
 
 For example, if you have some **multivariate** model to use 3 [MetricQL queries](https://docs.victoriametrics.com/metricsql/), each returning 5 time series, there will be one shared model created in total. Once fit, this model will expect **exactly 15 time series with exact same labelsets as an input**. This model will produce **one shared [output](#vmanomaly-output)**.
 
-> **Note:** Starting from [v1.16.0](https://docs.victoriametrics.com/anomaly-detection/changelog#v1160), N models — one for each unique combination of label values specified in the `groupby` [common argument](#group-by) — can be trained. This allows for context separation (e.g., one model per host, region, or other relevant grouping label), leading to improved accuracy and faster training. See an example [here](#group-by).
+> **Note:** {{% available_from "v1.16.0" anomaly %}}, N models — one for each unique combination of label values specified in the `groupby` [common argument](#group-by) — can be trained. This allows for context separation (e.g., one model per host, region, or other relevant grouping label), leading to improved accuracy and faster training. See an example [here](#group-by).
 
 If during an inference, you got a **different amount of series** or some series having a **new labelset** (not present in any of fitted models), the inference will be skipped until you get a model, trained particularly for such labelset during forthcoming re-fit step. 
 
@@ -386,16 +515,16 @@ Every other model that isn't [online](#online-models). Offline models are comple
 ## Built-in Models 
 
 ### Overview
-VictoriaMetrics Anomaly Detection models support 2 groups of parameters:
+Built-in models support 2 groups of arguments:
 
 - **`vmanomaly`-specific** arguments - please refer to *Parameters specific for vmanomaly* and *Default model parameters* subsections for each of the models below.
-- Arguments to **inner model** (say, [Facebook's Prophet](https://facebook.github.io/prophet/docs/quick_start#python-api)), passed in a `args` argument as key-value pairs, that will be directly given to the model during initialization to allow granular control. Optional.
+- Arguments to **inner model** (say, [Facebook's Prophet](https://facebook.github.io/prophet/docs/quick_start#python-api)), passed inside `args` argument as key-value pairs, that will be directly given to the model during initialization to allow granular control. Optional.
 
 > **Note**: For users who may not be familiar with Python data types such as `list[dict]`, a [dictionary](https://www.w3schools.com/python/python_dictionaries.asp) in Python is a data structure that stores data values in key-value pairs. This structure allows for efficient data retrieval and management.
 
 
 **Models**:
-* [AutoTuned](#autotuned) - designed to take the cognitive load off the user, allowing any of built-in models below to be re-tuned for best params on data seen during each `fit` phase of the algorithm. Tradeoff is between increased computational time and optimized results / simpler maintenance.
+* [AutoTuned](#autotuned) - designed to take the cognitive load off the user, allowing any of built-in models below to be re-tuned for best hyperparameters on data seen during each `fit` phase of the algorithm. Tradeoff is between increased computational time and optimized results / simpler maintenance.
 * [Prophet](#prophet) - the most versatile one for production usage, especially for complex data ([trends](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#trend), [change points](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-2/#novelties), [multi-seasonality](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#seasonality))
 * [Z-score](#z-score) - useful for initial testing and for simpler data ([de-trended](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#trend) data without strict [seasonality](https://victoriametrics.com/blog/victoriametrics-anomaly-detection-handbook-chapter-1/#seasonality) and with anomalies of similar magnitude as your "normal" data)
 * [Online Z-score](#online-z-score) - [online](#online-models) alternative to [Z-score](#z-score) model with exact same behavior and use cases.
@@ -418,7 +547,7 @@ Tuning hyperparameters of a model can be tricky and often requires in-depth know
 * `tuned_class_name` (string) - Built-in model class to tune, i.e. `model.zscore.ZscoreModel` (or `zscore`with class alias support{{% available_from "v1.13.0" anomaly %}}).
 * `optimization_params` (dict) - Optimization parameters for unsupervised model tuning. Control % of found anomalies, as well as a tradeoff between time spent and the accuracy. The more `timeout` and `n_trials` are, the better model configuration can be found for `tuned_class_name`, but the longer it takes and vice versa. Set `n_jobs` to `-1` to use all the CPUs available, it makes sense if only you have a big dataset to train on during `fit` calls, otherwise overhead isn't worth it.
   - `anomaly_percentage` (float) - Expected percentage of anomalies that can be seen in training data, from (0, 0.5) interval.
-  - `optimized_business_params` (list[string]) - Starting from [v1.15.0](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1150) this argument allows particular business-specific parameters such as [`detection_direction`](https://docs.victoriametrics.com/anomaly-detection/components/models/#detection-direction) or [`min_dev_from_expected`](https://docs.victoriametrics.com/anomaly-detection/components/models/#minimal-deviation-from-expected) to remain **unchanged during optimizations, retaining their default values**. I.e. setting `optimized_business_params` to  `['detection_direction']` will allow to optimize only `detection_direction` business-specific arg, while `min_dev_from_expected` will retain its default value (0.0). By default and if not set, will be equal to `[]` (empty list), meaning no business params will be optimized. **A recommended option is to leave it empty** for more stable results and increased convergence (less iterations needed for a good result).
+  - `optimized_business_params` (list[string]) - {{% available_from "v1.15.0" anomaly %}} this argument allows particular business-specific parameters such as [`detection_direction`](https://docs.victoriametrics.com/anomaly-detection/components/models/#detection-direction) or [`min_dev_from_expected`](https://docs.victoriametrics.com/anomaly-detection/components/models/#minimal-deviation-from-expected) to remain **unchanged during optimizations, retaining their default values**. I.e. setting `optimized_business_params` to  `['detection_direction']` will allow to optimize only `detection_direction` business-specific arg, while `min_dev_from_expected` will retain its default value (0.0). By default and if not set, will be equal to `[]` (empty list), meaning no business params will be optimized. **A recommended option is to leave it empty** for more stable results and increased convergence (less iterations needed for a good result).
   - `seed` (int) - Random seed for reproducibility and deterministic nature of underlying optimizations.
   - `n_splits` (int) - How many folds to create for hyperparameter tuning out of your data. The higher, the longer it takes but the better the results can be. Defaults to 3.
   - `n_trials` (int) - How many trials to sample from hyperparameter search space. The higher, the longer it takes but the better the results can be. Defaults to 128.
@@ -453,19 +582,17 @@ models:
 ### [Prophet](https://facebook.github.io/prophet/)
 `vmanomaly` uses the Facebook Prophet implementation for time series forecasting, with detailed usage provided in the [Prophet library documentation](https://facebook.github.io/prophet/docs/quick_start#python-api). All original Prophet parameters are supported and can be directly passed to the model via `args` argument.
 
-
 > **Note**: `ProphetModel` is a [univariate](#univariate-models), [non-rolling](#non-rolling-models), [offline](#offline-models) model.
 
-
-> **Note**: Starting with [v1.18.2](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1182), the format for `tz_seasonalities` has been updated to enhance flexibility. Previously, it accepted a list of strings (e.g., `['hod', 'minute']`). Now, it follows the same structure as custom seasonalities defined in the `seasonalities` argument (e.g., `{"name": "hod", "fourier_order": 5, "mode": "additive"}`). This change is backward-compatible, so older configurations will be automatically converted to the new format using default values.
+> **Note**: {{% available_from "v1.18.2" anomaly %}} the format for `tz_seasonalities` has been updated to enhance flexibility. Previously, it accepted a list of strings (e.g., `['hod', 'minute']`). Now, it follows the same structure as custom seasonalities defined in the `seasonalities` argument (e.g., `{"name": "hod", "fourier_order": 5, "mode": "additive"}`). This change is backward-compatible, so older configurations will be automatically converted to the new format using default values.
 
 *Parameters specific for vmanomaly*:
 
 - `class` (string) - model class name `"model.prophet.ProphetModel"` (or `prophet` with class alias support{{% available_from "v1.13.0" anomaly %}})
 - `seasonalities` (list[dict], optional): Additional seasonal components to include in Prophet. See Prophet’s [`add_seasonality()`](https://facebook.github.io/prophet/docs/seasonality,_holiday_effects,_and_regressors#modeling-holidays-and-special-events:~:text=modeling%20the%20cycle-,Specifying,-Custom%20Seasonalities) documentation for details.
-- `scale`{{% available_from "v1.18.0" anomaly %}} (float): Is used to adjust the margin between `yhat` and [`yhat_lower`, `yhat_upper`]. New margin = `|yhat_* - yhat_lower| * scale`. Defaults to 1 (no scaling is applied).
+- `scale`{{% available_from "v1.18.0" anomaly %}} (float): Is used to adjust the margins between `yhat` and [`yhat_lower`, `yhat_upper`]. New margin = `|yhat_* - yhat_lower| * scale`. Defaults to 1 (no scaling is applied). See `scale`[common arg](https://docs.victoriametrics.com/anomaly-detection/components/models/#scale) section for detailed instructions and 2-sided option.
 - `tz_aware`{{% available_from "v1.18.0" anomaly %}} (bool): Enables handling of timezone-aware timestamps. Default is `False`. Should be used with `tz_seasonalities` and `tz_use_cyclical_encoding` parameters.
-- `tz_seasonalities`{{% available_from "v1.18.0" anomaly %}} (list[dict]): Specifies timezone-aware seasonal components. Requires `tz_aware=True`. Supported options include `minute`, `hod` (hour of day), `dow` (day of week), and `month` (month of year). Starting with [v1.18.2](https://docs.victoriametrics.com/anomaly-detection/changelog/#v1182), users can configure additional parameters for each seasonality, such as `fourier_order`, `prior_scale`, and `mode`. For more details, please refer to the **Timezone-unaware** configuration example below.
+- `tz_seasonalities`{{% available_from "v1.18.0" anomaly %}} (list[dict]): Specifies timezone-aware seasonal components. Requires `tz_aware=True`. Supported options include `minute`, `hod` (hour of day), `dow` (day of week), and `month` (month of year). {{% available_from "v1.18.2" anomaly %}} users can configure additional parameters for each seasonality, such as `fourier_order`, `prior_scale`, and `mode`. For more details, please refer to the **Timezone-unaware** configuration example below.
 - `tz_use_cyclical_encoding`{{% available_from "v1.18.0" anomaly %}} (bool): If set to `True`, applies [cyclical encoding technique](https://www.kaggle.com/code/avanwyk/encoding-cyclical-features-for-deep-learning) to timezone-aware seasonalities. Should be used with `tz_aware=True` and `tz_seasonalities`.
 
 > **Note**: Apart from standard [`vmanomaly` output](#vmanomaly-output), Prophet model can provide additional metrics.
@@ -489,6 +616,17 @@ models:
   your_desired_alias_for_a_model:
     class: 'prophet'  # or 'model.prophet.ProphetModel' until v1.13.0
     provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper', 'trend']
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper', 'trend']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
     seasonalities:
       - name: 'hourly'
         period: 0.04166666666
@@ -508,6 +646,17 @@ models:
   your_desired_alias_for_a_model:
     class: 'prophet'  # or 'model.prophet.ProphetModel' until v1.13.0
     provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper', 'trend']
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper', 'trend']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
     tz_aware: True
     tz_use_cyclical_encoding: True
     tz_seasonalities: # intra-day + intra-week seasonality, no intra-year / sub-hour seasonality
@@ -544,6 +693,17 @@ models:
   your_desired_alias_for_a_model:
     class: "zscore"  # or 'model.zscore.ZscoreModel' until v1.13.0
     z_threshold: 3.5
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -569,6 +729,17 @@ models:
     z_threshold: 3.5
     min_n_samples_seen: 128  # i.e. calculate it as full seasonality / data freq
     provide_series: ['anomaly_score', 'yhat']  # common arg example
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -614,6 +785,17 @@ models:
     args:
       seasonal: 'add'
       initialization_method: 'estimated'
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 
@@ -639,6 +821,17 @@ models:
   your_desired_alias_for_a_model:
     class: "mad"  # or 'model.mad.MADModel' until v1.13.0
     threshold: 2.5
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -668,6 +861,17 @@ models:
     min_n_samples_seen: 128  # i.e. calculate it as full seasonality / data freq
     compression: 100  # higher values mean higher accuracy but higher memory usage
     provide_series: ['anomaly_score', 'yhat']  # common arg example
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -693,6 +897,17 @@ models:
     class: "rolling_quantile" # or 'model.rolling_quantile.RollingQuantileModel' until v1.13.0
     quantile: 0.9
     window_steps: 96
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -716,7 +931,7 @@ It uses the `quantiles` triplet to calculate `yhat_lower`, `yhat`, and `yhat_upp
 * `min_subseason` (str, optional) - the minimum interval to estimate quantiles for. By default not set. Note that the minimum interval should be a multiple of the seasonal interval, i.e. if seasonal_interval='2h', then min_subseason='15m' is valid, but '37m' is not.
 * `use_transform` (bool, optional) - whether to internally apply a `log1p(abs(x)) * sign(x)` transformation to the data to stabilize internal quantile estimation. Does not affect the scale of produced output (i.e. `yhat`) By default False.
 * `global_smoothing` (float, optional) - the smoothing parameter for the global quantiles. i.e. the output is a weighted average of the global and seasonal quantiles (if `seasonal_interval` and `min_subseason` args are set). Should be from `[0, 1]` interval, where 0 means no smoothing and 1 means using only global quantile values.
-* `scale` (float, optional) - the scaling factor for the `yhat_lower` and `yhat_upper` quantiles. By default 1.0 (no scaling). if > 1, increases the boundaries [`yhat_lower`, `yhat_upper`] that define "non-anomalous" points. Should be > 0.
+* `scale` (float, optional) - Is used to adjust the margins between `yhat` and [`yhat_lower`, `yhat_upper`]. New margin = `|yhat_* - yhat_lower| * scale`. Defaults to 1 (no scaling is applied). See `scale`[common arg](https://docs.victoriametrics.com/anomaly-detection/components/models/#scale) section for detailed instructions and 2-sided option.
 * `season_starts_from` (str, optional) - the start date for the seasonal adjustment, as a reference point to start counting the intervals. By default '1970-01-01'.
 * `min_n_samples_seen` (int, optional) - the minimum number of samples to be seen (`n_samples_seen_` property) before computing the anomaly score. Otherwise, the **anomaly score will be 0**, as there is not enough data to trust the model's predictions. Defaults to 16.
 * `compression` (int, optional) - the compression parameter for the underlying [t-digests](https://www.sciencedirect.com/science/article/pii/S2665963820300403). Higher values mean higher accuracy but higher memory usage. By default 100.
@@ -737,6 +952,17 @@ models:
     season_starts_from: '2024-01-01'  # interval calculation starting point, especially for uncommon seasonalities like '36h' or '12d'
     compression: 100  # higher values mean higher accuracy but higher memory usage
     provide_series: ['anomaly_score', 'yhat']  # common arg example
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 Resulting metrics of the model are described [here](#vmanomaly-output).
@@ -763,6 +989,17 @@ models:
   your_desired_alias_for_a_model:
     class: "std"  # or 'model.std.StdModel' starting from v1.13.0
     period: 2
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # detection_direction: 'both'  # meaning both drops and spikes will be captured
+    # min_dev_from_expected: 0.0  # meaning, no minimal threshold is applied to prevent smaller anomalies
+    # scale: [1.0, 1.0]  # if needed, prediction intervals' width can be increased (>1) or narrowed (<1)
+    # clip_predictions: False  # if data_range for respective `queries` is set in reader, `yhat.*` columns will be clipped
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 
@@ -818,6 +1055,13 @@ models:
       n_estimators: 100
       # i.e. to assure reproducibility of produced results each time model is fit on the same input
       random_state: 42
+    # Common arguments for built-in model, if not set, default to
+    # See https://docs.victoriametrics.com/anomaly-detection/components/models/#common-args
+    #
+    # provide_series: ['anomaly_score', 'yhat', 'yhat_lower', 'yhat_upper']
+    # schedulers: [all scheduler aliases defined in `scheduler` section]
+    # queries: [all query aliases defined in `reader.queries` section]
+    # anomaly_score_outside_data_range: 1.01  # auto anomaly score (1.01) if `y` (real value) is outside of data_range, if set
 ```
 
 
@@ -994,7 +1238,7 @@ monitoring:
 Let's pull the docker image for `vmanomaly`:
 
 ```sh
-docker pull victoriametrics/vmanomaly:v1.19.2
+docker pull victoriametrics/vmanomaly:v1.20.0
 ```
 
 Now we can run the docker container putting as volumes both config and model file:
@@ -1008,7 +1252,7 @@ docker run -it \
 -v $(PWD)/license:/license \
 -v $(PWD)/custom_model.py:/vmanomaly/model/custom.py \
 -v $(PWD)/custom.yaml:/config.yaml \
-victoriametrics/vmanomaly:v1.19.2 /config.yaml \
+victoriametrics/vmanomaly:v1.20.0 /config.yaml \
 --licenseFile=/license
 ```
 

docs/anomaly-detection/guides/guide-vmanomaly-vmalert/README.md

@@ -387,7 +387,7 @@ services:
     restart: always
   vmanomaly:
     container_name: vmanomaly
-    image: victoriametrics/vmanomaly:v1.19.2
+    image: victoriametrics/vmanomaly:v1.20.0
     depends_on:
       - "victoriametrics"
     ports:

docs/changelog/CHANGELOG.md

@@ -19,6 +19,7 @@ See also [LTS releases](https://docs.victoriametrics.com/lts-releases/).
 ## tip
 
 **Update note 1: [vmsingle](https://docs.victoriametrics.com/single-server-victoriametrics/) and [vmagent](https://docs.victoriametrics.com/vmagent/) include a fix which enforces IPv6 addresses escaping for containers discovered with [Kubernetes service-discovery](https://docs.victoriametrics.com/sd_configs/#kubernetes_sd_configs) and `role: pod` which do not have exposed ports defined. This means that `address` for these containers will always be wrapped in square brackets, this might affect some relabeling rules which were relying on previous behaviour.**
+
 **Update note 2: [vmalert](https://docs.victoriametrics.com/vmalert/) disallow using [time buckets stats pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets) in alerting or recording rules with VictoriaLogs as datasource. Time buckets used with [stats query API](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats) may produce unexpected results for user and result into cardinality issues.**
 
 * FEATURE: upgrade Go builder from Go1.23.6 to Go1.24. See [Go1.24 release notes](https://tip.golang.org/doc/go1.24).
@@ -32,14 +33,18 @@ See also [LTS releases](https://docs.victoriametrics.com/lts-releases/).
 * FEATURE: [vmalert-tool](https://docs.victoriametrics.com/vmalert-tool/): add command-line flag `-httpListenPort` to specify the port used during testing. If not provided, a random unoccupied port will be assigned. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8393).
 * FEATURE: [vmalert-tool](https://docs.victoriametrics.com/vmalert-tool/): make the temporary storage path for unittest unique, allowing user to run multiple vmalert-tool processes on a single host simultaneously. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8393).
 * FEATURE: [vmalert](https://docs.victoriametrics.com/vmalert/): disallow using [time buckets stats pipe](https://docs.victoriametrics.com/victorialogs/logsql/#stats-by-time-buckets) in VictoriaLogs rule expressions. Such construction produces meaningless results for [stats query API](https://docs.victoriametrics.com/victorialogs/querying/#querying-log-stats) and may lead to cardinality issues.
+* FEATURE: [data ingestion](https://docs.victoriametrics.com/victorialogs/data-ingestion/): make `KeyValueList`, `ArrayValue` [OpenTelemetry protocol for metrics](https://docs.victoriametrics.com/#sending-data-via-opentelemetry) attributes label values compatible with open-telemetry-collector format. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8384).
 
 * BUGFIX: [Single-node VictoriaMetrics](https://docs.victoriametrics.com/) and [vmstorage](https://docs.victoriametrics.com/victoriametrics/): fix the incorrect caching of extMetricsIDs when a query timeout error occurs. This can lead to incorrect query results. Thanks to @changshun-shi for [the bug report issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8345).
 * BUGFIX: [vmctl](https://docs.victoriametrics.com/vmctl/): respect time filter when exploring time series for [influxdb mode](https://docs.victoriametrics.com/vmctl/#migrating-data-from-influxdb-1x). See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8259) for details.
 * BUGFIX: [vmsingle](https://docs.victoriametrics.com/single-server-victoriametrics/): properly apply global relabeling configuration, defined with  `-relabelConfig` flag, for metrics scrapped with `-promscrape.config`. Bug was introduces in [v1.108.0](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v1.108.0). See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8389).
 * BUGFIX: [vmbackupmanager](https://docs.victoriametrics.com/vmbackupmanager/): properly propagate an error message when applying retention policy fails. Previously, an actual error messages was discarded.
 * BUGFIX: [vmgateway](https://docs.victoriametrics.com/vmgateway): fix data query in [rate limiter](https://docs.victoriametrics.com/vmgateway/#rate-limiter). The bug was introduced in [this commit](https://github.com/VictoriaMetrics/VictoriaMetrics/commit/68bad22fd26d1436ad0236b1f3ced8604c5d851c) starting from [v1.106.0](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v1.106.0).
+* BUGFIX: [vmgateway](https://docs.victoriametrics.com/vmgateway): properly apply the [rate limiter](https://docs.victoriametrics.com/vmgateway/#rate-limiter) for the `rows_inserted` limit type. Previously, the rate limit for this type was ignored.
+* BUGFIX: [vmgateway](https://docs.victoriametrics.com/vmgateway): properly handle HTTP requests with path ending with a trailing `/` when using the [rate limiter](https://docs.victoriametrics.com/vmgateway/#rate-limiter). Previously, the trailing slash was removed and caused an incorrect redirect path when visiting VMUI. Thanks to @jindov for [the bug report issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8439).
 * BUGFIX: [vmsingle](https://docs.victoriametrics.com/single-server-victoriametrics/) and [vmagent](https://docs.victoriametrics.com/vmagent/): properly escape IPv6 address in [Kubernetes service-discovery](https://docs.victoriametrics.com/sd_configs/#kubernetes_sd_configs) with `role: pod` for containers without exposed ports. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8374).
 * BUGFIX: [vmalert-tool](https://docs.victoriametrics.com/vmalert-tool/): clean up the temporary storage path when process is terminated by SIGTERM or SIGINT. Previously, unclean shut down might affect the next run.
+* BUGFIX: [vmui](https://docs.victoriametrics.com/#vmui): fix an infinite loader on the [Downsampling filters debug page](https://docs.victoriametrics.com/#vmui) when provided configuration matches no series. See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/8339).
 
 ## [v1.102.15](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/tag/v1.102.15)
 

docs/victoriametrics-cloud/README.md

@@ -1,10 +1,9 @@
 VictoriaMetrics Cloud is a managed, easy to use monitoring solution that integrates seamlessly with
 other tools and frameworks in the Observability ecosystem such as OpenTelemetry, Grafana, Prometheus, Graphite,
 InfluxDB, OpenTSDB and DataDog - see [these docs](https://docs.victoriametrics.com/#how-to-import-time-series-data)
-for further details.
+for further details about importing time series data into VictoriaMetrics.
 
 <br>
-<!--TODO: Just a test: Needs to be changed by something better!-->
 
 ![](/victoriametrics-cloud/get-started/get_started_preview.webp)
 <br>
@@ -13,35 +12,16 @@ for further details.
 * [Quick Start](/victoriametrics-cloud/quickstart/) documentation.
 * [Try it now](https://console.victoriametrics.cloud/signUp?utm_source=website&utm_campaign=docs_overview) with a free trial.
 
+
 ## Use cases
-The most common use cases for VictoriaMetrics Cloud are:
-* Long-term remote storage for Prometheus metrics.
+VictoriaMetrics Cloud is designed for teams and organizations that handle any volume of metrics. The most common use cases for VictoriaMetrics Cloud are:
+* Long-term remote storage for Prometheus, OpenTelemetry and any other standardized metrics.
 * Reliable and efficient drop-in replacement for Prometheus and Graphite.
+* Easy and cost-saving  enterprise managed alternative solution for Prometheus, Thanos, Mimir or Cortex.
 * Efficient replacement for InfluxDB and OpenTSDB by consuming lower amounts of RAM, CPU and disk.
-* Cost-efficient alternative for Observability services like DataDog.
+* Cost-efficient alternative for other Observability services like DataDog or Grafana Cloud.
 
-## Benefits
-We run VictoriaMetrics Cloud deployments in our environment on AWS and provide easy-to-use endpoints
-for data ingestion and querying. The VictoriaMetrics team takes care of optimal configuration and software
-maintenance. This means that VictoriaMetrics Cloud allows users to run the Enterprise version of VictoriaMetrics, hosted on AWS,
-without the hustle to perform typical DevOps tasks such as:
-* Managing configuration.
-* Monitoring.
-* Logs collection.
-* Access protection.
-* Software updates.
-* Regular backups.
-* Control costs.
-
-## Features
-VictoriaMetrics Cloud comes with the following features:
-* It can be used as a Managed Prometheus - just configure Prometheus or vmagent to write data to VictoriaMetrics Cloud and then use the provided endpoint as a Prometheus datasource in Grafana.
-* Built-in [Alerting & Recording](https://docs.victoriametrics.com/victoriametrics-cloud/alertmanager-setup-for-deployment/#configure-alerting-rules) rules execution.
-* Hosted [Alertmanager](https://docs.victoriametrics.com/victoriametrics-cloud/alertmanager-setup-for-deployment/) for sending notifications.
-* Every VictoriaMetrics Cloud deployment runs in an isolated environment, so deployments cannot interfere with each other.
-* VictoriaMetrics Cloud deployment can be scaled up or scaled down in a few clicks.
-* Automated backups.
-* No surprises. Select a tier and pay only for the actual used resources - compute, storage, traffic.
+Discover VictoriaMetrics Cloud Features and Benefits [here](/victoriametrics-cloud/get-started/features).
 
 ## Learn more
 * [VictoriaMetrics Cloud announcement](https://victoriametrics.com/blog/introduction-to-managed-monitoring/).

docs/victoriametrics-cloud/_index.md

@@ -1,7 +1,6 @@
 ---
-title: VictoriaMetrics Cloud Overview
+title: VictoriaMetrics Cloud
 weight: 40
-disableToc: true
 menu:
   docs:
     weight: 40

docs/victoriametrics-cloud/get-started/_index.md

@@ -10,18 +10,15 @@ menu:
 ---
 In this section you will find everything you need to start using [VictoriaMetrics Cloud](https://console.victoriametrics.cloud/signUp?utm_source=website&utm_campaign=docs_vm_get_started).
 
-* [Overview of VictoriaMetrics Cloud](overview/)
-* [Quick Start](quickstart/)
+* [Overview of VictoriaMetrics Cloud](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/overview/)
+* [Key Features & Benefits](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/features/)
+* [Quick Start](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/quickstart/)
+* [Guides and Best Practices](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/guides/)
 
-## Guides
-* [Understand Your Setup Size](/guides/understand-your-setup-size/)
-* [Alerting & recording rules with Alertmanager configuration for VictoriaMetrics Cloud deployment](/victoriametrics-cloud/alertmanager-setup-for-deployment/)
-* [Kubernetes Monitoring with VictoriaMetrics Cloud](/victoriametrics-cloud/how-to-monitor-k8s/)
-* [Setup Notifications](/victoriametrics-cloud/setup-notifications/)
-* [User Management](/victoriametrics-cloud/user-managment/)
+<details>
+<summary>Learn more about VictoriaMetrics Cloud</summary>
 
-Learn more about VictoriaMetrics Cloud:
 * [VictoriaMetrics Cloud announcement](https://victoriametrics.com/blog/introduction-to-managed-monitoring/)
 * [Pricing comparison for Managed Prometheus](https://victoriametrics.com/blog/managed-prometheus-pricing/)
 * [Monitoring Proxmox VE via VictoriaMetrics Cloud and vmagent](https://victoriametrics.com/blog/proxmox-monitoring-with-dbaas/)
-
+</details>

docs/victoriametrics-cloud/get-started/features.md

@@ -0,0 +1,142 @@
+---
+weight: 2
+title: Key Features & Benefits
+menu:
+  docs:
+    parent: get-started
+    weight: 2
+aliases:
+  - /victoriametrics-cloud/quickstart/features.html
+  - /managed-victoriametrics/quickstart/features.html
+---
+
+VictoriaMetrics Cloud helps optimizing your data and maximizing its value in the most reliable way. It can be used as an **Enterprise-level Managed Prometheus**: just configure Prometheus, [vmagent](https://docs.victoriametrics.com/vmagent/), an OpenTelemetry Collector or any agent to write data to VictoriaMetrics Cloud, and point Grafana to VictoriaMetrics Cloud by configuring it as a Prometheus datasource.
+
+## Features
+VictoriaMetrics Cloud offers a robust suite of features designed to optimize your cloud experience. Seamless integrations, scalability and cost-saving measures, and comprehensive operational tools ensure that VictoriaMetrics Cloud can support your business needs.
+
+<details>
+<summary>Integrations and Compatibility</summary>
+
+* **Observability protocols**: OpenTelemetry, InfluxDB, DataDog, NewRelic, OpenTSDB & Graphite.
+* **Data visualization**: Use built-in [VictoriaMetrics UI](https://play.victoriametrics.com/) or integrate seamlessly with your current stack to query and visualize your data in [Grafana](https://grafana.com/) or [Perses](https://perses.dev).
+* [**AWS PrivateLink**](https://aws.amazon.com/privatelink/): enabling even more secure communication with VictoriaMetrics Cloud deployments directly from your VPC.
+
+![Integrations](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/features_integrations.webp)
+<figcaption style="text-align: center; font-style: italic;">VictoriaMetrics Cloud Integrations</figcaption>
+
+</details>
+
+<details>
+<summary>Scale as you go and save costs</summary>
+
+* **Easy Scaling**: VictoriaMetrics Cloud deployments can be scaled up or down with just a few clicks in line with growth and needs.
+* **Downsampling**: Lower your disk footprint (and save on storage costs!) by keeping fewer data points for historical data and speed up queries for it, while preserving high precision for your operational data.
+* **Retention filters**: Configure a custom retention period on a team (tenant) level or time series level by using label filters so that unneeded time series are wiped out freeing up storage space for new metrics data enabling additional cost savings
+* **Recording rules**: Improve query performance with recording rules, facilitating quicker data access & dashboard responsiveness.
+</details>
+
+<details>
+<summary>Operations</summary>
+
+* **Enterprise, managed VictoriaMetrics Solution**: Comes with all the proven features in VictoriaMetrics open source & Enterprise.
+* **Single-node** & **Cluster** configurations with automatic software version and security updates.
+* Built-in [Alerting & Recording](https://docs.victoriametrics.com/victoriametrics-cloud/alertmanager-setup-for-deployment/#configure-alerting-rules) rules execution. Define your rules & get immediate alerts as issues arise, enabling swift action & minimizing disruption to your users.
+* Hosted [Alertmanager](https://docs.victoriametrics.com/victoriametrics-cloud/alertmanager-setup-for-deployment/) for sending notifications.
+* **Isolated Deployments**: VictoriaMetrics Cloud provisions dedicated resources for your deployments, so you won’t encounter “noisy neighbors” problems as deployments do not compete for resources.
+* **Multitenancy**: Easily serve multiple teams (tenants) with one Cluster deployment by having a dedicated namespace for each team.
+* **Automated Backups**: Regular backup procedures are in place. Your data is automatically saved to a backup storage, so you can easily restore it when the need arises.
+* **High-availability** & replication.
+* **Reliability** & extraordinary performance with 99.95% SLA.
+</details>
+
+## Get instant value from your data
+
+VictoriaMetrics Cloud allows you to explore and optimize both your data and deployments.
+
+<details>
+<summary>Query your own metrics</summary>
+
+* Visualize your own data in graphs, table or json formats
+* Combine several queries at the same time
+* Prettify your queries to improve readability
+* Autocomplete to help you writing queries
+* Trace your queries to understand behavior
+
+![Query](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/features_query.webp)
+<figcaption style="text-align: center; font-style: italic;">Query your data with VictoriaMetrics Cloud</figcaption>
+
+</details>
+
+<details>
+<summary>Explore valuable insights</summary>
+
+* List your Prometheus metrics by Job and Instance
+* Inspect your time series data cardinality to optimize usage and costs
+* Discover top used or heaviest queries
+
+![Cardinality](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/features_cardinality.webp)
+<figcaption style="text-align: center; font-style: italic;">Understand your data with VictoriaMetrics Cloud</figcaption>
+</details>
+
+<details>
+<summary>Analyze, debug and learn</summary>
+
+* Trace and query analyzer to debug queries
+* WITH templating for MetricsQL: functions, variables and filters
+* Debug metrics relabling with easy-to-follow examples
+
+![Traces](https://docs.victoriametrics.com/victoriametrics-cloud/get-started/features_traces.webp)
+<figcaption style="text-align: center; font-style: italic;">Debug your queries</figcaption>
+</details>
+
+## Benefits
+In brief, we run VictoriaMetrics Cloud deployments in our AWS environment and provide direct endpoints
+for data ingestion and querying. The VictoriaMetrics team takes care of optimal configuration and software
+maintenance. You can think of it as having access to a **fully supported, enterprise** version of VictoriaMetrics
+that runs outside your environment, helping you to save resources and costs, without the hustle of performing
+typical DevOps tasks such as configuration management, monitoring, log collection, access protection, perform
+software and infrastructure upgrades, store backups regularly or control costs. **We take care of that**.
+
+> VictoriaMetrics Cloud is able to handle larger workloads than competing solutions at a far lower cost.
+
+<details>
+<summary>Easy Migration</summary>
+
+* Migrate from costly & less scalable monitoring solutions such as Managed Prometheus service from AWS, GCP or Azure, InfluxDB Cloud, or your on-premises setup.
+* Get higher data resolution with much higher cardinality.
+* Run more complex queries.
+
+</details>
+
+<details>
+<summary>Enterprise level support</summary>
+
+Includes all VictoriaMetrics Enterprise Features Plus:
+
+* Business days & hours support
+* 8 hours response time for system impaired issues
+
+</details>
+
+<details>
+<summary>Cost-efficient Scaling</summary>
+
+* Only pay for the resources that you actually use (compute, disk and network).
+* Downsampling and retention filters features enable additional cost-savings.
+
+</details>
+
+<details>
+<summary>Ease of Budgeting</summary>
+
+**No invoice surprises**: pick a tier at a fixed price. Our pricing model protects you from surprise overages coming from unexpected changes in workload such as spikes in data ingestion rate, cardinality explosions or accidental heavy queries.
+</details>
+
+
+<details>
+<summary>Ease of use</summary>
+
+The VictoriaMetrics team takes care of optimal configuration and handles all software maintenance, so you can focus on the monitoring.
+</details>
+

docs/victoriametrics-cloud/get-started/guides.md

@@ -0,0 +1,19 @@
+---
+weight: 4
+title: Guides and Best Practices
+menu:
+  docs:
+    parent: get-started
+    weight: 4
+aliases:
+  - /victoriametrics-cloud/quickstart/best-practices.html
+  - /managed-victoriametrics/quickstart/best-practices.html
+---
+
+Here you can find some guides and best practices:
+
+* [Understand Your Setup Size](https://docs.victoriametrics.com/guides/understand-your-setup-size/)
+* [Alerting & recording rules with Alertmanager configuration for VictoriaMetrics Cloud deployment](https://docs.victoriametrics.com/victoriametrics-cloud/alertmanager-setup-for-deployment/)
+* [Kubernetes Monitoring with VictoriaMetrics Cloud](https://docs.victoriametrics.com/victoriametrics-cloud/how-to-monitor-k8s/)
+* [Setup Notifications](https://docs.victoriametrics.com/victoriametrics-cloud/setup-notifications/)
+* [User Management](https://docs.victoriametrics.com/victoriametrics-cloud/user-managment/)

docs/vmalert.md

@@ -952,7 +952,7 @@ Sensitive info is stripped from the `curl` examples - see [security](#security)
 
 ### Never-firing alerts
 
-vmalert can detect{{% available_from "v1.90.0" %}} if alert's expression doesn't match any time series in runtime 
+vmalert can detect{{% available_from "v1.91.0" %}} if alert's expression doesn't match any time series in runtime 
 starting from [v1.91](https://docs.victoriametrics.com/changelog/#v1910). This problem usually happens
 when alerting expression selects time series which aren't present in the datasource (i.e. wrong `job` label)
 or there is a typo in the series selector (i.e. `env=prod`). Such alerting rules will be marked with special icon in 

lib/protoparser/opentelemetry/pb/helpers.go

@@ -1,40 +1,11 @@
 package pb
 
 import (
-	"encoding/base64"
-	"encoding/json"
 	"fmt"
 	"math"
 	"strconv"
 )
 
-// FormatString returns string reperesentation for av.
-func (av *AnyValue) FormatString() string {
-	if av == nil {
-		return ""
-	}
-	switch {
-	case av.StringValue != nil:
-		return *av.StringValue
-	case av.BoolValue != nil:
-		return strconv.FormatBool(*av.BoolValue)
-	case av.IntValue != nil:
-		return strconv.FormatInt(*av.IntValue, 10)
-	case av.DoubleValue != nil:
-		return float64AsString(*av.DoubleValue)
-	case av.ArrayValue != nil:
-		jsonStr, _ := json.Marshal(av.ArrayValue.Values)
-		return string(jsonStr)
-	case av.KeyValueList != nil:
-		jsonStr, _ := json.Marshal(av.KeyValueList.Values)
-		return string(jsonStr)
-	case av.BytesValue != nil:
-		return base64.StdEncoding.EncodeToString(*av.BytesValue)
-	default:
-		return ""
-	}
-}
-
 func float64AsString(f float64) string {
 	if math.IsInf(f, 0) || math.IsNaN(f) {
 		return fmt.Sprintf("json: unsupported value: %s", strconv.FormatFloat(f, 'g', -1, 64))

lib/protoparser/opentelemetry/pb/helpers.qtpl

@@ -0,0 +1,65 @@
+{% import (
+	"strconv"
+	"encoding/base64"
+)%}
+
+{% stripspace %}
+{% func (kvl *KeyValueList) FormatString() %}
+{% if len(kvl.Values) > 0 %}
+{
+	{% for i, v := range kvl.Values %}
+		{%q= v.Key %}: {%s= v.Value.FormatString(false) %}
+		{% if i + 1 < len(kvl.Values) %},{% endif %}
+	{% endfor %}
+}
+{% else %}
+{}
+{% endif %}
+{% endfunc %}
+{% endstripspace %}
+
+{% stripspace %}
+{% func (av *ArrayValue) FormatString() %}
+{% if len(av.Values) > 0 %}
+[      
+        {% for i, v := range av.Values %}
+                {%s= v.FormatString(false) %}
+                {% if i + 1 < len(av.Values) %},{% endif %}
+        {% endfor %}
+]
+{% else %}
+[]
+{% endif %}
+{% endfunc %}
+{% endstripspace %}
+
+{% stripspace %}
+{% func (av *AnyValue) FormatString(toplevel bool) %}
+{% if av == nil %}
+  {% if !toplevel %}
+       null
+  {% endif %}
+  {% return %}
+{% endif %}
+{% switch %}
+{% case av.StringValue != nil %}
+	{% if toplevel %}
+		{%s= *av.StringValue %}
+	{% else %}
+		{%q= *av.StringValue %}
+	{% endif %}
+{% case av.BoolValue != nil %}
+	{%s= strconv.FormatBool(*av.BoolValue) %}
+{% case av.IntValue != nil %}
+	{%dl= *av.IntValue %}
+{% case av.DoubleValue != nil %}
+	{%s= float64AsString(*av.DoubleValue) %}
+{% case av.ArrayValue != nil %}
+	{%s= av.ArrayValue.FormatString() %}
+{% case av.KeyValueList != nil %}
+	{%s= av.KeyValueList.FormatString() %}
+{% case av.BytesValue != nil %}
+	{%s= base64.StdEncoding.EncodeToString(*av.BytesValue) %}
+{% endswitch %}
+{% endfunc %}
+{% endstripspace %}

lib/protoparser/opentelemetry/pb/helpers.qtpl.go

@@ -0,0 +1,221 @@
+// Code generated by qtc from "helpers.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:1
+package pb
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:1
+import (
+	"encoding/base64"
+	"strconv"
+)
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:7
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:7
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:7
+func (kvl *KeyValueList) StreamFormatString(qw422016 *qt422016.Writer) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:8
+	if len(kvl.Values) > 0 {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:8
+		qw422016.N().S(`{`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:10
+		for i, v := range kvl.Values {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:11
+			qw422016.N().Q(v.Key)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:11
+			qw422016.N().S(`:`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:11
+			qw422016.N().S(v.Value.FormatString(false))
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:12
+			if i+1 < len(kvl.Values) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:12
+				qw422016.N().S(`,`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:12
+			}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:13
+		}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:13
+		qw422016.N().S(`}`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:15
+	} else {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:15
+		qw422016.N().S(`{}`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:17
+	}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+func (kvl *KeyValueList) WriteFormatString(qq422016 qtio422016.Writer) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	kvl.StreamFormatString(qw422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	qt422016.ReleaseWriter(qw422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+func (kvl *KeyValueList) FormatString() string {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	qb422016 := qt422016.AcquireByteBuffer()
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	kvl.WriteFormatString(qb422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	qs422016 := string(qb422016.B)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	qt422016.ReleaseByteBuffer(qb422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+	return qs422016
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:18
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:22
+func (av *ArrayValue) StreamFormatString(qw422016 *qt422016.Writer) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:23
+	if len(av.Values) > 0 {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:23
+		qw422016.N().S(`[`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:25
+		for i, v := range av.Values {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:26
+			qw422016.N().S(v.FormatString(false))
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:27
+			if i+1 < len(av.Values) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:27
+				qw422016.N().S(`,`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:27
+			}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:28
+		}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:28
+		qw422016.N().S(`]`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:30
+	} else {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:30
+		qw422016.N().S(`[]`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:32
+	}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+func (av *ArrayValue) WriteFormatString(qq422016 qtio422016.Writer) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	av.StreamFormatString(qw422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	qt422016.ReleaseWriter(qw422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+func (av *ArrayValue) FormatString() string {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	qb422016 := qt422016.AcquireByteBuffer()
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	av.WriteFormatString(qb422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	qs422016 := string(qb422016.B)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	qt422016.ReleaseByteBuffer(qb422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+	return qs422016
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:33
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:37
+func (av *AnyValue) StreamFormatString(qw422016 *qt422016.Writer, toplevel bool) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:38
+	if av == nil {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:39
+		if !toplevel {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:39
+			qw422016.N().S(`null`)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:41
+		}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:42
+		return
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:43
+	}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:44
+	switch {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:45
+	case av.StringValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:46
+		if toplevel {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:47
+			qw422016.N().S(*av.StringValue)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:48
+		} else {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:49
+			qw422016.N().Q(*av.StringValue)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:50
+		}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:51
+	case av.BoolValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:52
+		qw422016.N().S(strconv.FormatBool(*av.BoolValue))
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:53
+	case av.IntValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:54
+		qw422016.N().DL(*av.IntValue)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:55
+	case av.DoubleValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:56
+		qw422016.N().S(float64AsString(*av.DoubleValue))
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:57
+	case av.ArrayValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:58
+		qw422016.N().S(av.ArrayValue.FormatString())
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:59
+	case av.KeyValueList != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:60
+		qw422016.N().S(av.KeyValueList.FormatString())
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:61
+	case av.BytesValue != nil:
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:62
+		qw422016.N().S(base64.StdEncoding.EncodeToString(*av.BytesValue))
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:63
+	}
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+func (av *AnyValue) WriteFormatString(qq422016 qtio422016.Writer, toplevel bool) {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	av.StreamFormatString(qw422016, toplevel)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	qt422016.ReleaseWriter(qw422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+}
+
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+func (av *AnyValue) FormatString(toplevel bool) string {
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	qb422016 := qt422016.AcquireByteBuffer()
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	av.WriteFormatString(qb422016, toplevel)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	qs422016 := string(qb422016.B)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	qt422016.ReleaseByteBuffer(qb422016)
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+	return qs422016
+//line lib/protoparser/opentelemetry/pb/helpers.qtpl:64
+}

lib/protoparser/opentelemetry/pb/helpers_test.go

@@ -0,0 +1,59 @@
+package pb
+
+import (
+	"testing"
+)
+
+func strptr(v string) *string {
+	return &v
+}
+
+func TestFormatString(t *testing.T) {
+	f := func(attr *AnyValue, expected string) {
+		t.Helper()
+		got := attr.FormatString(true)
+		if got != expected {
+			t.Fatalf("unexpected attribute string representation, got: %s, want: %s", got, expected)
+		}
+	}
+
+	f(&AnyValue{
+		StringValue: strptr("test1"),
+	}, `test1`)
+	f(&AnyValue{
+		KeyValueList: &KeyValueList{
+			Values: []*KeyValue{
+				{
+					Key: "test1",
+					Value: &AnyValue{
+						StringValue: strptr("1"),
+					},
+				},
+				{
+					Key: "test2",
+					Value: &AnyValue{
+						StringValue: strptr("2"),
+					},
+				},
+			},
+		},
+	}, `{"test1":"1","test2":"2"}`)
+	f(&AnyValue{
+		ArrayValue: &ArrayValue{
+			Values: []*AnyValue{
+				{
+					StringValue: strptr("1"),
+				},
+				{
+					ArrayValue: &ArrayValue{
+						Values: []*AnyValue{
+							{
+								StringValue: strptr("1"),
+							},
+						},
+					},
+				},
+			},
+		},
+	}, `["1",["1"]]`)
+}

lib/protoparser/opentelemetry/stream/streamparser.go

@@ -267,7 +267,7 @@ func appendAttributesToPromLabels(dst []prompbmarshal.Label, attributes []*pb.Ke
 	for _, at := range attributes {
 		dst = append(dst, prompbmarshal.Label{
 			Name:  sanitizeLabelName(at.Key),
-			Value: at.Value.FormatString(),
+			Value: at.Value.FormatString(true),
 		})
 	}
 	return dst

lib/protoparser/opentelemetry/stream/streamparser_test.go

@@ -214,6 +214,105 @@ func TestParseStream(t *testing.T) {
 		},
 		true,
 	)
+
+	// Test gauge with deeply nested attributes
+	f(
+		[]*pb.Metric{
+			{
+				Name: "my-gauge",
+				Unit: "",
+				Gauge: &pb.Gauge{
+					DataPoints: []*pb.NumberDataPoint{
+						{
+							Attributes: []*pb.KeyValue{
+								{
+									Key: "label1",
+									Value: &pb.AnyValue{
+										StringValue: ptrTo("value1"),
+									},
+								},
+								{
+									Key:   "emptylabelvalue",
+									Value: &pb.AnyValue{},
+								},
+								{
+									Key: "emptylabel",
+								},
+								{
+									Key: "label_array",
+									Value: &pb.AnyValue{
+										ArrayValue: &pb.ArrayValue{
+											Values: []*pb.AnyValue{
+												{
+													StringValue: ptrTo("value5"),
+												},
+												{
+													KeyValueList: &pb.KeyValueList{},
+												},
+											},
+										},
+									},
+								},
+								{
+									Key: "nested_label",
+									Value: &pb.AnyValue{
+										KeyValueList: &pb.KeyValueList{
+											Values: []*pb.KeyValue{
+												{
+													Key: "empty_value",
+												},
+												{
+													Key: "value_top_2",
+													Value: &pb.AnyValue{
+														StringValue: ptrTo("valuetop"),
+													},
+												},
+												{
+													Key: "nested_kv_list",
+													Value: &pb.AnyValue{
+														KeyValueList: &pb.KeyValueList{
+															Values: []*pb.KeyValue{
+																{
+																	Key:   "integer",
+																	Value: &pb.AnyValue{IntValue: ptrTo(int64(15))},
+																},
+																{
+																	Key:   "doable",
+																	Value: &pb.AnyValue{DoubleValue: ptrTo(5.1)},
+																},
+																{
+																	Key:   "string",
+																	Value: &pb.AnyValue{StringValue: ptrTo("value2")},
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+							},
+							IntValue:     ptrTo(int64(15)),
+							TimeUnixNano: uint64(15 * time.Second),
+						},
+					},
+				},
+			},
+		},
+		[]prompbmarshal.TimeSeries{
+			newPromPBTs("my-gauge",
+				15000,
+				15.0,
+				jobLabelValue,
+				kvLabel("label1", "value1"),
+				kvLabel("emptylabelvalue", ""),
+				kvLabel("emptylabel", ""),
+				kvLabel("label_array", `["value5",{}]`),
+				kvLabel("nested_label", `{"empty_value":null,"value_top_2":"valuetop","nested_kv_list":{"integer":15,"doable":5.1,"string":"value2"}}`)),
+		},
+		false,
+	)
 }
 
 func checkParseStream(data []byte, checkSeries func(tss []prompbmarshal.TimeSeries) error) error {
@@ -429,3 +528,7 @@ func sortLabels(labels []prompbmarshal.Label) {
 		return labels[i].Name < labels[j].Name
 	})
 }
+
+func ptrTo[T any](v T) *T {
+	return &v
+}