package influx_test import ( "bytes" "errors" "fmt" "io" "testing" "github.com/influxdata/telegraf/plugins/parsers/influx" "github.com/stretchr/testify/require" ) type TestingHandler struct { results []Result } func (h *TestingHandler) SetMeasurement(name []byte) error { n := make([]byte, len(name)) copy(n, name) mname := Result{ Name: Measurement, Value: n, } h.results = append(h.results, mname) return nil } func (h *TestingHandler) AddTag(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) tagkey := Result{ Name: TagKey, Value: k, } tagvalue := Result{ Name: TagValue, Value: v, } h.results = append(h.results, tagkey, tagvalue) return nil } func (h *TestingHandler) AddInt(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) fieldkey := Result{ Name: FieldKey, Value: k, } fieldvalue := Result{ Name: FieldInt, Value: v, } h.results = append(h.results, fieldkey, fieldvalue) return nil } func (h *TestingHandler) AddUint(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) fieldkey := Result{ Name: FieldKey, Value: key, } fieldvalue := Result{ Name: FieldUint, Value: value, } h.results = append(h.results, fieldkey, fieldvalue) return nil } func (h *TestingHandler) AddFloat(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) fieldkey := Result{ Name: FieldKey, Value: k, } fieldvalue := Result{ Name: FieldFloat, Value: v, } h.results = append(h.results, fieldkey, fieldvalue) return nil } func (h *TestingHandler) AddString(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) fieldkey := Result{ Name: FieldKey, Value: k, } fieldvalue := Result{ Name: FieldString, Value: v, } h.results = append(h.results, fieldkey, fieldvalue) return nil } func (h *TestingHandler) AddBool(key []byte, value []byte) error { k := make([]byte, len(key)) copy(k, key) v := make([]byte, len(value)) copy(v, value) fieldkey := Result{ Name: FieldKey, Value: k, } fieldvalue := Result{ Name: FieldBool, Value: v, } h.results = append(h.results, fieldkey, fieldvalue) return nil } func (h *TestingHandler) SetTimestamp(tm []byte) error { t := make([]byte, len(tm)) copy(t, tm) timestamp := Result{ Name: Timestamp, Value: t, } h.results = append(h.results, timestamp) return nil } func (h *TestingHandler) Result(err error) { var res Result if err == nil { res = Result{ Name: Success, } } else { res = Result{ Name: Error, err: err, } } h.results = append(h.results, res) } func (h *TestingHandler) Results() []Result { return h.results } type BenchmarkingHandler struct { } func (h *BenchmarkingHandler) SetMeasurement(name []byte) error { return nil } func (h *BenchmarkingHandler) AddTag(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) AddInt(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) AddUint(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) AddFloat(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) AddString(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) AddBool(key []byte, value []byte) error { return nil } func (h *BenchmarkingHandler) SetTimestamp(tm []byte) error { return nil } type TokenType int const ( NoMatch TokenType = iota Measurement TagKey TagValue FieldKey FieldString FieldInt FieldUint FieldFloat FieldBool Timestamp EOL EOF Punc WhiteSpace Success Error ) func (t TokenType) String() string { switch t { case NoMatch: return "NoMatch" case Measurement: return "Measurement" case TagKey: return "TagKey" case TagValue: return "TagValue" case FieldKey: return "FieldKey" case FieldInt: return "FieldInt" case FieldUint: return "FieldUint" case FieldFloat: return "FieldFloat" case FieldString: return "FieldString" case FieldBool: return "FieldBool" case Timestamp: return "Timestamp" case EOL: return "EOL" case EOF: return "EOF" case Punc: return "Punc" case WhiteSpace: return "WhiteSpace" case Success: return "Success" case Error: return "Error" default: panic("Unknown TokenType") } } type Token struct { Name TokenType Value []byte } func (t Token) String() string { return fmt.Sprintf("(%s %q)", t.Name, t.Value) } type Result struct { Name TokenType Value []byte err error } func (r Result) String() string { return fmt.Sprintf("(%s, %q, %v)", r.Name, r.Value, r.err) } var tests = []struct { name string input []byte results []Result err error }{ { name: "empty string", input: []byte(""), results: nil, }, { name: "minimal", input: []byte("cpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "newline", input: []byte("cpu value=42\n"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "minimal with timestamp", input: []byte("cpu value=42 1516241192000000000"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Timestamp, Value: []byte("1516241192000000000"), }, { Name: Success, }, }, }, { name: "measurement escape non-special", input: []byte(`c\pu value=42`), results: []Result{ { Name: Measurement, Value: []byte(`c\pu`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "measurement escaped trailing backslash", input: []byte(`cpu\\ value=42`), results: []Result{ { Name: Measurement, Value: []byte(`cpu\\`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "single char measurement", input: []byte("c value=42"), results: []Result{ { Name: Measurement, Value: []byte("c"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "escape backslash in measurement", input: []byte(`cp\\u value=42`), results: []Result{ { Name: Measurement, Value: []byte(`cp\\u`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "measurement escape space", input: []byte(`cpu\ abc value=42`), results: []Result{ { Name: Measurement, Value: []byte(`cpu\ abc`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "scientific float", input: []byte("cpu value=42e0"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42e0"), }, { Name: Success, }, }, }, { name: "scientific float negative mantissa", input: []byte("cpu value=-42e0"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("-42e0"), }, { Name: Success, }, }, }, { name: "scientific float negative exponent", input: []byte("cpu value=42e-1"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42e-1"), }, { Name: Success, }, }, }, { name: "scientific float big e", input: []byte("cpu value=42E0"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42E0"), }, { Name: Success, }, }, }, { name: "scientific float missing exponent", input: []byte("cpu value=42E"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "float with decimal", input: []byte("cpu value=42.2"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42.2"), }, { Name: Success, }, }, }, { name: "negative float", input: []byte("cpu value=-42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("-42"), }, { Name: Success, }, }, }, { name: "float without integer digits", input: []byte("cpu value=.42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte(".42"), }, { Name: Success, }, }, }, { name: "float without integer digits negative", input: []byte("cpu value=-.42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("-.42"), }, { Name: Success, }, }, }, { name: "float with multiple leading 0", input: []byte("cpu value=00.42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("00.42"), }, { Name: Success, }, }, }, { name: "invalid float with only dot", input: []byte("cpu value=."), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "multiple fields", input: []byte("cpu x=42,y=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("x"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: FieldKey, Value: []byte("y"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "integer field", input: []byte("cpu value=42i"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("42i"), }, { Name: Success, }, }, }, { name: "negative integer field", input: []byte("cpu value=-42i"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("-42i"), }, { Name: Success, }, }, }, { name: "zero integer field", input: []byte("cpu value=0i"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("0i"), }, { Name: Success, }, }, }, { name: "negative zero integer field", input: []byte("cpu value=-0i"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("-0i"), }, { Name: Success, }, }, }, { name: "integer field overflow okay", input: []byte("cpu value=9223372036854775808i"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("9223372036854775808i"), }, { Name: Success, }, }, }, { name: "invalid field", input: []byte("cpu value=howdy"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "string field", input: []byte("cpu value=\"42\""), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldString, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "newline in string field", input: []byte("cpu value=\"4\n2\""), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldString, Value: []byte("4\n2"), }, { Name: Success, }, }, }, { name: "cr in string field", input: []byte("cpu value=\"4\r2\""), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldString, Value: []byte("4\r2"), }, { Name: Success, }, }, }, { name: "bool field", input: []byte("cpu value=true"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldBool, Value: []byte("true"), }, { Name: Success, }, }, }, { name: "tag", input: []byte("cpu,host=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("host"), }, { Name: TagValue, Value: []byte("localhost"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag key escape space", input: []byte("cpu,h\\ ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte(`h\ ost`), }, { Name: TagValue, Value: []byte("localhost"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag key escape comma", input: []byte("cpu,h\\,ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte(`h\,ost`), }, { Name: TagValue, Value: []byte("localhost"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag key escape equal", input: []byte("cpu,h\\=ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte(`h\=ost`), }, { Name: TagValue, Value: []byte("localhost"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "multiple tags", input: []byte("cpu,host=localhost,cpu=cpu0 value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("host"), }, { Name: TagValue, Value: []byte("localhost"), }, { Name: TagKey, Value: []byte("cpu"), }, { Name: TagValue, Value: []byte("cpu0"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag value escape space", input: []byte(`cpu,host=two\ words value=42`), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("host"), }, { Name: TagValue, Value: []byte(`two\ words`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag value double escape space", input: []byte(`cpu,host=two\\ words value=42`), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("host"), }, { Name: TagValue, Value: []byte(`two\\ words`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag value triple escape space", input: []byte(`cpu,host=two\\\ words value=42`), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("host"), }, { Name: TagValue, Value: []byte(`two\\\ words`), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "tag invalid missing separator", input: []byte("cpu,xyzzy value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "tag invalid missing value", input: []byte("cpu,xyzzy= value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "tag invalid unescaped space", input: []byte("cpu,h ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "tag invalid unescaped comma", input: []byte("cpu,h,ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "tag invalid unescaped equals", input: []byte("cpu,h=ost=localhost value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "timestamp negative", input: []byte("cpu value=42 -1"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Timestamp, Value: []byte("-1"), }, { Name: Success, }, }, }, { name: "timestamp zero", input: []byte("cpu value=42 0"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Timestamp, Value: []byte("0"), }, { Name: Success, }, }, }, { name: "multiline", input: []byte("cpu value=42\n\n\n\ncpu value=43"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("43"), }, { Name: Success, }, }, }, { name: "error recovery", input: []byte("cpu value=howdy,value2=42\ncpu\ncpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, { Name: Error, err: influx.ErrTagParse, }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "line whitespace", input: []byte(" cpu value=42 1516241192000000000 \n\n cpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Timestamp, Value: []byte("1516241192000000000"), }, { Name: Success, }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "leading newline", input: []byte("\ncpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "invalid missing field value", input: []byte("cpu value="), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "invalid eof field key", input: []byte("cpu value"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "invalid measurement only", input: []byte("cpu"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "invalid measurement char", input: []byte(","), results: []Result{ { Name: Error, err: influx.ErrNameParse, }, }, }, { name: "invalid missing tag", input: []byte("cpu, value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrTagParse, }, }, }, { name: "invalid missing field", input: []byte("cpu,x=y "), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("x"), }, { Name: TagValue, Value: []byte("y"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "invalid too many fields", input: []byte("cpu value=42 value=43"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Error, err: influx.ErrTimestampParse, }, }, }, { name: "invalid timestamp too long", input: []byte("cpu value=42 12345678901234567890"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Error, err: influx.ErrTimestampParse, }, }, }, { name: "invalid open string field", input: []byte(`cpu value="42 12345678901234567890`), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "invalid field value", input: []byte("cpu value=howdy"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: influx.ErrFieldParse, }, }, }, { name: "invalid quoted timestamp", input: []byte("cpu value=42 \"12345678901234567890\""), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Error, err: influx.ErrTimestampParse, }, }, }, { name: "comment only", input: []byte("# blah blah"), results: []Result(nil), }, { name: "commented line", input: []byte("# blah blah\ncpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "middle comment", input: []byte("cpu value=42\n# blah blah\ncpu value=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "end with comment", input: []byte("cpu value=42\n# blah blah"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "end with comment and whitespace", input: []byte("cpu value=42\n# blah blah\n\n "), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, { name: "unicode", input: []byte("cpu ☺=42"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("☺"), }, { Name: FieldFloat, Value: []byte("42"), }, { Name: Success, }, }, }, } func TestMachine(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { handler := &TestingHandler{} fsm := influx.NewMachine(handler) fsm.SetData(tt.input) for i := 0; i < 20; i++ { err := fsm.Next() if err != nil && err == influx.EOF { break } handler.Result(err) } results := handler.Results() require.Equal(t, tt.results, results) }) } } var positionTests = []struct { name string input []byte lineno int column int }{ { name: "empty string", input: []byte(""), lineno: 1, column: 1, }, { name: "minimal", input: []byte("cpu value=42"), lineno: 1, column: 13, }, { name: "one newline", input: []byte("cpu value=42\ncpu value=42"), lineno: 2, column: 13, }, { name: "several newlines", input: []byte("cpu value=42\n\n\n"), lineno: 4, column: 1, }, { name: "error on second line", input: []byte("cpu value=42\ncpu value=invalid"), lineno: 2, column: 11, }, { name: "error after comment line", input: []byte("cpu value=42\n# comment\ncpu value=invalid"), lineno: 3, column: 11, }, { name: "dos line endings", input: []byte("cpu value=42\r\ncpu value=invalid"), lineno: 2, column: 11, }, { name: "mac line endings not supported", input: []byte("cpu value=42\rcpu value=invalid"), lineno: 1, column: 14, }, } func TestMachinePosition(t *testing.T) { for _, tt := range positionTests { t.Run(tt.name, func(t *testing.T) { handler := &TestingHandler{} fsm := influx.NewMachine(handler) fsm.SetData(tt.input) // Parse until an error or eof for i := 0; i < 20; i++ { err := fsm.Next() if err != nil { break } } require.Equal(t, tt.lineno, fsm.LineNumber(), "lineno") require.Equal(t, tt.column, fsm.Column(), "column") }) } } func BenchmarkMachine(b *testing.B) { for _, tt := range tests { b.Run(tt.name, func(b *testing.B) { handler := &BenchmarkingHandler{} fsm := influx.NewMachine(handler) for n := 0; n < b.N; n++ { fsm.SetData(tt.input) for { err := fsm.Next() if err != nil { break } } } }) } } func TestMachineProcstat(t *testing.T) { input := []byte("procstat,exe=bash,process_name=bash voluntary_context_switches=42i,memory_rss=5103616i,rlimit_memory_data_hard=2147483647i,cpu_time_user=0.02,rlimit_file_locks_soft=2147483647i,pid=29417i,cpu_time_nice=0,rlimit_memory_locked_soft=65536i,read_count=259i,rlimit_memory_vms_hard=2147483647i,memory_swap=0i,rlimit_num_fds_soft=1024i,rlimit_nice_priority_hard=0i,cpu_time_soft_irq=0,cpu_time=0i,rlimit_memory_locked_hard=65536i,realtime_priority=0i,signals_pending=0i,nice_priority=20i,cpu_time_idle=0,memory_stack=139264i,memory_locked=0i,rlimit_memory_stack_soft=8388608i,cpu_time_iowait=0,cpu_time_guest=0,cpu_time_guest_nice=0,rlimit_memory_data_soft=2147483647i,read_bytes=0i,rlimit_cpu_time_soft=2147483647i,involuntary_context_switches=2i,write_bytes=106496i,cpu_time_system=0,cpu_time_irq=0,cpu_usage=0,memory_vms=21659648i,memory_data=1576960i,rlimit_memory_stack_hard=2147483647i,num_threads=1i,rlimit_memory_rss_soft=2147483647i,rlimit_realtime_priority_soft=0i,num_fds=4i,write_count=35i,rlimit_signals_pending_soft=78994i,cpu_time_steal=0,rlimit_num_fds_hard=4096i,rlimit_file_locks_hard=2147483647i,rlimit_cpu_time_hard=2147483647i,rlimit_signals_pending_hard=78994i,rlimit_nice_priority_soft=0i,rlimit_memory_rss_hard=2147483647i,rlimit_memory_vms_soft=2147483647i,rlimit_realtime_priority_hard=0i 1517620624000000000") handler := &TestingHandler{} fsm := influx.NewMachine(handler) fsm.SetData(input) for { err := fsm.Next() if err != nil { break } } } func BenchmarkMachineProcstat(b *testing.B) { input := []byte("procstat,exe=bash,process_name=bash voluntary_context_switches=42i,memory_rss=5103616i,rlimit_memory_data_hard=2147483647i,cpu_time_user=0.02,rlimit_file_locks_soft=2147483647i,pid=29417i,cpu_time_nice=0,rlimit_memory_locked_soft=65536i,read_count=259i,rlimit_memory_vms_hard=2147483647i,memory_swap=0i,rlimit_num_fds_soft=1024i,rlimit_nice_priority_hard=0i,cpu_time_soft_irq=0,cpu_time=0i,rlimit_memory_locked_hard=65536i,realtime_priority=0i,signals_pending=0i,nice_priority=20i,cpu_time_idle=0,memory_stack=139264i,memory_locked=0i,rlimit_memory_stack_soft=8388608i,cpu_time_iowait=0,cpu_time_guest=0,cpu_time_guest_nice=0,rlimit_memory_data_soft=2147483647i,read_bytes=0i,rlimit_cpu_time_soft=2147483647i,involuntary_context_switches=2i,write_bytes=106496i,cpu_time_system=0,cpu_time_irq=0,cpu_usage=0,memory_vms=21659648i,memory_data=1576960i,rlimit_memory_stack_hard=2147483647i,num_threads=1i,rlimit_memory_rss_soft=2147483647i,rlimit_realtime_priority_soft=0i,num_fds=4i,write_count=35i,rlimit_signals_pending_soft=78994i,cpu_time_steal=0,rlimit_num_fds_hard=4096i,rlimit_file_locks_hard=2147483647i,rlimit_cpu_time_hard=2147483647i,rlimit_signals_pending_hard=78994i,rlimit_nice_priority_soft=0i,rlimit_memory_rss_hard=2147483647i,rlimit_memory_vms_soft=2147483647i,rlimit_realtime_priority_hard=0i 1517620624000000000") handler := &BenchmarkingHandler{} fsm := influx.NewMachine(handler) for n := 0; n < b.N; n++ { fsm.SetData(input) for { err := fsm.Next() if err != nil { break } } } } func TestSeriesMachine(t *testing.T) { var tests = []struct { name string input []byte results []Result err error }{ { name: "empty string", input: []byte(""), results: nil, }, { name: "no tags", input: []byte("cpu"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Success, }, }, }, { name: "tags", input: []byte("cpu,a=x,b=y"), results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: TagKey, Value: []byte("a"), }, { Name: TagValue, Value: []byte("x"), }, { Name: TagKey, Value: []byte("b"), }, { Name: TagValue, Value: []byte("y"), }, { Name: Success, }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { handler := &TestingHandler{} fsm := influx.NewSeriesMachine(handler) fsm.SetData(tt.input) for { err := fsm.Next() if err != nil { break } handler.Result(err) } results := handler.Results() require.Equal(t, tt.results, results) }) } } type MockHandler struct { SetMeasurementF func(name []byte) error AddTagF func(key []byte, value []byte) error AddIntF func(key []byte, value []byte) error AddUintF func(key []byte, value []byte) error AddFloatF func(key []byte, value []byte) error AddStringF func(key []byte, value []byte) error AddBoolF func(key []byte, value []byte) error SetTimestampF func(tm []byte) error TestingHandler } func (h *MockHandler) SetMeasurement(name []byte) error { h.TestingHandler.SetMeasurement(name) return h.SetMeasurementF(name) } func (h *MockHandler) AddTag(name, value []byte) error { return h.AddTagF(name, value) } func (h *MockHandler) AddInt(name, value []byte) error { err := h.AddIntF(name, value) if err != nil { return err } h.TestingHandler.AddInt(name, value) return nil } func (h *MockHandler) AddUint(name, value []byte) error { err := h.AddUintF(name, value) if err != nil { return err } h.TestingHandler.AddUint(name, value) return nil } func (h *MockHandler) AddFloat(name, value []byte) error { return h.AddFloatF(name, value) } func (h *MockHandler) AddString(name, value []byte) error { return h.AddStringF(name, value) } func (h *MockHandler) AddBool(name, value []byte) error { return h.AddBoolF(name, value) } func (h *MockHandler) SetTimestamp(tm []byte) error { return h.SetTimestampF(tm) } var errorRecoveryTests = []struct { name string input []byte handler *MockHandler results []Result }{ { name: "integer", input: []byte("cpu value=43i\ncpu value=42i"), handler: &MockHandler{ SetMeasurementF: func(name []byte) error { return nil }, AddIntF: func(name, value []byte) error { if string(value) != "42i" { return errors.New("handler error") } return nil }, }, results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: errors.New("handler error"), }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("42i"), }, { Name: Success, }, }, }, { name: "integer with timestamp", input: []byte("cpu value=43i 1516241192000000000\ncpu value=42i"), handler: &MockHandler{ SetMeasurementF: func(name []byte) error { return nil }, AddIntF: func(name, value []byte) error { if string(value) != "42i" { return errors.New("handler error") } return nil }, }, results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: errors.New("handler error"), }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldInt, Value: []byte("42i"), }, { Name: Success, }, }, }, { name: "unsigned", input: []byte("cpu value=43u\ncpu value=42u"), handler: &MockHandler{ SetMeasurementF: func(name []byte) error { return nil }, AddUintF: func(name, value []byte) error { if string(value) != "42u" { return errors.New("handler error") } return nil }, }, results: []Result{ { Name: Measurement, Value: []byte("cpu"), }, { Name: Error, err: errors.New("handler error"), }, { Name: Measurement, Value: []byte("cpu"), }, { Name: FieldKey, Value: []byte("value"), }, { Name: FieldUint, Value: []byte("42u"), }, { Name: Success, }, }, }, } func TestHandlerErrorRecovery(t *testing.T) { for _, tt := range errorRecoveryTests { t.Run(tt.name, func(t *testing.T) { fsm := influx.NewMachine(tt.handler) fsm.SetData(tt.input) for i := 0; i < 20; i++ { err := fsm.Next() if err != nil && err == influx.EOF { break } tt.handler.Result(err) } results := tt.handler.Results() require.Equal(t, tt.results, results) }) } } func TestStreamMachine(t *testing.T) { type testcase struct { name string input io.Reader results []Result err error } var tc []testcase for _, tt := range tests { tc = append(tc, testcase{ name: tt.name, input: bytes.NewBuffer([]byte(tt.input)), results: tt.results, err: tt.err, }) } for _, tt := range tc { t.Run(tt.name, func(t *testing.T) { handler := &TestingHandler{} fsm := influx.NewStreamMachine(tt.input, handler) // Parse only up to 20 metrics; to avoid any bugs where the parser // isn't terminated. for i := 0; i < 20; i++ { err := fsm.Next() if err != nil && err == influx.EOF { break } handler.Result(err) } results := handler.Results() require.Equal(t, tt.results, results) }) } } func TestStreamMachinePosition(t *testing.T) { type testcase struct { name string input io.Reader lineno int column int } var tc []testcase for _, tt := range positionTests { tc = append(tc, testcase{ name: tt.name, input: bytes.NewBuffer([]byte(tt.input)), lineno: tt.lineno, column: tt.column, }) } for _, tt := range tc { t.Run(tt.name, func(t *testing.T) { handler := &TestingHandler{} fsm := influx.NewStreamMachine(tt.input, handler) // Parse until an error or eof for i := 0; i < 20; i++ { err := fsm.Next() if err != nil { break } } require.Equal(t, tt.lineno, fsm.LineNumber(), "lineno") require.Equal(t, tt.column, fsm.Column(), "column") }) } }