lib/fs: add MustStopDirRemover for waiting until pending directories are removed on graceful shutdown

This patch is mainly required for laggy NFS. See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/162

.dockerignore

@@ -0,0 +1,6 @@
+.git
+vendor
+gocache-for-docker
+victoria-metrics-data
+vmstorage-data
+vmselect-cache

.github/workflows/main.yml

@@ -0,0 +1,38 @@
+name: main
+on:
+  - push
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.12
+        id: go
+      - name: Code checkout
+        uses: actions/checkout@v1
+      - name: Dependencies
+        env:
+          GO111MODULE: off
+        run: |
+          go get -v golang.org/x/lint/golint
+          go get -u github.com/kisielk/errcheck
+      - name: Build
+        env:
+          GO111MODULE: on
+        run: |
+            export PATH=$PATH:$(go env GOPATH)/bin # temporary fix. See https://github.com/actions/setup-go/issues/14
+            make check-all
+            git diff --exit-code
+            make test-full
+            make test-pure
+            make vminsert vmselect vmstorage
+            make vminsert-pure vmselect-pure vmstorage-pure
+            GOOS=freebsd go build -mod=vendor ./app/vminsert
+            GOOS=freebsd go build -mod=vendor ./app/vmselect
+            GOOS=freebsd go build -mod=vendor ./app/vmstorage
+            GOOS=darwin go build -mod=vendor ./app/vminsert
+            GOOS=darwin go build -mod=vendor ./app/vmselect
+            GOOS=darwin go build -mod=vendor ./app/vmstorage

.gitignore

@@ -0,0 +1,18 @@
+/tags
+/pkg
+*.pprof
+/bin
+.idea
+*.test
+*.swp
+/gocache-for-docker
+/victoria-metrics-data
+/vmstorage-data
+/vmselect-cache
+.DS_Store
+
+
+### terraform
+terraform.tfstate
+terraform.tfstate.*
+.terraform/

LICENSE

@@ -0,0 +1,190 @@
+ Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2019 VictoriaMetrics, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Makefile

@@ -0,0 +1,112 @@
+PKG_PREFIX := github.com/VictoriaMetrics/VictoriaMetrics
+
+BUILDINFO_TAG ?= $(shell echo $$(git describe --long --all | tr '/' '-')$$( \
+	      git diff-index --quiet HEAD -- || echo '-dirty-'$$(git diff-index -u HEAD | openssl sha1 | cut -c 10-17)))
+
+PKG_TAG ?= $(shell git tag -l --points-at HEAD)
+ifeq ($(PKG_TAG),)
+PKG_TAG := $(BUILDINFO_TAG)
+endif
+
+GO_BUILDINFO = -X '$(PKG_PREFIX)/lib/buildinfo.Version=$(APP_NAME)-$(shell date -u +'%Y%m%d-%H%M%S')-$(BUILDINFO_TAG)'
+
+all: \
+	vminsert \
+	vmselect \
+	vmstorage
+
+all-pure: \
+	vminsert-pure \
+	vmselect-pure \
+	vmstorage-pure
+
+include app/*/Makefile
+include deployment/*/Makefile
+include deployment/*/helm/Makefile
+
+clean:
+	rm -rf bin/*
+
+publish: \
+	publish-vmstorage \
+	publish-vmselect \
+	publish-vminsert
+
+package: \
+	package-vmstorage \
+	package-vmselect \
+	package-vminsert
+
+release: \
+	vminsert-prod \
+	vmselect-prod \
+	vmstorage-prod
+	cd bin && tar czf victoria-metrics-$(PKG_TAG).tar.gz vminsert-prod vmselect-prod vmstorage-prod
+
+fmt:
+	GO111MODULE=on gofmt -l -w -s ./lib
+	GO111MODULE=on gofmt -l -w -s ./app
+
+vet:
+	GO111MODULE=on go vet -mod=vendor ./lib/...
+	GO111MODULE=on go vet -mod=vendor ./app/...
+
+lint: install-golint
+	golint lib/...
+	golint app/...
+
+install-golint:
+	which golint || GO111MODULE=off go get -u github.com/golang/lint/golint
+
+errcheck: install-errcheck
+	errcheck -exclude=errcheck_excludes.txt ./lib/...
+	errcheck -exclude=errcheck_excludes.txt ./app/vminsert/...
+	errcheck -exclude=errcheck_excludes.txt ./app/vmselect/...
+	errcheck -exclude=errcheck_excludes.txt ./app/vmstorage/...
+
+install-errcheck:
+	which errcheck || GO111MODULE=off go get -u github.com/kisielk/errcheck
+
+check-all: fmt vet lint errcheck golangci-lint
+
+test:
+	GO111MODULE=on go test -mod=vendor ./lib/... ./app/...
+
+test-pure:
+	GO111MODULE=on CGO_ENABLED=0 go test -mod=vendor ./lib/... ./app/...
+
+test-full:
+	GO111MODULE=on go test -mod=vendor -coverprofile=coverage.txt -covermode=atomic ./lib/... ./app/...
+
+benchmark:
+	GO111MODULE=on go test -mod=vendor -bench=. ./lib/...
+	GO111MODULE=on go test -mod=vendor -bench=. ./app/...
+
+benchmark-pure:
+	GO111MODULE=on CGO_ENABLED=0 go test -mod=vendor -bench=. ./lib/...
+	GO111MODULE=on CGO_ENABLED=0 go test -mod=vendor -bench=. ./app/...
+
+vendor-update:
+	GO111MODULE=on go get -u ./lib/...
+	GO111MODULE=on go get -u ./app/...
+	GO111MODULE=on go mod tidy
+	GO111MODULE=on go mod vendor
+
+app-local:
+	CGO_ENABLED=1 GO111MODULE=on go build $(RACE) -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/$(APP_NAME)$(RACE) $(PKG_PREFIX)/app/$(APP_NAME)
+
+app-local-pure:
+	CGO_ENABLED=0 GO111MODULE=on go build $(RACE) -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/$(APP_NAME)-pure$(RACE) $(PKG_PREFIX)/app/$(APP_NAME)
+
+quicktemplate-gen: install-qtc
+	qtc
+
+install-qtc:
+	which qtc || GO111MODULE=off go get -u github.com/valyala/quicktemplate/qtc
+
+
+golangci-lint: install-golangci-lint
+	golangci-lint run --exclude '(SA4003|SA1019):' -D errcheck
+
+install-golangci-lint:
+	which golangci-lint || GO111MODULE=off go get -u github.com/golangci/golangci-lint/cmd/golangci-lint

README.md

@@ -1,35 +1,242 @@
-<img  text-align="center" alt="Victoria Metrics" src="logo.png">
+<img alt="Victoria Metrics" src="logo.png">
 
-## VictoriaMetrics - the best long-term remote storage for Prometheus
+# Cluster version of VictoriaMetrics
 
-[![Latest Release](https://img.shields.io/github/release/VictoriaMetrics/VictoriaMetrics.svg?style=flat-square)](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/latest)
+VictoriaMetrics is fast, cost-effective and scalable time series database. It can be used as a long-term remote storage for Prometheus.
 
-### VictoriaMetrics features
-
-- Full [PromQL](https://prometheus.io/docs/prometheus/latest/querying/basics/) support. Additionally, VictoriaMetrics extends PromQL with useful features. See [Extended PromQL](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki/ExtendedPromQL) for more details.
-- Simple configuration. Just copy-n-paste remote storage URL to Prometheus config and that's it! See [Quick Start](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki/Quick-Start) for more info.
-- Reduced operational overhead. Prometheus local storage retention may be set to the minimum possible value when using VictoriaMetrics remote storage. This effectively makes Prometheus stateless, so it may be run as a stateless service in Kubernetes.
-- Insertion rate scales to millions of metric values per second.
-- Storage scales to millions of metrics with trillions of metric values.
-- Wide range of retention periods - from 1 month to 5 years. Users may create different projects (aka `storage namespaces`) with different retention periods.
-- Fast query engine. It excels on heavy queries over thousands of metrics with millions of metric values.
-- The same remote storage URL may be used by multiple Prometheus instances collecting distinct metric sets, so all these metrics may be used in a single query (aka `global querying view`). This works ideally for multiple Prometheus instances located in different subnetworks / datacenters.
+It is recommended using [single-node version](https://github.com/VictoriaMetrics/VictoriaMetrics) instead of cluster version
+for ingestion rates lower than 10 million of data points per second.
+Single-node version [scales perfectly](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae)
+with the number of CPU cores, RAM and available storage space.
+Single-node version is easier to configure and operate comparing to cluster version, so think twice before sticking to cluster version.
 
 
-### Useful links
+## Prominent features
 
-* [Site](https://victoriametrics.com/)
-* [`WITH` templates playground](https://play.victoriametrics.com/promql/expand-with-exprs)
-* [Grafana playground](http://play-grafana.victoriametrics.com:3000/d/4ome8yJmz/node-exporter-on-victoriametrics-demo)
-* [Docs](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki)
-* [FAQ](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki/FAQ)
-* [Issues](https://github.com/VictoriaMetrics/VictoriaMetrics/issues)
-* [Google group](https://groups.google.com/forum/#!forum/victoriametrics)
-* [Creating the best remote storage for Prometheus](https://medium.com/devopslinks/victoriametrics-creating-the-best-remote-storage-for-prometheus-5d92d66787ac) - an article with technical details about VictoriaMetrics.
-* [Docker images](https://hub.docker.com/r/valyala/victoria-metrics/) and the corresponding [binaries](https://github.com/VictoriaMetrics/VictoriaMetrics/releases) for single-server VictoriaMetrics
+- Supports all the features of [single-node version](https://github.com/VictoriaMetrics/VictoriaMetrics).
+- Scales horizontally to multiple nodes.
+- Supports multiple independent namespaces for time series data (aka multi-tenancy).
 
 
-### Victoria Metrics Logo
+## Architecture overview
+
+VictoriaMetrics cluster consists of the following services:
+
+- `vmstorage` - stores the data
+- `vminsert` - proxies the ingested data to `vmstorage` shards using consistent hashing
+- `vmselect` - performs incoming queries using the data from `vmstorage`
+
+Each service may scale independently and may run on the most suitable hardware.
+
+<img src="https://docs.google.com/drawings/d/e/2PACX-1vTvk2raU9kFgZ84oF-OKolrGwHaePhHRsZEcfQ1I_EC5AB_XPWwB392XshxPramLJ8E4bqptTnFn5LL/pub?w=1104&amp;h=746">
+
+
+## Building from sources
+
+Source code for cluster version is available at [cluster branch](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/cluster).
+
+
+### Development Builds
+
+1. [Install go](https://golang.org/doc/install). The minimum supported version is Go 1.12.
+2. Run `make` from the repository root. It should build `vmstorage`, `vmselect`
+   and `vminsert` binaries and put them into the `bin` folder.
+
+
+### Production builds
+
+There is no need in installing Go on a host system since binaries are built
+inside [the official docker container for Go](https://hub.docker.com/_/golang).
+This makes reproducible builds.
+So [install docker](https://docs.docker.com/install/) and run the following command:
+
+```
+make vminsert-prod vmselect-prod vmstorage-prod
+```
+
+Production binaries are built into statically linked binaries for `GOARCH=amd64`, `GOOS=linux`.
+They are put into `bin` folder with `-prod` suffixes:
+```
+$ make vminsert-prod vmselect-prod vmstorage-prod
+$ ls -1 bin
+vminsert-prod
+vmselect-prod
+vmstorage-prod
+```
+
+### Building docker images
+
+Run `make package`. It will build the following docker images locally:
+
+* `victoriametrics/vminsert:<PKG_TAG>`
+* `victoriametrics/vmselect:<PKG_TAG>`
+* `victoriametrics/vmstorage:<PKG_TAG>`
+
+`<PKG_TAG>` is auto-generated image tag, which depends on source code in the repository.
+The `<PKG_TAG>` may be manually set via `PKG_TAG=foobar make package`.
+
+
+
+## Operation
+
+### Cluster setup
+
+A minimal cluster must contain the following nodes:
+
+* a single `vmstorage` node with `-retentionPeriod` and `-storageDataPath` flags
+* a single `vminsert` node with `-storageNode=<vmstorage_host>:8400`
+* a single `vmselect` node with `-storageNode=<vmstorage_host>:8401`
+
+It is recommended to run at least two nodes for each service
+for high availability purposes.
+
+An http load balancer must be put in front of `vminsert` and `vmselect` nodes:
+- requests starting with `/insert` must be routed to port `8480` on `vminsert` nodes.
+- requests starting with `/select` must be routed to port `8481` on `vmselect` nodes.
+
+Ports may be altered by setting `-httpListenAddr` on the corresponding nodes.
+
+
+### URL format
+
+* URLs for data ingestion: `/insert/<accountID>/<suffix>`, where:
+  - `<accountID>` is an arbitrary number identifying namespace for data ingestion (aka tenant)
+  - `<suffix>` may have the following values:
+     - `prometheus` - for inserting data with [Prometheus remote write API](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write)
+     - `influx/write` or `influx/api/v2/write` - for inserting data with [Influx line protocol](https://docs.influxdata.com/influxdb/v1.7/write_protocols/line_protocol_tutorial/)
+
+* URLs for querying: `/select/<accountID>/prometheus/<suffix>`, where:
+  - `<accountID>` is an arbitrary number identifying data namespace for the query (aka tenant)
+  - `<suffix>` may have the following values:
+    - `api/v1/query` - performs [PromQL instant query](https://prometheus.io/docs/prometheus/latest/querying/api/#instant-queries)
+    - `api/v1/query_range` - performs [PromQL range query](https://prometheus.io/docs/prometheus/latest/querying/api/#range-queries)
+    - `api/v1/series` - performs [series query](https://prometheus.io/docs/prometheus/latest/querying/api/#finding-series-by-label-matchers)
+    - `api/v1/labels` - returns a [list of label names](https://prometheus.io/docs/prometheus/latest/querying/api/#getting-label-names)
+    - `api/v1/label/<label_name>/values` - returns values for the given `<label_name>` according [to API](https://prometheus.io/docs/prometheus/latest/querying/api/#querying-label-values)
+    - `federate` - returns [federated metrics](https://prometheus.io/docs/prometheus/latest/federation/)
+    - `api/v1/export` - exports raw data. See [this article](https://medium.com/@valyala/analyzing-prometheus-data-with-external-tools-5f3e5e147639) for details
+
+* `vmstorage` nodes provide the following HTTP endpoints on `8482` port:
+  - `/snapshot/create` - create [instant snapshot](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282),
+    which can be used for backups in background. Snapshots are created in `<storageDataPath>/snapshots` folder, where `<storageDataPath>` is the corresponding
+    command-line flag value.
+  - `/snapshot/list` - list available snasphots.
+  - `/snapshot/delete?snapshot=<id>` - delete the given snapshot.
+  - `/snapshot/delete_all` - delete all the snapshots.
+
+  Snapshots may be created independently on each `vmstorage` node. There is no need in synchronizing snapshots' creation
+  across `vmstorage` nodes.
+
+
+### Cluster resizing
+
+* `vminsert` and `vmselect` nodes are stateless and may be added / removed at any time.
+  Do not forget updating the list of these nodes on http load balancer.
+* `vmstorage` nodes own the ingested data, so they cannot be removed without data loss.
+
+Steps to add `vmstorage` node:
+
+1. Start new `vmstorage` node with the same `-retentionPeriod` as existing nodes in the cluster.
+2. Gradually restart all the `vmselect` nodes with new `-storageNode` arg containing `<new_vmstorage_host>:8401`.
+3. Gradually restart all the `vminsert` nodes with new `-storageNode` arg containing `<new_vmstorage_host>:8400`.
+
+
+### Cluster availability
+
+* HTTP load balancer must stop routing requests to unavailable `vminsert` and `vmselect` nodes.
+* The cluster remains available if at least a single `vmstorage` node exists:
+
+  - `vminsert` re-routes incoming data from unavailable `vmstorage` nodes to healthy `vmstorage` nodes
+  - `vmselect` continues serving partial responses if at least a single `vmstorage` node is available.
+
+
+### Updating / reconfiguring cluster nodes
+
+All the node types - `vminsert`, `vmselect` and `vmstorage` - may be updated via graceful shutdown.
+Send `SIGINT` signal to the corresponding process, wait until it finishes and then start new version
+with new configs.
+
+Cluster should remain in working state if at least a single node of each type remains available during
+the update process. See [cluster availability](#cluster-availability) section for details.
+
+
+### Helm
+
+Helm chart simplifies managing cluster version of VictoriaMetrics in Kubernetes.
+It is available in the `deployment/k8s/helm/victoria-metrics` folder.
+
+1. Install Cluster: `helm install -n <NAME> deployment/k8s/helm/victoria-mertrics` or `ENV=<NAME> make helm-install`.
+2. Upgrade Cluster: `helm upgrade <NAME> deployment/k8s/helm/victoria-mertrics` or `ENV=<NAME> make helm-upgrade`.
+3. Delete Cluster: `helm del --purge <NAME>` or `ENV=<NAME> make helm-delete`.
+
+Upgrade follows `Cluster resizing procedure` under the hood.
+
+
+### Replication and data safety
+
+VictoriaMetrics offloads replication to the underlying storage pointed by `-storageDataPath`.
+It is recommended storing data on [Google Compute Engine persistent disks](https://cloud.google.com/compute/docs/disks/#pdspecs),
+since they are protected from data loss and data corruption. They also provide consistently high performance
+and [may be resized](https://cloud.google.com/compute/docs/disks/add-persistent-disk) without downtime.
+HDD-based persistent disks should be enough for the majority of use cases.
+
+It is recommended using durable replicated persistent volumes in Kubernetes.
+
+
+### Backups
+
+It is recommended performing periodical backups from [instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282)
+for protecting from user errors such as accidental data deletion.
+
+The following steps must be performed for each `vmstorage` node for creating a backup:
+
+1. Create an instant snapshot by navigating to `/snapshot/create` HTTP handler. It will create snapshot and return its name.
+2. Archive the created snapshot from `<-storageDataPath>/snapshots/<snapshot_name>` folder using any suitable tool that follows symlinks. For instance,
+   `cp -L`, `rsync -L` or `scp -r`. The archival process doesn't interfere with `vmstorage` work, so it may be performed at any suitable time.
+   Incremental backups are possible with `rsync --delete`, which should [remove extraneous files from backup dir](https://askubuntu.com/questions/476041/how-do-i-make-rsync-delete-files-that-have-been-deleted-from-the-source-folder).
+3. Delete unused snapshots via `/snapshot/delete?snapshot=<snapshot_name>` or `/snapshot/delete_all` in order to free up occupied storage space.
+
+There is no need in synchronizing backups among all the `vmstorage` nodes.
+
+Restoring from backup:
+
+1. Stop `vmstorage` node with `kill -INT`.
+2. Delete all the contents of the directory pointed by `-storageDataPath` command-line flag.
+3. Copy all the contents of the backup directory to `-storageDataPath` directory.
+4. Start `vmstorage` node.
+
+
+## Community and contributions
+
+We are open to third-party pull requests provided they follow [KISS design principle](https://en.wikipedia.org/wiki/KISS_principle):
+
+- Prefer simple code and architecture.
+- Avoid complex abstractions.
+- Avoid magic code and fancy algorithms.
+- Avoid [big external dependencies](https://medium.com/@valyala/stripping-dependency-bloat-in-victoriametrics-docker-image-983fb5912b0d).
+- Minimize the number of moving parts in the distributed system.
+- Avoid automated decisions, which may hurt cluster availability, consistency or performance.
+
+Adhering `KISS` principle simplifies the resulting code and architecture, so it can be reviewed, understood and verified by many people.
+
+Due to `KISS` cluster version of VictoriaMetrics has no the following "features" popular in distributed computing world:
+
+- Fragile gossip protocols. See [failed attempt in Thanos](https://github.com/improbable-eng/thanos/blob/030bc345c12c446962225221795f4973848caab5/docs/proposals/completed/201809_gossip-removal.md).
+- Hard-to-understand-and-implement-properly [Paxos protocols](https://www.quora.com/In-distributed-systems-what-is-a-simple-explanation-of-the-Paxos-algorithm).
+- Complex replication schemes, which may go nuts in unforesseen edge cases. The replication is offloaded to the underlying durable replicated storage
+  such as [persistent disks in Google Compute Engine](https://cloud.google.com/compute/docs/disks/#pdspecs).
+- Automatic data reshuffling between storage nodes, which may hurt cluster performance and availability.
+- Automatic cluster resizing, which may cost you a lot of money if improperly configured.
+- Automatic discovering and addition of new nodes in the cluster, which may mix data between dev and prod clusters :)
+- Automatic leader election, which may result in split brain disaster on network errors.
+
+
+## Reporting bugs
+
+Report bugs and propose new features [here](https://github.com/VictoriaMetrics/VictoriaMetrics/issues).
+
+
+## Victoria Metrics Logo
 
 [Zip](VM_logo.zip) contains three folders with different image orientation (main color and inverted version).
 
@@ -40,24 +247,21 @@ Files included in each folder:
 * 2 EPS Adobe Illustrator EPS10 files
 
 
-#### Logo Usage Guidelines
+### Logo Usage Guidelines
 
-##### Font used: 
+#### Font used:
 
-* Lato Black 
+* Lato Black
 * Lato Regular
 
-##### Color Palette:
+#### Color Palette:
 
-* HEX [#110f0f](https://www.color-hex.com/color/110f0f) 
+* HEX [#110f0f](https://www.color-hex.com/color/110f0f)
 * HEX [#ffffff](https://www.color-hex.com/color/ffffff)
 
-#### We kindly ask:
+### We kindly ask:
 
 - Please don't use any other font instead of suggested.
 - There should be sufficient clear space around the logo.
 - Do not change spacing, alignment, or relative locations of the design elements.
 - Do not change the proportions of any of the design elements or the design itself. You    may resize as needed but must retain all proportions.
-
-
-

app/vminsert/Makefile

@@ -0,0 +1,36 @@
+# All these commands must run from repository root.
+
+run-vminsert:
+	APP_NAME=vminsert \
+	ARGS='-storageNode=localhost:8400' \
+	$(MAKE) run-via-docker
+
+vminsert:
+	APP_NAME=vminsert $(MAKE) app-local
+
+vminsert-race:
+	APP_NAME=vminsert RACE=-race $(MAKE) app-local
+
+vminsert-prod:
+	APP_NAME=vminsert $(MAKE) app-via-docker
+
+vminsert-prod-race:
+	APP_NAME=vminsert RACE=-race $(MAKE) app-via-docker
+
+vminsert-pure:
+	APP_NAME=vminsert $(MAKE) app-local-pure
+
+vminsert-pure-prod:
+	APP_NAME=vminsert APP_SUFFIX='-pure' DOCKER_OPTS='--env CGO_ENABLED=0' $(MAKE) app-via-docker
+
+package-vminsert:
+	APP_NAME=vminsert $(MAKE) package-via-docker
+
+package-vminsert-race:
+	APP_NAME=vminsert RACE=-race $(MAKE) package-via-docker
+
+publish-vminsert:
+	APP_NAME=vminsert $(MAKE) publish-via-docker
+
+publish-vminsert-race:
+	APP_NAME=vminsert RACE=-race $(MAKE) publish-via-docker

app/vminsert/README.md

@@ -0,0 +1 @@
+`vminsert` routes the ingested data to `vmstorage` nodes.

app/vminsert/common/gzip_reader.go

@@ -0,0 +1,30 @@
+package common
+
+import (
+	"compress/gzip"
+	"io"
+	"sync"
+)
+
+// GetGzipReader returns new gzip reader from the pool.
+//
+// Return back the gzip reader when it no longer needed with PutGzipReader.
+func GetGzipReader(r io.Reader) (*gzip.Reader, error) {
+	v := gzipReaderPool.Get()
+	if v == nil {
+		return gzip.NewReader(r)
+	}
+	zr := v.(*gzip.Reader)
+	if err := zr.Reset(r); err != nil {
+		return nil, err
+	}
+	return zr, nil
+}
+
+// PutGzipReader returns back gzip reader obtained via GetGzipReader.
+func PutGzipReader(zr *gzip.Reader) {
+	_ = zr.Close()
+	gzipReaderPool.Put(zr)
+}
+
+var gzipReaderPool sync.Pool

app/vminsert/common/lines_reader.go

@@ -0,0 +1,68 @@
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+)
+
+// The maximum size of a single line returned by ReadLinesBlock.
+const maxLineSize = 256 * 1024
+
+// Default size in bytes of a single block returned by ReadLinesBlock.
+const defaultBlockSize = 64 * 1024
+
+// ReadLinesBlock reads a block of lines delimited by '\n' from tailBuf and r into dstBuf.
+//
+// Trailing chars after the last newline are put into tailBuf.
+//
+// Returns (dstBuf, tailBuf).
+func ReadLinesBlock(r io.Reader, dstBuf, tailBuf []byte) ([]byte, []byte, error) {
+	if cap(dstBuf) < defaultBlockSize {
+		dstBuf = bytesutil.Resize(dstBuf, defaultBlockSize)
+	}
+	dstBuf = append(dstBuf[:0], tailBuf...)
+	tailBuf = tailBuf[:0]
+again:
+	n, err := r.Read(dstBuf[len(dstBuf):cap(dstBuf)])
+	// Check for error only if zero bytes read from r, i.e. no forward progress made.
+	// Otherwise process the read data.
+	if n == 0 {
+		if err == nil {
+			return dstBuf, tailBuf, fmt.Errorf("no forward progress made")
+		}
+		if err == io.EOF && len(dstBuf) > 0 {
+			// Missing newline in the end of stream. This is OK,
+			// so suppress io.EOF for now. It will be returned during the next
+			// call to ReadLinesBlock.
+			// This fixes https://github.com/VictoriaMetrics/VictoriaMetrics/issues/60 .
+			return dstBuf, tailBuf, nil
+		}
+		return dstBuf, tailBuf, err
+	}
+	dstBuf = dstBuf[:len(dstBuf)+n]
+
+	// Search for the last newline in dstBuf and put the rest into tailBuf.
+	nn := bytes.LastIndexByte(dstBuf[len(dstBuf)-n:], '\n')
+	if nn < 0 {
+		// Didn't found at least a single line.
+		if len(dstBuf) > maxLineSize {
+			return dstBuf, tailBuf, fmt.Errorf("too long line: more than %d bytes", maxLineSize)
+		}
+		if cap(dstBuf) < 2*len(dstBuf) {
+			// Increase dsbBuf capacity, so more data could be read into it.
+			dstBufLen := len(dstBuf)
+			dstBuf = bytesutil.Resize(dstBuf, 2*cap(dstBuf))
+			dstBuf = dstBuf[:dstBufLen]
+		}
+		goto again
+	}
+
+	// Found at least a single line. Return it.
+	nn += len(dstBuf) - n
+	tailBuf = append(tailBuf[:0], dstBuf[nn+1:]...)
+	dstBuf = dstBuf[:nn]
+	return dstBuf, tailBuf, nil
+}

app/vminsert/common/lines_reader_test.go

@@ -0,0 +1,213 @@
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"testing"
+)
+
+func TestReadLinesBlockFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		r := bytes.NewBufferString(s)
+		if _, _, err := ReadLinesBlock(r, nil, nil); err == nil {
+			t.Fatalf("expecting non-nil error")
+		}
+		sbr := &singleByteReader{
+			b: []byte(s),
+		}
+		if _, _, err := ReadLinesBlock(sbr, nil, nil); err == nil {
+			t.Fatalf("expecting non-nil error")
+		}
+		fr := &failureReader{}
+		if _, _, err := ReadLinesBlock(fr, nil, nil); err == nil {
+			t.Fatalf("expecting non-nil error")
+		}
+	}
+
+	// empty string
+	f("")
+
+	// too long string
+	b := make([]byte, maxLineSize+1)
+	f(string(b))
+}
+
+type failureReader struct{}
+
+func (fr *failureReader) Read(p []byte) (int, error) {
+	return 0, fmt.Errorf("some error")
+}
+
+func TestReadLinesBlockMultiLinesSingleByteReader(t *testing.T) {
+	f := func(s string, linesExpected []string) {
+		t.Helper()
+
+		r := &singleByteReader{
+			b: []byte(s),
+		}
+		var err error
+		var dstBuf, tailBuf []byte
+		var lines []string
+		for {
+			dstBuf, tailBuf, err = ReadLinesBlock(r, dstBuf, tailBuf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatalf("unexpected error in ReadLinesBlock(%q): %s", s, err)
+			}
+			lines = append(lines, string(dstBuf))
+		}
+		if !reflect.DeepEqual(lines, linesExpected) {
+			t.Fatalf("unexpected lines after reading %q: got %q; want %q", s, lines, linesExpected)
+		}
+	}
+
+	f("", nil)
+	f("foo", []string{"foo"})
+	f("foo\n", []string{"foo"})
+	f("foo\nbar", []string{"foo", "bar"})
+	f("\nfoo\nbar", []string{"", "foo", "bar"})
+	f("\nfoo\nbar\n", []string{"", "foo", "bar"})
+	f("\nfoo\nbar\n\n", []string{"", "foo", "bar", ""})
+}
+
+func TestReadLinesBlockMultiLinesBytesBuffer(t *testing.T) {
+	f := func(s string, linesExpected []string) {
+		t.Helper()
+
+		r := bytes.NewBufferString(s)
+		var err error
+		var dstBuf, tailBuf []byte
+		var lines []string
+		for {
+			dstBuf, tailBuf, err = ReadLinesBlock(r, dstBuf, tailBuf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatalf("unexpected error in ReadLinesBlock(%q): %s", s, err)
+			}
+			lines = append(lines, string(dstBuf))
+		}
+		if !reflect.DeepEqual(lines, linesExpected) {
+			t.Fatalf("unexpected lines after reading %q: got %q; want %q", s, lines, linesExpected)
+		}
+	}
+
+	f("", nil)
+	f("foo", []string{"foo"})
+	f("foo\n", []string{"foo"})
+	f("foo\nbar", []string{"foo", "bar"})
+	f("\nfoo\nbar", []string{"\nfoo", "bar"})
+	f("\nfoo\nbar\n", []string{"\nfoo\nbar"})
+	f("\nfoo\nbar\n\n", []string{"\nfoo\nbar\n"})
+}
+
+func TestReadLinesBlockSuccessSingleByteReader(t *testing.T) {
+	f := func(s, dstBufExpected, tailBufExpected string) {
+		t.Helper()
+
+		r := &singleByteReader{
+			b: []byte(s),
+		}
+		dstBuf, tailBuf, err := ReadLinesBlock(r, nil, nil)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if string(dstBuf) != dstBufExpected {
+			t.Fatalf("unexpected dstBuf; got %q; want %q; tailBuf=%q", dstBuf, dstBufExpected, tailBuf)
+		}
+		if string(tailBuf) != tailBufExpected {
+			t.Fatalf("unexpected tailBuf; got %q; want %q; dstBuf=%q", tailBuf, tailBufExpected, dstBuf)
+		}
+
+		// Verify the same with non-empty dstBuf and tailBuf
+		r = &singleByteReader{
+			b: []byte(s),
+		}
+		dstBuf, tailBuf, err = ReadLinesBlock(r, dstBuf, tailBuf[:0])
+		if err != nil {
+			t.Fatalf("non-empty bufs: unexpected error: %s", err)
+		}
+		if string(dstBuf) != dstBufExpected {
+			t.Fatalf("non-empty bufs: unexpected dstBuf; got %q; want %q; tailBuf=%q", dstBuf, dstBufExpected, tailBuf)
+		}
+		if string(tailBuf) != tailBufExpected {
+			t.Fatalf("non-empty bufs: unexpected tailBuf; got %q; want %q; dstBuf=%q", tailBuf, tailBufExpected, dstBuf)
+		}
+	}
+
+	f("\n", "", "")
+	f("foo\n", "foo", "")
+	f("\nfoo", "", "")
+	f("foo\nbar", "foo", "")
+	f("foo\nbar\nbaz", "foo", "")
+	f("foo", "foo", "")
+
+	// The maximum line size
+	b := make([]byte, maxLineSize+10)
+	b[maxLineSize] = '\n'
+	f(string(b), string(b[:maxLineSize]), "")
+}
+
+func TestReadLinesBlockSuccessBytesBuffer(t *testing.T) {
+	f := func(s, dstBufExpected, tailBufExpected string) {
+		t.Helper()
+
+		r := bytes.NewBufferString(s)
+		dstBuf, tailBuf, err := ReadLinesBlock(r, nil, nil)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if string(dstBuf) != dstBufExpected {
+			t.Fatalf("unexpected dstBuf; got %q; want %q; tailBuf=%q", dstBuf, dstBufExpected, tailBuf)
+		}
+		if string(tailBuf) != tailBufExpected {
+			t.Fatalf("unexpected tailBuf; got %q; want %q; dstBuf=%q", tailBuf, tailBufExpected, dstBuf)
+		}
+
+		// Verify the same with non-empty dstBuf and tailBuf
+		r = bytes.NewBufferString(s)
+		dstBuf, tailBuf, err = ReadLinesBlock(r, dstBuf, tailBuf[:0])
+		if err != nil {
+			t.Fatalf("non-empty bufs: unexpected error: %s", err)
+		}
+		if string(dstBuf) != dstBufExpected {
+			t.Fatalf("non-empty bufs: unexpected dstBuf; got %q; want %q; tailBuf=%q", dstBuf, dstBufExpected, tailBuf)
+		}
+		if string(tailBuf) != tailBufExpected {
+			t.Fatalf("non-empty bufs: unexpected tailBuf; got %q; want %q; dstBuf=%q", tailBuf, tailBufExpected, dstBuf)
+		}
+	}
+
+	f("\n", "", "")
+	f("foo\n", "foo", "")
+	f("\nfoo", "", "foo")
+	f("foo\nbar", "foo", "bar")
+	f("foo\nbar\nbaz", "foo\nbar", "baz")
+
+	// The maximum line size
+	b := make([]byte, maxLineSize+10)
+	b[maxLineSize] = '\n'
+	f(string(b), string(b[:maxLineSize]), string(b[maxLineSize+1:]))
+}
+
+type singleByteReader struct {
+	b []byte
+}
+
+func (sbr *singleByteReader) Read(p []byte) (int, error) {
+	if len(sbr.b) == 0 {
+		return 0, io.EOF
+	}
+	n := copy(p, sbr.b[:1])
+	sbr.b = sbr.b[n:]
+	if len(sbr.b) == 0 {
+		return n, io.EOF
+	}
+	return n, nil
+}

app/vminsert/concurrencylimiter/concurrencylimiter.go

@@ -0,0 +1,75 @@
+package concurrencylimiter
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"runtime"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var maxConcurrentInserts = flag.Int("maxConcurrentInserts", runtime.GOMAXPROCS(-1)*4, "The maximum number of concurrent inserts")
+
+var (
+	// ch is the channel for limiting concurrent calls to Do.
+	ch chan struct{}
+
+	// waitDuration is the amount of time to wait until at least a single
+	// concurrent Do call out of cap(ch) inserts is complete.
+	waitDuration = time.Second * 30
+)
+
+// Init initializes concurrencylimiter.
+//
+// Init must be called after flag.Parse call.
+func Init() {
+	ch = make(chan struct{}, *maxConcurrentInserts)
+}
+
+// Do calls f with the limited concurrency.
+func Do(f func() error) error {
+	// Limit the number of conurrent f calls in order to prevent from excess
+	// memory usage and CPU trashing.
+	select {
+	case ch <- struct{}{}:
+		err := f()
+		<-ch
+		return err
+	default:
+	}
+
+	// All the workers are busy.
+	// Sleep for up to waitDuration.
+	concurrencyLimitReached.Inc()
+	t := timerpool.Get(waitDuration)
+	select {
+	case ch <- struct{}{}:
+		timerpool.Put(t)
+		err := f()
+		<-ch
+		return err
+	case <-t.C:
+		timerpool.Put(t)
+		concurrencyLimitTimeout.Inc()
+		return &httpserver.ErrorWithStatusCode{
+			Err:        fmt.Errorf("the server is overloaded with %d concurrent inserts; either increase -maxConcurrentInserts or reduce the load", cap(ch)),
+			StatusCode: http.StatusServiceUnavailable,
+		}
+	}
+}
+
+var (
+	concurrencyLimitReached = metrics.NewCounter(`vm_concurrent_insert_limit_reached_total`)
+	concurrencyLimitTimeout = metrics.NewCounter(`vm_concurrent_insert_limit_timeout_total`)
+
+	_ = metrics.NewGauge(`vm_concurrent_insert_capacity`, func() float64 {
+		return float64(cap(ch))
+	})
+	_ = metrics.NewGauge(`vm_concurrent_insert_current`, func() float64 {
+		return float64(len(ch))
+	})
+)

app/vminsert/deployment/Dockerfile

@@ -0,0 +1,5 @@
+FROM scratch
+COPY --from=local/certs:1.0.2 /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
+COPY bin/vminsert-prod .
+EXPOSE 8480
+ENTRYPOINT ["/vminsert-prod"]

app/vminsert/graphite/parser.go

@@ -0,0 +1,190 @@
+package graphite
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+// Rows contains parsed graphite rows.
+type Rows struct {
+	Rows []Row
+
+	tagsPool []Tag
+}
+
+// Reset resets rs.
+func (rs *Rows) Reset() {
+	// Reset items, so they can be GC'ed
+
+	for i := range rs.Rows {
+		rs.Rows[i].reset()
+	}
+	rs.Rows = rs.Rows[:0]
+
+	for i := range rs.tagsPool {
+		rs.tagsPool[i].reset()
+	}
+	rs.tagsPool = rs.tagsPool[:0]
+}
+
+// Unmarshal unmarshals grahite plaintext protocol rows from s.
+//
+// See https://graphite.readthedocs.io/en/latest/feeding-carbon.html#the-plaintext-protocol
+//
+// s must be unchanged until rs is in use.
+func (rs *Rows) Unmarshal(s string) {
+	rs.Rows, rs.tagsPool = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0])
+}
+
+// Row is a single graphite row.
+type Row struct {
+	Metric    string
+	Tags      []Tag
+	Value     float64
+	Timestamp int64
+}
+
+func (r *Row) reset() {
+	r.Metric = ""
+	r.Tags = nil
+	r.Value = 0
+	r.Timestamp = 0
+}
+
+func (r *Row) unmarshal(s string, tagsPool []Tag) ([]Tag, error) {
+	r.reset()
+	n := strings.IndexByte(s, ' ')
+	if n < 0 {
+		return tagsPool, fmt.Errorf("cannot find whitespace between metric and value in %q", s)
+	}
+	metricAndTags := s[:n]
+	tail := s[n+1:]
+
+	n = strings.IndexByte(metricAndTags, ';')
+	if n < 0 {
+		// No tags
+		r.Metric = metricAndTags
+	} else {
+		// Tags found
+		r.Metric = metricAndTags[:n]
+		tagsStart := len(tagsPool)
+		var err error
+		tagsPool, err = unmarshalTags(tagsPool, metricAndTags[n+1:])
+		if err != nil {
+			return tagsPool, fmt.Errorf("cannot umarshal tags: %s", err)
+		}
+		tags := tagsPool[tagsStart:]
+		r.Tags = tags[:len(tags):len(tags)]
+	}
+	if len(r.Metric) == 0 {
+		return tagsPool, fmt.Errorf("metric cannot be empty")
+	}
+
+	n = strings.IndexByte(tail, ' ')
+	if n < 0 {
+		// There is no timestamp. Use default timestamp instead.
+		r.Value = fastfloat.ParseBestEffort(tail)
+		return tagsPool, nil
+	}
+	r.Value = fastfloat.ParseBestEffort(tail[:n])
+	r.Timestamp = fastfloat.ParseInt64BestEffort(tail[n+1:])
+	return tagsPool, nil
+}
+
+func unmarshalRows(dst []Row, s string, tagsPool []Tag) ([]Row, []Tag) {
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n < 0 {
+			// The last line.
+			return unmarshalRow(dst, s, tagsPool)
+		}
+		dst, tagsPool = unmarshalRow(dst, s[:n], tagsPool)
+		s = s[n+1:]
+	}
+	return dst, tagsPool
+}
+
+func unmarshalRow(dst []Row, s string, tagsPool []Tag) ([]Row, []Tag) {
+	if len(s) > 0 && s[len(s)-1] == '\r' {
+		s = s[:len(s)-1]
+	}
+	if len(s) == 0 {
+		// Skip empty line
+		return dst, tagsPool
+	}
+
+	if cap(dst) > len(dst) {
+		dst = dst[:len(dst)+1]
+	} else {
+		dst = append(dst, Row{})
+	}
+	r := &dst[len(dst)-1]
+	var err error
+	tagsPool, err = r.unmarshal(s, tagsPool)
+	if err != nil {
+		dst = dst[:len(dst)-1]
+		logger.Errorf("cannot unmarshal Graphite line %q: %s", s, err)
+		invalidLines.Inc()
+	}
+	return dst, tagsPool
+}
+
+var invalidLines = metrics.NewCounter(`vm_rows_invalid_total{type="graphite"}`)
+
+func unmarshalTags(dst []Tag, s string) ([]Tag, error) {
+	for {
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Tag{})
+		}
+		tag := &dst[len(dst)-1]
+
+		n := strings.IndexByte(s, ';')
+		if n < 0 {
+			// The last tag found
+			if err := tag.unmarshal(s); err != nil {
+				return dst[:len(dst)-1], err
+			}
+			if len(tag.Key) == 0 || len(tag.Value) == 0 {
+				// Skip empty tag
+				dst = dst[:len(dst)-1]
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n]); err != nil {
+			return dst[:len(dst)-1], err
+		}
+		s = s[n+1:]
+		if len(tag.Key) == 0 || len(tag.Value) == 0 {
+			// Skip empty tag
+			dst = dst[:len(dst)-1]
+		}
+	}
+}
+
+// Tag is a graphite tag.
+type Tag struct {
+	Key   string
+	Value string
+}
+
+func (t *Tag) reset() {
+	t.Key = ""
+	t.Value = ""
+}
+
+func (t *Tag) unmarshal(s string) error {
+	t.reset()
+	n := strings.IndexByte(s, '=')
+	if n < 0 {
+		return fmt.Errorf("missing tag value for %q", s)
+	}
+	t.Key = s[:n]
+	t.Value = s[n+1:]
+	return nil
+}

app/vminsert/graphite/parser_test.go

@@ -0,0 +1,154 @@
+package graphite
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+
+		// Try again
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+	}
+
+	// Missing metric
+	f(" 123 455")
+
+	// Missing value
+	f("aaa")
+
+	// missing tag
+	f("aa; 12 34")
+
+	// missing tag value
+	f("aa;bb 23 34")
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		rows.Reset()
+		if len(rows.Rows) != 0 {
+			t.Fatalf("non-empty rows after reset: %+v", rows.Rows)
+		}
+	}
+
+	// Empty line
+	f("", &Rows{})
+	f("\r", &Rows{})
+	f("\n\n", &Rows{})
+	f("\n\r\n", &Rows{})
+
+	// Single line
+	f("foobar -123.456 789", &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+		}},
+	})
+	f("foo.bar 123.456 789\n", &Rows{
+		Rows: []Row{{
+			Metric:    "foo.bar",
+			Value:     123.456,
+			Timestamp: 789,
+		}},
+	})
+
+	// Missing timestamp
+	f("aaa 1123", &Rows{
+		Rows: []Row{{
+			Metric: "aaa",
+			Value:  1123,
+		}},
+	})
+
+	// Tags
+	f("foo;bar=baz 1 2", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{{
+				Key:   "bar",
+				Value: "baz",
+			}},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+	// Empty tags
+	f("foo;bar=baz;aa=;x=y;=z 1 2", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{
+				{
+					Key:   "bar",
+					Value: "baz",
+				},
+				{
+					Key:   "x",
+					Value: "y",
+				},
+			},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+
+	// Multi lines
+	f("foo 0.3 2\naaa 3\nbar.baz 0.34 43\n", &Rows{
+		Rows: []Row{
+			{
+				Metric:    "foo",
+				Value:     0.3,
+				Timestamp: 2,
+			},
+			{
+				Metric: "aaa",
+				Value:  3,
+			},
+			{
+				Metric:    "bar.baz",
+				Value:     0.34,
+				Timestamp: 43,
+			},
+		},
+	})
+
+	// Multi lines with invalid line
+	f("foo 0.3 2\naaa\nbar.baz 0.34 43\n", &Rows{
+		Rows: []Row{
+			{
+				Metric:    "foo",
+				Value:     0.3,
+				Timestamp: 2,
+			},
+			{
+				Metric:    "bar.baz",
+				Value:     0.34,
+				Timestamp: 43,
+			},
+		},
+	})
+}

app/vminsert/graphite/parser_timing_test.go

@@ -0,0 +1,25 @@
+package graphite
+
+import (
+	"fmt"
+	"testing"
+)
+
+func BenchmarkRowsUnmarshal(b *testing.B) {
+	s := `cpu.usage_user 1.23 1234556768
+cpu.usage_system 23.344 1234556768
+cpu.usage_iowait 3.3443 1234556769
+cpu.usage_irq 0.34432 1234556768
+`
+	b.SetBytes(int64(len(s)))
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		var rows Rows
+		for pb.Next() {
+			rows.Unmarshal(s)
+			if len(rows.Rows) != 4 {
+				panic(fmt.Errorf("unexpected number of rows unmarshaled: got %d; want 4", len(rows.Rows)))
+			}
+		}
+	})
+}

app/vminsert/graphite/request_handler.go

@@ -0,0 +1,179 @@
+package graphite
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/common"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/tenantmetrics"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+var (
+	rowsInserted  = tenantmetrics.NewCounterMap(`vm_rows_inserted_total{type="graphite"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="graphite"}`)
+)
+
+// insertHandler processes remote write for graphite plaintext protocol.
+//
+// See https://graphite.readthedocs.io/en/latest/feeding-carbon.html#the-plaintext-protocol
+func insertHandler(at *auth.Token, r io.Reader) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(at, r)
+	})
+}
+
+func insertHandlerInternal(at *auth.Token, r io.Reader) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	for ctx.Read(r) {
+		if err := ctx.InsertRows(at); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows(at *auth.Token) error {
+	rows := ctx.Rows.Rows
+	ic := &ctx.Common
+	ic.Reset()
+	atCopy := *at
+	for i := range rows {
+		r := &rows[i]
+		ic.Labels = ic.Labels[:0]
+		ic.AddLabel("", r.Metric)
+		for j := range r.Tags {
+			tag := &r.Tags[j]
+			if atCopy.AccountID == 0 {
+				// Multi-tenancy support via custom tags.
+				// Do not allow overriding AccountID and ProjectID from atCopy for security reasons.
+				if tag.Key == "VictoriaMetrics_AccountID" {
+					atCopy.AccountID = uint32(fastfloat.ParseUint64BestEffort(tag.Value))
+				}
+				if atCopy.ProjectID == 0 && tag.Key == "VictoriaMetrics_ProjectID" {
+					atCopy.ProjectID = uint32(fastfloat.ParseUint64BestEffort(tag.Value))
+				}
+			}
+			ic.AddLabel(tag.Key, tag.Value)
+		}
+		if err := ic.WriteDataPoint(&atCopy, ic.Labels, r.Timestamp, r.Value); err != nil {
+			return err
+		}
+	}
+	// Assume that all the rows for a single connection belong to the same (AccountID, ProjectID).
+	rowsInserted.Get(&atCopy).Add(len(rows))
+	rowsPerInsert.Update(float64(len(rows)))
+	return ic.FlushBufs()
+}
+
+const flushTimeout = 3 * time.Second
+
+func (ctx *pushCtx) Read(r io.Reader) bool {
+	graphiteReadCalls.Inc()
+	if ctx.err != nil {
+		return false
+	}
+	if c, ok := r.(net.Conn); ok {
+		if err := c.SetReadDeadline(time.Now().Add(flushTimeout)); err != nil {
+			graphiteReadErrors.Inc()
+			ctx.err = fmt.Errorf("cannot set read deadline: %s", err)
+			return false
+		}
+	}
+	ctx.reqBuf, ctx.tailBuf, ctx.err = common.ReadLinesBlock(r, ctx.reqBuf, ctx.tailBuf)
+	if ctx.err != nil {
+		if ne, ok := ctx.err.(net.Error); ok && ne.Timeout() {
+			// Flush the read data on timeout and try reading again.
+			ctx.err = nil
+		} else {
+			if ctx.err != io.EOF {
+				graphiteReadErrors.Inc()
+				ctx.err = fmt.Errorf("cannot read graphite plaintext protocol data: %s", ctx.err)
+			}
+			return false
+		}
+	}
+	ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf))
+
+	// Fill missing timestamps with the current timestamp rounded to seconds.
+	currentTimestamp := time.Now().Unix()
+	rows := ctx.Rows.Rows
+	for i := range rows {
+		r := &rows[i]
+		if r.Timestamp == 0 {
+			r.Timestamp = currentTimestamp
+		}
+	}
+
+	// Convert timestamps from seconds to milliseconds.
+	for i := range rows {
+		rows[i].Timestamp *= 1e3
+	}
+
+	return true
+}
+
+type pushCtx struct {
+	Rows   Rows
+	Common netstorage.InsertCtx
+
+	reqBuf  []byte
+	tailBuf []byte
+
+	err error
+}
+
+func (ctx *pushCtx) Error() error {
+	if ctx.err == io.EOF {
+		return nil
+	}
+	return ctx.err
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Rows.Reset()
+	ctx.Common.Reset()
+	ctx.reqBuf = ctx.reqBuf[:0]
+	ctx.tailBuf = ctx.tailBuf[:0]
+
+	ctx.err = nil
+}
+
+var (
+	graphiteReadCalls  = metrics.NewCounter(`vm_read_calls_total{name="graphite"}`)
+	graphiteReadErrors = metrics.NewCounter(`vm_read_errors_total{name="graphite"}`)
+)
+
+func getPushCtx() *pushCtx {
+	select {
+	case ctx := <-pushCtxPoolCh:
+		return ctx
+	default:
+		if v := pushCtxPool.Get(); v != nil {
+			return v.(*pushCtx)
+		}
+		return &pushCtx{}
+	}
+}
+
+func putPushCtx(ctx *pushCtx) {
+	ctx.reset()
+	select {
+	case pushCtxPoolCh <- ctx:
+	default:
+		pushCtxPool.Put(ctx)
+	}
+}
+
+var pushCtxPool sync.Pool
+var pushCtxPoolCh = make(chan *pushCtx, runtime.GOMAXPROCS(-1))

app/vminsert/graphite/server.go

@@ -0,0 +1,141 @@
+package graphite
+
+import (
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/netutil"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	writeRequestsTCP = metrics.NewCounter(`vm_graphite_requests_total{name="write", net="tcp"}`)
+	writeErrorsTCP   = metrics.NewCounter(`vm_graphite_request_errors_total{name="write", net="tcp"}`)
+
+	writeRequestsUDP = metrics.NewCounter(`vm_graphite_requests_total{name="write", net="udp"}`)
+	writeErrorsUDP   = metrics.NewCounter(`vm_graphite_request_errors_total{name="write", net="udp"}`)
+)
+
+// Serve starts graphite server on the given addr.
+func Serve(addr string) {
+	logger.Infof("starting TCP Graphite server at %q", addr)
+	lnTCP, err := netutil.NewTCPListener("graphite", addr)
+	if err != nil {
+		logger.Fatalf("cannot start TCP Graphite server at %q: %s", addr, err)
+	}
+	listenerTCP = lnTCP
+
+	logger.Infof("starting UDP Graphite server at %q", addr)
+	lnUDP, err := net.ListenPacket("udp4", addr)
+	if err != nil {
+		logger.Fatalf("cannot start UDP Graphite server at %q: %s", addr, err)
+	}
+	listenerUDP = lnUDP
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		serveTCP(listenerTCP)
+		logger.Infof("stopped TCP Graphite server at %q", addr)
+	}()
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		serveUDP(listenerUDP)
+		logger.Infof("stopped UDP Graphite server at %q", addr)
+	}()
+	wg.Wait()
+}
+
+func serveTCP(ln net.Listener) {
+	for {
+		c, err := ln.Accept()
+		if err != nil {
+			if ne, ok := err.(net.Error); ok {
+				if ne.Temporary() {
+					time.Sleep(time.Second)
+					continue
+				}
+				if strings.Contains(err.Error(), "use of closed network connection") {
+					break
+				}
+				logger.Fatalf("unrecoverable error when accepting TCP Graphite connections: %s", err)
+			}
+			logger.Fatalf("unexpected error when accepting TCP Graphite connections: %s", err)
+		}
+		go func() {
+			writeRequestsTCP.Inc()
+			var at auth.Token // TODO: properly initialize auth token
+			if err := insertHandler(&at, c); err != nil {
+				writeErrorsTCP.Inc()
+				logger.Errorf("error in TCP Graphite conn %q<->%q: %s", c.LocalAddr(), c.RemoteAddr(), err)
+			}
+			_ = c.Close()
+		}()
+	}
+}
+
+func serveUDP(ln net.PacketConn) {
+	gomaxprocs := runtime.GOMAXPROCS(-1)
+	var wg sync.WaitGroup
+	for i := 0; i < gomaxprocs; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var bb bytesutil.ByteBuffer
+			bb.B = bytesutil.Resize(bb.B, 64*1024)
+			var at auth.Token // TODO: properly initialize auth token
+			for {
+				bb.Reset()
+				bb.B = bb.B[:cap(bb.B)]
+				n, addr, err := ln.ReadFrom(bb.B)
+				if err != nil {
+					writeErrorsUDP.Inc()
+					if ne, ok := err.(net.Error); ok {
+						if ne.Temporary() {
+							time.Sleep(time.Second)
+							continue
+						}
+						if strings.Contains(err.Error(), "use of closed network connection") {
+							break
+						}
+					}
+					logger.Errorf("cannot read Graphite UDP data: %s", err)
+					continue
+				}
+				bb.B = bb.B[:n]
+				writeRequestsUDP.Inc()
+				if err := insertHandler(&at, bb.NewReader()); err != nil {
+					writeErrorsUDP.Inc()
+					logger.Errorf("error in UDP Graphite conn %q<->%q: %s", ln.LocalAddr(), addr, err)
+					continue
+				}
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+var (
+	listenerTCP net.Listener
+	listenerUDP net.PacketConn
+)
+
+// Stop stops the server.
+func Stop() {
+	logger.Infof("stopping TCP Graphite server at %q...", listenerTCP.Addr())
+	if err := listenerTCP.Close(); err != nil {
+		logger.Errorf("cannot close TCP Graphite server: %s", err)
+	}
+	logger.Infof("stopping UDP Graphite server at %q...", listenerUDP.LocalAddr())
+	if err := listenerUDP.Close(); err != nil {
+		logger.Errorf("cannot close UDP Graphite server: %s", err)
+	}
+}

app/vminsert/influx/parser.go

@@ -0,0 +1,399 @@
+package influx
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+// Rows contains parsed influx rows.
+type Rows struct {
+	Rows []Row
+
+	tagsPool   []Tag
+	fieldsPool []Field
+}
+
+// Reset resets rs.
+func (rs *Rows) Reset() {
+	// Reset rows, tags and fields in order to remove references to old data,
+	// so GC could collect it.
+
+	for i := range rs.Rows {
+		rs.Rows[i].reset()
+	}
+	rs.Rows = rs.Rows[:0]
+
+	for i := range rs.tagsPool {
+		rs.tagsPool[i].reset()
+	}
+	rs.tagsPool = rs.tagsPool[:0]
+
+	for i := range rs.fieldsPool {
+		rs.fieldsPool[i].reset()
+	}
+	rs.fieldsPool = rs.fieldsPool[:0]
+}
+
+// Unmarshal unmarshals influx line protocol rows from s.
+//
+// See https://docs.influxdata.com/influxdb/v1.7/write_protocols/line_protocol_tutorial/
+//
+// s must be unchanged until rs is in use.
+func (rs *Rows) Unmarshal(s string) {
+	rs.Rows, rs.tagsPool, rs.fieldsPool = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0], rs.fieldsPool[:0])
+}
+
+// Row is a single influx row.
+type Row struct {
+	Measurement string
+	Tags        []Tag
+	Fields      []Field
+	Timestamp   int64
+}
+
+func (r *Row) reset() {
+	r.Measurement = ""
+	r.Tags = nil
+	r.Fields = nil
+	r.Timestamp = 0
+}
+
+func (r *Row) unmarshal(s string, tagsPool []Tag, fieldsPool []Field, noEscapeChars bool) ([]Tag, []Field, error) {
+	r.reset()
+	n := nextUnescapedChar(s, ' ', noEscapeChars)
+	if n < 0 {
+		return tagsPool, fieldsPool, fmt.Errorf("cannot find Whitespace I in %q", s)
+	}
+	measurementTags := s[:n]
+	s = s[n+1:]
+
+	// Parse measurement and tags
+	var err error
+	n = nextUnescapedChar(measurementTags, ',', noEscapeChars)
+	if n >= 0 {
+		tagsStart := len(tagsPool)
+		tagsPool, err = unmarshalTags(tagsPool, measurementTags[n+1:], noEscapeChars)
+		if err != nil {
+			return tagsPool, fieldsPool, err
+		}
+		tags := tagsPool[tagsStart:]
+		r.Tags = tags[:len(tags):len(tags)]
+		measurementTags = measurementTags[:n]
+	}
+	r.Measurement = unescapeTagValue(measurementTags, noEscapeChars)
+	if len(r.Measurement) == 0 {
+		return tagsPool, fieldsPool, fmt.Errorf("measurement cannot be empty. measurementTags=%q", s)
+	}
+
+	// Parse fields
+	fieldsStart := len(fieldsPool)
+	hasQuotedFields := nextUnescapedChar(s, '"', noEscapeChars) >= 0
+	n = nextUnquotedChar(s, ' ', noEscapeChars, hasQuotedFields)
+	if n < 0 {
+		// No timestamp.
+		fieldsPool, err = unmarshalInfluxFields(fieldsPool, s, noEscapeChars, hasQuotedFields)
+		if err != nil {
+			return tagsPool, fieldsPool, err
+		}
+		fields := fieldsPool[fieldsStart:]
+		r.Fields = fields[:len(fields):len(fields)]
+		return tagsPool, fieldsPool, nil
+	}
+	fieldsPool, err = unmarshalInfluxFields(fieldsPool, s[:n], noEscapeChars, hasQuotedFields)
+	if err != nil {
+		return tagsPool, fieldsPool, err
+	}
+	r.Fields = fieldsPool[fieldsStart:]
+	s = s[n+1:]
+
+	// Parse timestamp
+	timestamp := fastfloat.ParseInt64BestEffort(s)
+	if timestamp == 0 && s != "0" {
+		return tagsPool, fieldsPool, fmt.Errorf("cannot parse timestamp %q", s)
+	}
+	r.Timestamp = timestamp
+	return tagsPool, fieldsPool, nil
+}
+
+// Tag represents influx tag.
+type Tag struct {
+	Key   string
+	Value string
+}
+
+func (tag *Tag) reset() {
+	tag.Key = ""
+	tag.Value = ""
+}
+
+func (tag *Tag) unmarshal(s string, noEscapeChars bool) error {
+	tag.reset()
+	n := nextUnescapedChar(s, '=', noEscapeChars)
+	if n < 0 {
+		return fmt.Errorf("missing tag value for %q", s)
+	}
+	tag.Key = unescapeTagValue(s[:n], noEscapeChars)
+	tag.Value = unescapeTagValue(s[n+1:], noEscapeChars)
+	return nil
+}
+
+// Field represents influx field.
+type Field struct {
+	Key   string
+	Value float64
+}
+
+func (f *Field) reset() {
+	f.Key = ""
+	f.Value = 0
+}
+
+func (f *Field) unmarshal(s string, noEscapeChars, hasQuotedFields bool) error {
+	f.reset()
+	n := nextUnescapedChar(s, '=', noEscapeChars)
+	if n < 0 {
+		return fmt.Errorf("missing field value for %q", s)
+	}
+	f.Key = unescapeTagValue(s[:n], noEscapeChars)
+	if len(f.Key) == 0 {
+		return fmt.Errorf("field key cannot be empty")
+	}
+	v, err := parseFieldValue(s[n+1:], hasQuotedFields)
+	if err != nil {
+		return fmt.Errorf("cannot parse field value for %q: %s", f.Key, err)
+	}
+	f.Value = v
+	return nil
+}
+
+func unmarshalRows(dst []Row, s string, tagsPool []Tag, fieldsPool []Field) ([]Row, []Tag, []Field) {
+	noEscapeChars := strings.IndexByte(s, '\\') < 0
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n < 0 {
+			// The last line.
+			return unmarshalRow(dst, s, tagsPool, fieldsPool, noEscapeChars)
+		}
+		dst, tagsPool, fieldsPool = unmarshalRow(dst, s[:n], tagsPool, fieldsPool, noEscapeChars)
+		s = s[n+1:]
+	}
+	return dst, tagsPool, fieldsPool
+}
+
+func unmarshalRow(dst []Row, s string, tagsPool []Tag, fieldsPool []Field, noEscapeChars bool) ([]Row, []Tag, []Field) {
+	if len(s) > 0 && s[len(s)-1] == '\r' {
+		s = s[:len(s)-1]
+	}
+	if len(s) == 0 {
+		// Skip empty line
+		return dst, tagsPool, fieldsPool
+	}
+	if s[0] == '#' {
+		// Skip comment
+		return dst, tagsPool, fieldsPool
+	}
+
+	if cap(dst) > len(dst) {
+		dst = dst[:len(dst)+1]
+	} else {
+		dst = append(dst, Row{})
+	}
+	r := &dst[len(dst)-1]
+	var err error
+	tagsPool, fieldsPool, err = r.unmarshal(s, tagsPool, fieldsPool, noEscapeChars)
+	if err != nil {
+		dst = dst[:len(dst)-1]
+		logger.Errorf("cannot unmarshal Influx line %q: %s; skipping it", s, err)
+		invalidLines.Inc()
+	}
+	return dst, tagsPool, fieldsPool
+}
+
+var invalidLines = metrics.NewCounter(`vm_rows_invalid_total{type="influx"}`)
+
+func unmarshalTags(dst []Tag, s string, noEscapeChars bool) ([]Tag, error) {
+	for {
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Tag{})
+		}
+		tag := &dst[len(dst)-1]
+		n := nextUnescapedChar(s, ',', noEscapeChars)
+		if n < 0 {
+			if err := tag.unmarshal(s, noEscapeChars); err != nil {
+				return dst[:len(dst)-1], err
+			}
+			if len(tag.Key) == 0 || len(tag.Value) == 0 {
+				// Skip empty tag
+				dst = dst[:len(dst)-1]
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n], noEscapeChars); err != nil {
+			return dst[:len(dst)-1], err
+		}
+		s = s[n+1:]
+		if len(tag.Key) == 0 || len(tag.Value) == 0 {
+			// Skip empty tag
+			dst = dst[:len(dst)-1]
+		}
+	}
+}
+
+func unmarshalInfluxFields(dst []Field, s string, noEscapeChars, hasQuotedFields bool) ([]Field, error) {
+	for {
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Field{})
+		}
+		f := &dst[len(dst)-1]
+		n := nextUnquotedChar(s, ',', noEscapeChars, hasQuotedFields)
+		if n < 0 {
+			if err := f.unmarshal(s, noEscapeChars, hasQuotedFields); err != nil {
+				return dst, err
+			}
+			return dst, nil
+		}
+		if err := f.unmarshal(s[:n], noEscapeChars, hasQuotedFields); err != nil {
+			return dst, err
+		}
+		s = s[n+1:]
+	}
+}
+
+func unescapeTagValue(s string, noEscapeChars bool) string {
+	if noEscapeChars {
+		// Fast path - no escape chars.
+		return s
+	}
+	n := strings.IndexByte(s, '\\')
+	if n < 0 {
+		return s
+	}
+
+	// Slow path. Remove escape chars.
+	dst := make([]byte, 0, len(s))
+	for {
+		dst = append(dst, s[:n]...)
+		s = s[n+1:]
+		if len(s) == 0 {
+			return string(append(dst, '\\'))
+		}
+		ch := s[0]
+		if ch != ' ' && ch != ',' && ch != '=' && ch != '\\' {
+			dst = append(dst, '\\')
+		}
+		dst = append(dst, ch)
+		s = s[1:]
+		n = strings.IndexByte(s, '\\')
+		if n < 0 {
+			return string(append(dst, s...))
+		}
+	}
+}
+
+func parseFieldValue(s string, hasQuotedFields bool) (float64, error) {
+	if len(s) == 0 {
+		return 0, fmt.Errorf("field value cannot be empty")
+	}
+	if hasQuotedFields && s[0] == '"' {
+		if len(s) < 2 || s[len(s)-1] != '"' {
+			return 0, fmt.Errorf("missing closing quote for quoted field value %s", s)
+		}
+		// Try converting quoted string to number, since sometimes Influx agents
+		// send numbers as strings.
+		s = s[1 : len(s)-1]
+		return fastfloat.ParseBestEffort(s), nil
+	}
+	ch := s[len(s)-1]
+	if ch == 'i' {
+		// Integer value
+		ss := s[:len(s)-1]
+		n := fastfloat.ParseInt64BestEffort(ss)
+		return float64(n), nil
+	}
+	if ch == 'u' {
+		// Unsigned integer value
+		ss := s[:len(s)-1]
+		n := fastfloat.ParseUint64BestEffort(ss)
+		return float64(n), nil
+	}
+	if s == "t" || s == "T" || s == "true" || s == "True" || s == "TRUE" {
+		return 1, nil
+	}
+	if s == "f" || s == "F" || s == "false" || s == "False" || s == "FALSE" {
+		return 0, nil
+	}
+	return fastfloat.ParseBestEffort(s), nil
+}
+
+func nextUnescapedChar(s string, ch byte, noEscapeChars bool) int {
+	if noEscapeChars {
+		// Fast path: just search for ch in s, since s has no escape chars.
+		return strings.IndexByte(s, ch)
+	}
+
+	sOrig := s
+again:
+	n := strings.IndexByte(s, ch)
+	if n < 0 {
+		return -1
+	}
+	if n == 0 {
+		return len(sOrig) - len(s) + n
+	}
+	if s[n-1] != '\\' {
+		return len(sOrig) - len(s) + n
+	}
+	nOrig := n
+	slashes := 0
+	for n > 0 && s[n-1] == '\\' {
+		slashes++
+		n--
+	}
+	if slashes&1 == 0 {
+		return len(sOrig) - len(s) + nOrig
+	}
+	s = s[nOrig+1:]
+	goto again
+}
+
+func nextUnquotedChar(s string, ch byte, noEscapeChars, hasQuotedFields bool) int {
+	if !hasQuotedFields {
+		return nextUnescapedChar(s, ch, noEscapeChars)
+	}
+	sOrig := s
+	for {
+		n := nextUnescapedChar(s, ch, noEscapeChars)
+		if n < 0 {
+			return -1
+		}
+		if !isInQuote(s[:n], noEscapeChars) {
+			return n + len(sOrig) - len(s)
+		}
+		s = s[n+1:]
+		n = nextUnescapedChar(s, '"', noEscapeChars)
+		if n < 0 {
+			return -1
+		}
+		s = s[n+1:]
+	}
+}
+
+func isInQuote(s string, noEscapeChars bool) bool {
+	isQuote := false
+	for {
+		n := nextUnescapedChar(s, '"', noEscapeChars)
+		if n < 0 {
+			return isQuote
+		}
+		isQuote = !isQuote
+		s = s[n+1:]
+	}
+}

app/vminsert/influx/parser_test.go

@@ -0,0 +1,430 @@
+package influx
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNextUnquotedChar(t *testing.T) {
+	f := func(s string, ch byte, noUnescape bool, nExpected int) {
+		t.Helper()
+		n := nextUnquotedChar(s, ch, noUnescape, true)
+		if n != nExpected {
+			t.Fatalf("unexpected n for nextUnqotedChar(%q, '%c', %v); got %d; want %d", s, ch, noUnescape, n, nExpected)
+		}
+	}
+
+	f(``, ' ', false, -1)
+	f(``, ' ', true, -1)
+	f(`""`, ' ', false, -1)
+	f(`""`, ' ', true, -1)
+	f(`"foo bar\" " baz`, ' ', false, 12)
+	f(`"foo bar\" " baz`, ' ', true, 10)
+}
+
+func TestNextUnescapedChar(t *testing.T) {
+	f := func(s string, ch byte, noUnescape bool, nExpected int) {
+		t.Helper()
+		n := nextUnescapedChar(s, ch, noUnescape)
+		if n != nExpected {
+			t.Fatalf("unexpected n for nextUnescapedChar(%q, '%c', %v); got %d; want %d", s, ch, noUnescape, n, nExpected)
+		}
+	}
+
+	f("", ' ', true, -1)
+	f("", ' ', false, -1)
+	f(" ", ' ', true, 0)
+	f(" ", ' ', false, 0)
+	f("x y", ' ', true, 1)
+	f("x y", ' ', false, 1)
+	f(`x\  y`, ' ', true, 2)
+	f(`x\  y`, ' ', false, 3)
+	f(`\\,`, ',', true, 2)
+	f(`\\,`, ',', false, 2)
+	f(`\\\=`, '=', true, 3)
+	f(`\\\=`, '=', false, -1)
+	f(`\\\=aa`, '=', true, 3)
+	f(`\\\=aa`, '=', false, -1)
+	f(`\\\=a=a`, '=', true, 3)
+	f(`\\\=a=a`, '=', false, 5)
+	f(`a\`, ' ', true, -1)
+	f(`a\`, ' ', false, -1)
+}
+
+func TestUnescapeTagValue(t *testing.T) {
+	f := func(s, sExpected string) {
+		t.Helper()
+		ss := unescapeTagValue(s, false)
+		if ss != sExpected {
+			t.Fatalf("unexpected value for %q; got %q; want %q", s, ss, sExpected)
+		}
+	}
+
+	f("", "")
+	f("x", "x")
+	f("foobar", "foobar")
+	f("привет", "привет")
+	f(`\a\b\cd`, `\a\b\cd`)
+	f(`\`, `\`)
+	f(`foo\`, `foo\`)
+	f(`\,foo\\\=\ bar`, `,foo\= bar`)
+}
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("expecting zero rows; got %d rows", len(rows.Rows))
+		}
+
+		// Try again
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("expecting zero rows; got %d rows", len(rows.Rows))
+		}
+	}
+
+	// Missing measurement
+	f(",foo=bar baz=123")
+
+	// No fields
+	f("foo")
+	f("foo,bar=baz 1234")
+
+	// Missing tag value
+	f("foo,bar")
+	f("foo,bar baz")
+	f("foo,bar=123, 123")
+
+	// Missing field value
+	f("foo bar")
+	f("foo bar=")
+	f("foo bar=,baz=23 123")
+	f("foo bar=1, 123")
+	f(`foo bar=" 123`)
+	f(`foo bar="123`)
+	f(`foo bar=",123`)
+	f(`foo bar=a"", 123`)
+
+	// Missing field name
+	f("foo =123")
+	f("foo =123\nbar")
+
+	// Invalid timestamp
+	f("foo bar=123 baz")
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		rows.Reset()
+		if len(rows.Rows) != 0 {
+			t.Fatalf("non-empty rows after reset: %+v", rows.Rows)
+		}
+	}
+
+	// Empty line
+	f("", &Rows{})
+	f("\n\n", &Rows{})
+	f("\n\r\n", &Rows{})
+
+	// Comment
+	f("\n# foobar\n", &Rows{})
+	f("#foobar baz", &Rows{})
+	f("#foobar baz\n#sss", &Rows{})
+
+	// Minimal line without tags and timestamp
+	f("foo bar=123", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+	f("# comment\nfoo bar=123\r\n#comment2 sdsf dsf", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+	f("foo bar=123\n", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+
+	// Line without tags and with a timestamp.
+	f("foo bar=123.45 -345", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123.45,
+			}},
+			Timestamp: -345,
+		}},
+	})
+
+	// Line with a single tag
+	f("foo,tag1=xyz bar=123", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Tags: []Tag{{
+				Key:   "tag1",
+				Value: "xyz",
+			}},
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+
+	// Line with multiple tags
+	f("foo,tag1=xyz,tag2=43as bar=123", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Tags: []Tag{
+				{
+					Key:   "tag1",
+					Value: "xyz",
+				},
+				{
+					Key:   "tag2",
+					Value: "43as",
+				},
+			},
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+
+	// Line with empty tag values
+	f("foo,tag1=xyz,tagN=,tag2=43as,=xxx bar=123", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Tags: []Tag{
+				{
+					Key:   "tag1",
+					Value: "xyz",
+				},
+				{
+					Key:   "tag2",
+					Value: "43as",
+				},
+			},
+			Fields: []Field{{
+				Key:   "bar",
+				Value: 123,
+			}},
+		}},
+	})
+
+	// Line with multiple tags, multiple fields and timestamp
+	f(`system,host=ip-172-16-10-144 uptime_format="3 days, 21:01",quoted_float="-1.23",quoted_int="123" 1557761040000000000`, &Rows{
+		Rows: []Row{{
+			Measurement: "system",
+			Tags: []Tag{{
+				Key:   "host",
+				Value: "ip-172-16-10-144",
+			}},
+			Fields: []Field{
+				{
+					Key:   "uptime_format",
+					Value: 0,
+				},
+				{
+					Key:   "quoted_float",
+					Value: -1.23,
+				},
+				{
+					Key:   "quoted_int",
+					Value: 123,
+				},
+			},
+			Timestamp: 1557761040000000000,
+		}},
+	})
+	f(`foo,tag1=xyz,tag2=43as bar=-123e4,x=True,y=-45i,z=f,aa="f,= \"a",bb=23u 48934`, &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Tags: []Tag{
+				{
+					Key:   "tag1",
+					Value: "xyz",
+				},
+				{
+					Key:   "tag2",
+					Value: "43as",
+				},
+			},
+			Fields: []Field{
+				{
+					Key:   "bar",
+					Value: -123e4,
+				},
+				{
+					Key:   "x",
+					Value: 1,
+				},
+				{
+					Key:   "y",
+					Value: -45,
+				},
+				{
+					Key:   "z",
+					Value: 0,
+				},
+				{
+					Key:   "aa",
+					Value: 0,
+				},
+				{
+					Key:   "bb",
+					Value: 23,
+				},
+			},
+			Timestamp: 48934,
+		}},
+	})
+
+	// Escape chars
+	f(`fo\,bar\=baz,x\=\b=\\a\,\=\q\  \\\a\=\,=4.34`, &Rows{
+		Rows: []Row{{
+			Measurement: `fo,bar=baz`,
+			Tags: []Tag{{
+				Key:   `x=\b`,
+				Value: `\a,=\q `,
+			}},
+			Fields: []Field{{
+				Key:   `\\a=,`,
+				Value: 4.34,
+			}},
+		}},
+	})
+
+	// Multiple lines
+	f("foo,tag=xyz field=1.23 48934\n"+
+		"bar x=-1i\n\n", &Rows{
+		Rows: []Row{
+			{
+				Measurement: "foo",
+				Tags: []Tag{{
+					Key:   "tag",
+					Value: "xyz",
+				}},
+				Fields: []Field{{
+					Key:   "field",
+					Value: 1.23,
+				}},
+				Timestamp: 48934,
+			},
+			{
+				Measurement: "bar",
+				Fields: []Field{{
+					Key:   "x",
+					Value: -1,
+				}},
+			},
+		},
+	})
+
+	// Multiple lines with invalid line in the middle.
+	f("foo,tag=xyz field=1.23 48934\n"+
+		"invalid line\n"+
+		"bar x=-1i\n\n", &Rows{
+		Rows: []Row{
+			{
+				Measurement: "foo",
+				Tags: []Tag{{
+					Key:   "tag",
+					Value: "xyz",
+				}},
+				Fields: []Field{{
+					Key:   "field",
+					Value: 1.23,
+				}},
+				Timestamp: 48934,
+			},
+			{
+				Measurement: "bar",
+				Fields: []Field{{
+					Key:   "x",
+					Value: -1,
+				}},
+			},
+		},
+	})
+
+	// No newline after the second line.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/82
+	f("foo,tag=xyz field=1.23 48934\n"+
+		"bar x=-1i", &Rows{
+		Rows: []Row{
+			{
+				Measurement: "foo",
+				Tags: []Tag{{
+					Key:   "tag",
+					Value: "xyz",
+				}},
+				Fields: []Field{{
+					Key:   "field",
+					Value: 1.23,
+				}},
+				Timestamp: 48934,
+			},
+			{
+				Measurement: "bar",
+				Fields: []Field{{
+					Key:   "x",
+					Value: -1,
+				}},
+			},
+		},
+	})
+
+	f("x,y=z,g=p:\\ \\ 5432\\,\\ gp\\ mon\\ [lol]\\ con10\\ cmd5\\ SELECT f=1", &Rows{
+		Rows: []Row{{
+			Measurement: "x",
+			Tags: []Tag{
+				{
+					Key:   "y",
+					Value: "z",
+				},
+				{
+					Key:   "g",
+					Value: "p:  5432, gp mon [lol] con10 cmd5 SELECT",
+				},
+			},
+			Fields: []Field{{
+				Key:   "f",
+				Value: 1,
+			}},
+		}},
+	})
+}

app/vminsert/influx/parser_timing_test.go

@@ -0,0 +1,25 @@
+package influx
+
+import (
+	"fmt"
+	"testing"
+)
+
+func BenchmarkRowsUnmarshal(b *testing.B) {
+	s := `cpu usage_user=1.23,usage_system=4.34,usage_iowait=0.1112 1234556768
+cpu usage_user=1.23,usage_system=4.34,usage_iowait=0.1112 123455676344
+aaa usage_user=1.23,usage_system=4.34,usage_iowait=0.1112 123455676344
+bbb usage_user=1.23,usage_system=4.34,usage_iowait=0.1112 123455676344
+`
+	b.SetBytes(int64(len(s)))
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		var rows Rows
+		for pb.Next() {
+			rows.Unmarshal(s)
+			if len(rows.Rows) != 4 {
+				panic(fmt.Errorf("unexpected number of rows parsed; got %d; want 4", len(rows.Rows)))
+			}
+		}
+	})
+}

app/vminsert/influx/request_handler.go

@@ -0,0 +1,229 @@
+package influx
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/common"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/tenantmetrics"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	measurementFieldSeparator = flag.String("influxMeasurementFieldSeparator", "_", "Separator for `{measurement}{separator}{field_name}` metric name when inserted via Influx line protocol")
+	skipSingleField           = flag.Bool("influxSkipSingleField", false, "Uses `{measurement}` instead of `{measurement}{separator}{field_name}` for metic name if Influx line contains only a single field")
+)
+
+var (
+	rowsInserted  = tenantmetrics.NewCounterMap(`vm_rows_inserted_total{type="influx"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="influx"}`)
+)
+
+// InsertHandler processes remote write for influx line protocol.
+//
+// See https://github.com/influxdata/influxdb/blob/4cbdc197b8117fee648d62e2e5be75c6575352f0/tsdb/README.md
+func InsertHandler(at *auth.Token, req *http.Request) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(at, req)
+	})
+}
+
+func insertHandlerInternal(at *auth.Token, req *http.Request) error {
+	influxReadCalls.Inc()
+
+	r := req.Body
+	if req.Header.Get("Content-Encoding") == "gzip" {
+		zr, err := common.GetGzipReader(r)
+		if err != nil {
+			return fmt.Errorf("cannot read gzipped influx line protocol data: %s", err)
+		}
+		defer common.PutGzipReader(zr)
+		r = zr
+	}
+
+	q := req.URL.Query()
+	tsMultiplier := int64(1e6)
+	switch q.Get("precision") {
+	case "ns":
+		tsMultiplier = 1e6
+	case "u":
+		tsMultiplier = 1e3
+	case "ms":
+		tsMultiplier = 1
+	case "s":
+		tsMultiplier = -1e3
+	case "m":
+		tsMultiplier = -1e3 * 60
+	case "h":
+		tsMultiplier = -1e3 * 3600
+	}
+
+	// Read db tag from https://docs.influxdata.com/influxdb/v1.7/tools/api/#write-http-endpoint
+	db := q.Get("db")
+
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	for ctx.Read(r, tsMultiplier) {
+		if err := ctx.InsertRows(at, db); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows(at *auth.Token, db string) error {
+	rows := ctx.Rows.Rows
+	ic := &ctx.Common
+	ic.Reset()
+	rowsTotal := 0
+	for i := range rows {
+		r := &rows[i]
+		ic.Labels = ic.Labels[:0]
+		hasDBLabel := false
+		for j := range r.Tags {
+			tag := &r.Tags[j]
+			if tag.Key == "db" {
+				hasDBLabel = true
+			}
+			ic.AddLabel(tag.Key, tag.Value)
+		}
+		if len(db) > 0 && !hasDBLabel {
+			ic.AddLabel("db", db)
+		}
+		ic.MetricNameBuf = storage.MarshalMetricNameRaw(ic.MetricNameBuf[:0], at.AccountID, at.ProjectID, ic.Labels)
+		metricNameBufLen := len(ic.MetricNameBuf)
+		ctx.metricGroupBuf = append(ctx.metricGroupBuf[:0], r.Measurement...)
+		skipFieldKey := len(r.Fields) == 1 && *skipSingleField
+		if !skipFieldKey {
+			ctx.metricGroupBuf = append(ctx.metricGroupBuf, *measurementFieldSeparator...)
+		}
+		metricGroupPrefixLen := len(ctx.metricGroupBuf)
+		ic.AddLabel("", "placeholder")
+		placeholderLabel := &ic.Labels[len(ic.Labels)-1]
+		for j := range r.Fields {
+			f := &r.Fields[j]
+			if !skipFieldKey {
+				ctx.metricGroupBuf = append(ctx.metricGroupBuf[:metricGroupPrefixLen], f.Key...)
+			}
+			metricGroup := bytesutil.ToUnsafeString(ctx.metricGroupBuf)
+			ic.Labels = ic.Labels[:len(ic.Labels)-1]
+			ic.AddLabel("", metricGroup)
+			ic.MetricNameBuf = storage.MarshalMetricLabelRaw(ic.MetricNameBuf[:metricNameBufLen], placeholderLabel)
+			storageNodeIdx := ic.GetStorageNodeIdx(at, ic.Labels)
+			if err := ic.WriteDataPointExt(at, storageNodeIdx, ic.MetricNameBuf, r.Timestamp, f.Value); err != nil {
+				return err
+			}
+		}
+		rowsTotal += len(r.Fields)
+	}
+	rowsInserted.Get(at).Add(rowsTotal)
+	rowsPerInsert.Update(float64(rowsTotal))
+	return ic.FlushBufs()
+}
+
+func (ctx *pushCtx) Read(r io.Reader, tsMultiplier int64) bool {
+	if ctx.err != nil {
+		return false
+	}
+	ctx.reqBuf, ctx.tailBuf, ctx.err = common.ReadLinesBlock(r, ctx.reqBuf, ctx.tailBuf)
+	if ctx.err != nil {
+		if ctx.err != io.EOF {
+			influxReadErrors.Inc()
+			ctx.err = fmt.Errorf("cannot read influx line protocol data: %s", ctx.err)
+		}
+		return false
+	}
+	ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf))
+
+	// Adjust timestamps according to tsMultiplier
+	currentTs := time.Now().UnixNano() / 1e6
+	if tsMultiplier >= 1 {
+		for i := range ctx.Rows.Rows {
+			row := &ctx.Rows.Rows[i]
+			if row.Timestamp == 0 {
+				row.Timestamp = currentTs
+			} else {
+				row.Timestamp /= tsMultiplier
+			}
+		}
+	} else if tsMultiplier < 0 {
+		tsMultiplier = -tsMultiplier
+		currentTs -= currentTs % tsMultiplier
+		for i := range ctx.Rows.Rows {
+			row := &ctx.Rows.Rows[i]
+			if row.Timestamp == 0 {
+				row.Timestamp = currentTs
+			} else {
+				row.Timestamp *= tsMultiplier
+			}
+		}
+	}
+	return true
+}
+
+var (
+	influxReadCalls  = metrics.NewCounter(`vm_read_calls_total{name="influx"}`)
+	influxReadErrors = metrics.NewCounter(`vm_read_errors_total{name="influx"}`)
+)
+
+type pushCtx struct {
+	Rows   Rows
+	Common netstorage.InsertCtx
+
+	reqBuf         []byte
+	tailBuf        []byte
+	metricGroupBuf []byte
+
+	err error
+}
+
+func (ctx *pushCtx) Error() error {
+	if ctx.err == io.EOF {
+		return nil
+	}
+	return ctx.err
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Rows.Reset()
+	ctx.Common.Reset()
+	ctx.reqBuf = ctx.reqBuf[:0]
+	ctx.tailBuf = ctx.tailBuf[:0]
+	ctx.metricGroupBuf = ctx.metricGroupBuf[:0]
+
+	ctx.err = nil
+}
+
+func getPushCtx() *pushCtx {
+	select {
+	case ctx := <-pushCtxPoolCh:
+		return ctx
+	default:
+		if v := pushCtxPool.Get(); v != nil {
+			return v.(*pushCtx)
+		}
+		return &pushCtx{}
+	}
+}
+
+func putPushCtx(ctx *pushCtx) {
+	ctx.reset()
+	select {
+	case pushCtxPoolCh <- ctx:
+	default:
+		pushCtxPool.Put(ctx)
+	}
+}
+
+var pushCtxPool sync.Pool
+var pushCtxPoolCh = make(chan *pushCtx, runtime.GOMAXPROCS(-1))

app/vminsert/main.go

@@ -0,0 +1,152 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/graphite"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/influx"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/opentsdb"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/opentsdbhttp"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/prometheus"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/procutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	graphiteListenAddr     = flag.String("graphiteListenAddr", "", "TCP and UDP address to listen for Graphite plaintext data. Usually :2003 must be set. Doesn't work if empty")
+	opentsdbListenAddr     = flag.String("opentsdbListenAddr", "", "TCP and UDP address to listen for OpentTSDB put messages. Usually :4242 must be set. Doesn't work if empty")
+	opentsdbHTTPListenAddr = flag.String("opentsdbHTTPListenAddr", "", "TCP address to listen for OpentTSDB HTTP put requests. Usually :4242 must be set. Doesn't work if empty")
+	httpListenAddr         = flag.String("httpListenAddr", ":8480", "Address to listen for http connections")
+	maxInsertRequestSize   = flag.Int("maxInsertRequestSize", 32*1024*1024, "The maximum size of a single insert request in bytes")
+	maxLabelsPerTimeseries = flag.Int("maxLabelsPerTimeseries", 30, "The maximum number of labels accepted per time series. Superflouos labels are dropped")
+	storageNodes           = flagutil.NewArray("storageNode", "Address of vmstorage nodes; usage: -storageNode=vmstorage-host1:8400 -storageNode=vmstorage-host2:8400")
+)
+
+func main() {
+	flag.Parse()
+	buildinfo.Init()
+	logger.Init()
+
+	logger.Infof("initializing netstorage for storageNodes %s...", *storageNodes)
+	startTime := time.Now()
+	if len(*storageNodes) == 0 {
+		logger.Fatalf("missing -storageNode arg")
+	}
+	netstorage.InitStorageNodes(*storageNodes)
+	logger.Infof("successfully initialized netstorage in %s", time.Since(startTime))
+
+	storage.SetMaxLabelsPerTimeseries(*maxLabelsPerTimeseries)
+
+	concurrencylimiter.Init()
+	if len(*graphiteListenAddr) > 0 {
+		go graphite.Serve(*graphiteListenAddr)
+	}
+	if len(*opentsdbListenAddr) > 0 {
+		go opentsdb.Serve(*opentsdbListenAddr)
+	}
+	if len(*opentsdbHTTPListenAddr) > 0 {
+		go opentsdbhttp.Serve(*opentsdbHTTPListenAddr, int64(*maxInsertRequestSize))
+	}
+
+	go func() {
+		httpserver.Serve(*httpListenAddr, requestHandler)
+	}()
+
+	sig := procutil.WaitForSigterm()
+	logger.Infof("service received signal %s", sig)
+
+	logger.Infof("gracefully shutting down the service at %q", *httpListenAddr)
+	startTime = time.Now()
+	if err := httpserver.Stop(*httpListenAddr); err != nil {
+		logger.Fatalf("cannot stop the service: %s", err)
+	}
+	logger.Infof("successfully shut down the service in %s", time.Since(startTime))
+
+	if len(*graphiteListenAddr) > 0 {
+		graphite.Stop()
+	}
+	if len(*opentsdbListenAddr) > 0 {
+		opentsdb.Stop()
+	}
+	if len(*opentsdbHTTPListenAddr) > 0 {
+		opentsdbhttp.Stop()
+	}
+
+	logger.Infof("shutting down neststorage...")
+	startTime = time.Now()
+	netstorage.Stop()
+	logger.Infof("successfully stopped netstorage in %s", time.Since(startTime))
+
+	fs.MustStopDirRemover()
+
+	logger.Infof("the vminsert has been stopped")
+}
+
+func requestHandler(w http.ResponseWriter, r *http.Request) bool {
+	p, err := httpserver.ParsePath(r.URL.Path)
+	if err != nil {
+		httpserver.Errorf(w, "cannot parse path %q: %s", r.URL.Path, err)
+		return true
+	}
+	if p.Prefix != "insert" {
+		// This is not our link.
+		return false
+	}
+	at, err := auth.NewToken(p.AuthToken)
+	if err != nil {
+		httpserver.Errorf(w, "auth error: %s", err)
+		return true
+	}
+
+	switch p.Suffix {
+	case "prometheus/", "prometheus", "prometheus/api/v1/write":
+		prometheusWriteRequests.Inc()
+		if err := prometheus.InsertHandler(at, r, int64(*maxInsertRequestSize)); err != nil {
+			prometheusWriteErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		w.WriteHeader(http.StatusNoContent)
+		return true
+	case "influx/write", "influx/api/v2/write":
+		influxWriteRequests.Inc()
+		if err := influx.InsertHandler(at, r); err != nil {
+			influxWriteErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		w.WriteHeader(http.StatusNoContent)
+		return true
+	case "influx/query":
+		// Emulate fake response for influx query.
+		// This is required for TSBS benchmark.
+		influxQueryRequests.Inc()
+		fmt.Fprintf(w, `{"results":[{"series":[{"values":[]}]}]}`)
+		return true
+	default:
+		// This is not our link
+		return false
+	}
+}
+
+var (
+	prometheusWriteRequests = metrics.NewCounter(`vm_http_requests_total{path="/insert/{}/prometheus/", protocol="prometheus"}`)
+	prometheusWriteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/insert/{}/prometheus/", protocol="prometheus"}`)
+
+	influxWriteRequests = metrics.NewCounter(`vm_http_requests_total{path="/insert/{}/influx/", protocol="influx"}`)
+	influxWriteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/insert/{}/influx/", protocol="influx"}`)
+
+	influxQueryRequests = metrics.NewCounter(`vm_http_requests_total{path="/insert/{}/influx/query", protocol="influx"}`)
+)

app/vminsert/netstorage/insert_ctx.go

@@ -0,0 +1,163 @@
+package netstorage
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/consts"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompb"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	xxhash "github.com/cespare/xxhash/v2"
+	jump "github.com/lithammer/go-jump-consistent-hash"
+)
+
+// InsertCtx is a generic context for inserting data
+type InsertCtx struct {
+	Labels        []prompb.Label
+	MetricNameBuf []byte
+
+	bufRowss  []bufRows
+	labelsBuf []byte
+}
+
+type bufRows struct {
+	buf  []byte
+	rows int
+}
+
+func (br *bufRows) pushTo(sn *storageNode) error {
+	bufLen := len(br.buf)
+	err := sn.push(br.buf, br.rows)
+	br.buf = br.buf[:0]
+	br.rows = 0
+	if err != nil {
+		return &httpserver.ErrorWithStatusCode{
+			Err:        fmt.Errorf("cannot send %d bytes to storageNode %q: %s", bufLen, sn.dialer.Addr(), err),
+			StatusCode: http.StatusServiceUnavailable,
+		}
+	}
+	return nil
+}
+
+// Reset resets ctx.
+func (ctx *InsertCtx) Reset() {
+	for _, label := range ctx.Labels {
+		label.Name = nil
+		label.Value = nil
+	}
+	ctx.Labels = ctx.Labels[:0]
+	ctx.MetricNameBuf = ctx.MetricNameBuf[:0]
+
+	if ctx.bufRowss == nil {
+		ctx.bufRowss = make([]bufRows, len(storageNodes))
+	}
+	for i := range ctx.bufRowss {
+		br := &ctx.bufRowss[i]
+		br.buf = br.buf[:0]
+		br.rows = 0
+	}
+	ctx.labelsBuf = ctx.labelsBuf[:0]
+}
+
+// AddLabel adds (name, value) label to ctx.Labels.
+//
+// name and value must exist until ctx.Labels is used.
+func (ctx *InsertCtx) AddLabel(name, value string) {
+	labels := ctx.Labels
+	if cap(labels) > len(labels) {
+		labels = labels[:len(labels)+1]
+	} else {
+		labels = append(labels, prompb.Label{})
+	}
+	label := &labels[len(labels)-1]
+
+	// Do not copy name and value contents for performance reasons.
+	// This reduces GC overhead on the number of objects and allocations.
+	label.Name = bytesutil.ToUnsafeBytes(name)
+	label.Value = bytesutil.ToUnsafeBytes(value)
+
+	ctx.Labels = labels
+}
+
+// WriteDataPoint writes (timestamp, value) data point with the given at and labels to ctx buffer.
+func (ctx *InsertCtx) WriteDataPoint(at *auth.Token, labels []prompb.Label, timestamp int64, value float64) error {
+	ctx.MetricNameBuf = storage.MarshalMetricNameRaw(ctx.MetricNameBuf[:0], at.AccountID, at.ProjectID, labels)
+	storageNodeIdx := ctx.GetStorageNodeIdx(at, labels)
+	return ctx.WriteDataPointExt(at, storageNodeIdx, ctx.MetricNameBuf, timestamp, value)
+}
+
+// WriteDataPointExt writes the given metricNameRaw with (timestmap, value) to ctx buffer with the given storageNodeIdx.
+func (ctx *InsertCtx) WriteDataPointExt(at *auth.Token, storageNodeIdx int, metricNameRaw []byte, timestamp int64, value float64) error {
+	br := &ctx.bufRowss[storageNodeIdx]
+	sn := storageNodes[storageNodeIdx]
+	bufNew := storage.MarshalMetricRow(br.buf, metricNameRaw, timestamp, value)
+	if len(bufNew) >= maxStorageNodeBufSize {
+		// Send buf to storageNode, since it is too big.
+		if err := br.pushTo(sn); err != nil {
+			return err
+		}
+		br.buf = storage.MarshalMetricRow(bufNew[:0], metricNameRaw, timestamp, value)
+	} else {
+		br.buf = bufNew
+	}
+	br.rows++
+	return nil
+}
+
+var maxStorageNodeBufSize = func() int {
+	n := 1024 * 1024
+	if n > consts.MaxInsertPacketSize {
+		n = consts.MaxInsertPacketSize
+	}
+	return n
+}()
+
+// FlushBufs flushes ctx bufs to remote storage nodes.
+func (ctx *InsertCtx) FlushBufs() error {
+	// Send per-storageNode bufs.
+	for i := range ctx.bufRowss {
+		br := &ctx.bufRowss[i]
+		if len(br.buf) == 0 {
+			continue
+		}
+		sn := storageNodes[i]
+		if err := br.pushTo(sn); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetStorageNodeIdx returns storage node index for the given at and labels.
+//
+// The returned index must be passed to WriteDataPoint.
+func (ctx *InsertCtx) GetStorageNodeIdx(at *auth.Token, labels []prompb.Label) int {
+	if len(storageNodes) == 1 {
+		// Fast path - only a single storage node.
+		return 0
+	}
+
+	buf := ctx.labelsBuf[:0]
+	buf = encoding.MarshalUint32(buf, at.AccountID)
+	buf = encoding.MarshalUint32(buf, at.ProjectID)
+	for i := range labels {
+		label := &labels[i]
+		buf = marshalBytesFast(buf, label.Name)
+		buf = marshalBytesFast(buf, label.Value)
+	}
+	h := xxhash.Sum64(buf)
+	ctx.labelsBuf = buf
+
+	idx := int(jump.Hash(h, int32(len(storageNodes))))
+	return idx
+}
+
+func marshalBytesFast(dst []byte, s []byte) []byte {
+	dst = encoding.MarshalUint16(dst, uint16(len(s)))
+	dst = append(dst, s...)
+	return dst
+}

app/vminsert/netstorage/netstorage.go

@@ -0,0 +1,461 @@
+package netstorage
+
+import (
+	"flag"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/consts"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/handshake"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/memory"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/netutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+	xxhash "github.com/cespare/xxhash/v2"
+)
+
+var disableRPCCompression = flag.Bool(`rpc.disableCompression`, false, "Disable compression of RPC traffic. This reduces CPU usage at the cost of higher network bandwidth usage")
+
+// push pushes buf to sn.
+//
+// It falls back to sending data to another vmstorage node if sn is currently
+// unavailable.
+//
+// rows is the number of rows in the buf.
+func (sn *storageNode) push(buf []byte, rows int) error {
+	if len(buf) > consts.MaxInsertPacketSize {
+		logger.Panicf("BUG: len(buf)=%d cannot exceed %d", len(buf), consts.MaxInsertPacketSize)
+	}
+	sn.rowsPushed.Add(rows)
+
+	sn.mu.Lock()
+	defer sn.mu.Unlock()
+
+	if sn.broken {
+		// The vmstorage node is broken. Re-route buf to healthy vmstorage nodes.
+		if err := addToReroutedBuf(buf, rows); err != nil {
+			rowsLostTotal.Add(rows)
+			return err
+		}
+		sn.rowsReroutedFromHere.Add(rows)
+		return nil
+	}
+
+	if len(sn.buf)+len(buf) <= consts.MaxInsertPacketSize {
+		// Fast path: the buf contents fits sn.buf.
+		sn.buf = append(sn.buf, buf...)
+		sn.rows += rows
+		return nil
+	}
+
+	// Slow path: the buf contents doesn't fit sn.buf.
+	// Flush sn.buf to vmstorage and then add buf to sn.buf.
+	if err := sn.flushBufLocked(); err != nil {
+		// Failed to flush or re-route sn.buf to vmstorage nodes.
+		// The sn.buf is already dropped by flushBufLocked.
+		// Drop buf too, since there is litte sense in trying to rescue it.
+		rowsLostTotal.Add(rows)
+		return err
+	}
+
+	// Successful flush.
+	sn.buf = append(sn.buf, buf...)
+	sn.rows += rows
+	return nil
+}
+
+func (sn *storageNode) sendReroutedRow(buf []byte) error {
+	sn.mu.Lock()
+	defer sn.mu.Unlock()
+
+	if sn.broken {
+		return errBrokenStorageNode
+	}
+	if len(sn.buf)+len(buf) > consts.MaxInsertPacketSize {
+		return fmt.Errorf("cannot put %d bytes into vmstorage buffer, since its size cannot exceed %d bytes", len(sn.buf)+len(buf), consts.MaxInsertPacketSize)
+	}
+	sn.buf = append(sn.buf, buf...)
+	sn.rows++
+	return nil
+}
+
+var errBrokenStorageNode = fmt.Errorf("the vmstorage node is temporarily broken")
+
+func (sn *storageNode) flushBufLocked() error {
+	if err := sn.sendBufLocked(sn.buf); err == nil {
+		// Successful flush. Remove broken flag.
+		sn.broken = false
+		sn.rowsSent.Add(sn.rows)
+		sn.buf = sn.buf[:0]
+		sn.rows = 0
+		return nil
+	}
+
+	// Couldn't flush sn.buf to vmstorage. Mark sn as broken
+	// and try re-routing sn.buf to healthy vmstorage nodes.
+	sn.broken = true
+	err := addToReroutedBuf(sn.buf, sn.rows)
+	if err != nil {
+		rowsLostTotal.Add(sn.rows)
+	}
+	sn.buf = sn.buf[:0]
+	sn.rows = 0
+	return err
+}
+
+func (sn *storageNode) sendBufLocked(buf []byte) error {
+	// sizeBuf guarantees that the rows batch will be either fully
+	// read or fully discarded on the vmstorage side.
+	// sizeBuf is used for read optimization in vmstorage.
+	if sn.bc == nil {
+		if err := sn.dial(); err != nil {
+			return fmt.Errorf("cannot dial %q: %s", sn.dialer.Addr(), err)
+		}
+	}
+	if len(buf) == 0 {
+		return nil
+	}
+	deadline := time.Now().Add(30 * time.Second)
+	if err := sn.bc.SetWriteDeadline(deadline); err != nil {
+		sn.closeBrokenConn()
+		return fmt.Errorf("cannot set write deadline to %s: %s", deadline, err)
+	}
+	sn.sizeBuf = encoding.MarshalUint64(sn.sizeBuf[:0], uint64(len(buf)))
+	if _, err := sn.bc.Write(sn.sizeBuf); err != nil {
+		sn.closeBrokenConn()
+		return fmt.Errorf("cannot write data size %d: %s", len(buf), err)
+	}
+	if _, err := sn.bc.Write(buf); err != nil {
+		sn.closeBrokenConn()
+		return fmt.Errorf("cannot write data: %s", err)
+	}
+	if err := sn.bc.Flush(); err != nil {
+		sn.closeBrokenConn()
+		return fmt.Errorf("cannot flush data: %s", err)
+	}
+	return nil
+}
+
+func (sn *storageNode) dial() error {
+	c, err := sn.dialer.Dial()
+	if err != nil {
+		sn.dialErrors.Inc()
+		return err
+	}
+	compressionLevel := 1
+	if *disableRPCCompression {
+		compressionLevel = 0
+	}
+	bc, err := handshake.VMInsertClient(c, compressionLevel)
+	if err != nil {
+		_ = c.Close()
+		sn.handshakeErrors.Inc()
+		return fmt.Errorf("handshake error: %s", err)
+	}
+	sn.bc = bc
+	return nil
+}
+
+func (sn *storageNode) closeBrokenConn() {
+	_ = sn.bc.Close()
+	sn.bc = nil
+	sn.connectionErrors.Inc()
+}
+
+func (sn *storageNode) run(stopCh <-chan struct{}) {
+	t := time.NewTimer(time.Second)
+	mustStop := false
+	for !mustStop {
+		select {
+		case <-stopCh:
+			mustStop = true
+			// Make sure flushBufLocked is called last time before returning
+			// in order to send the remaining bits of data.
+		case <-t.C:
+		}
+
+		sn.mu.Lock()
+		if err := sn.flushBufLocked(); err != nil {
+			sn.closeBrokenConn()
+			logger.Errorf("cannot flush data to storageNode %q: %s", sn.dialer.Addr(), err)
+		}
+		sn.mu.Unlock()
+
+		t.Reset(time.Second)
+	}
+	t.Stop()
+}
+
+func rerouteWorker(stopCh <-chan struct{}) {
+	t := time.NewTimer(time.Second)
+	var buf []byte
+	mustStop := false
+	for !mustStop {
+		select {
+		case <-stopCh:
+			mustStop = true
+			// Make sure spreadReroutedBufToStorageNodes is called last time before returning
+			// in order to reroute the remaining data to healthy vmstorage nodes.
+		case <-t.C:
+		}
+
+		var err error
+		buf, err = spreadReroutedBufToStorageNodes(buf[:0])
+		if err != nil {
+			rerouteErrors.Inc()
+			logger.Errorf("cannot reroute data among healthy vmstorage nodes: %s", err)
+		}
+		t.Reset(time.Second)
+	}
+	t.Stop()
+}
+
+// storageNode is a client sending data to vmstorage node.
+type storageNode struct {
+	mu sync.Mutex
+
+	// Buffer with data that needs to be written to vmstorage node.
+	buf []byte
+
+	// The number of rows buf contains at the moment.
+	rows int
+
+	// Temporary buffer for encoding marshaled buf size.
+	sizeBuf []byte
+
+	// broken is set to true if the given vmstorage node is temporarily unhealthy.
+	// In this case the data is re-routed to the remaining healthy vmstorage nodes.
+	broken bool
+
+	dialer *netutil.TCPDialer
+
+	bc *handshake.BufferedConn
+
+	// The number of dial errors to vmstorage node.
+	dialErrors *metrics.Counter
+
+	// The number of handshake errors to vmstorage node.
+	handshakeErrors *metrics.Counter
+
+	// The number of connection errors to vmstorage node.
+	connectionErrors *metrics.Counter
+
+	// The number of rows pushed to storageNode with push method.
+	rowsPushed *metrics.Counter
+
+	// The number of rows sent to vmstorage node.
+	rowsSent *metrics.Counter
+
+	// The number of rows rerouted from the given vmstorage node
+	// to healthy nodes when the given node was unhealthy.
+	rowsReroutedFromHere *metrics.Counter
+
+	// The number of rows rerouted to the given vmstorage node
+	// from other nodes when they were unhealthy.
+	rowsReroutedToHere *metrics.Counter
+}
+
+// storageNodes contains a list of vmstorage node clients.
+var storageNodes []*storageNode
+
+var (
+	storageNodesWG  sync.WaitGroup
+	rerouteWorkerWG sync.WaitGroup
+)
+
+var (
+	storageNodesStopCh  = make(chan struct{})
+	rerouteWorkerStopCh = make(chan struct{})
+)
+
+// InitStorageNodes initializes vmstorage nodes' connections to the given addrs.
+func InitStorageNodes(addrs []string) {
+	if len(addrs) == 0 {
+		logger.Panicf("BUG: addrs must be non-empty")
+	}
+	if len(addrs) > 255 {
+		logger.Panicf("BUG: too much addresses: %d; max supported %d addresses", len(addrs), 255)
+	}
+
+	for _, addr := range addrs {
+		sn := &storageNode{
+			dialer: netutil.NewTCPDialer("vminsert", addr),
+
+			dialErrors:           metrics.NewCounter(fmt.Sprintf(`vm_rpc_dial_errors_total{name="vminsert", addr=%q}`, addr)),
+			handshakeErrors:      metrics.NewCounter(fmt.Sprintf(`vm_rpc_handshake_errors_total{name="vminsert", addr=%q}`, addr)),
+			connectionErrors:     metrics.NewCounter(fmt.Sprintf(`vm_rpc_connection_errors_total{name="vminsert", addr=%q}`, addr)),
+			rowsPushed:           metrics.NewCounter(fmt.Sprintf(`vm_rpc_rows_pushed_total{name="vminsert", addr=%q}`, addr)),
+			rowsSent:             metrics.NewCounter(fmt.Sprintf(`vm_rpc_rows_sent_total{name="vminsert", addr=%q}`, addr)),
+			rowsReroutedFromHere: metrics.NewCounter(fmt.Sprintf(`vm_rpc_rows_rerouted_from_here_total{name="vminsert", addr=%q}`, addr)),
+			rowsReroutedToHere:   metrics.NewCounter(fmt.Sprintf(`vm_rpc_rows_rerouted_to_here_total{name="vminsert", addr=%q}`, addr)),
+		}
+		_ = metrics.NewGauge(fmt.Sprintf(`vm_rpc_rows_pending{name="vminsert", addr=%q}`, addr), func() float64 {
+			sn.mu.Lock()
+			n := sn.rows
+			sn.mu.Unlock()
+			return float64(n)
+		})
+		_ = metrics.NewGauge(fmt.Sprintf(`vm_rpc_buf_pending_bytes{name="vminsert", addr=%q}`, addr), func() float64 {
+			sn.mu.Lock()
+			n := len(sn.buf)
+			sn.mu.Unlock()
+			return float64(n)
+		})
+		storageNodes = append(storageNodes, sn)
+		storageNodesWG.Add(1)
+		go func(addr string) {
+			sn.run(storageNodesStopCh)
+			storageNodesWG.Done()
+		}(addr)
+	}
+
+	reroutedBufMaxSize = memory.Allowed() / 8
+	rerouteWorkerWG.Add(1)
+	go func() {
+		rerouteWorker(rerouteWorkerStopCh)
+		rerouteWorkerWG.Done()
+	}()
+}
+
+// Stop gracefully stops netstorage.
+func Stop() {
+	close(rerouteWorkerStopCh)
+	rerouteWorkerWG.Wait()
+
+	close(storageNodesStopCh)
+	storageNodesWG.Wait()
+}
+
+func addToReroutedBuf(buf []byte, rows int) error {
+	reroutedLock.Lock()
+	defer reroutedLock.Unlock()
+	if len(reroutedBuf)+len(buf) > reroutedBufMaxSize {
+		reroutedBufOverflows.Inc()
+		return fmt.Errorf("%d rows dropped because of reroutedBuf overflows %d bytes", rows, reroutedBufMaxSize)
+	}
+	reroutedBuf = append(reroutedBuf, buf...)
+	reroutedRows += rows
+	reroutesTotal.Inc()
+	return nil
+}
+
+func spreadReroutedBufToStorageNodes(swapBuf []byte) ([]byte, error) {
+	healthyStorageNodes := getHealthyStorageNodes()
+	if len(healthyStorageNodes) == 0 {
+		// No more vmstorage nodes to write data to.
+		return swapBuf, fmt.Errorf("all the storage nodes are unhealthy")
+	}
+
+	reroutedLock.Lock()
+	reroutedBuf, swapBuf = swapBuf[:0], reroutedBuf
+	rows := reroutedRows
+	reroutedRows = 0
+	reroutedLock.Unlock()
+
+	if len(swapBuf) == 0 {
+		// Nothing to re-route.
+		return swapBuf, nil
+	}
+
+	var mr storage.MetricRow
+	src := swapBuf
+	rowsProcessed := 0
+	for len(src) > 0 {
+		tail, err := mr.Unmarshal(src)
+		if err != nil {
+			logger.Panicf("BUG: cannot unmarshal recently marshaled MetricRow: %s", err)
+		}
+		rowBuf := src[:len(src)-len(tail)]
+		src = tail
+
+		// Use non-consistent hashing instead of jump hash in order to re-route rows
+		// equally among healthy vmstorage nodes.
+		// This should spread the increased load among healthy vmstorage nodes.
+		h := xxhash.Sum64(mr.MetricNameRaw)
+		idx := h % uint64(len(healthyStorageNodes))
+		attempts := 0
+		for {
+			sn := healthyStorageNodes[idx]
+			err := sn.sendReroutedRow(rowBuf)
+			if err == nil {
+				sn.rowsReroutedToHere.Inc()
+				break
+			}
+
+			// Cannot send data to sn. Try sending to the next vmstorage node.
+			idx++
+			if idx >= uint64(len(healthyStorageNodes)) {
+				idx = 0
+			}
+			attempts++
+			if attempts == len(healthyStorageNodes) {
+				// There are no healthy nodes.
+				// Try returning the remaining data to reroutedBuf if it has enough free space.
+				rowsRemaining := rows - rowsProcessed
+				recovered := false
+				reroutedLock.Lock()
+				if len(rowBuf)+len(tail)+len(reroutedBuf) <= reroutedBufMaxSize {
+					swapBuf = append(swapBuf[:0], rowBuf...)
+					swapBuf = append(swapBuf, tail...)
+					swapBuf = append(swapBuf, reroutedBuf...)
+					reroutedBuf, swapBuf = swapBuf, reroutedBuf[:0]
+					reroutedRows += rowsRemaining
+					recovered = true
+				}
+				reroutedLock.Unlock()
+				if recovered {
+					return swapBuf, nil
+				}
+				rowsLostTotal.Add(rowsRemaining)
+				return swapBuf, fmt.Errorf("all the %d vmstorage nodes are unavailable; lost %d rows; last error: %s", len(storageNodes), rowsRemaining, err)
+			}
+		}
+		rowsProcessed++
+	}
+	if rowsProcessed != rows {
+		logger.Panicf("BUG: unexpected number of rows processed; got %d; want %d", rowsProcessed, rows)
+	}
+	reroutedRowsProcessed.Add(rowsProcessed)
+	return swapBuf, nil
+}
+
+var (
+	reroutedLock       sync.Mutex
+	reroutedBuf        []byte
+	reroutedRows       int
+	reroutedBufMaxSize int
+
+	reroutedRowsProcessed = metrics.NewCounter(`vm_rpc_rerouted_rows_processed_total{name="vminsert"}`)
+	reroutedBufOverflows  = metrics.NewCounter(`vm_rpc_rerouted_buf_overflows_total{name="vminsert"}`)
+	reroutesTotal         = metrics.NewCounter(`vm_rpc_reroutes_total{name="vminsert"}`)
+	_                     = metrics.NewGauge(`vm_rpc_rerouted_rows_pending{name="vminsert"}`, func() float64 {
+		reroutedLock.Lock()
+		n := reroutedRows
+		reroutedLock.Unlock()
+		return float64(n)
+	})
+	_ = metrics.NewGauge(`vm_rpc_rerouted_buf_pending_bytes{name="vminsert"}`, func() float64 {
+		reroutedLock.Lock()
+		n := len(reroutedBuf)
+		reroutedLock.Unlock()
+		return float64(n)
+	})
+
+	rerouteErrors = metrics.NewCounter(`vm_rpc_reroute_errors_total{name="vminsert"}`)
+	rowsLostTotal = metrics.NewCounter(`vm_rpc_rows_lost_total{name="vminsert"}`)
+)
+
+func getHealthyStorageNodes() []*storageNode {
+	sns := make([]*storageNode, 0, len(storageNodes)-1)
+	for _, sn := range storageNodes {
+		sn.mu.Lock()
+		if !sn.broken {
+			sns = append(sns, sn)
+		}
+		sn.mu.Unlock()
+	}
+	return sns
+}

app/vminsert/opentsdb/parser.go

@@ -0,0 +1,187 @@
+package opentsdb
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+// Rows contains parsed OpenTSDB rows.
+type Rows struct {
+	Rows []Row
+
+	tagsPool []Tag
+}
+
+// Reset resets rs.
+func (rs *Rows) Reset() {
+	// Release references to objects, so they can be GC'ed.
+
+	for i := range rs.Rows {
+		rs.Rows[i].reset()
+	}
+	rs.Rows = rs.Rows[:0]
+
+	for i := range rs.tagsPool {
+		rs.tagsPool[i].reset()
+	}
+	rs.tagsPool = rs.tagsPool[:0]
+}
+
+// Unmarshal unmarshals OpenTSDB put rows from s.
+//
+// See http://opentsdb.net/docs/build/html/api_telnet/put.html
+//
+// s must be unchanged until rs is in use.
+func (rs *Rows) Unmarshal(s string) {
+	rs.Rows, rs.tagsPool = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0])
+}
+
+// Row is a single OpenTSDB row.
+type Row struct {
+	Metric    string
+	Tags      []Tag
+	Value     float64
+	Timestamp int64
+}
+
+func (r *Row) reset() {
+	r.Metric = ""
+	r.Tags = nil
+	r.Value = 0
+	r.Timestamp = 0
+}
+
+func (r *Row) unmarshal(s string, tagsPool []Tag) ([]Tag, error) {
+	r.reset()
+	if !strings.HasPrefix(s, "put ") {
+		return tagsPool, fmt.Errorf("missing `put ` prefix in %q", s)
+	}
+	s = s[len("put "):]
+	n := strings.IndexByte(s, ' ')
+	if n < 0 {
+		return tagsPool, fmt.Errorf("cannot find whitespace between metric and timestamp in %q", s)
+	}
+	r.Metric = s[:n]
+	if len(r.Metric) == 0 {
+		return tagsPool, fmt.Errorf("metric cannot be empty")
+	}
+	tail := s[n+1:]
+	n = strings.IndexByte(tail, ' ')
+	if n < 0 {
+		return tagsPool, fmt.Errorf("cannot find whitespace between timestamp and value in %q", s)
+	}
+	r.Timestamp = int64(fastfloat.ParseBestEffort(tail[:n]))
+	tail = tail[n+1:]
+	n = strings.IndexByte(tail, ' ')
+	if n < 0 {
+		return tagsPool, fmt.Errorf("cannot find whitespace between value and the first tag in %q", s)
+	}
+	r.Value = fastfloat.ParseBestEffort(tail[:n])
+	var err error
+	tagsStart := len(tagsPool)
+	tagsPool, err = unmarshalTags(tagsPool, tail[n+1:])
+	if err != nil {
+		return tagsPool, fmt.Errorf("cannot unmarshal tags in %q: %s", s, err)
+	}
+	tags := tagsPool[tagsStart:]
+	r.Tags = tags[:len(tags):len(tags)]
+	return tagsPool, nil
+}
+
+func unmarshalRows(dst []Row, s string, tagsPool []Tag) ([]Row, []Tag) {
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n < 0 {
+			// The last line.
+			return unmarshalRow(dst, s, tagsPool)
+		}
+		dst, tagsPool = unmarshalRow(dst, s[:n], tagsPool)
+		s = s[n+1:]
+	}
+	return dst, tagsPool
+}
+
+func unmarshalRow(dst []Row, s string, tagsPool []Tag) ([]Row, []Tag) {
+	if len(s) > 0 && s[len(s)-1] == '\r' {
+		s = s[:len(s)-1]
+	}
+	if len(s) == 0 {
+		// Skip empty line
+		return dst, tagsPool
+	}
+
+	if cap(dst) > len(dst) {
+		dst = dst[:len(dst)+1]
+	} else {
+		dst = append(dst, Row{})
+	}
+	r := &dst[len(dst)-1]
+	var err error
+	tagsPool, err = r.unmarshal(s, tagsPool)
+	if err != nil {
+		dst = dst[:len(dst)-1]
+		logger.Errorf("cannot unmarshal OpenTSDB line %q: %s", s, err)
+		invalidLines.Inc()
+	}
+	return dst, tagsPool
+}
+
+var invalidLines = metrics.NewCounter(`vm_rows_invalid_total{type="opentsdb"}`)
+
+func unmarshalTags(dst []Tag, s string) ([]Tag, error) {
+	for {
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Tag{})
+		}
+		tag := &dst[len(dst)-1]
+
+		n := strings.IndexByte(s, ' ')
+		if n < 0 {
+			// The last tag found
+			if err := tag.unmarshal(s); err != nil {
+				return dst[:len(dst)-1], err
+			}
+			if len(tag.Key) == 0 || len(tag.Value) == 0 {
+				// Skip empty tag
+				dst = dst[:len(dst)-1]
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n]); err != nil {
+			return dst[:len(dst)-1], err
+		}
+		s = s[n+1:]
+		if len(tag.Key) == 0 || len(tag.Value) == 0 {
+			// Skip empty tag
+			dst = dst[:len(dst)-1]
+		}
+	}
+}
+
+// Tag is an OpenTSDB tag.
+type Tag struct {
+	Key   string
+	Value string
+}
+
+func (t *Tag) reset() {
+	t.Key = ""
+	t.Value = ""
+}
+
+func (t *Tag) unmarshal(s string) error {
+	t.reset()
+	n := strings.IndexByte(s, '=')
+	if n < 0 {
+		return fmt.Errorf("missing tag value for %q", s)
+	}
+	t.Key = s[:n]
+	t.Value = s[n+1:]
+	return nil
+}

app/vminsert/opentsdb/parser_test.go

@@ -0,0 +1,222 @@
+package opentsdb
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+
+		// Try again
+		rows.Unmarshal(s)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+	}
+
+	// Missing put prefix
+	f("xx")
+
+	// Missing metric
+	f("put  111 34")
+
+	// Missing timestamp
+	f("put aaa")
+
+	// Missing value
+	f("put aaa 1123")
+
+	// Invalid timestamp
+	f("put aaa timestamp")
+
+	// Missing first tag
+	f("put aaa 123 43")
+
+	// Invalid value
+	f("put aaa 123 invalid-value")
+
+	// Invalid multiline
+	f("put aaa\nbbb 123 34")
+
+	// Invalid tag
+	f("put aaa 123 4.5 foo")
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		rows.Unmarshal(s)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		rows.Reset()
+		if len(rows.Rows) != 0 {
+			t.Fatalf("non-empty rows after reset: %+v", rows.Rows)
+		}
+	}
+
+	// Empty line
+	f("", &Rows{})
+	f("\r", &Rows{})
+	f("\n\n", &Rows{})
+	f("\n\r\n", &Rows{})
+
+	// Single line
+	f("put foobar 789 -123.456 a=b", &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	// Empty tag
+	f("put foobar 789 -123.456 a= b=c =d", &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags: []Tag{
+				{
+					Key:   "b",
+					Value: "c",
+				},
+			},
+		}},
+	})
+	// Fractional timestamp that is supported by Akumuli.
+	f("put foobar 789.4 -123.456 a=b", &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	f("put foo.bar 789 123.456 a=b\n", &Rows{
+		Rows: []Row{{
+			Metric:    "foo.bar",
+			Value:     123.456,
+			Timestamp: 789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+
+	// Tags
+	f("put foo 2 1 bar=baz", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{{
+				Key:   "bar",
+				Value: "baz",
+			}},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+	f("put foo 2 1 bar=baz x=y", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{
+				{
+					Key:   "bar",
+					Value: "baz",
+				},
+				{
+					Key:   "x",
+					Value: "y",
+				},
+			},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+	f("put foo 2 1 bar=baz=aaa x=y", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{
+				{
+					Key:   "bar",
+					Value: "baz=aaa",
+				},
+				{
+					Key:   "x",
+					Value: "y",
+				},
+			},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+
+	// Multi lines
+	f("put foo 2 0.3 a=b\nput bar.baz 43 0.34 a=b\n", &Rows{
+		Rows: []Row{
+			{
+				Metric:    "foo",
+				Value:     0.3,
+				Timestamp: 2,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+			{
+				Metric:    "bar.baz",
+				Value:     0.34,
+				Timestamp: 43,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+		},
+	})
+	// Multi lines with invalid line
+	f("put foo 2 0.3 a=b\naaa bbb\nput bar.baz 43 0.34 a=b\n", &Rows{
+		Rows: []Row{
+			{
+				Metric:    "foo",
+				Value:     0.3,
+				Timestamp: 2,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+			{
+				Metric:    "bar.baz",
+				Value:     0.34,
+				Timestamp: 43,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+		},
+	})
+}

app/vminsert/opentsdb/parser_timing_test.go

@@ -0,0 +1,25 @@
+package opentsdb
+
+import (
+	"fmt"
+	"testing"
+)
+
+func BenchmarkRowsUnmarshal(b *testing.B) {
+	s := `put cpu.usage_user 1234556768 1.23 a=b
+put cpu.usage_system 1234556768 23.344 a=b
+put cpu.usage_iowait 1234556769 3.3443 a=b
+put cpu.usage_irq 1234556768 0.34432 a=b
+`
+	b.SetBytes(int64(len(s)))
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		var rows Rows
+		for pb.Next() {
+			rows.Unmarshal(s)
+			if len(rows.Rows) != 4 {
+				panic(fmt.Errorf("unexpected number of parsed rows; got %d; want 4", len(rows.Rows)))
+			}
+		}
+	})
+}

app/vminsert/opentsdb/request_handler.go

@@ -0,0 +1,178 @@
+package opentsdb
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/common"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/tenantmetrics"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+var (
+	rowsInserted  = tenantmetrics.NewCounterMap(`vm_rows_inserted_total{type="opentsdb"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="opentsdb"}`)
+)
+
+// insertHandler processes remote write for OpenTSDB put protocol.
+//
+// See http://opentsdb.net/docs/build/html/api_telnet/put.html
+func insertHandler(at *auth.Token, r io.Reader) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(at, r)
+	})
+}
+
+func insertHandlerInternal(at *auth.Token, r io.Reader) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	for ctx.Read(r) {
+		if err := ctx.InsertRows(at); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows(at *auth.Token) error {
+	rows := ctx.Rows.Rows
+	ic := &ctx.Common
+	ic.Reset()
+	atCopy := *at
+	for i := range rows {
+		r := &rows[i]
+		ic.Labels = ic.Labels[:0]
+		ic.AddLabel("", r.Metric)
+		for j := range r.Tags {
+			tag := &r.Tags[j]
+			if atCopy.AccountID == 0 {
+				// Multi-tenancy support via custom tags.
+				// Do not allow overriding AccountID and ProjectID from atCopy for security reasons.
+				if tag.Key == "VictoriaMetrics_AccountID" {
+					atCopy.AccountID = uint32(fastfloat.ParseUint64BestEffort(tag.Value))
+				}
+				if atCopy.ProjectID == 0 && tag.Key == "VictoriaMetrics_ProjectID" {
+					atCopy.ProjectID = uint32(fastfloat.ParseUint64BestEffort(tag.Value))
+				}
+			}
+			ic.AddLabel(tag.Key, tag.Value)
+		}
+		if err := ic.WriteDataPoint(&atCopy, ic.Labels, r.Timestamp, r.Value); err != nil {
+			return err
+		}
+	}
+	// Assume that all the rows for a single connection belong to the same (AccountID, ProjectID).
+	rowsInserted.Get(&atCopy).Add(len(rows))
+	rowsPerInsert.Update(float64(len(rows)))
+	return ic.FlushBufs()
+}
+
+const flushTimeout = 3 * time.Second
+
+func (ctx *pushCtx) Read(r io.Reader) bool {
+	opentsdbReadCalls.Inc()
+	if ctx.err != nil {
+		return false
+	}
+	if c, ok := r.(net.Conn); ok {
+		if err := c.SetReadDeadline(time.Now().Add(flushTimeout)); err != nil {
+			opentsdbReadErrors.Inc()
+			ctx.err = fmt.Errorf("cannot set read deadline: %s", err)
+			return false
+		}
+	}
+	ctx.reqBuf, ctx.tailBuf, ctx.err = common.ReadLinesBlock(r, ctx.reqBuf, ctx.tailBuf)
+	if ctx.err != nil {
+		if ne, ok := ctx.err.(net.Error); ok && ne.Timeout() {
+			// Flush the read data on timeout and try reading again.
+			ctx.err = nil
+		} else {
+			if ctx.err != io.EOF {
+				opentsdbReadErrors.Inc()
+				ctx.err = fmt.Errorf("cannot read OpenTSDB put protocol data: %s", ctx.err)
+			}
+			return false
+		}
+	}
+	ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf))
+
+	// Fill in missing timestamps
+	currentTimestamp := time.Now().Unix()
+	rows := ctx.Rows.Rows
+	for i := range rows {
+		r := &rows[i]
+		if r.Timestamp == 0 {
+			r.Timestamp = currentTimestamp
+		}
+	}
+
+	// Convert timestamps from seconds to milliseconds
+	for i := range rows {
+		rows[i].Timestamp *= 1e3
+	}
+	return true
+}
+
+type pushCtx struct {
+	Rows   Rows
+	Common netstorage.InsertCtx
+
+	reqBuf  []byte
+	tailBuf []byte
+
+	err error
+}
+
+func (ctx *pushCtx) Error() error {
+	if ctx.err == io.EOF {
+		return nil
+	}
+	return ctx.err
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Rows.Reset()
+	ctx.Common.Reset()
+	ctx.reqBuf = ctx.reqBuf[:0]
+	ctx.tailBuf = ctx.tailBuf[:0]
+
+	ctx.err = nil
+}
+
+var (
+	opentsdbReadCalls  = metrics.NewCounter(`vm_read_calls_total{name="opentsdb"}`)
+	opentsdbReadErrors = metrics.NewCounter(`vm_read_errors_total{name="opentsdb"}`)
+)
+
+func getPushCtx() *pushCtx {
+	select {
+	case ctx := <-pushCtxPoolCh:
+		return ctx
+	default:
+		if v := pushCtxPool.Get(); v != nil {
+			return v.(*pushCtx)
+		}
+		return &pushCtx{}
+	}
+}
+
+func putPushCtx(ctx *pushCtx) {
+	ctx.reset()
+	select {
+	case pushCtxPoolCh <- ctx:
+	default:
+		pushCtxPool.Put(ctx)
+	}
+}
+
+var pushCtxPool sync.Pool
+var pushCtxPoolCh = make(chan *pushCtx, runtime.GOMAXPROCS(-1))

app/vminsert/opentsdb/server.go

@@ -0,0 +1,141 @@
+package opentsdb
+
+import (
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/netutil"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	writeRequestsTCP = metrics.NewCounter(`vm_opentsdb_requests_total{name="write", net="tcp"}`)
+	writeErrorsTCP   = metrics.NewCounter(`vm_opentsdb_request_errors_total{name="write", net="tcp"}`)
+
+	writeRequestsUDP = metrics.NewCounter(`vm_opentsdb_requests_total{name="write", net="udp"}`)
+	writeErrorsUDP   = metrics.NewCounter(`vm_opentsdb_request_errors_total{name="write", net="udp"}`)
+)
+
+// Serve starts OpenTSDB collector on the given addr.
+func Serve(addr string) {
+	logger.Infof("starting TCP OpenTSDB collector at %q", addr)
+	lnTCP, err := netutil.NewTCPListener("opentsdb", addr)
+	if err != nil {
+		logger.Fatalf("cannot start TCP OpenTSDB collector at %q: %s", addr, err)
+	}
+	listenerTCP = lnTCP
+
+	logger.Infof("starting UDP OpenTSDB collector at %q", addr)
+	lnUDP, err := net.ListenPacket("udp4", addr)
+	if err != nil {
+		logger.Fatalf("cannot start UDP OpenTSDB collector at %q: %s", addr, err)
+	}
+	listenerUDP = lnUDP
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		serveTCP(listenerTCP)
+		logger.Infof("stopped TCP OpenTSDB collector at %q", addr)
+	}()
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		serveUDP(listenerUDP)
+		logger.Infof("stopped UDP OpenTSDB collector at %q", addr)
+	}()
+	wg.Wait()
+}
+
+func serveTCP(ln net.Listener) {
+	for {
+		c, err := ln.Accept()
+		if err != nil {
+			if ne, ok := err.(net.Error); ok {
+				if ne.Temporary() {
+					time.Sleep(time.Second)
+					continue
+				}
+				if strings.Contains(err.Error(), "use of closed network connection") {
+					break
+				}
+				logger.Fatalf("unrecoverable error when accepting TCP OpenTSDB connections: %s", err)
+			}
+			logger.Fatalf("unexpected error when accepting TCP OpenTSDB connections: %s", err)
+		}
+		go func() {
+			writeRequestsTCP.Inc()
+			var at auth.Token // TODO: properly initialize the auth token
+			if err := insertHandler(&at, c); err != nil {
+				writeErrorsTCP.Inc()
+				logger.Errorf("error in TCP OpenTSDB conn %q<->%q: %s", c.LocalAddr(), c.RemoteAddr(), err)
+			}
+			_ = c.Close()
+		}()
+	}
+}
+
+func serveUDP(ln net.PacketConn) {
+	gomaxprocs := runtime.GOMAXPROCS(-1)
+	var wg sync.WaitGroup
+	for i := 0; i < gomaxprocs; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var bb bytesutil.ByteBuffer
+			bb.B = bytesutil.Resize(bb.B, 64*1024)
+			var at auth.Token // TODO: properly initialize the auth token
+			for {
+				bb.Reset()
+				bb.B = bb.B[:cap(bb.B)]
+				n, addr, err := ln.ReadFrom(bb.B)
+				if err != nil {
+					writeErrorsUDP.Inc()
+					if ne, ok := err.(net.Error); ok {
+						if ne.Temporary() {
+							time.Sleep(time.Second)
+							continue
+						}
+						if strings.Contains(err.Error(), "use of closed network connection") {
+							break
+						}
+					}
+					logger.Errorf("cannot read OpenTSDB UDP data: %s", err)
+					continue
+				}
+				bb.B = bb.B[:n]
+				writeRequestsUDP.Inc()
+				if err := insertHandler(&at, bb.NewReader()); err != nil {
+					writeErrorsUDP.Inc()
+					logger.Errorf("error in UDP OpenTSDB conn %q<->%q: %s", ln.LocalAddr(), addr, err)
+					continue
+				}
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+var (
+	listenerTCP net.Listener
+	listenerUDP net.PacketConn
+)
+
+// Stop stops the server.
+func Stop() {
+	logger.Infof("stopping TCP OpenTSDB server at %q...", listenerTCP.Addr())
+	if err := listenerTCP.Close(); err != nil {
+		logger.Errorf("cannot close TCP OpenTSDB server: %s", err)
+	}
+	logger.Infof("stopping UDP OpenTSDB server at %q...", listenerUDP.LocalAddr())
+	if err := listenerUDP.Close(); err != nil {
+		logger.Errorf("cannot close UDP OpenTSDB server: %s", err)
+	}
+}

app/vminsert/opentsdbhttp/parser.go

@@ -0,0 +1,198 @@
+package opentsdbhttp
+
+import (
+	"fmt"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson"
+	"github.com/valyala/fastjson/fastfloat"
+)
+
+// Rows contains parsed OpenTSDB rows.
+type Rows struct {
+	Rows []Row
+
+	tagsPool []Tag
+}
+
+// Reset resets rs.
+func (rs *Rows) Reset() {
+	// Release references to objects, so they can be GC'ed.
+	for i := range rs.Rows {
+		rs.Rows[i].reset()
+	}
+	rs.Rows = rs.Rows[:0]
+
+	for i := range rs.tagsPool {
+		rs.tagsPool[i].reset()
+	}
+	rs.tagsPool = rs.tagsPool[:0]
+}
+
+// Unmarshal unmarshals OpenTSDB rows from av.
+//
+// See http://opentsdb.net/docs/build/html/api_http/put.html
+//
+// s must be unchanged until rs is in use.
+func (rs *Rows) Unmarshal(av *fastjson.Value) {
+	rs.Rows, rs.tagsPool = unmarshalRows(rs.Rows[:0], av, rs.tagsPool[:0])
+}
+
+// Row is a single OpenTSDB row.
+type Row struct {
+	Metric    string
+	Tags      []Tag
+	Value     float64
+	Timestamp int64
+}
+
+func (r *Row) reset() {
+	r.Metric = ""
+	r.Tags = nil
+	r.Value = 0
+	r.Timestamp = 0
+}
+
+func (r *Row) unmarshal(o *fastjson.Value, tagsPool []Tag) ([]Tag, error) {
+	r.reset()
+	m := o.GetStringBytes("metric")
+	if len(m) == 0 {
+		return tagsPool, fmt.Errorf("missing `metric` in %s", o)
+	}
+	r.Metric = bytesutil.ToUnsafeString(m)
+
+	rawTs := o.Get("timestamp")
+	if rawTs != nil {
+		ts, err := getFloat64(rawTs)
+		if err != nil {
+			return tagsPool, fmt.Errorf("invalid `timestamp` in %s: %s", o, err)
+		}
+		r.Timestamp = int64(ts)
+	} else {
+		// Allow missing timestamp. It is automatically populated
+		// with the current time in this case.
+		r.Timestamp = 0
+	}
+
+	rawV := o.Get("value")
+	if rawV == nil {
+		return tagsPool, fmt.Errorf("missing `value` in %s", o)
+	}
+	v, err := getFloat64(rawV)
+	if err != nil {
+		return tagsPool, fmt.Errorf("invalid `value` in %s: %s", o, err)
+	}
+	r.Value = v
+
+	vt := o.Get("tags")
+	if vt == nil {
+		// Allow empty tags.
+		return tagsPool, nil
+	}
+	rawTags, err := vt.Object()
+	if err != nil {
+		return tagsPool, fmt.Errorf("invalid `tags` in %s: %s", o, err)
+	}
+
+	tagsStart := len(tagsPool)
+	tagsPool, err = unmarshalTags(tagsPool, rawTags)
+	if err != nil {
+		return tagsPool, fmt.Errorf("cannot parse tags %s: %s", rawTags, err)
+	}
+	tags := tagsPool[tagsStart:]
+	r.Tags = tags[:len(tags):len(tags)]
+	return tagsPool, nil
+}
+
+func getFloat64(v *fastjson.Value) (float64, error) {
+	switch v.Type() {
+	case fastjson.TypeNumber:
+		return v.Float64()
+	case fastjson.TypeString:
+		vStr, _ := v.StringBytes()
+		vFloat := fastfloat.ParseBestEffort(bytesutil.ToUnsafeString(vStr))
+		if vFloat == 0 && string(vStr) != "0" && string(vStr) != "0.0" {
+			return 0, fmt.Errorf("invalid float64 value: %q", vStr)
+		}
+		return vFloat, nil
+	default:
+		return 0, fmt.Errorf("value doesn't contain float64; it contains %s", v.Type())
+	}
+}
+
+func unmarshalRows(dst []Row, av *fastjson.Value, tagsPool []Tag) ([]Row, []Tag) {
+	switch av.Type() {
+	case fastjson.TypeObject:
+		return unmarshalRow(dst, av, tagsPool)
+	case fastjson.TypeArray:
+		a, _ := av.Array()
+		for _, o := range a {
+			dst, tagsPool = unmarshalRow(dst, o, tagsPool)
+		}
+		return dst, tagsPool
+	default:
+		logger.Errorf("OpenTSDB JSON must be either object or array; got %s; body=%s", av.Type(), av)
+		invalidLines.Inc()
+		return dst, tagsPool
+	}
+}
+
+func unmarshalRow(dst []Row, o *fastjson.Value, tagsPool []Tag) ([]Row, []Tag) {
+	if cap(dst) > len(dst) {
+		dst = dst[:len(dst)+1]
+	} else {
+		dst = append(dst, Row{})
+	}
+	r := &dst[len(dst)-1]
+	var err error
+	tagsPool, err = r.unmarshal(o, tagsPool)
+	if err != nil {
+		dst = dst[:len(dst)-1]
+		logger.Errorf("cannot unmarshal OpenTSDB object %s: %s", o, err)
+		invalidLines.Inc()
+	}
+	return dst, tagsPool
+}
+
+var invalidLines = metrics.NewCounter(`vm_rows_invalid_total{type="opentsdb-http"}`)
+
+func unmarshalTags(dst []Tag, o *fastjson.Object) ([]Tag, error) {
+	var err error
+	o.Visit(func(k []byte, v *fastjson.Value) {
+		if v.Type() != fastjson.TypeString {
+			err = fmt.Errorf("tag value must be string; got %s; value=%s", v.Type(), v)
+			return
+		}
+		if len(k) == 0 {
+			// Skip empty tags
+			return
+		}
+		vStr, _ := v.StringBytes()
+		if len(vStr) == 0 {
+			// Skip empty tags
+			return
+		}
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Tag{})
+		}
+		tag := &dst[len(dst)-1]
+		tag.Key = bytesutil.ToUnsafeString(k)
+		tag.Value = bytesutil.ToUnsafeString(vStr)
+	})
+	return dst, err
+}
+
+// Tag is an OpenTSDB tag.
+type Tag struct {
+	Key   string
+	Value string
+}
+
+func (t *Tag) reset() {
+	t.Key = ""
+	t.Value = ""
+}

app/vminsert/opentsdbhttp/parser_test.go

@@ -0,0 +1,246 @@
+package opentsdbhttp
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		p := parserPool.Get()
+		defer parserPool.Put(p)
+		v, err := p.Parse(s)
+		if err != nil {
+			// Expected JSON parser error
+			return
+		}
+		// Verify OpenTSDB body parsing error
+		rows.Unmarshal(v)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+		// Try again
+		rows.Unmarshal(v)
+		if len(rows.Rows) != 0 {
+			t.Fatalf("unexpected number of rows parsed; got %d; want 0", len(rows.Rows))
+		}
+	}
+
+	// invalid json
+	f("{g")
+
+	// Invalid json type
+	f(`1`)
+	f(`"foo"`)
+	f(`[1,2]`)
+	f(`null`)
+
+	// Incomplete object
+	f(`{}`)
+	f(`{"metric": "aaa"}`)
+	f(`{"metric": "aaa", "timestamp": 1122}`)
+	f(`{"metric": "aaa", "timestamp": "tststs"}`)
+	f(`{"timestamp": 1122, "value": 33}`)
+	f(`{"value": 33}`)
+	f(`{"value": 33, "tags": {"fooo":"bar"}}`)
+
+	// Invalid value
+	f(`{"metric": "aaa", "timestamp": 1122, "value": "0.0.0"}`)
+
+	// Invalid metric type
+	f(`{"metric": "", "timestamp": 1122, "value": 0.45, "tags": {"foo": "bar"}}`)
+	f(`{"metric": ["aaa"], "timestamp": 1122, "value": 0.45, "tags": {"foo": "bar"}}`)
+	f(`{"metric": {"aaa":1}, "timestamp": 1122, "value": 0.45, "tags": {"foo": "bar"}}`)
+	f(`{"metric": 1, "timestamp": 1122, "value": 0.45, "tags": {"foo": "bar"}}`)
+
+	// Invalid timestamp type
+	f(`{"metric": "aaa", "timestamp": "foobar", "value": 0.45, "tags": {"foo": "bar"}}`)
+	f(`{"metric": "aaa", "timestamp": [1,2], "value": 0.45, "tags": {"foo": "bar"}}`)
+	f(`{"metric": "aaa", "timestamp": {"a":1}, "value": 0.45, "tags": {"foo": "bar"}}`)
+
+	// Invalid value type
+	f(`{"metric": "aaa", "timestamp": 1122, "value": [0,1], "tags": {"foo":"bar"}}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": {"a":1}, "tags": {"foo":"bar"}}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": "foobar", "tags": {"foo":"bar"}}`)
+
+	// Invalid tags type
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": 1}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": [1,2]}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": "foo"}`)
+
+	// Invalid tag value type
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": {"foo": ["bar"]}}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": {"foo": {"bar":"baz"}}}`)
+	f(`{"metric": "aaa", "timestamp": 1122, "value": 0.45, "tags": {"foo": 1}}`)
+
+	// Invalid multiline
+	f(`[{"metric": "aaa", "timestamp": 1122, "value": "trt", "tags":{"foo":"bar"}}, {"metric": "aaa", "timestamp": [1122], "value": 111}]`)
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+
+		p := parserPool.Get()
+		defer parserPool.Put(p)
+		v, err := p.Parse(s)
+		if err != nil {
+			t.Fatalf("cannot parse json %s: %s", s, err)
+		}
+		rows.Unmarshal(v)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		rows.Unmarshal(v)
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		rows.Reset()
+		if len(rows.Rows) != 0 {
+			t.Fatalf("non-empty rows after reset: %+v", rows.Rows)
+		}
+	}
+
+	// Normal line
+	f(`{"metric": "foobar", "timestamp": 789, "value": -123.456, "tags": {"a":"b"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	// Timestamp as string
+	f(`{"metric": "foobar", "timestamp": "1789", "value": -123.456, "tags": {"a":"b"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 1789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	// Timestamp as float64 (it is truncated to integer)
+	f(`{"metric": "foobar", "timestamp": 17.89, "value": -123.456, "tags": {"a":"b"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 17,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	// Empty tags
+	f(`{"metric": "foobar", "timestamp": 789, "value": -123.456, "tags": {}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags:      nil,
+		}},
+	})
+	// Missing tags
+	f(`{"metric": "foobar", "timestamp": 789, "value": -123.456}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags:      nil,
+		}},
+	})
+	// Empty tag value
+	f(`{"metric": "foobar", "timestamp": 123, "value": -123.456, "tags": {"a":"", "b":"c", "": "d"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 123,
+			Tags: []Tag{
+				{
+					Key:   "b",
+					Value: "c",
+				},
+			},
+		}},
+	})
+	// Value as string
+	f(`{"metric": "foobar", "timestamp": 789, "value": "-12.456", "tags": {"a":"b"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -12.456,
+			Timestamp: 789,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+	// Missing timestamp
+	f(`{"metric": "foobar", "value": "-12.456", "tags": {"a":"b"}}`, &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -12.456,
+			Timestamp: 0,
+			Tags: []Tag{{
+				Key:   "a",
+				Value: "b",
+			}},
+		}},
+	})
+
+	// Multiple tags
+	f(`{"metric": "foo", "value": 1, "timestamp": 2, "tags": {"bar":"baz", "x": "y"}}`, &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{
+				{
+					Key:   "bar",
+					Value: "baz",
+				},
+				{
+					Key:   "x",
+					Value: "y",
+				},
+			},
+			Value:     1,
+			Timestamp: 2,
+		}},
+	})
+
+	// Multi lines
+	f(`[{"metric": "foo", "value": "0.3", "timestamp": 2, "tags": {"a":"b"}},
+{"metric": "bar.baz", "value": 0.34, "timestamp": 43, "tags": {"a":"b"}}]`, &Rows{
+		Rows: []Row{
+			{
+				Metric:    "foo",
+				Value:     0.3,
+				Timestamp: 2,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+			{
+				Metric:    "bar.baz",
+				Value:     0.34,
+				Timestamp: 43,
+				Tags: []Tag{{
+					Key:   "a",
+					Value: "b",
+				}},
+			},
+		},
+	})
+}

app/vminsert/opentsdbhttp/parser_timing_test.go

@@ -0,0 +1,33 @@
+package opentsdbhttp
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/valyala/fastjson"
+)
+
+func BenchmarkRowsUnmarshal(b *testing.B) {
+	s := `[{"metric": "cpu.usage_user", "timestamp": 1234556768, "value": 1.23, "tags": {"a":"b", "x": "y"}},
+{"metric": "cpu.usage_system", "timestamp": 1234556768, "value": 23.344, "tags": {"a":"b"}},
+{"metric": "cpu.usage_iowait", "timestamp": 1234556769, "value":3.3443, "tags": {"a":"b"}},
+{"metric": "cpu.usage_irq", "timestamp": 1234556768, "value": 0.34432, "tags": {"a":"b"}}
+]
+`
+	b.SetBytes(int64(len(s)))
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		var rows Rows
+		var p fastjson.Parser
+		for pb.Next() {
+			v, err := p.Parse(s)
+			if err != nil {
+				panic(fmt.Errorf("cannot parse %q: %s", s, err))
+			}
+			rows.Unmarshal(v)
+			if len(rows.Rows) != 4 {
+				panic(fmt.Errorf("unexpected number of rows unmarshaled; got %d; want 4", len(rows.Rows)))
+			}
+		}
+	})
+}

app/vminsert/opentsdbhttp/request_handler.go

@@ -0,0 +1,155 @@
+package opentsdbhttp
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/common"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/tenantmetrics"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/fastjson"
+)
+
+var (
+	rowsInserted  = tenantmetrics.NewCounterMap(`vm_rows_inserted_total{type="opentsdb-http"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="opentsdb-http"}`)
+
+	opentsdbReadCalls       = metrics.NewCounter(`vm_read_calls_total{name="opentsdb-http"}`)
+	opentsdbReadErrors      = metrics.NewCounter(`vm_read_errors_total{name="opentsdb-http"}`)
+	opentsdbUnmarshalErrors = metrics.NewCounter(`vm_unmarshal_errors_total{name="opentsdb-http"}`)
+)
+
+// insertHandler processes HTTP OpenTSDB put requests.
+// See http://opentsdb.net/docs/build/html/api_http/put.html
+func insertHandler(at *auth.Token, req *http.Request, maxSize int64) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(at, req, maxSize)
+	})
+}
+
+func insertHandlerInternal(at *auth.Token, req *http.Request, maxSize int64) error {
+	opentsdbReadCalls.Inc()
+
+	r := req.Body
+	if req.Header.Get("Content-Encoding") == "gzip" {
+		zr, err := common.GetGzipReader(r)
+		if err != nil {
+			opentsdbReadErrors.Inc()
+			return fmt.Errorf("cannot read gzipped http protocol data: %s", err)
+		}
+		defer common.PutGzipReader(zr)
+		r = zr
+	}
+
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+
+	// Read the request in ctx.reqBuf
+	lr := io.LimitReader(r, maxSize+1)
+	reqLen, err := ctx.reqBuf.ReadFrom(lr)
+	if err != nil {
+		opentsdbReadErrors.Inc()
+		return fmt.Errorf("cannot read HTTP OpenTSDB request: %s", err)
+	}
+	if reqLen > maxSize {
+		opentsdbReadErrors.Inc()
+		return fmt.Errorf("too big HTTP OpenTSDB request; mustn't exceed %d bytes", maxSize)
+	}
+
+	// Unmarshal the request to ctx.Rows
+	p := parserPool.Get()
+	defer parserPool.Put(p)
+	v, err := p.ParseBytes(ctx.reqBuf.B)
+	if err != nil {
+		opentsdbUnmarshalErrors.Inc()
+		return fmt.Errorf("cannot parse HTTP OpenTSDB json: %s", err)
+	}
+	ctx.Rows.Unmarshal(v)
+
+	// Fill in missing timestamps
+	currentTimestamp := time.Now().Unix()
+	rows := ctx.Rows.Rows
+	for i := range rows {
+		r := &rows[i]
+		if r.Timestamp == 0 {
+			r.Timestamp = currentTimestamp
+		}
+	}
+
+	// Convert timestamps in seconds to milliseconds if needed.
+	// See http://opentsdb.net/docs/javadoc/net/opentsdb/core/Const.html#SECOND_MASK
+	for i := range rows {
+		r := &rows[i]
+		if r.Timestamp&secondMask == 0 {
+			r.Timestamp *= 1e3
+		}
+	}
+
+	// Insert ctx.Rows to db.
+	ic := &ctx.Common
+	ic.Reset()
+	for i := range rows {
+		r := &rows[i]
+		ic.Labels = ic.Labels[:0]
+		ic.AddLabel("", r.Metric)
+		for j := range r.Tags {
+			tag := &r.Tags[j]
+			ic.AddLabel(tag.Key, tag.Value)
+		}
+		if err := ic.WriteDataPoint(at, ic.Labels, r.Timestamp, r.Value); err != nil {
+			return err
+		}
+	}
+	rowsInserted.Get(at).Add(len(rows))
+	rowsPerInsert.Update(float64(len(rows)))
+	return ic.FlushBufs()
+}
+
+const secondMask int64 = 0x7FFFFFFF00000000
+
+var parserPool fastjson.ParserPool
+
+type pushCtx struct {
+	Rows   Rows
+	Common netstorage.InsertCtx
+
+	reqBuf bytesutil.ByteBuffer
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Rows.Reset()
+	ctx.Common.Reset()
+	ctx.reqBuf.Reset()
+}
+
+func getPushCtx() *pushCtx {
+	select {
+	case ctx := <-pushCtxPoolCh:
+		return ctx
+	default:
+		if v := pushCtxPool.Get(); v != nil {
+			return v.(*pushCtx)
+		}
+		return &pushCtx{}
+	}
+}
+
+func putPushCtx(ctx *pushCtx) {
+	ctx.reset()
+	select {
+	case pushCtxPoolCh <- ctx:
+	default:
+		pushCtxPool.Put(ctx)
+	}
+}
+
+var pushCtxPool sync.Pool
+var pushCtxPoolCh = make(chan *pushCtx, runtime.GOMAXPROCS(-1))

app/vminsert/opentsdbhttp/server.go

@@ -0,0 +1,87 @@
+package opentsdbhttp
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	writeRequests = metrics.NewCounter(`vm_http_requests_total{path="/insert/{}/api/put", protocol="opentsdb-http"}`)
+	writeErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/insert/{}/api/put", protocol="opentsdb-http"}`)
+)
+
+var (
+	httpServer     *http.Server
+	httpAddr       string
+	maxRequestSize int64
+)
+
+// Serve starts HTTP OpenTSDB server on the given addr.
+func Serve(addr string, maxReqSize int64) {
+	logger.Infof("starting HTTP OpenTSDB server at %q", addr)
+	httpAddr = addr
+	maxRequestSize = maxReqSize
+	httpServer = &http.Server{
+		Addr:         addr,
+		Handler:      http.HandlerFunc(requestHandler),
+		ReadTimeout:  30 * time.Second,
+		WriteTimeout: 10 * time.Second,
+	}
+	go func() {
+		err := httpServer.ListenAndServe()
+		if err == http.ErrServerClosed {
+			return
+		}
+		if err != nil {
+			logger.Fatalf("FATAL: error serving HTTP OpenTSDB: %s", err)
+		}
+	}()
+}
+
+// requestHandler handles HTTP OpenTSDB insert request.
+func requestHandler(w http.ResponseWriter, r *http.Request) {
+	p, err := httpserver.ParsePath(r.URL.Path)
+	if err != nil {
+		httpserver.Errorf(w, "cannot parse path %q: %s", r.URL.Path, err)
+		return
+	}
+	if p.Prefix != "insert" {
+		// This is not our link.
+		httpserver.Errorf(w, "unexpected path requested on HTTP OpenTSDB server: %q", r.URL.Path)
+		return
+	}
+	at, err := auth.NewToken(p.AuthToken)
+	if err != nil {
+		httpserver.Errorf(w, "auth error: %s", err)
+		return
+	}
+
+	switch p.Suffix {
+	case "api/put":
+		writeRequests.Inc()
+		if err := insertHandler(at, r, maxRequestSize); err != nil {
+			writeErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	default:
+		httpserver.Errorf(w, "unexpected path requested on HTTP OpenTSDB server: %q", r.URL.Path)
+	}
+}
+
+// Stop stops HTTP OpenTSDB server.
+func Stop() {
+	logger.Infof("stopping HTTP OpenTSDB server at %q...", httpAddr)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := httpServer.Shutdown(ctx); err != nil {
+		logger.Fatalf("FATAL: cannot close HTTP OpenTSDB server: %s", err)
+	}
+}

app/vminsert/prometheus/request_handler.go

@@ -0,0 +1,118 @@
+package prometheus
+
+import (
+	"fmt"
+	"net/http"
+	"runtime"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompb"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/tenantmetrics"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	rowsInserted  = tenantmetrics.NewCounterMap(`vm_rows_inserted_total{type="prometheus"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="prometheus"}`)
+)
+
+// InsertHandler processes remote write for prometheus.
+func InsertHandler(at *auth.Token, r *http.Request, maxSize int64) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(at, r, maxSize)
+	})
+}
+
+func insertHandlerInternal(at *auth.Token, r *http.Request, maxSize int64) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	if err := ctx.Read(r, maxSize); err != nil {
+		return err
+	}
+
+	ic := &ctx.Common
+	ic.Reset()
+	timeseries := ctx.req.Timeseries
+	rowsTotal := 0
+	for i := range timeseries {
+		ts := &timeseries[i]
+		storageNodeIdx := ic.GetStorageNodeIdx(at, ts.Labels)
+		ic.MetricNameBuf = ic.MetricNameBuf[:0]
+		for i := range ts.Samples {
+			r := &ts.Samples[i]
+			if len(ic.MetricNameBuf) == 0 {
+				ic.MetricNameBuf = storage.MarshalMetricNameRaw(ic.MetricNameBuf[:0], at.AccountID, at.ProjectID, ts.Labels)
+			}
+			if err := ic.WriteDataPointExt(at, storageNodeIdx, ic.MetricNameBuf, r.Timestamp, r.Value); err != nil {
+				return err
+			}
+		}
+		rowsTotal += len(ts.Samples)
+	}
+	rowsInserted.Get(at).Add(rowsTotal)
+	rowsPerInsert.Update(float64(rowsTotal))
+	return ic.FlushBufs()
+}
+
+type pushCtx struct {
+	Common netstorage.InsertCtx
+
+	req    prompb.WriteRequest
+	reqBuf []byte
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Common.Reset()
+	ctx.req.Reset()
+	ctx.reqBuf = ctx.reqBuf[:0]
+}
+
+func (ctx *pushCtx) Read(r *http.Request, maxSize int64) error {
+	prometheusReadCalls.Inc()
+
+	var err error
+	ctx.reqBuf, err = prompb.ReadSnappy(ctx.reqBuf[:0], r.Body, maxSize)
+	if err != nil {
+		prometheusReadErrors.Inc()
+		return fmt.Errorf("cannot read prompb.WriteRequest: %s", err)
+	}
+	if err = ctx.req.Unmarshal(ctx.reqBuf); err != nil {
+		prometheusUnmarshalErrors.Inc()
+		return fmt.Errorf("cannot unmarshal prompb.WriteRequest with size %d bytes: %s", len(ctx.reqBuf), err)
+	}
+	return nil
+}
+
+var (
+	prometheusReadCalls       = metrics.NewCounter(`vm_read_calls_total{name="prometheus"}`)
+	prometheusReadErrors      = metrics.NewCounter(`vm_read_errors_total{name="prometheus"}`)
+	prometheusUnmarshalErrors = metrics.NewCounter(`vm_unmarshal_errors_total{name="prometheus"}`)
+)
+
+func getPushCtx() *pushCtx {
+	select {
+	case ctx := <-pushCtxPoolCh:
+		return ctx
+	default:
+		if v := pushCtxPool.Get(); v != nil {
+			return v.(*pushCtx)
+		}
+		return &pushCtx{}
+	}
+}
+
+func putPushCtx(ctx *pushCtx) {
+	ctx.reset()
+	select {
+	case pushCtxPoolCh <- ctx:
+	default:
+		pushCtxPool.Put(ctx)
+	}
+}
+
+var pushCtxPool sync.Pool
+var pushCtxPoolCh = make(chan *pushCtx, runtime.GOMAXPROCS(-1))

app/vmselect/Makefile

@@ -0,0 +1,38 @@
+# All these commands must run from repository root.
+
+run-vmselect:
+	mkdir -p vmselect-cache
+	DOCKER_OPTS='-v $(shell pwd)/vmselect-cache:/cache' \
+	APP_NAME=vmselect \
+	ARGS='-storageNode=localhost:8401 -selectNode=localhost:8481 -cacheDataPath=/cache' \
+	$(MAKE) run-via-docker
+
+vmselect:
+	APP_NAME=vmselect $(MAKE) app-local
+
+vmselect-race:
+	APP_NAME=vmselect RACE=-race $(MAKE) app-local
+
+vmselect-prod:
+	APP_NAME=vmselect $(MAKE) app-via-docker
+
+vmselect-prod-race:
+	APP_NAME=vmselect RACE=-race $(MAKE) app-via-docker
+
+vmselect-pure:
+	APP_NAME=vmselect $(MAKE) app-local-pure
+
+vmselect-pure-prod:
+	APP_NAME=vmselect APP_SUFFIX='-pure' DOCKER_OPTS='--env CGO_ENABLED=0' $(MAKE) app-via-docker
+
+package-vmselect:
+	APP_NAME=vmselect $(MAKE) package-via-docker
+
+package-vmselect-race:
+	APP_NAME=vmselect RACE=-race $(MAKE) package-via-docker
+
+publish-vmselect:
+	APP_NAME=vmselect $(MAKE) publish-via-docker
+
+publish-vmselect-race:
+	APP_NAME=vmselect RACE=-race $(MAKE) publish-via-docker

app/vmselect/README.md

@@ -0,0 +1,6 @@
+`vmselect` performs the following tasks:
+
+- Splits incoming selects to tasks for `vmstorage` nodes and issues these tasks
+  to all the `vmstorage` nodes in the cluster.
+
+- Merges responses from all the `vmstorage` nodes and returns a single response.

app/vmselect/deployment/Dockerfile

@@ -0,0 +1,5 @@
+FROM scratch
+COPY --from=local/certs:1.0.2 /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
+COPY bin/vmselect-prod .
+EXPOSE 8481
+ENTRYPOINT ["/vmselect-prod"]

app/vmselect/main.go

@@ -0,0 +1,300 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/prometheus"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/promql"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/procutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	httpListenAddr        = flag.String("httpListenAddr", ":8481", "Address to listen for http connections")
+	cacheDataPath         = flag.String("cacheDataPath", "", "Path to directory for cache files. Cache isn't saved if empty")
+	maxConcurrentRequests = flag.Int("search.maxConcurrentRequests", runtime.GOMAXPROCS(-1)*2, "The maximum number of concurrent search requests. It shouldn't exceed 2*vCPUs for better performance. See also -search.maxQueueDuration")
+	maxQueueDuration      = flag.Duration("search.maxQueueDuration", 10*time.Second, "The maximum time the request waits for execution when -search.maxConcurrentRequests limit is reached")
+	storageNodes          = flagutil.NewArray("storageNode", "Addresses of vmstorage nodes; usage: -storageNode=vmstorage-host1:8401 -storageNode=vmstorage-host2:8401")
+)
+
+func main() {
+	flag.Parse()
+	buildinfo.Init()
+	logger.Init()
+
+	logger.Infof("starting netstorage at storageNodes %s", *storageNodes)
+	startTime := time.Now()
+	if len(*storageNodes) == 0 {
+		logger.Fatalf("missing -storageNode arg")
+	}
+	netstorage.InitStorageNodes(*storageNodes)
+	logger.Infof("started netstorage in %s", time.Since(startTime))
+
+	if len(*cacheDataPath) > 0 {
+		tmpDataPath := *cacheDataPath + "/tmp"
+		fs.RemoveDirContents(tmpDataPath)
+		netstorage.InitTmpBlocksDir(tmpDataPath)
+		promql.InitRollupResultCache(*cacheDataPath + "/rollupResult")
+	} else {
+		netstorage.InitTmpBlocksDir("")
+		promql.InitRollupResultCache("")
+	}
+	concurrencyCh = make(chan struct{}, *maxConcurrentRequests)
+
+	go func() {
+		httpserver.Serve(*httpListenAddr, requestHandler)
+	}()
+
+	sig := procutil.WaitForSigterm()
+	logger.Infof("service received signal %s", sig)
+
+	logger.Infof("gracefully shutting down the service at %q", *httpListenAddr)
+	startTime = time.Now()
+	if err := httpserver.Stop(*httpListenAddr); err != nil {
+		logger.Fatalf("cannot stop the service: %s", err)
+	}
+	logger.Infof("successfully shut down the service in %s", time.Since(startTime))
+
+	logger.Infof("shutting down neststorage...")
+	startTime = time.Now()
+	netstorage.Stop()
+	if len(*cacheDataPath) > 0 {
+		promql.StopRollupResultCache()
+	}
+	logger.Infof("successfully stopped netstorage in %s", time.Since(startTime))
+
+	fs.MustStopDirRemover()
+
+	logger.Infof("the vmselect has been stopped")
+}
+
+var concurrencyCh chan struct{}
+
+var (
+	concurrencyLimitReached = metrics.NewCounter(`vm_concurrent_select_limit_reached_total`)
+	concurrencyLimitTimeout = metrics.NewCounter(`vm_concurrent_select_limit_timeout_total`)
+
+	_ = metrics.NewGauge(`vm_concurrent_select_capacity`, func() float64 {
+		return float64(cap(concurrencyCh))
+	})
+	_ = metrics.NewGauge(`vm_concurrent_select_current`, func() float64 {
+		return float64(len(concurrencyCh))
+	})
+)
+
+func requestHandler(w http.ResponseWriter, r *http.Request) bool {
+	// Limit the number of concurrent queries.
+	select {
+	case concurrencyCh <- struct{}{}:
+		defer func() { <-concurrencyCh }()
+	default:
+		// Sleep for a while until giving up. This should resolve short bursts in requests.
+		concurrencyLimitReached.Inc()
+		t := timerpool.Get(*maxQueueDuration)
+		select {
+		case concurrencyCh <- struct{}{}:
+			timerpool.Put(t)
+			defer func() { <-concurrencyCh }()
+		case <-t.C:
+			timerpool.Put(t)
+			concurrencyLimitTimeout.Inc()
+			err := &httpserver.ErrorWithStatusCode{
+				Err:        fmt.Errorf("cannot handle more than %d concurrent requests", cap(concurrencyCh)),
+				StatusCode: http.StatusServiceUnavailable,
+			}
+			httpserver.Errorf(w, "%s", err)
+			return true
+		}
+	}
+
+	path := r.URL.Path
+	if path == "/internal/resetRollupResultCache" {
+		promql.ResetRollupResultCache()
+		return true
+	}
+
+	p, err := httpserver.ParsePath(path)
+	if err != nil {
+		httpserver.Errorf(w, "cannot parse path %q: %s", path, err)
+		return true
+	}
+	at, err := auth.NewToken(p.AuthToken)
+	if err != nil {
+		httpserver.Errorf(w, "auth error: %s", err)
+		return true
+	}
+	switch p.Prefix {
+	case "select":
+		return selectHandler(w, r, p, at)
+	case "delete":
+		return deleteHandler(w, r, p, at)
+	default:
+		// This is not our link
+		return false
+	}
+}
+
+func selectHandler(w http.ResponseWriter, r *http.Request, p *httpserver.Path, at *auth.Token) bool {
+	if strings.HasPrefix(p.Suffix, "prometheus/api/v1/label/") {
+		s := p.Suffix[len("prometheus/api/v1/label/"):]
+		if strings.HasSuffix(s, "/values") {
+			labelValuesRequests.Inc()
+			labelName := s[:len(s)-len("/values")]
+			httpserver.EnableCORS(w, r)
+			if err := prometheus.LabelValuesHandler(at, labelName, w, r); err != nil {
+				labelValuesErrors.Inc()
+				sendPrometheusError(w, r, err)
+				return true
+			}
+			return true
+		}
+	}
+
+	switch p.Suffix {
+	case "prometheus/api/v1/query":
+		queryRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.QueryHandler(at, w, r); err != nil {
+			queryErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/query_range":
+		queryRangeRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.QueryRangeHandler(at, w, r); err != nil {
+			queryRangeErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/series":
+		seriesRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.SeriesHandler(at, w, r); err != nil {
+			seriesErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/series/count":
+		seriesCountRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.SeriesCountHandler(at, w, r); err != nil {
+			seriesCountErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/labels":
+		labelsRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.LabelsHandler(at, w, r); err != nil {
+			labelsErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/labels/count":
+		labelsCountRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.LabelsCountHandler(at, w, r); err != nil {
+			labelsCountErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "prometheus/api/v1/export":
+		exportRequests.Inc()
+		if err := prometheus.ExportHandler(at, w, r); err != nil {
+			exportErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		return true
+	case "prometheus/federate":
+		federateRequests.Inc()
+		if err := prometheus.FederateHandler(at, w, r); err != nil {
+			federateErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		return true
+	default:
+		return false
+	}
+}
+
+func deleteHandler(w http.ResponseWriter, r *http.Request, p *httpserver.Path, at *auth.Token) bool {
+	switch p.Suffix {
+	case "prometheus/api/v1/admin/tsdb/delete_series":
+		deleteRequests.Inc()
+		if err := prometheus.DeleteHandler(at, r); err != nil {
+			deleteErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		w.WriteHeader(http.StatusNoContent)
+		return true
+	default:
+		return false
+	}
+}
+
+func sendPrometheusError(w http.ResponseWriter, r *http.Request, err error) {
+	logger.Errorf("error in %q: %s", r.URL.Path, err)
+
+	w.Header().Set("Content-Type", "application/json")
+	statusCode := http.StatusUnprocessableEntity
+	if esc, ok := err.(*httpserver.ErrorWithStatusCode); ok {
+		statusCode = esc.StatusCode
+	}
+	w.WriteHeader(statusCode)
+	prometheus.WriteErrorResponse(w, statusCode, err)
+}
+
+var (
+	labelValuesRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/label/{}/values"}`)
+	labelValuesErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="select/{}/prometheus/api/v1/label/{}/values"}`)
+
+	queryRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/query"}`)
+	queryErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/query"}`)
+
+	queryRangeRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/prometheus/api/v1/query_range"}`)
+	queryRangeErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/query_range"}`)
+
+	seriesRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/series"}`)
+	seriesErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/series"}`)
+
+	seriesCountRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/series/count"}`)
+	seriesCountErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/series/count"}`)
+
+	labelsRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/labels"}`)
+	labelsErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/labels"}`)
+
+	labelsCountRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/labels/count"}`)
+	labelsCountErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/labels/count"}`)
+
+	deleteRequests = metrics.NewCounter(`vm_http_requests_total{path="/delete/{}/prometheus/api/v1/admin/tsdb/delete_series"}`)
+	deleteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/delete/{}/prometheus/api/v1/admin/tsdb/delete_series"}`)
+
+	exportRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/api/v1/export"}`)
+	exportErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/api/v1/export"}`)
+
+	federateRequests = metrics.NewCounter(`vm_http_requests_total{path="/select/{}/prometheus/federate"}`)
+	federateErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/select/{}/prometheus/federate"}`)
+)

app/vmselect/netstorage/fadvise_darwin.go

@@ -0,0 +1,9 @@
+package netstorage
+
+import (
+	"os"
+)
+
+func mustFadviseRandomRead(f *os.File) {
+	// Do nothing :)
+}

app/vmselect/netstorage/fadvise_freebsd.go

@@ -0,0 +1,15 @@
+package netstorage
+
+import (
+	"os"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"golang.org/x/sys/unix"
+)
+
+func mustFadviseRandomRead(f *os.File) {
+	fd := int(f.Fd())
+	if err := unix.Fadvise(int(fd), 0, 0, unix.FADV_RANDOM|unix.FADV_WILLNEED); err != nil {
+		logger.Panicf("FATAL: error returned from unix.Fadvise(RANDOM|WILLNEED): %s", err)
+	}
+}

app/vmselect/netstorage/fadvise_linux.go

@@ -0,0 +1,15 @@
+package netstorage
+
+import (
+	"os"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"golang.org/x/sys/unix"
+)
+
+func mustFadviseRandomRead(f *os.File) {
+	fd := int(f.Fd())
+	if err := unix.Fadvise(int(fd), 0, 0, unix.FADV_RANDOM|unix.FADV_WILLNEED); err != nil {
+		logger.Panicf("FATAL: error returned from unix.Fadvise(RANDOM|WILLNEED): %s", err)
+	}
+}

app/vmselect/netstorage/tmp_blocks_file.go

@@ -0,0 +1,180 @@
+package netstorage
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/memory"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+// InitTmpBlocksDir initializes directory to store temporary search results.
+//
+// It stores data in system-defined temporary directory if tmpDirPath is empty.
+func InitTmpBlocksDir(tmpDirPath string) {
+	if len(tmpDirPath) == 0 {
+		tmpDirPath = os.TempDir()
+	}
+	tmpBlocksDir = tmpDirPath + "/searchResults"
+	fs.MustRemoveAll(tmpBlocksDir)
+	if err := fs.MkdirAllIfNotExist(tmpBlocksDir); err != nil {
+		logger.Panicf("FATAL: cannot create %q: %s", tmpBlocksDir, err)
+	}
+}
+
+var tmpBlocksDir string
+
+func maxInmemoryTmpBlocksFile() int {
+	mem := memory.Allowed()
+	maxLen := mem / 1024
+	if maxLen < 64*1024 {
+		return 64 * 1024
+	}
+	return maxLen
+}
+
+var _ = metrics.NewGauge(`vm_tmp_blocks_max_inmemory_file_size_bytes`, func() float64 {
+	return float64(maxInmemoryTmpBlocksFile())
+})
+
+type tmpBlocksFile struct {
+	buf []byte
+
+	f *os.File
+
+	offset uint64
+}
+
+func getTmpBlocksFile() *tmpBlocksFile {
+	v := tmpBlocksFilePool.Get()
+	if v == nil {
+		return &tmpBlocksFile{
+			buf: make([]byte, 0, maxInmemoryTmpBlocksFile()),
+		}
+	}
+	return v.(*tmpBlocksFile)
+}
+
+func putTmpBlocksFile(tbf *tmpBlocksFile) {
+	tbf.MustClose()
+	tbf.buf = tbf.buf[:0]
+	tbf.f = nil
+	tbf.offset = 0
+	tmpBlocksFilePool.Put(tbf)
+}
+
+var tmpBlocksFilePool sync.Pool
+
+type tmpBlockAddr struct {
+	offset uint64
+	size   int
+}
+
+func (addr tmpBlockAddr) String() string {
+	return fmt.Sprintf("offset %d, size %d", addr.offset, addr.size)
+}
+
+var tmpBlocksFilesCreated = metrics.NewCounter(`vm_tmp_blocks_files_created_total`)
+
+// WriteBlock writes b to tbf.
+//
+// It returns errors since the operation may fail on space shortage
+// and this must be handled.
+func (tbf *tmpBlocksFile) WriteBlock(b *storage.Block) (tmpBlockAddr, error) {
+	bb := tmpBufPool.Get()
+	defer tmpBufPool.Put(bb)
+	bb.B = storage.MarshalBlock(bb.B[:0], b)
+
+	var addr tmpBlockAddr
+	addr.offset = tbf.offset
+	addr.size = len(bb.B)
+	tbf.offset += uint64(addr.size)
+	if len(tbf.buf)+len(bb.B) <= cap(tbf.buf) {
+		// Fast path - the data fits tbf.buf
+		tbf.buf = append(tbf.buf, bb.B...)
+		return addr, nil
+	}
+
+	// Slow path: flush the data from tbf.buf to file.
+	if tbf.f == nil {
+		f, err := ioutil.TempFile(tmpBlocksDir, "")
+		if err != nil {
+			return addr, err
+		}
+		tbf.f = f
+		tmpBlocksFilesCreated.Inc()
+	}
+	_, err := tbf.f.Write(tbf.buf)
+	tbf.buf = append(tbf.buf[:0], bb.B...)
+	if err != nil {
+		return addr, fmt.Errorf("cannot write block to %q: %s", tbf.f.Name(), err)
+	}
+	return addr, nil
+}
+
+func (tbf *tmpBlocksFile) Finalize() error {
+	if tbf.f == nil {
+		return nil
+	}
+	if _, err := tbf.f.Write(tbf.buf); err != nil {
+		return fmt.Errorf("cannot flush the remaining %d bytes to tmpBlocksFile: %s", len(tbf.buf), err)
+	}
+	tbf.buf = tbf.buf[:0]
+	if _, err := tbf.f.Seek(0, 0); err != nil {
+		logger.Panicf("FATAL: cannot seek to the start of file: %s", err)
+	}
+	mustFadviseRandomRead(tbf.f)
+	return nil
+}
+
+func (tbf *tmpBlocksFile) MustReadBlockAt(dst *storage.Block, addr tmpBlockAddr) {
+	var buf []byte
+	if tbf.f == nil {
+		buf = tbf.buf[addr.offset : addr.offset+uint64(addr.size)]
+	} else {
+		bb := tmpBufPool.Get()
+		defer tmpBufPool.Put(bb)
+		bb.B = bytesutil.Resize(bb.B, addr.size)
+		n, err := tbf.f.ReadAt(bb.B, int64(addr.offset))
+		if err != nil {
+			logger.Panicf("FATAL: cannot read from %q at %s: %s", tbf.f.Name(), addr, err)
+		}
+		if n != len(bb.B) {
+			logger.Panicf("FATAL: too short number of bytes read at %s; got %d; want %d", addr, n, len(bb.B))
+		}
+		buf = bb.B
+	}
+	tail, err := storage.UnmarshalBlock(dst, buf)
+	if err != nil {
+		logger.Panicf("FATAL: cannot unmarshal data at %s: %s", addr, err)
+	}
+	if len(tail) > 0 {
+		logger.Panicf("FATAL: unexpected non-empty tail left after unmarshaling data at %s; len(tail)=%d", addr, len(tail))
+	}
+}
+
+var tmpBufPool bytesutil.ByteBufferPool
+
+func (tbf *tmpBlocksFile) MustClose() {
+	if tbf.f == nil {
+		return
+	}
+	fname := tbf.f.Name()
+
+	// Remove the file at first, then close it.
+	// This way the OS shouldn't try to flush file contents to storage
+	// on close.
+	if err := os.Remove(fname); err != nil {
+		logger.Panicf("FATAL: cannot remove %q: %s", fname, err)
+	}
+	if err := tbf.f.Close(); err != nil {
+		logger.Panicf("FATAL: cannot close %q: %s", fname, err)
+	}
+	tbf.f = nil
+}

app/vmselect/netstorage/tmp_blocks_file_test.go

@@ -0,0 +1,150 @@
+package netstorage
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+func TestMain(m *testing.M) {
+	rand.Seed(time.Now().UnixNano())
+	tmpDir := "TestTmpBlocks"
+	InitTmpBlocksDir(tmpDir)
+	statusCode := m.Run()
+	if err := os.RemoveAll(tmpDir); err != nil {
+		logger.Panicf("cannot remove %q: %s", tmpDir, err)
+	}
+	os.Exit(statusCode)
+}
+
+func TestTmpBlocksFileSerial(t *testing.T) {
+	if err := testTmpBlocksFile(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+}
+
+func TestTmpBlocksFileConcurrent(t *testing.T) {
+	concurrency := 3
+	ch := make(chan error, concurrency)
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			ch <- testTmpBlocksFile()
+		}()
+	}
+	for i := 0; i < concurrency; i++ {
+		select {
+		case err := <-ch:
+			if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+		case <-time.After(30 * time.Second):
+			t.Fatalf("timeout")
+		}
+	}
+}
+
+func testTmpBlocksFile() error {
+	createBlock := func() *storage.Block {
+		rowsCount := rand.Intn(8000) + 1
+		var timestamps, values []int64
+		ts := int64(rand.Intn(1023434))
+		for i := 0; i < rowsCount; i++ {
+			ts += int64(rand.Intn(1000) + 1)
+			timestamps = append(timestamps, ts)
+			values = append(values, int64(i*i+rand.Intn(20)))
+		}
+		tsid := &storage.TSID{
+			MetricID: 234211,
+		}
+		scale := int16(rand.Intn(123))
+		precisionBits := uint8(rand.Intn(63) + 1)
+		var b storage.Block
+		b.Init(tsid, timestamps, values, scale, precisionBits)
+		_, _, _ = b.MarshalData(0, 0)
+		return &b
+	}
+	for _, size := range []int{1024, 16 * 1024, maxInmemoryTmpBlocksFile() / 2, 2 * maxInmemoryTmpBlocksFile()} {
+		err := func() error {
+			tbf := getTmpBlocksFile()
+			defer putTmpBlocksFile(tbf)
+
+			// Write blocks until their summary size exceeds `size`.
+			var addrs []tmpBlockAddr
+			var blocks []*storage.Block
+			for tbf.offset < uint64(size) {
+				b := createBlock()
+				addr, err := tbf.WriteBlock(b)
+				if err != nil {
+					return fmt.Errorf("cannot write block at offset %d: %s", tbf.offset, err)
+				}
+				if addr.offset+uint64(addr.size) != tbf.offset {
+					return fmt.Errorf("unexpected addr=%+v for offset %v", &addr, tbf.offset)
+				}
+				addrs = append(addrs, addr)
+				blocks = append(blocks, b)
+			}
+			if err := tbf.Finalize(); err != nil {
+				return fmt.Errorf("cannot finalize tbf: %s", err)
+			}
+
+			// Read blocks in parallel and verify them
+			concurrency := 2
+			workCh := make(chan int)
+			doneCh := make(chan error)
+			for i := 0; i < concurrency; i++ {
+				go func() {
+					doneCh <- func() error {
+						var b1 storage.Block
+						for idx := range workCh {
+							addr := addrs[idx]
+							b := blocks[idx]
+							if err := b.UnmarshalData(); err != nil {
+								return fmt.Errorf("cannot unmarshal data from the original block: %s", err)
+							}
+							b1.Reset()
+							tbf.MustReadBlockAt(&b1, addr)
+							if err := b1.UnmarshalData(); err != nil {
+								return fmt.Errorf("cannot unmarshal data from tbf: %s", err)
+							}
+							if b1.RowsCount() != b.RowsCount() {
+								return fmt.Errorf("unexpected number of rows in tbf block; got %d; want %d", b1.RowsCount(), b.RowsCount())
+							}
+							if !reflect.DeepEqual(b1.Timestamps(), b.Timestamps()) {
+								return fmt.Errorf("unexpected timestamps; got\n%v\nwant\n%v", b1.Timestamps(), b.Timestamps())
+							}
+							if !reflect.DeepEqual(b1.Values(), b.Values()) {
+								return fmt.Errorf("unexpected values; got\n%v\nwant\n%v", b1.Values(), b.Values())
+							}
+						}
+						return nil
+					}()
+				}()
+			}
+			for i := range addrs {
+				workCh <- i
+			}
+			close(workCh)
+			for i := 0; i < concurrency; i++ {
+				select {
+				case err := <-doneCh:
+					if err != nil {
+						return err
+					}
+				case <-time.After(time.Second):
+					return fmt.Errorf("timeout")
+				}
+			}
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

app/vmselect/prometheus/error_response.qtpl

@@ -0,0 +1,11 @@
+{% stripspace %}
+ErrorResponse generates error response for /api/v1/query.
+See https://prometheus.io/docs/prometheus/latest/querying/api/#format-overview
+{% func ErrorResponse(statusCode int, err error) %}
+{
+	"status":"error",
+	"errorType":"{%d statusCode %}",
+	"error": {%q= err.Error() %}
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/error_response.qtpl.go

@@ -0,0 +1,61 @@
+// Code generated by qtc from "error_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+// ErrorResponse generates error response for /api/v1/query.See https://prometheus.io/docs/prometheus/latest/querying/api/#format-overview
+
+//line app/vmselect/prometheus/error_response.qtpl:4
+package prometheus
+
+//line app/vmselect/prometheus/error_response.qtpl:4
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/error_response.qtpl:4
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/error_response.qtpl:4
+func StreamErrorResponse(qw422016 *qt422016.Writer, statusCode int, err error) {
+//line app/vmselect/prometheus/error_response.qtpl:4
+	qw422016.N().S(`{"status":"error","errorType":"`)
+//line app/vmselect/prometheus/error_response.qtpl:7
+	qw422016.N().D(statusCode)
+//line app/vmselect/prometheus/error_response.qtpl:7
+	qw422016.N().S(`","error":`)
+//line app/vmselect/prometheus/error_response.qtpl:8
+	qw422016.N().Q(err.Error())
+//line app/vmselect/prometheus/error_response.qtpl:8
+	qw422016.N().S(`}`)
+//line app/vmselect/prometheus/error_response.qtpl:10
+}
+
+//line app/vmselect/prometheus/error_response.qtpl:10
+func WriteErrorResponse(qq422016 qtio422016.Writer, statusCode int, err error) {
+//line app/vmselect/prometheus/error_response.qtpl:10
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/error_response.qtpl:10
+	StreamErrorResponse(qw422016, statusCode, err)
+//line app/vmselect/prometheus/error_response.qtpl:10
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/error_response.qtpl:10
+}
+
+//line app/vmselect/prometheus/error_response.qtpl:10
+func ErrorResponse(statusCode int, err error) string {
+//line app/vmselect/prometheus/error_response.qtpl:10
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/error_response.qtpl:10
+	WriteErrorResponse(qb422016, statusCode, err)
+//line app/vmselect/prometheus/error_response.qtpl:10
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/error_response.qtpl:10
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/error_response.qtpl:10
+	return qs422016
+//line app/vmselect/prometheus/error_response.qtpl:10
+}

app/vmselect/prometheus/export.qtpl

@@ -0,0 +1,96 @@
+{% import (
+	"github.com/valyala/quicktemplate"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+) %}
+
+{% stripspace %}
+
+{% func ExportPrometheusLine(rs *netstorage.Result) %}
+	{% if len(rs.Timestamps) == 0 %}{% return %}{% endif %}
+	{% code bb := quicktemplate.AcquireByteBuffer() %}
+	{% code writeprometheusMetricName(bb, &rs.MetricName) %}
+	{% for i, ts := range rs.Timestamps %}
+		{%z= bb.B %}{% space %}
+		{%f= rs.Values[i] %}{% space %}
+		{%d= int(ts) %}{% newline %}
+	{% endfor %}
+	{% code quicktemplate.ReleaseByteBuffer(bb) %}
+{% endfunc %}
+
+{% func ExportJSONLine(rs *netstorage.Result) %}
+	{% if len(rs.Timestamps) == 0 %}{% return %}{% endif %}
+	{
+		"metric":{%= metricNameObject(&rs.MetricName) %},
+		"values":[
+			{% if len(rs.Values) > 0 %}
+				{% code values := rs.Values %}
+				{%f= values[0] %}
+				{% code values = values[1:] %}
+				{% for _, v := range values %}
+					,{%f= v %}
+				{% endfor %}
+			{% endif %}
+		],
+		"timestamps":[
+			{% if len(rs.Timestamps) > 0 %}
+				{% code timestamps := rs.Timestamps %}
+				{%d= int(timestamps[0]) %}
+				{% code timestamps = timestamps[1:] %}
+				{% for _, ts := range timestamps %}
+					,{%d= int(ts) %}
+				{% endfor %}
+			{% endif %}
+		]
+	}{% newline %}
+{% endfunc %}
+
+{% func ExportPromAPILine(rs *netstorage.Result) %}
+{
+	"metric": {%= metricNameObject(&rs.MetricName) %},
+	"values": {%= valuesWithTimestamps(rs.Values, rs.Timestamps) %}
+}
+{% endfunc %}
+
+{% func ExportPromAPIResponse(resultsCh <-chan *quicktemplate.ByteBuffer) %}
+{
+	"status":"success",
+	"data":{
+		"resultType":"matrix",
+		"result":[
+			{% code bb, ok := <-resultsCh %}
+			{% if ok %}
+				{%z= bb.B %}
+				{% code quicktemplate.ReleaseByteBuffer(bb) %}
+				{% for bb := range resultsCh %}
+					,{%z= bb.B %}
+					{% code quicktemplate.ReleaseByteBuffer(bb) %}
+				{% endfor %}
+			{% endif %}
+		]
+	}
+}
+{% endfunc %}
+
+{% func ExportStdResponse(resultsCh <-chan *quicktemplate.ByteBuffer) %}
+	{% for bb := range resultsCh %}
+		{%z= bb.B %}
+		{% code quicktemplate.ReleaseByteBuffer(bb) %}
+	{% endfor %}
+{% endfunc %}
+
+{% func prometheusMetricName(mn *storage.MetricName) %}
+	{%z= mn.MetricGroup %}
+	{% if len(mn.Tags) > 0 %}
+	{
+		{% code tags := mn.Tags %}
+		{%z= tags[0].Key %}={%qz= tags[0].Value %}
+		{% code tags = tags[1:] %}
+		{% for i := range tags %}
+			{% code tag := &tags[i] %}
+			,{%z= tag.Key %}={%qz= tag.Value %}
+		{% endfor %}
+	}
+	{% endif %}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/export.qtpl.go

@@ -0,0 +1,385 @@
+// Code generated by qtc from "export.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/export.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/export.qtpl:1
+import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/export.qtpl:9
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/export.qtpl:9
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/export.qtpl:9
+func StreamExportPrometheusLine(qw422016 *qt422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:10
+	if len(rs.Timestamps) == 0 {
+//line app/vmselect/prometheus/export.qtpl:10
+		return
+//line app/vmselect/prometheus/export.qtpl:10
+	}
+//line app/vmselect/prometheus/export.qtpl:11
+	bb := quicktemplate.AcquireByteBuffer()
+
+//line app/vmselect/prometheus/export.qtpl:12
+	writeprometheusMetricName(bb, &rs.MetricName)
+
+//line app/vmselect/prometheus/export.qtpl:13
+	for i, ts := range rs.Timestamps {
+//line app/vmselect/prometheus/export.qtpl:14
+		qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/export.qtpl:14
+		qw422016.N().S(` `)
+//line app/vmselect/prometheus/export.qtpl:15
+		qw422016.N().F(rs.Values[i])
+//line app/vmselect/prometheus/export.qtpl:15
+		qw422016.N().S(` `)
+//line app/vmselect/prometheus/export.qtpl:16
+		qw422016.N().D(int(ts))
+//line app/vmselect/prometheus/export.qtpl:16
+		qw422016.N().S(`
+`)
+//line app/vmselect/prometheus/export.qtpl:17
+	}
+//line app/vmselect/prometheus/export.qtpl:18
+	quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/export.qtpl:19
+}
+
+//line app/vmselect/prometheus/export.qtpl:19
+func WriteExportPrometheusLine(qq422016 qtio422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:19
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:19
+	StreamExportPrometheusLine(qw422016, rs)
+//line app/vmselect/prometheus/export.qtpl:19
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:19
+}
+
+//line app/vmselect/prometheus/export.qtpl:19
+func ExportPrometheusLine(rs *netstorage.Result) string {
+//line app/vmselect/prometheus/export.qtpl:19
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:19
+	WriteExportPrometheusLine(qb422016, rs)
+//line app/vmselect/prometheus/export.qtpl:19
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:19
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:19
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:19
+}
+
+//line app/vmselect/prometheus/export.qtpl:21
+func StreamExportJSONLine(qw422016 *qt422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:22
+	if len(rs.Timestamps) == 0 {
+//line app/vmselect/prometheus/export.qtpl:22
+		return
+//line app/vmselect/prometheus/export.qtpl:22
+	}
+//line app/vmselect/prometheus/export.qtpl:22
+	qw422016.N().S(`{"metric":`)
+//line app/vmselect/prometheus/export.qtpl:24
+	streammetricNameObject(qw422016, &rs.MetricName)
+//line app/vmselect/prometheus/export.qtpl:24
+	qw422016.N().S(`,"values":[`)
+//line app/vmselect/prometheus/export.qtpl:26
+	if len(rs.Values) > 0 {
+//line app/vmselect/prometheus/export.qtpl:27
+		values := rs.Values
+
+//line app/vmselect/prometheus/export.qtpl:28
+		qw422016.N().F(values[0])
+//line app/vmselect/prometheus/export.qtpl:29
+		values = values[1:]
+
+//line app/vmselect/prometheus/export.qtpl:30
+		for _, v := range values {
+//line app/vmselect/prometheus/export.qtpl:30
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/export.qtpl:31
+			qw422016.N().F(v)
+//line app/vmselect/prometheus/export.qtpl:32
+		}
+//line app/vmselect/prometheus/export.qtpl:33
+	}
+//line app/vmselect/prometheus/export.qtpl:33
+	qw422016.N().S(`],"timestamps":[`)
+//line app/vmselect/prometheus/export.qtpl:36
+	if len(rs.Timestamps) > 0 {
+//line app/vmselect/prometheus/export.qtpl:37
+		timestamps := rs.Timestamps
+
+//line app/vmselect/prometheus/export.qtpl:38
+		qw422016.N().D(int(timestamps[0]))
+//line app/vmselect/prometheus/export.qtpl:39
+		timestamps = timestamps[1:]
+
+//line app/vmselect/prometheus/export.qtpl:40
+		for _, ts := range timestamps {
+//line app/vmselect/prometheus/export.qtpl:40
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/export.qtpl:41
+			qw422016.N().D(int(ts))
+//line app/vmselect/prometheus/export.qtpl:42
+		}
+//line app/vmselect/prometheus/export.qtpl:43
+	}
+//line app/vmselect/prometheus/export.qtpl:43
+	qw422016.N().S(`]}`)
+//line app/vmselect/prometheus/export.qtpl:45
+	qw422016.N().S(`
+`)
+//line app/vmselect/prometheus/export.qtpl:46
+}
+
+//line app/vmselect/prometheus/export.qtpl:46
+func WriteExportJSONLine(qq422016 qtio422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:46
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:46
+	StreamExportJSONLine(qw422016, rs)
+//line app/vmselect/prometheus/export.qtpl:46
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:46
+}
+
+//line app/vmselect/prometheus/export.qtpl:46
+func ExportJSONLine(rs *netstorage.Result) string {
+//line app/vmselect/prometheus/export.qtpl:46
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:46
+	WriteExportJSONLine(qb422016, rs)
+//line app/vmselect/prometheus/export.qtpl:46
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:46
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:46
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:46
+}
+
+//line app/vmselect/prometheus/export.qtpl:48
+func StreamExportPromAPILine(qw422016 *qt422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:48
+	qw422016.N().S(`{"metric":`)
+//line app/vmselect/prometheus/export.qtpl:50
+	streammetricNameObject(qw422016, &rs.MetricName)
+//line app/vmselect/prometheus/export.qtpl:50
+	qw422016.N().S(`,"values":`)
+//line app/vmselect/prometheus/export.qtpl:51
+	streamvaluesWithTimestamps(qw422016, rs.Values, rs.Timestamps)
+//line app/vmselect/prometheus/export.qtpl:51
+	qw422016.N().S(`}`)
+//line app/vmselect/prometheus/export.qtpl:53
+}
+
+//line app/vmselect/prometheus/export.qtpl:53
+func WriteExportPromAPILine(qq422016 qtio422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/export.qtpl:53
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:53
+	StreamExportPromAPILine(qw422016, rs)
+//line app/vmselect/prometheus/export.qtpl:53
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:53
+}
+
+//line app/vmselect/prometheus/export.qtpl:53
+func ExportPromAPILine(rs *netstorage.Result) string {
+//line app/vmselect/prometheus/export.qtpl:53
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:53
+	WriteExportPromAPILine(qb422016, rs)
+//line app/vmselect/prometheus/export.qtpl:53
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:53
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:53
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:53
+}
+
+//line app/vmselect/prometheus/export.qtpl:55
+func StreamExportPromAPIResponse(qw422016 *qt422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/export.qtpl:55
+	qw422016.N().S(`{"status":"success","data":{"resultType":"matrix","result":[`)
+//line app/vmselect/prometheus/export.qtpl:61
+	bb, ok := <-resultsCh
+
+//line app/vmselect/prometheus/export.qtpl:62
+	if ok {
+//line app/vmselect/prometheus/export.qtpl:63
+		qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/export.qtpl:64
+		quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/export.qtpl:65
+		for bb := range resultsCh {
+//line app/vmselect/prometheus/export.qtpl:65
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/export.qtpl:66
+			qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/export.qtpl:67
+			quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/export.qtpl:68
+		}
+//line app/vmselect/prometheus/export.qtpl:69
+	}
+//line app/vmselect/prometheus/export.qtpl:69
+	qw422016.N().S(`]}}`)
+//line app/vmselect/prometheus/export.qtpl:73
+}
+
+//line app/vmselect/prometheus/export.qtpl:73
+func WriteExportPromAPIResponse(qq422016 qtio422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/export.qtpl:73
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:73
+	StreamExportPromAPIResponse(qw422016, resultsCh)
+//line app/vmselect/prometheus/export.qtpl:73
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:73
+}
+
+//line app/vmselect/prometheus/export.qtpl:73
+func ExportPromAPIResponse(resultsCh <-chan *quicktemplate.ByteBuffer) string {
+//line app/vmselect/prometheus/export.qtpl:73
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:73
+	WriteExportPromAPIResponse(qb422016, resultsCh)
+//line app/vmselect/prometheus/export.qtpl:73
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:73
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:73
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:73
+}
+
+//line app/vmselect/prometheus/export.qtpl:75
+func StreamExportStdResponse(qw422016 *qt422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/export.qtpl:76
+	for bb := range resultsCh {
+//line app/vmselect/prometheus/export.qtpl:77
+		qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/export.qtpl:78
+		quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/export.qtpl:79
+	}
+//line app/vmselect/prometheus/export.qtpl:80
+}
+
+//line app/vmselect/prometheus/export.qtpl:80
+func WriteExportStdResponse(qq422016 qtio422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/export.qtpl:80
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:80
+	StreamExportStdResponse(qw422016, resultsCh)
+//line app/vmselect/prometheus/export.qtpl:80
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:80
+}
+
+//line app/vmselect/prometheus/export.qtpl:80
+func ExportStdResponse(resultsCh <-chan *quicktemplate.ByteBuffer) string {
+//line app/vmselect/prometheus/export.qtpl:80
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:80
+	WriteExportStdResponse(qb422016, resultsCh)
+//line app/vmselect/prometheus/export.qtpl:80
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:80
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:80
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:80
+}
+
+//line app/vmselect/prometheus/export.qtpl:82
+func streamprometheusMetricName(qw422016 *qt422016.Writer, mn *storage.MetricName) {
+//line app/vmselect/prometheus/export.qtpl:83
+	qw422016.N().Z(mn.MetricGroup)
+//line app/vmselect/prometheus/export.qtpl:84
+	if len(mn.Tags) > 0 {
+//line app/vmselect/prometheus/export.qtpl:84
+		qw422016.N().S(`{`)
+//line app/vmselect/prometheus/export.qtpl:86
+		tags := mn.Tags
+
+//line app/vmselect/prometheus/export.qtpl:87
+		qw422016.N().Z(tags[0].Key)
+//line app/vmselect/prometheus/export.qtpl:87
+		qw422016.N().S(`=`)
+//line app/vmselect/prometheus/export.qtpl:87
+		qw422016.N().QZ(tags[0].Value)
+//line app/vmselect/prometheus/export.qtpl:88
+		tags = tags[1:]
+
+//line app/vmselect/prometheus/export.qtpl:89
+		for i := range tags {
+//line app/vmselect/prometheus/export.qtpl:90
+			tag := &tags[i]
+
+//line app/vmselect/prometheus/export.qtpl:90
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/export.qtpl:91
+			qw422016.N().Z(tag.Key)
+//line app/vmselect/prometheus/export.qtpl:91
+			qw422016.N().S(`=`)
+//line app/vmselect/prometheus/export.qtpl:91
+			qw422016.N().QZ(tag.Value)
+//line app/vmselect/prometheus/export.qtpl:92
+		}
+//line app/vmselect/prometheus/export.qtpl:92
+		qw422016.N().S(`}`)
+//line app/vmselect/prometheus/export.qtpl:94
+	}
+//line app/vmselect/prometheus/export.qtpl:95
+}
+
+//line app/vmselect/prometheus/export.qtpl:95
+func writeprometheusMetricName(qq422016 qtio422016.Writer, mn *storage.MetricName) {
+//line app/vmselect/prometheus/export.qtpl:95
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/export.qtpl:95
+	streamprometheusMetricName(qw422016, mn)
+//line app/vmselect/prometheus/export.qtpl:95
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/export.qtpl:95
+}
+
+//line app/vmselect/prometheus/export.qtpl:95
+func prometheusMetricName(mn *storage.MetricName) string {
+//line app/vmselect/prometheus/export.qtpl:95
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/export.qtpl:95
+	writeprometheusMetricName(qb422016, mn)
+//line app/vmselect/prometheus/export.qtpl:95
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/export.qtpl:95
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/export.qtpl:95
+	return qs422016
+//line app/vmselect/prometheus/export.qtpl:95
+}

app/vmselect/prometheus/federate.qtpl

@@ -0,0 +1,16 @@
+{% import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+) %}
+
+{% stripspace %}
+
+// Federate writes rs in /federate format.
+// See https://prometheus.io/docs/prometheus/latest/federation/
+{% func Federate(rs *netstorage.Result) %}
+	{% if len(rs.Timestamps) == 0 || len(rs.Values) == 0 %}{% return %}{% endif %}
+	{%= prometheusMetricName(&rs.MetricName) %}{% space %}
+	{%f= rs.Values[len(rs.Values)-1] %}{% space %}
+	{%d= int(rs.Timestamps[len(rs.Timestamps)-1]) %}{% newline %}
+{% endfunc %}
+
+{% endstripspace %}

app/vmselect/prometheus/federate.qtpl.go

@@ -0,0 +1,75 @@
+// Code generated by qtc from "federate.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/federate.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/federate.qtpl:1
+import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+)
+
+// Federate writes rs in /federate format.// See https://prometheus.io/docs/prometheus/latest/federation/
+
+//line app/vmselect/prometheus/federate.qtpl:9
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/federate.qtpl:9
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/federate.qtpl:9
+func StreamFederate(qw422016 *qt422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/federate.qtpl:10
+	if len(rs.Timestamps) == 0 || len(rs.Values) == 0 {
+//line app/vmselect/prometheus/federate.qtpl:10
+		return
+//line app/vmselect/prometheus/federate.qtpl:10
+	}
+//line app/vmselect/prometheus/federate.qtpl:11
+	streamprometheusMetricName(qw422016, &rs.MetricName)
+//line app/vmselect/prometheus/federate.qtpl:11
+	qw422016.N().S(` `)
+//line app/vmselect/prometheus/federate.qtpl:12
+	qw422016.N().F(rs.Values[len(rs.Values)-1])
+//line app/vmselect/prometheus/federate.qtpl:12
+	qw422016.N().S(` `)
+//line app/vmselect/prometheus/federate.qtpl:13
+	qw422016.N().D(int(rs.Timestamps[len(rs.Timestamps)-1]))
+//line app/vmselect/prometheus/federate.qtpl:13
+	qw422016.N().S(`
+`)
+//line app/vmselect/prometheus/federate.qtpl:14
+}
+
+//line app/vmselect/prometheus/federate.qtpl:14
+func WriteFederate(qq422016 qtio422016.Writer, rs *netstorage.Result) {
+//line app/vmselect/prometheus/federate.qtpl:14
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/federate.qtpl:14
+	StreamFederate(qw422016, rs)
+//line app/vmselect/prometheus/federate.qtpl:14
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/federate.qtpl:14
+}
+
+//line app/vmselect/prometheus/federate.qtpl:14
+func Federate(rs *netstorage.Result) string {
+//line app/vmselect/prometheus/federate.qtpl:14
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/federate.qtpl:14
+	WriteFederate(qb422016, rs)
+//line app/vmselect/prometheus/federate.qtpl:14
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/federate.qtpl:14
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/federate.qtpl:14
+	return qs422016
+//line app/vmselect/prometheus/federate.qtpl:14
+}

app/vmselect/prometheus/label_values_response.qtpl

@@ -0,0 +1,15 @@
+{% stripspace %}
+LabelValuesResponse generates response for /api/v1/label/<labelName>/values .
+See https://prometheus.io/docs/prometheus/latest/querying/api/#querying-label-values
+{% func LabelValuesResponse(labelValues []string) %}
+{
+	"status":"success",
+	"data":[
+		{% for i, labelValue := range labelValues %}
+			{%q= labelValue %}
+			{% if i+1 < len(labelValues) %},{% endif %}
+		{% endfor %}
+	]
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/label_values_response.qtpl.go

@@ -0,0 +1,67 @@
+// Code generated by qtc from "label_values_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+// LabelValuesResponse generates response for /api/v1/label/<labelName>/values .See https://prometheus.io/docs/prometheus/latest/querying/api/#querying-label-values
+
+//line app/vmselect/prometheus/label_values_response.qtpl:4
+package prometheus
+
+//line app/vmselect/prometheus/label_values_response.qtpl:4
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/label_values_response.qtpl:4
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/label_values_response.qtpl:4
+func StreamLabelValuesResponse(qw422016 *qt422016.Writer, labelValues []string) {
+//line app/vmselect/prometheus/label_values_response.qtpl:4
+	qw422016.N().S(`{"status":"success","data":[`)
+//line app/vmselect/prometheus/label_values_response.qtpl:8
+	for i, labelValue := range labelValues {
+//line app/vmselect/prometheus/label_values_response.qtpl:9
+		qw422016.N().Q(labelValue)
+//line app/vmselect/prometheus/label_values_response.qtpl:10
+		if i+1 < len(labelValues) {
+//line app/vmselect/prometheus/label_values_response.qtpl:10
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/label_values_response.qtpl:10
+		}
+//line app/vmselect/prometheus/label_values_response.qtpl:11
+	}
+//line app/vmselect/prometheus/label_values_response.qtpl:11
+	qw422016.N().S(`]}`)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+}
+
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+func WriteLabelValuesResponse(qq422016 qtio422016.Writer, labelValues []string) {
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	StreamLabelValuesResponse(qw422016, labelValues)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+}
+
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+func LabelValuesResponse(labelValues []string) string {
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	WriteLabelValuesResponse(qb422016, labelValues)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+	return qs422016
+//line app/vmselect/prometheus/label_values_response.qtpl:14
+}

app/vmselect/prometheus/labels_count_response.qtpl

@@ -0,0 +1,17 @@
+{% import "github.com/VictoriaMetrics/VictoriaMetrics/lib/storage" %}
+
+{% stripspace %}
+LabelsCountResponse generates response for /api/v1/label_entries .
+{% func LabelsCountResponse(labelEntries []storage.TagEntry) %}
+{
+	"status":"success",
+	"data":{
+		{% for i, e := range labelEntries %}
+			{%q= e.Key %}:{%d= len(e.Values) %}
+			{% if i+1 < len(labelEntries) %},{% endif %}
+		{% endfor %}
+	}
+}
+{% endfunc %}
+
+{% endstripspace %}

app/vmselect/prometheus/labels_count_response.qtpl.go

@@ -0,0 +1,74 @@
+// Code generated by qtc from "labels_count_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:1
+import "github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+
+// LabelsCountResponse generates response for /api/v1/label_entries .
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:5
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:5
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:5
+func StreamLabelsCountResponse(qw422016 *qt422016.Writer, labelEntries []storage.TagEntry) {
+//line app/vmselect/prometheus/labels_count_response.qtpl:5
+	qw422016.N().S(`{"status":"success","data":{`)
+//line app/vmselect/prometheus/labels_count_response.qtpl:9
+	for i, e := range labelEntries {
+//line app/vmselect/prometheus/labels_count_response.qtpl:10
+		qw422016.N().Q(e.Key)
+//line app/vmselect/prometheus/labels_count_response.qtpl:10
+		qw422016.N().S(`:`)
+//line app/vmselect/prometheus/labels_count_response.qtpl:10
+		qw422016.N().D(len(e.Values))
+//line app/vmselect/prometheus/labels_count_response.qtpl:11
+		if i+1 < len(labelEntries) {
+//line app/vmselect/prometheus/labels_count_response.qtpl:11
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/labels_count_response.qtpl:11
+		}
+//line app/vmselect/prometheus/labels_count_response.qtpl:12
+	}
+//line app/vmselect/prometheus/labels_count_response.qtpl:12
+	qw422016.N().S(`}}`)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+}
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+func WriteLabelsCountResponse(qq422016 qtio422016.Writer, labelEntries []storage.TagEntry) {
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	StreamLabelsCountResponse(qw422016, labelEntries)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+}
+
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+func LabelsCountResponse(labelEntries []storage.TagEntry) string {
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	WriteLabelsCountResponse(qb422016, labelEntries)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+	return qs422016
+//line app/vmselect/prometheus/labels_count_response.qtpl:15
+}

app/vmselect/prometheus/labels_response.qtpl

@@ -0,0 +1,15 @@
+{% stripspace %}
+LabelsResponse generates response for /api/v1/labels .
+See https://prometheus.io/docs/prometheus/latest/querying/api/#getting-label-names
+{% func LabelsResponse(labels []string) %}
+{
+	"status":"success",
+	"data":[
+		{% for i, label := range labels %}
+			{%q= label %}
+			{% if i+1 < len(labels) %},{% endif %}
+		{% endfor %}
+	]
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/labels_response.qtpl.go

@@ -0,0 +1,67 @@
+// Code generated by qtc from "labels_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+// LabelsResponse generates response for /api/v1/labels .See https://prometheus.io/docs/prometheus/latest/querying/api/#getting-label-names
+
+//line app/vmselect/prometheus/labels_response.qtpl:4
+package prometheus
+
+//line app/vmselect/prometheus/labels_response.qtpl:4
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/labels_response.qtpl:4
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/labels_response.qtpl:4
+func StreamLabelsResponse(qw422016 *qt422016.Writer, labels []string) {
+//line app/vmselect/prometheus/labels_response.qtpl:4
+	qw422016.N().S(`{"status":"success","data":[`)
+//line app/vmselect/prometheus/labels_response.qtpl:8
+	for i, label := range labels {
+//line app/vmselect/prometheus/labels_response.qtpl:9
+		qw422016.N().Q(label)
+//line app/vmselect/prometheus/labels_response.qtpl:10
+		if i+1 < len(labels) {
+//line app/vmselect/prometheus/labels_response.qtpl:10
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/labels_response.qtpl:10
+		}
+//line app/vmselect/prometheus/labels_response.qtpl:11
+	}
+//line app/vmselect/prometheus/labels_response.qtpl:11
+	qw422016.N().S(`]}`)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+}
+
+//line app/vmselect/prometheus/labels_response.qtpl:14
+func WriteLabelsResponse(qq422016 qtio422016.Writer, labels []string) {
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	StreamLabelsResponse(qw422016, labels)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+}
+
+//line app/vmselect/prometheus/labels_response.qtpl:14
+func LabelsResponse(labels []string) string {
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	WriteLabelsResponse(qb422016, labels)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/labels_response.qtpl:14
+	return qs422016
+//line app/vmselect/prometheus/labels_response.qtpl:14
+}

app/vmselect/prometheus/prometheus.go

@@ -0,0 +1,853 @@
+package prometheus
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"net/http"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/promql"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/flagutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/quicktemplate"
+)
+
+var (
+	maxQueryDuration    = flag.Duration("search.maxQueryDuration", time.Second*30, "The maximum time for search query execution")
+	maxQueryLen         = flag.Int("search.maxQueryLen", 16*1024, "The maximum search query length in bytes")
+	denyPartialResponse = flag.Bool("search.denyPartialResponse", false, "Whether to deny partial responses when some of vmstorage nodes are unavailable. This trades consistency over availability")
+	selectNodes         = flagutil.NewArray("selectNode", "Addresses of vmselect nodes; usage: -selectNode=vmselect-host1:8481 -selectNode=vmselect-host2:8481")
+)
+
+// Default step used if not set.
+const defaultStep = 5 * 60 * 1000
+
+// Latency for data processing pipeline, i.e. the time between data is ignested
+// into the system and the time it becomes visible to search.
+const latencyOffset = 60 * 1000
+
+// FederateHandler implements /federate . See https://prometheus.io/docs/prometheus/latest/federation/
+func FederateHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	ct := currentTime()
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse request form values: %s", err)
+	}
+	matches := r.Form["match[]"]
+	if len(matches) == 0 {
+		return fmt.Errorf("missing `match[]` arg")
+	}
+	maxLookback, err := getDuration(r, "max_lookback", defaultStep)
+	if err != nil {
+		return err
+	}
+	start, err := getTime(r, "start", ct-maxLookback)
+	if err != nil {
+		return err
+	}
+	end, err := getTime(r, "end", ct)
+	if err != nil {
+		return err
+	}
+	deadline := getDeadline(r)
+	if start >= end {
+		start = end - defaultStep
+	}
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	sq := &storage.SearchQuery{
+		AccountID:    at.AccountID,
+		ProjectID:    at.ProjectID,
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, isPartial, err := netstorage.ProcessSearchQuery(at, sq, true, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	resultsCh := make(chan *quicktemplate.ByteBuffer)
+	doneCh := make(chan error)
+	go func() {
+		err := rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+			bb := quicktemplate.AcquireByteBuffer()
+			WriteFederate(bb, rs)
+			resultsCh <- bb
+		})
+		close(resultsCh)
+		doneCh <- err
+	}()
+
+	w.Header().Set("Content-Type", "text/plain")
+	for bb := range resultsCh {
+		w.Write(bb.B)
+		quicktemplate.ReleaseByteBuffer(bb)
+	}
+
+	err = <-doneCh
+	if err != nil {
+		return fmt.Errorf("error during data fetching: %s", err)
+	}
+	federateDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var federateDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/federate"}`)
+
+// ExportHandler exports data in raw format from /api/v1/export.
+func ExportHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	ct := currentTime()
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse request form values: %s", err)
+	}
+	matches := r.Form["match[]"]
+	if len(matches) == 0 {
+		// Maintain backwards compatibility
+		match := r.FormValue("match")
+		if len(match) == 0 {
+			return fmt.Errorf("missing `match[]` arg")
+		}
+		matches = []string{match}
+	}
+	start, err := getTime(r, "start", 0)
+	if err != nil {
+		return err
+	}
+	end, err := getTime(r, "end", ct)
+	if err != nil {
+		return err
+	}
+	format := r.FormValue("format")
+	deadline := getDeadline(r)
+	if start >= end {
+		start = end - defaultStep
+	}
+	if err := exportHandler(at, w, matches, start, end, format, deadline); err != nil {
+		return err
+	}
+	exportDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var exportDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/export"}`)
+
+func exportHandler(at *auth.Token, w http.ResponseWriter, matches []string, start, end int64, format string, deadline netstorage.Deadline) error {
+	writeResponseFunc := WriteExportStdResponse
+	writeLineFunc := WriteExportJSONLine
+	contentType := "application/json"
+	if format == "prometheus" {
+		contentType = "text/plain"
+		writeLineFunc = WriteExportPrometheusLine
+	} else if format == "promapi" {
+		writeResponseFunc = WriteExportPromAPIResponse
+		writeLineFunc = WriteExportPromAPILine
+	}
+
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	sq := &storage.SearchQuery{
+		AccountID:    at.AccountID,
+		ProjectID:    at.ProjectID,
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, isPartial, err := netstorage.ProcessSearchQuery(at, sq, true, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+	if isPartial {
+		rss.Cancel()
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	resultsCh := make(chan *quicktemplate.ByteBuffer, runtime.GOMAXPROCS(-1))
+	doneCh := make(chan error)
+	go func() {
+		err := rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+			bb := quicktemplate.AcquireByteBuffer()
+			writeLineFunc(bb, rs)
+			resultsCh <- bb
+		})
+		close(resultsCh)
+		doneCh <- err
+	}()
+
+	w.Header().Set("Content-Type", contentType)
+	writeResponseFunc(w, resultsCh)
+
+	// Consume all the data from resultsCh in the event writeResponseFunc
+	// fails to consume all the data.
+	for bb := range resultsCh {
+		quicktemplate.ReleaseByteBuffer(bb)
+	}
+	err = <-doneCh
+	if err != nil {
+		return fmt.Errorf("error during data fetching: %s", err)
+	}
+	return nil
+}
+
+// DeleteHandler processes /api/v1/admin/tsdb/delete_series prometheus API request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#delete-series
+func DeleteHandler(at *auth.Token, r *http.Request) error {
+	startTime := time.Now()
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse request form values: %s", err)
+	}
+	if r.FormValue("start") != "" || r.FormValue("end") != "" {
+		return fmt.Errorf("start and end aren't supported. Remove these args from the query in order to delete all the matching metrics")
+	}
+	matches := r.Form["match[]"]
+	if len(matches) == 0 {
+		return fmt.Errorf("missing `match[]` arg")
+	}
+	deadline := getDeadline(r)
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	sq := &storage.SearchQuery{
+		AccountID:   at.AccountID,
+		ProjectID:   at.ProjectID,
+		TagFilterss: tagFilterss,
+	}
+	deletedCount, err := netstorage.DeleteSeries(at, sq, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot delete time series matching %q: %s", matches, err)
+	}
+	if deletedCount > 0 {
+		// Reset rollup result cache on all the vmselect nodes,
+		// since the cache may contain deleted data.
+		// TODO: reset only cache for (account, project)
+		resetRollupResultCaches()
+	}
+	deleteDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var deleteDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/admin/tsdb/delete_series"}`)
+
+func resetRollupResultCaches() {
+	if len(*selectNodes) == 0 {
+		logger.Panicf("BUG: missing -selectNode flag")
+	}
+	for _, selectNode := range *selectNodes {
+		callURL := fmt.Sprintf("http://%s/internal/resetRollupResultCache", selectNode)
+		resp, err := httpClient.Get(callURL)
+		if err != nil {
+			logger.Errorf("error when accessing %q: %s", callURL, err)
+			resetRollupResultCacheErrors.Inc()
+			continue
+		}
+		if resp.StatusCode != http.StatusOK {
+			_ = resp.Body.Close()
+			logger.Errorf("unexpected status code at %q; got %d; want %d", callURL, resp.StatusCode, http.StatusOK)
+			resetRollupResultCacheErrors.Inc()
+			continue
+		}
+		_ = resp.Body.Close()
+	}
+	resetRollupResultCacheCalls.Inc()
+}
+
+var (
+	resetRollupResultCacheErrors = metrics.NewCounter("vm_reset_rollup_result_cache_errors_total")
+	resetRollupResultCacheCalls  = metrics.NewCounter("vm_reset_rollup_result_cache_calls_total")
+)
+
+var httpClient = &http.Client{
+	Timeout: time.Second * 5,
+}
+
+// LabelValuesHandler processes /api/v1/label/<labelName>/values request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#querying-label-values
+func LabelValuesHandler(at *auth.Token, labelName string, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse form values: %s", err)
+	}
+	var labelValues []string
+	var isPartial bool
+	if len(r.Form["match[]"]) == 0 && len(r.Form["start"]) == 0 && len(r.Form["end"]) == 0 {
+		var err error
+		labelValues, isPartial, err = netstorage.GetLabelValues(at, labelName, deadline)
+		if err != nil {
+			return fmt.Errorf(`cannot obtain label values for %q: %s`, labelName, err)
+		}
+	} else {
+		// Extended functionality that allows filtering by label filters and time range
+		// i.e. /api/v1/label/foo/values?match[]=foobar{baz="abc"}&start=...&end=...
+		// is equivalent to `label_values(foobar{baz="abc"}, foo)` call on the selected
+		// time range in Grafana templating.
+		matches := r.Form["match[]"]
+		if len(matches) == 0 {
+			matches = []string{fmt.Sprintf("{%s!=''}", labelName)}
+		}
+		ct := currentTime()
+		end, err := getTime(r, "end", ct)
+		if err != nil {
+			return err
+		}
+		start, err := getTime(r, "start", end-defaultStep)
+		if err != nil {
+			return err
+		}
+		labelValues, isPartial, err = labelValuesWithMatches(at, labelName, matches, start, end, deadline)
+		if err != nil {
+			return fmt.Errorf("cannot obtain label values for %q, match[]=%q, start=%d, end=%d: %s", labelName, matches, start, end, err)
+		}
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteLabelValuesResponse(w, labelValues)
+	labelValuesDuration.UpdateDuration(startTime)
+	return nil
+}
+
+func labelValuesWithMatches(at *auth.Token, labelName string, matches []string, start, end int64, deadline netstorage.Deadline) ([]string, bool, error) {
+	if len(matches) == 0 {
+		logger.Panicf("BUG: matches must be non-empty")
+	}
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return nil, false, err
+	}
+	if start >= end {
+		start = end - defaultStep
+	}
+	sq := &storage.SearchQuery{
+		AccountID:    at.AccountID,
+		ProjectID:    at.ProjectID,
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, isPartial, err := netstorage.ProcessSearchQuery(at, sq, false, deadline)
+	if err != nil {
+		return nil, false, fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+
+	m := make(map[string]struct{})
+	var mLock sync.Mutex
+	err = rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+		labelValue := rs.MetricName.GetTagValue(labelName)
+		if len(labelValue) == 0 {
+			return
+		}
+		mLock.Lock()
+		m[string(labelValue)] = struct{}{}
+		mLock.Unlock()
+	})
+	if err != nil {
+		return nil, false, fmt.Errorf("error when data fetching: %s", err)
+	}
+
+	labelValues := make([]string, 0, len(m))
+	for labelValue := range m {
+		labelValues = append(labelValues, labelValue)
+	}
+	sort.Strings(labelValues)
+	return labelValues, isPartial, nil
+}
+
+var labelValuesDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/label/{}/values"}`)
+
+// LabelsCountHandler processes /api/v1/labels/count request.
+func LabelsCountHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	labelEntries, isPartial, err := netstorage.GetLabelEntries(at, deadline)
+	if err != nil {
+		return fmt.Errorf(`cannot obtain label entries: %s`, err)
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteLabelsCountResponse(w, labelEntries)
+	labelsCountDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var labelsCountDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/labels/count"}`)
+
+// LabelsHandler processes /api/v1/labels request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#getting-label-names
+func LabelsHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	labels, isPartial, err := netstorage.GetLabels(at, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot obtain labels: %s", err)
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteLabelsResponse(w, labels)
+	labelsDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var labelsDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/labels"}`)
+
+// SeriesCountHandler processes /api/v1/series/count request.
+func SeriesCountHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	n, isPartial, err := netstorage.GetSeriesCount(at, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot obtain series count: %s", err)
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteSeriesCountResponse(w, n)
+	seriesCountDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var seriesCountDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/series/count"}`)
+
+// SeriesHandler processes /api/v1/series request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#finding-series-by-label-matchers
+func SeriesHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	ct := currentTime()
+
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse form values: %s", err)
+	}
+	matches := r.Form["match[]"]
+	if len(matches) == 0 {
+		return fmt.Errorf("missing `match[]` arg")
+	}
+	end, err := getTime(r, "end", ct)
+	if err != nil {
+		return err
+	}
+	// Do not set start to minTimeMsecs by default as Prometheus does,
+	// since this leads to fetching and scanning all the data from the storage,
+	// which can take a lot of time for big storages.
+	// It is better setting start as end-defaultStep by default.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/91
+	start, err := getTime(r, "start", end-defaultStep)
+	if err != nil {
+		return err
+	}
+	deadline := getDeadline(r)
+
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	if start >= end {
+		start = end - defaultStep
+	}
+	sq := &storage.SearchQuery{
+		AccountID:    at.AccountID,
+		ProjectID:    at.ProjectID,
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, isPartial, err := netstorage.ProcessSearchQuery(at, sq, false, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+	if isPartial && getDenyPartialResponse(r) {
+		return fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+
+	resultsCh := make(chan *quicktemplate.ByteBuffer)
+	doneCh := make(chan error)
+	go func() {
+		err := rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+			bb := quicktemplate.AcquireByteBuffer()
+			writemetricNameObject(bb, &rs.MetricName)
+			resultsCh <- bb
+		})
+		close(resultsCh)
+		doneCh <- err
+	}()
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteSeriesResponse(w, resultsCh)
+
+	// Consume all the data from resultsCh in the event WriteSeriesResponse
+	// fails to consume all the data.
+	for bb := range resultsCh {
+		quicktemplate.ReleaseByteBuffer(bb)
+	}
+	err = <-doneCh
+	if err != nil {
+		return fmt.Errorf("error during data fetching: %s", err)
+	}
+	seriesDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var seriesDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/series"}`)
+
+// QueryHandler processes /api/v1/query request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#instant-queries
+func QueryHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	ct := currentTime()
+
+	query := r.FormValue("query")
+	if len(query) == 0 {
+		return fmt.Errorf("missing `query` arg")
+	}
+	start, err := getTime(r, "time", ct)
+	if err != nil {
+		return err
+	}
+	step, err := getDuration(r, "step", latencyOffset)
+	if err != nil {
+		return err
+	}
+	deadline := getDeadline(r)
+
+	if len(query) > *maxQueryLen {
+		return fmt.Errorf(`too long query; got %d bytes; mustn't exceed %d bytes`, len(query), *maxQueryLen)
+	}
+	if ct-start < latencyOffset {
+		start -= latencyOffset
+	}
+	if childQuery, windowStr, offsetStr := promql.IsMetricSelectorWithRollup(query); childQuery != "" {
+		var window int64
+		if len(windowStr) > 0 {
+			var err error
+			window, err = promql.DurationValue(windowStr, step)
+			if err != nil {
+				return err
+			}
+		}
+		var offset int64
+		if len(offsetStr) > 0 {
+			var err error
+			offset, err = promql.DurationValue(offsetStr, step)
+			if err != nil {
+				return err
+			}
+		}
+		start -= offset
+		end := start
+		start = end - window
+		if err := exportHandler(at, w, []string{childQuery}, start, end, "promapi", deadline); err != nil {
+			return err
+		}
+		queryDuration.UpdateDuration(startTime)
+		return nil
+	}
+
+	ec := promql.EvalConfig{
+		AuthToken: at,
+		Start:     start,
+		End:       start,
+		Step:      step,
+		Deadline:  deadline,
+
+		DenyPartialResponse: getDenyPartialResponse(r),
+	}
+	result, err := promql.Exec(&ec, query, true)
+	if err != nil {
+		return fmt.Errorf("cannot execute %q: %s", query, err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteQueryResponse(w, result)
+	queryDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var queryDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/query"}`)
+
+// QueryRangeHandler processes /api/v1/query_range request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#range-queries
+func QueryRangeHandler(at *auth.Token, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	ct := currentTime()
+
+	query := r.FormValue("query")
+	if len(query) == 0 {
+		return fmt.Errorf("missing `query` arg")
+	}
+	start, err := getTime(r, "start", ct-defaultStep)
+	if err != nil {
+		return err
+	}
+	end, err := getTime(r, "end", ct)
+	if err != nil {
+		return err
+	}
+	step, err := getDuration(r, "step", defaultStep)
+	if err != nil {
+		return err
+	}
+	deadline := getDeadline(r)
+	mayCache := !getBool(r, "nocache")
+
+	// Validate input args.
+	if len(query) > *maxQueryLen {
+		return fmt.Errorf(`too long query; got %d bytes; mustn't exceed %d bytes`, len(query), *maxQueryLen)
+	}
+	if start > end {
+		start = end
+	}
+	if err := promql.ValidateMaxPointsPerTimeseries(start, end, step); err != nil {
+		return err
+	}
+	if mayCache {
+		start, end = promql.AdjustStartEnd(start, end, step)
+	}
+
+	ec := promql.EvalConfig{
+		AuthToken: at,
+		Start:     start,
+		End:       end,
+		Step:      step,
+		Deadline:  deadline,
+		MayCache:  mayCache,
+
+		DenyPartialResponse: getDenyPartialResponse(r),
+	}
+	result, err := promql.Exec(&ec, query, false)
+	if err != nil {
+		return fmt.Errorf("cannot execute %q: %s", query, err)
+	}
+	if ct-end < latencyOffset {
+		result = adjustLastPoints(result)
+	}
+
+	// Remove NaN values as Prometheus does.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/153
+	removeNaNValuesInplace(result)
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteQueryRangeResponse(w, result)
+	queryRangeDuration.UpdateDuration(startTime)
+	return nil
+}
+
+func removeNaNValuesInplace(tss []netstorage.Result) {
+	for i := range tss {
+		ts := &tss[i]
+		hasNaNs := false
+		for _, v := range ts.Values {
+			if math.IsNaN(v) {
+				hasNaNs = true
+				break
+			}
+		}
+		if !hasNaNs {
+			// Fast path: nothing to remove.
+			continue
+		}
+
+		// Slow path: remove NaNs.
+		srcTimestamps := ts.Timestamps
+		dstValues := ts.Values[:0]
+		dstTimestamps := ts.Timestamps[:0]
+		for j, v := range ts.Values {
+			if math.IsNaN(v) {
+				continue
+			}
+			dstValues = append(dstValues, v)
+			dstTimestamps = append(dstTimestamps, srcTimestamps[j])
+		}
+		ts.Values = dstValues
+		ts.Timestamps = dstTimestamps
+	}
+}
+
+var queryRangeDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/query_range"}`)
+
+// adjustLastPoints substitutes the last point values with the previous
+// point values, since the last points may contain garbage.
+func adjustLastPoints(tss []netstorage.Result) []netstorage.Result {
+	if len(tss) == 0 {
+		return nil
+	}
+
+	// Search for the last non-NaN value across all the timeseries.
+	lastNonNaNIdx := -1
+	for i := range tss {
+		values := tss[i].Values
+		j := len(values) - 1
+		for j >= 0 && math.IsNaN(values[j]) {
+			j--
+		}
+		if j > lastNonNaNIdx {
+			lastNonNaNIdx = j
+		}
+	}
+	if lastNonNaNIdx == -1 {
+		// All timeseries contain only NaNs.
+		return nil
+	}
+
+	// Substitute the last two values starting from lastNonNaNIdx
+	// with the previous values for each timeseries.
+	for i := range tss {
+		values := tss[i].Values
+		for j := 0; j < 2; j++ {
+			idx := lastNonNaNIdx + j
+			if idx <= 0 || idx >= len(values) || math.IsNaN(values[idx-1]) {
+				continue
+			}
+			values[idx] = values[idx-1]
+		}
+	}
+	return tss
+}
+
+func getTime(r *http.Request, argKey string, defaultValue int64) (int64, error) {
+	argValue := r.FormValue(argKey)
+	if len(argValue) == 0 {
+		return defaultValue, nil
+	}
+	secs, err := strconv.ParseFloat(argValue, 64)
+	if err != nil {
+		// Try parsing string format
+		t, err := time.Parse(time.RFC3339, argValue)
+		if err != nil {
+			// Handle Prometheus'-provided minTime and maxTime.
+			// See https://github.com/prometheus/client_golang/issues/614
+			switch argValue {
+			case prometheusMinTimeFormatted:
+				return minTimeMsecs, nil
+			case prometheusMaxTimeFormatted:
+				return maxTimeMsecs, nil
+			}
+			return 0, fmt.Errorf("cannot parse %q=%q: %s", argKey, argValue, err)
+		}
+		secs = float64(t.UnixNano()) / 1e9
+	}
+	msecs := int64(secs * 1e3)
+	if msecs < minTimeMsecs {
+		msecs = 0
+	}
+	if msecs > maxTimeMsecs {
+		msecs = maxTimeMsecs
+	}
+	return msecs, nil
+}
+
+var (
+	// These constants were obtained from https://github.com/prometheus/prometheus/blob/91d7175eaac18b00e370965f3a8186cc40bf9f55/web/api/v1/api.go#L442
+	// See https://github.com/prometheus/client_golang/issues/614 for details.
+	prometheusMinTimeFormatted = time.Unix(math.MinInt64/1000+62135596801, 0).UTC().Format(time.RFC3339Nano)
+	prometheusMaxTimeFormatted = time.Unix(math.MaxInt64/1000-62135596801, 999999999).UTC().Format(time.RFC3339Nano)
+)
+
+const (
+	// These values prevent from overflow when storing msec-precision time in int64.
+	minTimeMsecs = 0 // use 0 instead of `int64(-1<<63) / 1e6` because the storage engine doesn't actually support negative time
+	maxTimeMsecs = int64(1<<63-1) / 1e6
+)
+
+func getDuration(r *http.Request, argKey string, defaultValue int64) (int64, error) {
+	argValue := r.FormValue(argKey)
+	if len(argValue) == 0 {
+		return defaultValue, nil
+	}
+	secs, err := strconv.ParseFloat(argValue, 64)
+	if err != nil {
+		// Try parsing string format
+		d, err := time.ParseDuration(argValue)
+		if err != nil {
+			return 0, fmt.Errorf("cannot parse %q=%q: %s", argKey, argValue, err)
+		}
+		secs = d.Seconds()
+	}
+	msecs := int64(secs * 1e3)
+	if msecs <= 0 || msecs > maxDurationMsecs {
+		return 0, fmt.Errorf("%q=%dms is out of allowed range [%d ... %d]", argKey, msecs, 0, int64(maxDurationMsecs))
+	}
+	return msecs, nil
+}
+
+const maxDurationMsecs = 100 * 365 * 24 * 3600 * 1000
+
+func getDeadline(r *http.Request) netstorage.Deadline {
+	d, err := getDuration(r, "timeout", 0)
+	if err != nil {
+		d = 0
+	}
+	dMax := int64(maxQueryDuration.Seconds() * 1e3)
+	if d <= 0 || d > dMax {
+		d = dMax
+	}
+	timeout := time.Duration(d) * time.Millisecond
+	return netstorage.NewDeadline(timeout)
+}
+
+func getBool(r *http.Request, argKey string) bool {
+	argValue := r.FormValue(argKey)
+	switch strings.ToLower(argValue) {
+	case "", "0", "f", "false", "no":
+		return false
+	default:
+		return true
+	}
+}
+
+func currentTime() int64 {
+	return int64(time.Now().UTC().Unix()) * 1e3
+}
+
+func getTagFilterssFromMatches(matches []string) ([][]storage.TagFilter, error) {
+	tagFilterss := make([][]storage.TagFilter, 0, len(matches))
+	for _, match := range matches {
+		tagFilters, err := promql.ParseMetricSelector(match)
+		if err != nil {
+			return nil, fmt.Errorf("cannot parse %q: %s", match, err)
+		}
+		tagFilterss = append(tagFilterss, tagFilters)
+	}
+	return tagFilterss, nil
+}
+
+func getDenyPartialResponse(r *http.Request) bool {
+	if *denyPartialResponse {
+		return true
+	}
+	return getBool(r, "deny_partial_response")
+}

app/vmselect/prometheus/prometheus_test.go

@@ -0,0 +1,115 @@
+package prometheus
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"net/url"
+	"reflect"
+	"testing"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+)
+
+func TestRemoveNaNValuesInplace(t *testing.T) {
+	f := func(tss []netstorage.Result, tssExpected []netstorage.Result) {
+		t.Helper()
+		removeNaNValuesInplace(tss)
+		if !reflect.DeepEqual(tss, tssExpected) {
+			t.Fatalf("unexpected result; got %v; want %v", tss, tssExpected)
+		}
+	}
+
+	nan := math.NaN()
+
+	f(nil, nil)
+	f([]netstorage.Result{
+		{
+			Timestamps: []int64{100, 200, 300},
+			Values:     []float64{1, 2, 3},
+		},
+		{
+			Timestamps: []int64{100, 200, 300, 400},
+			Values:     []float64{nan, nan, 3, nan},
+		},
+	}, []netstorage.Result{
+		{
+			Timestamps: []int64{100, 200, 300},
+			Values:     []float64{1, 2, 3},
+		},
+		{
+			Timestamps: []int64{300},
+			Values:     []float64{3},
+		},
+	})
+}
+
+func TestGetTimeSuccess(t *testing.T) {
+	f := func(s string, timestampExpected int64) {
+		t.Helper()
+		urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
+		r, err := http.NewRequest("GET", urlStr, nil)
+		if err != nil {
+			t.Fatalf("unexpected error in NewRequest: %s", err)
+		}
+
+		// Verify defaultValue
+		ts, err := getTime(r, "foo", 123)
+		if err != nil {
+			t.Fatalf("unexpected error when obtaining default time from getTime(%q): %s", s, err)
+		}
+		if ts != 123 {
+			t.Fatalf("unexpected default value for getTime(%q); got %d; want %d", s, ts, 123)
+		}
+
+		// Verify timestampExpected
+		ts, err = getTime(r, "s", 123)
+		if err != nil {
+			t.Fatalf("unexpected error in getTime(%q): %s", s, err)
+		}
+		if ts != timestampExpected {
+			t.Fatalf("unexpected timestamp for getTime(%q); got %d; want %d", s, ts, timestampExpected)
+		}
+	}
+
+	f("2019-07-07T20:01:02Z", 1562529662000)
+	f("2019-07-07T20:47:40+03:00", 1562521660000)
+	f("-292273086-05-16T16:47:06Z", minTimeMsecs)
+	f("292277025-08-18T07:12:54.999999999Z", maxTimeMsecs)
+	f("1562529662.324", 1562529662324)
+	f("-9223372036.854", minTimeMsecs)
+	f("-9223372036.855", minTimeMsecs)
+	f("9223372036.855", maxTimeMsecs)
+}
+
+func TestGetTimeError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		urlStr := fmt.Sprintf("http://foo.bar/baz?s=%s", url.QueryEscape(s))
+		r, err := http.NewRequest("GET", urlStr, nil)
+		if err != nil {
+			t.Fatalf("unexpected error in NewRequest: %s", err)
+		}
+
+		// Verify defaultValue
+		ts, err := getTime(r, "foo", 123)
+		if err != nil {
+			t.Fatalf("unexpected error when obtaining default time from getTime(%q): %s", s, err)
+		}
+		if ts != 123 {
+			t.Fatalf("unexpected default value for getTime(%q); got %d; want %d", s, ts, 123)
+		}
+
+		// Verify timestampExpected
+		_, err = getTime(r, "s", 123)
+		if err == nil {
+			t.Fatalf("expecting non-nil error in getTime(%q)", s)
+		}
+	}
+
+	f("foo")
+	f("2019-07-07T20:01:02Zisdf")
+	f("2019-07-07T20:47:40+03:00123")
+	f("-292273086-05-16T16:47:07Z")
+	f("292277025-08-18T07:12:54.999999998Z")
+}

app/vmselect/prometheus/query_range_response.qtpl

@@ -0,0 +1,33 @@
+{% import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+) %}
+
+{% stripspace %}
+QueryRangeResponse generates response for /api/v1/query_range.
+See https://prometheus.io/docs/prometheus/latest/querying/api/#range-queries
+{% func QueryRangeResponse(rs []netstorage.Result) %}
+{
+	"status":"success",
+	"data":{
+		"resultType":"matrix",
+		"result":[
+			{% if len(rs) > 0 %}
+				{%= queryRangeLine(&rs[0]) %}
+				{% code rs = rs[1:] %}
+				{% for i := range rs %}
+					,{%= queryRangeLine(&rs[i]) %}
+				{% endfor %}
+			{% endif %}
+		]
+	}
+}
+{% endfunc %}
+
+{% func queryRangeLine(r *netstorage.Result) %}
+{
+	"metric": {%= metricNameObject(&r.MetricName) %},
+	"values": {%= valuesWithTimestamps(r.Values, r.Timestamps) %}
+}
+{% endfunc %}
+
+{% endstripspace %}

app/vmselect/prometheus/query_range_response.qtpl.go

@@ -0,0 +1,118 @@
+// Code generated by qtc from "query_range_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/query_range_response.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/query_range_response.qtpl:1
+import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+)
+
+// QueryRangeResponse generates response for /api/v1/query_range.See https://prometheus.io/docs/prometheus/latest/querying/api/#range-queries
+
+//line app/vmselect/prometheus/query_range_response.qtpl:8
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/query_range_response.qtpl:8
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/query_range_response.qtpl:8
+func StreamQueryRangeResponse(qw422016 *qt422016.Writer, rs []netstorage.Result) {
+//line app/vmselect/prometheus/query_range_response.qtpl:8
+	qw422016.N().S(`{"status":"success","data":{"resultType":"matrix","result":[`)
+//line app/vmselect/prometheus/query_range_response.qtpl:14
+	if len(rs) > 0 {
+//line app/vmselect/prometheus/query_range_response.qtpl:15
+		streamqueryRangeLine(qw422016, &rs[0])
+//line app/vmselect/prometheus/query_range_response.qtpl:16
+		rs = rs[1:]
+
+//line app/vmselect/prometheus/query_range_response.qtpl:17
+		for i := range rs {
+//line app/vmselect/prometheus/query_range_response.qtpl:17
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/query_range_response.qtpl:18
+			streamqueryRangeLine(qw422016, &rs[i])
+//line app/vmselect/prometheus/query_range_response.qtpl:19
+		}
+//line app/vmselect/prometheus/query_range_response.qtpl:20
+	}
+//line app/vmselect/prometheus/query_range_response.qtpl:20
+	qw422016.N().S(`]}}`)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+}
+
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+func WriteQueryRangeResponse(qq422016 qtio422016.Writer, rs []netstorage.Result) {
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	StreamQueryRangeResponse(qw422016, rs)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+}
+
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+func QueryRangeResponse(rs []netstorage.Result) string {
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	WriteQueryRangeResponse(qb422016, rs)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+	return qs422016
+//line app/vmselect/prometheus/query_range_response.qtpl:24
+}
+
+//line app/vmselect/prometheus/query_range_response.qtpl:26
+func streamqueryRangeLine(qw422016 *qt422016.Writer, r *netstorage.Result) {
+//line app/vmselect/prometheus/query_range_response.qtpl:26
+	qw422016.N().S(`{"metric":`)
+//line app/vmselect/prometheus/query_range_response.qtpl:28
+	streammetricNameObject(qw422016, &r.MetricName)
+//line app/vmselect/prometheus/query_range_response.qtpl:28
+	qw422016.N().S(`,"values":`)
+//line app/vmselect/prometheus/query_range_response.qtpl:29
+	streamvaluesWithTimestamps(qw422016, r.Values, r.Timestamps)
+//line app/vmselect/prometheus/query_range_response.qtpl:29
+	qw422016.N().S(`}`)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+}
+
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+func writequeryRangeLine(qq422016 qtio422016.Writer, r *netstorage.Result) {
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	streamqueryRangeLine(qw422016, r)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+}
+
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+func queryRangeLine(r *netstorage.Result) string {
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	writequeryRangeLine(qb422016, r)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+	return qs422016
+//line app/vmselect/prometheus/query_range_response.qtpl:31
+}

app/vmselect/prometheus/query_response.qtpl

@@ -0,0 +1,32 @@
+{% import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+) %}
+
+{% stripspace %}
+QueryResponse generates response for /api/v1/query.
+See https://prometheus.io/docs/prometheus/latest/querying/api/#instant-queries
+{% func QueryResponse(rs []netstorage.Result) %}
+{
+	"status":"success",
+	"data":{
+		"resultType":"vector",
+		"result":[
+			{% if len(rs) > 0 %}
+				{
+					"metric": {%= metricNameObject(&rs[0].MetricName) %},
+					"value": {%= metricRow(rs[0].Timestamps[0], rs[0].Values[0]) %}
+				}
+				{% code rs = rs[1:] %}
+				{% for i := range rs %}
+					{% code r := &rs[i] %}
+					,{
+						"metric": {%= metricNameObject(&r.MetricName) %},
+						"value": {%= metricRow(r.Timestamps[0], r.Values[0]) %}
+					}
+				{% endfor %}
+			{% endif %}
+		]
+	}
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/query_response.qtpl.go

@@ -0,0 +1,94 @@
+// Code generated by qtc from "query_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/query_response.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/query_response.qtpl:1
+import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+)
+
+// QueryResponse generates response for /api/v1/query.See https://prometheus.io/docs/prometheus/latest/querying/api/#instant-queries
+
+//line app/vmselect/prometheus/query_response.qtpl:8
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/query_response.qtpl:8
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/query_response.qtpl:8
+func StreamQueryResponse(qw422016 *qt422016.Writer, rs []netstorage.Result) {
+//line app/vmselect/prometheus/query_response.qtpl:8
+	qw422016.N().S(`{"status":"success","data":{"resultType":"vector","result":[`)
+//line app/vmselect/prometheus/query_response.qtpl:14
+	if len(rs) > 0 {
+//line app/vmselect/prometheus/query_response.qtpl:14
+		qw422016.N().S(`{"metric":`)
+//line app/vmselect/prometheus/query_response.qtpl:16
+		streammetricNameObject(qw422016, &rs[0].MetricName)
+//line app/vmselect/prometheus/query_response.qtpl:16
+		qw422016.N().S(`,"value":`)
+//line app/vmselect/prometheus/query_response.qtpl:17
+		streammetricRow(qw422016, rs[0].Timestamps[0], rs[0].Values[0])
+//line app/vmselect/prometheus/query_response.qtpl:17
+		qw422016.N().S(`}`)
+//line app/vmselect/prometheus/query_response.qtpl:19
+		rs = rs[1:]
+
+//line app/vmselect/prometheus/query_response.qtpl:20
+		for i := range rs {
+//line app/vmselect/prometheus/query_response.qtpl:21
+			r := &rs[i]
+
+//line app/vmselect/prometheus/query_response.qtpl:21
+			qw422016.N().S(`,{"metric":`)
+//line app/vmselect/prometheus/query_response.qtpl:23
+			streammetricNameObject(qw422016, &r.MetricName)
+//line app/vmselect/prometheus/query_response.qtpl:23
+			qw422016.N().S(`,"value":`)
+//line app/vmselect/prometheus/query_response.qtpl:24
+			streammetricRow(qw422016, r.Timestamps[0], r.Values[0])
+//line app/vmselect/prometheus/query_response.qtpl:24
+			qw422016.N().S(`}`)
+//line app/vmselect/prometheus/query_response.qtpl:26
+		}
+//line app/vmselect/prometheus/query_response.qtpl:27
+	}
+//line app/vmselect/prometheus/query_response.qtpl:27
+	qw422016.N().S(`]}}`)
+//line app/vmselect/prometheus/query_response.qtpl:31
+}
+
+//line app/vmselect/prometheus/query_response.qtpl:31
+func WriteQueryResponse(qq422016 qtio422016.Writer, rs []netstorage.Result) {
+//line app/vmselect/prometheus/query_response.qtpl:31
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/query_response.qtpl:31
+	StreamQueryResponse(qw422016, rs)
+//line app/vmselect/prometheus/query_response.qtpl:31
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/query_response.qtpl:31
+}
+
+//line app/vmselect/prometheus/query_response.qtpl:31
+func QueryResponse(rs []netstorage.Result) string {
+//line app/vmselect/prometheus/query_response.qtpl:31
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/query_response.qtpl:31
+	WriteQueryResponse(qb422016, rs)
+//line app/vmselect/prometheus/query_response.qtpl:31
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/query_response.qtpl:31
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/query_response.qtpl:31
+	return qs422016
+//line app/vmselect/prometheus/query_response.qtpl:31
+}

app/vmselect/prometheus/series_count_response.qtpl

@@ -0,0 +1,9 @@
+{% stripspace %}
+SeriesCountResponse generates response for /api/v1/series/count .
+{% func SeriesCountResponse(n uint64) %}
+{
+	"status":"success",
+	"data":[{%d int(n) %}]
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/series_count_response.qtpl.go

@@ -0,0 +1,57 @@
+// Code generated by qtc from "series_count_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+// SeriesCountResponse generates response for /api/v1/series/count .
+
+//line app/vmselect/prometheus/series_count_response.qtpl:3
+package prometheus
+
+//line app/vmselect/prometheus/series_count_response.qtpl:3
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/series_count_response.qtpl:3
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/series_count_response.qtpl:3
+func StreamSeriesCountResponse(qw422016 *qt422016.Writer, n uint64) {
+//line app/vmselect/prometheus/series_count_response.qtpl:3
+	qw422016.N().S(`{"status":"success","data":[`)
+//line app/vmselect/prometheus/series_count_response.qtpl:6
+	qw422016.N().D(int(n))
+//line app/vmselect/prometheus/series_count_response.qtpl:6
+	qw422016.N().S(`]}`)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+}
+
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+func WriteSeriesCountResponse(qq422016 qtio422016.Writer, n uint64) {
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	StreamSeriesCountResponse(qw422016, n)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+}
+
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+func SeriesCountResponse(n uint64) string {
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	WriteSeriesCountResponse(qb422016, n)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+	return qs422016
+//line app/vmselect/prometheus/series_count_response.qtpl:8
+}

app/vmselect/prometheus/series_response.qtpl

@@ -0,0 +1,24 @@
+{% import (
+	"github.com/valyala/quicktemplate"
+) %}
+
+{% stripspace %}
+SeriesResponse generates response for /api/v1/series.
+See https://prometheus.io/docs/prometheus/latest/querying/api/#finding-series-by-label-matchers
+{% func SeriesResponse(resultsCh <-chan *quicktemplate.ByteBuffer) %}
+{
+	"status":"success",
+	"data":[
+		{% code bb, ok := <-resultsCh %}
+		{% if ok %}
+			{%z= bb.B %}
+			{% code quicktemplate.ReleaseByteBuffer(bb) %}
+			{% for bb := range resultsCh %}
+				,{%z= bb.B %}
+				{% code quicktemplate.ReleaseByteBuffer(bb) %}
+			{% endfor %}
+		{% endif %}
+	]
+}
+{% endfunc %}
+{% endstripspace %}

app/vmselect/prometheus/series_response.qtpl.go

@@ -0,0 +1,83 @@
+// Code generated by qtc from "series_response.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/series_response.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/series_response.qtpl:1
+import (
+	"github.com/valyala/quicktemplate"
+)
+
+// SeriesResponse generates response for /api/v1/series.See https://prometheus.io/docs/prometheus/latest/querying/api/#finding-series-by-label-matchers
+
+//line app/vmselect/prometheus/series_response.qtpl:8
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/series_response.qtpl:8
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/series_response.qtpl:8
+func StreamSeriesResponse(qw422016 *qt422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/series_response.qtpl:8
+	qw422016.N().S(`{"status":"success","data":[`)
+//line app/vmselect/prometheus/series_response.qtpl:12
+	bb, ok := <-resultsCh
+
+//line app/vmselect/prometheus/series_response.qtpl:13
+	if ok {
+//line app/vmselect/prometheus/series_response.qtpl:14
+		qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/series_response.qtpl:15
+		quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/series_response.qtpl:16
+		for bb := range resultsCh {
+//line app/vmselect/prometheus/series_response.qtpl:16
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/series_response.qtpl:17
+			qw422016.N().Z(bb.B)
+//line app/vmselect/prometheus/series_response.qtpl:18
+			quicktemplate.ReleaseByteBuffer(bb)
+
+//line app/vmselect/prometheus/series_response.qtpl:19
+		}
+//line app/vmselect/prometheus/series_response.qtpl:20
+	}
+//line app/vmselect/prometheus/series_response.qtpl:20
+	qw422016.N().S(`]}`)
+//line app/vmselect/prometheus/series_response.qtpl:23
+}
+
+//line app/vmselect/prometheus/series_response.qtpl:23
+func WriteSeriesResponse(qq422016 qtio422016.Writer, resultsCh <-chan *quicktemplate.ByteBuffer) {
+//line app/vmselect/prometheus/series_response.qtpl:23
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/series_response.qtpl:23
+	StreamSeriesResponse(qw422016, resultsCh)
+//line app/vmselect/prometheus/series_response.qtpl:23
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/series_response.qtpl:23
+}
+
+//line app/vmselect/prometheus/series_response.qtpl:23
+func SeriesResponse(resultsCh <-chan *quicktemplate.ByteBuffer) string {
+//line app/vmselect/prometheus/series_response.qtpl:23
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/series_response.qtpl:23
+	WriteSeriesResponse(qb422016, resultsCh)
+//line app/vmselect/prometheus/series_response.qtpl:23
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/series_response.qtpl:23
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/series_response.qtpl:23
+	return qs422016
+//line app/vmselect/prometheus/series_response.qtpl:23
+}

app/vmselect/prometheus/util.qtpl

@@ -0,0 +1,47 @@
+{% import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+) %}
+
+{% stripspace %}
+
+{% func metricNameObject(mn *storage.MetricName) %}
+{
+	{% if len(mn.MetricGroup) > 0 %}
+		"__name__":{%qz= mn.MetricGroup %}{% if len(mn.Tags) > 0 %},{% endif %}
+	{% endif %}
+	{% for j := range mn.Tags %}
+		{% code tag := &mn.Tags[j] %}
+		{%qz= tag.Key %}:{%qz= tag.Value %}{% if j+1 < len(mn.Tags) %},{% endif %}
+	{% endfor %}
+}
+{% endfunc %}
+
+{% func metricRow(timestamp int64, value float64) %}
+	[{%f= float64(timestamp)/1e3 %},"{%f= value %}"]
+{% endfunc %}
+
+{% func valuesWithTimestamps(values []float64, timestamps []int64) %}
+[
+	{% if len(values) == 0 %}
+		{% return %}
+	{% endif %}
+	{% code /* inline metricRow call here for the sake of performance optimization */ %}
+	[{%f= float64(timestamps[0])/1e3 %},"{%f= values[0] %}"]
+	{% code
+		timestamps = timestamps[1:]
+		values = values[1:]
+	%}
+	{% if len(values) > 0 %}
+		{%code
+			// Remove bounds check inside the loop below
+			_ = timestamps[len(values)-1]
+		%}
+		{% for i, v := range values %}
+			{% code /* inline metricRow call here for the sake of performance optimization */ %}
+			,[{%f= float64(timestamps[i])/1e3 %},"{%f= v %}"]
+		{% endfor %}
+	{% endif %}
+]
+{% endfunc %}
+
+{% endstripspace %}

app/vmselect/prometheus/util.qtpl.go

@@ -0,0 +1,215 @@
+// Code generated by qtc from "util.qtpl". DO NOT EDIT.
+// See https://github.com/valyala/quicktemplate for details.
+
+//line app/vmselect/prometheus/util.qtpl:1
+package prometheus
+
+//line app/vmselect/prometheus/util.qtpl:1
+import (
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+//line app/vmselect/prometheus/util.qtpl:7
+import (
+	qtio422016 "io"
+
+	qt422016 "github.com/valyala/quicktemplate"
+)
+
+//line app/vmselect/prometheus/util.qtpl:7
+var (
+	_ = qtio422016.Copy
+	_ = qt422016.AcquireByteBuffer
+)
+
+//line app/vmselect/prometheus/util.qtpl:7
+func streammetricNameObject(qw422016 *qt422016.Writer, mn *storage.MetricName) {
+//line app/vmselect/prometheus/util.qtpl:7
+	qw422016.N().S(`{`)
+//line app/vmselect/prometheus/util.qtpl:9
+	if len(mn.MetricGroup) > 0 {
+//line app/vmselect/prometheus/util.qtpl:9
+		qw422016.N().S(`"__name__":`)
+//line app/vmselect/prometheus/util.qtpl:10
+		qw422016.N().QZ(mn.MetricGroup)
+//line app/vmselect/prometheus/util.qtpl:10
+		if len(mn.Tags) > 0 {
+//line app/vmselect/prometheus/util.qtpl:10
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/util.qtpl:10
+		}
+//line app/vmselect/prometheus/util.qtpl:11
+	}
+//line app/vmselect/prometheus/util.qtpl:12
+	for j := range mn.Tags {
+//line app/vmselect/prometheus/util.qtpl:13
+		tag := &mn.Tags[j]
+
+//line app/vmselect/prometheus/util.qtpl:14
+		qw422016.N().QZ(tag.Key)
+//line app/vmselect/prometheus/util.qtpl:14
+		qw422016.N().S(`:`)
+//line app/vmselect/prometheus/util.qtpl:14
+		qw422016.N().QZ(tag.Value)
+//line app/vmselect/prometheus/util.qtpl:14
+		if j+1 < len(mn.Tags) {
+//line app/vmselect/prometheus/util.qtpl:14
+			qw422016.N().S(`,`)
+//line app/vmselect/prometheus/util.qtpl:14
+		}
+//line app/vmselect/prometheus/util.qtpl:15
+	}
+//line app/vmselect/prometheus/util.qtpl:15
+	qw422016.N().S(`}`)
+//line app/vmselect/prometheus/util.qtpl:17
+}
+
+//line app/vmselect/prometheus/util.qtpl:17
+func writemetricNameObject(qq422016 qtio422016.Writer, mn *storage.MetricName) {
+//line app/vmselect/prometheus/util.qtpl:17
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/util.qtpl:17
+	streammetricNameObject(qw422016, mn)
+//line app/vmselect/prometheus/util.qtpl:17
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/util.qtpl:17
+}
+
+//line app/vmselect/prometheus/util.qtpl:17
+func metricNameObject(mn *storage.MetricName) string {
+//line app/vmselect/prometheus/util.qtpl:17
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/util.qtpl:17
+	writemetricNameObject(qb422016, mn)
+//line app/vmselect/prometheus/util.qtpl:17
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/util.qtpl:17
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/util.qtpl:17
+	return qs422016
+//line app/vmselect/prometheus/util.qtpl:17
+}
+
+//line app/vmselect/prometheus/util.qtpl:19
+func streammetricRow(qw422016 *qt422016.Writer, timestamp int64, value float64) {
+//line app/vmselect/prometheus/util.qtpl:19
+	qw422016.N().S(`[`)
+//line app/vmselect/prometheus/util.qtpl:20
+	qw422016.N().F(float64(timestamp) / 1e3)
+//line app/vmselect/prometheus/util.qtpl:20
+	qw422016.N().S(`,"`)
+//line app/vmselect/prometheus/util.qtpl:20
+	qw422016.N().F(value)
+//line app/vmselect/prometheus/util.qtpl:20
+	qw422016.N().S(`"]`)
+//line app/vmselect/prometheus/util.qtpl:21
+}
+
+//line app/vmselect/prometheus/util.qtpl:21
+func writemetricRow(qq422016 qtio422016.Writer, timestamp int64, value float64) {
+//line app/vmselect/prometheus/util.qtpl:21
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/util.qtpl:21
+	streammetricRow(qw422016, timestamp, value)
+//line app/vmselect/prometheus/util.qtpl:21
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/util.qtpl:21
+}
+
+//line app/vmselect/prometheus/util.qtpl:21
+func metricRow(timestamp int64, value float64) string {
+//line app/vmselect/prometheus/util.qtpl:21
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/util.qtpl:21
+	writemetricRow(qb422016, timestamp, value)
+//line app/vmselect/prometheus/util.qtpl:21
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/util.qtpl:21
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/util.qtpl:21
+	return qs422016
+//line app/vmselect/prometheus/util.qtpl:21
+}
+
+//line app/vmselect/prometheus/util.qtpl:23
+func streamvaluesWithTimestamps(qw422016 *qt422016.Writer, values []float64, timestamps []int64) {
+//line app/vmselect/prometheus/util.qtpl:23
+	qw422016.N().S(`[`)
+//line app/vmselect/prometheus/util.qtpl:25
+	if len(values) == 0 {
+//line app/vmselect/prometheus/util.qtpl:26
+		return
+//line app/vmselect/prometheus/util.qtpl:27
+	}
+//line app/vmselect/prometheus/util.qtpl:28
+	/* inline metricRow call here for the sake of performance optimization */
+
+//line app/vmselect/prometheus/util.qtpl:28
+	qw422016.N().S(`[`)
+//line app/vmselect/prometheus/util.qtpl:29
+	qw422016.N().F(float64(timestamps[0]) / 1e3)
+//line app/vmselect/prometheus/util.qtpl:29
+	qw422016.N().S(`,"`)
+//line app/vmselect/prometheus/util.qtpl:29
+	qw422016.N().F(values[0])
+//line app/vmselect/prometheus/util.qtpl:29
+	qw422016.N().S(`"]`)
+//line app/vmselect/prometheus/util.qtpl:31
+	timestamps = timestamps[1:]
+	values = values[1:]
+
+//line app/vmselect/prometheus/util.qtpl:34
+	if len(values) > 0 {
+//line app/vmselect/prometheus/util.qtpl:36
+		// Remove bounds check inside the loop below
+		_ = timestamps[len(values)-1]
+
+//line app/vmselect/prometheus/util.qtpl:39
+		for i, v := range values {
+//line app/vmselect/prometheus/util.qtpl:40
+			/* inline metricRow call here for the sake of performance optimization */
+
+//line app/vmselect/prometheus/util.qtpl:40
+			qw422016.N().S(`,[`)
+//line app/vmselect/prometheus/util.qtpl:41
+			qw422016.N().F(float64(timestamps[i]) / 1e3)
+//line app/vmselect/prometheus/util.qtpl:41
+			qw422016.N().S(`,"`)
+//line app/vmselect/prometheus/util.qtpl:41
+			qw422016.N().F(v)
+//line app/vmselect/prometheus/util.qtpl:41
+			qw422016.N().S(`"]`)
+//line app/vmselect/prometheus/util.qtpl:42
+		}
+//line app/vmselect/prometheus/util.qtpl:43
+	}
+//line app/vmselect/prometheus/util.qtpl:43
+	qw422016.N().S(`]`)
+//line app/vmselect/prometheus/util.qtpl:45
+}
+
+//line app/vmselect/prometheus/util.qtpl:45
+func writevaluesWithTimestamps(qq422016 qtio422016.Writer, values []float64, timestamps []int64) {
+//line app/vmselect/prometheus/util.qtpl:45
+	qw422016 := qt422016.AcquireWriter(qq422016)
+//line app/vmselect/prometheus/util.qtpl:45
+	streamvaluesWithTimestamps(qw422016, values, timestamps)
+//line app/vmselect/prometheus/util.qtpl:45
+	qt422016.ReleaseWriter(qw422016)
+//line app/vmselect/prometheus/util.qtpl:45
+}
+
+//line app/vmselect/prometheus/util.qtpl:45
+func valuesWithTimestamps(values []float64, timestamps []int64) string {
+//line app/vmselect/prometheus/util.qtpl:45
+	qb422016 := qt422016.AcquireByteBuffer()
+//line app/vmselect/prometheus/util.qtpl:45
+	writevaluesWithTimestamps(qb422016, values, timestamps)
+//line app/vmselect/prometheus/util.qtpl:45
+	qs422016 := string(qb422016.B)
+//line app/vmselect/prometheus/util.qtpl:45
+	qt422016.ReleaseByteBuffer(qb422016)
+//line app/vmselect/prometheus/util.qtpl:45
+	return qs422016
+//line app/vmselect/prometheus/util.qtpl:45
+}

app/vmselect/promql/aggr.go

@@ -0,0 +1,548 @@
+package promql
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+var aggrFuncs = map[string]aggrFunc{
+	// See https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators
+	"sum":          newAggrFunc(aggrFuncSum),
+	"min":          newAggrFunc(aggrFuncMin),
+	"max":          newAggrFunc(aggrFuncMax),
+	"avg":          newAggrFunc(aggrFuncAvg),
+	"stddev":       newAggrFunc(aggrFuncStddev),
+	"stdvar":       newAggrFunc(aggrFuncStdvar),
+	"count":        newAggrFunc(aggrFuncCount),
+	"count_values": aggrFuncCountValues,
+	"bottomk":      newAggrFuncTopK(true),
+	"topk":         newAggrFuncTopK(false),
+	"quantile":     aggrFuncQuantile,
+
+	// Extended PromQL funcs
+	"median":   aggrFuncMedian,
+	"limitk":   aggrFuncLimitK,
+	"distinct": newAggrFunc(aggrFuncDistinct),
+	"sum2":     newAggrFunc(aggrFuncSum2),
+	"geomean":  newAggrFunc(aggrFuncGeomean),
+}
+
+type aggrFunc func(afa *aggrFuncArg) ([]*timeseries, error)
+
+type aggrFuncArg struct {
+	args [][]*timeseries
+	ae   *aggrFuncExpr
+	ec   *EvalConfig
+}
+
+func getAggrFunc(s string) aggrFunc {
+	s = strings.ToLower(s)
+	return aggrFuncs[s]
+}
+
+func isAggrFunc(s string) bool {
+	return getAggrFunc(s) != nil
+}
+
+func isAggrFuncModifier(s string) bool {
+	s = strings.ToLower(s)
+	switch s {
+	case "by", "without":
+		return true
+	default:
+		return false
+	}
+}
+
+func newAggrFunc(afe func(tss []*timeseries) []*timeseries) aggrFunc {
+	return func(afa *aggrFuncArg) ([]*timeseries, error) {
+		args := afa.args
+		if err := expectTransformArgsNum(args, 1); err != nil {
+			return nil, err
+		}
+		return aggrFuncExt(afe, args[0], &afa.ae.Modifier, false)
+	}
+}
+
+func removeGroupTags(metricName *storage.MetricName, modifier *modifierExpr) {
+	groupOp := strings.ToLower(modifier.Op)
+	switch groupOp {
+	case "", "by":
+		metricName.RemoveTagsOn(modifier.Args)
+	case "without":
+		metricName.RemoveTagsIgnoring(modifier.Args)
+	default:
+		logger.Panicf("BUG: unknown group modifier: %q", groupOp)
+	}
+}
+
+func aggrFuncExt(afe func(tss []*timeseries) []*timeseries, argOrig []*timeseries, modifier *modifierExpr, keepOriginal bool) ([]*timeseries, error) {
+	arg := copyTimeseriesMetricNames(argOrig)
+
+	// Perform grouping.
+	m := make(map[string][]*timeseries)
+	bb := bbPool.Get()
+	for i, ts := range arg {
+		removeGroupTags(&ts.MetricName, modifier)
+		bb.B = marshalMetricNameSorted(bb.B[:0], &ts.MetricName)
+		if keepOriginal {
+			ts = argOrig[i]
+		}
+		m[string(bb.B)] = append(m[string(bb.B)], ts)
+	}
+	bbPool.Put(bb)
+
+	srcTssCount := 0
+	dstTssCount := 0
+	rvs := make([]*timeseries, 0, len(m))
+	for _, tss := range m {
+		rv := afe(tss)
+		rvs = append(rvs, rv...)
+		srcTssCount += len(tss)
+		dstTssCount += len(rv)
+		if dstTssCount > 2000 && dstTssCount > 16*srcTssCount {
+			// This looks like count_values explosion.
+			return nil, fmt.Errorf(`too many timeseries after aggragation; got %d; want less than %d`, dstTssCount, 16*srcTssCount)
+		}
+	}
+	return rvs, nil
+}
+
+func aggrFuncSum(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - nothing to sum.
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		sum := float64(0)
+		count := 0
+		for _, ts := range tss {
+			if math.IsNaN(ts.Values[i]) {
+				continue
+			}
+			sum += ts.Values[i]
+			count++
+		}
+		if count == 0 {
+			sum = nan
+		}
+		dst.Values[i] = sum
+	}
+	return tss[:1]
+}
+
+func aggrFuncSum2(tss []*timeseries) []*timeseries {
+	dst := tss[0]
+	for i := range dst.Values {
+		sum2 := float64(0)
+		count := 0
+		for _, ts := range tss {
+			v := ts.Values[i]
+			if math.IsNaN(v) {
+				continue
+			}
+			sum2 += v * v
+			count++
+		}
+		if count == 0 {
+			sum2 = nan
+		}
+		dst.Values[i] = sum2
+	}
+	return tss[:1]
+}
+
+func aggrFuncGeomean(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - nothing to geomean.
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		p := 1.0
+		count := 0
+		for _, ts := range tss {
+			v := ts.Values[i]
+			if math.IsNaN(v) {
+				continue
+			}
+			p *= v
+			count++
+		}
+		if count == 0 {
+			p = nan
+		}
+		dst.Values[i] = math.Pow(p, 1/float64(count))
+	}
+	return tss[:1]
+}
+
+func aggrFuncMin(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - nothing to min.
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		min := dst.Values[i]
+		for _, ts := range tss {
+			if math.IsNaN(min) || ts.Values[i] < min {
+				min = ts.Values[i]
+			}
+		}
+		dst.Values[i] = min
+	}
+	return tss[:1]
+}
+
+func aggrFuncMax(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - nothing to max.
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		max := dst.Values[i]
+		for _, ts := range tss {
+			if math.IsNaN(max) || ts.Values[i] > max {
+				max = ts.Values[i]
+			}
+		}
+		dst.Values[i] = max
+	}
+	return tss[:1]
+}
+
+func aggrFuncAvg(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - nothing to avg.
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		// Do not use `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation,
+		// since it is slower and has no obvious benefits in increased precision.
+		var sum float64
+		count := 0
+		for _, ts := range tss {
+			v := ts.Values[i]
+			if math.IsNaN(v) {
+				continue
+			}
+			count++
+			sum += v
+		}
+		avg := nan
+		if count > 0 {
+			avg = sum / float64(count)
+		}
+		dst.Values[i] = avg
+	}
+	return tss[:1]
+}
+
+func aggrFuncStddev(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - stddev over a single time series is zero
+		values := tss[0].Values
+		for i, v := range values {
+			if !math.IsNaN(v) {
+				values[i] = 0
+			}
+		}
+		return tss
+	}
+	rvs := aggrFuncStdvar(tss)
+	dst := rvs[0]
+	for i, v := range dst.Values {
+		dst.Values[i] = math.Sqrt(v)
+	}
+	return rvs
+}
+
+func aggrFuncStdvar(tss []*timeseries) []*timeseries {
+	if len(tss) == 1 {
+		// Fast path - stdvar over a single time series is zero
+		values := tss[0].Values
+		for i, v := range values {
+			if !math.IsNaN(v) {
+				values[i] = 0
+			}
+		}
+		return tss
+	}
+	dst := tss[0]
+	for i := range dst.Values {
+		// See `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation
+		var avg float64
+		var count float64
+		var q float64
+		for _, ts := range tss {
+			v := ts.Values[i]
+			if math.IsNaN(v) {
+				continue
+			}
+			count++
+			avgNew := avg + (v-avg)/count
+			q += (v - avg) * (v - avgNew)
+			avg = avgNew
+		}
+		if count == 0 {
+			q = nan
+		}
+		dst.Values[i] = q / count
+	}
+	return tss[:1]
+}
+
+func aggrFuncCount(tss []*timeseries) []*timeseries {
+	dst := tss[0]
+	for i := range dst.Values {
+		count := 0
+		for _, ts := range tss {
+			if math.IsNaN(ts.Values[i]) {
+				continue
+			}
+			count++
+		}
+		v := float64(count)
+		if count == 0 {
+			v = nan
+		}
+		dst.Values[i] = v
+	}
+	return tss[:1]
+}
+
+func aggrFuncDistinct(tss []*timeseries) []*timeseries {
+	dst := tss[0]
+	m := make(map[float64]struct{}, len(tss))
+	for i := range dst.Values {
+		for _, ts := range tss {
+			v := ts.Values[i]
+			if math.IsNaN(v) {
+				continue
+			}
+			m[v] = struct{}{}
+		}
+		n := float64(len(m))
+		if n == 0 {
+			n = nan
+		}
+		dst.Values[i] = n
+		for k := range m {
+			delete(m, k)
+		}
+	}
+	return tss[:1]
+}
+
+func aggrFuncCountValues(afa *aggrFuncArg) ([]*timeseries, error) {
+	args := afa.args
+	if err := expectTransformArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	dstLabel, err := getString(args[0], 0)
+	if err != nil {
+		return nil, err
+	}
+
+	// Remove dstLabel from grouping like Prometheus does.
+	modifier := &afa.ae.Modifier
+	switch strings.ToLower(modifier.Op) {
+	case "without":
+		modifier.Args = append(modifier.Args, dstLabel)
+	case "by":
+		dstArgs := modifier.Args[:0]
+		for _, arg := range modifier.Args {
+			if arg == dstLabel {
+				continue
+			}
+			dstArgs = append(dstArgs, arg)
+		}
+		modifier.Args = dstArgs
+	default:
+		// Do nothing
+	}
+
+	afe := func(tss []*timeseries) []*timeseries {
+		m := make(map[float64]bool)
+		for _, ts := range tss {
+			for _, v := range ts.Values {
+				if math.IsNaN(v) {
+					continue
+				}
+				m[v] = true
+			}
+		}
+		values := make([]float64, 0, len(m))
+		for v := range m {
+			values = append(values, v)
+		}
+		sort.Float64s(values)
+
+		var rvs []*timeseries
+		for _, v := range values {
+			var dst timeseries
+			dst.CopyFromShallowTimestamps(tss[0])
+			dst.MetricName.RemoveTag(dstLabel)
+			dst.MetricName.AddTag(dstLabel, strconv.FormatFloat(v, 'g', -1, 64))
+			for i := range dst.Values {
+				count := 0
+				for _, ts := range tss {
+					if ts.Values[i] == v {
+						count++
+					}
+				}
+				n := float64(count)
+				if n == 0 {
+					n = nan
+				}
+				dst.Values[i] = n
+			}
+			rvs = append(rvs, &dst)
+		}
+		return rvs
+	}
+	return aggrFuncExt(afe, args[1], &afa.ae.Modifier, false)
+}
+
+func newAggrFuncTopK(isReverse bool) aggrFunc {
+	return func(afa *aggrFuncArg) ([]*timeseries, error) {
+		args := afa.args
+		if err := expectTransformArgsNum(args, 2); err != nil {
+			return nil, err
+		}
+		ks, err := getScalar(args[0], 0)
+		if err != nil {
+			return nil, err
+		}
+		afe := func(tss []*timeseries) []*timeseries {
+			rvs := tss
+			for n := range rvs[0].Values {
+				sort.Slice(rvs, func(i, j int) bool {
+					a := rvs[i].Values[n]
+					b := rvs[j].Values[n]
+					cmp := lessWithNaNs(a, b)
+					if isReverse {
+						cmp = !cmp
+					}
+					return cmp
+				})
+				if math.IsNaN(ks[n]) {
+					ks[n] = 0
+				}
+				k := int(ks[n])
+				if k < 0 {
+					k = 0
+				}
+				if k > len(rvs) {
+					k = len(rvs)
+				}
+				for _, ts := range rvs[:len(rvs)-k] {
+					ts.Values[n] = nan
+				}
+			}
+			return removeNaNs(rvs)
+		}
+		return aggrFuncExt(afe, args[1], &afa.ae.Modifier, true)
+	}
+}
+
+func aggrFuncLimitK(afa *aggrFuncArg) ([]*timeseries, error) {
+	args := afa.args
+	if err := expectTransformArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	ks, err := getScalar(args[0], 0)
+	if err != nil {
+		return nil, err
+	}
+	maxK := 0
+	for _, kf := range ks {
+		k := int(kf)
+		if k > maxK {
+			maxK = k
+		}
+	}
+	afe := func(tss []*timeseries) []*timeseries {
+		if len(tss) > maxK {
+			tss = tss[:maxK]
+		}
+		for i, kf := range ks {
+			k := int(kf)
+			if k < 0 {
+				k = 0
+			}
+			for j := k; j < len(tss); j++ {
+				tss[j].Values[i] = nan
+			}
+		}
+		return tss
+	}
+	return aggrFuncExt(afe, args[1], &afa.ae.Modifier, true)
+}
+
+func aggrFuncQuantile(afa *aggrFuncArg) ([]*timeseries, error) {
+	args := afa.args
+	if err := expectTransformArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	phis, err := getScalar(args[0], 0)
+	if err != nil {
+		return nil, err
+	}
+	afe := newAggrQuantileFunc(phis)
+	return aggrFuncExt(afe, args[1], &afa.ae.Modifier, false)
+}
+
+func aggrFuncMedian(afa *aggrFuncArg) ([]*timeseries, error) {
+	args := afa.args
+	if err := expectTransformArgsNum(args, 1); err != nil {
+		return nil, err
+	}
+	phis := evalNumber(afa.ec, 0.5)[0].Values
+	afe := newAggrQuantileFunc(phis)
+	return aggrFuncExt(afe, args[0], &afa.ae.Modifier, false)
+}
+
+func newAggrQuantileFunc(phis []float64) func(tss []*timeseries) []*timeseries {
+	return func(tss []*timeseries) []*timeseries {
+		dst := tss[0]
+		for n := range dst.Values {
+			sort.Slice(tss, func(i, j int) bool {
+				a := tss[i].Values[n]
+				b := tss[j].Values[n]
+				return lessWithNaNs(a, b)
+			})
+			phi := phis[n]
+			if math.IsNaN(phi) {
+				phi = 1
+			}
+			if phi < 0 {
+				phi = 0
+			}
+			if phi > 1 {
+				phi = 1
+			}
+			idx := int(math.Round(float64(len(tss)-1) * phi))
+			dst.Values[n] = tss[idx].Values[n]
+		}
+		tss[0] = dst
+		return tss[:1]
+	}
+}
+
+func lessWithNaNs(a, b float64) bool {
+	if math.IsNaN(a) {
+		return !math.IsNaN(b)
+	}
+	return a < b
+}

app/vmselect/promql/aggr_incremental.go

@@ -0,0 +1,450 @@
+package promql
+
+import (
+	"math"
+	"strings"
+	"sync"
+)
+
+// callbacks for optimized incremental calculations for aggregate functions
+// over rollups over metricExpr.
+//
+// These calculations save RAM for aggregates over big number of time series.
+var incrementalAggrFuncCallbacksMap = map[string]*incrementalAggrFuncCallbacks{
+	"sum": {
+		updateAggrFunc:   updateAggrSum,
+		mergeAggrFunc:    mergeAggrSum,
+		finalizeAggrFunc: finalizeAggrCommon,
+	},
+	"min": {
+		updateAggrFunc:   updateAggrMin,
+		mergeAggrFunc:    mergeAggrMin,
+		finalizeAggrFunc: finalizeAggrCommon,
+	},
+	"max": {
+		updateAggrFunc:   updateAggrMax,
+		mergeAggrFunc:    mergeAggrMax,
+		finalizeAggrFunc: finalizeAggrCommon,
+	},
+	"avg": {
+		updateAggrFunc:   updateAggrAvg,
+		mergeAggrFunc:    mergeAggrAvg,
+		finalizeAggrFunc: finalizeAggrAvg,
+	},
+	"count": {
+		updateAggrFunc:   updateAggrCount,
+		mergeAggrFunc:    mergeAggrCount,
+		finalizeAggrFunc: finalizeAggrCount,
+	},
+	"sum2": {
+		updateAggrFunc:   updateAggrSum2,
+		mergeAggrFunc:    mergeAggrSum2,
+		finalizeAggrFunc: finalizeAggrCommon,
+	},
+	"geomean": {
+		updateAggrFunc:   updateAggrGeomean,
+		mergeAggrFunc:    mergeAggrGeomean,
+		finalizeAggrFunc: finalizeAggrGeomean,
+	},
+}
+
+type incrementalAggrFuncContext struct {
+	ae *aggrFuncExpr
+
+	mLock sync.Mutex
+	m     map[uint]map[string]*incrementalAggrContext
+
+	callbacks *incrementalAggrFuncCallbacks
+}
+
+func newIncrementalAggrFuncContext(ae *aggrFuncExpr, callbacks *incrementalAggrFuncCallbacks) *incrementalAggrFuncContext {
+	return &incrementalAggrFuncContext{
+		ae:        ae,
+		m:         make(map[uint]map[string]*incrementalAggrContext),
+		callbacks: callbacks,
+	}
+}
+
+func (iafc *incrementalAggrFuncContext) updateTimeseries(ts *timeseries, workerID uint) {
+	iafc.mLock.Lock()
+	m := iafc.m[workerID]
+	if m == nil {
+		m = make(map[string]*incrementalAggrContext, 1)
+		iafc.m[workerID] = m
+	}
+	iafc.mLock.Unlock()
+
+	removeGroupTags(&ts.MetricName, &iafc.ae.Modifier)
+	bb := bbPool.Get()
+	bb.B = marshalMetricNameSorted(bb.B[:0], &ts.MetricName)
+	iac := m[string(bb.B)]
+	if iac == nil {
+		tsAggr := &timeseries{
+			Values:     make([]float64, len(ts.Values)),
+			Timestamps: ts.Timestamps,
+			denyReuse:  true,
+		}
+		tsAggr.MetricName.CopyFrom(&ts.MetricName)
+		iac = &incrementalAggrContext{
+			ts:     tsAggr,
+			values: make([]float64, len(ts.Values)),
+		}
+		m[string(bb.B)] = iac
+	}
+	bbPool.Put(bb)
+	iafc.callbacks.updateAggrFunc(iac, ts.Values)
+}
+
+func (iafc *incrementalAggrFuncContext) finalizeTimeseries() []*timeseries {
+	// There is no need in iafc.mLock.Lock here, since finalizeTimeseries must be called
+	// without concurrent goroutines touching iafc.
+	mGlobal := make(map[string]*incrementalAggrContext)
+	mergeAggrFunc := iafc.callbacks.mergeAggrFunc
+	for _, m := range iafc.m {
+		for k, iac := range m {
+			iacGlobal := mGlobal[k]
+			if iacGlobal == nil {
+				mGlobal[k] = iac
+				continue
+			}
+			mergeAggrFunc(iacGlobal, iac)
+		}
+	}
+	tss := make([]*timeseries, 0, len(mGlobal))
+	finalizeAggrFunc := iafc.callbacks.finalizeAggrFunc
+	for _, iac := range mGlobal {
+		finalizeAggrFunc(iac)
+		tss = append(tss, iac.ts)
+	}
+	return tss
+}
+
+type incrementalAggrFuncCallbacks struct {
+	updateAggrFunc   func(iac *incrementalAggrContext, values []float64)
+	mergeAggrFunc    func(dst, src *incrementalAggrContext)
+	finalizeAggrFunc func(iac *incrementalAggrContext)
+}
+
+func getIncrementalAggrFuncCallbacks(name string) *incrementalAggrFuncCallbacks {
+	name = strings.ToLower(name)
+	return incrementalAggrFuncCallbacksMap[name]
+}
+
+type incrementalAggrContext struct {
+	ts     *timeseries
+	values []float64
+}
+
+func finalizeAggrCommon(iac *incrementalAggrContext) {
+	counts := iac.values
+	dstValues := iac.ts.Values
+	_ = dstValues[len(counts)-1]
+	for i, v := range counts {
+		if v == 0 {
+			dstValues[i] = nan
+		}
+	}
+}
+
+func updateAggrSum(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] += v
+	}
+}
+
+func mergeAggrSum(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] += v
+	}
+}
+
+func updateAggrMin(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		if v < dstValues[i] {
+			dstValues[i] = v
+		}
+	}
+}
+
+func mergeAggrMin(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		if v < dstValues[i] {
+			dstValues[i] = v
+		}
+	}
+}
+
+func updateAggrMax(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		if v > dstValues[i] {
+			dstValues[i] = v
+		}
+	}
+}
+
+func mergeAggrMax(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		if v > dstValues[i] {
+			dstValues[i] = v
+		}
+	}
+}
+
+func updateAggrAvg(iac *incrementalAggrContext, values []float64) {
+	// Do not use `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation,
+	// since it is slower and has no obvious benefits in increased precision.
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] += v
+		dstCounts[i]++
+	}
+}
+
+func mergeAggrAvg(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = srcCounts[i]
+			continue
+		}
+		dstValues[i] += v
+		dstCounts[i] += srcCounts[i]
+	}
+}
+
+func finalizeAggrAvg(iac *incrementalAggrContext) {
+	dstValues := iac.ts.Values
+	counts := iac.values
+	_ = dstValues[len(counts)-1]
+	for i, v := range counts {
+		if v == 0 {
+			dstValues[i] = nan
+			continue
+		}
+		dstValues[i] /= v
+	}
+}
+
+func updateAggrCount(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	_ = dstValues[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		dstValues[i]++
+	}
+}
+
+func mergeAggrCount(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		dstValues[i] += v
+	}
+}
+
+func finalizeAggrCount(iac *incrementalAggrContext) {
+	dstValues := iac.ts.Values
+	for i, v := range dstValues {
+		if v == 0 {
+			dstValues[i] = nan
+		}
+	}
+}
+
+func updateAggrSum2(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v * v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] += v * v
+	}
+}
+
+func mergeAggrSum2(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] += v
+	}
+}
+
+func updateAggrGeomean(iac *incrementalAggrContext, values []float64) {
+	dstValues := iac.ts.Values
+	dstCounts := iac.values
+	_ = dstValues[len(values)-1]
+	_ = dstCounts[len(values)-1]
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = 1
+			continue
+		}
+		dstValues[i] *= v
+		dstCounts[i]++
+	}
+}
+
+func mergeAggrGeomean(dst, src *incrementalAggrContext) {
+	srcValues := src.ts.Values
+	dstValues := dst.ts.Values
+	srcCounts := src.values
+	dstCounts := dst.values
+	_ = srcCounts[len(srcValues)-1]
+	_ = dstCounts[len(srcValues)-1]
+	_ = dstValues[len(srcValues)-1]
+	for i, v := range srcValues {
+		if srcCounts[i] == 0 {
+			continue
+		}
+		if dstCounts[i] == 0 {
+			dstValues[i] = v
+			dstCounts[i] = srcCounts[i]
+			continue
+		}
+		dstValues[i] *= v
+		dstCounts[i] += srcCounts[i]
+	}
+}
+
+func finalizeAggrGeomean(iac *incrementalAggrContext) {
+	dstValues := iac.ts.Values
+	counts := iac.values
+	_ = dstValues[len(counts)-1]
+	for i, v := range counts {
+		if v == 0 {
+			dstValues[i] = nan
+			continue
+		}
+		dstValues[i] = math.Pow(dstValues[i], 1/v)
+	}
+}

app/vmselect/promql/aggr_incremental_test.go

@@ -0,0 +1,188 @@
+package promql
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"runtime"
+	"sync"
+	"testing"
+)
+
+func TestIncrementalAggr(t *testing.T) {
+	defaultTimestamps := []int64{100e3, 200e3, 300e3, 400e3}
+	values := [][]float64{
+		{1, nan, 2, nan},
+		{3, nan, nan, 4},
+		{nan, nan, 5, 6},
+		{7, nan, 8, 9},
+		{4, nan, nan, nan},
+		{2, nan, 3, 2},
+		{0, nan, 1, 1},
+	}
+	tssSrc := make([]*timeseries, len(values))
+	for i, vs := range values {
+		ts := &timeseries{
+			Timestamps: defaultTimestamps,
+			Values:     vs,
+		}
+		tssSrc[i] = ts
+	}
+
+	copyTimeseries := func(tssSrc []*timeseries) []*timeseries {
+		tssDst := make([]*timeseries, len(tssSrc))
+		for i, tsSrc := range tssSrc {
+			var tsDst timeseries
+			tsDst.CopyFromShallowTimestamps(tsSrc)
+			tssDst[i] = &tsDst
+		}
+		return tssDst
+	}
+
+	f := func(name string, valuesExpected []float64) {
+		t.Helper()
+		callbacks := getIncrementalAggrFuncCallbacks(name)
+		ae := &aggrFuncExpr{
+			Name: name,
+		}
+		tssExpected := []*timeseries{{
+			Timestamps: defaultTimestamps,
+			Values:     valuesExpected,
+		}}
+		// run the test multiple times to make sure there are no side effects on concurrency
+		for i := 0; i < 10; i++ {
+			iafc := newIncrementalAggrFuncContext(ae, callbacks)
+			tssSrcCopy := copyTimeseries(tssSrc)
+			if err := testIncrementalParallelAggr(iafc, tssSrcCopy, tssExpected); err != nil {
+				t.Fatalf("unexpected error on iteration %d: %s", i, err)
+			}
+		}
+	}
+
+	t.Run("sum", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{17, nan, 19, 22}
+		f("sum", valuesExpected)
+	})
+	t.Run("min", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{0, nan, 1, 1}
+		f("min", valuesExpected)
+	})
+	t.Run("max", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{7, nan, 8, 9}
+		f("max", valuesExpected)
+	})
+	t.Run("avg", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{2.8333333333333335, nan, 3.8, 4.4}
+		f("avg", valuesExpected)
+	})
+	t.Run("count", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{6, nan, 5, 5}
+		f("count", valuesExpected)
+	})
+	t.Run("sum2", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{79, nan, 103, 138}
+		f("sum2", valuesExpected)
+	})
+	t.Run("geomean", func(t *testing.T) {
+		t.Parallel()
+		valuesExpected := []float64{0, nan, 2.9925557394776896, 3.365865436338599}
+		f("geomean", valuesExpected)
+	})
+}
+
+func testIncrementalParallelAggr(iafc *incrementalAggrFuncContext, tssSrc, tssExpected []*timeseries) error {
+	const workersCount = 3
+	tsCh := make(chan *timeseries)
+	var wg sync.WaitGroup
+	wg.Add(workersCount)
+	for i := 0; i < workersCount; i++ {
+		go func(workerID uint) {
+			defer wg.Done()
+			for ts := range tsCh {
+				runtime.Gosched() // allow other goroutines performing the work
+				iafc.updateTimeseries(ts, workerID)
+			}
+		}(uint(i))
+	}
+	for _, ts := range tssSrc {
+		tsCh <- ts
+	}
+	close(tsCh)
+	wg.Wait()
+	tssActual := iafc.finalizeTimeseries()
+	if err := expectTimeseriesEqual(tssActual, tssExpected); err != nil {
+		return fmt.Errorf("%s; tssActual=%v, tssExpected=%v", err, tssActual, tssExpected)
+	}
+	return nil
+}
+
+func expectTimeseriesEqual(actual, expected []*timeseries) error {
+	if len(actual) != len(expected) {
+		return fmt.Errorf("unexpected number of time series; got %d; want %d", len(actual), len(expected))
+	}
+	mActual := timeseriesToMap(actual)
+	mExpected := timeseriesToMap(expected)
+	if len(mActual) != len(mExpected) {
+		return fmt.Errorf("unexpected number of time series after converting to map; got %d; want %d", len(mActual), len(mExpected))
+	}
+	for k, tsExpected := range mExpected {
+		tsActual := mActual[k]
+		if tsActual == nil {
+			return fmt.Errorf("missing time series for key=%q", k)
+		}
+		if err := expectTsEqual(tsActual, tsExpected); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func timeseriesToMap(tss []*timeseries) map[string]*timeseries {
+	m := make(map[string]*timeseries, len(tss))
+	for _, ts := range tss {
+		k := ts.MetricName.Marshal(nil)
+		m[string(k)] = ts
+	}
+	return m
+}
+
+func expectTsEqual(actual, expected *timeseries) error {
+	mnActual := actual.MetricName.Marshal(nil)
+	mnExpected := expected.MetricName.Marshal(nil)
+	if string(mnActual) != string(mnExpected) {
+		return fmt.Errorf("unexpected metric name; got %q; want %q", mnActual, mnExpected)
+	}
+	if !reflect.DeepEqual(actual.Timestamps, expected.Timestamps) {
+		return fmt.Errorf("unexpected timestamps; got %v; want %v", actual.Timestamps, expected.Timestamps)
+	}
+	if err := compareValues(actual.Values, expected.Values); err != nil {
+		return fmt.Errorf("%s; actual %v; expected %v", err, actual.Values, expected.Values)
+	}
+	return nil
+}
+
+func compareValues(vs1, vs2 []float64) error {
+	if len(vs1) != len(vs2) {
+		return fmt.Errorf("unexpected number of values; got %d; want %d", len(vs1), len(vs2))
+	}
+	for i, v1 := range vs1 {
+		v2 := vs2[i]
+		if math.IsNaN(v1) {
+			if !math.IsNaN(v2) {
+				return fmt.Errorf("unexpected value; got %v; want %v", v1, v2)
+			}
+			continue
+		}
+		eps := math.Abs(v1 - v2)
+		if eps > 1e-14 {
+			return fmt.Errorf("unexpected value; got %v; want %v", v1, v2)
+		}
+	}
+	return nil
+}

app/vmselect/promql/aggr_test.go

@@ -0,0 +1,30 @@
+package promql
+
+import (
+	"testing"
+)
+
+func TestIsAggrFuncModifierSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if !isAggrFuncModifier(s) {
+			t.Fatalf("expecting valid funcModifier: %q", s)
+		}
+	}
+	f("by")
+	f("BY")
+	f("without")
+	f("Without")
+}
+
+func TestIsAggrFuncModifierError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if isAggrFuncModifier(s) {
+			t.Fatalf("unexpected valid funcModifier: %q", s)
+		}
+	}
+	f("byfix")
+	f("on")
+	f("ignoring")
+}

app/vmselect/promql/arch_amd64.go

@@ -0,0 +1,3 @@
+package promql
+
+const maxByteSliceLen = 1 << 40

app/vmselect/promql/arch_arm.go

@@ -0,0 +1,3 @@
+package promql
+
+const maxByteSliceLen = 1<<31 - 1

app/vmselect/promql/binary_op.go

@@ -0,0 +1,560 @@
+package promql
+
+import (
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+var binaryOpFuncs = map[string]binaryOpFunc{
+	"+": newBinaryOpArithFunc(binaryOpPlus),
+	"-": newBinaryOpArithFunc(binaryOpMinus),
+	"*": newBinaryOpArithFunc(binaryOpMul),
+	"/": newBinaryOpArithFunc(binaryOpDiv),
+	"%": newBinaryOpArithFunc(binaryOpMod),
+	"^": newBinaryOpArithFunc(binaryOpPow),
+
+	// cmp ops
+	"==": newBinaryOpCmpFunc(binaryOpEq),
+	"!=": newBinaryOpCmpFunc(binaryOpNeq),
+	">":  newBinaryOpCmpFunc(binaryOpGt),
+	"<":  newBinaryOpCmpFunc(binaryOpLt),
+	">=": newBinaryOpCmpFunc(binaryOpGte),
+	"<=": newBinaryOpCmpFunc(binaryOpLte),
+
+	// logical set ops
+	"and":    binaryOpAnd,
+	"or":     binaryOpOr,
+	"unless": binaryOpUnless,
+
+	// New op
+	"if":      newBinaryOpArithFunc(binaryOpIf),
+	"ifnot":   newBinaryOpArithFunc(binaryOpIfnot),
+	"default": newBinaryOpArithFunc(binaryOpDefault),
+}
+
+var binaryOpPriorities = map[string]int{
+	"default": -1,
+
+	"if":    0,
+	"ifnot": 0,
+
+	// See https://prometheus.io/docs/prometheus/latest/querying/operators/#binary-operator-precedence
+	"or": 1,
+
+	"and":    2,
+	"unless": 2,
+
+	"==": 3,
+	"!=": 3,
+	"<":  3,
+	">":  3,
+	"<=": 3,
+	">=": 3,
+
+	"+": 4,
+	"-": 4,
+
+	"*": 5,
+	"/": 5,
+	"%": 5,
+
+	"^": 6,
+}
+
+func getBinaryOpFunc(op string) binaryOpFunc {
+	op = strings.ToLower(op)
+	return binaryOpFuncs[op]
+}
+
+func isBinaryOp(op string) bool {
+	return getBinaryOpFunc(op) != nil
+}
+
+func binaryOpPriority(op string) int {
+	op = strings.ToLower(op)
+	return binaryOpPriorities[op]
+}
+
+func scanBinaryOpPrefix(s string) int {
+	n := 0
+	for op := range binaryOpFuncs {
+		if len(s) < len(op) {
+			continue
+		}
+		ss := strings.ToLower(s[:len(op)])
+		if ss == op && len(op) > n {
+			n = len(op)
+		}
+	}
+	return n
+}
+
+func isRightAssociativeBinaryOp(op string) bool {
+	// See https://prometheus.io/docs/prometheus/latest/querying/operators/#binary-operator-precedence
+	return op == "^"
+}
+
+func isBinaryOpGroupModifier(s string) bool {
+	s = strings.ToLower(s)
+	switch s {
+	// See https://prometheus.io/docs/prometheus/latest/querying/operators/#vector-matching
+	case "on", "ignoring":
+		return true
+	default:
+		return false
+	}
+}
+
+func isBinaryOpJoinModifier(s string) bool {
+	s = strings.ToLower(s)
+	switch s {
+	case "group_left", "group_right":
+		return true
+	default:
+		return false
+	}
+}
+
+func isBinaryOpBoolModifier(s string) bool {
+	s = strings.ToLower(s)
+	return s == "bool"
+}
+
+func isBinaryOpCmp(op string) bool {
+	switch op {
+	case "==", "!=", ">", "<", ">=", "<=":
+		return true
+	default:
+		return false
+	}
+}
+
+func isBinaryOpLogicalSet(op string) bool {
+	op = strings.ToLower(op)
+	switch op {
+	case "and", "or", "unless":
+		return true
+	default:
+		return false
+	}
+}
+
+func binaryOpConstants(op string, left, right float64, isBool bool) float64 {
+	if isBinaryOpCmp(op) {
+		evalCmp := func(cf func(left, right float64) bool) float64 {
+			if isBool {
+				if cf(left, right) {
+					return 1
+				}
+				return 0
+			}
+			if cf(left, right) {
+				return left
+			}
+			return nan
+		}
+		switch op {
+		case "==":
+			left = evalCmp(binaryOpEq)
+		case "!=":
+			left = evalCmp(binaryOpNeq)
+		case ">":
+			left = evalCmp(binaryOpGt)
+		case "<":
+			left = evalCmp(binaryOpLt)
+		case ">=":
+			left = evalCmp(binaryOpGte)
+		case "<=":
+			left = evalCmp(binaryOpLte)
+		default:
+			logger.Panicf("BUG: unexpected comparison binaryOp: %q", op)
+		}
+	} else {
+		switch op {
+		case "+":
+			left = binaryOpPlus(left, right)
+		case "-":
+			left = binaryOpMinus(left, right)
+		case "*":
+			left = binaryOpMul(left, right)
+		case "/":
+			left = binaryOpDiv(left, right)
+		case "%":
+			left = binaryOpMod(left, right)
+		case "^":
+			left = binaryOpPow(left, right)
+		case "and":
+			// Nothing to do
+		case "or":
+			// Nothing to do
+		case "unless":
+			left = nan
+		case "default":
+			left = binaryOpDefault(left, right)
+		case "if":
+			left = binaryOpIf(left, right)
+		case "ifnot":
+			left = binaryOpIfnot(left, right)
+		default:
+			logger.Panicf("BUG: unexpected non-comparison binaryOp: %q", op)
+		}
+	}
+	return left
+}
+
+type binaryOpFuncArg struct {
+	be    *binaryOpExpr
+	left  []*timeseries
+	right []*timeseries
+}
+
+type binaryOpFunc func(bfa *binaryOpFuncArg) ([]*timeseries, error)
+
+func newBinaryOpCmpFunc(cf func(left, right float64) bool) binaryOpFunc {
+	cfe := func(left, right float64, isBool bool) float64 {
+		if !isBool {
+			if cf(left, right) {
+				return left
+			}
+			return nan
+		}
+		if cf(left, right) {
+			return 1
+		}
+		return 0
+	}
+	return newBinaryOpFunc(cfe)
+}
+
+func newBinaryOpArithFunc(af func(left, right float64) float64) binaryOpFunc {
+	afe := func(left, right float64, isBool bool) float64 {
+		return af(left, right)
+	}
+	return newBinaryOpFunc(afe)
+}
+
+func newBinaryOpFunc(bf func(left, right float64, isBool bool) float64) binaryOpFunc {
+	return func(bfa *binaryOpFuncArg) ([]*timeseries, error) {
+		isBool := bfa.be.Bool
+		left, right, dst, err := adjustBinaryOpTags(bfa.be, bfa.left, bfa.right)
+		if err != nil {
+			return nil, err
+		}
+		if len(left) != len(right) || len(left) != len(dst) {
+			logger.Panicf("BUG: len(left) must match len(right) and len(dst); got %d vs %d vs %d", len(left), len(right), len(dst))
+		}
+		for i, tsLeft := range left {
+			leftValues := tsLeft.Values
+			rightValues := right[i].Values
+			dstValues := dst[i].Values
+			if len(leftValues) != len(rightValues) || len(leftValues) != len(dstValues) {
+				logger.Panicf("BUG: len(leftVaues) must match len(rightValues) and len(dstValues); got %d vs %d vs %d",
+					len(leftValues), len(rightValues), len(dstValues))
+			}
+			for j, a := range leftValues {
+				b := rightValues[j]
+				dstValues[j] = bf(a, b, isBool)
+			}
+		}
+		// Optimization: remove time series containing only NaNs.
+		// This is quite common after applying filters like `q > 0`.
+		dst = removeNaNs(dst)
+		return dst, nil
+	}
+}
+
+func adjustBinaryOpTags(be *binaryOpExpr, left, right []*timeseries) ([]*timeseries, []*timeseries, []*timeseries, error) {
+	if len(be.GroupModifier.Op) == 0 && len(be.JoinModifier.Op) == 0 {
+		if isScalar(left) {
+			// Fast path: `scalar op vector`
+			rvsLeft := make([]*timeseries, len(right))
+			tsLeft := left[0]
+			for i, tsRight := range right {
+				resetMetricGroupIfRequired(be, tsRight)
+				rvsLeft[i] = tsLeft
+			}
+			return rvsLeft, right, right, nil
+		}
+		if isScalar(right) {
+			// Fast path: `vector op scalar`
+			rvsRight := make([]*timeseries, len(left))
+			tsRight := right[0]
+			for i, tsLeft := range left {
+				resetMetricGroupIfRequired(be, tsLeft)
+				rvsRight[i] = tsRight
+			}
+			return left, rvsRight, left, nil
+		}
+	}
+
+	// Slow path: `vector op vector` or `a op {on|ignoring} {group_left|group_right} b`
+	ensureOneX := func(side string, tss []*timeseries) error {
+		if len(tss) == 0 {
+			logger.Panicf("BUG: tss must contain at least one value")
+		}
+		if len(tss) == 1 {
+			return nil
+		}
+		if mergeNonOverlappingTimeseries(tss) {
+			return nil
+		}
+		return fmt.Errorf(`duplicate timeseries on the %s side of %s %s: %s and %s`, side, be.Op, be.GroupModifier.AppendString(nil),
+			stringMetricTags(&tss[0].MetricName), stringMetricTags(&tss[1].MetricName))
+	}
+
+	var rvsLeft, rvsRight []*timeseries
+	mLeft, mRight := createTimeseriesMapByTagSet(be, left, right)
+	joinOp := strings.ToLower(be.JoinModifier.Op)
+	joinTags := be.JoinModifier.Args
+	for k, tssLeft := range mLeft {
+		tssRight := mRight[k]
+		if len(tssRight) == 0 {
+			continue
+		}
+		switch joinOp {
+		case "group_left":
+			if err := ensureOneX("right", tssRight); err != nil {
+				return nil, nil, nil, err
+			}
+			src := tssRight[0]
+			for _, ts := range tssLeft {
+				resetMetricGroupIfRequired(be, ts)
+				ts.MetricName.AddMissingTags(joinTags, &src.MetricName)
+				rvsLeft = append(rvsLeft, ts)
+				rvsRight = append(rvsRight, src)
+			}
+		case "group_right":
+			if err := ensureOneX("left", tssLeft); err != nil {
+				return nil, nil, nil, err
+			}
+			src := tssLeft[0]
+			for _, ts := range tssRight {
+				resetMetricGroupIfRequired(be, ts)
+				ts.MetricName.AddMissingTags(joinTags, &src.MetricName)
+				rvsLeft = append(rvsLeft, src)
+				rvsRight = append(rvsRight, ts)
+			}
+		case "":
+			if err := ensureOneX("left", tssLeft); err != nil {
+				return nil, nil, nil, err
+			}
+			if err := ensureOneX("right", tssRight); err != nil {
+				return nil, nil, nil, err
+			}
+			resetMetricGroupIfRequired(be, tssLeft[0])
+			rvsLeft = append(rvsLeft, tssLeft[0])
+			rvsRight = append(rvsRight, tssRight[0])
+		default:
+			return nil, nil, nil, fmt.Errorf(`unexpected join modifier %q`, joinOp)
+		}
+	}
+	dst := rvsLeft
+	if joinOp == "group_right" {
+		dst = rvsRight
+	}
+	return rvsLeft, rvsRight, dst, nil
+}
+
+func resetMetricGroupIfRequired(be *binaryOpExpr, ts *timeseries) {
+	if isBinaryOpCmp(be.Op) && !be.Bool {
+		// Do not reset MetricGroup for non-boolean `compare` binary ops like Prometheus does.
+		return
+	}
+	switch be.Op {
+	case "default", "if", "ifnot":
+		// Do not reset MetricGroup for these ops.
+		return
+	}
+	ts.MetricName.ResetMetricGroup()
+}
+
+func binaryOpPlus(left, right float64) float64 {
+	return left + right
+}
+
+func binaryOpMinus(left, right float64) float64 {
+	return left - right
+}
+
+func binaryOpMul(left, right float64) float64 {
+	return left * right
+}
+
+func binaryOpDiv(left, right float64) float64 {
+	return left / right
+}
+
+func binaryOpMod(left, right float64) float64 {
+	return math.Mod(left, right)
+}
+
+func binaryOpPow(left, right float64) float64 {
+	return math.Pow(left, right)
+}
+
+func binaryOpDefault(left, right float64) float64 {
+	if math.IsNaN(left) {
+		return right
+	}
+	return left
+}
+
+func binaryOpIf(left, right float64) float64 {
+	if math.IsNaN(right) {
+		return nan
+	}
+	return left
+}
+
+func binaryOpIfnot(left, right float64) float64 {
+	if math.IsNaN(right) {
+		return left
+	}
+	return nan
+}
+
+func binaryOpEq(left, right float64) bool {
+	// Special handling for nan == nan.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/150 .
+	if math.IsNaN(left) {
+		return math.IsNaN(right)
+	}
+
+	return left == right
+}
+
+func binaryOpNeq(left, right float64) bool {
+	// Special handling for comparison with nan.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/150 .
+	if math.IsNaN(left) {
+		return !math.IsNaN(right)
+	}
+	if math.IsNaN(right) {
+		return true
+	}
+
+	return left != right
+}
+
+func binaryOpGt(left, right float64) bool {
+	return left > right
+}
+
+func binaryOpLt(left, right float64) bool {
+	return left < right
+}
+
+func binaryOpGte(left, right float64) bool {
+	return left >= right
+}
+
+func binaryOpLte(left, right float64) bool {
+	return left <= right
+}
+
+func binaryOpAnd(bfa *binaryOpFuncArg) ([]*timeseries, error) {
+	mLeft, mRight := createTimeseriesMapByTagSet(bfa.be, bfa.left, bfa.right)
+	var rvs []*timeseries
+	for k := range mRight {
+		if tss := mLeft[k]; tss != nil {
+			rvs = append(rvs, tss...)
+		}
+	}
+	return rvs, nil
+}
+
+func binaryOpOr(bfa *binaryOpFuncArg) ([]*timeseries, error) {
+	mLeft, mRight := createTimeseriesMapByTagSet(bfa.be, bfa.left, bfa.right)
+	var rvs []*timeseries
+	for _, tss := range mLeft {
+		rvs = append(rvs, tss...)
+	}
+	for k, tss := range mRight {
+		if mLeft[k] == nil {
+			rvs = append(rvs, tss...)
+		}
+	}
+	return rvs, nil
+}
+
+func binaryOpUnless(bfa *binaryOpFuncArg) ([]*timeseries, error) {
+	mLeft, mRight := createTimeseriesMapByTagSet(bfa.be, bfa.left, bfa.right)
+	var rvs []*timeseries
+	for k, tss := range mLeft {
+		if mRight[k] == nil {
+			rvs = append(rvs, tss...)
+		}
+	}
+	return rvs, nil
+}
+
+func createTimeseriesMapByTagSet(be *binaryOpExpr, left, right []*timeseries) (map[string][]*timeseries, map[string][]*timeseries) {
+	groupTags := be.GroupModifier.Args
+	groupOp := strings.ToLower(be.GroupModifier.Op)
+	if len(groupOp) == 0 {
+		groupOp = "ignoring"
+	}
+	getTagsMap := func(arg []*timeseries) map[string][]*timeseries {
+		bb := bbPool.Get()
+		m := make(map[string][]*timeseries, len(arg))
+		mn := storage.GetMetricName()
+		for _, ts := range arg {
+			mn.CopyFrom(&ts.MetricName)
+			mn.ResetMetricGroup()
+			switch groupOp {
+			case "on":
+				mn.RemoveTagsOn(groupTags)
+			case "ignoring":
+				mn.RemoveTagsIgnoring(groupTags)
+			default:
+				logger.Panicf("BUG: unexpected binary op modifier %q", groupOp)
+			}
+			bb.B = marshalMetricTagsSorted(bb.B[:0], mn)
+			m[string(bb.B)] = append(m[string(bb.B)], ts)
+		}
+		storage.PutMetricName(mn)
+		bbPool.Put(bb)
+		return m
+	}
+	mLeft := getTagsMap(left)
+	mRight := getTagsMap(right)
+	return mLeft, mRight
+}
+
+func isScalar(arg []*timeseries) bool {
+	if len(arg) != 1 {
+		return false
+	}
+	mn := &arg[0].MetricName
+	if len(mn.MetricGroup) > 0 {
+		return false
+	}
+	return len(mn.Tags) == 0
+}
+
+func mergeNonOverlappingTimeseries(tss []*timeseries) bool {
+	if len(tss) < 2 {
+		logger.Panicf("BUG: expecting at least two timeseries. Got %d", len(tss))
+	}
+
+	// Check whether time series in tss overlap.
+	var dst timeseries
+	dst.CopyFromShallowTimestamps(tss[0])
+	dstValues := dst.Values
+	for _, ts := range tss[1:] {
+		for i, value := range ts.Values {
+			if math.IsNaN(dstValues[i]) {
+				dstValues[i] = value
+			} else if !math.IsNaN(value) {
+				// Time series overlap.
+				return false
+			}
+		}
+	}
+	tss[0].CopyFromShallowTimestamps(&dst)
+	return true
+}

app/vmselect/promql/binary_op_test.go

@@ -0,0 +1,125 @@
+package promql
+
+import (
+	"testing"
+)
+
+func TestIsBinaryOpSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if !isBinaryOp(s) {
+			t.Fatalf("expecting valid binaryOp: %q", s)
+		}
+	}
+	f("and")
+	f("AND")
+	f("unless")
+	f("unleSS")
+	f("==")
+	f("!=")
+	f(">=")
+	f("<=")
+	f("or")
+	f("Or")
+	f("+")
+	f("-")
+	f("*")
+	f("/")
+	f("%")
+	f("^")
+	f(">")
+	f("<")
+}
+
+func TestIsBinaryOpError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if isBinaryOp(s) {
+			t.Fatalf("unexpected valid binaryOp: %q", s)
+		}
+	}
+	f("foobar")
+	f("=~")
+	f("!~")
+	f("=")
+	f("<==")
+	f("234")
+}
+
+func TestIsBinaryOpGroupModifierSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if !isBinaryOpGroupModifier(s) {
+			t.Fatalf("expecting valid binaryOpGroupModifier: %q", s)
+		}
+	}
+	f("on")
+	f("ON")
+	f("oN")
+	f("ignoring")
+	f("IGnoring")
+}
+
+func TestIsBinaryOpGroupModifierError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if isBinaryOpGroupModifier(s) {
+			t.Fatalf("unexpected valid binaryOpGroupModifier: %q", s)
+		}
+	}
+	f("off")
+	f("by")
+	f("without")
+	f("123")
+}
+
+func TestIsBinaryOpJoinModifierSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if !isBinaryOpJoinModifier(s) {
+			t.Fatalf("expecting valid binaryOpJoinModifier: %q", s)
+		}
+	}
+	f("group_left")
+	f("group_right")
+	f("group_LEft")
+	f("GRoup_RighT")
+}
+
+func TestIsBinaryOpJoinModifierError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if isBinaryOpJoinModifier(s) {
+			t.Fatalf("unexpected valid binaryOpJoinModifier: %q", s)
+		}
+	}
+	f("on")
+	f("by")
+	f("without")
+	f("123")
+}
+
+func TestIsBinaryOpBoolModifierSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if !isBinaryOpBoolModifier(s) {
+			t.Fatalf("expecting valid binaryOpBoolModifier: %q", s)
+		}
+	}
+	f("bool")
+	f("bOOL")
+	f("BOOL")
+}
+
+func TestIsBinaryOpBoolModifierError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		if isBinaryOpBoolModifier(s) {
+			t.Fatalf("unexpected valid binaryOpBoolModifier: %q", s)
+		}
+	}
+	f("on")
+	f("by")
+	f("without")
+	f("123")
+}

app/vmselect/promql/eval.go

@@ -0,0 +1,795 @@
+package promql
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"runtime"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/memory"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	maxPointsPerTimeseries = flag.Int("search.maxPointsPerTimeseries", 30e3, "The maximum points per a single timeseries returned from the search")
+)
+
+// The minimum number of points per timeseries for enabling time rounding.
+// This improves cache hit ratio for frequently requested queries over
+// big time ranges.
+const minTimeseriesPointsForTimeRounding = 50
+
+// ValidateMaxPointsPerTimeseries checks the maximum number of points that
+// may be returned per each time series.
+//
+// The number mustn't exceed -search.maxPointsPerTimeseries.
+func ValidateMaxPointsPerTimeseries(start, end, step int64) error {
+	points := (end-start)/step + 1
+	if uint64(points) > uint64(*maxPointsPerTimeseries) {
+		return fmt.Errorf(`too many points for the given step=%d, start=%d and end=%d: %d; cannot exceed -search.maxPointsPerTimeseries=%d`,
+			step, start, end, uint64(points), *maxPointsPerTimeseries)
+	}
+	return nil
+}
+
+// AdjustStartEnd adjusts start and end values, so response caching may be enabled.
+//
+// See EvalConfig.mayCache for details.
+func AdjustStartEnd(start, end, step int64) (int64, int64) {
+	points := (end-start)/step + 1
+	if points < minTimeseriesPointsForTimeRounding {
+		// Too small number of points for rounding.
+		return start, end
+	}
+
+	// Round start and end to values divisible by step in order
+	// to enable response caching (see EvalConfig.mayCache).
+
+	// Round start to the nearest smaller value divisible by step.
+	start -= start % step
+	// Round end to the nearest bigger value divisible by step.
+	adjust := end % step
+	if adjust > 0 {
+		end += step - adjust
+	}
+	return start, end
+}
+
+// EvalConfig is the configuration required for query evaluation via Exec
+type EvalConfig struct {
+	AuthToken *auth.Token
+	Start     int64
+	End       int64
+	Step      int64
+
+	Deadline netstorage.Deadline
+
+	MayCache bool
+
+	DenyPartialResponse bool
+
+	timestamps     []int64
+	timestampsOnce sync.Once
+}
+
+// newEvalConfig returns new EvalConfig copy from src.
+func newEvalConfig(src *EvalConfig) *EvalConfig {
+	var ec EvalConfig
+	ec.AuthToken = src.AuthToken
+	ec.Start = src.Start
+	ec.End = src.End
+	ec.Step = src.Step
+	ec.Deadline = src.Deadline
+	ec.MayCache = src.MayCache
+	ec.DenyPartialResponse = src.DenyPartialResponse
+
+	// do not copy src.timestamps - they must be generated again.
+	return &ec
+}
+
+func (ec *EvalConfig) validate() {
+	if ec.Start > ec.End {
+		logger.Panicf("BUG: start cannot exceed end; got %d vs %d", ec.Start, ec.End)
+	}
+	if ec.Step <= 0 {
+		logger.Panicf("BUG: step must be greater than 0; got %d", ec.Step)
+	}
+}
+
+func (ec *EvalConfig) mayCache() bool {
+	if !ec.MayCache {
+		return false
+	}
+	if ec.Start%ec.Step != 0 {
+		return false
+	}
+	if ec.End%ec.Step != 0 {
+		return false
+	}
+	return true
+}
+
+func (ec *EvalConfig) getSharedTimestamps() []int64 {
+	ec.timestampsOnce.Do(ec.timestampsInit)
+	return ec.timestamps
+}
+
+func (ec *EvalConfig) timestampsInit() {
+	ec.timestamps = getTimestamps(ec.Start, ec.End, ec.Step)
+}
+
+func getTimestamps(start, end, step int64) []int64 {
+	// Sanity checks.
+	if step <= 0 {
+		logger.Panicf("BUG: Step must be bigger than 0; got %d", step)
+	}
+	if start > end {
+		logger.Panicf("BUG: Start cannot exceed End; got %d vs %d", start, end)
+	}
+	if err := ValidateMaxPointsPerTimeseries(start, end, step); err != nil {
+		logger.Panicf("BUG: %s; this must be validated before the call to getTimestamps", err)
+	}
+
+	// Prepare timestamps.
+	points := 1 + (end-start)/step
+	timestamps := make([]int64, points)
+	for i := range timestamps {
+		timestamps[i] = start
+		start += step
+	}
+	return timestamps
+}
+
+func evalExpr(ec *EvalConfig, e expr) ([]*timeseries, error) {
+	if me, ok := e.(*metricExpr); ok {
+		re := &rollupExpr{
+			Expr: me,
+		}
+		rv, err := evalRollupFunc(ec, "default_rollup", rollupDefault, re, nil)
+		if err != nil {
+			return nil, fmt.Errorf(`cannot evaluate %q: %s`, me.AppendString(nil), err)
+		}
+		return rv, nil
+	}
+	if re, ok := e.(*rollupExpr); ok {
+		rv, err := evalRollupFunc(ec, "default_rollup", rollupDefault, re, nil)
+		if err != nil {
+			return nil, fmt.Errorf(`cannot evaluate %q: %s`, re.AppendString(nil), err)
+		}
+		return rv, nil
+	}
+	if fe, ok := e.(*funcExpr); ok {
+		nrf := getRollupFunc(fe.Name)
+		if nrf == nil {
+			args, err := evalExprs(ec, fe.Args)
+			if err != nil {
+				return nil, err
+			}
+			tf := getTransformFunc(fe.Name)
+			if tf == nil {
+				return nil, fmt.Errorf(`unknown func %q`, fe.Name)
+			}
+			tfa := &transformFuncArg{
+				ec:   ec,
+				fe:   fe,
+				args: args,
+			}
+			rv, err := tf(tfa)
+			if err != nil {
+				return nil, fmt.Errorf(`cannot evaluate %q: %s`, fe.AppendString(nil), err)
+			}
+			return rv, nil
+		}
+		args, re, err := evalRollupFuncArgs(ec, fe)
+		if err != nil {
+			return nil, err
+		}
+		rf, err := nrf(args)
+		if err != nil {
+			return nil, err
+		}
+		rv, err := evalRollupFunc(ec, fe.Name, rf, re, nil)
+		if err != nil {
+			return nil, fmt.Errorf(`cannot evaluate %q: %s`, fe.AppendString(nil), err)
+		}
+		return rv, nil
+	}
+	if ae, ok := e.(*aggrFuncExpr); ok {
+		if callbacks := getIncrementalAggrFuncCallbacks(ae.Name); callbacks != nil {
+			fe, nrf := tryGetArgRollupFuncWithMetricExpr(ae)
+			if fe != nil {
+				// There is an optimized path for calculating aggrFuncExpr over rollupFunc over metricExpr.
+				// The optimized path saves RAM for aggregates over big number of time series.
+				args, re, err := evalRollupFuncArgs(ec, fe)
+				if err != nil {
+					return nil, err
+				}
+				rf, err := nrf(args)
+				if err != nil {
+					return nil, err
+				}
+				iafc := newIncrementalAggrFuncContext(ae, callbacks)
+				return evalRollupFunc(ec, fe.Name, rf, re, iafc)
+			}
+		}
+		args, err := evalExprs(ec, ae.Args)
+		if err != nil {
+			return nil, err
+		}
+		af := getAggrFunc(ae.Name)
+		if af == nil {
+			return nil, fmt.Errorf(`unknown func %q`, ae.Name)
+		}
+		afa := &aggrFuncArg{
+			ae:   ae,
+			args: args,
+			ec:   ec,
+		}
+		rv, err := af(afa)
+		if err != nil {
+			return nil, fmt.Errorf(`cannot evaluate %q: %s`, ae.AppendString(nil), err)
+		}
+		return rv, nil
+	}
+	if be, ok := e.(*binaryOpExpr); ok {
+		left, err := evalExpr(ec, be.Left)
+		if err != nil {
+			return nil, err
+		}
+		right, err := evalExpr(ec, be.Right)
+		if err != nil {
+			return nil, err
+		}
+		bf := getBinaryOpFunc(be.Op)
+		if bf == nil {
+			return nil, fmt.Errorf(`unknown binary op %q`, be.Op)
+		}
+		bfa := &binaryOpFuncArg{
+			be:    be,
+			left:  left,
+			right: right,
+		}
+		rv, err := bf(bfa)
+		if err != nil {
+			return nil, fmt.Errorf(`cannot evaluate %q: %s`, be.AppendString(nil), err)
+		}
+		return rv, nil
+	}
+	if ne, ok := e.(*numberExpr); ok {
+		rv := evalNumber(ec, ne.N)
+		return rv, nil
+	}
+	if se, ok := e.(*stringExpr); ok {
+		rv := evalString(ec, se.S)
+		return rv, nil
+	}
+	return nil, fmt.Errorf("unexpected expression %q", e.AppendString(nil))
+}
+
+func tryGetArgRollupFuncWithMetricExpr(ae *aggrFuncExpr) (*funcExpr, newRollupFunc) {
+	if len(ae.Args) != 1 {
+		return nil, nil
+	}
+	e := ae.Args[0]
+	// Make sure e contains one of the following:
+	// - metricExpr
+	// - metricExpr[d]
+	// - rollupFunc(metricExpr)
+	// - rollupFunc(metricExpr[d])
+
+	if me, ok := e.(*metricExpr); ok {
+		// e = metricExpr
+		if me.IsEmpty() {
+			return nil, nil
+		}
+		fe := &funcExpr{
+			Name: "default_rollup",
+			Args: []expr{me},
+		}
+		nrf := getRollupFunc(fe.Name)
+		return fe, nrf
+	}
+	if re, ok := e.(*rollupExpr); ok {
+		if me, ok := re.Expr.(*metricExpr); !ok || me.IsEmpty() {
+			return nil, nil
+		}
+		// e = rollupExpr(metricExpr)
+		fe := &funcExpr{
+			Name: "default_rollup",
+			Args: []expr{re},
+		}
+		nrf := getRollupFunc(fe.Name)
+		return fe, nrf
+	}
+	fe, ok := e.(*funcExpr)
+	if !ok {
+		return nil, nil
+	}
+	nrf := getRollupFunc(fe.Name)
+	if nrf == nil {
+		return nil, nil
+	}
+	rollupArgIdx := getRollupArgIdx(fe.Name)
+	arg := fe.Args[rollupArgIdx]
+	if me, ok := arg.(*metricExpr); ok {
+		if me.IsEmpty() {
+			return nil, nil
+		}
+		return &funcExpr{
+			Name: fe.Name,
+			Args: []expr{me},
+		}, nrf
+	}
+	if re, ok := arg.(*rollupExpr); ok {
+		if me, ok := re.Expr.(*metricExpr); !ok || me.IsEmpty() {
+			return nil, nil
+		}
+		return fe, nrf
+	}
+	return nil, nil
+}
+
+func evalExprs(ec *EvalConfig, es []expr) ([][]*timeseries, error) {
+	var rvs [][]*timeseries
+	for _, e := range es {
+		rv, err := evalExpr(ec, e)
+		if err != nil {
+			return nil, err
+		}
+		rvs = append(rvs, rv)
+	}
+	return rvs, nil
+}
+
+func evalRollupFuncArgs(ec *EvalConfig, fe *funcExpr) ([]interface{}, *rollupExpr, error) {
+	var re *rollupExpr
+	rollupArgIdx := getRollupArgIdx(fe.Name)
+	args := make([]interface{}, len(fe.Args))
+	for i, arg := range fe.Args {
+		if i == rollupArgIdx {
+			re = getRollupExprArg(arg)
+			args[i] = re
+			continue
+		}
+		ts, err := evalExpr(ec, arg)
+		if err != nil {
+			return nil, nil, fmt.Errorf("cannot evaluate arg #%d for %q: %s", i+1, fe.AppendString(nil), err)
+		}
+		args[i] = ts
+	}
+	return args, re, nil
+}
+
+func getRollupExprArg(arg expr) *rollupExpr {
+	re, ok := arg.(*rollupExpr)
+	if !ok {
+		// Wrap non-rollup arg into rollupExpr.
+		return &rollupExpr{
+			Expr: arg,
+		}
+	}
+	if len(re.Step) == 0 && !re.InheritStep {
+		// Return standard rollup if it doesn't set step.
+		return re
+	}
+	me, ok := re.Expr.(*metricExpr)
+	if !ok {
+		// arg contains subquery.
+		return re
+	}
+	// Convert me[w:step] -> default_rollup(me)[w:step]
+	reNew := *re
+	reNew.Expr = &funcExpr{
+		Name: "default_rollup",
+		Args: []expr{
+			&rollupExpr{Expr: me},
+		},
+	}
+	return &reNew
+}
+
+func evalRollupFunc(ec *EvalConfig, name string, rf rollupFunc, re *rollupExpr, iafc *incrementalAggrFuncContext) ([]*timeseries, error) {
+	ecNew := ec
+	var offset int64
+	if len(re.Offset) > 0 {
+		var err error
+		offset, err = DurationValue(re.Offset, ec.Step)
+		if err != nil {
+			return nil, err
+		}
+		ecNew = newEvalConfig(ec)
+		ecNew.Start -= offset
+		ecNew.End -= offset
+		ecNew.Start, ecNew.End = AdjustStartEnd(ecNew.Start, ecNew.End, ecNew.Step)
+	}
+	var rvs []*timeseries
+	var err error
+	if me, ok := re.Expr.(*metricExpr); ok {
+		rvs, err = evalRollupFuncWithMetricExpr(ecNew, name, rf, me, iafc, re.Window)
+	} else {
+		if iafc != nil {
+			logger.Panicf("BUG: iafc must be nil for rollup %q over subquery %q", name, re.AppendString(nil))
+		}
+		rvs, err = evalRollupFuncWithSubquery(ecNew, name, rf, re)
+	}
+	if err != nil {
+		return nil, err
+	}
+	if offset != 0 && len(rvs) > 0 {
+		// Make a copy of timestamps, since they may be used in other values.
+		srcTimestamps := rvs[0].Timestamps
+		dstTimestamps := append([]int64{}, srcTimestamps...)
+		for i := range dstTimestamps {
+			dstTimestamps[i] += offset
+		}
+		for _, ts := range rvs {
+			ts.Timestamps = dstTimestamps
+		}
+	}
+	return rvs, nil
+}
+
+func evalRollupFuncWithSubquery(ec *EvalConfig, name string, rf rollupFunc, re *rollupExpr) ([]*timeseries, error) {
+	// Do not use rollupResultCacheV here, since it works only with metricExpr.
+	var step int64
+	if len(re.Step) > 0 {
+		var err error
+		step, err = DurationValue(re.Step, ec.Step)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		step = ec.Step
+	}
+	var window int64
+	if len(re.Window) > 0 {
+		var err error
+		window, err = DurationValue(re.Window, ec.Step)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	ecSQ := newEvalConfig(ec)
+	ecSQ.Start -= window + maxSilenceInterval + step
+	ecSQ.Step = step
+	if err := ValidateMaxPointsPerTimeseries(ecSQ.Start, ecSQ.End, ecSQ.Step); err != nil {
+		return nil, err
+	}
+	ecSQ.Start, ecSQ.End = AdjustStartEnd(ecSQ.Start, ecSQ.End, ecSQ.Step)
+	tssSQ, err := evalExpr(ecSQ, re.Expr)
+	if err != nil {
+		return nil, err
+	}
+
+	sharedTimestamps := getTimestamps(ec.Start, ec.End, ec.Step)
+	preFunc, rcs := getRollupConfigs(name, rf, ec.Start, ec.End, ec.Step, window, sharedTimestamps)
+	tss := make([]*timeseries, 0, len(tssSQ)*len(rcs))
+	var tssLock sync.Mutex
+	removeMetricGroup := !rollupFuncsKeepMetricGroup[name]
+	doParallel(tssSQ, func(tsSQ *timeseries, values []float64, timestamps []int64) ([]float64, []int64) {
+		values, timestamps = removeNanValues(values[:0], timestamps[:0], tsSQ.Values, tsSQ.Timestamps)
+		preFunc(values, timestamps)
+		for _, rc := range rcs {
+			var ts timeseries
+			doRollupForTimeseries(rc, &ts, &tsSQ.MetricName, values, timestamps, sharedTimestamps, removeMetricGroup)
+			tssLock.Lock()
+			tss = append(tss, &ts)
+			tssLock.Unlock()
+		}
+		return values, timestamps
+	})
+	return tss, nil
+}
+
+func doParallel(tss []*timeseries, f func(ts *timeseries, values []float64, timestamps []int64) ([]float64, []int64)) {
+	concurrency := runtime.GOMAXPROCS(-1)
+	if concurrency > len(tss) {
+		concurrency = len(tss)
+	}
+	workCh := make(chan *timeseries, concurrency)
+	var wg sync.WaitGroup
+	wg.Add(concurrency)
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			defer wg.Done()
+			var tmpValues []float64
+			var tmpTimestamps []int64
+			for ts := range workCh {
+				tmpValues, tmpTimestamps = f(ts, tmpValues, tmpTimestamps)
+			}
+		}()
+	}
+	for _, ts := range tss {
+		workCh <- ts
+	}
+	close(workCh)
+	wg.Wait()
+}
+
+func removeNanValues(dstValues []float64, dstTimestamps []int64, values []float64, timestamps []int64) ([]float64, []int64) {
+	hasNan := false
+	for _, v := range values {
+		if math.IsNaN(v) {
+			hasNan = true
+		}
+	}
+	if !hasNan {
+		// Fast path - no NaNs.
+		dstValues = append(dstValues, values...)
+		dstTimestamps = append(dstTimestamps, timestamps...)
+		return dstValues, dstTimestamps
+	}
+
+	// Slow path - remove NaNs.
+	for i, v := range values {
+		if math.IsNaN(v) {
+			continue
+		}
+		dstValues = append(dstValues, v)
+		dstTimestamps = append(dstTimestamps, timestamps[i])
+	}
+	return dstValues, dstTimestamps
+}
+
+var (
+	rollupResultCacheFullHits    = metrics.NewCounter(`vm_rollup_result_cache_full_hits_total`)
+	rollupResultCachePartialHits = metrics.NewCounter(`vm_rollup_result_cache_partial_hits_total`)
+	rollupResultCacheMiss        = metrics.NewCounter(`vm_rollup_result_cache_miss_total`)
+)
+
+func evalRollupFuncWithMetricExpr(ec *EvalConfig, name string, rf rollupFunc, me *metricExpr, iafc *incrementalAggrFuncContext, windowStr string) ([]*timeseries, error) {
+	if me.IsEmpty() {
+		return evalNumber(ec, nan), nil
+	}
+	var window int64
+	if len(windowStr) > 0 {
+		var err error
+		window, err = DurationValue(windowStr, ec.Step)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Search for partial results in cache.
+	tssCached, start := rollupResultCacheV.Get(name, ec, me, iafc, window)
+	if start > ec.End {
+		// The result is fully cached.
+		rollupResultCacheFullHits.Inc()
+		return tssCached, nil
+	}
+	if start > ec.Start {
+		rollupResultCachePartialHits.Inc()
+	} else {
+		rollupResultCacheMiss.Inc()
+	}
+
+	// Fetch the remaining part of the result.
+	sq := &storage.SearchQuery{
+		AccountID:    ec.AuthToken.AccountID,
+		ProjectID:    ec.AuthToken.ProjectID,
+		MinTimestamp: start - window - maxSilenceInterval,
+		MaxTimestamp: ec.End + ec.Step,
+		TagFilterss:  [][]storage.TagFilter{me.TagFilters},
+	}
+	rss, isPartial, err := netstorage.ProcessSearchQuery(ec.AuthToken, sq, true, ec.Deadline)
+	if err != nil {
+		return nil, err
+	}
+	if isPartial && ec.DenyPartialResponse {
+		return nil, fmt.Errorf("cannot return full response, since some of vmstorage nodes are unavailable")
+	}
+	rssLen := rss.Len()
+	if rssLen == 0 {
+		rss.Cancel()
+		// Add missing points until ec.End.
+		// Do not cache the result, since missing points
+		// may be backfilled in the future.
+		tss := mergeTimeseries(tssCached, nil, start, ec)
+		return tss, nil
+	}
+	sharedTimestamps := getTimestamps(start, ec.End, ec.Step)
+	preFunc, rcs := getRollupConfigs(name, rf, start, ec.End, ec.Step, window, sharedTimestamps)
+
+	// Verify timeseries fit available memory after the rollup.
+	// Take into account points from tssCached.
+	pointsPerTimeseries := 1 + (ec.End-ec.Start)/ec.Step
+	rollupPoints := mulNoOverflow(pointsPerTimeseries, int64(rssLen*len(rcs)))
+	rollupMemorySize := mulNoOverflow(rollupPoints, 16)
+	rml := getRollupMemoryLimiter()
+	if !rml.Get(uint64(rollupMemorySize)) {
+		rss.Cancel()
+		return nil, fmt.Errorf("not enough memory for processing %d data points across %d time series with %d points in each time series; "+
+			"possible solutions are: reducing the number of matching time series; switching to node with more RAM; "+
+			"increasing -memory.allowedPercent; increasing `step` query arg (%gs)",
+			rollupPoints, rssLen*len(rcs), pointsPerTimeseries, float64(ec.Step)/1e3)
+	}
+	defer rml.Put(uint64(rollupMemorySize))
+
+	// Evaluate rollup
+	removeMetricGroup := !rollupFuncsKeepMetricGroup[name]
+	var tss []*timeseries
+	if iafc != nil {
+		tss, err = evalRollupWithIncrementalAggregate(iafc, rss, rcs, preFunc, sharedTimestamps, removeMetricGroup)
+	} else {
+		tss, err = evalRollupNoIncrementalAggregate(rss, rcs, preFunc, sharedTimestamps, removeMetricGroup)
+	}
+	if err != nil {
+		return nil, err
+	}
+	tss = mergeTimeseries(tssCached, tss, start, ec)
+	if !isPartial {
+		rollupResultCacheV.Put(name, ec, me, iafc, window, tss)
+	}
+	return tss, nil
+}
+
+var (
+	rollupMemoryLimiter     memoryLimiter
+	rollupMemoryLimiterOnce sync.Once
+)
+
+func getRollupMemoryLimiter() *memoryLimiter {
+	rollupMemoryLimiterOnce.Do(func() {
+		rollupMemoryLimiter.MaxSize = uint64(memory.Allowed()) / 4
+	})
+	return &rollupMemoryLimiter
+}
+
+func evalRollupWithIncrementalAggregate(iafc *incrementalAggrFuncContext, rss *netstorage.Results, rcs []*rollupConfig,
+	preFunc func(values []float64, timestamps []int64), sharedTimestamps []int64, removeMetricGroup bool) ([]*timeseries, error) {
+	err := rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+		preFunc(rs.Values, rs.Timestamps)
+		ts := getTimeseries()
+		defer putTimeseries(ts)
+		for _, rc := range rcs {
+			ts.Reset()
+			doRollupForTimeseries(rc, ts, &rs.MetricName, rs.Values, rs.Timestamps, sharedTimestamps, removeMetricGroup)
+			iafc.updateTimeseries(ts, workerID)
+
+			// ts.Timestamps points to sharedTimestamps. Zero it, so it can be re-used.
+			ts.Timestamps = nil
+			ts.denyReuse = false
+		}
+	})
+	if err != nil {
+		return nil, err
+	}
+	tss := iafc.finalizeTimeseries()
+	return tss, nil
+}
+
+func evalRollupNoIncrementalAggregate(rss *netstorage.Results, rcs []*rollupConfig,
+	preFunc func(values []float64, timestamps []int64), sharedTimestamps []int64, removeMetricGroup bool) ([]*timeseries, error) {
+	tss := make([]*timeseries, 0, rss.Len()*len(rcs))
+	var tssLock sync.Mutex
+	err := rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+		preFunc(rs.Values, rs.Timestamps)
+		for _, rc := range rcs {
+			var ts timeseries
+			doRollupForTimeseries(rc, &ts, &rs.MetricName, rs.Values, rs.Timestamps, sharedTimestamps, removeMetricGroup)
+			tssLock.Lock()
+			tss = append(tss, &ts)
+			tssLock.Unlock()
+		}
+	})
+	if err != nil {
+		return nil, err
+	}
+	return tss, nil
+}
+
+func doRollupForTimeseries(rc *rollupConfig, tsDst *timeseries, mnSrc *storage.MetricName, valuesSrc []float64, timestampsSrc []int64,
+	sharedTimestamps []int64, removeMetricGroup bool) {
+	tsDst.MetricName.CopyFrom(mnSrc)
+	if len(rc.TagValue) > 0 {
+		tsDst.MetricName.AddTag("rollup", rc.TagValue)
+	}
+	if removeMetricGroup {
+		tsDst.MetricName.ResetMetricGroup()
+	}
+	tsDst.Values = rc.Do(tsDst.Values[:0], valuesSrc, timestampsSrc)
+	tsDst.Timestamps = sharedTimestamps
+	tsDst.denyReuse = true
+}
+
+func getRollupConfigs(name string, rf rollupFunc, start, end, step, window int64, sharedTimestamps []int64) (func(values []float64, timestamps []int64), []*rollupConfig) {
+	preFunc := func(values []float64, timestamps []int64) {}
+	if rollupFuncsRemoveCounterResets[name] {
+		preFunc = func(values []float64, timestamps []int64) {
+			removeCounterResets(values)
+		}
+	}
+	newRollupConfig := func(rf rollupFunc, tagValue string) *rollupConfig {
+		return &rollupConfig{
+			TagValue:        tagValue,
+			Func:            rf,
+			Start:           start,
+			End:             end,
+			Step:            step,
+			Window:          window,
+			MayAdjustWindow: rollupFuncsMayAdjustWindow[name],
+			Timestamps:      sharedTimestamps,
+		}
+	}
+	appendRollupConfigs := func(dst []*rollupConfig) []*rollupConfig {
+		dst = append(dst, newRollupConfig(rollupMin, "min"))
+		dst = append(dst, newRollupConfig(rollupMax, "max"))
+		dst = append(dst, newRollupConfig(rollupAvg, "avg"))
+		return dst
+	}
+	var rcs []*rollupConfig
+	switch name {
+	case "rollup":
+		rcs = appendRollupConfigs(rcs)
+	case "rollup_rate", "rollup_deriv":
+		preFuncPrev := preFunc
+		preFunc = func(values []float64, timestamps []int64) {
+			preFuncPrev(values, timestamps)
+			derivValues(values, timestamps)
+		}
+		rcs = appendRollupConfigs(rcs)
+	case "rollup_increase", "rollup_delta":
+		preFuncPrev := preFunc
+		preFunc = func(values []float64, timestamps []int64) {
+			preFuncPrev(values, timestamps)
+			deltaValues(values)
+		}
+		rcs = appendRollupConfigs(rcs)
+	case "rollup_candlestick":
+		rcs = append(rcs, newRollupConfig(rollupFirst, "open"))
+		rcs = append(rcs, newRollupConfig(rollupLast, "close"))
+		rcs = append(rcs, newRollupConfig(rollupMin, "low"))
+		rcs = append(rcs, newRollupConfig(rollupMax, "high"))
+	default:
+		rcs = append(rcs, newRollupConfig(rf, ""))
+	}
+	return preFunc, rcs
+}
+
+var bbPool bytesutil.ByteBufferPool
+
+func evalNumber(ec *EvalConfig, n float64) []*timeseries {
+	var ts timeseries
+	ts.denyReuse = true
+	ts.MetricName.AccountID = ec.AuthToken.AccountID
+	ts.MetricName.ProjectID = ec.AuthToken.ProjectID
+	timestamps := ec.getSharedTimestamps()
+	values := make([]float64, len(timestamps))
+	for i := range timestamps {
+		values[i] = n
+	}
+	ts.Values = values
+	ts.Timestamps = timestamps
+	return []*timeseries{&ts}
+}
+
+func evalString(ec *EvalConfig, s string) []*timeseries {
+	rv := evalNumber(ec, nan)
+	rv[0].MetricName.MetricGroup = append(rv[0].MetricName.MetricGroup[:0], s...)
+	return rv
+}
+
+func evalTime(ec *EvalConfig) []*timeseries {
+	rv := evalNumber(ec, nan)
+	timestamps := rv[0].Timestamps
+	values := rv[0].Values
+	for i, ts := range timestamps {
+		values[i] = float64(ts) * 1e-3
+	}
+	return rv
+}
+
+func mulNoOverflow(a, b int64) int64 {
+	if math.MaxInt64/b < a {
+		// Overflow
+		return math.MaxInt64
+	}
+	return a * b
+}

app/vmselect/promql/exec.go

@@ -0,0 +1,248 @@
+package promql
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"sort"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var logSlowQueryDuration = flag.Duration("search.logSlowQueryDuration", 5*time.Second, "Log queries with execution time exceeding this value. Zero disables slow query logging")
+
+var slowQueries = metrics.NewCounter(`vm_slow_queries_total`)
+
+// ExpandWithExprs expands WITH expressions inside q and returns the resulting
+// PromQL without WITH expressions.
+func ExpandWithExprs(q string) (string, error) {
+	e, err := parsePromQLWithCache(q)
+	if err != nil {
+		return "", err
+	}
+	buf := e.AppendString(nil)
+	return string(buf), nil
+}
+
+// Exec executes q for the given ec.
+func Exec(ec *EvalConfig, q string, isFirstPointOnly bool) ([]netstorage.Result, error) {
+	if *logSlowQueryDuration > 0 {
+		startTime := time.Now()
+		defer func() {
+			d := time.Since(startTime)
+			if d >= *logSlowQueryDuration {
+				logger.Infof("slow query according to -search.logSlowQueryDuration=%s: duration=%s, start=%d, end=%d, step=%d, accountID=%d, projectID=%d, query=%q",
+					*logSlowQueryDuration, d, ec.Start/1000, ec.End/1000, ec.Step/1000, ec.AuthToken.AccountID, ec.AuthToken.ProjectID, q)
+				slowQueries.Inc()
+			}
+		}()
+	}
+
+	ec.validate()
+
+	e, err := parsePromQLWithCache(q)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add an additional point to the end. This point is used
+	// in calculating the last value for rate, deriv, increase
+	// and delta funcs.
+	ec.End += ec.Step
+
+	rv, err := evalExpr(ec, e)
+	if err != nil {
+		return nil, err
+	}
+
+	// Remove the additional point at the end.
+	for _, ts := range rv {
+		ts.Values = ts.Values[:len(ts.Values)-1]
+
+		// ts.Timestamps may be shared between timeseries, so truncate it with len(ts.Values) instead of len(ts.Timestamps)-1
+		ts.Timestamps = ts.Timestamps[:len(ts.Values)]
+	}
+	ec.End -= ec.Step
+
+	if isFirstPointOnly {
+		// Remove all the points except the first one from every time series.
+		for _, ts := range rv {
+			ts.Values = ts.Values[:1]
+			ts.Timestamps = ts.Timestamps[:1]
+		}
+	}
+
+	maySort := maySortResults(e, rv)
+	result, err := timeseriesToResult(rv, maySort)
+	if err != nil {
+		return nil, err
+	}
+	return result, err
+}
+
+func maySortResults(e expr, tss []*timeseries) bool {
+	if len(tss) > 100 {
+		// There is no sense in sorting a lot of results
+		return false
+	}
+	fe, ok := e.(*funcExpr)
+	if !ok {
+		return true
+	}
+	switch fe.Name {
+	case "sort", "sort_desc":
+		return false
+	default:
+		return true
+	}
+}
+
+func timeseriesToResult(tss []*timeseries, maySort bool) ([]netstorage.Result, error) {
+	tss = removeNaNs(tss)
+	result := make([]netstorage.Result, len(tss))
+	m := make(map[string]struct{}, len(tss))
+	bb := bbPool.Get()
+	for i, ts := range tss {
+		bb.B = marshalMetricNameSorted(bb.B[:0], &ts.MetricName)
+		if _, ok := m[string(bb.B)]; ok {
+			return nil, fmt.Errorf(`duplicate output timeseries: %s%s`, ts.MetricName.MetricGroup, stringMetricName(&ts.MetricName))
+		}
+		m[string(bb.B)] = struct{}{}
+
+		rs := &result[i]
+		rs.MetricNameMarshaled = append(rs.MetricNameMarshaled[:0], bb.B...)
+		rs.MetricName.CopyFrom(&ts.MetricName)
+		rs.Values = append(rs.Values[:0], ts.Values...)
+		rs.Timestamps = append(rs.Timestamps[:0], ts.Timestamps...)
+	}
+	bbPool.Put(bb)
+
+	if maySort {
+		sort.Slice(result, func(i, j int) bool {
+			return string(result[i].MetricNameMarshaled) < string(result[j].MetricNameMarshaled)
+		})
+	}
+
+	return result, nil
+}
+
+func removeNaNs(tss []*timeseries) []*timeseries {
+	rvs := tss[:0]
+	for _, ts := range tss {
+		allNans := true
+		for _, v := range ts.Values {
+			if !math.IsNaN(v) {
+				allNans = false
+				break
+			}
+		}
+		if allNans {
+			// Skip timeseries with all NaNs.
+			continue
+		}
+		rvs = append(rvs, ts)
+	}
+	for i := len(rvs); i < len(tss); i++ {
+		// Zero unused time series, so GC could reclaim them.
+		tss[i] = nil
+	}
+	return rvs
+}
+
+func parsePromQLWithCache(q string) (expr, error) {
+	pcv := parseCacheV.Get(q)
+	if pcv == nil {
+		e, err := parsePromQL(q)
+		pcv = &parseCacheValue{
+			e:   e,
+			err: err,
+		}
+		parseCacheV.Put(q, pcv)
+	}
+	if pcv.err != nil {
+		return nil, pcv.err
+	}
+	return pcv.e, nil
+}
+
+var parseCacheV = func() *parseCache {
+	pc := &parseCache{
+		m: make(map[string]*parseCacheValue),
+	}
+	metrics.NewGauge(`vm_cache_requests_total{type="promql/parse"}`, func() float64 {
+		return float64(pc.Requests())
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="promql/parse"}`, func() float64 {
+		return float64(pc.Misses())
+	})
+	metrics.NewGauge(`vm_cache_entries{type="promql/parse"}`, func() float64 {
+		return float64(pc.Len())
+	})
+	return pc
+}()
+
+const parseCacheMaxLen = 10e3
+
+type parseCacheValue struct {
+	e   expr
+	err error
+}
+
+type parseCache struct {
+	m  map[string]*parseCacheValue
+	mu sync.RWMutex
+
+	requests uint64
+	misses   uint64
+}
+
+func (pc *parseCache) Requests() uint64 {
+	return atomic.LoadUint64(&pc.requests)
+}
+
+func (pc *parseCache) Misses() uint64 {
+	return atomic.LoadUint64(&pc.misses)
+}
+
+func (pc *parseCache) Len() uint64 {
+	pc.mu.RLock()
+	n := len(pc.m)
+	pc.mu.RUnlock()
+	return uint64(n)
+}
+
+func (pc *parseCache) Get(q string) *parseCacheValue {
+	atomic.AddUint64(&pc.requests, 1)
+
+	pc.mu.RLock()
+	pcv := pc.m[q]
+	pc.mu.RUnlock()
+
+	if pcv == nil {
+		atomic.AddUint64(&pc.misses, 1)
+	}
+	return pcv
+}
+
+func (pc *parseCache) Put(q string, pcv *parseCacheValue) {
+	pc.mu.Lock()
+	overflow := len(pc.m) - parseCacheMaxLen
+	if overflow > 0 {
+		// Remove 10% of items from the cache.
+		overflow = int(float64(len(pc.m)) * 0.1)
+		for k := range pc.m {
+			delete(pc.m, k)
+			overflow--
+			if overflow <= 0 {
+				break
+			}
+		}
+	}
+	pc.m[q] = pcv
+	pc.mu.Unlock()
+}

app/vmselect/promql/lexer.go

@@ -0,0 +1,473 @@
+package promql
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+)
+
+type lexer struct {
+	// Token contains the currently parsed token.
+	// An empty token means EOF.
+	Token string
+
+	prevTokens []string
+	nextTokens []string
+
+	sOrig string
+	sTail string
+
+	err error
+}
+
+func (lex *lexer) Context() string {
+	return fmt.Sprintf("%s%s", lex.Token, lex.sTail)
+}
+
+func (lex *lexer) Init(s string) {
+	lex.Token = ""
+	lex.prevTokens = nil
+	lex.nextTokens = nil
+	lex.err = nil
+
+	lex.sOrig = s
+	lex.sTail = s
+}
+
+func (lex *lexer) Next() error {
+	if lex.err != nil {
+		return lex.err
+	}
+	lex.prevTokens = append(lex.prevTokens, lex.Token)
+	if len(lex.nextTokens) > 0 {
+		lex.Token = lex.nextTokens[len(lex.nextTokens)-1]
+		lex.nextTokens = lex.nextTokens[:len(lex.nextTokens)-1]
+		return nil
+	}
+	token, err := lex.next()
+	if err != nil {
+		lex.err = err
+		return err
+	}
+	lex.Token = token
+	return nil
+}
+
+func (lex *lexer) next() (string, error) {
+again:
+	// Skip whitespace
+	s := lex.sTail
+	i := 0
+	for i < len(s) && isSpaceChar(s[i]) {
+		i++
+	}
+	s = s[i:]
+	lex.sTail = s
+
+	if len(s) == 0 {
+		return "", nil
+	}
+
+	var token string
+	var err error
+	switch s[0] {
+	case '#':
+		// Skip comment till the end of string
+		s = s[1:]
+		n := strings.IndexByte(s, '\n')
+		if n < 0 {
+			return "", nil
+		}
+		lex.sTail = s[n+1:]
+		goto again
+	case '{', '}', '[', ']', '(', ')', ',':
+		token = s[:1]
+		goto tokenFoundLabel
+	}
+	if isIdentPrefix(s) {
+		token = scanIdent(s)
+		goto tokenFoundLabel
+	}
+	if isStringPrefix(s) {
+		token, err = scanString(s)
+		if err != nil {
+			return "", err
+		}
+		goto tokenFoundLabel
+	}
+	if n := scanBinaryOpPrefix(s); n > 0 {
+		token = s[:n]
+		goto tokenFoundLabel
+	}
+	if n := scanTagFilterOpPrefix(s); n > 0 {
+		token = s[:n]
+		goto tokenFoundLabel
+	}
+	if n := scanDuration(s); n > 0 {
+		token = s[:n]
+		goto tokenFoundLabel
+	}
+	if isPositiveNumberPrefix(s) {
+		token, err = scanPositiveNumber(s)
+		if err != nil {
+			return "", err
+		}
+		goto tokenFoundLabel
+	}
+	return "", fmt.Errorf("cannot recognize %q", s)
+
+tokenFoundLabel:
+	lex.sTail = s[len(token):]
+	return token, nil
+}
+
+func scanString(s string) (string, error) {
+	if len(s) < 2 {
+		return "", fmt.Errorf("cannot find end of string in %q", s)
+	}
+
+	quote := s[0]
+	i := 1
+	for {
+		n := strings.IndexByte(s[i:], quote)
+		if n < 0 {
+			return "", fmt.Errorf("cannot find closing quote %ch for the string %q", quote, s)
+		}
+		i += n
+		bs := 0
+		for bs < i && s[i-bs-1] == '\\' {
+			bs++
+		}
+		if bs%2 == 0 {
+			token := s[:i+1]
+			return token, nil
+		}
+		i++
+	}
+}
+
+func scanPositiveNumber(s string) (string, error) {
+	// Scan integer part. It may be empty if fractional part exists.
+	i := 0
+	for i < len(s) && isDecimalChar(s[i]) {
+		i++
+	}
+
+	if i == len(s) {
+		if i == 0 {
+			return "", fmt.Errorf("number cannot be empty")
+		}
+		return s, nil
+	}
+	if s[i] != '.' && s[i] != 'e' && s[i] != 'E' {
+		return s[:i], nil
+	}
+
+	if s[i] == '.' {
+		// Scan fractional part. It cannot be empty.
+		i++
+		j := i
+		for j < len(s) && isDecimalChar(s[j]) {
+			j++
+		}
+		if j == i {
+			return "", fmt.Errorf("missing fractional part in %q", s)
+		}
+		i = j
+		if i == len(s) {
+			return s, nil
+		}
+	}
+
+	if s[i] != 'e' && s[i] != 'E' {
+		return s[:i], nil
+	}
+	i++
+
+	// Scan exponent part.
+	if i == len(s) {
+		return "", fmt.Errorf("missing exponent part in %q", s)
+	}
+	if s[i] == '-' || s[i] == '+' {
+		i++
+	}
+	j := i
+	for j < len(s) && isDecimalChar(s[j]) {
+		j++
+	}
+	if j == i {
+		return "", fmt.Errorf("missing exponent part in %q", s)
+	}
+	return s[:j], nil
+}
+
+func scanIdent(s string) string {
+	i := 0
+	for i < len(s) {
+		if isIdentChar(s[i]) {
+			i++
+			continue
+		}
+		if s[i] != '\\' {
+			break
+		}
+
+		// Do not verify the next char, since it is escaped.
+		i += 2
+		if i > len(s) {
+			i--
+			break
+		}
+	}
+	if i == 0 {
+		logger.Panicf("BUG: scanIdent couldn't find a single ident char; make sure isIdentPrefix called before scanIdent")
+	}
+	return s[:i]
+}
+
+func unescapeIdent(s string) string {
+	n := strings.IndexByte(s, '\\')
+	if n < 0 {
+		return s
+	}
+	dst := make([]byte, 0, len(s))
+	for {
+		dst = append(dst, s[:n]...)
+		s = s[n+1:]
+		if len(s) == 0 {
+			return string(dst)
+		}
+		if s[0] == 'x' && len(s) >= 3 {
+			h1 := fromHex(s[1])
+			h2 := fromHex(s[2])
+			if h1 >= 0 && h2 >= 0 {
+				dst = append(dst, byte((h1<<4)|h2))
+				s = s[3:]
+			} else {
+				dst = append(dst, s[0])
+				s = s[1:]
+			}
+		} else {
+			dst = append(dst, s[0])
+			s = s[1:]
+		}
+		n = strings.IndexByte(s, '\\')
+		if n < 0 {
+			dst = append(dst, s...)
+			return string(dst)
+		}
+	}
+}
+
+func fromHex(ch byte) int {
+	if ch >= '0' && ch <= '9' {
+		return int(ch - '0')
+	}
+	if ch >= 'a' && ch <= 'f' {
+		return int((ch - 'a') + 10)
+	}
+	if ch >= 'A' && ch <= 'F' {
+		return int((ch - 'A') + 10)
+	}
+	return -1
+}
+
+func toHex(n byte) byte {
+	if n < 10 {
+		return '0' + n
+	}
+	return 'a' + (n - 10)
+}
+
+func appendEscapedIdent(dst, s []byte) []byte {
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if isIdentChar(ch) {
+			if i == 0 && !isFirstIdentChar(ch) {
+				// hex-encode the first char
+				dst = append(dst, '\\', 'x', toHex(ch>>4), toHex(ch&0xf))
+			} else {
+				dst = append(dst, ch)
+			}
+		} else if ch >= 0x20 && ch < 0x7f {
+			// Leave ASCII printable chars as is
+			dst = append(dst, '\\', ch)
+		} else {
+			// hex-encode non-printable chars
+			dst = append(dst, '\\', 'x', toHex(ch>>4), toHex(ch&0xf))
+		}
+	}
+	return dst
+}
+
+func (lex *lexer) Prev() {
+	lex.nextTokens = append(lex.nextTokens, lex.Token)
+	lex.Token = lex.prevTokens[len(lex.prevTokens)-1]
+	lex.prevTokens = lex.prevTokens[:len(lex.prevTokens)-1]
+}
+
+func isEOF(s string) bool {
+	return len(s) == 0
+}
+
+func scanTagFilterOpPrefix(s string) int {
+	if len(s) >= 2 {
+		switch s[:2] {
+		case "=~", "!~", "!=":
+			return 2
+		}
+	}
+	if len(s) >= 1 {
+		if s[0] == '=' {
+			return 1
+		}
+	}
+	return -1
+}
+
+func isInfOrNaN(s string) bool {
+	if len(s) != 3 {
+		return false
+	}
+	s = strings.ToLower(s)
+	return s == "inf" || s == "nan"
+}
+
+func isOffset(s string) bool {
+	s = strings.ToLower(s)
+	return s == "offset"
+}
+
+func isStringPrefix(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	switch s[0] {
+	// See https://prometheus.io/docs/prometheus/latest/querying/basics/#string-literals
+	case '"', '\'', '`':
+		return true
+	default:
+		return false
+	}
+}
+
+func isPositiveNumberPrefix(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	if isDecimalChar(s[0]) {
+		return true
+	}
+
+	// Check for .234 numbers
+	if s[0] != '.' || len(s) < 2 {
+		return false
+	}
+	return isDecimalChar(s[1])
+}
+
+func isDuration(s string) bool {
+	n := scanDuration(s)
+	return n == len(s)
+}
+
+// DurationValue returns the duration in milliseconds for the given s
+// and the given step.
+func DurationValue(s string, step int64) (int64, error) {
+	n := scanDuration(s)
+	if n != len(s) {
+		return 0, fmt.Errorf("cannot parse duration %q", s)
+	}
+
+	f, err := strconv.ParseFloat(s[:len(s)-1], 64)
+	if err != nil {
+		return 0, fmt.Errorf("cannot parse duration %q: %s", s, err)
+	}
+
+	var mp float64
+	switch s[len(s)-1] {
+	case 's':
+		mp = 1
+	case 'm':
+		mp = 60
+	case 'h':
+		mp = 60 * 60
+	case 'd':
+		mp = 24 * 60 * 60
+	case 'w':
+		mp = 7 * 24 * 60 * 60
+	case 'y':
+		mp = 365 * 24 * 60 * 60
+	case 'i':
+		mp = float64(step) / 1e3
+	default:
+		return 0, fmt.Errorf("invalid duration suffix in %q", s)
+	}
+	return int64(mp * f * 1e3), nil
+}
+
+func scanDuration(s string) int {
+	i := 0
+	for i < len(s) && isDecimalChar(s[i]) {
+		i++
+	}
+	if i == 0 || i == len(s) {
+		return -1
+	}
+	if s[i] == '.' {
+		j := i
+		i++
+		for i < len(s) && isDecimalChar(s[i]) {
+			i++
+		}
+		if i == j || i == len(s) {
+			return -1
+		}
+	}
+	switch s[i] {
+	case 's', 'm', 'h', 'd', 'w', 'y', 'i':
+		return i + 1
+	default:
+		return -1
+	}
+}
+
+func isDecimalChar(ch byte) bool {
+	return ch >= '0' && ch <= '9'
+}
+
+func isIdentPrefix(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	if s[0] == '\\' {
+		// Assume this is an escape char for the next char.
+		return true
+	}
+	return isFirstIdentChar(s[0])
+}
+
+func isFirstIdentChar(ch byte) bool {
+	if ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' {
+		return true
+	}
+	return ch == '_' || ch == ':'
+}
+
+func isIdentChar(ch byte) bool {
+	if isFirstIdentChar(ch) {
+		return true
+	}
+	return isDecimalChar(ch) || ch == '.'
+}
+
+func isSpaceChar(ch byte) bool {
+	switch ch {
+	case ' ', '\t', '\n', '\v', '\f', '\r':
+		return true
+	default:
+		return false
+	}
+}

app/vmselect/promql/lexer_test.go

@@ -0,0 +1,346 @@
+package promql
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestUnescapeIdent(t *testing.T) {
+	f := func(s, resultExpected string) {
+		t.Helper()
+		result := unescapeIdent(s)
+		if result != resultExpected {
+			t.Fatalf("unexpected result for unescapeIdent(%q); got %q; want %q", s, result, resultExpected)
+		}
+	}
+	f("", "")
+	f("a", "a")
+	f("\\", "")
+	f(`\\`, `\`)
+	f(`\foo\-bar`, `foo-bar`)
+	f(`a\\\\b\"c\d`, `a\\b"cd`)
+	f(`foo.bar:baz_123`, `foo.bar:baz_123`)
+	f(`foo\ bar`, `foo bar`)
+	f(`\x21`, `!`)
+	f(`\xeDfoo\x2Fbar\-\xqw\x`, "\xedfoo\x2fbar-xqwx")
+}
+
+func TestAppendEscapedIdent(t *testing.T) {
+	f := func(s, resultExpected string) {
+		t.Helper()
+		result := appendEscapedIdent(nil, []byte(s))
+		if string(result) != resultExpected {
+			t.Fatalf("unexpected result for appendEscapedIdent(%q); got %q; want %q", s, result, resultExpected)
+		}
+	}
+	f(`a`, `a`)
+	f(`a.b:c_23`, `a.b:c_23`)
+	f(`a b-cd+dd\`, `a\ b\-cd\+dd\\`)
+	f("a\x1E\x20\xee", `a\x1e\ \xee`)
+	f("\x2e\x2e", `\x2e.`)
+}
+
+func TestScanIdent(t *testing.T) {
+	f := func(s, resultExpected string) {
+		t.Helper()
+		result := scanIdent(s)
+		if result != resultExpected {
+			t.Fatalf("unexpected result for scanIdent(%q): got %q; want %q", s, result, resultExpected)
+		}
+	}
+	f("a", "a")
+	f("foo.bar:baz_123", "foo.bar:baz_123")
+	f("a+b", "a")
+	f("foo()", "foo")
+	f(`a\-b+c`, `a\-b`)
+	f(`a\ b\\\ c\`, `a\ b\\\ c\`)
+}
+
+func TestLexerNextPrev(t *testing.T) {
+	var lex lexer
+	lex.Init("foo bar baz")
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpeted error: %s", err)
+	}
+	if lex.Token != "foo" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "foo")
+	}
+
+	// Rewind before the first item.
+	lex.Prev()
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "foo" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "foo")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "bar" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "bar")
+	}
+
+	// Rewind to the first item.
+	lex.Prev()
+	if lex.Token != "foo" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "foo")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "bar" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "bar")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "baz" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "baz")
+	}
+
+	// Go beyond the token stream.
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if !isEOF(lex.Token) {
+		t.Fatalf("expecting eof")
+	}
+	lex.Prev()
+	if lex.Token != "baz" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "baz")
+	}
+
+	// Go multiple times lex.Next() beyond token stream.
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if !isEOF(lex.Token) {
+		t.Fatalf("expecting eof")
+	}
+	if err := lex.Next(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if !isEOF(lex.Token) {
+		t.Fatalf("expecting eof")
+	}
+	lex.Prev()
+	if lex.Token != "" {
+		t.Fatalf("unexpected token got: %q; want %q", lex.Token, "")
+	}
+	if !isEOF(lex.Token) {
+		t.Fatalf("expecting eof")
+	}
+}
+
+func TestLexerSuccess(t *testing.T) {
+	var s string
+	var expectedTokens []string
+
+	// An empty string
+	s = ""
+	expectedTokens = nil
+	testLexerSuccess(t, s, expectedTokens)
+
+	// String with whitespace
+	s = "  \n\t\r "
+	expectedTokens = nil
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Just metric name
+	s = "metric"
+	expectedTokens = []string{"metric"}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Metric name with spec chars
+	s = ":foo.bar_"
+	expectedTokens = []string{":foo.bar_"}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Metric name with window
+	s = "metric[5m]  "
+	expectedTokens = []string{"metric", "[", "5m", "]"}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Metric name with tag filters
+	s = `  metric:12.34{a="foo", b != "bar", c=~ "x.+y", d !~ "zzz"}`
+	expectedTokens = []string{`metric:12.34`, `{`, `a`, `=`, `"foo"`, `,`, `b`, `!=`, `"bar"`, `,`, `c`, `=~`, `"x.+y"`, `,`, `d`, `!~`, `"zzz"`, `}`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Metric name with offset
+	s = `   metric offset 10d   `
+	expectedTokens = []string{`metric`, `offset`, `10d`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Func call
+	s = `sum  (  metric{x="y"  }  [5m] offset 10h)`
+	expectedTokens = []string{`sum`, `(`, `metric`, `{`, `x`, `=`, `"y"`, `}`, `[`, `5m`, `]`, `offset`, `10h`, `)`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Binary op
+	s = `a+b or c % d and e unless f`
+	expectedTokens = []string{`a`, `+`, `b`, `or`, `c`, `%`, `d`, `and`, `e`, `unless`, `f`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Numbers
+	s = `3+1.2-.23+4.5e5-78e-6+1.24e+45-NaN+Inf`
+	expectedTokens = []string{`3`, `+`, `1.2`, `-`, `.23`, `+`, `4.5e5`, `-`, `78e-6`, `+`, `1.24e+45`, `-`, `NaN`, `+`, `Inf`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	s = `12.34`
+	expectedTokens = []string{`12.34`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	// Strings
+	s = `""''` + "``" + `"\\"  '\\'  "\"" '\''"\\\"\\"`
+	expectedTokens = []string{`""`, `''`, "``", `"\\"`, `'\\'`, `"\""`, `'\''`, `"\\\"\\"`}
+	testLexerSuccess(t, s, expectedTokens)
+
+	s = "   `foo\\\\\\`бар`  "
+	expectedTokens = []string{"`foo\\\\\\`бар`"}
+	testLexerSuccess(t, s, expectedTokens)
+
+	s = `# comment # sdf
+		foobar # comment
+		baz
+		# yet another comment`
+	expectedTokens = []string{"foobar", "baz"}
+	testLexerSuccess(t, s, expectedTokens)
+}
+
+func testLexerSuccess(t *testing.T, s string, expectedTokens []string) {
+	t.Helper()
+
+	var lex lexer
+	lex.Init(s)
+
+	var tokens []string
+	for {
+		if err := lex.Next(); err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if isEOF(lex.Token) {
+			break
+		}
+		tokens = append(tokens, lex.Token)
+	}
+	if !reflect.DeepEqual(tokens, expectedTokens) {
+		t.Fatalf("unexected tokens\ngot\n%q\nwant\n%q", tokens, expectedTokens)
+	}
+}
+
+func TestLexerError(t *testing.T) {
+	// Invalid identifier
+	testLexerError(t, ".foo")
+
+	// Incomplete string
+	testLexerError(t, `"foobar`)
+	testLexerError(t, `'`)
+	testLexerError(t, "`")
+
+	// Unrecognized char
+	testLexerError(t, "тест")
+
+	// Invalid numbers
+	testLexerError(t, `.`)
+	testLexerError(t, `123.`)
+	testLexerError(t, `12e`)
+	testLexerError(t, `1.2e`)
+	testLexerError(t, `1.2E+`)
+	testLexerError(t, `1.2E-`)
+}
+
+func testLexerError(t *testing.T, s string) {
+	t.Helper()
+
+	var lex lexer
+	lex.Init(s)
+	for {
+		if err := lex.Next(); err != nil {
+			// Expected error
+			break
+		}
+		if isEOF(lex.Token) {
+			t.Fatalf("expecting error during parse")
+		}
+	}
+
+	// Try calling Next again. It must return error.
+	if err := lex.Next(); err == nil {
+		t.Fatalf("expecting non-nil error")
+	}
+}
+
+func TestDurationSuccess(t *testing.T) {
+	// Integer durations
+	testDurationSuccess(t, "123s", 42, 123*1000)
+	testDurationSuccess(t, "123m", 42, 123*60*1000)
+	testDurationSuccess(t, "1h", 42, 1*60*60*1000)
+	testDurationSuccess(t, "2d", 42, 2*24*60*60*1000)
+	testDurationSuccess(t, "3w", 42, 3*7*24*60*60*1000)
+	testDurationSuccess(t, "4y", 42, 4*365*24*60*60*1000)
+	testDurationSuccess(t, "1i", 42*1000, 42*1000)
+	testDurationSuccess(t, "3i", 42, 3*42)
+
+	// Float durations
+	testDurationSuccess(t, "0.234s", 42, 234)
+	testDurationSuccess(t, "1.5s", 42, 1.5*1000)
+	testDurationSuccess(t, "1.5m", 42, 1.5*60*1000)
+	testDurationSuccess(t, "1.2h", 42, 1.2*60*60*1000)
+	testDurationSuccess(t, "1.1d", 42, 1.1*24*60*60*1000)
+	testDurationSuccess(t, "1.1w", 42, 1.1*7*24*60*60*1000)
+	testDurationSuccess(t, "1.3y", 42, 1.3*365*24*60*60*1000)
+	testDurationSuccess(t, "0.1i", 12340, 0.1*12340)
+}
+
+func testDurationSuccess(t *testing.T, s string, step, expectedD int64) {
+	t.Helper()
+	d, err := DurationValue(s, step)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if d != expectedD {
+		t.Fatalf("unexpected duration; got %d; want %d", d, expectedD)
+	}
+}
+
+func TestDurationError(t *testing.T) {
+	testDurationError(t, "")
+	testDurationError(t, "foo")
+	testDurationError(t, "m")
+	testDurationError(t, "12")
+	testDurationError(t, "1.23")
+	testDurationError(t, "1.23mm")
+	testDurationError(t, "123q")
+}
+
+func testDurationError(t *testing.T, s string) {
+	t.Helper()
+
+	if isDuration(s) {
+		t.Fatalf("unexpected valud duration %q", s)
+	}
+
+	d, err := DurationValue(s, 42)
+	if err == nil {
+		t.Fatalf("expecting non-nil error for duration %q", s)
+	}
+	if d != 0 {
+		t.Fatalf("expecting zero duration; got %d", d)
+	}
+}

app/vmselect/promql/memory_limiter.go

@@ -0,0 +1,33 @@
+package promql
+
+import (
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+)
+
+type memoryLimiter struct {
+	MaxSize uint64
+
+	mu    sync.Mutex
+	usage uint64
+}
+
+func (ml *memoryLimiter) Get(n uint64) bool {
+	ml.mu.Lock()
+	ok := n <= ml.MaxSize && ml.MaxSize-n >= ml.usage
+	if ok {
+		ml.usage += n
+	}
+	ml.mu.Unlock()
+	return ok
+}
+
+func (ml *memoryLimiter) Put(n uint64) {
+	ml.mu.Lock()
+	if n > ml.usage {
+		logger.Panicf("BUG: n=%d cannot exceed %d", n, ml.usage)
+	}
+	ml.usage -= n
+	ml.mu.Unlock()
+}

app/vmselect/promql/memory_limiter_test.go

@@ -0,0 +1,56 @@
+package promql
+
+import (
+	"testing"
+)
+
+func TestMemoryLimiter(t *testing.T) {
+	var ml memoryLimiter
+	ml.MaxSize = 100
+
+	// Allocate memory
+	if !ml.Get(10) {
+		t.Fatalf("cannot get 10 out of %d bytes", ml.MaxSize)
+	}
+	if ml.usage != 10 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 10)
+	}
+	if !ml.Get(20) {
+		t.Fatalf("cannot get 20 out of 90 bytes")
+	}
+	if ml.usage != 30 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 30)
+	}
+	if ml.Get(1000) {
+		t.Fatalf("unexpected get for 1000 bytes")
+	}
+	if ml.usage != 30 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 30)
+	}
+	if ml.Get(71) {
+		t.Fatalf("unexpected get for 71 bytes")
+	}
+	if ml.usage != 30 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 30)
+	}
+	if !ml.Get(70) {
+		t.Fatalf("cannot get 70 bytes")
+	}
+	if ml.usage != 100 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 100)
+	}
+
+	// Return memory back
+	ml.Put(10)
+	ml.Put(70)
+	if ml.usage != 20 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 20)
+	}
+	if !ml.Get(30) {
+		t.Fatalf("cannot get 30 bytes")
+	}
+	ml.Put(50)
+	if ml.usage != 0 {
+		t.Fatalf("unexpected usage; got %d; want %d", ml.usage, 0)
+	}
+}

app/vmselect/promql/parser_test.go

@@ -0,0 +1,716 @@
+package promql
+
+import (
+	"testing"
+)
+
+func TestParseMetricSelectorSuccess(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		tfs, err := ParseMetricSelector(s)
+		if err != nil {
+			t.Fatalf("unexpected error when parsing %q: %s", s, err)
+		}
+		if tfs == nil {
+			t.Fatalf("expecting non-nil tfs when parsing %q", s)
+		}
+	}
+	f("foo")
+	f(":foo")
+	f("  :fo:bar.baz")
+	f(`a{}`)
+	f(`{foo="bar"}`)
+	f(`{:f:oo=~"bar.+"}`)
+	f(`foo {bar != "baz"}`)
+	f(` foo { bar !~ "^ddd(x+)$", a="ss", __name__="sffd"}  `)
+	f(`(foo)`)
+}
+
+func TestParseMetricSelectorError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		tfs, err := ParseMetricSelector(s)
+		if err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+		if tfs != nil {
+			t.Fatalf("expecting nil tfs when parsing %q", s)
+		}
+	}
+	f("")
+	f(`{}`)
+	f(`foo bar`)
+	f(`foo+bar`)
+	f(`sum(bar)`)
+	f(`x{y}`)
+	f(`x{y+z}`)
+	f(`foo[5m]`)
+	f(`foo offset 5m`)
+}
+
+func TestParsePromQLSuccess(t *testing.T) {
+	another := func(s string, sExpected string) {
+		t.Helper()
+
+		e, err := parsePromQL(s)
+		if err != nil {
+			t.Fatalf("unexpected error when parsing %q: %s", s, err)
+		}
+		res := e.AppendString(nil)
+		if string(res) != sExpected {
+			t.Fatalf("unexpected string constructed;\ngot\n%q\nwant\n%q", res, sExpected)
+		}
+	}
+	same := func(s string) {
+		t.Helper()
+		another(s, s)
+	}
+
+	// metricExpr
+	same(`{}`)
+	same(`{}[5m]`)
+	same(`{}[5m:]`)
+	same(`{}[:]`)
+	another(`{}[: ]`, `{}[:]`)
+	same(`{}[:3s]`)
+	another(`{}[: 3s ]`, `{}[:3s]`)
+	same(`{}[5m:3s]`)
+	another(`{}[ 5m : 3s ]`, `{}[5m:3s]`)
+	same(`{} offset 5m`)
+	same(`{}[5m] offset 10y`)
+	same(`{}[5.3m:3.4s] offset 10y`)
+	same(`{}[:3.4s] offset 10y`)
+	same(`{Foo="bAR"}`)
+	same(`{foo="bar"}`)
+	same(`{foo="bar"}[5m]`)
+	same(`{foo="bar"}[5m:]`)
+	same(`{foo="bar"}[5m:3s]`)
+	same(`{foo="bar"} offset 10y`)
+	same(`{foo="bar"}[5m] offset 10y`)
+	same(`{foo="bar"}[5m:3s] offset 10y`)
+	another(`{foo="bar"}[5m] oFFSEt 10y`, `{foo="bar"}[5m] offset 10y`)
+	same("METRIC")
+	same("metric")
+	same("m_e:tri44:_c123")
+	another("-metric", "0 - metric")
+	same(`metric offset 10h`)
+	same("metric[5m]")
+	same("metric[5m:3s]")
+	same("metric[5m] offset 10h")
+	same("metric[5m:3s] offset 10h")
+	same("metric[5i:3i] offset 10i")
+	same(`metric{foo="bar"}`)
+	same(`metric{foo="bar"} offset 10h`)
+	same(`metric{foo!="bar"}[2d]`)
+	same(`metric{foo="bar"}[2d] offset 10h`)
+	same(`metric{foo="bar", b="sdfsdf"}[2d:3h] offset 10h`)
+	another(`  metric  {  foo  = "bar"  }  [  2d ]   offset   10h  `, `metric{foo="bar"}[2d] offset 10h`)
+	// metric name matching keywords
+	same("rate")
+	same("RATE")
+	same("by")
+	same("BY")
+	same("bool")
+	same("BOOL")
+	same("unless")
+	same("UNLESS")
+	same("Ignoring")
+	same("with")
+	same("WITH")
+	same("With")
+	same("alias")
+	same(`alias{foo="bar"}`)
+	same(`aLIas{alias="aa"}`)
+	another(`al\ias`, `alias`)
+	// identifiers with with escape chars
+	same(`foo\ bar`)
+	same(`foo\-bar\{{baz\+bar="aa"}`)
+	another(`\x2E\x2ef\oo{b\xEF\ar="aa"}`, `\x2e.foo{b\xefar="aa"}`)
+	// Duplicate filters
+	same(`foo{__name__="bar"}`)
+	same(`foo{a="b", a="c", __name__="aaa", b="d"}`)
+	// Metric filters ending with comma
+	another(`m{foo="bar",}`, `m{foo="bar"}`)
+	// String concat in tag value
+	another(`m{foo="bar" + "baz"}`, `m{foo="barbaz"}`)
+
+	// Valid regexp
+	same(`foo{bar=~"x"}`)
+	same(`foo{bar=~"^x"}`)
+	same(`foo{bar=~"^x$"}`)
+	same(`foo{bar=~"^(a[bc]|d)$"}`)
+	same(`foo{bar!~"x"}`)
+	same(`foo{bar!~"^x"}`)
+	same(`foo{bar!~"^x$"}`)
+	same(`foo{bar!~"^(a[bc]|d)$"}`)
+
+	// stringExpr
+	same(`""`)
+	same(`"\n\t\r 12:{}[]()44"`)
+	another(`''`, `""`)
+	another("``", `""`)
+	another("   `foo\"b'ar`  ", "\"foo\\\"b'ar\"")
+	another(`  'foo\'bar"BAZ'  `, `"foo'bar\"BAZ"`)
+	// string concat
+	another(`"foo"+'bar'`, `"foobar"`)
+
+	// numberExpr
+	same(`1`)
+	same(`1.23`)
+	same(`0.23`)
+	same(`1.2e+45`)
+	same(`1.2e-45`)
+	same(`-1`)
+	same(`-1.23`)
+	same(`-0.23`)
+	same(`-1.2e+45`)
+	same(`-1.2e-45`)
+	same(`-1.2e-45`)
+	another(`12.5E34`, `1.25e+35`)
+	another(`-.2`, `-0.2`)
+	another(`-.2E-2`, `-0.002`)
+	same(`NaN`)
+	another(`nan`, `NaN`)
+	another(`NAN`, `NaN`)
+	another(`nAN`, `NaN`)
+	another(`Inf`, `+Inf`)
+	another(`INF`, `+Inf`)
+	another(`inf`, `+Inf`)
+	another(`+Inf`, `+Inf`)
+	another(`-Inf`, `-Inf`)
+	another(`-inF`, `-Inf`)
+
+	// binaryOpExpr
+	another(`nan == nan`, `NaN`)
+	another(`nan ==bool nan`, `1`)
+	another(`nan !=bool nan`, `0`)
+	another(`nan !=bool 2`, `1`)
+	another(`2 !=bool nan`, `1`)
+	another(`nan >bool nan`, `0`)
+	another(`nan <bool nan`, `0`)
+	another(`1 ==bool nan`, `0`)
+	another(`NaN !=bool 1`, `1`)
+	another(`inf >=bool 2`, `1`)
+	another(`-1 >bool -inf`, `1`)
+	another(`-1 <bool -inf`, `0`)
+	another(`nan + 2 *3 * inf`, `NaN`)
+	another(`INF - Inf`, `NaN`)
+	another(`Inf + inf`, `+Inf`)
+	another(`1/0`, `+Inf`)
+	another(`0/0`, `NaN`)
+	another(`-m`, `0 - m`)
+	same(`m + ignoring () n[5m]`)
+	another(`M + IGNORING () N[5m]`, `M + ignoring () N[5m]`)
+	same(`m + on (foo) n[5m]`)
+	another(`m + ON (Foo) n[5m]`, `m + on (Foo) n[5m]`)
+	same(`m + ignoring (a, b) n[5m]`)
+	another(`1 or 2`, `1`)
+	another(`1 and 2`, `1`)
+	another(`1 unless 2`, `NaN`)
+	another(`1 default 2`, `1`)
+	another(`1 default NaN`, `1`)
+	another(`NaN default 2`, `2`)
+	another(`1 > 2`, `NaN`)
+	another(`1 > bool 2`, `0`)
+	another(`3 >= 2`, `3`)
+	another(`3 <= bool 2`, `0`)
+	another(`1 + -2 - 3`, `-4`)
+	another(`1 / 0 + 2`, `+Inf`)
+	another(`2 + -1 / 0`, `-Inf`)
+	another(`-1 ^ 0.5`, `NaN`)
+	another(`512.5 - (1 + 3) * (2 ^ 2) ^ 3`, `256.5`)
+	another(`1 == bool 1 != bool 24 < bool 4 > bool -1`, `1`)
+	another(`1 == bOOl 1 != BOOL 24 < Bool 4 > booL -1`, `1`)
+	another(`m1+on(foo)group_left m2`, `m1 + on (foo) group_left () m2`)
+	another(`M1+ON(FOO)GROUP_left M2`, `M1 + on (FOO) group_left () M2`)
+	same(`m1 + on (foo) group_right () m2`)
+	same(`m1 + on (foo, bar) group_right (x, y) m2`)
+	another(`m1 + on (foo, bar,) group_right (x, y,) m2`, `m1 + on (foo, bar) group_right (x, y) m2`)
+	same(`m1 == bool on (foo, bar) group_right (x, y) m2`)
+	another(`5 - 1 + 3 * 2 ^ 2 ^ 3 - 2  OR Metric {Bar= "Baz", aaa!="bb",cc=~"dd" ,zz !~"ff" } `,
+		`770 or Metric{Bar="Baz", aaa!="bb", cc=~"dd", zz!~"ff"}`)
+	same(`"foo" + bar()`)
+	same(`"foo" + bar{x="y"}`)
+	same(`("foo"[3s] + bar{x="y"})[5m:3s] offset 10s`)
+	same(`("foo"[3s] + bar{x="y"})[5i:3i] offset 10i`)
+	same(`bar + "foo" offset 3s`)
+	same(`bar + "foo" offset 3i`)
+	another(`1+2 if 2>3`, `NaN`)
+	another(`1+4 if 2<3`, `5`)
+	another(`2+6 default 3 if 2>3`, `8`)
+	another(`2+6 if 2>3 default NaN`, `NaN`)
+	another(`42 if 3>2 if 2+2<5`, `42`)
+	another(`42 if 3>2 if 2+2>=5`, `NaN`)
+	another(`1+2 ifnot 2>3`, `3`)
+	another(`1+4 ifnot 2<3`, `NaN`)
+	another(`2+6 default 3 ifnot 2>3`, `8`)
+	another(`2+6 ifnot 2>3 default NaN`, `8`)
+	another(`42 if 3>2 ifnot 2+2<5`, `NaN`)
+	another(`42 if 3>2 ifnot 2+2>=5`, `42`)
+
+	// parensExpr
+	another(`(-foo + ((bar) / (baz))) + ((23))`, `((0 - foo) + (bar / baz)) + 23`)
+	another(`(FOO + ((Bar) / (baZ))) + ((23))`, `(FOO + (Bar / baZ)) + 23`)
+	same(`(foo, bar)`)
+	another(`1+(foo, bar,)`, `1 + (foo, bar)`)
+	another(`((foo(bar,baz)), (1+(2)+(3,4)+()))`, `(foo(bar, baz), (3 + (3, 4)) + ())`)
+	same(`()`)
+
+	// funcExpr
+	same(`f()`)
+	another(`f(x,)`, `f(x)`)
+	another(`-f()-Ff()`, `(0 - f()) - Ff()`)
+	same(`F()`)
+	another(`+F()`, `F()`)
+	another(`++F()`, `F()`)
+	another(`--F()`, `0 - (0 - F())`)
+	same(`f(http_server_request)`)
+	same(`f(http_server_request)[4s:5m] offset 10m`)
+	same(`f(http_server_request)[4i:5i] offset 10i`)
+	same(`F(HttpServerRequest)`)
+	same(`f(job, foo)`)
+	same(`F(Job, Foo)`)
+	another(` FOO (bar) + f  (  m  (  ),ff(1 + (  2.5)) ,M[5m ]  , "ff"  )`, `FOO(bar) + f(m(), ff(3.5), M[5m], "ff")`)
+	// funcName matching keywords
+	same(`by(2)`)
+	same(`BY(2)`)
+	same(`or(2)`)
+	same(`OR(2)`)
+	same(`bool(2)`)
+	same(`BOOL(2)`)
+	same(`rate(rate(m))`)
+	same(`rate(rate(m[5m]))`)
+	same(`rate(rate(m[5m])[1h:])`)
+	same(`rate(rate(m[5m])[1h:3s])`)
+	// funcName with escape chars
+	same(`foo\(ba\-r()`)
+
+	// aggrFuncExpr
+	same(`sum(http_server_request) by ()`)
+	same(`sum(http_server_request) by (job)`)
+	same(`sum(http_server_request) without (job, foo)`)
+	another(`sum(x,y,) without (a,b,)`, `sum(x, y) without (a, b)`)
+	another(`sum by () (xx)`, `sum(xx) by ()`)
+	another(`sum by (s) (xx)[5s]`, `(sum(xx) by (s))[5s]`)
+	another(`SUM BY (ZZ, aa) (XX)`, `sum(XX) by (ZZ, aa)`)
+	another(`sum without (a, b) (xx,2+2)`, `sum(xx, 4) without (a, b)`)
+	another(`Sum WIthout (a, B) (XX,2+2)`, `sum(XX, 4) without (a, B)`)
+	same(`sum(a) or sum(b)`)
+	same(`sum(a) by () or sum(b) without (x, y)`)
+	same(`sum(a) + sum(b)`)
+	same(`sum(x) * (1 + sum(a))`)
+
+	// All the above
+	another(`Sum(Ff(M) * M{X=""}[5m] Offset 7m - 123, 35) BY (X, y) * F2("Test")`,
+		`sum((Ff(M) * M{X=""}[5m] offset 7m) - 123, 35) by (X, y) * F2("Test")`)
+	another(`# comment
+		Sum(Ff(M) * M{X=""}[5m] Offset 7m - 123, 35) BY (X, y) # yet another comment
+		* F2("Test")`,
+		`sum((Ff(M) * M{X=""}[5m] offset 7m) - 123, 35) by (X, y) * F2("Test")`)
+
+	// withExpr
+	another(`with () x`, `x`)
+	another(`with (x=1,) x`, `1`)
+	another(`with (x = m offset 5h) x + x`, `m offset 5h + m offset 5h`)
+	another(`with (x = m offset 5i) x + x`, `m offset 5i + m offset 5i`)
+	another(`with (foo = bar{x="x"}) 1`, `1`)
+	another(`with (foo = bar{x="x"}) "x"`, `"x"`)
+	another(`with (f="x") f`, `"x"`)
+	another(`with (foo = bar{x="x"}) x{x="y"}`, `x{x="y"}`)
+	another(`with (foo = bar{x="x"}) 1+1`, `2`)
+	another(`with (foo = bar{x="x"}) f()`, `f()`)
+	another(`with (foo = bar{x="x"}) sum(x)`, `sum(x)`)
+	another(`with (foo = bar{x="x"}) baz{foo="bar"}`, `baz{foo="bar"}`)
+	another(`with (foo = bar) baz`, `baz`)
+	another(`with (foo = bar) foo + foo{a="b"}`, `bar + bar{a="b"}`)
+	another(`with (foo = bar, bar=baz + f()) test`, `test`)
+	another(`with (ct={job="test"}) a{ct} + ct() + f({ct="x"})`, `(a{job="test"} + {job="test"}) + f({ct="x"})`)
+	another(`with (ct={job="test", i="bar"}) ct + {ct, x="d"} + foo{ct, ct} + ctx(1)`,
+		`(({job="test", i="bar"} + {job="test", i="bar", x="d"}) + foo{job="test", i="bar"}) + ctx(1)`)
+	another(`with (foo = bar) {__name__=~"foo"}`, `{__name__=~"foo"}`)
+	another(`with (foo = bar) foo{__name__="foo"}`, `bar`)
+	another(`with (foo = bar) {__name__="foo", x="y"}`, `bar{x="y"}`)
+	another(`with (foo(bar) = {__name__!="bar"}) foo(x)`, `{__name__!="bar"}`)
+	another(`with (foo(bar) = bar{__name__="bar"}) foo(x)`, `x`)
+	another(`with (foo\-bar(baz) = baz + baz) foo\-bar((x,y))`, `(x, y) + (x, y)`)
+	another(`with (foo\-bar(baz) = baz + baz) foo\-bar(x*y)`, `(x * y) + (x * y)`)
+	another(`with (foo\-bar(baz) = baz + baz) foo\-bar(x\*y)`, `x\*y + x\*y`)
+	another(`with (foo\-bar(b\ az) = b\ az + b\ az) foo\-bar(x\*y)`, `x\*y + x\*y`)
+	// override ttf to something new.
+	another(`with (ttf = a) ttf + b`, `a + b`)
+	// override ttf to ru
+	another(`with (ttf = ru(m, n)) ttf`, `(clamp_min(n - clamp_min(m, 0), 0) / clamp_min(n, 0)) * 100`)
+
+	// Verify withExpr recursion and forward reference
+	another(`with (x = x+y, y = x+x) y ^ 2`, `((x + y) + (x + y)) ^ 2`)
+	another(`with (f1(x)=f2(x), f2(x)=f1(x)^2) f1(foobar)`, `f2(foobar)`)
+	another(`with (f1(x)=f2(x), f2(x)=f1(x)^2) f2(foobar)`, `f2(foobar) ^ 2`)
+
+	// Verify withExpr funcs
+	another(`with (x() = y+1) x`, `y + 1`)
+	another(`with (x(foo) = foo+1) x(a)`, `a + 1`)
+	another(`with (x(a, b) = a + b) x(foo, bar)`, `foo + bar`)
+	another(`with (x(a, b) = a + b) x(foo, x(1, 2))`, `foo + 3`)
+	another(`with (x(a) = sum(a) by (b)) x(xx) / x(y)`, `sum(xx) by (b) / sum(y) by (b)`)
+	another(`with (f(a,f,x)=ff(x,f,a)) f(f(x,y,z),1,2)`, `ff(2, 1, ff(z, y, x))`)
+	another(`with (f(x)=1+f(x)) f(foo{bar="baz"})`, `1 + f(foo{bar="baz"})`)
+	another(`with (a=foo, y=bar, f(a)= a+a+y) f(x)`, `(x + x) + bar`)
+	another(`with (f(a, b) = m{a, b}) f({a="x", b="y"}, {c="d"})`, `m{a="x", b="y", c="d"}`)
+	another(`with (xx={a="x"}, f(a, b) = m{a, b}) f({xx, b="y"}, {c="d"})`, `m{a="x", b="y", c="d"}`)
+	another(`with (x() = {b="c"}) foo{x}`, `foo{b="c"}`)
+	another(`with (f(x)=x{foo="bar"} offset 5m) f(m offset 10m)`, `(m{foo="bar"} offset 10m) offset 5m`)
+	another(`with (f(x)=x{foo="bar",bas="a"}[5m]) f(m[10m] offset 3s)`, `(m{foo="bar", bas="a"}[10m] offset 3s)[5m]`)
+	another(`with (f(x)=x{foo="bar"}[5m] offset 10m) f(m{x="y"})`, `m{x="y", foo="bar"}[5m] offset 10m`)
+	another(`with (f(x)=x{foo="bar"}[5m] offset 10m) f({x="y", foo="bar", foo="bar"})`, `{x="y", foo="bar"}[5m] offset 10m`)
+	another(`with (f(m, x)=m{x}[5m] offset 10m) f(foo, {})`, `foo[5m] offset 10m`)
+	another(`with (f(m, x)=m{x, bar="baz"}[5m] offset 10m) f(foo, {})`, `foo{bar="baz"}[5m] offset 10m`)
+	another(`with (f(x)=x[5m] offset 3s) f(foo[3m]+bar)`, `(foo[3m] + bar)[5m] offset 3s`)
+	another(`with (f(x)=x[5m:3s] oFFsEt 1.5m) f(sum(s) by (a,b))`, `(sum(s) by (a, b))[5m:3s] offset 1.5m`)
+	another(`with (x="a", y=x) y+"bc"`, `"abc"`)
+	another(`with (x="a", y="b"+x) "we"+y+"z"+f()`, `"webaz" + f()`)
+	another(`with (f(x) = m{foo=x+"y", bar="y"+x, baz=x} + x) f("qwe")`, `m{foo="qwey", bar="yqwe", baz="qwe"} + "qwe"`)
+	another(`with (f(a)=a) f`, `f`)
+	another(`with (f\q(a)=a) f\q`, `fq`)
+
+	// Verify withExpr for aggr func modifiers
+	another(`with (f(x) = x, y = sum(m) by (f)) y`, `sum(m) by (f)`)
+	another(`with (f(x) = sum(m) by (x)) f(foo)`, `sum(m) by (foo)`)
+	another(`with (f(x) = sum(m) by (x)) f((foo, bar, foo))`, `sum(m) by (foo, bar)`)
+	another(`with (f(x) = sum(m) without (x,y)) f((a, b))`, `sum(m) without (a, b, y)`)
+	another(`with (f(x) = sum(m) without (y,x)) f((a, y))`, `sum(m) without (y, a)`)
+	another(`with (f(x,y) = a + on (x,y) group_left (y,bar) b) f(foo,())`, `a + on (foo) group_left (bar) b`)
+	another(`with (f(x,y) = a + on (x,y) group_left (y,bar) b) f((foo),())`, `a + on (foo) group_left (bar) b`)
+	another(`with (f(x,y) = a + on (x,y) group_left (y,bar) b) f((foo,xx),())`, `a + on (foo, xx) group_left (bar) b`)
+
+	// Verify nested with exprs
+	another(`with (f(x) = (with(x=y) x) + x) f(z)`, `y + z`)
+	another(`with (x=foo) f(a, with (y=x) y)`, `f(a, foo)`)
+	another(`with (x=foo) a * x + (with (y=x) y) / y`, `(a * foo) + (foo / y)`)
+	another(`with (x = with (y = foo) y + x) x/x`, `(foo + x) / (foo + x)`)
+	another(`with (
+		x = {foo="bar"},
+		q = m{x, y="1"},
+		f(x) =
+			with (
+				z(y) = x + y * q
+			)
+			z(foo) / f(x)
+	)
+	f(a)`, `(a + (foo * m{foo="bar", y="1"})) / f(a)`)
+
+	// complex withExpr
+	another(`WITH (
+		treshold = (0.9),
+		commonFilters = {job="cacher", instance=~"1.2.3.4"},
+		hits = rate(cache{type="hit", commonFilters}[5m]),
+		miss = rate(cache{type="miss", commonFilters}[5m]),
+		sumByInstance(arg) = sum(arg) by (instance),
+		hitRatio = sumByInstance(hits) / sumByInstance(hits + miss)
+	)
+	hitRatio < treshold`,
+		`(sum(rate(cache{type="hit", job="cacher", instance=~"1.2.3.4"}[5m])) by (instance) / sum(rate(cache{type="hit", job="cacher", instance=~"1.2.3.4"}[5m]) + rate(cache{type="miss", job="cacher", instance=~"1.2.3.4"}[5m])) by (instance)) < 0.9`)
+	another(`WITH (
+		x2(x) = x^2,
+		f(x, y) = x2(x) + x*y + x2(y)
+	)
+	f(a, 3)
+	`, `((a ^ 2) + (a * 3)) + 9`)
+	another(`WITH (
+		x2(x) = x^2,
+		f(x, y) = x2(x) + x*y + x2(y)
+	)
+	f(2, 3)
+	`, `19`)
+	another(`WITH (
+		commonFilters = {instance="foo"},
+		timeToFuckup(currv, maxv) = (maxv - currv) / rate(currv)
+	)
+	timeToFuckup(diskUsage{commonFilters}, maxDiskSize{commonFilters})`,
+		`(maxDiskSize{instance="foo"} - diskUsage{instance="foo"}) / rate(diskUsage{instance="foo"})`)
+	another(`WITH (
+	       commonFilters = {job="foo", instance="bar"},
+	       sumRate(m, cf) = sum(rate(m{cf})) by (job, instance),
+	       hitRate(hits, misses) = sumRate(hits, commonFilters) / (sumRate(hits, commonFilters) + sumRate(misses, commonFilters))
+	   )
+	   hitRate(cacheHits, cacheMisses)`,
+		`sum(rate(cacheHits{job="foo", instance="bar"})) by (job, instance) / (sum(rate(cacheHits{job="foo", instance="bar"})) by (job, instance) + sum(rate(cacheMisses{job="foo", instance="bar"})) by (job, instance))`)
+	another(`with(y=123,z=5) union(with(y=3,f(x)=x*y) f(2) + f(3), with(x=5,y=2) x*y*z)`, `union(15, 50)`)
+}
+
+func TestParsePromQLError(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+
+		e, err := parsePromQL(s)
+		if err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+		if e != nil {
+			t.Fatalf("expecting nil expr when parsing %q", s)
+		}
+	}
+
+	// an empty string
+	f("")
+	f("  \t\b\r\n  ")
+
+	// invalid metricExpr
+	f(`{__name__="ff"} offset 55`)
+	f(`{__name__="ff"} offset -5m`)
+	f(`foo[55]`)
+	f(`m[-5m]`)
+	f(`{`)
+	f(`foo{`)
+	f(`foo{bar`)
+	f(`foo{bar=`)
+	f(`foo{bar="baz"`)
+	f(`foo{bar="baz",  `)
+	f(`foo{123="23"}`)
+	f(`foo{foo}`)
+	f(`foo{,}`)
+	f(`foo{,foo="bar"}`)
+	f(`foo{foo=}`)
+	f(`foo{foo="ba}`)
+	f(`foo{"foo"="bar"}`)
+	f(`foo{$`)
+	f(`foo{a $`)
+	f(`foo{a="b",$`)
+	f(`foo{a="b"}$`)
+	f(`[`)
+	f(`[]`)
+	f(`f[5m]$`)
+	f(`[5m]`)
+	f(`[5m] offset 4h`)
+	f(`m[5m] offset $`)
+	f(`m[5m] offset 5h $`)
+	f(`m[]`)
+	f(`m[-5m]`)
+	f(`m[5m:`)
+	f(`m[5m:-`)
+	f(`m[5m:-1`)
+	f(`m[5m:-1]`)
+	f(`m[:`)
+	f(`m[:-`)
+	f(`m[:1]`)
+	f(`m[:-1m]`)
+	f(`m[5]`)
+	f(`m[[5m]]`)
+	f(`m[foo]`)
+	f(`m["ff"]`)
+	f(`m[10m`)
+	f(`m[123`)
+	f(`m["ff`)
+	f(`m[(f`)
+	f(`fd}`)
+	f(`]`)
+	f(`m $`)
+	f(`m{,}`)
+	f(`m{x=y}`)
+	f(`m{x=y/5}`)
+	f(`m{x=y+5}`)
+
+	// Invalid regexp
+	f(`foo{bar=~"x["}`)
+	f(`foo{bar=~"x("}`)
+	f(`foo{bar=~"x)"}`)
+	f(`foo{bar!~"x["}`)
+	f(`foo{bar!~"x("}`)
+	f(`foo{bar!~"x)"}`)
+
+	// invalid stringExpr
+	f(`'`)
+	f(`"`)
+	f("`")
+	f(`"foo`)
+	f(`'foo`)
+	f("`foo")
+	f(`"foo\"bar`)
+	f(`'foo\'bar`)
+	f("`foo\\`bar")
+	f(`"" $`)
+	f(`"foo" +`)
+	f(`n{"foo" + m`)
+
+	// invalid numberExpr
+	f(`12.`)
+	f(`1.2e`)
+	f(`23e-`)
+	f(`23E+`)
+	f(`.`)
+	f(`-12.`)
+	f(`-1.2e`)
+	f(`-23e-`)
+	f(`-23E+`)
+	f(`-.`)
+	f(`-1$$`)
+	f(`-$$`)
+	f(`+$$`)
+	f(`23 $$`)
+
+	// invalid binaryOpExpr
+	f(`+`)
+	f(`1 +`)
+	f(`1 + 2.`)
+	f(`3 unless`)
+	f(`23 + on (foo)`)
+	f(`m + on (,) m`)
+	f(`3 * ignoring`)
+	f(`m * on (`)
+	f(`m * on (foo`)
+	f(`m * on (foo,`)
+	f(`m * on (foo,)`)
+	f(`m * on (,foo)`)
+	f(`m * on (,)`)
+	f(`m == bool (bar) baz`)
+	f(`m == bool () baz`)
+	f(`m * by (baz) n`)
+	f(`m + bool group_left m2`)
+	f(`m + on () group_left (`)
+	f(`m + on () group_left (,`)
+	f(`m + on () group_left (,foo`)
+	f(`m + on () group_left (foo,)`)
+	f(`m + on () group_left (,foo)`)
+	f(`m + on () group_left (foo)`)
+	f(`m + on () group_right (foo) (m`)
+	f(`m or ignoring () group_left () n`)
+	f(`1 + bool 2`)
+	f(`m % bool n`)
+	f(`m * bool baz`)
+	f(`M * BOoL BaZ`)
+	f(`foo unless ignoring (bar) group_left xxx`)
+	f(`foo or bool bar`)
+	f(`foo == bool $$`)
+	f(`"foo" + bar`)
+
+	// invalid parensExpr
+	f(`(`)
+	f(`($`)
+	f(`(+`)
+	f(`(1`)
+	f(`(m+`)
+	f(`1)`)
+	f(`(,)`)
+	f(`(1)$`)
+
+	// invalid funcExpr
+	f(`f $`)
+	f(`f($)`)
+	f(`f[`)
+	f(`f()$`)
+	f(`f(`)
+	f(`f(foo`)
+	f(`f(f,`)
+	f(`f(,`)
+	f(`f(,)`)
+	f(`f(,foo)`)
+	f(`f(,foo`)
+	f(`f(foo,$`)
+	f(`f() by (a)`)
+	f(`f without (x) (y)`)
+	f(`f() foo (a)`)
+	f(`f bar (x) (b)`)
+	f(`f bar (x)`)
+
+	// invalid aggrFuncExpr
+	f(`sum(`)
+	f(`sum $`)
+	f(`sum [`)
+	f(`sum($)`)
+	f(`sum()$`)
+	f(`sum(foo) ba`)
+	f(`sum(foo) ba()`)
+	f(`sum(foo) by`)
+	f(`sum(foo) without x`)
+	f(`sum(foo) aaa`)
+	f(`sum(foo) aaa x`)
+	f(`sum() by $`)
+	f(`sum() by (`)
+	f(`sum() by ($`)
+	f(`sum() by (a`)
+	f(`sum() by (a $`)
+	f(`sum() by (a ]`)
+	f(`sum() by (a)$`)
+	f(`sum() by (,`)
+	f(`sum() by (a,$`)
+	f(`sum() by (,)`)
+	f(`sum() by (,a`)
+	f(`sum() by (,a)`)
+	f(`sum() on (b)`)
+	f(`sum() bool`)
+	f(`sum() group_left`)
+	f(`sum() group_right(x)`)
+	f(`sum ba`)
+	f(`sum ba ()`)
+	f(`sum by (`)
+	f(`sum by (a`)
+	f(`sum by (,`)
+	f(`sum by (,)`)
+	f(`sum by (,a`)
+	f(`sum by (,a)`)
+	f(`sum by (a)`)
+	f(`sum by (a) (`)
+	f(`sum by (a) [`)
+	f(`sum by (a) {`)
+	f(`sum by (a) (b`)
+	f(`sum by (a) (b,`)
+	f(`sum by (a) (,)`)
+	f(`avg by (a) (,b)`)
+	f(`sum by (x) (y) by (z)`)
+	f(`sum(m) by (1)`)
+
+	// invalid withExpr
+	f(`with $`)
+	f(`with a`)
+	f(`with a=b c`)
+	f(`with (`)
+	f(`with (x=b)$`)
+	f(`with ($`)
+	f(`with (foo`)
+	f(`with (foo $`)
+	f(`with (x y`)
+	f(`with (x =`)
+	f(`with (x = $`)
+	f(`with (x= y`)
+	f(`with (x= y $`)
+	f(`with (x= y)`)
+	f(`with (x=(`)
+	f(`with (x=[)`)
+	f(`with (x=() x)`)
+	f(`with ($$)`)
+	f(`with (x $$`)
+	f(`with (x = $$)`)
+	f(`with (x = foo) bar{x}`)
+	f(`with (x = {foo="bar"}[5m]) bar{x}`)
+	f(`with (x = {foo="bar"} offset 5m) bar{x}`)
+	f(`with (x = a, x = b) c`)
+	f(`with (x(a, a) = b) c`)
+	f(`with (x=m{f="x"}) foo{x}`)
+	f(`with (sum = x) y`)
+	f(`with (rate(a) = b) c`)
+	f(`with (clamp_min=x) y`)
+	f(`with (f()`)
+	f(`with (a=b c=d) e`)
+	f(`with (f(x)=x^2) m{x}`)
+	f(`with (f(x)=ff()) m{x}`)
+	f(`with (f(x`)
+	f(`with (x=m) a{x} + b`)
+	f(`with (x=m) b + a{x}`)
+	f(`with (x=m) f(b, a{x})`)
+	f(`with (x=m) sum(a{x})`)
+	f(`with (x=m) (a{x})`)
+	f(`with (f(a)=a) f(1, 2)`)
+	f(`with (f(x)=x{foo="bar"}) f(1)`)
+	f(`with (f(x)=x{foo="bar"}) f(m + n)`)
+	f(`with (f = with`)
+	f(`with (,)`)
+	f(`with (1) 2`)
+	f(`with (f(1)=2) 3`)
+	f(`with (f(,)=x) x`)
+	f(`with (x(a) = {b="c"}) foo{x}`)
+	f(`with (f(x) = m{foo=xx}) f("qwe")`)
+	f(`a + with(f(x)=x) f(1,2)`)
+	f(`with (f(x) = sum(m) by (x)) f({foo="bar"})`)
+	f(`with (f(x) = sum(m) by (x)) f((xx(), {foo="bar"}))`)
+	f(`with (f(x) = m + on (x) n) f(xx())`)
+	f(`with (f(x) = m + on (a) group_right (x) n) f(xx())`)
+}

app/vmselect/promql/regexp_cache.go

@@ -0,0 +1,105 @@
+package promql
+
+import (
+	"regexp"
+	"sync"
+	"sync/atomic"
+
+	"github.com/VictoriaMetrics/metrics"
+)
+
+func compileRegexpAnchored(re string) (*regexp.Regexp, error) {
+	reAnchored := "^(?:" + re + ")$"
+	return compileRegexp(reAnchored)
+}
+
+func compileRegexp(re string) (*regexp.Regexp, error) {
+	rcv := regexpCacheV.Get(re)
+	if rcv != nil {
+		return rcv.r, rcv.err
+	}
+	r, err := regexp.Compile(re)
+	rcv = &regexpCacheValue{
+		r:   r,
+		err: err,
+	}
+	regexpCacheV.Put(re, rcv)
+	return rcv.r, rcv.err
+}
+
+var regexpCacheV = func() *regexpCache {
+	rc := &regexpCache{
+		m: make(map[string]*regexpCacheValue),
+	}
+	metrics.NewGauge(`vm_cache_requests_total{type="promql/regexp"}`, func() float64 {
+		return float64(rc.Requests())
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="promql/regexp"}`, func() float64 {
+		return float64(rc.Misses())
+	})
+	metrics.NewGauge(`vm_cache_entries{type="promql/regexp"}`, func() float64 {
+		return float64(rc.Len())
+	})
+	return rc
+}()
+
+const regexpCacheMaxLen = 10e3
+
+type regexpCacheValue struct {
+	r   *regexp.Regexp
+	err error
+}
+
+type regexpCache struct {
+	m  map[string]*regexpCacheValue
+	mu sync.RWMutex
+
+	requests uint64
+	misses   uint64
+}
+
+func (rc *regexpCache) Requests() uint64 {
+	return atomic.LoadUint64(&rc.requests)
+}
+
+func (rc *regexpCache) Misses() uint64 {
+	return atomic.LoadUint64(&rc.misses)
+}
+
+func (rc *regexpCache) Len() uint64 {
+	rc.mu.RLock()
+	n := len(rc.m)
+	rc.mu.RUnlock()
+	return uint64(n)
+}
+
+func (rc *regexpCache) Get(regexp string) *regexpCacheValue {
+	atomic.AddUint64(&rc.requests, 1)
+
+	rc.mu.RLock()
+	rcv := rc.m[regexp]
+	rc.mu.RUnlock()
+
+	if rcv == nil {
+		atomic.AddUint64(&rc.misses, 1)
+	}
+	return rcv
+}
+
+func (rc *regexpCache) Put(regexp string, rcv *regexpCacheValue) {
+	rc.mu.Lock()
+	overflow := len(rc.m) - regexpCacheMaxLen
+	if overflow > 0 {
+		// Remove 10% of items from the cache.
+		overflow = int(float64(len(rc.m)) * 0.1)
+		for k := range rc.m {
+			delete(rc.m, k)
+			overflow--
+			if overflow <= 0 {
+				break
+			}
+		}
+	}
+	rc.m[regexp] = rcv
+	rc.mu.Unlock()
+}

app/vmselect/promql/rollup.go

@@ -0,0 +1,978 @@
+package promql
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/decimal"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/valyala/histogram"
+)
+
+var rollupFuncs = map[string]newRollupFunc{
+	"default_rollup": newRollupFuncOneArg(rollupDefault), // default rollup func
+
+	// Standard rollup funcs from PromQL.
+	// See funcs accepting range-vector on https://prometheus.io/docs/prometheus/latest/querying/functions/ .
+	"changes":            newRollupFuncOneArg(rollupChanges),
+	"delta":              newRollupFuncOneArg(rollupDelta),
+	"deriv":              newRollupFuncOneArg(rollupDerivSlow),
+	"deriv_fast":         newRollupFuncOneArg(rollupDerivFast),
+	"holt_winters":       newRollupHoltWinters,
+	"idelta":             newRollupFuncOneArg(rollupIdelta),
+	"increase":           newRollupFuncOneArg(rollupDelta),  // + rollupFuncsRemoveCounterResets
+	"irate":              newRollupFuncOneArg(rollupIderiv), // + rollupFuncsRemoveCounterResets
+	"predict_linear":     newRollupPredictLinear,
+	"rate":               newRollupFuncOneArg(rollupDerivFast), // + rollupFuncsRemoveCounterResets
+	"resets":             newRollupFuncOneArg(rollupResets),
+	"avg_over_time":      newRollupFuncOneArg(rollupAvg),
+	"min_over_time":      newRollupFuncOneArg(rollupMin),
+	"max_over_time":      newRollupFuncOneArg(rollupMax),
+	"sum_over_time":      newRollupFuncOneArg(rollupSum),
+	"count_over_time":    newRollupFuncOneArg(rollupCount),
+	"quantile_over_time": newRollupQuantile,
+	"stddev_over_time":   newRollupFuncOneArg(rollupStddev),
+	"stdvar_over_time":   newRollupFuncOneArg(rollupStdvar),
+
+	// Additional rollup funcs.
+	"sum2_over_time":     newRollupFuncOneArg(rollupSum2),
+	"geomean_over_time":  newRollupFuncOneArg(rollupGeomean),
+	"first_over_time":    newRollupFuncOneArg(rollupFirst),
+	"last_over_time":     newRollupFuncOneArg(rollupLast),
+	"distinct_over_time": newRollupFuncOneArg(rollupDistinct),
+	"integrate":          newRollupFuncOneArg(rollupIntegrate),
+	"ideriv":             newRollupFuncOneArg(rollupIderiv),
+	"lifetime":           newRollupFuncOneArg(rollupLifetime),
+	"scrape_interval":    newRollupFuncOneArg(rollupScrapeInterval),
+	"rollup":             newRollupFuncOneArg(rollupFake),
+	"rollup_rate":        newRollupFuncOneArg(rollupFake), // + rollupFuncsRemoveCounterResets
+	"rollup_deriv":       newRollupFuncOneArg(rollupFake),
+	"rollup_delta":       newRollupFuncOneArg(rollupFake),
+	"rollup_increase":    newRollupFuncOneArg(rollupFake), // + rollupFuncsRemoveCounterResets
+	"rollup_candlestick": newRollupFuncOneArg(rollupFake),
+}
+
+var rollupFuncsMayAdjustWindow = map[string]bool{
+	"default_rollup":  true,
+	"first_over_time": true,
+	"last_over_time":  true,
+	"deriv":           true,
+	"deriv_fast":      true,
+	"irate":           true,
+	"rate":            true,
+	"lifetime":        true,
+	"scrape_interval": true,
+}
+
+var rollupFuncsRemoveCounterResets = map[string]bool{
+	"increase":        true,
+	"irate":           true,
+	"rate":            true,
+	"rollup_rate":     true,
+	"rollup_increase": true,
+}
+
+var rollupFuncsKeepMetricGroup = map[string]bool{
+	"default_rollup":     true,
+	"avg_over_time":      true,
+	"min_over_time":      true,
+	"max_over_time":      true,
+	"quantile_over_time": true,
+	"rollup":             true,
+	"geomean_over_time":  true,
+}
+
+func getRollupArgIdx(funcName string) int {
+	funcName = strings.ToLower(funcName)
+	if rollupFuncs[funcName] == nil {
+		logger.Panicf("BUG: getRollupArgIdx is called for non-rollup func %q", funcName)
+	}
+	if funcName == "quantile_over_time" {
+		return 1
+	}
+	return 0
+}
+
+func getRollupFunc(funcName string) newRollupFunc {
+	funcName = strings.ToLower(funcName)
+	return rollupFuncs[funcName]
+}
+
+func isRollupFunc(funcName string) bool {
+	return getRollupFunc(funcName) != nil
+}
+
+type rollupFuncArg struct {
+	prevValue     float64
+	prevTimestamp int64
+	values        []float64
+	timestamps    []int64
+
+	idx  int
+	step int64
+}
+
+func (rfa *rollupFuncArg) reset() {
+	rfa.prevValue = 0
+	rfa.prevTimestamp = 0
+	rfa.values = nil
+	rfa.timestamps = nil
+	rfa.idx = 0
+	rfa.step = 0
+}
+
+// rollupFunc must return rollup value for the given rfa.
+//
+// prevValue may be nan, values and timestamps may be empty.
+type rollupFunc func(rfa *rollupFuncArg) float64
+
+type rollupConfig struct {
+	// This tag value must be added to "rollup" tag if non-empty.
+	TagValue string
+
+	Func   rollupFunc
+	Start  int64
+	End    int64
+	Step   int64
+	Window int64
+
+	// Whether window may be adjusted to 2 x interval between data points.
+	// This is needed for functions which have dt in the denominator
+	// such as rate, deriv, etc.
+	// Without the adjustement their value would jump in unexpected directions
+	// when using window smaller than 2 x scrape_interval.
+	MayAdjustWindow bool
+
+	Timestamps []int64
+}
+
+var (
+	nan = math.NaN()
+	inf = math.Inf(1)
+)
+
+// The maximum interval without previous rows.
+const maxSilenceInterval = 5 * 60 * 1000
+
+// Do calculates rollups for the given timestamps and values, appends
+// them to dstValues and returns results.
+//
+// rc.Timestamps are used as timestamps for dstValues.
+//
+// timestamps must cover time range [rc.Start - rc.Window - maxSilenceInterval ... rc.End + rc.Step].
+//
+// Cannot be called from concurrent goroutines.
+func (rc *rollupConfig) Do(dstValues []float64, values []float64, timestamps []int64) []float64 {
+	// Sanity checks.
+	if rc.Step <= 0 {
+		logger.Panicf("BUG: Step must be bigger than 0; got %d", rc.Step)
+	}
+	if rc.Start > rc.End {
+		logger.Panicf("BUG: Start cannot exceed End; got %d vs %d", rc.Start, rc.End)
+	}
+	if rc.Window < 0 {
+		logger.Panicf("BUG: Window must be non-negative; got %d", rc.Window)
+	}
+	if err := ValidateMaxPointsPerTimeseries(rc.Start, rc.End, rc.Step); err != nil {
+		logger.Panicf("BUG: %s; this must be validated before the call to rollupConfig.Do", err)
+	}
+
+	// Extend dstValues in order to remove mallocs below.
+	dstValues = decimal.ExtendFloat64sCapacity(dstValues, len(rc.Timestamps))
+
+	maxPrevInterval := getMaxPrevInterval(timestamps)
+	window := rc.Window
+	if window <= 0 {
+		window = rc.Step
+	}
+	if rc.MayAdjustWindow && window < maxPrevInterval {
+		window = maxPrevInterval
+	}
+	rfa := getRollupFuncArg()
+	rfa.idx = 0
+	rfa.step = rc.Step
+
+	i := 0
+	j := 0
+	ni := 0
+	nj := 0
+	for _, tEnd := range rc.Timestamps {
+		tStart := tEnd - window
+		ni = seekFirstTimestampIdxAfter(timestamps[i:], tStart, ni)
+		i += ni
+		if j < i {
+			j = i
+		}
+		nj = seekFirstTimestampIdxAfter(timestamps[j:], tEnd, nj)
+		j += nj
+
+		rfa.prevValue = nan
+		rfa.prevTimestamp = tStart - maxPrevInterval
+		if i < len(timestamps) && i > 0 && timestamps[i-1] > rfa.prevTimestamp {
+			rfa.prevValue = values[i-1]
+			rfa.prevTimestamp = timestamps[i-1]
+		}
+
+		rfa.values = values[i:j]
+		rfa.timestamps = timestamps[i:j]
+		value := rc.Func(rfa)
+		rfa.idx++
+		dstValues = append(dstValues, value)
+	}
+	putRollupFuncArg(rfa)
+
+	return dstValues
+}
+
+func seekFirstTimestampIdxAfter(timestamps []int64, seekTimestamp int64, nHint int) int {
+	if len(timestamps) == 0 || timestamps[0] > seekTimestamp {
+		return 0
+	}
+	startIdx := nHint - 2
+	if startIdx < 0 {
+		startIdx = 0
+	}
+	if startIdx >= len(timestamps) {
+		startIdx = len(timestamps) - 1
+	}
+	endIdx := nHint + 2
+	if endIdx > len(timestamps) {
+		endIdx = len(timestamps)
+	}
+	if startIdx > 0 && timestamps[startIdx] <= seekTimestamp {
+		timestamps = timestamps[startIdx:]
+		endIdx -= startIdx
+	} else {
+		startIdx = 0
+	}
+	if endIdx < len(timestamps) && timestamps[endIdx] > seekTimestamp {
+		timestamps = timestamps[:endIdx]
+	}
+	if len(timestamps) < 16 {
+		// Fast path: the number of timestamps to search is small, so scan them all.
+		for i, timestamp := range timestamps {
+			if timestamp > seekTimestamp {
+				return startIdx + i
+			}
+		}
+		return startIdx + len(timestamps)
+	}
+	// Slow path: too big len(timestamps), so use binary search.
+	i := sort.Search(len(timestamps), func(n int) bool {
+		return n >= 0 && n < len(timestamps) && timestamps[n] > seekTimestamp
+	})
+	return startIdx + i
+}
+
+func getMaxPrevInterval(timestamps []int64) int64 {
+	if len(timestamps) < 2 {
+		return int64(maxSilenceInterval)
+	}
+	d := (timestamps[len(timestamps)-1] - timestamps[0]) / int64(len(timestamps)-1)
+	if d <= 0 {
+		return int64(maxSilenceInterval)
+	}
+	// Increase d more for smaller scrape intervals in order to hide possible gaps
+	// when high jitter is present.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/139 .
+	if d <= 2*1000 {
+		return d + 4*d
+	}
+	if d <= 4*1000 {
+		return d + 2*d
+	}
+	if d <= 8*1000 {
+		return d + d
+	}
+	if d <= 16*1000 {
+		return d + d/2
+	}
+	if d <= 32*1000 {
+		return d + d/4
+	}
+	return d + d/8
+}
+
+func removeCounterResets(values []float64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	var correction float64
+	prevValue := values[0]
+	for i, v := range values {
+		d := v - prevValue
+		if d < 0 {
+			if (-d * 8) < prevValue {
+				// This is likely jitter from `Prometheus HA pairs`.
+				// Just substitute v with prevValue.
+				v = prevValue
+			} else {
+				correction += prevValue
+			}
+		}
+		prevValue = v
+		values[i] = v + correction
+	}
+}
+
+func deltaValues(values []float64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	prevDelta := float64(0)
+	prevValue := values[0]
+	for i, v := range values[1:] {
+		prevDelta = v - prevValue
+		values[i] = prevDelta
+		prevValue = v
+	}
+	values[len(values)-1] = prevDelta
+}
+
+func derivValues(values []float64, timestamps []int64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	prevDeriv := float64(0)
+	prevValue := values[0]
+	prevTs := timestamps[0]
+	for i, v := range values[1:] {
+		ts := timestamps[i+1]
+		if ts == prevTs {
+			// Use the previous value for duplicate timestamps.
+			values[i] = prevDeriv
+			continue
+		}
+		dt := float64(ts-prevTs) * 1e-3
+		prevDeriv = (v - prevValue) / dt
+		values[i] = prevDeriv
+		prevValue = v
+		prevTs = ts
+	}
+	values[len(values)-1] = prevDeriv
+}
+
+type newRollupFunc func(args []interface{}) (rollupFunc, error)
+
+func newRollupFuncOneArg(rf rollupFunc) newRollupFunc {
+	return func(args []interface{}) (rollupFunc, error) {
+		if err := expectRollupArgsNum(args, 1); err != nil {
+			return nil, err
+		}
+		return rf, nil
+	}
+}
+
+func newRollupHoltWinters(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 3); err != nil {
+		return nil, err
+	}
+	sfs, err := getScalar(args[1], 1)
+	if err != nil {
+		return nil, err
+	}
+	tfs, err := getScalar(args[2], 2)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		// There is no need in handling NaNs here, since they must be cleaned up
+		// before calling rollup funcs.
+		values := rfa.values
+		if len(values) == 0 {
+			return rfa.prevValue
+		}
+		sf := sfs[rfa.idx]
+		if sf <= 0 || sf >= 1 {
+			return nan
+		}
+		tf := tfs[rfa.idx]
+		if tf <= 0 || tf >= 1 {
+			return nan
+		}
+
+		// See https://en.wikipedia.org/wiki/Exponential_smoothing#Double_exponential_smoothing .
+		// TODO: determine whether this shit really works.
+		s0 := rfa.prevValue
+		if math.IsNaN(s0) {
+			s0 = values[0]
+			values = values[1:]
+			if len(values) == 0 {
+				return s0
+			}
+		}
+		b0 := values[0] - s0
+		for _, v := range values {
+			s1 := sf*v + (1-sf)*(s0+b0)
+			b1 := tf*(s1-s0) + (1-tf)*b0
+			s0 = s1
+			b0 = b1
+		}
+		return s0
+	}
+	return rf, nil
+}
+
+func newRollupPredictLinear(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	secs, err := getScalar(args[1], 1)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		v, k := linearRegression(rfa)
+		if math.IsNaN(v) {
+			return nan
+		}
+		sec := secs[rfa.idx]
+		return v + k*sec
+	}
+	return rf, nil
+}
+
+func linearRegression(rfa *rollupFuncArg) (float64, float64) {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	timestamps := rfa.timestamps
+	if len(values) == 0 {
+		return rfa.prevValue, 0
+	}
+
+	// See https://en.wikipedia.org/wiki/Simple_linear_regression#Numerical_example
+	tFirst := rfa.prevTimestamp
+	vSum := rfa.prevValue
+	tSum := float64(0)
+	tvSum := float64(0)
+	ttSum := float64(0)
+	n := 1.0
+	if math.IsNaN(rfa.prevValue) {
+		tFirst = timestamps[0]
+		vSum = 0
+		n = 0
+	}
+	for i, v := range values {
+		dt := float64(timestamps[i]-tFirst) * 1e-3
+		vSum += v
+		tSum += dt
+		tvSum += dt * v
+		ttSum += dt * dt
+	}
+	n += float64(len(values))
+	if n == 1 {
+		return vSum, 0
+	}
+	k := (n*tvSum - tSum*vSum) / (n*ttSum - tSum*tSum)
+	v := (vSum - k*tSum) / n
+	// Adjust v to the last timestamp on the given time range.
+	v += k * (float64(timestamps[len(timestamps)-1]-tFirst) * 1e-3)
+	return v, k
+}
+
+func newRollupQuantile(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	phis, err := getScalar(args[0], 0)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		// There is no need in handling NaNs here, since they must be cleaned up
+		// before calling rollup funcs.
+		values := rfa.values
+		if len(values) == 0 {
+			return rfa.prevValue
+		}
+		if len(values) == 1 {
+			// Fast path - only a single value.
+			return values[0]
+		}
+		hf := histogram.GetFast()
+		for _, v := range values {
+			hf.Update(v)
+		}
+		phi := phis[rfa.idx]
+		qv := hf.Quantile(phi)
+		histogram.PutFast(hf)
+		return qv
+	}
+	return rf, nil
+}
+
+func rollupAvg(rfa *rollupFuncArg) float64 {
+	// Do not use `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation,
+	// since it is slower and has no significant benefits in precision.
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	var sum float64
+	for _, v := range values {
+		sum += v
+	}
+	return sum / float64(len(values))
+}
+
+func rollupMin(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	minValue := values[0]
+	for _, v := range values {
+		if v < minValue {
+			minValue = v
+		}
+	}
+	return minValue
+}
+
+func rollupMax(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	maxValue := values[0]
+	for _, v := range values {
+		if v > maxValue {
+			maxValue = v
+		}
+	}
+	return maxValue
+}
+
+func rollupSum(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	var sum float64
+	for _, v := range values {
+		sum += v
+	}
+	return sum
+}
+
+func rollupSum2(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue * rfa.prevValue
+	}
+	var sum2 float64
+	for _, v := range values {
+		sum2 += v * v
+	}
+	return sum2
+}
+
+func rollupGeomean(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	p := 1.0
+	for _, v := range values {
+		p *= v
+	}
+	return math.Pow(p, 1/float64(len(values)))
+}
+
+func rollupCount(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	return float64(len(values))
+}
+
+func rollupStddev(rfa *rollupFuncArg) float64 {
+	stdvar := rollupStdvar(rfa)
+	return math.Sqrt(stdvar)
+}
+
+func rollupStdvar(rfa *rollupFuncArg) float64 {
+	// See `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	if len(values) == 1 {
+		// Fast path.
+		return values[0]
+	}
+	var avg float64
+	var count float64
+	var q float64
+	for _, v := range values {
+		count++
+		avgNew := avg + (v-avg)/count
+		q += (v - avg) * (v - avgNew)
+		avg = avgNew
+	}
+	return q / count
+}
+
+func rollupDelta(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	prevValue := rfa.prevValue
+	if math.IsNaN(prevValue) {
+		if len(values) == 0 {
+			return nan
+		}
+		if len(values) == 1 {
+			// Assume that the previous non-existing value was 0.
+			return values[0]
+		}
+		prevValue = values[0]
+		values = values[1:]
+	}
+	if len(values) == 0 {
+		// Assume that the value didn't change on the given interval.
+		return 0
+	}
+	return values[len(values)-1] - prevValue
+}
+
+func rollupIdelta(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		// Assume that the value didn't change on the given interval.
+		return 0
+	}
+	lastValue := values[len(values)-1]
+	values = values[:len(values)-1]
+	if len(values) == 0 {
+		prevValue := rfa.prevValue
+		if math.IsNaN(prevValue) {
+			// Assume that the previous non-existing value was 0.
+			return lastValue
+		}
+		return lastValue - prevValue
+	}
+	return lastValue - values[len(values)-1]
+}
+
+func rollupDerivSlow(rfa *rollupFuncArg) float64 {
+	// Use linear regression like Prometheus does.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/73
+	_, k := linearRegression(rfa)
+	return k
+}
+
+func rollupDerivFast(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	timestamps := rfa.timestamps
+	prevValue := rfa.prevValue
+	prevTimestamp := rfa.prevTimestamp
+	if math.IsNaN(prevValue) {
+		if len(values) < 2 {
+			// It is impossible to calculate derivative on 0 or 1 values.
+			return nan
+		}
+		prevValue = values[0]
+		prevTimestamp = timestamps[0]
+		values = values[1:]
+		timestamps = timestamps[1:]
+	}
+	if len(values) == 0 {
+		// Assume that the value didn't change on the given interval.
+		return 0
+	}
+	vEnd := values[len(values)-1]
+	tEnd := timestamps[len(timestamps)-1]
+	dv := vEnd - prevValue
+	dt := float64(tEnd-prevTimestamp) * 1e-3
+	return dv / dt
+}
+
+func rollupIderiv(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	timestamps := rfa.timestamps
+	if len(values) < 2 {
+		if len(values) == 0 || math.IsNaN(rfa.prevValue) {
+			// It is impossible to calculate derivative on 0 or 1 values.
+			return nan
+		}
+		return (values[0] - rfa.prevValue) / (float64(timestamps[0]-rfa.prevTimestamp) * 1e-3)
+	}
+	vEnd := values[len(values)-1]
+	tEnd := timestamps[len(timestamps)-1]
+	values = values[:len(values)-1]
+	timestamps = timestamps[:len(timestamps)-1]
+	// Skip data points with duplicate timestamps.
+	for len(timestamps) > 0 && timestamps[len(timestamps)-1] >= tEnd {
+		timestamps = timestamps[:len(timestamps)-1]
+	}
+	var tStart int64
+	var vStart float64
+	if len(timestamps) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return 0
+		}
+		tStart = rfa.prevTimestamp
+		vStart = rfa.prevValue
+	} else {
+		tStart = timestamps[len(timestamps)-1]
+		vStart = values[len(timestamps)-1]
+	}
+	dv := vEnd - vStart
+	dt := tEnd - tStart
+	return dv / (float64(dt) * 1e-3)
+}
+
+func rollupLifetime(rfa *rollupFuncArg) float64 {
+	// Calculate the duration between the first and the last data points.
+	timestamps := rfa.timestamps
+	if math.IsNaN(rfa.prevValue) {
+		if len(timestamps) < 2 {
+			return nan
+		}
+		return float64(timestamps[len(timestamps)-1]-timestamps[0]) * 1e-3
+	}
+	if len(timestamps) == 0 {
+		return nan
+	}
+	return float64(timestamps[len(timestamps)-1]-rfa.prevTimestamp) * 1e-3
+}
+
+func rollupScrapeInterval(rfa *rollupFuncArg) float64 {
+	// Calculate the average interval between data points.
+	timestamps := rfa.timestamps
+	if math.IsNaN(rfa.prevValue) {
+		if len(timestamps) < 2 {
+			return nan
+		}
+		return float64(timestamps[len(timestamps)-1]-timestamps[0]) * 1e-3 / float64(len(timestamps)-1)
+	}
+	if len(timestamps) == 0 {
+		return nan
+	}
+	return (float64(timestamps[len(timestamps)-1]-rfa.prevTimestamp) * 1e-3) / float64(len(timestamps))
+}
+
+func rollupChanges(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	prevValue := rfa.prevValue
+	n := 0
+	if math.IsNaN(prevValue) {
+		if len(values) == 0 {
+			return nan
+		}
+		prevValue = values[0]
+		values = values[1:]
+		n++
+	}
+	for _, v := range values {
+		if v != prevValue {
+			n++
+			prevValue = v
+		}
+	}
+	return float64(n)
+}
+
+func rollupResets(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	prevValue := rfa.prevValue
+	if math.IsNaN(prevValue) {
+		prevValue = values[0]
+		values = values[1:]
+	}
+	if len(values) == 0 {
+		return 0
+	}
+	n := 0
+	for _, v := range values {
+		if v < prevValue {
+			n++
+		}
+		prevValue = v
+	}
+	return float64(n)
+}
+
+func rollupFirst(rfa *rollupFuncArg) float64 {
+	// See https://prometheus.io/docs/prometheus/latest/querying/basics/#staleness
+	v := rfa.prevValue
+	if !math.IsNaN(v) {
+		return v
+	}
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return nan
+	}
+	return values[0]
+}
+
+var rollupDefault = rollupLast
+
+func rollupLast(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	return values[len(values)-1]
+}
+
+func rollupDistinct(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	m := make(map[float64]struct{})
+	for _, v := range values {
+		m[v] = struct{}{}
+	}
+	return float64(len(m))
+}
+
+func rollupIntegrate(rfa *rollupFuncArg) float64 {
+	prevTimestamp := rfa.prevTimestamp
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	timestamps := rfa.timestamps
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	prevValue := rfa.prevValue
+	if math.IsNaN(prevValue) {
+		prevValue = values[0]
+		prevTimestamp = timestamps[0]
+		values = values[1:]
+		timestamps = timestamps[1:]
+	}
+	if len(values) == 0 {
+		return 0
+	}
+
+	var sum float64
+	for i, v := range values {
+		timestamp := timestamps[i]
+		dt := float64(timestamp-prevTimestamp) * 1e-3
+		sum += 0.5 * (v + prevValue) * dt
+	}
+	return sum
+}
+
+func rollupFake(rfa *rollupFuncArg) float64 {
+	logger.Panicf("BUG: rollupFake shouldn't be called")
+	return 0
+}
+
+func getScalar(arg interface{}, argNum int) ([]float64, error) {
+	ts, ok := arg.([]*timeseries)
+	if !ok {
+		return nil, fmt.Errorf(`unexpected type for arg #%d; got %T; want %T`, argNum+1, arg, ts)
+	}
+	if len(ts) != 1 {
+		return nil, fmt.Errorf(`arg #%d must contain a single timeseries; got %d timeseries`, argNum+1, len(ts))
+	}
+	return ts[0].Values, nil
+}
+
+func getString(tss []*timeseries, argNum int) (string, error) {
+	if len(tss) != 1 {
+		return "", fmt.Errorf(`arg #%d must contain a single timeseries; got %d timeseries`, argNum+1, len(tss))
+	}
+	ts := tss[0]
+	for _, v := range ts.Values {
+		if !math.IsNaN(v) {
+			return "", fmt.Errorf(`arg #%d contains non-string timeseries`, argNum+1)
+		}
+	}
+	return string(ts.MetricName.MetricGroup), nil
+}
+
+func expectRollupArgsNum(args []interface{}, expectedNum int) error {
+	if len(args) == expectedNum {
+		return nil
+	}
+	return fmt.Errorf(`unexpected number of args; got %d; want %d`, len(args), expectedNum)
+}
+
+func getRollupFuncArg() *rollupFuncArg {
+	v := rfaPool.Get()
+	if v == nil {
+		return &rollupFuncArg{}
+	}
+	return v.(*rollupFuncArg)
+}
+
+func putRollupFuncArg(rfa *rollupFuncArg) {
+	rfa.reset()
+	rfaPool.Put(rfa)
+}
+
+var rfaPool sync.Pool

app/vmselect/promql/rollup_result_cache.go

@@ -0,0 +1,534 @@
+package promql
+
+import (
+	"crypto/rand"
+	"flag"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/memory"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/workingsetcache"
+	"github.com/VictoriaMetrics/fastcache"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var disableCache = flag.Bool("search.disableCache", false, "Whether to disable response caching. This may be useful during data backfilling")
+
+var rollupResultCacheV = &rollupResultCache{
+	c: workingsetcache.New(1024*1024, time.Hour), // This is a cache for testing.
+}
+var rollupResultCachePath string
+
+func getRollupResultCacheSize() int {
+	rollupResultCacheSizeOnce.Do(func() {
+		n := memory.Allowed() / 16
+		if n <= 0 {
+			n = 1024 * 1024
+		}
+		rollupResultCacheSize = n
+	})
+	return rollupResultCacheSize
+}
+
+var (
+	rollupResultCacheSize     int
+	rollupResultCacheSizeOnce sync.Once
+)
+
+// InitRollupResultCache initializes the rollupResult cache
+//
+// if cachePath is empty, then the cache isn't stored to persistent disk.
+func InitRollupResultCache(cachePath string) {
+	rollupResultCachePath = cachePath
+	startTime := time.Now()
+	cacheSize := getRollupResultCacheSize()
+	var c *workingsetcache.Cache
+	if len(rollupResultCachePath) > 0 {
+		logger.Infof("loading rollupResult cache from %q...", rollupResultCachePath)
+		c = workingsetcache.Load(rollupResultCachePath, cacheSize, time.Hour)
+	} else {
+		c = workingsetcache.New(cacheSize, time.Hour)
+	}
+	if *disableCache {
+		c.Reset()
+	}
+
+	stats := &fastcache.Stats{}
+	var statsLock sync.Mutex
+	var statsLastUpdate time.Time
+	fcs := func() *fastcache.Stats {
+		statsLock.Lock()
+		defer statsLock.Unlock()
+
+		if time.Since(statsLastUpdate) < time.Second {
+			return stats
+		}
+		var fcs fastcache.Stats
+		c.UpdateStats(&fcs)
+		stats = &fcs
+		statsLastUpdate = time.Now()
+		return stats
+	}
+	if len(rollupResultCachePath) > 0 {
+		logger.Infof("loaded rollupResult cache from %q in %s; entriesCount: %d, sizeBytes: %d",
+			rollupResultCachePath, time.Since(startTime), fcs().EntriesCount, fcs().BytesSize)
+	}
+
+	metrics.NewGauge(`vm_cache_entries{type="promql/rollupResult"}`, func() float64 {
+		return float64(fcs().EntriesCount)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="promql/rollupResult"}`, func() float64 {
+		return float64(fcs().BytesSize)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="promql/rollupResult"}`, func() float64 {
+		return float64(fcs().GetCalls)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="promql/rollupResult"}`, func() float64 {
+		return float64(fcs().Misses)
+	})
+
+	rollupResultCacheV = &rollupResultCache{
+		c: c,
+	}
+}
+
+// StopRollupResultCache closes the rollupResult cache.
+func StopRollupResultCache() {
+	if len(rollupResultCachePath) == 0 {
+		rollupResultCacheV.c.Stop()
+		rollupResultCacheV.c = nil
+		return
+	}
+	logger.Infof("saving rollupResult cache to %q...", rollupResultCachePath)
+	startTime := time.Now()
+	if err := rollupResultCacheV.c.Save(rollupResultCachePath); err != nil {
+		logger.Errorf("cannot close rollupResult cache at %q: %s", rollupResultCachePath, err)
+		return
+	}
+	var fcs fastcache.Stats
+	rollupResultCacheV.c.UpdateStats(&fcs)
+	rollupResultCacheV.c.Stop()
+	rollupResultCacheV.c = nil
+	logger.Infof("saved rollupResult cache to %q in %s; entriesCount: %d, sizeBytes: %d",
+		rollupResultCachePath, time.Since(startTime), fcs.EntriesCount, fcs.BytesSize)
+}
+
+// TODO: convert this cache to distributed cache shared among vmselect
+// instances in the cluster.
+type rollupResultCache struct {
+	c *workingsetcache.Cache
+}
+
+var rollupResultCacheResets = metrics.NewCounter(`vm_cache_resets_total{type="promql/rollupResult"}`)
+
+// ResetRollupResultCache resets rollup result cache.
+func ResetRollupResultCache() {
+	rollupResultCacheResets.Inc()
+	rollupResultCacheV.c.Reset()
+}
+
+func (rrc *rollupResultCache) Get(funcName string, ec *EvalConfig, me *metricExpr, iafc *incrementalAggrFuncContext, window int64) (tss []*timeseries, newStart int64) {
+	if *disableCache || !ec.mayCache() {
+		return nil, ec.Start
+	}
+
+	// Obtain tss from the cache.
+	bb := bbPool.Get()
+	defer bbPool.Put(bb)
+
+	bb.B = marshalRollupResultCacheKey(bb.B[:0], funcName, ec.AuthToken, me, iafc, window, ec.Step)
+	metainfoBuf := rrc.c.Get(nil, bb.B)
+	if len(metainfoBuf) == 0 {
+		return nil, ec.Start
+	}
+	var mi rollupResultCacheMetainfo
+	if err := mi.Unmarshal(metainfoBuf); err != nil {
+		logger.Panicf("BUG: cannot unmarshal rollupResultCacheMetainfo: %s; it looks like it was improperly saved", err)
+	}
+	key := mi.GetBestKey(ec.Start, ec.End)
+	if key.prefix == 0 && key.suffix == 0 {
+		return nil, ec.Start
+	}
+	bb.B = key.Marshal(bb.B[:0])
+	compressedResultBuf := resultBufPool.Get()
+	defer resultBufPool.Put(compressedResultBuf)
+	compressedResultBuf.B = rrc.c.GetBig(compressedResultBuf.B[:0], bb.B)
+	if len(compressedResultBuf.B) == 0 {
+		mi.RemoveKey(key)
+		metainfoBuf = mi.Marshal(metainfoBuf[:0])
+		bb.B = marshalRollupResultCacheKey(bb.B[:0], funcName, ec.AuthToken, me, iafc, window, ec.Step)
+		rrc.c.Set(bb.B, metainfoBuf)
+		return nil, ec.Start
+	}
+	// Decompress into newly allocated byte slice, since tss returned from unmarshalTimeseriesFast
+	// refers to the byte slice, so it cannot be returned to the resultBufPool.
+	resultBuf, err := encoding.DecompressZSTD(nil, compressedResultBuf.B)
+	if err != nil {
+		logger.Panicf("BUG: cannot decompress resultBuf from rollupResultCache: %s; it looks like it was improperly saved", err)
+	}
+	tss, err = unmarshalTimeseriesFast(resultBuf)
+	if err != nil {
+		logger.Panicf("BUG: cannot unmarshal timeseries from rollupResultCache: %s; it looks like it was improperly saved", err)
+	}
+
+	// Extract values for the matching timestamps
+	timestamps := tss[0].Timestamps
+	i := 0
+	for i < len(timestamps) && timestamps[i] < ec.Start {
+		i++
+	}
+	if i == len(timestamps) {
+		// no matches.
+		return nil, ec.Start
+	}
+	if timestamps[i] != ec.Start {
+		// The cached range doesn't cover the requested range.
+		return nil, ec.Start
+	}
+
+	j := len(timestamps) - 1
+	for j >= 0 && timestamps[j] > ec.End {
+		j--
+	}
+	j++
+	if j <= i {
+		// no matches.
+		return nil, ec.Start
+	}
+
+	for _, ts := range tss {
+		ts.Timestamps = ts.Timestamps[i:j]
+		ts.Values = ts.Values[i:j]
+	}
+
+	timestamps = tss[0].Timestamps
+	newStart = timestamps[len(timestamps)-1] + ec.Step
+	return tss, newStart
+}
+
+var resultBufPool bytesutil.ByteBufferPool
+
+func (rrc *rollupResultCache) Put(funcName string, ec *EvalConfig, me *metricExpr, iafc *incrementalAggrFuncContext, window int64, tss []*timeseries) {
+	if *disableCache || len(tss) == 0 || !ec.mayCache() {
+		return
+	}
+
+	// Remove values up to currentTime - step - maxSilenceInterval,
+	// since these values may be added later.
+	timestamps := tss[0].Timestamps
+	deadline := (time.Now().UnixNano() / 1e6) - ec.Step - maxSilenceInterval
+	i := len(timestamps) - 1
+	for i >= 0 && timestamps[i] > deadline {
+		i--
+	}
+	i++
+	if i == 0 {
+		// Nothing to store in the cache.
+		return
+	}
+	if i < len(timestamps) {
+		timestamps = timestamps[:i]
+		// Make a copy of tss and remove unfit values
+		rvs := copyTimeseriesShallow(tss)
+		for _, ts := range rvs {
+			ts.Timestamps = ts.Timestamps[:i]
+			ts.Values = ts.Values[:i]
+		}
+		tss = rvs
+	}
+
+	// Store tss in the cache.
+	maxMarshaledSize := getRollupResultCacheSize() / 4
+	resultBuf := resultBufPool.Get()
+	defer resultBufPool.Put(resultBuf)
+	resultBuf.B = marshalTimeseriesFast(resultBuf.B[:0], tss, maxMarshaledSize, ec.Step)
+	if len(resultBuf.B) == 0 {
+		tooBigRollupResults.Inc()
+		return
+	}
+	compressedResultBuf := resultBufPool.Get()
+	defer resultBufPool.Put(compressedResultBuf)
+	compressedResultBuf.B = encoding.CompressZSTDLevel(compressedResultBuf.B[:0], resultBuf.B, 1)
+
+	bb := bbPool.Get()
+	defer bbPool.Put(bb)
+
+	var key rollupResultCacheKey
+	key.prefix = rollupResultCacheKeyPrefix
+	key.suffix = atomic.AddUint64(&rollupResultCacheKeySuffix, 1)
+	bb.B = key.Marshal(bb.B[:0])
+	rrc.c.SetBig(bb.B, compressedResultBuf.B)
+
+	bb.B = marshalRollupResultCacheKey(bb.B[:0], funcName, ec.AuthToken, me, iafc, window, ec.Step)
+	metainfoBuf := rrc.c.Get(nil, bb.B)
+	var mi rollupResultCacheMetainfo
+	if len(metainfoBuf) > 0 {
+		if err := mi.Unmarshal(metainfoBuf); err != nil {
+			logger.Panicf("BUG: cannot unmarshal rollupResultCacheMetainfo: %s; it looks like it was improperly saved", err)
+		}
+	}
+	mi.AddKey(key, timestamps[0], timestamps[len(timestamps)-1])
+	metainfoBuf = mi.Marshal(metainfoBuf[:0])
+	rrc.c.Set(bb.B, metainfoBuf)
+}
+
+var (
+	rollupResultCacheKeyPrefix = func() uint64 {
+		var buf [8]byte
+		if _, err := rand.Read(buf[:]); err != nil {
+			// do not use logger.Panicf, since it isn't initialized yet.
+			panic(fmt.Errorf("FATAL: cannot read random data for rollupResultCacheKeyPrefix: %s", err))
+		}
+		return encoding.UnmarshalUint64(buf[:])
+	}()
+	rollupResultCacheKeySuffix = uint64(time.Now().UnixNano())
+)
+
+var tooBigRollupResults = metrics.NewCounter("vm_too_big_rollup_results_total")
+
+// Increment this value every time the format of the cache changes.
+const rollupResultCacheVersion = 6
+
+func marshalRollupResultCacheKey(dst []byte, funcName string, at *auth.Token, me *metricExpr, iafc *incrementalAggrFuncContext, window, step int64) []byte {
+	dst = append(dst, rollupResultCacheVersion)
+	if iafc == nil {
+		dst = append(dst, 0)
+	} else {
+		dst = append(dst, 1)
+		dst = iafc.ae.AppendString(dst)
+	}
+	dst = encoding.MarshalUint32(dst, at.AccountID)
+	dst = encoding.MarshalUint32(dst, at.ProjectID)
+	dst = encoding.MarshalUint64(dst, uint64(len(funcName)))
+	dst = append(dst, funcName...)
+	dst = encoding.MarshalInt64(dst, window)
+	dst = encoding.MarshalInt64(dst, step)
+	for i := range me.TagFilters {
+		dst = me.TagFilters[i].Marshal(dst)
+	}
+	return dst
+}
+
+// mergeTimeseries concatenates b with a and returns the result.
+//
+// Preconditions:
+// - a mustn't intersect with b.
+// - a timestamps must be smaller than b timestamps.
+//
+// Postconditions:
+// - a and b cannot be used after returning from the call.
+func mergeTimeseries(a, b []*timeseries, bStart int64, ec *EvalConfig) []*timeseries {
+	sharedTimestamps := ec.getSharedTimestamps()
+	if bStart == ec.Start {
+		// Nothing to merge - b covers all the time range.
+		// Verify b is correct.
+		for _, tsB := range b {
+			tsB.denyReuse = true
+			tsB.Timestamps = sharedTimestamps
+			if len(tsB.Values) != len(tsB.Timestamps) {
+				logger.Panicf("BUG: unexpected number of values in b; got %d; want %d", len(tsB.Values), len(tsB.Timestamps))
+			}
+		}
+		return b
+	}
+
+	m := make(map[string]*timeseries, len(a))
+	bb := bbPool.Get()
+	defer bbPool.Put(bb)
+	for _, ts := range a {
+		bb.B = marshalMetricNameSorted(bb.B[:0], &ts.MetricName)
+		m[string(bb.B)] = ts
+	}
+
+	rvs := make([]*timeseries, 0, len(a))
+	for _, tsB := range b {
+		var tmp timeseries
+		tmp.denyReuse = true
+		tmp.Timestamps = sharedTimestamps
+		tmp.Values = make([]float64, 0, len(tmp.Timestamps))
+		// Do not use MetricName.CopyFrom for performance reasons.
+		// It is safe to make shallow copy, since tsB must no longer used.
+		tmp.MetricName = tsB.MetricName
+
+		bb.B = marshalMetricNameSorted(bb.B[:0], &tsB.MetricName)
+		tsA := m[string(bb.B)]
+		if tsA == nil {
+			tStart := ec.Start
+			for tStart < bStart {
+				tmp.Values = append(tmp.Values, nan)
+				tStart += ec.Step
+			}
+		} else {
+			tmp.Values = append(tmp.Values, tsA.Values...)
+			delete(m, string(bb.B))
+		}
+		tmp.Values = append(tmp.Values, tsB.Values...)
+		if len(tmp.Values) != len(tmp.Timestamps) {
+			logger.Panicf("BUG: unexpected values after merging new values; got %d; want %d", len(tmp.Values), len(tmp.Timestamps))
+		}
+		rvs = append(rvs, &tmp)
+	}
+
+	// Copy the remaining timeseries from m.
+	for _, tsA := range m {
+		var tmp timeseries
+		tmp.denyReuse = true
+		tmp.Timestamps = sharedTimestamps
+		// Do not use MetricName.CopyFrom for performance reasons.
+		// It is safe to make shallow copy, since tsA must no longer used.
+		tmp.MetricName = tsA.MetricName
+		tmp.Values = append(tmp.Values, tsA.Values...)
+
+		tStart := bStart
+		for tStart <= ec.End {
+			tmp.Values = append(tmp.Values, nan)
+			tStart += ec.Step
+		}
+		if len(tmp.Values) != len(tmp.Timestamps) {
+			logger.Panicf("BUG: unexpected values in the result after adding cached values; got %d; want %d", len(tmp.Values), len(tmp.Timestamps))
+		}
+		rvs = append(rvs, &tmp)
+	}
+	return rvs
+}
+
+type rollupResultCacheMetainfo struct {
+	entries []rollupResultCacheMetainfoEntry
+}
+
+func (mi *rollupResultCacheMetainfo) Marshal(dst []byte) []byte {
+	dst = encoding.MarshalUint32(dst, uint32(len(mi.entries)))
+	for i := range mi.entries {
+		dst = mi.entries[i].Marshal(dst)
+	}
+	return dst
+}
+
+func (mi *rollupResultCacheMetainfo) Unmarshal(src []byte) error {
+	if len(src) < 4 {
+		return fmt.Errorf("cannot unmarshal len(etries) from %d bytes; need at least %d bytes", len(src), 4)
+	}
+	entriesLen := int(encoding.UnmarshalUint32(src))
+	src = src[4:]
+	if n := entriesLen - cap(mi.entries); n > 0 {
+		mi.entries = append(mi.entries[:cap(mi.entries)], make([]rollupResultCacheMetainfoEntry, n)...)
+	}
+	mi.entries = mi.entries[:entriesLen]
+	for i := 0; i < entriesLen; i++ {
+		tail, err := mi.entries[i].Unmarshal(src)
+		if err != nil {
+			return fmt.Errorf("cannot unmarshal entry #%d: %s", i, err)
+		}
+		src = tail
+	}
+	if len(src) > 0 {
+		return fmt.Errorf("unexpected non-empty tail left; len(tail)=%d", len(src))
+	}
+	return nil
+}
+
+func (mi *rollupResultCacheMetainfo) GetBestKey(start, end int64) rollupResultCacheKey {
+	if start > end {
+		logger.Panicf("BUG: start cannot exceed end; got %d vs %d", start, end)
+	}
+	var bestKey rollupResultCacheKey
+	bestD := int64(1<<63 - 1)
+	for i := range mi.entries {
+		e := &mi.entries[i]
+		if start < e.start || end <= e.start {
+			continue
+		}
+		d := start - e.start
+		if d < bestD {
+			bestD = d
+			bestKey = e.key
+		}
+	}
+	return bestKey
+}
+
+func (mi *rollupResultCacheMetainfo) AddKey(key rollupResultCacheKey, start, end int64) {
+	if start > end {
+		logger.Panicf("BUG: start cannot exceed end; got %d vs %d", start, end)
+	}
+	mi.entries = append(mi.entries, rollupResultCacheMetainfoEntry{
+		start: start,
+		end:   end,
+		key:   key,
+	})
+	if len(mi.entries) > 30 {
+		// Remove old entries.
+		mi.entries = append(mi.entries[:0], mi.entries[10:]...)
+	}
+}
+
+func (mi *rollupResultCacheMetainfo) RemoveKey(key rollupResultCacheKey) {
+	for i := range mi.entries {
+		if mi.entries[i].key == key {
+			mi.entries = append(mi.entries[:i], mi.entries[i+1:]...)
+			return
+		}
+	}
+}
+
+type rollupResultCacheMetainfoEntry struct {
+	start int64
+	end   int64
+	key   rollupResultCacheKey
+}
+
+func (mie *rollupResultCacheMetainfoEntry) Marshal(dst []byte) []byte {
+	dst = encoding.MarshalInt64(dst, mie.start)
+	dst = encoding.MarshalInt64(dst, mie.end)
+	dst = encoding.MarshalUint64(dst, mie.key.prefix)
+	dst = encoding.MarshalUint64(dst, mie.key.suffix)
+	return dst
+}
+
+func (mie *rollupResultCacheMetainfoEntry) Unmarshal(src []byte) ([]byte, error) {
+	if len(src) < 8 {
+		return src, fmt.Errorf("cannot unmarshal start from %d bytes; need at least %d bytes", len(src), 8)
+	}
+	mie.start = encoding.UnmarshalInt64(src)
+	src = src[8:]
+
+	if len(src) < 8 {
+		return src, fmt.Errorf("cannot unmarshal end from %d bytes; need at least %d bytes", len(src), 8)
+	}
+	mie.end = encoding.UnmarshalInt64(src)
+	src = src[8:]
+
+	if len(src) < 8 {
+		return src, fmt.Errorf("cannot unmarshal key prefix from %d bytes; need at least %d bytes", len(src), 8)
+	}
+	mie.key.prefix = encoding.UnmarshalUint64(src)
+	src = src[8:]
+
+	if len(src) < 8 {
+		return src, fmt.Errorf("cannot unmarshal key suffix from %d bytes; need at least %d bytes", len(src), 8)
+	}
+	mie.key.suffix = encoding.UnmarshalUint64(src)
+	src = src[8:]
+
+	return src, nil
+}
+
+// rollupResultCacheKey must be globally unique across vmselect nodes,
+// so it has prefix and suffix.
+type rollupResultCacheKey struct {
+	prefix uint64
+	suffix uint64
+}
+
+func (k *rollupResultCacheKey) Marshal(dst []byte) []byte {
+	dst = append(dst, rollupResultCacheVersion)
+	dst = encoding.MarshalUint64(dst, k.prefix)
+	dst = encoding.MarshalUint64(dst, k.suffix)
+	return dst
+}

app/vmselect/promql/rollup_result_cache_test.go

@@ -0,0 +1,400 @@
+package promql
+
+import (
+	"testing"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/auth"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+func TestRollupResultCache(t *testing.T) {
+	ResetRollupResultCache()
+	funcName := "foo"
+	window := int64(456)
+	ec := &EvalConfig{
+		Start: 1000,
+		End:   2000,
+		Step:  200,
+
+		AuthToken: &auth.Token{
+			AccountID: 333,
+			ProjectID: 843,
+		},
+
+		MayCache: true,
+	}
+	me := &metricExpr{
+		TagFilters: []storage.TagFilter{{
+			Key:   []byte("aaa"),
+			Value: []byte("xxx"),
+		}},
+	}
+	iafc := &incrementalAggrFuncContext{
+		ae: &aggrFuncExpr{
+			Name: "foobar",
+		},
+	}
+
+	// Try obtaining an empty value.
+	t.Run("empty", func(t *testing.T) {
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != ec.Start {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, ec.Start)
+		}
+		if len(tss) != 0 {
+			t.Fatalf("got %d timeseries, while expecting zero", len(tss))
+		}
+	})
+
+	// Store timeseries overlapping with start
+	t.Run("start-overlap-no-iafc", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{800, 1000, 1200},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1400 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1400)
+		}
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{1, 2},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+	t.Run("start-overlap-with-iafc", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{800, 1000, 1200},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, iafc, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, iafc, window)
+		if newStart != 1400 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1400)
+		}
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{1, 2},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+
+	// Store timeseries overlapping with end
+	t.Run("end-overlap", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{1800, 2000, 2200, 2400},
+				Values:     []float64{333, 0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1000 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1000)
+		}
+		if len(tss) != 0 {
+			t.Fatalf("got %d timeseries, while expecting zero", len(tss))
+		}
+	})
+
+	// Store timeseries covered by [start ... end]
+	t.Run("full-cover", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{1200, 1400, 1600},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1000 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1000)
+		}
+		if len(tss) != 0 {
+			t.Fatalf("got %d timeseries, while expecting zero", len(tss))
+		}
+	})
+
+	// Store timeseries below start
+	t.Run("before-start", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{200, 400, 600},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1000 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1000)
+		}
+		if len(tss) != 0 {
+			t.Fatalf("got %d timeseries, while expecting zero", len(tss))
+		}
+	})
+
+	// Store timeseries after end
+	t.Run("after-end", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{2200, 2400, 2600},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1000 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1000)
+		}
+		if len(tss) != 0 {
+			t.Fatalf("got %d timeseries, while expecting zero", len(tss))
+		}
+	})
+
+	// Store timeseries bigger than the interval [start ... end]
+	t.Run("bigger-than-start-end", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{800, 1000, 1200, 1400, 1600, 1800, 2000, 2200},
+				Values:     []float64{0, 1, 2, 3, 4, 5, 6, 7},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 2200 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 2200)
+		}
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+
+	// Store timeseries matching the interval [start ... end]
+	t.Run("start-end-match", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 2200 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 2200)
+		}
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+
+	// Store big timeseries, so their marshaled size exceeds 64Kb.
+	t.Run("big-timeseries", func(t *testing.T) {
+		ResetRollupResultCache()
+		var tss []*timeseries
+		for i := 0; i < 1000; i++ {
+			ts := &timeseries{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			}
+			tss = append(tss, ts)
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss)
+		tssResult, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 2200 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 2200)
+		}
+		testTimeseriesEqual(t, tssResult, tss)
+	})
+
+	// Store multiple time series
+	t.Run("multi-timeseries", func(t *testing.T) {
+		ResetRollupResultCache()
+		tss1 := []*timeseries{
+			{
+				Timestamps: []int64{800, 1000, 1200},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		tss2 := []*timeseries{
+			{
+				Timestamps: []int64{1800, 2000, 2200, 2400},
+				Values:     []float64{333, 0, 1, 2},
+			},
+		}
+		tss3 := []*timeseries{
+			{
+				Timestamps: []int64{1200, 1400, 1600},
+				Values:     []float64{0, 1, 2},
+			},
+		}
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss1)
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss2)
+		rollupResultCacheV.Put(funcName, ec, me, nil, window, tss3)
+		tss, newStart := rollupResultCacheV.Get(funcName, ec, me, nil, window)
+		if newStart != 1400 {
+			t.Fatalf("unexpected newStart; got %d; want %d", newStart, 1400)
+		}
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{1, 2},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+
+}
+
+func TestMergeTimeseries(t *testing.T) {
+	ec := &EvalConfig{
+		Start: 1000,
+		End:   2000,
+		Step:  200,
+	}
+	bStart := int64(1400)
+
+	t.Run("bStart=ec.Start", func(t *testing.T) {
+		a := []*timeseries{}
+		b := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			},
+		}
+		tss := mergeTimeseries(a, b, 1000, ec)
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{1, 2, 3, 4, 5, 6},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+	t.Run("a-empty", func(t *testing.T) {
+		a := []*timeseries{}
+		b := []*timeseries{
+			{
+				Timestamps: []int64{1400, 1600, 1800, 2000},
+				Values:     []float64{3, 4, 5, 6},
+			},
+		}
+		tss := mergeTimeseries(a, b, bStart, ec)
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{nan, nan, 3, 4, 5, 6},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+	t.Run("b-empty", func(t *testing.T) {
+		a := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{2, 1},
+			},
+		}
+		b := []*timeseries{}
+		tss := mergeTimeseries(a, b, bStart, ec)
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{2, 1, nan, nan, nan, nan},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+	t.Run("non-empty", func(t *testing.T) {
+		a := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{2, 1},
+			},
+		}
+		b := []*timeseries{
+			{
+				Timestamps: []int64{1400, 1600, 1800, 2000},
+				Values:     []float64{3, 4, 5, 6},
+			},
+		}
+		tss := mergeTimeseries(a, b, bStart, ec)
+		tssExpected := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{2, 1, 3, 4, 5, 6},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+	t.Run("non-empty-distinct-metric-names", func(t *testing.T) {
+		a := []*timeseries{
+			{
+				Timestamps: []int64{1000, 1200},
+				Values:     []float64{2, 1},
+			},
+		}
+		a[0].MetricName.MetricGroup = []byte("bar")
+		b := []*timeseries{
+			{
+				Timestamps: []int64{1400, 1600, 1800, 2000},
+				Values:     []float64{3, 4, 5, 6},
+			},
+		}
+		b[0].MetricName.MetricGroup = []byte("foo")
+		tss := mergeTimeseries(a, b, bStart, ec)
+		tssExpected := []*timeseries{
+			{
+				MetricName: storage.MetricName{
+					MetricGroup: []byte("foo"),
+				},
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{nan, nan, 3, 4, 5, 6},
+			},
+			{
+				MetricName: storage.MetricName{
+					MetricGroup: []byte("bar"),
+				},
+				Timestamps: []int64{1000, 1200, 1400, 1600, 1800, 2000},
+				Values:     []float64{2, 1, nan, nan, nan, nan},
+			},
+		}
+		testTimeseriesEqual(t, tss, tssExpected)
+	})
+}
+
+func testTimeseriesEqual(t *testing.T, tss, tssExpected []*timeseries) {
+	t.Helper()
+	if len(tss) != len(tssExpected) {
+		t.Fatalf(`unexpected timeseries count; got %d; want %d`, len(tss), len(tssExpected))
+	}
+	for i, ts := range tss {
+		tsExpected := tssExpected[i]
+		testMetricNamesEqual(t, &ts.MetricName, &tsExpected.MetricName)
+		testRowsEqual(t, ts.Values, ts.Timestamps, tsExpected.Values, tsExpected.Timestamps)
+	}
+}

app/vmselect/promql/rollup_test.go

@@ -0,0 +1,819 @@
+package promql
+
+import (
+	"math"
+	"testing"
+)
+
+var (
+	testValues     = []float64{123, 34, 44, 21, 54, 34, 99, 12, 44, 32, 34, 34}
+	testTimestamps = []int64{5, 15, 24, 36, 49, 60, 78, 80, 97, 115, 120, 130}
+)
+
+func TestRollupIderivDuplicateTimestamps(t *testing.T) {
+	rfa := &rollupFuncArg{
+		values:     []float64{1, 2, 3, 4, 5},
+		timestamps: []int64{100, 100, 200, 300, 300},
+	}
+	n := rollupIderiv(rfa)
+	if n != 20 {
+		t.Fatalf("unexpected value; got %v; want %v", n, 20)
+	}
+
+	rfa = &rollupFuncArg{
+		values:     []float64{1, 2, 3, 4, 5},
+		timestamps: []int64{100, 100, 300, 300, 300},
+	}
+	n = rollupIderiv(rfa)
+	if n != 15 {
+		t.Fatalf("unexpected value; got %v; want %v", n, 15)
+	}
+
+	rfa = &rollupFuncArg{
+		prevValue:  nan,
+		values:     []float64{},
+		timestamps: []int64{},
+	}
+	n = rollupIderiv(rfa)
+	if !math.IsNaN(n) {
+		t.Fatalf("unexpected value; got %v; want %v", n, nan)
+	}
+
+	rfa = &rollupFuncArg{
+		prevValue:  nan,
+		values:     []float64{15},
+		timestamps: []int64{100},
+	}
+	n = rollupIderiv(rfa)
+	if !math.IsNaN(n) {
+		t.Fatalf("unexpected value; got %v; want %v", n, nan)
+	}
+
+	rfa = &rollupFuncArg{
+		prevTimestamp: 90,
+		prevValue:     10,
+		values:        []float64{15},
+		timestamps:    []int64{100},
+	}
+	n = rollupIderiv(rfa)
+	if n != 500 {
+		t.Fatalf("unexpected value; got %v; want %v", n, 0.5)
+	}
+
+	rfa = &rollupFuncArg{
+		prevTimestamp: 100,
+		prevValue:     10,
+		values:        []float64{15},
+		timestamps:    []int64{100},
+	}
+	n = rollupIderiv(rfa)
+	if n != inf {
+		t.Fatalf("unexpected value; got %v; want %v", n, inf)
+	}
+
+	rfa = &rollupFuncArg{
+		prevTimestamp: 100,
+		prevValue:     10,
+		values:        []float64{15, 20},
+		timestamps:    []int64{100, 100},
+	}
+	n = rollupIderiv(rfa)
+	if n != inf {
+		t.Fatalf("unexpected value; got %v; want %v", n, inf)
+	}
+}
+
+func TestRemoveCounterResets(t *testing.T) {
+	removeCounterResets(nil)
+
+	values := append([]float64{}, testValues...)
+	removeCounterResets(values)
+	valuesExpected := []float64{123, 157, 167, 188, 221, 255, 320, 332, 364, 396, 398, 398}
+	testRowsEqual(t, values, testTimestamps, valuesExpected, testTimestamps)
+
+	// removeCounterResets doesn't expect negative values, so it doesn't work properly with them.
+	values = []float64{-100, -200, -300, -400}
+	removeCounterResets(values)
+	valuesExpected = []float64{-100, -300, -600, -1000}
+	timestampsExpected := []int64{0, 1, 2, 3}
+	testRowsEqual(t, values, timestampsExpected, valuesExpected, timestampsExpected)
+
+	// verify how jitter from `Prometheus HA pairs` is handled
+	values = []float64{100, 95, 120, 140, 137, 50}
+	removeCounterResets(values)
+	valuesExpected = []float64{100, 100, 120, 140, 140, 190}
+	timestampsExpected = []int64{0, 1, 2, 3, 4, 5}
+	testRowsEqual(t, values, timestampsExpected, valuesExpected, timestampsExpected)
+}
+
+func TestDeltaValues(t *testing.T) {
+	deltaValues(nil)
+
+	values := []float64{123}
+	deltaValues(values)
+	valuesExpected := []float64{0}
+	testRowsEqual(t, values, testTimestamps[:1], valuesExpected, testTimestamps[:1])
+
+	values = append([]float64{}, testValues...)
+	deltaValues(values)
+	valuesExpected = []float64{-89, 10, -23, 33, -20, 65, -87, 32, -12, 2, 0, 0}
+	testRowsEqual(t, values, testTimestamps, valuesExpected, testTimestamps)
+
+	// remove counter resets
+	values = append([]float64{}, testValues...)
+	removeCounterResets(values)
+	deltaValues(values)
+	valuesExpected = []float64{34, 10, 21, 33, 34, 65, 12, 32, 32, 2, 0, 0}
+	testRowsEqual(t, values, testTimestamps, valuesExpected, testTimestamps)
+}
+
+func TestDerivValues(t *testing.T) {
+	derivValues(nil, nil)
+
+	values := []float64{123}
+	derivValues(values, testTimestamps[:1])
+	valuesExpected := []float64{0}
+	testRowsEqual(t, values, testTimestamps[:1], valuesExpected, testTimestamps[:1])
+
+	values = append([]float64{}, testValues...)
+	derivValues(values, testTimestamps)
+	valuesExpected = []float64{-8900, 1111.111111111111, -1916.6666666666665, 2538.461538461538, -1818.1818181818182, 3611.111111111111,
+		-43500, 1882.3529411764705, -666.6666666666666, 400, 0, 0}
+	testRowsEqual(t, values, testTimestamps, valuesExpected, testTimestamps)
+
+	// remove counter resets
+	values = append([]float64{}, testValues...)
+	removeCounterResets(values)
+	derivValues(values, testTimestamps)
+	valuesExpected = []float64{3400, 1111.111111111111, 1750, 2538.461538461538, 3090.909090909091, 3611.111111111111,
+		6000, 1882.3529411764705, 1777.7777777777776, 400, 0, 0}
+	testRowsEqual(t, values, testTimestamps, valuesExpected, testTimestamps)
+
+	// duplicate timestamps
+	values = []float64{1, 2, 3, 4, 5, 6, 7}
+	timestamps := []int64{100, 100, 200, 200, 300, 400, 400}
+	derivValues(values, timestamps)
+	valuesExpected = []float64{0, 20, 20, 20, 10, 10, 10}
+	testRowsEqual(t, values, timestamps, valuesExpected, timestamps)
+}
+
+func testRollupFunc(t *testing.T, funcName string, args []interface{}, meExpected *metricExpr, vExpected float64) {
+	t.Helper()
+	nrf := getRollupFunc(funcName)
+	if nrf == nil {
+		t.Fatalf("cannot obtain %q", funcName)
+	}
+	rf, err := nrf(args)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	var rfa rollupFuncArg
+	rfa.prevValue = nan
+	rfa.prevTimestamp = 0
+	rfa.values = append(rfa.values, testValues...)
+	rfa.timestamps = append(rfa.timestamps, testTimestamps...)
+	if rollupFuncsRemoveCounterResets[funcName] {
+		removeCounterResets(rfa.values)
+	}
+	for i := 0; i < 5; i++ {
+		v := rf(&rfa)
+		if math.IsNaN(vExpected) {
+			if !math.IsNaN(v) {
+				t.Fatalf("unexpected value; got %v; want %v", v, vExpected)
+			}
+		} else {
+			eps := math.Abs(v - vExpected)
+			if eps > 1e-14 {
+				t.Fatalf("unexpected value; got %v; want %v", v, vExpected)
+			}
+		}
+	}
+}
+
+func TestRollupQuantileOverTime(t *testing.T) {
+	f := func(phi, vExpected float64) {
+		t.Helper()
+		phis := []*timeseries{{
+			Values:     []float64{phi},
+			Timestamps: []int64{123},
+		}}
+		var me metricExpr
+		args := []interface{}{phis, &rollupExpr{Expr: &me}}
+		testRollupFunc(t, "quantile_over_time", args, &me, vExpected)
+	}
+
+	f(-123, 12)
+	f(-0.5, 12)
+	f(0, 12)
+	f(0.1, 21)
+	f(0.5, 34)
+	f(0.9, 99)
+	f(1, 123)
+	f(234, 123)
+}
+
+func TestRollupPredictLinear(t *testing.T) {
+	f := func(sec, vExpected float64) {
+		t.Helper()
+		secs := []*timeseries{{
+			Values:     []float64{sec},
+			Timestamps: []int64{123},
+		}}
+		var me metricExpr
+		args := []interface{}{&rollupExpr{Expr: &me}, secs}
+		testRollupFunc(t, "predict_linear", args, &me, vExpected)
+	}
+
+	f(0e-3, 30.382432471845043)
+	f(50e-3, 17.03950235614201)
+	f(100e-3, 3.696572240438975)
+	f(200e-3, -22.989287990967092)
+}
+
+func TestRollupHoltWinters(t *testing.T) {
+	f := func(sf, tf, vExpected float64) {
+		t.Helper()
+		sfs := []*timeseries{{
+			Values:     []float64{sf},
+			Timestamps: []int64{123},
+		}}
+		tfs := []*timeseries{{
+			Values:     []float64{tf},
+			Timestamps: []int64{123},
+		}}
+		var me metricExpr
+		args := []interface{}{&rollupExpr{Expr: &me}, sfs, tfs}
+		testRollupFunc(t, "holt_winters", args, &me, vExpected)
+	}
+
+	f(-1, 0.5, nan)
+	f(0, 0.5, nan)
+	f(1, 0.5, nan)
+	f(2, 0.5, nan)
+	f(0.5, -1, nan)
+	f(0.5, 0, nan)
+	f(0.5, 1, nan)
+	f(0.5, 2, nan)
+	f(0.5, 0.5, 34.97794532775879)
+	f(0.1, 0.5, -131.30529492371622)
+	f(0.1, 0.1, -397.3307790780296)
+	f(0.5, 0.1, -5.791530520284198)
+	f(0.5, 0.9, 25.498906408926757)
+	f(0.9, 0.9, 33.99637566941818)
+}
+
+func TestRollupNewRollupFuncSuccess(t *testing.T) {
+	f := func(funcName string, vExpected float64) {
+		t.Helper()
+		var me metricExpr
+		args := []interface{}{&rollupExpr{Expr: &me}}
+		testRollupFunc(t, funcName, args, &me, vExpected)
+	}
+
+	f("default_rollup", 34)
+	f("changes", 11)
+	f("delta", -89)
+	f("deriv", -266.85860231406065)
+	f("deriv_fast", -712)
+	f("idelta", 0)
+	f("increase", 275)
+	f("irate", 0)
+	f("rate", 2200)
+	f("resets", 5)
+	f("avg_over_time", 47.083333333333336)
+	f("min_over_time", 12)
+	f("max_over_time", 123)
+	f("sum_over_time", 565)
+	f("sum2_over_time", 37951)
+	f("geomean_over_time", 39.33466603189148)
+	f("count_over_time", 12)
+	f("stddev_over_time", 30.752935722554287)
+	f("stdvar_over_time", 945.7430555555555)
+	f("first_over_time", 123)
+	f("last_over_time", 34)
+	f("integrate", 61.0275)
+	f("distinct_over_time", 8)
+	f("ideriv", 0)
+}
+
+func TestRollupNewRollupFuncError(t *testing.T) {
+	if nrf := getRollupFunc("non-existing-func"); nrf != nil {
+		t.Fatalf("expecting nil func; got %p", nrf)
+	}
+
+	f := func(funcName string, args []interface{}) {
+		t.Helper()
+
+		nrf := getRollupFunc(funcName)
+		rf, err := nrf(args)
+		if err == nil {
+			t.Fatalf("expecting non-nil error")
+		}
+		if rf != nil {
+			t.Fatalf("expecting nil rf; got %p", rf)
+		}
+	}
+
+	// Invalid number of args
+	f("default_rollup", nil)
+	f("holt_winters", nil)
+	f("predict_linear", nil)
+	f("quantile_over_time", nil)
+
+	// Invalid arg type
+	scalarTs := []*timeseries{{
+		Values:     []float64{321},
+		Timestamps: []int64{123},
+	}}
+	me := &metricExpr{}
+	f("holt_winters", []interface{}{123, 123, 321})
+	f("holt_winters", []interface{}{me, 123, 321})
+	f("holt_winters", []interface{}{me, scalarTs, 321})
+	f("predict_linear", []interface{}{123, 123})
+	f("predict_linear", []interface{}{me, 123})
+	f("quantile_over_time", []interface{}{123, 123})
+}
+
+func TestRollupNoWindowNoPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    4,
+			Step:   1,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, nan, nan, nan, nan}
+		timestampsExpected := []int64{0, 1, 2, 3, 4}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupDelta,
+			Start:  120,
+			End:    148,
+			Step:   4,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{2, 0, 0, 0, nan, nan, nan, nan}
+		timestampsExpected := []int64{120, 124, 128, 132, 136, 140, 144, 148}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupWindowNoPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    4,
+			Step:   1,
+			Window: 3,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, nan, nan, nan, nan}
+		timestampsExpected := []int64{0, 1, 2, 3, 4}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  161,
+			End:    191,
+			Step:   10,
+			Window: 3,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, nan, nan, nan}
+		timestampsExpected := []int64{161, 171, 181, 191}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupNoWindowPartialPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    25,
+			Step:   5,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 123, 123, 123, 34, 34}
+		timestampsExpected := []int64{0, 5, 10, 15, 20, 25}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  100,
+			End:    160,
+			Step:   20,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{12, 44, 34, nan}
+		timestampsExpected := []int64{100, 120, 140, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("middle", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  -50,
+			End:    150,
+			Step:   50,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, nan, 123, 54, 44}
+		timestampsExpected := []int64{-50, 0, 50, 100, 150}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupWindowPartialPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupLast,
+			Start:  0,
+			End:    20,
+			Step:   5,
+			Window: 8,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 123, 123, 34, 34}
+		timestampsExpected := []int64{0, 5, 10, 15, 20}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupLast,
+			Start:  100,
+			End:    160,
+			Step:   20,
+			Window: 18,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{44, 34, 34, nan}
+		timestampsExpected := []int64{100, 120, 140, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("middle", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupLast,
+			Start:  0,
+			End:    150,
+			Step:   50,
+			Window: 19,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 54, 44, nan}
+		timestampsExpected := []int64{0, 50, 100, 150}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupFuncsNoWindow(t *testing.T) {
+	t.Run("first", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 123, 21, 12, 34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("count", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupCount,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 4, 4, 3, 1}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("min", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupMin,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 21, 12, 32, 34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("max", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupMax,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 123, 99, 44, 34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("sum", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupSum,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 222, 199, 110, 34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("delta", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupDelta,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, -102, -9, 22, 0}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("idelta", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupIdelta,
+			Start:  10,
+			End:    130,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{123, 33, -87, 0}
+		timestampsExpected := []int64{10, 50, 90, 130}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("lifetime_1", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupLifetime,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 0.031, 0.044, 0.04, 0.01}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("lifetime_2", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupLifetime,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 200,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 0.031, 0.075, 0.115, 0.125}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("scrape_interval_1", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupScrapeInterval,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 0.010333333333333333, 0.011, 0.013333333333333334, 0.01}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("scrape_interval_2", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupScrapeInterval,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 80,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 0.010333333333333333, 0.010714285714285714, 0.012, 0.0125}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("changes", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupChanges,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 4, 4, 3, 0}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("changes_small_window", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupChanges,
+			Start:  0,
+			End:    45,
+			Step:   9,
+			Window: 9,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 1, 1, 1, 1, 0}
+		timestampsExpected := []int64{0, 9, 18, 27, 36, 45}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("resets", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupResets,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 2, 2, 1, 0}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("avg", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupAvg,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 55.5, 49.75, 36.666666666666664, 34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("deriv", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupDerivSlow,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{0, -2879.310344827587, 558.0608793686592, 422.84569138276544, 0}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("ideriv", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupIderiv,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, -1916.6666666666665, -43500, 400, 0}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("stddev", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupStddev,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 39.81519810323691, 32.080952292598795, 5.2493385826745405, 5.830951894845301}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("integrate", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupIntegrate,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 4.6035, 4.3934999999999995, 2.166, 0.34}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("distinct_over_time_1", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupDistinct,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 4, 4, 3, 1}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("distinct_over_time_2", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupDistinct,
+			Start:  0,
+			End:    160,
+			Step:   40,
+			Window: 80,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 4, 7, 6, 3}
+		timestampsExpected := []int64{0, 40, 80, 120, 160}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func testRowsEqual(t *testing.T, values []float64, timestamps []int64, valuesExpected []float64, timestampsExpected []int64) {
+	t.Helper()
+	if len(values) != len(valuesExpected) {
+		t.Fatalf("unexpected len(values); got %d; want %d\nvalues=\n%v\nvaluesExpected=\n%v",
+			len(values), len(valuesExpected), values, valuesExpected)
+	}
+	if len(timestamps) != len(timestampsExpected) {
+		t.Fatalf("unexpected len(timestamps); got %d; want %d\ntimestamps=\n%v\ntimestampsExpected=\n%v",
+			len(timestamps), len(timestampsExpected), timestamps, timestampsExpected)
+	}
+	if len(values) != len(timestamps) {
+		t.Fatalf("len(values) doesn't match len(timestamps); got %d vs %d", len(values), len(timestamps))
+	}
+	for i, v := range values {
+		ts := timestamps[i]
+		tsExpected := timestampsExpected[i]
+		if ts != tsExpected {
+			t.Fatalf("unexpected timestamp at timestamps[%d]; got %d; want %d\ntimestamps=\n%v\ntimestampsExpected=\n%v",
+				i, ts, tsExpected, timestamps, timestampsExpected)
+		}
+		vExpected := valuesExpected[i]
+		if math.IsNaN(v) {
+			if !math.IsNaN(vExpected) {
+				t.Fatalf("unexpected nan value at values[%d]; want %f\nvalues=\n%v\nvaluesExpected=\n%v",
+					i, vExpected, values, valuesExpected)
+			}
+			continue
+		}
+		if v != vExpected {
+			t.Fatalf("unexpected value at values[%d]; got %f; want %f\nvalues=\n%v\nvaluesExpected=\n%v",
+				i, v, vExpected, values, valuesExpected)
+		}
+	}
+}

app/vmselect/promql/rollup_timing_test.go

@@ -0,0 +1,43 @@
+package promql
+
+import (
+	"math/rand"
+	"sync"
+	"testing"
+)
+
+func BenchmarkRollupAvg(b *testing.B) {
+	rfa := &rollupFuncArg{
+		values: benchValues,
+	}
+
+	b.ReportAllocs()
+	b.SetBytes(int64(len(benchValues)))
+	b.RunParallel(func(pb *testing.PB) {
+		var vSum float64
+		for pb.Next() {
+			vSum += rollupAvg(rfa)
+		}
+		SinkLock.Lock()
+		Sink += vSum
+		SinkLock.Unlock()
+	})
+}
+
+var (
+	// Sink is a global sink for benchmarks.
+	// It guarantees the compiler doesn't remove the code in benchmarks,
+	// which writes data to the Sink.
+	Sink float64
+
+	// SinkLock locks Sink.
+	SinkLock sync.Mutex
+)
+
+var benchValues = func() []float64 {
+	values := make([]float64, 1000)
+	for i := range values {
+		values[i] = rand.Float64() * 100
+	}
+	return values
+}()

app/vmselect/promql/timeseries.go

@@ -0,0 +1,400 @@
+package promql
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"sync"
+	"unsafe"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+type timeseries struct {
+	MetricName storage.MetricName
+	Values     []float64
+	Timestamps []int64
+
+	// Whether the timeseries may be re-used.
+	// Timeseries may be re-used only if their members own values
+	// they refer to.
+	denyReuse bool
+}
+
+func (ts *timeseries) Reset() {
+	if ts.denyReuse {
+		*ts = timeseries{}
+		return
+	}
+
+	ts.MetricName.Reset()
+	ts.Values = ts.Values[:0]
+	ts.Timestamps = ts.Timestamps[:0]
+}
+
+func (ts *timeseries) String() string {
+	return fmt.Sprintf("MetricName=%s, Values=%g, Timestamps=%d", &ts.MetricName, ts.Values, ts.Timestamps)
+}
+
+func (ts *timeseries) CopyFromShallowTimestamps(src *timeseries) {
+	ts.Reset()
+	ts.MetricName.CopyFrom(&src.MetricName)
+	ts.Values = append(ts.Values[:0], src.Values...)
+	ts.Timestamps = src.Timestamps
+
+	ts.denyReuse = true
+}
+
+func (ts *timeseries) CopyFromMetricNames(src *timeseries) {
+	ts.Reset()
+	ts.MetricName.CopyFrom(&src.MetricName)
+	ts.Values = src.Values
+	ts.Timestamps = src.Timestamps
+
+	ts.denyReuse = true
+}
+
+func (ts *timeseries) CopyShallow(src *timeseries) {
+	*ts = *src
+	ts.denyReuse = true
+}
+
+func getTimeseries() *timeseries {
+	if v := timeseriesPool.Get(); v != nil {
+		return v.(*timeseries)
+	}
+	return &timeseries{}
+}
+
+func putTimeseries(ts *timeseries) {
+	ts.Reset()
+	timeseriesPool.Put(ts)
+}
+
+var timeseriesPool sync.Pool
+
+func marshalTimeseriesFast(dst []byte, tss []*timeseries, maxSize int, step int64) []byte {
+	if len(tss) == 0 {
+		logger.Panicf("BUG: tss cannot be empty")
+	}
+
+	// Calculate the required size for marshaled tss.
+	size := 0
+	for _, ts := range tss {
+		size += ts.marshaledFastSizeNoTimestamps()
+	}
+	// timestamps are stored only once for all the tss, since they are identical.
+	assertIdenticalTimestamps(tss, step)
+	size += 8 * len(tss[0].Timestamps)
+
+	if size > maxSize {
+		// Do not marshal tss, since it would occupy too much space
+		return dst
+	}
+
+	// Allocate the buffer for the marshaled tss before its' marshaling.
+	// This should reduce memory fragmentation and memory usage.
+	dst = bytesutil.Resize(dst, size)
+	dst = marshalFastTimestamps(dst[:0], tss[0].Timestamps)
+	for _, ts := range tss {
+		dst = ts.marshalFastNoTimestamps(dst)
+	}
+	return dst
+}
+
+// unmarshalTimeseriesFast unmarshals timeseries from src.
+//
+// The returned timeseries refer to src, so it is unsafe to modify it
+// until timeseries are in use.
+func unmarshalTimeseriesFast(src []byte) ([]*timeseries, error) {
+	tail, timestamps, err := unmarshalFastTimestamps(src)
+	if err != nil {
+		return nil, err
+	}
+	src = tail
+
+	var tss []*timeseries
+	for len(src) > 0 {
+		var ts timeseries
+		ts.denyReuse = false
+		ts.Timestamps = timestamps
+
+		tail, err := ts.unmarshalFastNoTimestamps(src)
+		if err != nil {
+			return nil, err
+		}
+		src = tail
+
+		tss = append(tss, &ts)
+	}
+	return tss, nil
+}
+
+// marshaledFastSizeNoTimestamps returns the size of marshaled ts
+// returned from marshalFastNoTimestamps.
+func (ts *timeseries) marshaledFastSizeNoTimestamps() int {
+	mn := &ts.MetricName
+	n := 2 + len(mn.MetricGroup)
+	n += 2 // Length of tags.
+	for i := range mn.Tags {
+		tag := &mn.Tags[i]
+		n += 2 + len(tag.Key)
+		n += 2 + len(tag.Value)
+	}
+	n += 8 * len(ts.Values)
+	return n
+}
+
+// marshalFastNoTimestamps appends marshaled ts to dst and returns the result.
+//
+// It doesn't marshal timestamps.
+//
+// The result must be unmarshaled with unmarshalFastNoTimestamps.
+func (ts *timeseries) marshalFastNoTimestamps(dst []byte) []byte {
+	mn := &ts.MetricName
+	dst = marshalBytesFast(dst, mn.MetricGroup)
+	dst = encoding.MarshalUint16(dst, uint16(len(mn.Tags)))
+	// There is no need in tags' sorting - they must be sorted after unmarshaling.
+	for i := range mn.Tags {
+		tag := &mn.Tags[i]
+		dst = marshalBytesFast(dst, tag.Key)
+		dst = marshalBytesFast(dst, tag.Value)
+	}
+
+	// Do not marshal len(ts.Values), since it is already encoded as len(ts.Timestamps)
+	// during marshalFastTimestamps.
+	var valuesBuf []byte
+	if len(ts.Values) > 0 {
+		valuesBuf = (*[maxByteSliceLen]byte)(unsafe.Pointer(&ts.Values[0]))[:len(ts.Values)*8]
+	}
+	dst = append(dst, valuesBuf...)
+	return dst
+}
+
+func marshalFastTimestamps(dst []byte, timestamps []int64) []byte {
+	dst = encoding.MarshalUint32(dst, uint32(len(timestamps)))
+	var timestampsBuf []byte
+	if len(timestamps) > 0 {
+		timestampsBuf = (*[maxByteSliceLen]byte)(unsafe.Pointer(&timestamps[0]))[:len(timestamps)*8]
+	}
+	dst = append(dst, timestampsBuf...)
+	return dst
+}
+
+// it is unsafe modifying src while the returned timestamps is in use.
+func unmarshalFastTimestamps(src []byte) ([]byte, []int64, error) {
+	if len(src) < 4 {
+		return src, nil, fmt.Errorf("cannot decode len(timestamps); got %d bytes; want at least %d bytes", len(src), 4)
+	}
+	timestampsCount := int(encoding.UnmarshalUint32(src))
+	src = src[4:]
+	if timestampsCount == 0 {
+		return src, nil, nil
+	}
+
+	bufSize := timestampsCount * 8
+	if len(src) < bufSize {
+		return src, nil, fmt.Errorf("cannot unmarshal timestamps; got %d bytes; want at least %d bytes", len(src), bufSize)
+	}
+	timestamps := (*[maxByteSliceLen / 8]int64)(unsafe.Pointer(&src[0]))[:timestampsCount]
+	timestamps = timestamps[:len(timestamps):len(timestamps)]
+	src = src[bufSize:]
+
+	return src, timestamps, nil
+}
+
+// unmarshalFastNoTimestamps unmarshals ts from src, so ts members reference src.
+//
+// It is expected that ts.Timestamps is already unmarshaled.
+//
+// It is unsafe to modify src while ts is in use.
+func (ts *timeseries) unmarshalFastNoTimestamps(src []byte) ([]byte, error) {
+	// ts members point to src, so they cannot be re-used.
+	ts.denyReuse = true
+
+	tail, err := unmarshalMetricNameFast(&ts.MetricName, src)
+	if err != nil {
+		return tail, fmt.Errorf("cannot unmarshal MetricName: %s", err)
+	}
+	src = tail
+
+	valuesCount := len(ts.Timestamps)
+	if valuesCount == 0 {
+		return src, nil
+	}
+	bufSize := valuesCount * 8
+	if len(src) < bufSize {
+		return src, fmt.Errorf("cannot unmarshal values; got %d bytes; want at least %d bytes", len(src), bufSize)
+	}
+	values := (*[maxByteSliceLen / 8]float64)(unsafe.Pointer(&src[0]))[:valuesCount]
+	ts.Values = values[:len(values):len(values)]
+
+	return src[bufSize:], nil
+}
+
+// unmarshalMetricNameFast unmarshals mn from src, so mn members
+// hold references to src.
+//
+// It is unsafe modifying src while mn is in use.
+func unmarshalMetricNameFast(mn *storage.MetricName, src []byte) ([]byte, error) {
+	mn.Reset()
+
+	tail, metricGroup, err := unmarshalBytesFast(src)
+	if err != nil {
+		return tail, fmt.Errorf("cannot unmarshal MetricGroup: %s", err)
+	}
+	src = tail
+	mn.MetricGroup = metricGroup[:len(metricGroup):len(metricGroup)]
+
+	if len(src) < 2 {
+		return src, fmt.Errorf("not enough bytes for unmarshaling len(tags); need at least 2 bytes; got %d bytes", len(src))
+	}
+	tagsLen := encoding.UnmarshalUint16(src)
+	src = src[2:]
+	if n := int(tagsLen) - cap(mn.Tags); n > 0 {
+		mn.Tags = append(mn.Tags[:cap(mn.Tags)], make([]storage.Tag, n)...)
+	}
+	mn.Tags = mn.Tags[:tagsLen]
+	for i := range mn.Tags {
+		tail, key, err := unmarshalBytesFast(src)
+		if err != nil {
+			return tail, fmt.Errorf("cannot unmarshal key for tag[%d]: %s", i, err)
+		}
+		src = tail
+
+		tail, value, err := unmarshalBytesFast(src)
+		if err != nil {
+			return tail, fmt.Errorf("cannot unmarshal value for tag[%d]: %s", i, err)
+		}
+		src = tail
+
+		tag := &mn.Tags[i]
+		tag.Key = key[:len(key):len(key)]
+		tag.Value = value[:len(value):len(value)]
+	}
+	return src, nil
+}
+
+func marshalMetricTagsFast(dst []byte, tags []storage.Tag) []byte {
+	for i := range tags {
+		tag := &tags[i]
+		dst = marshalBytesFast(dst, tag.Key)
+		dst = marshalBytesFast(dst, tag.Value)
+	}
+	return dst
+}
+
+func marshalMetricNameSorted(dst []byte, mn *storage.MetricName) []byte {
+	// Do not marshal AccountID and ProjectID, since they are unused.
+	dst = marshalBytesFast(dst, mn.MetricGroup)
+	sortMetricTags(mn.Tags)
+	dst = marshalMetricTagsFast(dst, mn.Tags)
+	return dst
+}
+
+func marshalMetricTagsSorted(dst []byte, mn *storage.MetricName) []byte {
+	sortMetricTags(mn.Tags)
+	return marshalMetricTagsFast(dst, mn.Tags)
+}
+
+func sortMetricTags(tags []storage.Tag) {
+	less := func(i, j int) bool {
+		return string(tags[i].Key) < string(tags[j].Key)
+	}
+	if sort.SliceIsSorted(tags, less) {
+		return
+	}
+	sort.Slice(tags, less)
+}
+
+func marshalBytesFast(dst []byte, s []byte) []byte {
+	dst = encoding.MarshalUint16(dst, uint16(len(s)))
+	dst = append(dst, s...)
+	return dst
+}
+
+func unmarshalBytesFast(src []byte) ([]byte, []byte, error) {
+	if len(src) < 2 {
+		return src, nil, fmt.Errorf("cannot decode size form src=%X; it must be at least 2 bytes", src)
+	}
+	n := encoding.UnmarshalUint16(src)
+	src = src[2:]
+	if len(src) < int(n) {
+		return src, nil, fmt.Errorf("too short src=%X; it must be at least %d bytes", src, n)
+	}
+	return src[n:], src[:n], nil
+}
+
+func stringMetricName(mn *storage.MetricName) string {
+	var dst []byte
+	dst = append(dst, mn.MetricGroup...)
+	sortMetricTags(mn.Tags)
+	dst = appendStringMetricTags(dst, mn.Tags)
+	return string(dst)
+}
+
+func stringMetricTags(mn *storage.MetricName) string {
+	var dst []byte
+	sortMetricTags(mn.Tags)
+	dst = appendStringMetricTags(dst, mn.Tags)
+	return string(dst)
+}
+
+func appendStringMetricTags(dst []byte, tags []storage.Tag) []byte {
+	dst = append(dst, '{')
+	for i := range tags {
+		tag := &tags[i]
+		dst = append(dst, tag.Key...)
+		dst = append(dst, '=')
+		value := bytesutil.ToUnsafeString(tag.Value)
+		dst = strconv.AppendQuote(dst, value)
+		if i+1 < len(tags) {
+			dst = append(dst, ", "...)
+		}
+	}
+	dst = append(dst, '}')
+	return dst
+}
+
+func assertIdenticalTimestamps(tss []*timeseries, step int64) {
+	if len(tss) == 0 {
+		return
+	}
+	tsGolden := tss[0]
+	if len(tsGolden.Values) != len(tsGolden.Timestamps) {
+		logger.Panicf("BUG: len(tsGolden.Values) must match len(tsGolden.Timestamps); got %d vs %d", len(tsGolden.Values), len(tsGolden.Timestamps))
+	}
+	if len(tsGolden.Timestamps) > 0 {
+		prevTimestamp := tsGolden.Timestamps[0]
+		for _, timestamp := range tsGolden.Timestamps[1:] {
+			if timestamp-prevTimestamp != step {
+				logger.Panicf("BUG: invalid step between timestamps; got %d; want %d; tsGolden.Timestamps=%d", timestamp-prevTimestamp, step, tsGolden.Timestamps)
+			}
+			prevTimestamp = timestamp
+		}
+	}
+	for _, ts := range tss {
+		if len(ts.Values) != len(tsGolden.Values) {
+			logger.Panicf("BUG: unexpected len(ts.Values); got %d; want %d; ts.Values=%g", len(ts.Values), len(tsGolden.Values), ts.Values)
+		}
+		if len(ts.Timestamps) != len(tsGolden.Timestamps) {
+			logger.Panicf("BUG: unexpected len(ts.Timestamps); got %d; want %d; ts.Timestamps=%d", len(ts.Timestamps), len(tsGolden.Timestamps), ts.Timestamps)
+		}
+		if len(ts.Timestamps) == 0 {
+			continue
+		}
+		if &ts.Timestamps[0] == &tsGolden.Timestamps[0] {
+			// Fast path - shared timestamps.
+			continue
+		}
+		for i := range ts.Timestamps {
+			if ts.Timestamps[i] != tsGolden.Timestamps[i] {
+				logger.Panicf("BUG: timestamps mismatch at position %d; got %d; want %d; ts.Timestamps=%d, tsGolden.Timestamps=%d",
+					i, ts.Timestamps[i], tsGolden.Timestamps[i], ts.Timestamps, tsGolden.Timestamps)
+			}
+		}
+	}
+}

app/vmselect/promql/timeseries_test.go

@@ -0,0 +1,104 @@
+package promql
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+func TestMain(m *testing.M) {
+	n := m.Run()
+	os.Exit(n)
+}
+
+func TestTimeseriesMarshalUnmarshalFast(t *testing.T) {
+	t.Run("single", func(t *testing.T) {
+		var tsOrig timeseries
+		buf := tsOrig.marshalFastNoTimestamps(nil)
+		n := tsOrig.marshaledFastSizeNoTimestamps()
+		if n != len(buf) {
+			t.Fatalf("unexpected marshaled size; got %d; want %d", n, len(buf))
+		}
+
+		var tsGot timeseries
+		tail, err := tsGot.unmarshalFastNoTimestamps(buf)
+		if err != nil {
+			t.Fatalf("cannot unmarshal timeseries: %s", err)
+		}
+		if len(tail) > 0 {
+			t.Fatalf("unexpected non-empty tail left: len(tail)=%d; tail=%X", len(tail), tail)
+		}
+		tsOrig.denyReuse = true
+		tsOrig.MetricName.MetricGroup = []byte{}
+		if !reflect.DeepEqual(&tsOrig, &tsGot) {
+			t.Fatalf("unexpected ts\ngot:\n%s\nwant:\n%s", &tsGot, &tsOrig)
+		}
+	})
+	t.Run("multiple", func(t *testing.T) {
+		var dst []byte
+		var tssOrig []*timeseries
+		timestamps := []int64{2}
+		for i := 0; i < 10; i++ {
+			var ts timeseries
+			ts.denyReuse = true
+			ts.MetricName.MetricGroup = []byte(fmt.Sprintf("metricGroup %d", i))
+			ts.MetricName.Tags = []storage.Tag{{
+				Key:   []byte(fmt.Sprintf("key %d", i)),
+				Value: []byte(fmt.Sprintf("value %d", i)),
+			}}
+			ts.Values = []float64{float64(i) + 0.2}
+			ts.Timestamps = timestamps
+
+			dstLen := len(dst)
+			dst = ts.marshalFastNoTimestamps(dst)
+			n := ts.marshaledFastSizeNoTimestamps()
+			if n != len(dst)-dstLen {
+				t.Fatalf("unexpected marshaled size on iteration %d; got %d; want %d", i, n, len(dst)-dstLen)
+			}
+
+			var tsGot timeseries
+			tsGot.Timestamps = ts.Timestamps
+			tail, err := tsGot.unmarshalFastNoTimestamps(dst[dstLen:])
+			if err != nil {
+				t.Fatalf("cannot unmarshal timeseries on iteration %d: %s", i, err)
+			}
+			if len(tail) > 0 {
+				t.Fatalf("unexpected non-empty tail left on iteration %d: len(tail)=%d; tail=%x", i, len(tail), tail)
+			}
+			if !reflect.DeepEqual(&ts, &tsGot) {
+				t.Fatalf("unexpected ts on iteration %d\ngot:\n%s\nwant:\n%s", i, &tsGot, &ts)
+			}
+
+			tssOrig = append(tssOrig, &ts)
+		}
+		buf := marshalTimeseriesFast(nil, tssOrig, 1e6, 123)
+		tssGot, err := unmarshalTimeseriesFast(buf)
+		if err != nil {
+			t.Fatalf("error in unmarshalTimeseriesFast: %s", err)
+		}
+		if !reflect.DeepEqual(tssOrig, tssGot) {
+			t.Fatalf("unexpected unmarshaled timeseries\ngot:\n%s\nwant:\n%s", tssGot, tssOrig)
+		}
+
+		src := dst
+		for i := 0; i < 10; i++ {
+			tsOrig := tssOrig[i]
+			var ts timeseries
+			ts.Timestamps = tsOrig.Timestamps
+			tail, err := ts.unmarshalFastNoTimestamps(src)
+			if err != nil {
+				t.Fatalf("cannot unmarshal timeseries[%d]: %s", i, err)
+			}
+			src = tail
+			if !reflect.DeepEqual(tsOrig, &ts) {
+				t.Fatalf("unexpected ts on iteration %d:\n%+v\nwant:\n%+v", i, &ts, tsOrig)
+			}
+		}
+		if len(src) > 0 {
+			t.Fatalf("unexpected tail left; len(tail)=%d; tail=%X", len(src), src)
+		}
+	})
+}

app/vmstorage/Makefile

@@ -0,0 +1,38 @@
+# All these commands must run from repository root.
+
+run-vmstorage:
+	mkdir -p vmstorage-data
+	DOCKER_OPTS='-v $(shell pwd)/vmstorage-data:/vmstorage-data' \
+	APP_NAME=vmstorage \
+	ARGS='-retentionPeriod=12' \
+	$(MAKE) run-via-docker
+
+vmstorage:
+	APP_NAME=vmstorage $(MAKE) app-local
+
+vmstorage-race:
+	APP_NAME=vmstorage RACE=-race $(MAKE) app-local
+
+vmstorage-prod:
+	APP_NAME=vmstorage $(MAKE) app-via-docker
+
+vmstorage-prod-race:
+	APP_NAME=vmstorage RACE=-race $(MAKE) app-via-docker
+
+vmstorage-pure:
+	APP_NAME=vmstorage $(MAKE) app-local-pure
+
+vmstorage-pure-prod:
+	APP_NAME=vmstorage APP_SUFFIX='-pure' DOCKER_OPTS='--env CGO_ENABLED=0' $(MAKE) app-via-docker
+
+package-vmstorage:
+	APP_NAME=vmstorage $(MAKE) package-via-docker
+
+package-vmstorage-race:
+	APP_NAME=vmstorage RACE=-race $(MAKE) package-via-docker
+
+publish-vmstorage:
+	APP_NAME=vmstorage $(MAKE) publish-via-docker
+
+publish-vmstorage-race:
+	APP_NAME=vmstorage RACE=-race $(MAKE) publish-via-docker

app/vmstorage/README.md

@@ -0,0 +1,5 @@
+`vmstorage` performs the following tasks:
+
+- Accepts inserts from `vminsert` nodes and stores them to local storage.
+
+- Performs select requests from `vmselect` nodes.

app/vmstorage/deployment/Dockerfile

@@ -0,0 +1,7 @@
+FROM scratch
+COPY --from=local/certs:1.0.2 /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
+COPY bin/vmstorage-prod .
+EXPOSE 8482
+EXPOSE 8400
+EXPOSE 8401
+ENTRYPOINT ["/vmstorage-prod"]

app/vmstorage/main.go

@@ -0,0 +1,477 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage/transport"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/procutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	httpListenAddr  = flag.String("httpListenAddr", ":8482", "Address to listen for http connections")
+	retentionPeriod = flag.Int("retentionPeriod", 1, "Retention period in months")
+	storageDataPath = flag.String("storageDataPath", "vmstorage-data", "Path to storage data")
+	vminsertAddr    = flag.String("vminsertAddr", ":8400", "TCP address to accept connections from vminsert services")
+	vmselectAddr    = flag.String("vmselectAddr", ":8401", "TCP address to accept connections from vmselect services")
+	snapshotAuthKey = flag.String("snapshotAuthKey", "", "authKey, which must be passed in query string to /snapshot* pages")
+)
+
+func main() {
+	flag.Parse()
+	buildinfo.Init()
+	logger.Init()
+
+	logger.Infof("opening storage at %q with retention period %d months", *storageDataPath, *retentionPeriod)
+	startTime := time.Now()
+	strg, err := storage.OpenStorage(*storageDataPath, *retentionPeriod)
+	if err != nil {
+		logger.Fatalf("cannot open a storage at %s with retention period %d months: %s", *storageDataPath, *retentionPeriod, err)
+	}
+
+	var m storage.Metrics
+	strg.UpdateMetrics(&m)
+	tm := &m.TableMetrics
+	partsCount := tm.SmallPartsCount + tm.BigPartsCount
+	blocksCount := tm.SmallBlocksCount + tm.BigBlocksCount
+	rowsCount := tm.SmallRowsCount + tm.BigRowsCount
+	sizeBytes := tm.SmallSizeBytes + tm.BigSizeBytes
+	logger.Infof("successfully opened storage %q in %s; partsCount: %d; blocksCount: %d; rowsCount: %d; sizeBytes: %d",
+		*storageDataPath, time.Since(startTime), partsCount, blocksCount, rowsCount, sizeBytes)
+
+	registerStorageMetrics(strg)
+
+	srv, err := transport.NewServer(*vminsertAddr, *vmselectAddr, strg)
+	if err != nil {
+		logger.Fatalf("cannot create a server with vminsertAddr=%s, vmselectAddr=%s: %s", *vminsertAddr, *vmselectAddr, err)
+	}
+
+	go srv.RunVMInsert()
+	go srv.RunVMSelect()
+
+	requestHandler := newRequestHandler(strg)
+	go func() {
+		httpserver.Serve(*httpListenAddr, requestHandler)
+	}()
+
+	sig := procutil.WaitForSigterm()
+	logger.Infof("service received signal %s", sig)
+
+	logger.Infof("gracefully shutting down the service")
+	startTime = time.Now()
+	srv.MustClose()
+	logger.Infof("successfully shut down the service in %s", time.Since(startTime))
+
+	logger.Infof("gracefully closing the storage at %s", *storageDataPath)
+	startTime = time.Now()
+	strg.MustClose()
+	logger.Infof("successfully closed the storage in %s", time.Since(startTime))
+
+	fs.MustStopDirRemover()
+
+	logger.Infof("the vmstorage has been stopped")
+}
+
+func newRequestHandler(strg *storage.Storage) httpserver.RequestHandler {
+	return func(w http.ResponseWriter, r *http.Request) bool {
+		return requestHandler(w, r, strg)
+	}
+}
+
+func requestHandler(w http.ResponseWriter, r *http.Request, strg *storage.Storage) bool {
+	path := r.URL.Path
+	if !strings.HasPrefix(path, "/snapshot") {
+		return false
+	}
+	authKey := r.FormValue("authKey")
+	if authKey != *snapshotAuthKey {
+		httpserver.Errorf(w, "invalid authKey %q. It must match the value from -snapshotAuthKey command line flag", authKey)
+		return true
+	}
+	path = path[len("/snapshot"):]
+
+	switch path {
+	case "/create":
+		w.Header().Set("Content-Type", "application/json")
+		snapshotPath, err := strg.CreateSnapshot()
+		if err != nil {
+			msg := fmt.Sprintf("cannot create snapshot: %s", err)
+			logger.Errorf("%s", msg)
+			fmt.Fprintf(w, `{"status":"error","msg":%q}`, msg)
+			return true
+		}
+		fmt.Fprintf(w, `{"status":"ok","snapshot":%q}`, snapshotPath)
+		return true
+	case "/list":
+		w.Header().Set("Content-Type", "application/json")
+		snapshots, err := strg.ListSnapshots()
+		if err != nil {
+			msg := fmt.Sprintf("cannot list snapshots: %s", err)
+			logger.Errorf("%s", msg)
+			fmt.Fprintf(w, `{"status":"error","msg":%q}`, msg)
+			return true
+		}
+		fmt.Fprintf(w, `{"status":"ok","snapshots":[`)
+		if len(snapshots) > 0 {
+			for _, snapshot := range snapshots[:len(snapshots)-1] {
+				fmt.Fprintf(w, "\n%q,", snapshot)
+			}
+			fmt.Fprintf(w, "\n%q\n", snapshots[len(snapshots)-1])
+		}
+		fmt.Fprintf(w, `]}`)
+		return true
+	case "/delete":
+		w.Header().Set("Content-Type", "application/json")
+		snapshotName := r.FormValue("snapshot")
+		if err := strg.DeleteSnapshot(snapshotName); err != nil {
+			msg := fmt.Sprintf("cannot delete snapshot %q: %s", snapshotName, err)
+			logger.Errorf("%s", msg)
+			fmt.Fprintf(w, `{"status":"error","msg":%q}`, msg)
+			return true
+		}
+		fmt.Fprintf(w, `{"status":"ok"}`)
+		return true
+	case "/delete_all":
+		w.Header().Set("Content-Type", "application/json")
+		snapshots, err := strg.ListSnapshots()
+		if err != nil {
+			msg := fmt.Sprintf("cannot list snapshots: %s", err)
+			logger.Errorf("%s", msg)
+			fmt.Fprintf(w, `{"status":"error","msg":%q}`, msg)
+			return true
+		}
+		for _, snapshotName := range snapshots {
+			if err := strg.DeleteSnapshot(snapshotName); err != nil {
+				msg := fmt.Sprintf("cannot delete snapshot %q: %s", snapshotName, err)
+				logger.Errorf("%s", msg)
+				fmt.Fprintf(w, `{"status":"error","msg":%q}`, msg)
+				return true
+			}
+		}
+		fmt.Fprintf(w, `{"status":"ok"}`)
+		return true
+	default:
+		return false
+	}
+}
+
+func registerStorageMetrics(strg *storage.Storage) {
+	mCache := &storage.Metrics{}
+	var mCacheLock sync.Mutex
+	var lastUpdateTime time.Time
+
+	m := func() *storage.Metrics {
+		mCacheLock.Lock()
+		defer mCacheLock.Unlock()
+		if time.Since(lastUpdateTime) < time.Second {
+			return mCache
+		}
+		var mc storage.Metrics
+		strg.UpdateMetrics(&mc)
+		mCache = &mc
+		lastUpdateTime = time.Now()
+		return mCache
+	}
+	tm := func() *storage.TableMetrics {
+		sm := m()
+		return &sm.TableMetrics
+	}
+	idbm := func() *storage.IndexDBMetrics {
+		sm := m()
+		return &sm.IndexDBMetrics
+	}
+
+	metrics.NewGauge(`vm_active_merges{type="storage/big"}`, func() float64 {
+		return float64(tm().ActiveBigMerges)
+	})
+	metrics.NewGauge(`vm_active_merges{type="storage/small"}`, func() float64 {
+		return float64(tm().ActiveSmallMerges)
+	})
+	metrics.NewGauge(`vm_active_merges{type="indexdb"}`, func() float64 {
+		return float64(idbm().ActiveMerges)
+	})
+
+	metrics.NewGauge(`vm_merges_total{type="storage/big"}`, func() float64 {
+		return float64(tm().BigMergesCount)
+	})
+	metrics.NewGauge(`vm_merges_total{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallMergesCount)
+	})
+	metrics.NewGauge(`vm_merges_total{type="indexdb"}`, func() float64 {
+		return float64(idbm().MergesCount)
+	})
+
+	metrics.NewGauge(`vm_rows_merged_total{type="storage/big"}`, func() float64 {
+		return float64(tm().BigRowsMerged)
+	})
+	metrics.NewGauge(`vm_rows_merged_total{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallRowsMerged)
+	})
+	metrics.NewGauge(`vm_rows_merged_total{type="indexdb"}`, func() float64 {
+		return float64(idbm().ItemsMerged)
+	})
+
+	metrics.NewGauge(`vm_rows_deleted_total{type="storage/big"}`, func() float64 {
+		return float64(tm().BigRowsDeleted)
+	})
+	metrics.NewGauge(`vm_rows_deleted_total{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallRowsDeleted)
+	})
+
+	metrics.NewGauge(`vm_references{type="storage/big", name="parts"}`, func() float64 {
+		return float64(tm().BigPartsRefCount)
+	})
+	metrics.NewGauge(`vm_references{type="storage/small", name="parts"}`, func() float64 {
+		return float64(tm().SmallPartsRefCount)
+	})
+	metrics.NewGauge(`vm_references{type="storage", name="partitions"}`, func() float64 {
+		return float64(tm().PartitionsRefCount)
+	})
+	metrics.NewGauge(`vm_references{type="indexdb", name="objects"}`, func() float64 {
+		return float64(idbm().IndexDBRefCount)
+	})
+	metrics.NewGauge(`vm_references{type="indexdb", name="parts"}`, func() float64 {
+		return float64(idbm().PartsRefCount)
+	})
+
+	metrics.NewGauge(`vm_missing_tsids_for_metric_id_total`, func() float64 {
+		return float64(idbm().MissingTSIDsForMetricID)
+	})
+	metrics.NewGauge(`vm_recent_hour_metric_ids_search_calls_total`, func() float64 {
+		return float64(idbm().RecentHourMetricIDsSearchCalls)
+	})
+	metrics.NewGauge(`vm_recent_hour_metric_ids_search_hits_total`, func() float64 {
+		return float64(idbm().RecentHourMetricIDsSearchHits)
+	})
+	metrics.NewGauge(`vm_date_metric_ids_search_calls_total`, func() float64 {
+		return float64(idbm().DateMetricIDsSearchCalls)
+	})
+	metrics.NewGauge(`vm_date_metric_ids_search_hits_total`, func() float64 {
+		return float64(idbm().DateMetricIDsSearchHits)
+	})
+
+	metrics.NewGauge(`vm_assisted_merges_total{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallAssistedMerges)
+	})
+	metrics.NewGauge(`vm_assisted_merges_total{type="indexdb"}`, func() float64 {
+		return float64(idbm().AssistedMerges)
+	})
+
+	metrics.NewGauge(`vm_pending_rows{type="storage"}`, func() float64 {
+		return float64(tm().PendingRows)
+	})
+	metrics.NewGauge(`vm_pending_rows{type="indexdb"}`, func() float64 {
+		return float64(idbm().PendingItems)
+	})
+
+	metrics.NewGauge(`vm_parts{type="storage/big"}`, func() float64 {
+		return float64(tm().BigPartsCount)
+	})
+	metrics.NewGauge(`vm_parts{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallPartsCount)
+	})
+	metrics.NewGauge(`vm_parts{type="indexdb"}`, func() float64 {
+		return float64(idbm().PartsCount)
+	})
+
+	metrics.NewGauge(`vm_blocks{type="storage/big"}`, func() float64 {
+		return float64(tm().BigBlocksCount)
+	})
+	metrics.NewGauge(`vm_blocks{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallBlocksCount)
+	})
+	metrics.NewGauge(`vm_blocks{type="indexdb"}`, func() float64 {
+		return float64(idbm().BlocksCount)
+	})
+
+	metrics.NewGauge(`vm_data_size_bytes{type="storage/big"}`, func() float64 {
+		return float64(tm().BigSizeBytes)
+	})
+	metrics.NewGauge(`vm_data_size_bytes{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallSizeBytes)
+	})
+	metrics.NewGauge(`vm_data_size_bytes{type="indexdb"}`, func() float64 {
+		return float64(idbm().SizeBytes)
+	})
+
+	metrics.NewGauge(`vm_rows_ignored_total{reason="big_timestamp"}`, func() float64 {
+		return float64(m().TooBigTimestampRows)
+	})
+	metrics.NewGauge(`vm_rows_ignored_total{reason="small_timestamp"}`, func() float64 {
+		return float64(m().TooSmallTimestampRows)
+	})
+
+	metrics.NewGauge(`vm_concurrent_addrows_limit_reached_total`, func() float64 {
+		return float64(m().AddRowsConcurrencyLimitReached)
+	})
+	metrics.NewGauge(`vm_concurrent_addrows_limit_timeout_total`, func() float64 {
+		return float64(m().AddRowsConcurrencyLimitTimeout)
+	})
+	metrics.NewGauge(`vm_concurrent_addrows_dropped_rows_total`, func() float64 {
+		return float64(m().AddRowsConcurrencyDroppedRows)
+	})
+	metrics.NewGauge(`vm_concurrent_addrows_capacity`, func() float64 {
+		return float64(m().AddRowsConcurrencyCapacity)
+	})
+	metrics.NewGauge(`vm_concurrent_addrows_current`, func() float64 {
+		return float64(m().AddRowsConcurrencyCurrent)
+	})
+
+	metrics.NewGauge(`vm_rows{type="storage/big"}`, func() float64 {
+		return float64(tm().BigRowsCount)
+	})
+	metrics.NewGauge(`vm_rows{type="storage/small"}`, func() float64 {
+		return float64(tm().SmallRowsCount)
+	})
+	metrics.NewGauge(`vm_rows{type="indexdb"}`, func() float64 {
+		return float64(idbm().ItemsCount)
+	})
+
+	metrics.NewGauge(`vm_cache_entries{type="storage/tsid"}`, func() float64 {
+		return float64(m().TSIDCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/metricIDs"}`, func() float64 {
+		return float64(m().MetricIDCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/metricName"}`, func() float64 {
+		return float64(m().MetricNameCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/date_metricID"}`, func() float64 {
+		return float64(m().DateMetricIDCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/hour_metric_ids"}`, func() float64 {
+		return float64(m().HourMetricIDCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/bigIndexBlocks"}`, func() float64 {
+		return float64(tm().BigIndexBlocksCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/smallIndexBlocks"}`, func() float64 {
+		return float64(tm().SmallIndexBlocksCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="indexdb/dataBlocks"}`, func() float64 {
+		return float64(idbm().DataBlocksCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="indexdb/indexBlocks"}`, func() float64 {
+		return float64(idbm().IndexBlocksCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="indexdb/tagFilters"}`, func() float64 {
+		return float64(idbm().TagCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="indexdb/uselessTagFilters"}`, func() float64 {
+		return float64(idbm().UselessTagFiltersCacheSize)
+	})
+	metrics.NewGauge(`vm_cache_entries{type="storage/regexps"}`, func() float64 {
+		return float64(storage.RegexpCacheSize())
+	})
+
+	metrics.NewGauge(`vm_cache_size_bytes{type="storage/tsid"}`, func() float64 {
+		return float64(m().TSIDCacheSizeBytes)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="storage/metricIDs"}`, func() float64 {
+		return float64(m().MetricIDCacheSizeBytes)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="storage/metricName"}`, func() float64 {
+		return float64(m().MetricNameCacheSizeBytes)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="storage/date_metricID"}`, func() float64 {
+		return float64(m().DateMetricIDCacheSizeBytes)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="indexdb/tagFilters"}`, func() float64 {
+		return float64(idbm().TagCacheSizeBytes)
+	})
+	metrics.NewGauge(`vm_cache_size_bytes{type="indexdb/uselessTagFilters"}`, func() float64 {
+		return float64(idbm().UselessTagFiltersCacheSizeBytes)
+	})
+
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/tsid"}`, func() float64 {
+		return float64(m().TSIDCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/metricIDs"}`, func() float64 {
+		return float64(m().MetricIDCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/metricName"}`, func() float64 {
+		return float64(m().MetricNameCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/date_metricID"}`, func() float64 {
+		return float64(m().DateMetricIDCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/bigIndexBlocks"}`, func() float64 {
+		return float64(tm().BigIndexBlocksCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/smallIndexBlocks"}`, func() float64 {
+		return float64(tm().SmallIndexBlocksCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="indexdb/dataBlocks"}`, func() float64 {
+		return float64(idbm().DataBlocksCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="indexdb/indexBlocks"}`, func() float64 {
+		return float64(idbm().IndexBlocksCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="indexdb/tagFilters"}`, func() float64 {
+		return float64(idbm().TagCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="indexdb/uselessTagFilters"}`, func() float64 {
+		return float64(idbm().UselessTagFiltersCacheRequests)
+	})
+	metrics.NewGauge(`vm_cache_requests_total{type="storage/regexps"}`, func() float64 {
+		return float64(storage.RegexpCacheRequests())
+	})
+
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/tsid"}`, func() float64 {
+		return float64(m().TSIDCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/metricIDs"}`, func() float64 {
+		return float64(m().MetricIDCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/metricName"}`, func() float64 {
+		return float64(m().MetricNameCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/date_metricID"}`, func() float64 {
+		return float64(m().DateMetricIDCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/bigIndexBlocks"}`, func() float64 {
+		return float64(tm().BigIndexBlocksCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/smallIndexBlocks"}`, func() float64 {
+		return float64(tm().SmallIndexBlocksCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="indexdb/dataBlocks"}`, func() float64 {
+		return float64(idbm().DataBlocksCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="indexdb/indexBlocks"}`, func() float64 {
+		return float64(idbm().IndexBlocksCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="indexdb/tagFilters"}`, func() float64 {
+		return float64(idbm().TagCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="indexdb/uselessTagFilters"}`, func() float64 {
+		return float64(idbm().UselessTagFiltersCacheMisses)
+	})
+	metrics.NewGauge(`vm_cache_misses_total{type="storage/regexps"}`, func() float64 {
+		return float64(storage.RegexpCacheMisses())
+	})
+
+	metrics.NewGauge(`vm_deleted_metrics_total{type="indexdb"}`, func() float64 {
+		return float64(idbm().DeletedMetricsCount)
+	})
+
+	metrics.NewGauge(`vm_cache_collisions_total{type="storage/tsid"}`, func() float64 {
+		return float64(m().TSIDCacheCollisions)
+	})
+	metrics.NewGauge(`vm_cache_collisions_total{type="storage/metricName"}`, func() float64 {
+		return float64(m().MetricNameCacheCollisions)
+	})
+	metrics.NewGauge(`vm_cache_collisions_total{type="storage/date_metricID"}`, func() float64 {
+		return float64(m().DateMetricIDCacheCollisions)
+	})
+}