app/vmselect: allow passing match[], start and time to /api/v1/label/<label_name>/values

`/api/v1/label/<label_name>/values?match[]=q` emulates emulates `label_values(q, <label_name>)`
call in Grafana templating.

.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,41 +1,690 @@
-<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. Offload operational burden - configuration, capacity planning, scalability, backups, retention, durability - from Prometheus local storage to VictoriaMetrics.
-- Insertion rate scales to [millions of metric values per second](https://medium.com/@valyala/insert-benchmarks-with-inch-influxdb-vs-victoriametrics-e31a41ae2893).
-- Storage scales to [millions of metrics](https://medium.com/@valyala/high-cardinality-tsdb-benchmarks-victoriametrics-vs-timescaledb-vs-influxdb-13e6ee64dd6b) 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](https://medium.com/@valyala/when-size-matters-benchmarking-victoriametrics-vs-timescale-and-influxdb-6035811952d4). 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 and in [OpenTSDB format](http://opentsdb.net/docs/build/html/api_telnet/put.html) if `-opentsdbListenAddr` is set.
-- VictoriaMetrics supports backfilling, i.e. data points from the past may be inserted into the DB.
-- Time series data may be exported via `/api/v1/export?match=<metric_selector>`. Optional `start` and `end` timestamps may be added for exporting time series in the given time range.
-- Time series may be deleted via `/api/v1/admin/tsdb/delete_series?match[]=<metric_selector>`.
-- [Instant snapshots](https://medium.com/@valyala/how-victoriametrics-makes-instant-snapshots-for-multi-terabyte-time-series-data-e1f3fb0e0282) are supported.
+## 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
 
-* [Free single-node VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics/wiki/Single-server-VictoriaMetrics)
-* [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.
+* 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.
+
+It is recommended setting up [monitoring](#monitoring) for VictoriaMetrics.
+
+
+### 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).
 
@@ -46,24 +695,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,245 @@
+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
+		currentTs -= currentTs % tsMultiplier
+		for i := range ctx.Rows.Rows {
+			row := &ctx.Rows.Rows[i]
+			if row.Timestamp == 0 {
+				row.Timestamp = currentTs
+			} else {
+				row.Timestamp *= tsMultiplier
+			}
+		}
+	}
+	return true
+}
+
+var (
+	influxReadCalls       = metrics.NewCounter(`vm_read_calls_total{name="influx"}`)
+	influxReadErrors      = metrics.NewCounter(`vm_read_errors_total{name="influx"}`)
+	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,572 @@
+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
+	fetchData bool
+	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, rss.fetchData, maxWorkersCount); err != nil {
+					break
+				}
+				if len(rs.Timestamps) == 0 && rss.fetchData {
+					// 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, fetchData bool, 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, fetchData); 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, fetchData bool) error {
+	tbf.MustReadBlockAt(&sb.b, addr)
+	if fetchData {
+		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, fetchData bool, 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, fetchData, *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.fetchData = fetchData
+	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,729 @@
+package prometheus
+
+import (
+	"flag"
+	"fmt"
+	"math"
+	"net/http"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/netstorage"
+	"github.com/VictoriaMetrics/VictoriaMetrics/app/vmselect/promql"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/logger"
+	"github.com/VictoriaMetrics/VictoriaMetrics/lib/storage"
+	"github.com/VictoriaMetrics/metrics"
+	"github.com/valyala/quicktemplate"
+)
+
+var (
+	maxQueryDuration = flag.Duration("search.maxQueryDuration", time.Second*30, "The maximum time for search query execution")
+	maxQueryLen      = flag.Int("search.maxQueryLen", 16*1024, "The maximum search query length in bytes")
+)
+
+// 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, true, 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, true, 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)
+
+	if err := r.ParseForm(); err != nil {
+		return fmt.Errorf("cannot parse form values: %s", err)
+	}
+	var labelValues []string
+	if len(r.Form["match[]"]) == 0 && len(r.Form["start"]) == 0 && len(r.Form["end"]) == 0 {
+		var err error
+		labelValues, err = netstorage.GetLabelValues(labelName, deadline)
+		if err != nil {
+			return fmt.Errorf(`cannot obtain label values for %q: %s`, labelName, err)
+		}
+	} else {
+		// Extended functionality that allows filtering by label filters and time range
+		// i.e. /api/v1/label/foo/values?match[]=foobar{baz="abc"}&start=...&end=...
+		// is equivalent to `label_values(foobar{baz="abc"}, foo)` call on the selected
+		// time range in Grafana templating.
+		matches := r.Form["match[]"]
+		if len(matches) == 0 {
+			matches = []string{fmt.Sprintf("{%s!=''}", labelName)}
+		}
+		ct := currentTime()
+		end, err := getTime(r, "end", ct)
+		if err != nil {
+			return err
+		}
+		start, err := getTime(r, "start", end-defaultStep)
+		if err != nil {
+			return err
+		}
+		labelValues, err = labelValuesWithMatches(labelName, matches, start, end, deadline)
+		if err != nil {
+			return fmt.Errorf("cannot obtain label values for %q, match[]=%q, start=%d, end=%d: %s", labelName, matches, start, end, err)
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	WriteLabelValuesResponse(w, labelValues)
+	labelValuesDuration.UpdateDuration(startTime)
+	return nil
+}
+
+func labelValuesWithMatches(labelName string, matches []string, start, end int64, deadline netstorage.Deadline) ([]string, error) {
+	if len(matches) == 0 {
+		logger.Panicf("BUG: matches must be non-empty")
+	}
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return nil, err
+	}
+	if start >= end {
+		start = end - defaultStep
+	}
+	sq := &storage.SearchQuery{
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, false, deadline)
+	if err != nil {
+		return nil, fmt.Errorf("cannot fetch data for %q: %s", sq, err)
+	}
+
+	m := make(map[string]struct{})
+	var mLock sync.Mutex
+	err = rss.RunParallel(func(rs *netstorage.Result, workerID uint) {
+		labelValue := rs.MetricName.GetTagValue(labelName)
+		if len(labelValue) == 0 {
+			return
+		}
+		mLock.Lock()
+		m[string(labelValue)] = struct{}{}
+		mLock.Unlock()
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error when data fetching: %s", err)
+	}
+
+	labelValues := make([]string, 0, len(m))
+	for labelValue := range m {
+		labelValues = append(labelValues, labelValue)
+	}
+	sort.Strings(labelValues)
+	return labelValues, 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")
+	}
+	end, err := getTime(r, "end", ct)
+	if err != nil {
+		return err
+	}
+	// Do not set start to minTimeMsecs by default as Prometheus does,
+	// since this leads to fetching and scanning all the data from the storage,
+	// which can take a lot of time for big storages.
+	// It is better setting start as end-defaultStep by default.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/91
+	start, err := getTime(r, "start", end-defaultStep)
+	if err != nil {
+		return err
+	}
+	deadline := getDeadline(r)
+
+	tagFilterss, err := getTagFilterssFromMatches(matches)
+	if err != nil {
+		return err
+	}
+	if start >= end {
+		start = end - defaultStep
+	}
+	sq := &storage.SearchQuery{
+		MinTimestamp: start,
+		MaxTimestamp: end,
+		TagFilterss:  tagFilterss,
+	}
+	rss, err := netstorage.ProcessSearchQuery(sq, false, 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, true, 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,896 @@
+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 int64(maxSilenceInterval)
+	}
+	// Increase d more for smaller scrape intervals in order to hide possible gaps
+	// when high jitter is present.
+	// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/139 .
+	if d <= 2*1000 {
+		return d + 4*d
+	}
+	if d <= 4*1000 {
+		return d + 2*d
+	}
+	if d <= 8*1000 {
+		return d + d
+	}
+	if d <= 16*1000 {
+		return d + d/2
+	}
+	if d <= 32*1000 {
+		return d + d/4
+	}
+	return d + d/8
+}
+
+func removeCounterResets(values []float64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	var correction float64
+	prevValue := values[0]
+	for i, v := range values {
+		d := v - prevValue
+		if d < 0 {
+			if (-d * 8) < prevValue {
+				// This is likely jitter from `Prometheus HA pairs`.
+				// Just substitute v with prevValue.
+				v = prevValue
+			} else {
+				correction += prevValue
+			}
+		}
+		prevValue = v
+		values[i] = v + correction
+	}
+}
+
+func deltaValues(values []float64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	prevDelta := float64(0)
+	prevValue := values[0]
+	for i, v := range values[1:] {
+		prevDelta = v - prevValue
+		values[i] = prevDelta
+		prevValue = v
+	}
+	values[len(values)-1] = prevDelta
+}
+
+func derivValues(values []float64, timestamps []int64) {
+	// There is no need in handling NaNs here, since they are impossible
+	// on values from vmstorage.
+	if len(values) == 0 {
+		return
+	}
+	prevDeriv := float64(0)
+	prevValue := values[0]
+	prevTs := timestamps[0]
+	for i, v := range values[1:] {
+		ts := timestamps[i+1]
+		if ts == prevTs {
+			// Use the previous value for duplicate timestamps.
+			values[i] = prevDeriv
+			continue
+		}
+		dt := float64(ts-prevTs) * 1e-3
+		prevDeriv = (v - prevValue) / dt
+		values[i] = prevDeriv
+		prevValue = v
+		prevTs = ts
+	}
+	values[len(values)-1] = prevDeriv
+}
+
+type newRollupFunc func(args []interface{}) (rollupFunc, error)
+
+func newRollupFuncOneArg(rf rollupFunc) newRollupFunc {
+	return func(args []interface{}) (rollupFunc, error) {
+		if err := expectRollupArgsNum(args, 1); err != nil {
+			return nil, err
+		}
+		return rf, nil
+	}
+}
+
+func newRollupHoltWinters(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 3); err != nil {
+		return nil, err
+	}
+	sfs, err := getScalar(args[1], 1)
+	if err != nil {
+		return nil, err
+	}
+	tfs, err := getScalar(args[2], 2)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		// There is no need in handling NaNs here, since they must be cleaned up
+		// before calling rollup funcs.
+		values := rfa.values
+		if len(values) == 0 {
+			return rfa.prevValue
+		}
+		sf := sfs[rfa.idx]
+		if sf <= 0 || sf >= 1 {
+			return nan
+		}
+		tf := tfs[rfa.idx]
+		if tf <= 0 || tf >= 1 {
+			return nan
+		}
+
+		// See https://en.wikipedia.org/wiki/Exponential_smoothing#Double_exponential_smoothing .
+		// TODO: determine whether this shit really works.
+		s0 := rfa.prevValue
+		if math.IsNaN(s0) {
+			s0 = values[0]
+			values = values[1:]
+			if len(values) == 0 {
+				return s0
+			}
+		}
+		b0 := values[0] - s0
+		for _, v := range values {
+			s1 := sf*v + (1-sf)*(s0+b0)
+			b1 := tf*(s1-s0) + (1-tf)*b0
+			s0 = s1
+			b0 = b1
+		}
+		return s0
+	}
+	return rf, nil
+}
+
+func newRollupPredictLinear(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	secs, err := getScalar(args[1], 1)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		v, k := linearRegression(rfa)
+		if math.IsNaN(v) {
+			return nan
+		}
+		sec := secs[rfa.idx]
+		return v + k*sec
+	}
+	return rf, nil
+}
+
+func linearRegression(rfa *rollupFuncArg) (float64, float64) {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	timestamps := rfa.timestamps
+	if len(values) == 0 {
+		return rfa.prevValue, 0
+	}
+
+	// See https://en.wikipedia.org/wiki/Simple_linear_regression#Numerical_example
+	tFirst := rfa.prevTimestamp
+	vSum := rfa.prevValue
+	tSum := float64(0)
+	tvSum := float64(0)
+	ttSum := float64(0)
+	n := 1.0
+	if math.IsNaN(rfa.prevValue) {
+		tFirst = timestamps[0]
+		vSum = 0
+		n = 0
+	}
+	for i, v := range values {
+		dt := float64(timestamps[i]-tFirst) * 1e-3
+		vSum += v
+		tSum += dt
+		tvSum += dt * v
+		ttSum += dt * dt
+	}
+	n += float64(len(values))
+	if n == 1 {
+		return vSum, 0
+	}
+	k := (n*tvSum - tSum*vSum) / (n*ttSum - tSum*tSum)
+	v := (vSum - k*tSum) / n
+	// Adjust v to the last timestamp on the given time range.
+	v += k * (float64(timestamps[len(timestamps)-1]-tFirst) * 1e-3)
+	return v, k
+}
+
+func newRollupQuantile(args []interface{}) (rollupFunc, error) {
+	if err := expectRollupArgsNum(args, 2); err != nil {
+		return nil, err
+	}
+	phis, err := getScalar(args[0], 0)
+	if err != nil {
+		return nil, err
+	}
+	rf := func(rfa *rollupFuncArg) float64 {
+		// There is no need in handling NaNs here, since they must be cleaned up
+		// before calling rollup funcs.
+		values := rfa.values
+		if len(values) == 0 {
+			return rfa.prevValue
+		}
+		if len(values) == 1 {
+			// Fast path - only a single value.
+			return values[0]
+		}
+		hf := histogram.GetFast()
+		for _, v := range values {
+			hf.Update(v)
+		}
+		phi := phis[rfa.idx]
+		qv := hf.Quantile(phi)
+		histogram.PutFast(hf)
+		return qv
+	}
+	return rf, nil
+}
+
+func rollupAvg(rfa *rollupFuncArg) float64 {
+	// Do not use `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation,
+	// since it is slower and has no significant benefits in precision.
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	var sum float64
+	for _, v := range values {
+		sum += v
+	}
+	return sum / float64(len(values))
+}
+
+func rollupMin(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	minValue := values[0]
+	for _, v := range values {
+		if v < minValue {
+			minValue = v
+		}
+	}
+	return minValue
+}
+
+func rollupMax(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	maxValue := values[0]
+	for _, v := range values {
+		if v > maxValue {
+			maxValue = v
+		}
+	}
+	return maxValue
+}
+
+func rollupSum(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	var sum float64
+	for _, v := range values {
+		sum += v
+	}
+	return sum
+}
+
+func rollupSum2(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue * rfa.prevValue
+	}
+	var sum2 float64
+	for _, v := range values {
+		sum2 += v * v
+	}
+	return sum2
+}
+
+func rollupGeomean(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		return rfa.prevValue
+	}
+	p := 1.0
+	for _, v := range values {
+		p *= v
+	}
+	return math.Pow(p, 1/float64(len(values)))
+}
+
+func rollupCount(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	return float64(len(values))
+}
+
+func rollupStddev(rfa *rollupFuncArg) float64 {
+	stdvar := rollupStdvar(rfa)
+	return math.Sqrt(stdvar)
+}
+
+func rollupStdvar(rfa *rollupFuncArg) float64 {
+	// See `Rapid calculation methods` at https://en.wikipedia.org/wiki/Standard_deviation
+
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	if len(values) == 0 {
+		if math.IsNaN(rfa.prevValue) {
+			return nan
+		}
+		return 0
+	}
+	if len(values) == 1 {
+		// Fast path.
+		return values[0]
+	}
+	var avg float64
+	var count float64
+	var q float64
+	for _, v := range values {
+		count++
+		avgNew := avg + (v-avg)/count
+		q += (v - avg) * (v - avgNew)
+		avg = avgNew
+	}
+	return q / count
+}
+
+func rollupDelta(rfa *rollupFuncArg) float64 {
+	// There is no need in handling NaNs here, since they must be cleaned up
+	// before calling rollup funcs.
+	values := rfa.values
+	prevValue := rfa.prevValue
+	if math.IsNaN(prevValue) {
+		if len(values) == 0 {
+			return nan
+		}
+		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, 0}
+		timestampsExpected := []int64{120, 124, 128, 132, 136, 140, 144, 148}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupWindowNoPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    4,
+			Step:   1,
+			Window: 3,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, nan, nan, nan, nan}
+		timestampsExpected := []int64{0, 1, 2, 3, 4}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  161,
+			End:    191,
+			Step:   10,
+			Window: 3,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{34, 34, 34, nan}
+		timestampsExpected := []int64{161, 171, 181, 191}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+}
+
+func TestRollupNoWindowPartialPoints(t *testing.T) {
+	t.Run("beforeStart", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  0,
+			End:    25,
+			Step:   5,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{nan, 123, 123, 123, 34, 34}
+		timestampsExpected := []int64{0, 5, 10, 15, 20, 25}
+		testRowsEqual(t, values, rc.Timestamps, valuesExpected, timestampsExpected)
+	})
+	t.Run("afterEnd", func(t *testing.T) {
+		rc := rollupConfig{
+			Func:   rollupFirst,
+			Start:  100,
+			End:    160,
+			Step:   20,
+			Window: 0,
+		}
+		rc.Timestamps = getTimestamps(rc.Start, rc.End, rc.Step)
+		values := rc.Do(nil, testValues, testTimestamps)
+		valuesExpected := []float64{12, 44, 34, 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, 34}
+		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