From 3f3ab233590cc0eee8b7130f56728aaecc2ca583 Mon Sep 17 00:00:00 2001 From: glightfoot Date: Tue, 28 Jul 2020 11:43:02 -0400 Subject: [PATCH] add globals for disabling individual tag parsing formats Signed-off-by: glightfoot --- main.go | 11 + pkg/line/line.go | 68 ++-- pkg/line/line_test.go | 749 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 800 insertions(+), 28 deletions(-) create mode 100644 pkg/line/line_test.go diff --git a/main.go b/main.go index 5ce9ff3..ec3bc9c 100644 --- a/main.go +++ b/main.go @@ -35,6 +35,7 @@ import ( "github.com/prometheus/statsd_exporter/pkg/address" "github.com/prometheus/statsd_exporter/pkg/event" "github.com/prometheus/statsd_exporter/pkg/exporter" + "github.com/prometheus/statsd_exporter/pkg/line" "github.com/prometheus/statsd_exporter/pkg/listener" "github.com/prometheus/statsd_exporter/pkg/mapper" ) @@ -268,6 +269,10 @@ func main() { eventFlushInterval = kingpin.Flag("statsd.event-flush-interval", "Number of events to hold in queue before flushing").Default("200ms").Duration() dumpFSMPath = kingpin.Flag("debug.dump-fsm", "The path to dump internal FSM generated for glob matching as Dot file.").Default("").String() checkConfig = kingpin.Flag("check-config", "Check configuration and exit.").Default("false").Bool() + dogstatsdTagsEnabled = kingpin.Flag("statsd.dogstatsd-tags-enabled", "Parse DogStatsd style tags").Default("true").Bool() + influxdbTagsEnabled = kingpin.Flag("statsd.influxdb-tags-enabled", "Parse InfluxDB style tags").Default("true").Bool() + libratoTagsEnabled = kingpin.Flag("statsd.librato-tags-enabled", "Parse Librato style tags").Default("true").Bool() + signalFXTagsEnabled = kingpin.Flag("statsd.signalfx-tags-enabled", "Parse SignalFX style tags").Default("true").Bool() ) promlogConfig := &promlog.Config{} @@ -277,6 +282,12 @@ func main() { kingpin.Parse() logger := promlog.New(promlogConfig) + // Set line parsing options + line.DogstatsdTagsEnabled = *dogstatsdTagsEnabled + line.InfluxdbTagsEnabled = *influxdbTagsEnabled + line.LibratoTagsEnabled = *libratoTagsEnabled + line.SignalFXTagsEnabled = *signalFXTagsEnabled + cacheOption := mapper.WithCacheType(*cacheType) if *statsdListenUDP == "" && *statsdListenTCP == "" && *statsdListenUnixgram == "" { diff --git a/pkg/line/line.go b/pkg/line/line.go index de299be..50f93fd 100644 --- a/pkg/line/line.go +++ b/pkg/line/line.go @@ -27,6 +27,14 @@ import ( "github.com/prometheus/statsd_exporter/pkg/mapper" ) +// These globals can be used to control parsing behavior +var ( + DogstatsdTagsEnabled = true + InfluxdbTagsEnabled = true + LibratoTagsEnabled = true + SignalFXTagsEnabled = true +) + func buildEvent(statType, metric string, value float64, relative bool, labels map[string]string) (event.Event, error) { switch statType { case "c": @@ -115,40 +123,44 @@ func trimLeftHash(s string) string { } func ParseDogStatsDTags(component string, labels map[string]string, tagErrors prometheus.Counter, logger log.Logger) { - lastTagEndIndex := 0 - for i, c := range component { - if c == ',' { - tag := component[lastTagEndIndex:i] - lastTagEndIndex = i + 1 + if DogstatsdTagsEnabled { + lastTagEndIndex := 0 + for i, c := range component { + if c == ',' { + tag := component[lastTagEndIndex:i] + lastTagEndIndex = i + 1 + parseTag(component, trimLeftHash(tag), ':', labels, tagErrors, logger) + } + } + + // If we're not off the end of the string, add the last tag + if lastTagEndIndex < len(component) { + tag := component[lastTagEndIndex:] parseTag(component, trimLeftHash(tag), ':', labels, tagErrors, logger) } } - - // If we're not off the end of the string, add the last tag - if lastTagEndIndex < len(component) { - tag := component[lastTagEndIndex:] - parseTag(component, trimLeftHash(tag), ':', labels, tagErrors, logger) - } } func parseNameAndTags(name string, labels map[string]string, tagErrors prometheus.Counter, logger log.Logger) string { - // check for SignalFx tags first - // `[` delimits start of tags by SignalFx - // `]` delimits end of tags by SignalFx - // https://docs.signalfx.com/en/latest/integrations/agent/monitors/collectd-statsd.html - startIdx := strings.IndexRune(name, '[') - endIdx := strings.IndexRune(name, ']') + if SignalFXTagsEnabled { + // check for SignalFx tags first + // `[` delimits start of tags by SignalFx + // `]` delimits end of tags by SignalFx + // https://docs.signalfx.com/en/latest/integrations/agent/monitors/collectd-statsd.html + startIdx := strings.IndexRune(name, '[') + endIdx := strings.IndexRune(name, ']') - switch { - case startIdx != -1 && endIdx != -1: - // good signalfx tags - parseNameTags(name[startIdx+1:endIdx], labels, tagErrors, logger) - return name[:startIdx] + name[endIdx+1:] - case (startIdx != -1) != (endIdx != -1): - // only one bracket, return unparsed - level.Debug(logger).Log("msg", "invalid SignalFx tags, not parsing", "metric", name) - tagErrors.Inc() - return name + switch { + case startIdx != -1 && endIdx != -1: + // good signalfx tags + parseNameTags(name[startIdx+1:endIdx], labels, tagErrors, logger) + return name[:startIdx] + name[endIdx+1:] + case (startIdx != -1) != (endIdx != -1): + // only one bracket, return unparsed + level.Debug(logger).Log("msg", "invalid SignalFx tags, not parsing", "metric", name) + tagErrors.Inc() + return name + } } for i, c := range name { @@ -156,7 +168,7 @@ func parseNameAndTags(name string, labels map[string]string, tagErrors prometheu // https://www.librato.com/docs/kb/collect/collection_agents/stastd/#stat-level-tags // `,` delimits start of tags by InfluxDB // https://www.influxdata.com/blog/getting-started-with-sending-statsd-metrics-to-telegraf-influxdb/#introducing-influx-statsd - if c == '#' || c == ',' { + if (c == '#' && LibratoTagsEnabled) || (c == ',' && InfluxdbTagsEnabled) { parseNameTags(name[i+1:], labels, tagErrors, logger) return name[:i] } diff --git a/pkg/line/line_test.go b/pkg/line/line_test.go new file mode 100644 index 0000000..0bb0c42 --- /dev/null +++ b/pkg/line/line_test.go @@ -0,0 +1,749 @@ +// Copyright 2020 The Prometheus Authors +// 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. + +package line + +import ( + "reflect" + "testing" + + "github.com/go-kit/kit/log" + "github.com/prometheus/client_golang/prometheus" + + "github.com/prometheus/statsd_exporter/pkg/event" +) + +var ( + nopSamplesReceived = prometheus.NewCounter( + prometheus.CounterOpts{ + Name: "statsd_exporter_samples_total", + Help: "The total number of StatsD samples received.", + }, + ) + nopSampleErrors = prometheus.NewCounterVec( + prometheus.CounterOpts{ + Name: "statsd_exporter_sample_errors_total", + Help: "The total number of errors parsing StatsD samples.", + }, + []string{"reason"}, + ) + nopTagsReceived = prometheus.NewCounter( + prometheus.CounterOpts{ + Name: "statsd_exporter_tags_total", + Help: "The total number of DogStatsD tags processed.", + }, + ) + nopTagErrors = prometheus.NewCounter( + prometheus.CounterOpts{ + Name: "statsd_exporter_tag_errors_total", + Help: "The number of errors parsing DogStatsD tags.", + }, + ) + nopLogger = log.NewNopLogger() +) + +func TestLineToEvents(t *testing.T) { + type testCase struct { + in string + out event.Events + } + + testCases := map[string]testCase{ + "empty": {}, + "simple counter": { + in: "foo:2|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 2, + CLabels: map[string]string{}, + }, + }, + }, + "simple gauge": { + in: "foo:3|g", + out: event.Events{ + &event.GaugeEvent{ + GMetricName: "foo", + GValue: 3, + GLabels: map[string]string{}, + }, + }, + }, + "gauge with sampling": { + in: "foo:3|g|@0.2", + out: event.Events{ + &event.GaugeEvent{ + GMetricName: "foo", + GValue: 3, + GLabels: map[string]string{}, + }, + }, + }, + "gauge decrement": { + in: "foo:-10|g", + out: event.Events{ + &event.GaugeEvent{ + GMetricName: "foo", + GValue: -10, + GRelative: true, + GLabels: map[string]string{}, + }, + }, + }, + "simple timer": { + in: "foo:200|ms", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.2, + OLabels: map[string]string{}, + }, + }, + }, + "simple histogram": { + in: "foo:200|h", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 200, + OLabels: map[string]string{}, + }, + }, + }, + "simple distribution": { + in: "foo:200|d", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 200, + OLabels: map[string]string{}, + }, + }, + }, + "distribution with sampling": { + in: "foo:0.01|d|@0.2|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "librato tag extension": { + in: "foo#tag1=bar,tag2=baz:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "librato tag extension with tag keys unsupported by prometheus": { + in: "foo#09digits=0,tag.with.dots=1:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"_09digits": "0", "tag_with_dots": "1"}, + }, + }, + }, + "influxdb tag extension": { + in: "foo,tag1=bar,tag2=baz:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "SignalFx tag extension": { + in: "foo.[tag1=bar,tag2=baz]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "SignalFx tag extension, tags at end of name": { + in: "foo.test[tag1=bar,tag2=baz]:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "SignalFx tag extension, tags at beginning of name": { + in: "[tag1=bar,tag2=baz]foo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "SignalFx tag extension, no tags": { + in: "foo.[]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, non-kv tags": { + in: "foo.[tag1,tag2]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, missing closing bracket": { + in: "[tag1=bar,tag2=bazfoo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "[tag1=bar,tag2=bazfoo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, missing opening bracket": { + in: "tag1=bar,tag2=baz]foo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "tag1=bar,tag2=baz]foo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "influxdb tag extension with tag keys unsupported by prometheus": { + in: "foo,09digits=0,tag.with.dots=1:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"_09digits": "0", "tag_with_dots": "1"}, + }, + }, + }, + "datadog tag extension": { + in: "foo:100|c|#tag1:bar,tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "datadog tag extension with # in all keys (as sent by datadog php client)": { + in: "foo:100|c|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "datadog tag extension with tag keys unsupported by prometheus": { + in: "foo:100|c|#09digits:0,tag.with.dots:1", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"_09digits": "0", "tag_with_dots": "1"}, + }, + }, + }, + "datadog tag extension with valueless tags: ignored": { + in: "foo:100|c|#tag_without_a_value", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with valueless tags (edge case)": { + in: "foo:100|c|#tag_without_a_value,tag:value", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag": "value"}, + }, + }, + }, + "datadog tag extension with empty tags (edge case)": { + in: "foo:100|c|#tag:value,,", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{"tag": "value"}, + }, + }, + }, + "datadog tag extension with sampling": { + in: "foo:100|c|@0.1|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 1000, + CLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "librato/dogstatsd mixed tag styles without sampling": { + in: "foo#tag1=foo,tag3=bing:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "signalfx/dogstatsd mixed tag styles without sampling": { + in: "foo[tag1=foo,tag3=bing]:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "influxdb/dogstatsd mixed tag styles without sampling": { + in: "foo,tag1=foo,tag3=bing:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "mixed tag styles with sampling": { + in: "foo#tag1=foo,tag3=bing:100|c|@0.1|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "histogram with sampling": { + in: "foo:0.01|h|@0.2|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.01, + OLabels: map[string]string{"tag1": "bar", "tag2": "baz"}, + }, + }, + }, + "datadog tag extension with multiple colons": { + in: "foo:100|c|@0.1|#tag1:foo:bar", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 1000, + CLabels: map[string]string{"tag1": "foo:bar"}, + }, + }, + }, + "datadog tag extension with invalid utf8 tag values": { + in: "foo:100|c|@0.1|#tag:\xc3\x28invalid", + }, + "datadog tag extension with both valid and invalid utf8 tag values": { + in: "foo:100|c|@0.1|#tag1:valid,tag2:\xc3\x28invalid", + }, + "timings with sampling factor": { + in: "foo.timing:0.5|ms|@0.1", + out: event.Events{ + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + &event.ObserverEvent{OMetricName: "foo.timing", OValue: 0.0005, OLabels: map[string]string{}}, + }, + }, + "bad line": { + in: "foo", + }, + "bad component": { + in: "foo:1", + }, + "bad value": { + in: "foo:1o|c", + }, + "illegal sampling factor": { + in: "foo:1|c|@bar", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 1, + CLabels: map[string]string{}, + }, + }, + }, + "zero sampling factor": { + in: "foo:2|c|@0", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 2, + CLabels: map[string]string{}, + }, + }, + }, + "illegal stat type": { + in: "foo:2|t", + }, + "empty metric name": { + in: ":100|ms", + }, + "empty component": { + in: "foo:1|c|", + }, + "invalid utf8": { + in: "invalid\xc3\x28utf8:1|c", + }, + "ms timer with conversion to seconds": { + in: "foo:200|ms", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 0.2, + OLabels: map[string]string{}, + }, + }, + }, + "histogram with no unit conversion": { + in: "foo:200|h", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 200, + OLabels: map[string]string{}, + }, + }, + }, + "distribution with no unit conversion": { + in: "foo:200|d", + out: event.Events{ + &event.ObserverEvent{ + OMetricName: "foo", + OValue: 200, + OLabels: map[string]string{}, + }, + }, + }, + } + + DogstatsdTagsEnabled = true + InfluxdbTagsEnabled = true + SignalFXTagsEnabled = true + LibratoTagsEnabled = true + + for name, testCase := range testCases { + t.Run(name, func(t *testing.T) { + events := LineToEvents(testCase.in, *nopSampleErrors, nopSamplesReceived, nopTagErrors, nopTagsReceived, nopLogger) + + for j, expected := range testCase.out { + if !reflect.DeepEqual(&expected, &events[j]) { + t.Fatalf("Expected %#v, got %#v in scenario '%s'", expected, events[j], name) + } + } + }) + } +} + +func TestDisableParsingLineToEvents(t *testing.T) { + type testCase struct { + in string + out event.Events + } + + testCases := map[string]testCase{ + "librato tag extension": { + in: "foo#tag1=bar,tag2=baz:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo#tag1=bar,tag2=baz", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "librato tag extension with tag keys unsupported by prometheus": { + in: "foo#09digits=0,tag.with.dots=1:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo#09digits=0,tag.with.dots=1", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "influxdb tag extension": { + in: "foo,tag1=bar,tag2=baz:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo,tag1=bar,tag2=baz", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension": { + in: "foo.[tag1=bar,tag2=baz]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.[tag1=bar,tag2=baz]test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, tags at end of name": { + in: "foo.test[tag1=bar,tag2=baz]:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.test[tag1=bar,tag2=baz]", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, tags at beginning of name": { + in: "[tag1=bar,tag2=baz]foo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "[tag1=bar,tag2=baz]foo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, no tags": { + in: "foo.[]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.[]test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, non-kv tags": { + in: "foo.[tag1,tag2]test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo.[tag1,tag2]test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, missing closing bracket": { + in: "[tag1=bar,tag2=bazfoo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "[tag1=bar,tag2=bazfoo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "SignalFx tag extension, missing opening bracket": { + in: "tag1=bar,tag2=baz]foo.test:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "tag1=bar,tag2=baz]foo.test", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "influxdb tag extension with tag keys unsupported by prometheus": { + in: "foo,09digits=0,tag.with.dots=1:100|c", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo,09digits=0,tag.with.dots=1", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension": { + in: "foo:100|c|#tag1:bar,tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with # in all keys (as sent by datadog php client)": { + in: "foo:100|c|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with tag keys unsupported by prometheus": { + in: "foo:100|c|#09digits:0,tag.with.dots:1", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with valueless tags: ignored": { + in: "foo:100|c|#tag_without_a_value", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with valueless tags (edge case)": { + in: "foo:100|c|#tag_without_a_value,tag:value", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with empty tags (edge case)": { + in: "foo:100|c|#tag:value,,", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 100, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with sampling": { + in: "foo:100|c|@0.1|#tag1:bar,#tag2:baz", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 1000, + CLabels: map[string]string{}, + }, + }, + }, + "librato/dogstatsd mixed tag styles without sampling": { + in: "foo#tag1=foo,tag3=bing:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "signalfx/dogstatsd mixed tag styles without sampling": { + in: "foo[tag1=foo,tag3=bing]:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "influxdb/dogstatsd mixed tag styles without sampling": { + in: "foo,tag1=foo,tag3=bing:100|c|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "mixed tag styles with sampling": { + in: "foo#tag1=foo,tag3=bing:100|c|@0.1|#tag1:bar,#tag2:baz", + out: event.Events{}, + }, + "datadog tag extension with multiple colons": { + in: "foo:100|c|@0.1|#tag1:foo:bar", + out: event.Events{ + &event.CounterEvent{ + CMetricName: "foo", + CValue: 1000, + CLabels: map[string]string{}, + }, + }, + }, + "datadog tag extension with invalid utf8 tag values": { + in: "foo:100|c|@0.1|#tag:\xc3\x28invalid", + }, + "datadog tag extension with both valid and invalid utf8 tag values": { + in: "foo:100|c|@0.1|#tag1:valid,tag2:\xc3\x28invalid", + }, + } + + DogstatsdTagsEnabled = false + InfluxdbTagsEnabled = false + SignalFXTagsEnabled = false + LibratoTagsEnabled = false + + for name, testCase := range testCases { + t.Run(name, func(t *testing.T) { + events := LineToEvents(testCase.in, *nopSampleErrors, nopSamplesReceived, nopTagErrors, nopTagsReceived, nopLogger) + + for j, expected := range testCase.out { + if !reflect.DeepEqual(&expected, &events[j]) { + t.Fatalf("Expected %#v, got %#v in scenario '%s'", expected, events[j], name) + } + } + }) + } +}