Binary operators in LogQL

[owen-d]

What this PR does / why we need it:
This feature introduces binary operators into LogQL. In addition to the benefits provided by binary operations, it also helps pave the way for future sharding work.

Arithmetic Binary Operators

Arithmetic binary operators
The following binary arithmetic operators exist in Loki:

• + (addition)
• - (subtraction)
• * (multiplication)
• / (division)
• % (modulo)

Binary arithmetic operators are defined only between two vectors.

Between two instant vectors, a binary arithmetic operator is applied to each entry in the left-hand side vector and its matching element in the right-hand vector. The result is propagated into the result vector with the grouping labels becoming the output label set. Entries for which no matching entry in the right-hand vector can be found are not part of the result.

Examples

Get proportion of warning logs to error logs for the foo app

sum(rate({app="foo", level="warn"}[1m])) / sum(rate({app="foo", level="error"}[1m]))

Operators on the same precedence level are left-associative (queries substituted with numbers here for simplicity). For example, 2 * 3 % 2 is equivalent to (2 * 3) % 2. However, some operators have different priorities: 1 + 2 / 3 will still be 1 + ( 2 / 3 ). These function identically to mathematical conventions.

Logical/set binary operators

These logical/set binary operators are only defined between two vectors:

• and (intersection)
• or (union)
• unless (complement)

vector1 and vector2 results in a vector consisting of the elements of vector1 for which there are elements in vector2 with exactly matching label sets. Other elements are dropped.

vector1 or vector2 results in a vector that contains all original elements (label sets + values) of vector1 and additionally all elements of vector2 which do not have matching label sets in vector1.

vector1 unless vector2 results in a vector consisting of the elements of vector1 for which there are no elements in vector2 with exactly matching label sets. All matching elements in both vectors are dropped.

Examples

This contrived query will return the intersection of these queries, effectively rate({app="bar"})

rate({app=~"foo|bar"}[1m]) and rate({app="bar"}[1m])

[codecov-io]

Codecov Report

Merging #1662 into master will increase coverage by 0.58%.
The diff coverage is 92.7%.

@@            Coverage Diff             @@
##           master    #1662      +/-   ##
==========================================
+ Coverage   61.73%   62.31%   +0.58%     
==========================================
  Files         109      109              
  Lines        8310     8446     +136     
==========================================
+ Hits         5130     5263     +133     
- Misses       2784     2786       +2     
- Partials      396      397       +1

Impacted Files	Coverage Δ
pkg/logql/lex.go	100% <ø> (ø)	⬆️
pkg/logql/ast.go	88.6% <100%> (+1.39%)	⬆️
pkg/logql/engine.go	88.23% <100%> (ø)	⬆️
pkg/logql/evaluator.go	92.23% <91.3%> (+0.48%)	⬆️
pkg/promtail/targets/filetarget.go	70.55% <0%> (+1.84%)	⬆️
pkg/promtail/targets/tailer.go	75.86% <0%> (+2.29%)	⬆️

[cyriltovena]

I'd like to have more failure tests, specially around unexpected type like two logstreams ({app="foo"} + {app="fuzz"}) which you seem to support reading the yacc file. (I might be wrong).

This would also be nice for covering panic thrown in the ast.go

We should try to keep error message for those bad query useful for our users.

[cyriltovena]

LGTM, left few comments about ast error.

[cyriltovena]

LGTM