Add CODE_OF_CONDUCT.md

Add a template for feature request

.dockerignore

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,30 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Version**
+The line returned when passing `--version` command line flag to binary. For example:
+```
+$ ./victoria-metrics-prod --version
+victoria-metrics-20190730-121249-heads-single-node-0-g671d9e55
+```
+
+**Additional context**
+Add any other context about the problem here such as error logs, `/metrics` output, screenshots from [the official Grafana dashboard for VictoriaMetrics](https://grafana.com/dashboards/10229).

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -0,0 +1,15 @@
+/tags
+/pkg
+*.pprof
+/bin
+.idea
+*.test
+*.swp
+/gocache-for-docker
+/victoria-metrics-data
+/vmstorage-data
+/vmselect-cache
+/package/temp-deb-*
+/package/temp-rpm-*
+/package/*.deb
+/package/*.rpm

.travis.yml

@@ -0,0 +1,26 @@
+language: go
+
+go:
+  - 1.12.x
+
+install: make
+
+env:
+  - GO111MODULE=on
+
+before_install:
+  - GO111MODULE=off go get -v golang.org/x/lint/golint
+  - GO111MODULE=off go get -u github.com/kisielk/errcheck
+
+script:
+  - make check_all
+  - git diff --exit-code
+  - make test-full
+  - make test-pure
+  - make victoria-metrics
+  - make victoria-metrics-pure
+  - make victoria-metrics-arm
+  - make victoria-metrics-arm64
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at info@victoriametrics.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,16 @@
+If you like VictoriaMetrics and want to contribute, then we need the following:
+
+- Filing issues and feature requests [here](https://github.com/VictoriaMetrics/VictoriaMetrics/issues).
+- Spreading a word about VictoriaMetrics: conference talks, articles, comments, experience sharing with colleagues.
+- Updating documentation.
+
+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.

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,89 @@
+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 | sha1sum | grep -oP '^.{8}')))
+
+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: \
+	victoria-metrics-prod
+
+include app/*/Makefile
+include deployment/*/Makefile
+
+clean:
+	rm -rf bin/*
+
+publish: publish-victoria-metrics
+
+package: package-victoria-metrics
+
+release: victoria-metrics-prod
+	cd bin && tar czf victoria-metrics-$(PKG_TAG).tar.gz victoria-metrics-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 -tags=integration -mod=vendor ./lib/... ./app/...
+
+test-pure:
+	GO111MODULE=on CGO_ENABLED=0 go test -tags=integration -mod=vendor ./lib/... ./app/...
+
+test-full:
+	GO111MODULE=on go test -tags=integration -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
+
+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,37 +1,688 @@
-<img  text-align="center" alt="Victoria Metrics" src="logo.png">
-
-## VictoriaMetrics - the best long-term remote storage for Prometheus
-
 [![Latest Release](https://img.shields.io/github/release/VictoriaMetrics/VictoriaMetrics.svg?style=flat-square)](https://github.com/VictoriaMetrics/VictoriaMetrics/releases/latest)
+[![Slack](https://img.shields.io/badge/join%20slack-%23victoriametrics-brightgreen.svg)](http://slack.victoriametrics.com/)
+[![GitHub license](https://img.shields.io/github/license/VictoriaMetrics/VictoriaMetrics.svg)](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/LICENSE)
+[![Go Report](https://goreportcard.com/badge/github.com/VictoriaMetrics/VictoriaMetrics)](https://goreportcard.com/report/github.com/VictoriaMetrics/VictoriaMetrics)
+[![Build Status](https://travis-ci.org/VictoriaMetrics/VictoriaMetrics.svg?branch=master)](https://travis-ci.org/VictoriaMetrics/VictoriaMetrics)
+[![codecov](https://codecov.io/gh/VictoriaMetrics/VictoriaMetrics/branch/master/graph/badge.svg)](https://codecov.io/gh/VictoriaMetrics/VictoriaMetrics)
 
-### VictoriaMetrics features
+<img alt="Victoria Metrics" src="logo.png">
 
-- Native [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.
-- Accepts data in [InfluxDB line protocol](https://docs.influxdata.com/influxdb/v1.7/write_protocols/line_protocol_reference/), so [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/) and other influx-compatible agents may send data to VictoriaMetrics.
-- [Single-server VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics/releases) accepts data in [Graphite plaintext protocol](https://graphite.readthedocs.io/en/latest/feeding-carbon.html#the-plaintext-protocol) if `-graphiteListenAddr` is set.
+## Single-node VictoriaMetrics
+
+VictoriaMetrics is fast, cost-effective and scalable time-series database. It can be used as long-term remote storage for Prometheus.
+It is available in [binary releases](https://github.com/VictoriaMetrics/VictoriaMetrics/releases),
+[docker images](https://hub.docker.com/r/victoriametrics/victoria-metrics/) and
+in [source code](https://github.com/VictoriaMetrics/VictoriaMetrics).
+
+Cluster version is available [here](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/cluster).
 
 
-### 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 [Prometheus querying API](https://prometheus.io/docs/prometheus/latest/querying/api/), so it can be used as Prometheus drop-in replacement in Grafana.
+  Additionally, VictoriaMetrics extends PromQL with opt-in [useful features](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki/ExtendedPromQL).
+* Global query view. Multiple Prometheus instances may write data into VictoriaMetrics. Later this data may be used in a single query.
+* High performance and good scalability for both [inserts](https://medium.com/@valyala/high-cardinality-tsdb-benchmarks-victoriametrics-vs-timescaledb-vs-influxdb-13e6ee64dd6b)
+  and [selects](https://medium.com/@valyala/when-size-matters-benchmarking-victoriametrics-vs-timescale-and-influxdb-6035811952d4).
+  [Outperforms InfluxDB and TimescaleDB by up to 20x](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae).
+* [Uses 10x less RAM than InfluxDB](https://medium.com/@valyala/insert-benchmarks-with-inch-influxdb-vs-victoriametrics-e31a41ae2893) when working with millions of unique time series (aka high cardinality).
+* High data compression, so [up to 70x more data points](https://medium.com/@valyala/when-size-matters-benchmarking-victoriametrics-vs-timescale-and-influxdb-6035811952d4)
+  may be crammed into limited storage comparing to TimescaleDB.
+* Optimized for storage with high-latency IO and low IOPS (HDD and network storage in AWS, Google Cloud, Microsoft Azure, etc). See [graphs from these benchmarks](https://medium.com/@valyala/high-cardinality-tsdb-benchmarks-victoriametrics-vs-timescaledb-vs-influxdb-13e6ee64dd6b).
+* A single-node VictoriaMetrics may substitute moderately sized clusters built with competing solutions such as Thanos, Uber M3, Cortex, InfluxDB or TimescaleDB.
+  See [vertical scalability benchmarks](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae)
+  and [comparing Thanos to VictoriaMetrics cluster](https://medium.com/@valyala/comparing-thanos-to-victoriametrics-cluster-b193bea1683).
+* Easy operation:
+  * VictoriaMetrics consists of a single executable without external dependencies.
+  * All the configuration is done via explicit command-line flags with reasonable defaults.
+  * All the data is stored in a single directory pointed by `-storageDataPath` flag.
+  * Easy backups from [instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282).
+* Storage is protected from corruption on unclean shutdown (i.e. hardware reset or `kill -9`) thanks to [the storage architecture](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282).
+* Supports metrics' ingestion and backfilling via the following protocols:
+  * [Prometheus remote write API](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write)
+  * [InfluxDB line protocol](https://docs.influxdata.com/influxdb/v1.7/write_protocols/line_protocol_tutorial/)
+  * [Graphite plaintext protocol](https://graphite.readthedocs.io/en/latest/feeding-carbon.html) with [tags](https://graphite.readthedocs.io/en/latest/tags.html#carbon)
+    if `-graphiteListenAddr` is set.
+  * [OpenTSDB put message](http://opentsdb.net/docs/build/html/api_telnet/put.html) if `-opentsdbListenAddr` is set.
+* Ideally works with big amounts of time series data from Kubernetes, IoT sensors, connected cars and industrial telemetry.
+* Has open source [cluster version](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/cluster).
 
 
-### Victoria Metrics Logo
+## Operation
+
+
+### Table of contents
+
+  - [How to start VictoriaMetrics](#how-to-start-victoriametrics)
+  - [Prometheus setup](#prometheus-setup)
+  - [Grafana setup](#grafana-setup)
+  - [How to upgrade VictoriaMetrics?](#how-to-upgrade-victoriametrics)
+  - [How to apply new config to VictoriaMetrics?](#how-to-apply-new-config-to-victoriametrics)
+  - [How to send data from InfluxDB-compatible agents such as Telegraf?](#how-to-send-data-from-influxdb-compatible-agents-such-as-telegraf)
+  - [How to send data from Graphite-compatible agents such as StatsD?](#how-to-send-data-from-graphite-compatible-agents-such-as-statsd)
+  - [Querying Graphite data](#querying-graphite-data)
+  - [How to send data from OpenTSDB-compatible agents?](#how-to-send-data-from-opentsdb-compatible-agents)
+  - [How to build from sources](#how-to-build-from-sources)
+    - [Development build](#development-build)
+    - [Production build](#production-build)
+    - [ARM build](#arm-build)
+    - [Pure Go build (CGO_ENABLED=0)](#pure-go-build-cgo_enabled0)
+    - [Building docker images](#building-docker-images)
+  - [Start with docker-compose](#start-with-docker-compose)
+  - [Setting up service](#setting-up-service)
+  - [Third-party contributions](#third-party-contributions)
+  - [How to work with snapshots?](#how-to-work-with-snapshots)
+  - [How to delete time series?](#how-to-delete-time-series)
+  - [How to export time series?](#how-to-export-time-series)
+  - [Federation](#federation)
+  - [Capacity planning](#capacity-planning)
+  - [High availability](#high-availability)
+  - [Multiple retentions](#multiple-retentions)
+  - [Downsampling](#downsampling)
+  - [Multi-tenancy](#multi-tenancy)
+  - [Scalability and cluster version](#scalability-and-cluster-version)
+  - [Alerting](#alerting)
+  - [Security](#security)
+  - [Tuning](#tuning)
+  - [Monitoring](#monitoring)
+  - [Troubleshooting](#troubleshooting)
+- [Roadmap](#roadmap)
+- [Contacts](#contacts)
+- [Community and contributions](#community-and-contributions)
+- [Reporting bugs](#reporting-bugs)
+- [Victoria Metrics Logo](#victoria-metrics-logo)
+  - [Logo Usage Guidelines](#logo-usage-guidelines)
+    - [Font used:](#font-used)
+    - [Color Palette:](#color-palette)
+  - [We kindly ask:](#we-kindly-ask)
+
+
+### How to start VictoriaMetrics
+
+Just start VictoriaMetrics [executable](https://github.com/VictoriaMetrics/VictoriaMetrics/releases)
+or [docker image](https://hub.docker.com/r/victoriametrics/victoria-metrics/) with the desired command-line flags.
+
+The following command-line flags are used the most:
+
+* `-storageDataPath` - path to data directory. VictoriaMetrics stores all the data in this directory.
+* `-retentionPeriod` - retention period in months for the data. Older data is automatically deleted.
+* `-httpListenAddr` - TCP address to listen to for http requests. By default, it listens port `8428` on all the network interfaces.
+* `-graphiteListenAddr` - TCP and UDP address to listen to for Graphite data. By default, it is disabled.
+* `-opentsdbListenAddr` - TCP and UDP address to listen to for OpenTSDB data. By default, it is disabled.
+
+Pass `-help` to see all the available flags with description and default values.
+
+
+### Prometheus setup
+
+Add the following lines to Prometheus config file (it is usually located at `/etc/prometheus/prometheus.yml`):
+
+```yml
+remote_write:
+  - url: http://<victoriametrics-addr>:8428/api/v1/write
+    queue_config:
+      max_samples_per_send: 10000
+      max_shards: 100
+```
+
+Substitute `<victoriametrics-addr>` with the hostname or IP address of VictoriaMetrics.
+Then apply the new config via the following command:
+
+```
+kill -HUP `pidof prometheus`
+```
+
+Prometheus writes incoming data to local storage and replicates it to remote storage in parallel.
+This means the data remains available in local storage for `--storage.tsdb.retention.time` duration
+even if remote storage is unavailable.
+
+If you plan to send data to VictoriaMetrics from multiple Prometheus instances, then add the following lines into `global` section
+of [Prometheus config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#configuration-file):
+
+```yml
+global:
+  external_labels:
+    datacenter: dc-123
+```
+
+This instructs Prometheus to add `datacenter=dc-123` label to each time series sent to remote storage.
+The label name may be arbitrary - `datacenter` is just an example. The label value must be unique
+across Prometheus instances, so those time series may be filtered and grouped by this label.
+
+
+It is recommended upgrading Prometheus to [v2.10.0](https://github.com/prometheus/prometheus/releases) or newer,
+since the previous versions may have issues with `remote_write`.
+
+
+### Grafana setup
+
+Create [Prometheus datasource](http://docs.grafana.org/features/datasources/prometheus/) in Grafana with the following Url:
+
+```
+http://<victoriametrics-addr>:8428
+```
+
+Substitute `<victoriametrics-addr>` with the hostname or IP address of VictoriaMetrics.
+
+Then build graphs with the created datasource using [Prometheus query language](https://prometheus.io/docs/prometheus/latest/querying/basics/).
+VictoriaMetrics supports native PromQL and [extends it with useful features](ExtendedPromQL).
+
+
+### How to upgrade VictoriaMetrics?
+
+It is safe upgrading VictoriaMetrics to new versions unless [release notes](https://github.com/VictoriaMetrics/VictoriaMetrics/releases)
+say otherwise. It is recommended performing regular upgrades to the latest version,
+since it may contain important bug fixes, performance optimizations or new features.
+
+Follow the following steps during the upgrade:
+
+1) Send `SIGINT` signal to VictoriaMetrics process in order to gracefully stop it.
+2) Wait until the process stops. This can take a few seconds.
+3) Start the upgraded VictoriaMetrics.
+
+
+### How to apply new config to VictoriaMetrics?
+
+VictoriaMetrics must be restarted for applying new config:
+
+1) Send `SIGINT` signal to VictoriaMetrics process in order to gracefully stop it.
+2) Wait until the process stops. This can take a few seconds.
+3) Start VictoriaMetrics with the new config.
+
+
+### How to send data from InfluxDB-compatible agents such as [Telegraf](https://www.influxdata.com/time-series-platform/telegraf/)?
+
+Just use `http://<victoriametric-addr>:8428` url instead of InfluxDB url in agents' configs.
+For instance, put the following lines into `Telegraf` config, so it sends data to VictoriaMetrics instead of InfluxDB:
+
+```
+[[outputs.influxdb]]
+  urls = ["http://<victoriametrics-addr>:8428"]
+```
+
+Do not forget substituting `<victoriametrics-addr>` with the real address where VictoriaMetrics runs.
+
+VictoriaMetrics maps Influx data using the following rules:
+* [`db` query arg](https://docs.influxdata.com/influxdb/v1.7/tools/api/#write-http-endpoint) is mapped into `db` label value.
+* Field names are mapped to time series names prefixed with `{measurement}{separator}` value,
+  where `{separator}` equals to `_` by default. It can be changed with `-influxMeasurementFieldSeparator` command-line flag.
+  See also `-influxSkipSingleField` command-line flag.
+* Field values are mapped to time series values.
+* Tags are mapped to Prometheus labels as-is.
+
+For example, the following Influx line:
+
+```
+foo,tag1=value1,tag2=value2 field1=12,field2=40
+```
+
+is converted into the following Prometheus data points:
+
+```
+foo.field1{tag1="value1", tag2="value2"} 12
+foo.field2{tag1="value1", tag2="value2"} 40
+```
+
+Example for writing data with [Influx line protocol](https://docs.influxdata.com/influxdb/v1.7/write_protocols/line_protocol_tutorial/)
+to local VictoriaMetrics using `curl`:
+
+```
+curl -d 'measurement,tag1=value1,tag2=value2 field1=123,field2=1.23' -X POST 'http://localhost:8428/write'
+```
+
+An arbitrary number of lines delimited by '\n' may be sent in a single request.
+After that the data may be read via [/api/v1/export](#how-to-export-time-series) endpoint:
+
+```
+curl -G 'http://localhost:8428/api/v1/export' --data-urlencode 'match={__name__!=""}'
+```
+
+The `/api/v1/export` endpoint should return the following response:
+
+```
+{"metric":{"__name__":"measurement.field1","tag1":"value1","tag2":"value2"},"values":[123],"timestamps":[1560272508147]}
+{"metric":{"__name__":"measurement.field2","tag1":"value1","tag2":"value2"},"values":[1.23],"timestamps":[1560272508147]}
+```
+
+
+### How to send data from Graphite-compatible agents such as [StatsD](https://github.com/etsy/statsd)?
+
+1) Enable Graphite receiver in VictoriaMetrics by setting `-graphiteListenAddr` command line flag. For instance,
+the following command will enable Graphite receiver in VictoriaMetrics on TCP and UDP port `2003`:
+
+```
+/path/to/victoria-metrics-prod -graphiteListenAddr=:2003
+```
+
+2) Use the configured address in Graphite-compatible agents. For instance, set `graphiteHost`
+to the VictoriaMetrics host in `StatsD` configs.
+
+
+Example for writing data with Graphite plaintext protocol to local VictoriaMetrics using `nc`:
+
+```
+echo "foo.bar.baz;tag1=value1;tag2=value2 123 `date +%s`" | nc -N localhost 2003
+```
+
+VictoriaMetrics sets the current time if the timestamp is omitted.
+An arbitrary number of lines delimited by `\n` may be sent in one go.
+After that the data may be read via [/api/v1/export](#how-to-export-time-series) endpoint:
+
+```
+curl -G 'http://localhost:8428/api/v1/export' --data-urlencode 'match={__name__!=""}'
+```
+
+The `/api/v1/export` endpoint should return the following response:
+
+```
+{"metric":{"__name__":"foo.bar.baz","tag1":"value1","tag2":"value2"},"values":[123],"timestamps":[1560277406000]}
+```
+
+
+### Querying Graphite data
+
+Data sent to VictoriaMetrics via `Graphite plaintext protocol` may be read either via
+[Prometheus querying API](https://prometheus.io/docs/prometheus/latest/querying/api/)
+or via [go-graphite/carbonapi](https://github.com/go-graphite/carbonapi/blob/master/cmd/carbonapi/carbonapi.example.prometheus.yaml).
+
+
+
+### How to send data from OpenTSDB-compatible agents?
+
+1) Enable OpenTSDB receiver in VictoriaMetrics by setting `-opentsdbListenAddr` command line flag. For instance,
+the following command will enable OpenTSDB receiver in VictoriaMetrics on TCP and UDP port `4242`:
+
+```
+/path/to/victoria-metrics-prod -opentsdbListenAddr=:4242
+```
+
+2) Send data to the given address from OpenTSDB-compatible agents.
+
+
+Example for writing data with OpenTSDB protocol to local VictoriaMetrics using `nc`:
+
+```
+echo "put foo.bar.baz `date +%s` 123 tag1=value1 tag2=value2" | nc -N localhost 4242
+```
+
+An arbitrary number of lines delimited by `\n` may be sent in one go.
+After that the data may be read via [/api/v1/export](#how-to-export-time-series) endpoint:
+
+```
+curl -G 'http://localhost:8428/api/v1/export' --data-urlencode 'match={__name__!=""}'
+```
+
+The `/api/v1/export` endpoint should return the following response:
+
+```
+{"metric":{"__name__":"foo.bar.baz","tag1":"value1","tag2":"value2"},"values":[123],"timestamps":[1560277292000]}
+```
+
+
+### How to build from sources
+
+We recommend using either [binary releases](https://github.com/VictoriaMetrics/VictoriaMetrics/releases) or
+[docker images](https://hub.docker.com/r/victoriametrics/victoria-metrics/) instead of building VictoriaMetrics
+from sources. Building from sources is reasonable when developing additional features specific
+to your needs.
+
+
+#### Development build
+
+1. [Install Go](https://golang.org/doc/install). The minimum supported version is Go 1.12.
+2. Run `make victoria-metrics` from the root folder of the repository.
+   It builds `victoria-metrics` binary and puts it into the `bin` folder.
+
+#### Production build
+
+1. [Install docker](https://docs.docker.com/install/).
+2. Run `make victoria-metrics-prod` from the root folder of the repository.
+   It builds `victoria-metrics-prod` binary and puts it into the `bin` folder.
+
+#### ARM build
+
+ARM build may run on Raspberry Pi or on [energy-efficient ARM servers](https://blog.cloudflare.com/arm-takes-wing/).
+
+#### Development ARM build
+
+1. [Install Go](https://golang.org/doc/install). The minimum supported version is Go 1.12.
+2. Run `make victoria-metrics-arm` or `make victoria-metrics-arm64` from the root folder of the repository.
+   It builds `victoria-metrics-arm` or `victoria-metrics-arm64` binary respectively and puts it into the `bin` folder.
+
+#### Production ARM build
+
+1. [Install docker](https://docs.docker.com/install/).
+2. Run `make victoria-metrics-arm-prod` or `make victoria-metrics-arm64-prod` from the root folder of the repository.
+   It builds `victoria-metrics-arm-prod` or `victoria-metrics-arm64-prod` binary respectively and puts it into the `bin` folder.
+
+#### Pure Go build (CGO_ENABLED=0)
+
+`Pure Go` mode builds only Go code without [cgo](https://golang.org/cmd/cgo/) dependencies.
+This is an experimental mode, which may result in a lower compression ratio and slower decompression performance.
+Use it with caution!
+
+1. [Install Go](https://golang.org/doc/install). The minimum supported version is Go 1.12.
+2. Run `make victoria-metrics-pure` from the root folder of the repository.
+   It builds `victoria-metrics-pure` binary and puts it into the `bin` folder.
+
+#### Building docker images
+
+Run `make package-victoria-metrics`. It builds `victoriametrics/victoria-metrics:<PKG_TAG>` docker image locally.
+`<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-victoria-metrics`.
+
+
+### Start with docker-compose
+
+[Docker-compose](https://github.com/VictoriaMetrics/VictoriaMetrics/blob/master/deployment/docker/docker-compose.yml)
+helps to spin up VictoriaMetrics, Prometheus and Grafana with one command.
+More details may be found [here](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/master/deployment/docker#folder-contains-basic-images-and-tools-for-building-and-running-victoria-metrics-in-docker).
+
+
+### Setting up service
+
+Read [these instructions](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/43) on how to set up VictoriaMetrics as a service in your OS.
+
+
+### Third-party contributions
+
+* [Unofficial yum repository](https://copr.fedorainfracloud.org/coprs/antonpatsev/VictoriaMetrics/) ([source code](https://github.com/patsevanton/victoriametrics-rpm))
+
+
+### How to work with snapshots?
+
+VictoriaMetrics can create [instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282)
+for all the data stored under `-storageDataPath` directory.
+Navigate to `http://<victoriametrics-addr>:8428/snapshot/create` in order to create an instant snapshot.
+The page will return the following JSON response:
+
+```
+{"status":"ok","snapshot":"<snapshot-name>"}
+```
+
+Snapshots are created under `<-storageDataPath>/snapshots` directory, where `<-storageDataPath>`
+is the command-line flag value. Snapshots can be archived to backup storage via `cp -L`, `rsync -L`, `scp -r`
+or any similar tool that follows symlinks during copying.
+
+The `http://<victoriametrics-addr>:8428/snapshot/list` page contains the list of available snapshots.
+
+Navigate to `http://<victoriametrics-addr>:8428/snapshot/delete?snapshot=<snapshot-name>` in order
+to delete `<snapshot-name>` snapshot.
+
+Navigate to `http://<victoriametrics-addr>:8428/snapshot/delete_all` in order to delete all the snapshots.
+
+Steps for restoring from a snapshot:
+1. Stop VictoriaMetrics with `kill -INT`.
+2. Remove the entire contents of the directory pointed by `-storageDataPath` command-line flag.
+3. Copy snapshot contents to the directory pointed by `-storageDataPath`.
+4. Start VictoriaMetrics.
+
+
+### How to delete time series?
+
+Send a request to `http://<victoriametrics-addr>:8428/api/v1/admin/tsdb/delete_series?match[]=<timeseries_selector_for_delete>`,
+where `<timeseries_selector_for_delete>` may contain any [time series selector](https://prometheus.io/docs/prometheus/latest/querying/basics/#time-series-selectors)
+for metrics to delete. After that all the time series matching the given selector are deleted. Storage space for
+the deleted time series isn't freed instantly - it is freed during subsequent merges of data files.
+
+
+### How to export time series?
+
+Send a request to `http://<victoriametrics-addr>:8428/api/v1/export?match[]=<timeseries_selector_for_export>`,
+where `<timeseries_selector_for_export>` may contain any [time series selector](https://prometheus.io/docs/prometheus/latest/querying/basics/#time-series-selectors)
+for metrics to export. The response would contain all the data for the selected time series in [JSON streaming format](https://en.wikipedia.org/wiki/JSON_streaming#Line-delimited_JSON).
+Each JSON line would contain data for a single time series. An example output:
+
+```
+{"metric":{"__name__":"up","job":"node_exporter","instance":"localhost:9100"},"values":[0,0,0],"timestamps":[1549891472010,1549891487724,1549891503438]}
+{"metric":{"__name__":"up","job":"prometheus","instance":"localhost:9090"},"values":[1,1,1],"timestamps":[1549891461511,1549891476511,1549891491511]}
+```
+
+Optional `start` and `end` args may be added to the request in order to limit the time frame for the exported data. These args may contain either
+unix timestamp in seconds or [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) values.
+
+
+### Federation
+
+VictoriaMetrics exports [Prometheus-compatible federation data](https://prometheus.io/docs/prometheus/latest/federation/)
+at `http://<victoriametrics-addr>:8428/federate?match[]=<timeseries_selector_for_federation>`.
+
+Optional `start` and `end` args may be added to the request in order to scrape the last point for each selected time series on the `[start ... end]` interval.
+`start` and `end` may contain either unix timestamp in seconds or [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) values. By default, the last point
+on the interval `[now - max_lookback ... now]` is scraped for each time series. The default value for `max_lookback` is `5m` (5 minutes), but can be overridden.
+For instance, `/federate?match[]=up&max_lookback=1h` would return last points on the `[now - 1h ... now]` interval. This may be useful for time series federation
+with scrape intervals exceeding `5m`.
+
+
+### Capacity planning
+
+A rough estimation of the required resources for ingestion path:
+
+* RAM size: less than 1KB per active time series. So, ~1GB of RAM is required for 1M active time series.
+  Time series is considered active if new data points have been added to it recently or if it has been recently queried.
+  The number of active time series may be obtained from `vm_cache_entries{type="storage/hour_metric_ids"}` metric
+  exproted on the `/metrics` page.
+  VictoriaMetrics stores various caches in RAM. Memory size for these caches may be limited by `-memory.allowedPercent` flag.
+
+* CPU cores: a CPU core per 300K inserted data points per second. So, ~4 CPU cores are required for processing
+  the insert stream of 1M data points per second. The ingestion rate may be lower for high cardinality data.
+  See [this article](https://medium.com/@valyala/insert-benchmarks-with-inch-influxdb-vs-victoriametrics-e31a41ae2893) for details.
+  If you see lower numbers per CPU core, then it is likely active time series info doesn't fit caches,
+  so you need more RAM for lowering CPU usage.
+
+* Storage space: less than a byte per data point on average. So, ~260GB is required for storing a month-long insert stream
+  of 100K data points per second.
+  The actual storage size heavily depends on data randomness (entropy). Higher randomness means higher storage size requirements.
+  Read [this article](https://medium.com/faun/victoriametrics-achieving-better-compression-for-time-series-data-than-gorilla-317bc1f95932)
+  for details.
+
+* Network usage: outbound traffic is negligible. Ingress traffic is ~100 bytes per ingested data point via
+  [Prometheus remote_write API](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write).
+  The actual ingress bandwidth usage depends on the average number of labels per ingested metric and the average size
+  of label values. The higher number of per-metric labels and longer label values mean the higher ingress bandwidth.
+
+
+The required resources for query path:
+
+* RAM size: depends on the number of time series to scan in each query and the `step`
+  argument passed to [/api/v1/query_range](https://prometheus.io/docs/prometheus/latest/querying/api/#range-queries).
+  The higher number of scanned time series and lower `step` argument results in the higher RAM usage.
+
+* CPU cores: a CPU core per 30 millions of scanned data points per second.
+
+* Network usage: depends on the frequency and the type of incoming requests. Typical Grafana dashboards usually
+  require negligible network bandwidth.
+
+
+### High availability
+
+1) Install multiple VictoriaMetrics instances in distinct datacenters (availability zones).
+2) Add addresses of these instances to `remote_write` section in Prometheus config:
+
+```yml
+remote_write:
+  - url: http://<victoriametrics-addr-1>:8428/api/v1/write
+    queue_config:
+      max_samples_per_send: 10000
+  # ...
+  - url: http://<victoriametrics-addr-N>:8428/api/v1/write
+    queue_config:
+      max_samples_per_send: 10000
+```
+
+3) Apply the updated config:
+
+```
+kill -HUP `pidof prometheus`
+```
+
+4) Now Prometheus should write data into all the configured `remote_write` urls in parallel.
+5) Set up [Promxy](https://github.com/jacksontj/promxy) in front of all the VictoriaMetrics replicas.
+6) Set up Prometheus datasource in Grafana that points to Promxy.
+
+
+If you have Prometheus HA pairs with replicas `r1` and `r2` in each pair, then configure each `r1`
+to write data to `<victoriametrics-addr-1`, while each `r2` should write data to `victoriametrics-addr-2`.
+
+
+### Multiple retentions
+
+Just start multiple VictoriaMetrics instances with distinct values for the following flags:
+
+* `-retentionPeriod`
+* `-storageDataPath`, so the data for each retention period is saved in a separate directory
+* `-httpListenAddr`, so clients may reach VictoriaMetrics instance with proper retention
+
+
+### Downsampling
+
+There is no downsampling support at the moment, but:
+- VictoriaMetrics is optimized for querying big amounts of raw data. See benchmark results for heavy queries
+  in [this article](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae).
+- VictoriaMetrics has good compression for on-disk data. See [this article](https://medium.com/@valyala/victoriametrics-achieving-better-compression-for-time-series-data-than-gorilla-317bc1f95932)
+  for details.
+
+These properties reduce the need in downsampling. We plan to implement downsampling in the future.
+See [this issue](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/36) for details.
+
+
+### Multi-tenancy
+
+Single-node VictoriaMetrics doesn't support multi-tenancy. Use [cluster version](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/cluster) instead.
+
+
+### Scalability and cluster version
+
+Though single-node VictoriaMetrics cannot scale to multiple nodes, it is optimized for resource usage - storage size / bandwidth / IOPS, RAM, CPU.
+This means that a single-node VictoriaMetrics may scale vertically and substitute a moderately sized cluster built with competing solutions
+such as Thanos, Uber M3, InfluxDB or TimescaleDB. See [vertical scalability benchmarks](https://medium.com/@valyala/measuring-vertical-scalability-for-time-series-databases-in-google-cloud-92550d78d8ae).
+
+So try single-node VictoriaMetrics at first and then [switch to cluster version](https://github.com/VictoriaMetrics/VictoriaMetrics/tree/cluster) if you still need
+horizontally scalable long-term remote storage for really large Prometheus deployments.
+[Contact us](mailto:info@victoriametrics.com) for paid support.
+
+
+### Alerting
+
+VictoriaMetrics doesn't support rule evaluation and alerting yet, so these actions must be performed either
+on [Prometheus side](https://prometheus.io/docs/alerting/overview/) or on [Grafana side](https://grafana.com/docs/alerting/rules/).
+
+
+### Security
+
+Do not forget protecting sensitive endpoints in VictoriaMetrics when exposing it to untrusted networks such as the internet.
+Consider setting the following command-line flags:
+
+* `-tls`, `-tlsCertFile` and `-tlsKeyFile` for switching from HTTP to HTTPS.
+* `-httpAuth.username` and `-httpAuth.password` for protecting all the HTTP endpoints
+  with [HTTP Basic Authentication](https://en.wikipedia.org/wiki/Basic_access_authentication).
+* `-deleteAuthKey` for protecting `/api/v1/admin/tsdb/delete_series` endpoint. See [how to delete time series](#how-to-delete-time-series).
+* `-snapshotAuthKey` for protecting `/snapshot*` endpoints. See [how to work with snapshots](#how-to-work-with-snapshots).
+
+Explicitly set internal network interface for TCP and UDP ports for data ingestion with Graphite and OpenTSDB formats.
+For example, substitute `-graphiteListenAddr=:2003` with `-graphiteListenAddr=<internal_iface_ip>:2003`.
+
+
+### Tuning
+
+* There is no need in VictoriaMetrics tuning since it uses reasonable defaults for command-line flags,
+  which are automatically adjusted for the available CPU and RAM resources.
+* There is no need in Operating System tuning since VictoriaMetrics is optimized for default OS settings.
+  The only option is increasing the limit on [the number of open files in the OS](https://medium.com/@muhammadtriwibowo/set-permanently-ulimit-n-open-files-in-ubuntu-4d61064429a),
+  so Prometheus instances could establish more connections to VictoriaMetrics.
+
+
+### Monitoring
+
+VictoriaMetrics exports internal metrics in Prometheus format on the `/metrics` page.
+Add this page to Prometheus' scrape config in order to collect VictoriaMetrics metrics.
+There is [an official Grafana dashboard for single-node VictoriaMetrics](https://grafana.com/dashboards/10229).
+
+The most interesting metrics are:
+
+* `vm_cache_entries{type="storage/hour_metric_ids"}` - the number of time series with new data points during the last hour
+  aka active time series.
+* `vm_rows{type="indexdb"}` - the number of rows in inverted index. Each label in each unique time series adds a single
+  row into the inverted index. An approximate number of time series in the database may be calculated as
+  `vm_rows{type="indexdb"} / (avg_labels_per_series + 1)`, where `avg_labels_per_series` is the average number of labels
+  per each time series.
+* Sum of `vm_rows{type="storage/big"}` and `vm_rows{type="storage/small"}` - total number of `(timestamp, value)` data points
+  in the database.
+* Sum of all the `vm_cache_size_bytes` metrics - the total size of all the caches in the database.
+* `vm_allowed_memory_bytes` - the maximum allowed size for caches in the database. It is calculated as `system_memory * <-memory.allowedPercent> / 100`,
+  where `system_memory` is the amount of system memory and `-memory.allowedPercent` is the corresponding flag value.
+* `vm_rows_inserted_total` - the total number of inserted rows since VictoriaMetrics start.
+
+
+### Troubleshooting
+
+* If VictoriaMetrics works slowly and eats more than a CPU core per 100K ingested data points per second,
+  then it is likely you have too many active time series for the current amount of RAM.
+  It is recommended increasing the amount of RAM on the node with VictoriaMetrics in order to improve
+  ingestion performance.
+  Another option is to increase `-memory.allowedPercent` command-line flag value. Be careful with this
+  option, since too big value for `-memory.allowedPercent` may result in high I/O usage.
+
+* VictoriaMetrics requires free disk space for [merging data files to bigger ones](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282).
+  It may slow down when there is no enough free space left. So make sure `-storageDataPath` directory
+  has at least 20% of free space comparing to disk size.
+
+* If VictoriaMetrics doesn't work because of certain parts are corrupted due to disk errors,
+  then just remove directoreis with broken parts. This will recover VictoriaMetrics at the cost
+  of data loss stored in the broken parts. In the future, `vmrecover` tool will be created
+  for automatic recovering from such errors.
+
+## Roadmap
+
+- [ ] Replication [#118](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/118)
+- [ ] Support of Object Storages (GCS, S3, Azure Storage) [#38](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/38)
+- [ ] Data downsampling [#36](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/36)
+- [ ] Alert Manager Integration [#119](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/119) 
+- [ ] CLI tool for data migration, re-balancing and adding/removing nodes [#103](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/103)
+
+
+The discussion happens [here](https://github.com/VictoriaMetrics/VictoriaMetrics/issues/129). Feel free to comment any item or add own one.
+
+
+## Contacts
+
+Contact us with any questions regarding VictoriaMetrics at [info@victoriametrics.com](mailto:info@victoriametrics.com).
+
+
+## Community and contributions
+
+Feel free asking any questions regarding VictoriaMetrics:
+
+- [slack](http://slack.victoriametrics.com/)
+- [telergam-en](https://t.me/VictoriaMetrics_en)
+- [telergam-ru](https://t.me/VictoriaMetrics_ru1)
+- [google groups](https://groups.google.com/forum/#!forum/victorametrics-users)
+
+
+If you like VictoriaMetrics and want to contribute, then we need the following:
+
+- Filing issues and feature requests [here](https://github.com/VictoriaMetrics/VictoriaMetrics/issues).
+- Spreading a word about VictoriaMetrics: conference talks, articles, comments, experience sharing with colleagues.
+- Updating documentation.
+
+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.
+
+
+## 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).
 
@@ -42,24 +693,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/victoria-metrics/Makefile

@@ -0,0 +1,72 @@
+# All these commands must run from repository root.
+
+victoria-metrics:
+	GO111MODULE=on go build -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/victoria-metrics ./app/victoria-metrics
+
+victoria-metrics-prod:
+	APP_NAME=victoria-metrics $(MAKE) app-via-docker
+
+package-victoria-metrics:
+	APP_NAME=victoria-metrics \
+	$(MAKE) package-via-docker
+
+publish-victoria-metrics:
+	APP_NAME=victoria-metrics $(MAKE) publish-via-docker
+
+run-victoria-metrics:
+	mkdir -p victoria-metrics-data
+	DOCKER_OPTS='-v $(shell pwd)/victoria-metrics-data:/victoria-metrics-data' \
+	APP_NAME=victoria-metrics \
+	ARGS='-graphiteListenAddr=:2003 -opentsdbListenAddr=:4242 -retentionPeriod=12 -search.maxUniqueTimeseries=1000000 -search.maxQueryDuration=10m' \
+	$(MAKE) run-via-docker
+
+victoria-metrics-arm:
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm GO111MODULE=on go build -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/victoria-metrics-arm ./app/victoria-metrics
+
+victoria-metrics-arm-prod:
+	APP_NAME=victoria-metrics APP_SUFFIX='-arm' DOCKER_OPTS='--env CGO_ENABLED=0 --env GOARCH=arm' $(MAKE) app-via-docker
+
+victoria-metrics-arm64:
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GO111MODULE=on go build -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/victoria-metrics-arm64 ./app/victoria-metrics
+
+victoria-metrics-arm64-prod:
+	APP_NAME=victoria-metrics APP_SUFFIX='-arm64' DOCKER_OPTS='--env CGO_ENABLED=0 --env GOARCH=arm64' $(MAKE) app-via-docker
+
+victoria-metrics-pure:
+	GO111MODULE=on CGO_ENABLED=0 go build -mod=vendor -ldflags "$(GO_BUILDINFO)" -o bin/victoria-metrics-pure ./app/victoria-metrics
+
+victoria-metrics-pure-prod:
+	APP_NAME=victoria-metrics APP_SUFFIX='-pure' DOCKER_OPTS='--env CGO_ENABLED=0' $(MAKE) app-via-docker
+
+### Packaging as DEB - amd64
+victoria-metrics-package-deb: victoria-metrics-prod
+	./package/package_deb.sh amd64
+
+### Packaging as DEB - arm64
+victoria-metrics-package-deb-arm64: victoria-metrics-arm64-prod
+	./package/package_deb.sh arm64
+
+### Packaging as DEB - all
+victoria-metrics-package-deb-all: \
+        victoria-metrics-package-deb \
+        victoria-metrics-package-deb-arm64
+
+### Packaging as RPM - amd64
+victoria-metrics-package-rpm: victoria-metrics-prod
+	./package/package_rpm.sh amd64
+
+### Packaging as RPM - arm64
+victoria-metrics-package-rpm-arm64: victoria-metrics-arm64-prod
+	./package/package_rpm.sh arm64
+
+### Packaging as RPM - all
+victoria-metrics-package-rpm-all: \
+        victoria-metrics-package-rpm \
+        victoria-metrics-package-rpm-arm64
+
+### Packaging as both DEB and RPM - all
+victoria-metrics-package-deb-rpm-all: \
+        victoria-metrics-package-deb \
+        victoria-metrics-package-deb-arm64 \
+        victoria-metrics-package-rpm \
+        victoria-metrics-package-rpm-arm64

app/victoria-metrics/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/victoria-metrics-prod .
+EXPOSE 8428
+ENTRYPOINT ["/victoria-metrics-prod"]

app/victoria-metrics/main.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"flag"
+	"net/http"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/procutil"
+)
+
+var httpListenAddr = flag.String("httpListenAddr", ":8428", "TCP address to listen for http connections")
+
+func main() {
+	flag.Parse()
+	buildinfo.Init()
+	logger.Init()
+	logger.Infof("starting VictoraMetrics at %q...", *httpListenAddr)
+	startTime := time.Now()
+	vmstorage.Init()
+	vmselect.Init()
+	vminsert.Init()
+
+	go httpserver.Serve(*httpListenAddr, requestHandler)
+	logger.Infof("started VictoriaMetrics in %s", time.Since(startTime))
+
+	sig := procutil.WaitForSigterm()
+	logger.Infof("received signal %s", sig)
+
+	logger.Infof("gracefully shutting down webservice at %q", *httpListenAddr)
+	startTime = time.Now()
+	if err := httpserver.Stop(*httpListenAddr); err != nil {
+		logger.Fatalf("cannot stop the webservice: %s", err)
+	}
+	vminsert.Stop()
+	logger.Infof("successfully shut down the webservice in %s", time.Since(startTime))
+
+	vmstorage.Stop()
+	vmselect.Stop()
+
+	logger.Infof("the VictoriaMetrics has been stopped in %s", time.Since(startTime))
+}
+
+func requestHandler(w http.ResponseWriter, r *http.Request) bool {
+	if vminsert.RequestHandler(w, r) {
+		return true
+	}
+	if vmselect.RequestHandler(w, r) {
+		return true
+	}
+	if vmstorage.RequestHandler(w, r) {
+		return true
+	}
+	return false
+}

app/victoria-metrics/main_test.go

@@ -0,0 +1,281 @@
+// +build integration
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+)
+
+const (
+	testFixturesDir        = "testdata"
+	testStorageSuffix      = "vm-test-storage"
+	testHTTPListenAddr     = ":7654"
+	testStatsDListenAddr   = ":2003"
+	testOpenTSDBListenAddr = ":4242"
+	testLogLevel           = "INFO"
+)
+
+const (
+	testReadHTTPPath   = "http://127.0.0.1" + testHTTPListenAddr
+	testWriteHTTPPath  = "http://127.0.0.1" + testHTTPListenAddr + "/write"
+	testHealthHTTPPath = "http://127.0.0.1" + testHTTPListenAddr + "/health"
+)
+
+const (
+	testStorageInitTimeout = 10 * time.Second
+)
+
+var (
+	storagePath   string
+	insertionTime = time.Now().UTC()
+)
+
+type test struct {
+	Name   string `json:"name"`
+	Data   string `json:"data"`
+	Query  string `json:"query"`
+	Result []Row  `json:"result"`
+}
+
+type Row struct {
+	Metric     map[string]string `json:"metric"`
+	Values     []float64         `json:"values"`
+	Timestamps []int64           `json:"timestamps"`
+}
+
+func TestMain(m *testing.M) {
+	setUp()
+	code := m.Run()
+	tearDown()
+	os.Exit(code)
+}
+
+func setUp() {
+	storagePath = filepath.Join(os.TempDir(), testStorageSuffix)
+	processFlags()
+	logger.Init()
+	vmstorage.InitWithoutMetrics()
+	vmselect.Init()
+	vminsert.Init()
+	go httpserver.Serve(*httpListenAddr, requestHandler)
+	readyStorageCheckFunc := func() bool {
+		resp, err := http.Get(testHealthHTTPPath)
+		if err != nil {
+			return false
+		}
+		resp.Body.Close()
+		return resp.StatusCode == 200
+	}
+	if err := waitFor(testStorageInitTimeout, readyStorageCheckFunc); err != nil {
+		log.Fatalf("http server can't start for %s seconds, err %s", testStorageInitTimeout, err)
+	}
+}
+
+func processFlags() {
+	flag.Parse()
+	for _, fs := range []struct {
+		flag  string
+		value string
+	}{
+		{flag: "storageDataPath", value: storagePath},
+		{flag: "httpListenAddr", value: testHTTPListenAddr},
+		{flag: "graphiteListenAddr", value: testStatsDListenAddr},
+		{flag: "opentsdbListenAddr", value: testOpenTSDBListenAddr},
+		{flag: "loggerLevel", value: testLogLevel},
+	} {
+		// panics if flag doesn't exist
+		if err := flag.Lookup(fs.flag).Value.Set(fs.value); err != nil {
+			log.Fatalf("unable to set %q with value %q, err: %v", fs.flag, fs.value, err)
+		}
+	}
+}
+
+func waitFor(timeout time.Duration, f func() bool) error {
+	fraction := timeout / 10
+	for i := fraction; i < timeout; i += fraction {
+		if f() {
+			return nil
+		}
+		time.Sleep(fraction)
+	}
+	return fmt.Errorf("timeout")
+}
+
+func tearDown() {
+	vminsert.Stop()
+	vmstorage.Stop()
+	vmselect.Stop()
+	if err := httpserver.Stop(*httpListenAddr); err != nil {
+		log.Fatalf("cannot stop the webservice: %s", err)
+	}
+	os.RemoveAll(storagePath)
+}
+
+func TestWriteRead(t *testing.T) {
+	t.Run("write", testWrite)
+	time.Sleep(1 * time.Second)
+	vmstorage.Stop()
+
+	// open storage after stop in write
+	vmstorage.InitWithoutMetrics()
+	t.Run("read", testRead)
+}
+
+func testWrite(t *testing.T) {
+	t.Run("influxdb", func(t *testing.T) {
+		for _, test := range readIn("influxdb", t, fmt.Sprintf("%d", insertionTime.UnixNano())) {
+			t.Run(test.Name, func(t *testing.T) {
+				t.Parallel()
+				httpWrite(t, testWriteHTTPPath, test.Data)
+			})
+		}
+	})
+	t.Run("graphite", func(t *testing.T) {
+		for _, test := range readIn("graphite", t, fmt.Sprintf("%d", insertionTime.Unix())) {
+			t.Run(test.Name, func(t *testing.T) {
+				t.Parallel()
+				tcpWrite(t, "127.0.0.1"+testStatsDListenAddr, test.Data)
+			})
+		}
+	})
+	t.Run("opentsdb", func(t *testing.T) {
+		for _, test := range readIn("opentsdb", t, fmt.Sprintf("%d", insertionTime.Unix())) {
+			t.Run(test.Name, func(t *testing.T) {
+				t.Parallel()
+				tcpWrite(t, "127.0.0.1"+testOpenTSDBListenAddr, test.Data)
+			})
+		}
+	})
+}
+
+func testRead(t *testing.T) {
+	for _, engine := range []string{"graphite", "opentsdb", "influxdb"} {
+		t.Run(engine, func(t *testing.T) {
+			for _, test := range readIn(engine, t, fmt.Sprintf("%d", insertionTime.UnixNano())) {
+				test := test
+				t.Run(test.Name, func(t *testing.T) {
+					t.Parallel()
+					rowContains(t, httpRead(t, testReadHTTPPath, test.Query), test.Result)
+				})
+			}
+		})
+	}
+}
+
+func readIn(readFor string, t *testing.T, timeStr string) []test {
+	t.Helper()
+	s := newSuite(t)
+	var tt []test
+	s.noError(filepath.Walk(filepath.Join(testFixturesDir, readFor), func(path string, info os.FileInfo, err error) error {
+		if filepath.Ext(path) != ".json" {
+			return nil
+		}
+		b, err := ioutil.ReadFile(path)
+		s.noError(err)
+		item := test{}
+		s.noError(json.Unmarshal(b, &item))
+		item.Data = strings.Replace(item.Data, "{TIME}", timeStr, 1)
+		tt = append(tt, item)
+		return nil
+	}))
+	if len(tt) == 0 {
+		t.Fatalf("no test found in %s", filepath.Join(testFixturesDir, readFor))
+	}
+	return tt
+}
+
+func httpWrite(t *testing.T, address string, data string) {
+	t.Helper()
+	s := newSuite(t)
+	resp, err := http.Post(address, "", bytes.NewBufferString(data))
+	s.noError(err)
+	s.noError(resp.Body.Close())
+	s.equalInt(resp.StatusCode, 204)
+}
+
+func tcpWrite(t *testing.T, address string, data string) {
+	t.Helper()
+	s := newSuite(t)
+	conn, err := net.Dial("tcp", address)
+	s.noError(err)
+	defer conn.Close()
+	n, err := conn.Write([]byte(data))
+	s.noError(err)
+	s.equalInt(n, len(data))
+}
+
+func httpRead(t *testing.T, address, query string) []Row {
+	t.Helper()
+	s := newSuite(t)
+	resp, err := http.Get(address + query)
+	s.noError(err)
+	defer resp.Body.Close()
+	s.equalInt(resp.StatusCode, 200)
+	var rows []Row
+	for dec := json.NewDecoder(resp.Body); dec.More(); {
+		var row Row
+		s.noError(dec.Decode(&row))
+		rows = append(rows, row)
+	}
+	return rows
+}
+
+func rowContains(t *testing.T, rows, contains []Row) {
+	t.Helper()
+	for _, r := range rows {
+		contains = removeIfFound(r, contains)
+	}
+	if len(contains) > 0 {
+		t.Fatalf("result rows %+v not found in %+v", contains, rows)
+	}
+}
+
+func removeIfFound(r Row, contains []Row) []Row {
+	for i, item := range contains {
+		// todo check time
+		if reflect.DeepEqual(r.Metric, item.Metric) && reflect.DeepEqual(r.Values, item.Values) {
+			contains[i] = contains[len(contains)-1]
+			return contains[:len(contains)-1]
+		}
+	}
+	return contains
+}
+
+type suite struct{ t *testing.T }
+
+func newSuite(t *testing.T) *suite { return &suite{t: t} }
+
+func (s *suite) noError(err error) {
+	s.t.Helper()
+	if err != nil {
+		s.t.Errorf("unexpected error %v", err)
+		s.t.FailNow()
+	}
+}
+
+func (s *suite) equalInt(a, b int) {
+	s.t.Helper()
+	if a != b {
+		s.t.Errorf("%d not equal %d", a, b)
+		s.t.FailNow()
+	}
+}

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

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

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

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

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

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

app/vminsert/README.md

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

app/vminsert/common/insert_ctx.go

@@ -0,0 +1,105 @@
+package common
+
+import (
+	"fmt"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompb"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+)
+
+// InsertCtx contains common bits for data points insertion.
+type InsertCtx struct {
+	Labels []prompb.Label
+
+	mrs            []storage.MetricRow
+	metricNamesBuf []byte
+}
+
+// Reset resets ctx for future fill with rowsLen rows.
+func (ctx *InsertCtx) Reset(rowsLen int) {
+	for _, label := range ctx.Labels {
+		label.Name = nil
+		label.Value = nil
+	}
+	ctx.Labels = ctx.Labels[:0]
+
+	for i := range ctx.mrs {
+		mr := &ctx.mrs[i]
+		mr.MetricNameRaw = nil
+	}
+	ctx.mrs = ctx.mrs[:0]
+	if n := rowsLen - cap(ctx.mrs); n > 0 {
+		ctx.mrs = append(ctx.mrs[:cap(ctx.mrs)], make([]storage.MetricRow, n)...)
+	}
+	ctx.mrs = ctx.mrs[:0]
+	ctx.metricNamesBuf = ctx.metricNamesBuf[:0]
+}
+
+func (ctx *InsertCtx) marshalMetricNameRaw(prefix []byte, labels []prompb.Label) []byte {
+	start := len(ctx.metricNamesBuf)
+	ctx.metricNamesBuf = append(ctx.metricNamesBuf, prefix...)
+	ctx.metricNamesBuf = storage.MarshalMetricNameRaw(ctx.metricNamesBuf, labels)
+	metricNameRaw := ctx.metricNamesBuf[start:]
+	return metricNameRaw[:len(metricNameRaw):len(metricNameRaw)]
+}
+
+// WriteDataPoint writes (timestamp, value) with the given prefix and lables into ctx buffer.
+func (ctx *InsertCtx) WriteDataPoint(prefix []byte, labels []prompb.Label, timestamp int64, value float64) {
+	metricNameRaw := ctx.marshalMetricNameRaw(prefix, labels)
+	ctx.addRow(metricNameRaw, timestamp, value)
+}
+
+// WriteDataPointExt writes (timestamp, value) with the given metricNameRaw and labels into ctx buffer.
+//
+// It returns metricNameRaw for the given labels if len(metricNameRaw) == 0.
+func (ctx *InsertCtx) WriteDataPointExt(metricNameRaw []byte, labels []prompb.Label, timestamp int64, value float64) []byte {
+	if len(metricNameRaw) == 0 {
+		metricNameRaw = ctx.marshalMetricNameRaw(nil, labels)
+	}
+	ctx.addRow(metricNameRaw, timestamp, value)
+	return metricNameRaw
+}
+
+func (ctx *InsertCtx) addRow(metricNameRaw []byte, timestamp int64, value float64) {
+	mrs := ctx.mrs
+	if cap(mrs) > len(mrs) {
+		mrs = mrs[:len(mrs)+1]
+	} else {
+		mrs = append(mrs, storage.MetricRow{})
+	}
+	mr := &mrs[len(mrs)-1]
+	ctx.mrs = mrs
+	mr.MetricNameRaw = metricNameRaw
+	mr.Timestamp = timestamp
+	mr.Value = value
+}
+
+// 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
+}
+
+// FlushBufs flushes buffered rows to the underlying storage.
+func (ctx *InsertCtx) FlushBufs() error {
+	if err := vmstorage.AddRows(ctx.mrs); err != nil {
+		return fmt.Errorf("cannot store metrics: %s", err)
+	}
+	return nil
+}

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,49 @@
+package concurrencylimiter
+
+import (
+	"flag"
+	"fmt"
+	"runtime"
+	"time"
+
+	"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.
+	t := timerpool.Get(waitDuration)
+	select {
+	case ch <- struct{}{}:
+		timerpool.Put(t)
+		err := f()
+		<-ch
+		return err
+	case <-t.C:
+		timerpool.Put(t)
+		concurrencyLimitErrors.Inc()
+		return fmt.Errorf("the server is overloaded with %d concurrent inserts; either increase -maxConcurrentInserts or reduce the load", cap(ch))
+	}
+}
+
+var concurrencyLimitErrors = metrics.NewCounter(`vm_concurrency_limit_errors_total`)

app/vminsert/graphite/parser.go

@@ -0,0 +1,180 @@
+package graphite
+
+import (
+	"fmt"
+	"strings"
+
+	"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) error {
+	var err error
+	rs.Rows, rs.tagsPool, err = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0])
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+// 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)]
+	}
+
+	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, error) {
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n == 0 {
+			// Skip empty line
+			s = s[1:]
+			continue
+		}
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Row{})
+		}
+		r := &dst[len(dst)-1]
+		if n < 0 {
+			// The last line.
+			var err error
+			tagsPool, err = r.unmarshal(s, tagsPool)
+			if err != nil {
+				err = fmt.Errorf("cannot unmarshal Graphite line %q: %s", s, err)
+				return dst, tagsPool, err
+			}
+			return dst, tagsPool, nil
+		}
+		var err error
+		tagsPool, err = r.unmarshal(s[:n], tagsPool)
+		if err != nil {
+			err = fmt.Errorf("cannot unmarshal Graphite line %q: %s", s[:n], err)
+			return dst, tagsPool, err
+		}
+		s = s[n+1:]
+	}
+	return dst, tagsPool, nil
+}
+
+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
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n]); err != nil {
+			return dst[:len(dst)-1], err
+		}
+		s = s[n+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]
+	if len(t.Key) == 0 {
+		return fmt.Errorf("tag key cannot be empty for %q", s)
+	}
+	t.Value = s[n+1:]
+	return nil
+}

app/vminsert/graphite/parser_test.go

@@ -0,0 +1,142 @@
+package graphite
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+
+		// Try again
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+	}
+
+	// Missing value
+	f("aaa")
+
+	// Invalid multiline
+	f("aaa\nbbb 123 34")
+
+	// missing tag
+	f("aa; 12 34")
+
+	// missing tag value
+	f("aa;bb 23 34")
+	f("aa;=dsd 234 45")
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		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{})
+
+	// 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,
+		}},
+	})
+	f("foo;bar=baz;aa=;x=y 1 2", &Rows{
+		Rows: []Row{{
+			Metric: "foo",
+			Tags: []Tag{
+				{
+					Key:   "bar",
+					Value: "baz",
+				},
+				{
+					Key:   "aa",
+					Value: "",
+				},
+				{
+					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,
+			},
+		},
+	})
+}

app/vminsert/graphite/parser_timing_test.go

@@ -0,0 +1,24 @@
+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() {
+			if err := rows.Unmarshal(s); err != nil {
+				panic(fmt.Errorf("cannot unmarshal %q: %s", s, err))
+			}
+		}
+	})
+}

app/vminsert/graphite/request_handler.go

@@ -0,0 +1,166 @@
+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/lib/bytesutil"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	rowsInserted  = metrics.NewCounter(`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(r io.Reader) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(r)
+	})
+}
+
+func insertHandlerInternal(r io.Reader) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	for ctx.Read(r) {
+		if err := ctx.InsertRows(); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows() error {
+	rows := ctx.Rows.Rows
+	ic := &ctx.Common
+	ic.Reset(len(rows))
+	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)
+		}
+		ic.WriteDataPoint(nil, ic.Labels, r.Timestamp, r.Value)
+	}
+	rowsInserted.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
+		}
+	}
+	if err := ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf)); err != nil {
+		graphiteUnmarshalErrors.Inc()
+		ctx.err = fmt.Errorf("cannot unmarshal graphite plaintext protocol data with size %d: %s", len(ctx.reqBuf), err)
+		return false
+	}
+
+	// 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 common.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(0)
+	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"}`)
+	graphiteUnmarshalErrors = metrics.NewCounter(`vm_unmarshal_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,138 @@
+package graphite
+
+import (
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"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()
+			if err := insertHandler(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)
+			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(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,388 @@
+package influx
+
+import (
+	"fmt"
+	"strings"
+
+	"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) error {
+	var err error
+	rs.Rows, rs.tagsPool, rs.fieldsPool, err = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0], rs.fieldsPool[:0])
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+// 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) ([]Tag, []Field, error) {
+	r.reset()
+	noEscapeChars := strings.IndexByte(s, '\\') < 0
+	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)
+	if len(tag.Key) == 0 {
+		return fmt.Errorf("tag key cannot be empty")
+	}
+	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, error) {
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n == 0 {
+			// Skip empty line
+			s = s[1:]
+			continue
+		}
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Row{})
+		}
+		r := &dst[len(dst)-1]
+		if n < 0 {
+			// The last line.
+			var err error
+			tagsPool, fieldsPool, err = r.unmarshal(s, tagsPool, fieldsPool)
+			if err != nil {
+				err = fmt.Errorf("cannot unmarshal Influx line %q: %s", s, err)
+				return dst, tagsPool, fieldsPool, err
+			}
+			return dst, tagsPool, fieldsPool, nil
+		}
+		var err error
+		tagsPool, fieldsPool, err = r.unmarshal(s[:n], tagsPool, fieldsPool)
+		if err != nil {
+			err = fmt.Errorf("cannot unmarshal Influx line %q: %s", s[:n], err)
+			return dst, tagsPool, fieldsPool, err
+		}
+		s = s[n+1:]
+	}
+	return dst, tagsPool, fieldsPool, nil
+}
+
+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, err
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n], noEscapeChars); err != nil {
+			return dst, err
+		}
+		s = s[n+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,377 @@
+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
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+
+		// Try again
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+	}
+
+	// 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= baz")
+	f("foo,bar=123, 123")
+
+	// Missing tag name
+	f("foo,=bar baz=234")
+
+	// 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
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		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{})
+
+	// Minimal line without tags and timestamp
+	f("foo bar=123", &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 bar=123", &Rows{
+		Rows: []Row{{
+			Measurement: "foo",
+			Tags: []Tag{
+				{
+					Key:   "tag1",
+					Value: "xyz",
+				},
+				{
+					Key:   "tagN",
+					Value: "",
+				},
+				{
+					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\==\\a\,\=\q\  \\\a\=\,=4.34`, &Rows{
+		Rows: []Row{{
+			Measurement: `fo,bar=baz`,
+			Tags: []Tag{{
+				Key:   `x=`,
+				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,
+				}},
+			},
+		},
+	})
+	// 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,
+				}},
+			},
+		},
+	})
+}

app/vminsert/influx/parser_timing_test.go

@@ -0,0 +1,20 @@
+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`
+	b.SetBytes(int64(len(s)))
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		var rows Rows
+		for pb.Next() {
+			if err := rows.Unmarshal(s); err != nil {
+				panic(fmt.Errorf("cannot unmarshal %q: %s", s, err))
+			}
+		}
+	})
+}

app/vminsert/influx/request_handler.go

@@ -0,0 +1,244 @@
+package influx
+
+import (
+	"compress/gzip"
+	"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/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"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  = metrics.NewCounter(`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(req *http.Request) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(req)
+	})
+}
+
+func insertHandlerInternal(req *http.Request) error {
+	influxReadCalls.Inc()
+
+	r := req.Body
+	if req.Header.Get("Content-Encoding") == "gzip" {
+		zr, err := getGzipReader(r)
+		if err != nil {
+			return fmt.Errorf("cannot read gzipped influx line protocol data: %s", err)
+		}
+		defer 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(db); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows(db string) error {
+	rows := ctx.Rows.Rows
+	rowsLen := 0
+	for i := range rows {
+		rowsLen += len(rows[i].Tags)
+	}
+	ic := &ctx.Common
+	ic.Reset(rowsLen)
+	rowsTotal := 0
+	for i := range rows {
+		r := &rows[i]
+		ic.Labels = ic.Labels[:0]
+		ic.AddLabel("db", db)
+		for j := range r.Tags {
+			tag := &r.Tags[j]
+			ic.AddLabel(tag.Key, tag.Value)
+		}
+		ctx.metricNameBuf = storage.MarshalMetricNameRaw(ctx.metricNameBuf[:0], ic.Labels)
+		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)
+		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[:0]
+			ic.AddLabel("", metricGroup)
+			ic.WriteDataPoint(ctx.metricNameBuf, ic.Labels[:1], r.Timestamp, f.Value)
+		}
+		rowsTotal += len(r.Fields)
+	}
+	rowsInserted.Add(rowsTotal)
+	rowsPerInsert.Update(float64(rowsTotal))
+	return ic.FlushBufs()
+}
+
+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
+}
+
+func putGzipReader(zr *gzip.Reader) {
+	_ = zr.Close()
+	gzipReaderPool.Put(zr)
+}
+
+var gzipReaderPool sync.Pool
+
+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
+	}
+	if err := ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf)); err != nil {
+		influxUnmarshalErrors.Inc()
+		ctx.err = fmt.Errorf("cannot unmarshal influx line protocol data with size %d: %s", len(ctx.reqBuf), err)
+		return false
+	}
+
+	// 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
+		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"}`)
+	influxUnmarshalErrors = metrics.NewCounter(`vm_unmarshal_errors_total{name="influx"}`)
+)
+
+type pushCtx struct {
+	Rows   Rows
+	Common common.InsertCtx
+
+	reqBuf         []byte
+	tailBuf        []byte
+	metricNameBuf  []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(0)
+
+	ctx.reqBuf = ctx.reqBuf[:0]
+	ctx.tailBuf = ctx.tailBuf[:0]
+	ctx.metricNameBuf = ctx.metricNameBuf[: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,87 @@
+package vminsert
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"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/opentsdb"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/prometheus"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"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")
+	maxInsertRequestSize = flag.Int("maxInsertRequestSize", 32*1024*1024, "The maximum size of a single insert request in bytes")
+)
+
+// Init initializes vminsert.
+func Init() {
+	concurrencylimiter.Init()
+	if len(*graphiteListenAddr) > 0 {
+		go graphite.Serve(*graphiteListenAddr)
+	}
+	if len(*opentsdbListenAddr) > 0 {
+		go opentsdb.Serve(*opentsdbListenAddr)
+	}
+}
+
+// Stop stops vminsert.
+func Stop() {
+	if len(*graphiteListenAddr) > 0 {
+		graphite.Stop()
+	}
+	if len(*opentsdbListenAddr) > 0 {
+		opentsdb.Stop()
+	}
+}
+
+// RequestHandler is a handler for Prometheus remote storage write API
+func RequestHandler(w http.ResponseWriter, r *http.Request) bool {
+	path := strings.Replace(r.URL.Path, "//", "/", -1)
+	switch path {
+	case "/api/v1/write":
+		prometheusWriteRequests.Inc()
+		if err := prometheus.InsertHandler(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 "/write", "/api/v2/write":
+		influxWriteRequests.Inc()
+		if err := influx.InsertHandler(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 "/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="/api/v1/write", protocol="prometheus"}`)
+	prometheusWriteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/write", protocol="prometheus"}`)
+
+	influxWriteRequests = metrics.NewCounter(`vm_http_requests_total{path="/write", protocol="influx"}`)
+	influxWriteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/write", protocol="influx"}`)
+
+	influxQueryRequests = metrics.NewCounter(`vm_http_requests_total{path="/query", protocol="influx"}`)
+)

app/vminsert/opentsdb/parser.go

@@ -0,0 +1,177 @@
+package opentsdb
+
+import (
+	"fmt"
+	"strings"
+
+	"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) error {
+	var err error
+	rs.Rows, rs.tagsPool, err = unmarshalRows(rs.Rows[:0], s, rs.tagsPool[:0])
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+// 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]
+	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, error) {
+	for len(s) > 0 {
+		n := strings.IndexByte(s, '\n')
+		if n == 0 {
+			// Skip empty line
+			s = s[1:]
+			continue
+		}
+		if cap(dst) > len(dst) {
+			dst = dst[:len(dst)+1]
+		} else {
+			dst = append(dst, Row{})
+		}
+		r := &dst[len(dst)-1]
+		if n < 0 {
+			// The last line.
+			var err error
+			tagsPool, err = r.unmarshal(s, tagsPool)
+			if err != nil {
+				err = fmt.Errorf("cannot unmarshal OpenTSDB line %q: %s", s, err)
+				return dst, tagsPool, err
+			}
+			return dst, tagsPool, nil
+		}
+		var err error
+		tagsPool, err = r.unmarshal(s[:n], tagsPool)
+		if err != nil {
+			err = fmt.Errorf("cannot unmarshal OpenTSDB line %q: %s", s[:n], err)
+			return dst, tagsPool, err
+		}
+		s = s[n+1:]
+	}
+	return dst, tagsPool, nil
+}
+
+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
+			}
+			return dst, nil
+		}
+		if err := tag.unmarshal(s[:n]); err != nil {
+			return dst[:len(dst)-1], err
+		}
+		s = s[n+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]
+	if len(t.Key) == 0 {
+		return fmt.Errorf("tag key cannot be empty for %q", s)
+	}
+	t.Value = s[n+1:]
+	return nil
+}

app/vminsert/opentsdb/parser_test.go

@@ -0,0 +1,203 @@
+package opentsdb
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRowsUnmarshalFailure(t *testing.T) {
+	f := func(s string) {
+		t.Helper()
+		var rows Rows
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+
+		// Try again
+		if err := rows.Unmarshal(s); err == nil {
+			t.Fatalf("expecting non-nil error when parsing %q", s)
+		}
+	}
+
+	// Missing put prefix
+	f("xx")
+
+	// 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")
+	f("put aaa 123 4.5 =")
+	f("put aaa 123 4.5 =foo")
+	f("put aaa 123 4.5 =foo a=b")
+}
+
+func TestRowsUnmarshalSuccess(t *testing.T) {
+	f := func(s string, rowsExpected *Rows) {
+		t.Helper()
+		var rows Rows
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		if !reflect.DeepEqual(rows.Rows, rowsExpected.Rows) {
+			t.Fatalf("unexpected rows;\ngot\n%+v;\nwant\n%+v", rows.Rows, rowsExpected.Rows)
+		}
+
+		// Try unmarshaling again
+		if err := rows.Unmarshal(s); err != nil {
+			t.Fatalf("cannot unmarshal %q: %s", s, err)
+		}
+		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{})
+
+	// 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 value
+	f("put foobar 789 -123.456 a= b=c", &Rows{
+		Rows: []Row{{
+			Metric:    "foobar",
+			Value:     -123.456,
+			Timestamp: 789,
+			Tags: []Tag{
+				{
+					Key:   "a",
+					Value: "",
+				},
+				{
+					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",
+				}},
+			},
+		},
+	})
+}

app/vminsert/opentsdb/parser_timing_test.go

@@ -0,0 +1,24 @@
+package opentsdb
+
+import (
+	"fmt"
+	"testing"
+)
+
+func BenchmarkRowsUnmarshal(b *testing.B) {
+	s := `cpu.usage_user 1234556768 1.23 a=b
+cpu.usage_system 1234556768 23.344 a=b
+cpu.usage_iowait 1234556769 3.3443 a=b
+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() {
+			if err := rows.Unmarshal(s); err != nil {
+				panic(fmt.Errorf("cannot unmarshal %q: %s", s, err))
+			}
+		}
+	})
+}

app/vminsert/opentsdb/request_handler.go

@@ -0,0 +1,155 @@
+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/lib/bytesutil"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	rowsInserted  = metrics.NewCounter(`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(r io.Reader) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(r)
+	})
+}
+
+func insertHandlerInternal(r io.Reader) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	for ctx.Read(r) {
+		if err := ctx.InsertRows(); err != nil {
+			return err
+		}
+	}
+	return ctx.Error()
+}
+
+func (ctx *pushCtx) InsertRows() error {
+	rows := ctx.Rows.Rows
+	ic := &ctx.Common
+	ic.Reset(len(rows))
+	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)
+		}
+		ic.WriteDataPoint(nil, ic.Labels, r.Timestamp, r.Value)
+	}
+	rowsInserted.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
+		}
+	}
+	if err := ctx.Rows.Unmarshal(bytesutil.ToUnsafeString(ctx.reqBuf)); err != nil {
+		opentsdbUnmarshalErrors.Inc()
+		ctx.err = fmt.Errorf("cannot unmarshal OpenTSDB put protocol data with size %d: %s", len(ctx.reqBuf), err)
+		return false
+	}
+
+	// Convert timestamps from seconds to milliseconds
+	for i := range ctx.Rows.Rows {
+		ctx.Rows.Rows[i].Timestamp *= 1e3
+	}
+	return true
+}
+
+type pushCtx struct {
+	Rows   Rows
+	Common common.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(0)
+	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"}`)
+	opentsdbUnmarshalErrors = metrics.NewCounter(`vm_unmarshal_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,138 @@
+package opentsdb
+
+import (
+	"net"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"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()
+			if err := insertHandler(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)
+			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(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/prometheus/request_handler.go

@@ -0,0 +1,112 @@
+package prometheus
+
+import (
+	"fmt"
+	"net/http"
+	"runtime"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/common"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vminsert/concurrencylimiter"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/prompb"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	rowsInserted  = metrics.NewCounter(`vm_rows_inserted_total{type="prometheus"}`)
+	rowsPerInsert = metrics.NewSummary(`vm_rows_per_insert{type="prometheus"}`)
+)
+
+// InsertHandler processes remote write for prometheus.
+func InsertHandler(r *http.Request, maxSize int64) error {
+	return concurrencylimiter.Do(func() error {
+		return insertHandlerInternal(r, maxSize)
+	})
+}
+
+func insertHandlerInternal(r *http.Request, maxSize int64) error {
+	ctx := getPushCtx()
+	defer putPushCtx(ctx)
+	if err := ctx.Read(r, maxSize); err != nil {
+		return err
+	}
+	timeseries := ctx.req.Timeseries
+	rowsLen := 0
+	for i := range timeseries {
+		rowsLen += len(timeseries[i].Samples)
+	}
+	ic := &ctx.Common
+	ic.Reset(rowsLen)
+	rowsTotal := 0
+	for i := range timeseries {
+		ts := &timeseries[i]
+		var metricNameRaw []byte
+		for i := range ts.Samples {
+			r := &ts.Samples[i]
+			metricNameRaw = ic.WriteDataPointExt(metricNameRaw, ts.Labels, r.Timestamp, r.Value)
+		}
+		rowsTotal += len(ts.Samples)
+	}
+	rowsInserted.Add(rowsTotal)
+	rowsPerInsert.Update(float64(rowsTotal))
+	return ic.FlushBufs()
+}
+
+type pushCtx struct {
+	Common common.InsertCtx
+
+	req    prompb.WriteRequest
+	reqBuf []byte
+}
+
+func (ctx *pushCtx) reset() {
+	ctx.Common.Reset(0)
+	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/README.md

@@ -0,0 +1,2 @@
+`vmselect` performs the incoming queries and fetches the required data
+from `vmstorage`.

app/vmselect/main.go

@@ -0,0 +1,203 @@
+package vmselect
+
+import (
+	"flag"
+	"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/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/fs"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/timerpool"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	deleteAuthKey         = flag.String("deleteAuthKey", "", "authKey for metrics' deletion via /api/v1/admin/tsdb/delete_series")
+	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")
+)
+
+// Init initializes vmselect
+func Init() {
+	tmpDirPath := *vmstorage.DataPath + "/tmp"
+	fs.RemoveDirContents(tmpDirPath)
+	netstorage.InitTmpBlocksDir(tmpDirPath)
+	promql.InitRollupResultCache(*vmstorage.DataPath + "/cache/rollupResult")
+	concurrencyCh = make(chan struct{}, *maxConcurrentRequests)
+}
+
+var concurrencyCh chan struct{}
+
+// Stop stops vmselect
+func Stop() {
+	promql.StopRollupResultCache()
+}
+
+// RequestHandler handles remote read API requests for Prometheus
+func RequestHandler(w http.ResponseWriter, r *http.Request) bool {
+	// Limit the number of concurrent queries.
+	// Sleep for a while until giving up. This should resolve short bursts in requests.
+	t := timerpool.Get(*maxQueueDuration)
+	select {
+	case concurrencyCh <- struct{}{}:
+		timerpool.Put(t)
+		defer func() { <-concurrencyCh }()
+	case <-t.C:
+		timerpool.Put(t)
+		httpserver.Errorf(w, "cannot handle more than %d concurrent requests", cap(concurrencyCh))
+		return true
+	}
+
+	path := strings.Replace(r.URL.Path, "//", "/", -1)
+	if strings.HasPrefix(path, "/api/v1/label/") {
+		s := r.URL.Path[len("/api/v1/label/"):]
+		if strings.HasSuffix(s, "/values") {
+			labelValuesRequests.Inc()
+			labelName := s[:len(s)-len("/values")]
+			httpserver.EnableCORS(w, r)
+			if err := prometheus.LabelValuesHandler(labelName, w, r); err != nil {
+				labelValuesErrors.Inc()
+				sendPrometheusError(w, r, err)
+				return true
+			}
+			return true
+		}
+	}
+
+	switch path {
+	case "/api/v1/query":
+		queryRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.QueryHandler(w, r); err != nil {
+			queryErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/query_range":
+		queryRangeRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.QueryRangeHandler(w, r); err != nil {
+			queryRangeErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/series":
+		seriesRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.SeriesHandler(w, r); err != nil {
+			seriesErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/series/count":
+		seriesCountRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.SeriesCountHandler(w, r); err != nil {
+			seriesCountErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/labels":
+		labelsRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.LabelsHandler(w, r); err != nil {
+			labelsErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/labels/count":
+		labelsCountRequests.Inc()
+		httpserver.EnableCORS(w, r)
+		if err := prometheus.LabelsCountHandler(w, r); err != nil {
+			labelsCountErrors.Inc()
+			sendPrometheusError(w, r, err)
+			return true
+		}
+		return true
+	case "/api/v1/export":
+		exportRequests.Inc()
+		if err := prometheus.ExportHandler(w, r); err != nil {
+			exportErrors.Inc()
+			httpserver.Errorf(w, "error in %q: %s", r.URL.Path, err)
+			return true
+		}
+		return true
+	case "/federate":
+		federateRequests.Inc()
+		if err := prometheus.FederateHandler(w, r); err != nil {
+			federateErrors.Inc()
+			httpserver.Errorf(w, "error int %q: %s", r.URL.Path, err)
+			return true
+		}
+		return true
+	case "/api/v1/admin/tsdb/delete_series":
+		deleteRequests.Inc()
+		authKey := r.FormValue("authKey")
+		if authKey != *deleteAuthKey {
+			httpserver.Errorf(w, "invalid authKey %q. It must match the value from -deleteAuthKey command line flag", authKey)
+			return true
+		}
+		if err := prometheus.DeleteHandler(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 := 422
+	w.WriteHeader(statusCode)
+	prometheus.WriteErrorResponse(w, statusCode, err)
+}
+
+var (
+	labelValuesRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/label/{}/values"}`)
+	labelValuesErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/label/{}/values"}`)
+
+	queryRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/query"}`)
+	queryErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/query"}`)
+
+	queryRangeRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/query_range"}`)
+	queryRangeErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/query_range"}`)
+
+	seriesRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/series"}`)
+	seriesErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/series"}`)
+
+	seriesCountRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/series/count"}`)
+	seriesCountErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/series/count"}`)
+
+	labelsRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/labels"}`)
+	labelsErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/labels"}`)
+
+	labelsCountRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/labels/count"}`)
+	labelsCountErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/labels/count"}`)
+
+	deleteRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/admin/tsdb/delete_series"}`)
+	deleteErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/admin/tsdb/delete_series"}`)
+
+	exportRequests = metrics.NewCounter(`vm_http_requests_total{path="/api/v1/export"}`)
+	exportErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/api/v1/export"}`)
+
+	federateRequests = metrics.NewCounter(`vm_http_requests_total{path="/federate"}`)
+	federateErrors   = metrics.NewCounter(`vm_http_request_errors_total{path="/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_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/netstorage.go

@@ -0,0 +1,568 @@
+package netstorage
+
+import (
+	"container/heap"
+	"flag"
+	"fmt"
+	"runtime"
+	"sort"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/bytesutil"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/decimal"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	maxTagKeysPerSearch   = flag.Int("search.maxTagKeys", 10e3, "The maximum number of tag keys returned per search")
+	maxTagValuesPerSearch = flag.Int("search.maxTagValues", 10e3, "The maximum number of tag values returned per search")
+	maxMetricsPerSearch   = flag.Int("search.maxUniqueTimeseries", 100e3, "The maximum number of unique time series each search can scan")
+)
+
+// Result is a single timeseries result.
+//
+// ProcessSearchQuery returns Result slice.
+type Result struct {
+	// The name of the metric.
+	MetricName storage.MetricName
+
+	// Values are sorted by Timestamps.
+	Values     []float64
+	Timestamps []int64
+
+	// Marshaled MetricName. Used only for results sorting
+	// in app/vmselect/promql
+	MetricNameMarshaled []byte
+}
+
+func (r *Result) reset() {
+	r.MetricName.Reset()
+	r.Values = r.Values[:0]
+	r.Timestamps = r.Timestamps[:0]
+	r.MetricNameMarshaled = r.MetricNameMarshaled[:0]
+}
+
+// Results holds results returned from ProcessSearchQuery.
+type Results struct {
+	tr       storage.TimeRange
+	deadline Deadline
+
+	tbf *tmpBlocksFile
+
+	packedTimeseries []packedTimeseries
+}
+
+// Len returns the number of results in rss.
+func (rss *Results) Len() int {
+	return len(rss.packedTimeseries)
+}
+
+// Cancel cancels rss work.
+func (rss *Results) Cancel() {
+	putTmpBlocksFile(rss.tbf)
+	rss.tbf = nil
+}
+
+// RunParallel runs in parallel f for all the results from rss.
+//
+// f shouldn't hold references to rs after returning.
+// workerID is the id of the worker goroutine that calls f.
+//
+// rss becomes unusable after the call to RunParallel.
+func (rss *Results) RunParallel(f func(rs *Result, workerID uint)) error {
+	defer func() {
+		putTmpBlocksFile(rss.tbf)
+		rss.tbf = nil
+	}()
+
+	workersCount := 1 + len(rss.packedTimeseries)/32
+	if workersCount > gomaxprocs {
+		workersCount = gomaxprocs
+	}
+	if workersCount == 0 {
+		logger.Panicf("BUG: workersCount cannot be zero")
+	}
+	workCh := make(chan *packedTimeseries, workersCount)
+	doneCh := make(chan error)
+
+	// Start workers.
+	for i := 0; i < workersCount; i++ {
+		go func(workerID uint) {
+			rs := getResult()
+			defer putResult(rs)
+			maxWorkersCount := gomaxprocs / workersCount
+
+			var err error
+			for pts := range workCh {
+				if time.Until(rss.deadline.Deadline) < 0 {
+					err = fmt.Errorf("timeout exceeded during query execution: %s", rss.deadline.Timeout)
+					break
+				}
+				if err = pts.Unpack(rss.tbf, rs, rss.tr, maxWorkersCount); err != nil {
+					break
+				}
+				if len(rs.Timestamps) == 0 {
+					// Skip empty blocks.
+					continue
+				}
+				f(rs, workerID)
+			}
+			// Drain the remaining work
+			for range workCh {
+			}
+			doneCh <- err
+		}(uint(i))
+	}
+
+	// Feed workers with work.
+	for i := range rss.packedTimeseries {
+		workCh <- &rss.packedTimeseries[i]
+	}
+	rss.packedTimeseries = rss.packedTimeseries[:0]
+	close(workCh)
+
+	// Wait until workers finish.
+	var errors []error
+	for i := 0; i < workersCount; i++ {
+		if err := <-doneCh; err != nil {
+			errors = append(errors, err)
+		}
+	}
+	if len(errors) > 0 {
+		// Return just the first error, since other errors
+		// is likely duplicate the first error.
+		return errors[0]
+	}
+	return nil
+}
+
+var gomaxprocs = runtime.GOMAXPROCS(-1)
+
+type packedTimeseries struct {
+	metricName string
+	addrs      []tmpBlockAddr
+}
+
+// Unpack unpacks pts to dst.
+func (pts *packedTimeseries) Unpack(tbf *tmpBlocksFile, dst *Result, tr storage.TimeRange, maxWorkersCount int) error {
+	dst.reset()
+
+	if err := dst.MetricName.Unmarshal(bytesutil.ToUnsafeBytes(pts.metricName)); err != nil {
+		return fmt.Errorf("cannot unmarshal metricName %q: %s", pts.metricName, err)
+	}
+
+	workersCount := 1 + len(pts.addrs)/32
+	if workersCount > maxWorkersCount {
+		workersCount = maxWorkersCount
+	}
+	if workersCount == 0 {
+		logger.Panicf("BUG: workersCount cannot be zero")
+	}
+
+	sbs := make([]*sortBlock, 0, len(pts.addrs))
+	var sbsLock sync.Mutex
+
+	workCh := make(chan tmpBlockAddr, workersCount)
+	doneCh := make(chan error)
+
+	// Start workers
+	for i := 0; i < workersCount; i++ {
+		go func() {
+			var err error
+			for addr := range workCh {
+				sb := getSortBlock()
+				if err = sb.unpackFrom(tbf, addr, tr); err != nil {
+					break
+				}
+
+				sbsLock.Lock()
+				sbs = append(sbs, sb)
+				sbsLock.Unlock()
+			}
+
+			// Drain the remaining work
+			for range workCh {
+			}
+			doneCh <- err
+		}()
+	}
+
+	// Feed workers with work
+	for _, addr := range pts.addrs {
+		workCh <- addr
+	}
+	pts.addrs = pts.addrs[:0]
+	close(workCh)
+
+	// Wait until workers finish
+	var errors []error
+	for i := 0; i < workersCount; i++ {
+		if err := <-doneCh; err != nil {
+			errors = append(errors, err)
+		}
+	}
+	if len(errors) > 0 {
+		// Return the first error only, since other errors are likely the same.
+		return errors[0]
+	}
+
+	// Merge blocks
+	mergeSortBlocks(dst, sbs)
+	return nil
+}
+
+func getSortBlock() *sortBlock {
+	v := sbPool.Get()
+	if v == nil {
+		return &sortBlock{}
+	}
+	return v.(*sortBlock)
+}
+
+func putSortBlock(sb *sortBlock) {
+	sb.reset()
+	sbPool.Put(sb)
+}
+
+var sbPool sync.Pool
+
+var metricRowsSkipped = metrics.NewCounter(`vm_metric_rows_skipped_total{name="vmselect"}`)
+
+func mergeSortBlocks(dst *Result, sbh sortBlocksHeap) {
+	// Skip empty sort blocks, since they cannot be passed to heap.Init.
+	src := sbh
+	sbh = sbh[:0]
+	for _, sb := range src {
+		if len(sb.Timestamps) == 0 {
+			putSortBlock(sb)
+			continue
+		}
+		sbh = append(sbh, sb)
+	}
+	if len(sbh) == 0 {
+		return
+	}
+	heap.Init(&sbh)
+	for {
+		top := sbh[0]
+		heap.Pop(&sbh)
+		if len(sbh) == 0 {
+			dst.Timestamps = append(dst.Timestamps, top.Timestamps[top.NextIdx:]...)
+			dst.Values = append(dst.Values, top.Values[top.NextIdx:]...)
+			putSortBlock(top)
+			return
+		}
+		sbNext := sbh[0]
+		tsNext := sbNext.Timestamps[sbNext.NextIdx]
+		idxNext := len(top.Timestamps)
+		if top.Timestamps[idxNext-1] > tsNext {
+			idxNext = top.NextIdx
+			for top.Timestamps[idxNext] <= tsNext {
+				idxNext++
+			}
+		}
+		dst.Timestamps = append(dst.Timestamps, top.Timestamps[top.NextIdx:idxNext]...)
+		dst.Values = append(dst.Values, top.Values[top.NextIdx:idxNext]...)
+		if idxNext < len(top.Timestamps) {
+			top.NextIdx = idxNext
+			heap.Push(&sbh, top)
+		} else {
+			// Return top to the pool.
+			putSortBlock(top)
+		}
+	}
+}
+
+type sortBlock struct {
+	// b is used as a temporary storage for unpacked rows before they
+	// go to Timestamps and Values.
+	b storage.Block
+
+	Timestamps []int64
+	Values     []float64
+	NextIdx    int
+}
+
+func (sb *sortBlock) reset() {
+	sb.b.Reset()
+	sb.Timestamps = sb.Timestamps[:0]
+	sb.Values = sb.Values[:0]
+	sb.NextIdx = 0
+}
+
+func (sb *sortBlock) unpackFrom(tbf *tmpBlocksFile, addr tmpBlockAddr, tr storage.TimeRange) error {
+	tbf.MustReadBlockAt(&sb.b, addr)
+	if err := sb.b.UnmarshalData(); err != nil {
+		return fmt.Errorf("cannot unmarshal block: %s", err)
+	}
+	timestamps := sb.b.Timestamps()
+
+	// Skip timestamps smaller than tr.MinTimestamp.
+	i := 0
+	for i < len(timestamps) && timestamps[i] < tr.MinTimestamp {
+		i++
+	}
+
+	// Skip timestamps bigger than tr.MaxTimestamp.
+	j := len(timestamps)
+	for j > i && timestamps[j-1] > tr.MaxTimestamp {
+		j--
+	}
+	skippedRows := sb.b.RowsCount() - (j - i)
+	metricRowsSkipped.Add(skippedRows)
+
+	// Copy the remaining values.
+	if i == j {
+		return nil
+	}
+	values := sb.b.Values()
+	sb.Timestamps = append(sb.Timestamps, timestamps[i:j]...)
+	sb.Values = decimal.AppendDecimalToFloat(sb.Values, values[i:j], sb.b.Scale())
+	return nil
+}
+
+type sortBlocksHeap []*sortBlock
+
+func (sbh sortBlocksHeap) Len() int {
+	return len(sbh)
+}
+
+func (sbh sortBlocksHeap) Less(i, j int) bool {
+	a := sbh[i]
+	b := sbh[j]
+	return a.Timestamps[a.NextIdx] < b.Timestamps[b.NextIdx]
+}
+
+func (sbh sortBlocksHeap) Swap(i, j int) {
+	sbh[i], sbh[j] = sbh[j], sbh[i]
+}
+
+func (sbh *sortBlocksHeap) Push(x interface{}) {
+	*sbh = append(*sbh, x.(*sortBlock))
+}
+
+func (sbh *sortBlocksHeap) Pop() interface{} {
+	a := *sbh
+	v := a[len(a)-1]
+	*sbh = a[:len(a)-1]
+	return v
+}
+
+// DeleteSeries deletes time series matching the given tagFilterss.
+func DeleteSeries(sq *storage.SearchQuery) (int, error) {
+	tfss, err := setupTfss(sq.TagFilterss)
+	if err != nil {
+		return 0, err
+	}
+	return vmstorage.DeleteMetrics(tfss)
+}
+
+// GetLabels returns labels until the given deadline.
+func GetLabels(deadline Deadline) ([]string, error) {
+	labels, err := vmstorage.SearchTagKeys(*maxTagKeysPerSearch)
+	if err != nil {
+		return nil, fmt.Errorf("error during labels search: %s", err)
+	}
+
+	// Substitute "" with "__name__"
+	for i := range labels {
+		if labels[i] == "" {
+			labels[i] = "__name__"
+		}
+	}
+
+	// Sort labels like Prometheus does
+	sort.Strings(labels)
+
+	return labels, nil
+}
+
+// GetLabelValues returns label values for the given labelName
+// until the given deadline.
+func GetLabelValues(labelName string, deadline Deadline) ([]string, error) {
+	if labelName == "__name__" {
+		labelName = ""
+	}
+
+	// Search for tag values
+	labelValues, err := vmstorage.SearchTagValues([]byte(labelName), *maxTagValuesPerSearch)
+	if err != nil {
+		return nil, fmt.Errorf("error during label values search for labelName=%q: %s", labelName, err)
+	}
+
+	// Sort labelValues like Prometheus does
+	sort.Strings(labelValues)
+
+	return labelValues, nil
+}
+
+// GetLabelEntries returns all the label entries until the given deadline.
+func GetLabelEntries(deadline Deadline) ([]storage.TagEntry, error) {
+	labelEntries, err := vmstorage.SearchTagEntries(*maxTagKeysPerSearch, *maxTagValuesPerSearch)
+	if err != nil {
+		return nil, fmt.Errorf("error during label entries request: %s", err)
+	}
+
+	// Substitute "" with "__name__"
+	for i := range labelEntries {
+		e := &labelEntries[i]
+		if e.Key == "" {
+			e.Key = "__name__"
+		}
+	}
+
+	// Sort labelEntries by the number of label values in each entry.
+	sort.Slice(labelEntries, func(i, j int) bool {
+		a, b := labelEntries[i].Values, labelEntries[j].Values
+		if len(a) < len(b) {
+			return true
+		}
+		if len(a) > len(b) {
+			return false
+		}
+		return labelEntries[i].Key < labelEntries[j].Key
+	})
+
+	return labelEntries, nil
+}
+
+// GetSeriesCount returns the number of unique series.
+func GetSeriesCount(deadline Deadline) (uint64, error) {
+	n, err := vmstorage.GetSeriesCount()
+	if err != nil {
+		return 0, fmt.Errorf("error during series count request: %s", err)
+	}
+	return n, nil
+}
+
+func getStorageSearch() *storage.Search {
+	v := ssPool.Get()
+	if v == nil {
+		return &storage.Search{}
+	}
+	return v.(*storage.Search)
+}
+
+func putStorageSearch(sr *storage.Search) {
+	n := atomic.LoadUint64(&sr.MissingMetricNamesForMetricID)
+	missingMetricNamesForMetricID.Add(int(n))
+	sr.MustClose()
+	ssPool.Put(sr)
+}
+
+var ssPool sync.Pool
+
+var missingMetricNamesForMetricID = metrics.NewCounter(`vm_missing_metric_names_for_metric_id_total`)
+
+// ProcessSearchQuery performs sq on storage nodes until the given deadline.
+func ProcessSearchQuery(sq *storage.SearchQuery, deadline Deadline) (*Results, error) {
+	// Setup search.
+	tfss, err := setupTfss(sq.TagFilterss)
+	if err != nil {
+		return nil, err
+	}
+	tr := storage.TimeRange{
+		MinTimestamp: sq.MinTimestamp,
+		MaxTimestamp: sq.MaxTimestamp,
+	}
+
+	vmstorage.WG.Add(1)
+	defer vmstorage.WG.Done()
+
+	sr := getStorageSearch()
+	defer putStorageSearch(sr)
+	sr.Init(vmstorage.Storage, tfss, tr, *maxMetricsPerSearch)
+
+	tbf := getTmpBlocksFile()
+	m := make(map[string][]tmpBlockAddr)
+	blocksRead := 0
+	for sr.NextMetricBlock() {
+		blocksRead++
+		addr, err := tbf.WriteBlock(sr.MetricBlock.Block)
+		if err != nil {
+			putTmpBlocksFile(tbf)
+			return nil, fmt.Errorf("cannot write data block #%d to temporary blocks file: %s", blocksRead, err)
+		}
+		if time.Until(deadline.Deadline) < 0 {
+			putTmpBlocksFile(tbf)
+			return nil, fmt.Errorf("timeout exceeded while fetching data block #%d from storage: %s", blocksRead, deadline.Timeout)
+		}
+		metricName := sr.MetricBlock.MetricName
+		m[string(metricName)] = append(m[string(metricName)], addr)
+	}
+	if err := sr.Error(); err != nil {
+		putTmpBlocksFile(tbf)
+		return nil, fmt.Errorf("search error after reading %d data blocks: %s", blocksRead, err)
+	}
+	if err := tbf.Finalize(); err != nil {
+		putTmpBlocksFile(tbf)
+		return nil, fmt.Errorf("cannot finalize temporary blocks file with %d blocks: %s", blocksRead, err)
+	}
+
+	var rss Results
+	rss.packedTimeseries = make([]packedTimeseries, len(m))
+	rss.tr = tr
+	rss.deadline = deadline
+	rss.tbf = tbf
+	i := 0
+	for metricName, addrs := range m {
+		pts := &rss.packedTimeseries[i]
+		i++
+		pts.metricName = metricName
+		pts.addrs = addrs
+	}
+	return &rss, nil
+}
+
+func getResult() *Result {
+	v := rsPool.Get()
+	if v == nil {
+		return &Result{}
+	}
+	return v.(*Result)
+}
+
+func putResult(rs *Result) {
+	if len(rs.Values) > 8192 {
+		// Do not pool big results, since they may occupy too much memory.
+		return
+	}
+	rs.reset()
+	rsPool.Put(rs)
+}
+
+var rsPool sync.Pool
+
+func setupTfss(tagFilterss [][]storage.TagFilter) ([]*storage.TagFilters, error) {
+	tfss := make([]*storage.TagFilters, 0, len(tagFilterss))
+	for _, tagFilters := range tagFilterss {
+		tfs := storage.NewTagFilters()
+		for i := range tagFilters {
+			tf := &tagFilters[i]
+			if err := tfs.Add(tf.Key, tf.Value, tf.IsNegative, tf.IsRegexp); err != nil {
+				return nil, fmt.Errorf("cannot parse tag filter %s: %s", tf, err)
+			}
+		}
+		tfss = append(tfss, tfs)
+	}
+	return tfss, nil
+}
+
+// Deadline contains deadline with the corresponding timeout for pretty error messages.
+type Deadline struct {
+	Deadline time.Time
+	Timeout  time.Duration
+}
+
+// NewDeadline returns deadline for the given timeout.
+func NewDeadline(timeout time.Duration) Deadline {
+	return Deadline{
+		Deadline: time.Now().Add(timeout),
+		Timeout:  timeout,
+	}
+}

app/vmselect/netstorage/tmp_blocks_file.go

@@ -0,0 +1,186 @@
+package netstorage
+
+import (
+	"bufio"
+	"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/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
+
+const maxInmemoryTmpBlocksFile = 512 * 1024
+
+type tmpBlocksFile struct {
+	buf []byte
+
+	f  *os.File
+	bw *bufio.Writer
+
+	offset uint64
+}
+
+func getTmpBlocksFile() *tmpBlocksFile {
+	v := tmpBlocksFilePool.Get()
+	if v == nil {
+		return &tmpBlocksFile{}
+	}
+	return v.(*tmpBlocksFile)
+}
+
+func putTmpBlocksFile(tbf *tmpBlocksFile) {
+	tbf.MustClose()
+	tbf.buf = tbf.buf[:0]
+	tbf.f = nil
+	tbf.bw = 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)
+}
+
+func getBufioWriter(f *os.File) *bufio.Writer {
+	v := bufioWriterPool.Get()
+	if v == nil {
+		return bufio.NewWriterSize(f, maxInmemoryTmpBlocksFile*2)
+	}
+	bw := v.(*bufio.Writer)
+	bw.Reset(f)
+	return bw
+}
+
+func putBufioWriter(bw *bufio.Writer) {
+	bufioWriterPool.Put(bw)
+}
+
+var bufioWriterPool sync.Pool
+
+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) {
+	var addr tmpBlockAddr
+	addr.offset = tbf.offset
+
+	tbfBufLen := len(tbf.buf)
+	tbf.buf = storage.MarshalBlock(tbf.buf, b)
+	addr.size = len(tbf.buf) - tbfBufLen
+	tbf.offset += uint64(addr.size)
+	if tbf.offset <= maxInmemoryTmpBlocksFile {
+		return addr, nil
+	}
+
+	if tbf.f == nil {
+		f, err := ioutil.TempFile(tmpBlocksDir, "")
+		if err != nil {
+			return addr, err
+		}
+		tbf.f = f
+		tbf.bw = getBufioWriter(f)
+		tmpBlocksFilesCreated.Inc()
+	}
+	_, err := tbf.bw.Write(tbf.buf)
+	tbf.buf = tbf.buf[:0]
+	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
+	}
+
+	err := tbf.bw.Flush()
+	putBufioWriter(tbf.bw)
+	tbf.bw = nil
+	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 err
+}
+
+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
+	}
+	if tbf.bw != nil {
+		putBufioWriter(tbf.bw)
+		tbf.bw = nil
+	}
+	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 := 4
+	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 := 3
+			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/labels/count .
+{% 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/labels/count .
+
+//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,649 @@
+package prometheus
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"net/http"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/promql"
+	"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")
+)
+
+// 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(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{
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+
+	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(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(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(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{
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+
+	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(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")
+	}
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	sq := &storage.SearchQuery{
+		TagFilterss: tagFilterss,
+	}
+	deletedCount, err := netstorage.DeleteSeries(sq)
+	if err != nil {
+		return fmt.Errorf("cannot delete time series matching %q: %s", matches, err)
+	}
+	if deletedCount > 0 {
+		promql.ResetRollupResultCache()
+	}
+	deleteDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var deleteDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/admin/tsdb/delete_series"}`)
+
+// LabelValuesHandler processes /api/v1/label/<labelName>/values request.
+//
+// See https://prometheus.io/docs/prometheus/latest/querying/api/#querying-label-values
+func LabelValuesHandler(labelName string, w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	labelValues, err := netstorage.GetLabelValues(labelName, deadline)
+	if err != nil {
+		return fmt.Errorf(`cannot obtain label values for %q: %s`, labelName, err)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteLabelValuesResponse(w, labelValues)
+	labelValuesDuration.UpdateDuration(startTime)
+	return nil
+}
+
+var labelValuesDuration = metrics.NewSummary(`vm_request_duration_seconds{path="/api/v1/label/{}/values"}`)
+
+// LabelsCountHandler processes /api/v1/labels/count request.
+func LabelsCountHandler(w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	labelEntries, err := netstorage.GetLabelEntries(deadline)
+	if err != nil {
+		return fmt.Errorf(`cannot obtain label entries: %s`, err)
+	}
+
+	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(w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	labels, err := netstorage.GetLabels(deadline)
+	if err != nil {
+		return fmt.Errorf("cannot obtain labels: %s", err)
+	}
+
+	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(w http.ResponseWriter, r *http.Request) error {
+	startTime := time.Now()
+	deadline := getDeadline(r)
+	n, err := netstorage.GetSeriesCount(deadline)
+	if err != nil {
+		return fmt.Errorf("cannot obtain series count: %s", err)
+	}
+	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(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")
+	}
+	// Set start to minTimeMsecs by default as Prometheus does.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/91
+	start, err := getTime(r, "start", minTimeMsecs)
+	if err != nil {
+		return err
+	}
+	end, err := getTime(r, "end", ct)
+	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{
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, deadline)
+	if err != nil {
+		return fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+
+	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(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(w, []string{childQuery}, start, end, "promapi", deadline); err != nil {
+			return err
+		}
+		queryDuration.UpdateDuration(startTime)
+		return nil
+	}
+
+	ec := promql.EvalConfig{
+		Start:    start,
+		End:      start,
+		Step:     step,
+		Deadline: deadline,
+	}
+	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(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
+	}
+	start, end = promql.AdjustStartEnd(start, end, step)
+
+	ec := promql.EvalConfig{
+		Start:    start,
+		End:      end,
+		Step:     step,
+		Deadline: deadline,
+		MayCache: mayCache,
+	}
+	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)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteQueryRangeResponse(w, result)
+	queryRangeDuration.UpdateDuration(startTime)
+	return nil
+}
+
+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
+}

app/vmselect/prometheus/prometheus_test.go

@@ -0,0 +1,78 @@
+package prometheus
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+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,529 @@
+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
+	}
+	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,187 @@
+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
+		}
+		if v1 != v2 {
+			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/arch_arm64.go

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

app/vmselect/promql/binary_op.go

@@ -0,0 +1,543 @@
+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 {
+				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 {
+				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 {
+	return left == right
+}
+
+func binaryOpNeq(left, right float64) bool {
+	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,781 @@
+package promql
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"runtime"
+	"sync"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"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 {
+	Start int64
+	End   int64
+	Step  int64
+
+	Deadline netstorage.Deadline
+
+	MayCache bool
+
+	timestamps     []int64
+	timestampsOnce sync.Once
+}
+
+// newEvalConfig returns new EvalConfig copy from src.
+func newEvalConfig(src *EvalConfig) *EvalConfig {
+	var ec EvalConfig
+	ec.Start = src.Start
+	ec.End = src.End
+	ec.Step = src.Step
+	ec.Deadline = src.Deadline
+	ec.MayCache = src.MayCache
+
+	// 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{
+		MinTimestamp: start - window - maxSilenceInterval,
+		MaxTimestamp: ec.End + ec.Step,
+		TagFilterss:  [][]storage.TagFilter{me.TagFilters},
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, ec.Deadline)
+	if err != nil {
+		return nil, err
+	}
+	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)
+	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
+	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, query=%q",
+					*logSlowQueryDuration, d, ec.Start/1000, ec.End/1000, ec.Step/1000, 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]bool)
+	bb := bbPool.Get()
+	for i, ts := range tss {
+		bb.B = marshalMetricNameSorted(bb.B[:0], &ts.MetricName)
+		if m[string(bb.B)] {
+			return nil, fmt.Errorf(`duplicate output timeseries: %s%s`, ts.MetricName.MetricGroup, stringMetricName(&ts.MetricName))
+		}
+		m[string(bb.B)] = true
+
+		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,471 @@
+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) {
+	if strings.HasPrefix(s, "Inf") {
+		return "Inf", nil
+	}
+	if strings.HasPrefix(s, "NaN") {
+		return "NaN", nil
+	}
+	// 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 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 strings.HasPrefix(s, "Inf") || strings.HasPrefix(s, "NaN")
+	}
+	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,696 @@
+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(`Inf`, `+Inf`)
+	another(`+Inf`, `+Inf`)
+	another(`-Inf`, `-Inf`)
+
+	// binaryOpExpr
+	another(`NaN + 2 *3 * Inf`, `NaN`)
+	another(`Inf - Inf`, `NaN`)
+	another(`Inf + Inf`, `+Inf`)
+	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,879 @@
+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),
+	"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,
+}
+
+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
+	for _, tEnd := range rc.Timestamps {
+		tStart := tEnd - window
+		n := sort.Search(len(timestamps)-i, func(n int) bool {
+			return timestamps[i+n] > tStart
+		})
+		i += n
+		if j < i {
+			j = i
+		}
+		n = sort.Search(len(timestamps)-j, func(n int) bool {
+			return timestamps[j+n] > tEnd
+		})
+		j += n
+
+		rfa.prevValue = nan
+		rfa.prevTimestamp = tStart - maxPrevInterval
+		if 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 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 1
+	}
+	// Slightly increase d in order to handle possible jitter in scrape interval.
+	return d + (d / 16)
+}
+
+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
+		}
+		prevValue = values[0]
+		values = values[1:]
+	}
+	if len(values) == 0 {
+		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
+		}
+		return 0
+	}
+	lastValue := values[len(values)-1]
+	values = values[:len(values)-1]
+	if len(values) == 0 {
+		prevValue := rfa.prevValue
+		if math.IsNaN(prevValue) {
+			return 0
+		}
+		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) == 0 {
+			return nan
+		}
+		prevValue = values[0]
+		prevTimestamp = timestamps[0]
+		values = values[1:]
+		timestamps = timestamps[1:]
+	}
+	if len(values) == 0 {
+		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) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	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) / 1000)
+}
+
+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,509 @@
+package promql
+
+import (
+	"crypto/rand"
+	"flag"
+	"fmt"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/memory"
+	"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{
+	fastcache.New(1024 * 1024), // 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
+func InitRollupResultCache(cachePath string) {
+	rollupResultCachePath = cachePath
+	startTime := time.Now()
+	var c *fastcache.Cache
+	if len(rollupResultCachePath) > 0 {
+		logger.Infof("loading rollupResult cache from %q...", rollupResultCachePath)
+		c = fastcache.LoadFromFileOrNew(rollupResultCachePath, getRollupResultCacheSize())
+	} else {
+		c = fastcache.New(getRollupResultCacheSize())
+	}
+	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.Reset()
+		return
+	}
+	gomaxprocs := runtime.GOMAXPROCS(-1)
+	logger.Infof("saving rollupResult cache to %q...", rollupResultCachePath)
+	startTime := time.Now()
+	if err := rollupResultCacheV.c.SaveToFileConcurrent(rollupResultCachePath, gomaxprocs); err != nil {
+		logger.Errorf("cannot close rollupResult cache at %q: %s", rollupResultCachePath, err)
+	} else {
+		var fcs fastcache.Stats
+		rollupResultCacheV.c.UpdateStats(&fcs)
+		rollupResultCacheV.c.Reset()
+		logger.Infof("saved rollupResult cache to %q in %s; entriesCount: %d, sizeBytes: %d",
+			rollupResultCachePath, time.Since(startTime), fcs.EntriesCount, fcs.BytesSize)
+	}
+}
+
+type rollupResultCache struct {
+	c *fastcache.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, 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])
+	resultBuf := rrc.c.GetBig(nil, bb.B)
+	if len(resultBuf) == 0 {
+		mi.RemoveKey(key)
+		metainfoBuf = mi.Marshal(metainfoBuf[:0])
+		bb.B = marshalRollupResultCacheKey(bb.B[:0], funcName, me, iafc, window, ec.Step)
+		rrc.c.Set(bb.B, metainfoBuf)
+		return nil, ec.Start
+	}
+	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
+}
+
+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
+	tssMarshaled := marshalTimeseriesFast(tss, maxMarshaledSize, ec.Step)
+	if tssMarshaled == nil {
+		tooBigRollupResults.Inc()
+		return
+	}
+
+	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, tssMarshaled)
+
+	bb.B = marshalRollupResultCacheKey(bb.B[:0], funcName, 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 = 5
+
+func marshalRollupResultCacheKey(dst []byte, funcName string, 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.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,394 @@
+package promql
+
+import (
+	"testing"
+
+	"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,
+
+		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,737 @@
+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 n != 0 {
+		t.Fatalf("unexpected value; got %v; want %v", n, 0)
+	}
+
+	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 {
+			if v != vExpected {
+				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, 0, 0, 0, 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:  141,
+			End:    171,
+			Step:   10,
+			Window: 3,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{34, nan, nan, nan}
+		timestampsExpected := []int64{141, 151, 161, 171}
+		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, 34}
+		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, 34}
+		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{0, 33, -87, 0}
+		timestampsExpected := []int64{10, 50, 90, 130}
+		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", 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)
+	})
+}
+
+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(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 nil
+	}
+
+	// Allocate the buffer for the marshaled tss before its' marshaling.
+	// This should reduce memory fragmentation and memory usage.
+	dst := make([]byte, 0, size)
+	dst = marshalFastTimestamps(dst, 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(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/README.md

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

app/vmstorage/main.go

@@ -0,0 +1,515 @@
+package vmstorage
+
+import (
+	"flag"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/encoding"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/httpserver"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/syncwg"
+	"github.com/VictoriaMetrics/metrics"
+)
+
+var (
+	retentionPeriod = flag.Int("retentionPeriod", 1, "Retention period in months")
+	snapshotAuthKey = flag.String("snapshotAuthKey", "", "authKey, which must be passed in query string to /snapshot* pages")
+
+	precisionBits = flag.Int("precisionBits", 64, "The number of precision bits to store per each value. Lower precision bits improves data compression at the cost of precision loss")
+
+	// DataPath is a path to storage data.
+	DataPath = flag.String("storageDataPath", "victoria-metrics-data", "Path to storage data")
+)
+
+// Init initializes vmstorage.
+func Init() {
+	InitWithoutMetrics()
+	registerStorageMetrics()
+}
+
+// InitWithoutMetrics must be called instead of Init inside tests.
+//
+// This allows multiple Init / Stop cycles.
+func InitWithoutMetrics() {
+	if err := encoding.CheckPrecisionBits(uint8(*precisionBits)); err != nil {
+		logger.Fatalf("invalid `-precisionBits`: %s", err)
+	}
+	logger.Infof("opening storage at %q with retention period %d months", *DataPath, *retentionPeriod)
+	startTime := time.Now()
+	WG = syncwg.WaitGroup{}
+	strg, err := storage.OpenStorage(*DataPath, *retentionPeriod)
+	if err != nil {
+		logger.Fatalf("cannot open a storage at %s with retention period %d months: %s", *DataPath, *retentionPeriod, err)
+	}
+	Storage = strg
+
+	var m storage.Metrics
+	Storage.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",
+		*DataPath, time.Since(startTime), partsCount, blocksCount, rowsCount, sizeBytes)
+}
+
+// Storage is a storage.
+//
+// Every storage call must be wrapped into WG.Add(1) ... WG.Done()
+// for proper graceful shutdown when Stop is called.
+var Storage *storage.Storage
+
+// WG must be incremented before Storage call.
+//
+// Use syncwg instead of sync, since Add is called from concurrent goroutines.
+var WG syncwg.WaitGroup
+
+// AddRows adds mrs to the storage.
+func AddRows(mrs []storage.MetricRow) error {
+	WG.Add(1)
+	err := Storage.AddRows(mrs, uint8(*precisionBits))
+	WG.Done()
+	return err
+}
+
+// DeleteMetrics deletes metrics matching tfss.
+//
+// Returns the number of deleted metrics.
+func DeleteMetrics(tfss []*storage.TagFilters) (int, error) {
+	WG.Add(1)
+	n, err := Storage.DeleteMetrics(tfss)
+	WG.Done()
+	return n, err
+}
+
+// SearchTagKeys searches for tag keys
+func SearchTagKeys(maxTagKeys int) ([]string, error) {
+	WG.Add(1)
+	keys, err := Storage.SearchTagKeys(maxTagKeys)
+	WG.Done()
+	return keys, err
+}
+
+// SearchTagValues searches for tag values for the given tagKey
+func SearchTagValues(tagKey []byte, maxTagValues int) ([]string, error) {
+	WG.Add(1)
+	values, err := Storage.SearchTagValues(tagKey, maxTagValues)
+	WG.Done()
+	return values, err
+}
+
+// SearchTagEntries searches for tag entries.
+func SearchTagEntries(maxTagKeys, maxTagValues int) ([]storage.TagEntry, error) {
+	WG.Add(1)
+	tagEntries, err := Storage.SearchTagEntries(maxTagKeys, maxTagValues)
+	WG.Done()
+	return tagEntries, err
+}
+
+// GetSeriesCount returns the number of time series in the storage.
+func GetSeriesCount() (uint64, error) {
+	WG.Add(1)
+	n, err := Storage.GetSeriesCount()
+	WG.Done()
+	return n, err
+}
+
+// Stop stops the vmstorage
+func Stop() {
+	logger.Infof("gracefully closing the storage at %s", *DataPath)
+	startTime := time.Now()
+	WG.WaitAndBlock()
+	Storage.MustClose()
+	logger.Infof("successfully closed the storage in %s", time.Since(startTime))
+
+	logger.Infof("the storage has been stopped")
+}
+
+// RequestHandler is a storage request handler.
+func RequestHandler(w http.ResponseWriter, r *http.Request) bool {
+	path := r.URL.Path
+	prometheusCompatibleResponse := false
+	if path == "/api/v1/admin/tsdb/snapshot" {
+		// Handle Prometheus API - https://prometheus.io/docs/prometheus/latest/querying/api/#snapshot .
+		prometheusCompatibleResponse = true
+		path = "/snapshot/create"
+	}
+	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 := Storage.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
+		}
+		if prometheusCompatibleResponse {
+			fmt.Fprintf(w, `{"status":"success","data":{"name":%q}}`, snapshotPath)
+		} else {
+			fmt.Fprintf(w, `{"status":"ok","snapshot":%q}`, snapshotPath)
+		}
+		return true
+	case "/list":
+		w.Header().Set("Content-Type", "application/json")
+		snapshots, err := Storage.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 := Storage.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 := Storage.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 := Storage.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() {
+	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
+		Storage.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_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)
+	})
+}

deployment/docker/Makefile

@@ -0,0 +1,44 @@
+DOCKER_NAMESPACE := victoriametrics
+BUILDER_IMAGE := local/builder:go1.12.7
+CERTS_IMAGE := local/certs:1.0.2
+
+package-certs:
+	(docker image ls --format '{{.Repository}}:{{.Tag}}' | grep -q '$(CERTS_IMAGE)') \
+		|| docker build -t $(CERTS_IMAGE) deployment/docker/certs
+
+package-builder:
+	(docker image ls --format '{{.Repository}}:{{.Tag}}' | grep -q '$(BUILDER_IMAGE)') \
+		|| docker build -t $(BUILDER_IMAGE) deployment/docker/builder
+
+app-via-docker: package-certs package-builder
+	mkdir -p gocache-for-docker
+	docker run --rm \
+		--user $(shell id -u):$(shell id -g) \
+		--mount type=bind,src="$(shell pwd)",dst=/VictoriaMetrics \
+		-w /VictoriaMetrics \
+		--mount type=bind,src="$(shell pwd)/gocache-for-docker",dst=/gocache \
+		--env GOCACHE=/gocache \
+		--env GO111MODULE=on \
+		$(DOCKER_OPTS) \
+		$(BUILDER_IMAGE) \
+		go build $(RACE) -mod=vendor -ldflags "-s -w -extldflags '-static' $(GO_BUILDINFO)" -tags 'netgo osusergo' -o bin/$(APP_NAME)$(APP_SUFFIX)-prod $(PKG_PREFIX)/app/$(APP_NAME)
+
+package-via-docker:
+	(docker image ls --format '{{.Repository}}:{{.Tag}}' | grep -q '$(DOCKER_NAMESPACE)/$(APP_NAME):$(PKG_TAG)$(RACE)') || (\
+		$(MAKE) app-via-docker && \
+		docker build -t $(DOCKER_NAMESPACE)/$(APP_NAME):$(PKG_TAG)$(RACE) -f app/$(APP_NAME)/deployment/Dockerfile .)
+
+publish-via-docker: package-via-docker
+	docker push $(DOCKER_NAMESPACE)/$(APP_NAME):$(PKG_TAG)$(RACE)
+	docker tag $(DOCKER_NAMESPACE)/$(APP_NAME):$(PKG_TAG)$(RACE) $(DOCKER_NAMESPACE)/$(APP_NAME):latest
+	docker push $(DOCKER_NAMESPACE)/$(APP_NAME):latest
+
+run-via-docker: package-via-docker
+	docker run -it --rm \
+		--user $(shell id -u):$(shell id -g) \
+		--net host \
+		$(DOCKER_OPTS) \
+		$(DOCKER_NAMESPACE)/$(APP_NAME):$(PKG_TAG)$(RACE) $(ARGS)
+
+remove-docker-images:
+	docker image ls --format '{{.Repository}}\t{{.ID}}' | grep $(DOCKER_NAMESPACE)/ | grep -v /builder | awk '{print $$2}' | xargs docker image rm -f