filters: use faster regexp package

[bboreham]

This PR applies some optimisations I have submitted to the Go project:

• regexp: allow patterns with no alternates to be one-pass
• regexp: speed up onepass prefix check
• regexp: handle prefix string with fold-case
• regexp: avoid copying each instruction executed
• regexp: allow prefix string anchored at beginning

I have a FOSDEM talk on Saturday 6th Feb about this.

I collected the optimisations into a new repo https://github.com/grafana/regexp; it exists purely to make PRs like this possible and can be retired once the changes land upstream.

I also added some new benchmark cases, because all the existing ones don't actually reach the regexp package after 'simplification'.
The benchmark is now running each case once for each iteration instead of a million times; this makes it easier to control the time and to read the averages.

name                                                           old time/op  new time/op   delta
_LineFilter/simplified_true_foo.*-4                            28.5ns ± 4%   27.8ns ± 4%     ~     (p=0.222 n=5+5)
_LineFilter/simplified_false_foo.*-4                           38.8ns ± 3%   39.0ns ± 5%     ~     (p=1.000 n=5+5)
_LineFilter/simplified_true_(?i)foo-4                           203ns ± 4%    200ns ± 3%     ~     (p=0.881 n=5+5)
_LineFilter/simplified_false_(?i)foo-4                          209ns ± 3%    211ns ± 5%     ~     (p=0.690 n=5+5)
_LineFilter/simplified_true_.*foo.*-4                          27.9ns ± 1%   28.1ns ± 2%     ~     (p=0.746 n=5+5)
_LineFilter/simplified_false_.*foo.*-4                         38.8ns ± 2%   39.0ns ± 3%     ~     (p=1.000 n=5+5)
_LineFilter/simplified_true_.*foo-4                            28.0ns ± 3%   27.9ns ± 2%     ~     (p=1.000 n=5+5)
_LineFilter/simplified_false_.*foo-4                           38.1ns ± 3%   39.0ns ± 2%     ~     (p=0.151 n=5+5)
_LineFilter/simplified_true_foo|bar-4                          78.5ns ± 1%   76.9ns ± 4%     ~     (p=0.151 n=5+5)
_LineFilter/simplified_false_foo|bar-4                         97.8ns ± 1%  100.1ns ± 6%     ~     (p=0.548 n=5+5)
_LineFilter/simplified_true_foo|bar|buzz-4                     92.5ns ± 2%   92.0ns ± 2%     ~     (p=0.548 n=5+5)
_LineFilter/simplified_false_foo|bar|buzz-4                     115ns ± 1%    114ns ± 2%     ~     (p=0.310 n=5+5)
_LineFilter/simplified_true_foo|(bar|buzz)-4                   93.7ns ± 4%   92.2ns ± 4%     ~     (p=0.222 n=5+5)
_LineFilter/simplified_false_foo|(bar|buzz)-4                   114ns ± 2%    112ns ± 1%     ~     (p=0.056 n=5+5)
_LineFilter/simplified_true_foo|bar.*|buzz-4                   93.5ns ± 4%   91.5ns ± 2%     ~     (p=0.222 n=5+5)
_LineFilter/simplified_false_foo|bar.*|buzz-4                   115ns ± 4%    114ns ± 2%     ~     (p=0.714 n=5+5)
_LineFilter/simplified_true_.*foo.*|bar|uzz-4                  92.3ns ± 3%   91.3ns ± 2%     ~     (p=0.087 n=5+5)
_LineFilter/simplified_false_.*foo.*|bar|uzz-4                  116ns ± 3%    115ns ± 3%     ~     (p=0.460 n=5+5)
_LineFilter/simplified_true_((f.*)|foobar.*)|.*buzz-4           145ns ± 2%    146ns ± 1%     ~     (p=0.222 n=5+5)
_LineFilter/simplified_false_((f.*)|foobar.*)|.*buzz-4          180ns ± 2%    179ns ± 1%     ~     (p=0.421 n=5+5)
_LineFilter/simplified_true_(?P<foo>.*foo.*|bar)-4             79.0ns ± 2%   77.3ns ± 3%     ~     (p=0.151 n=5+5)
_LineFilter/simplified_false_(?P<foo>.*foo.*|bar)-4             104ns ± 6%     99ns ± 4%     ~     (p=0.056 n=5+5)
_LineFilter/simplified_true_(\s|")+(?i)bar-4                   7.10µs ± 5%   6.87µs ± 2%   -3.24%  (p=0.032 n=5+5)
_LineFilter/simplified_false_(\s|")+(?i)bar-4                  7.09µs ± 2%   6.90µs ± 2%   -2.72%  (p=0.016 n=5+5)
_LineFilter/simplified_true_(node:24)_buzz*-4                   110ns ± 3%     45ns ± 2%  -58.49%  (p=0.008 n=5+5)
_LineFilter/simplified_false_(node:24)_buzz*-4                  120ns ± 2%     56ns ± 4%  -53.25%  (p=0.008 n=5+5)
_LineFilter/simplified_true_(HTTP/.*\"|HEAD|GET)_(2..|5..)-4   8.11µs ± 2%   7.84µs ± 3%   -3.38%  (p=0.016 n=5+5)
_LineFilter/simplified_false_(HTTP/.*\"|HEAD|GET)_(2..|5..)-4  8.12µs ± 2%   7.85µs ± 1%   -3.34%  (p=0.008 n=5+5)
_LineFilter/simplified_true_"@l":"(Warning|Error|Fatal)"-4      110ns ± 2%     46ns ± 4%  -58.33%  (p=0.008 n=5+5)
_LineFilter/simplified_false_"@l":"(Warning|Error|Fatal)"-4     122ns ± 2%     57ns ± 3%  -52.85%  (p=0.008 n=5+5)

Checklist

• NA Documentation added
• Tests updated
• Add an entry in the CHANGELOG.md about the changes.

[cyriltovena]

LGTM

Love it does it work the same for capture and such as the line_format regexp can match and return values as opposed to line filters which can only filters.

[bboreham]

does it work the same for capture and such

Yes, the same regexp engine is used for Match, Find and Replace, so they should see some benefit.
I guess we should have a benchmark for those.

[cyriltovena]

Let's sync to test this in dev and check the wins.