func TestExec(t *testing.T) { parser, _ := parsers.NewJSONParser("exec", []string{}, nil) e := &Exec{ runner: newRunnerMock([]byte(validJson), nil), Commands: []string{"testcommand arg1"}, parser: parser, } var acc testutil.Accumulator err := e.Gather(&acc) require.NoError(t, err) assert.Equal(t, acc.NFields(), 8, "non-numeric measurements should be ignored") fields := map[string]interface{}{ "num_processes": float64(82), "cpu_used": float64(8234), "cpu_free": float64(32), "percent": float64(0.81), "users_0": float64(0), "users_1": float64(1), "users_2": float64(2), "users_3": float64(3), } acc.AssertContainsFields(t, "exec", fields) }
func TestExecMalformed(t *testing.T) { parser, _ := parsers.NewJSONParser("exec", []string{}, nil) e := &Exec{ runner: newRunnerMock([]byte(malformedJson), nil), Commands: []string{"badcommand arg1"}, parser: parser, } var acc testutil.Accumulator err := e.Gather(&acc) require.Error(t, err) assert.Equal(t, acc.NFields(), 0, "No new points should have been added") }
func TestCommandError(t *testing.T) { parser, _ := parsers.NewJSONParser("exec", []string{}, nil) e := &Exec{ runner: newRunnerMock(nil, fmt.Errorf("exit status code 1")), Commands: []string{"badcommand"}, parser: parser, } var acc testutil.Accumulator err := e.Gather(&acc) require.Error(t, err) assert.Equal(t, acc.NFields(), 0, "No new points should have been added") }
// Test that the parser parses json format messages into metrics func TestRunParserAndGatherJSON(t *testing.T) { n, in := newTestMQTTConsumer() acc := testutil.Accumulator{} n.acc = &acc defer close(n.done) n.parser, _ = parsers.NewJSONParser("nats_json_test", []string{}, nil) go n.receiver() in <- mqttMsg(testMsgJSON) time.Sleep(time.Millisecond * 25) n.Gather(&acc) acc.AssertContainsFields(t, "nats_json_test", map[string]interface{}{ "a": float64(5), "b_c": float64(6), }) }
// Test that the parser parses kafka messages into points func TestRunParserAndGatherJSON(t *testing.T) { k, in := NewTestKafka() defer close(k.done) k.parser, _ = parsers.NewJSONParser("kafka_json_test", []string{}, nil) go k.receiver() in <- saramaMsg(testMsgJSON) time.Sleep(time.Millisecond) acc := testutil.Accumulator{} k.Gather(&acc) assert.Equal(t, len(acc.Metrics), 1) acc.AssertContainsFields(t, "kafka_json_test", map[string]interface{}{ "a": float64(5), "b_c": float64(6), }) }
// Test that the parser parses json format messages into metrics func TestRunParserAndGatherJSON(t *testing.T) { n, in := newTestNatsConsumer() defer close(n.done) n.parser, _ = parsers.NewJSONParser("nats_json_test", []string{}, nil) go n.receiver() in <- natsMsg(testMsgJSON) time.Sleep(time.Millisecond) acc := testutil.Accumulator{} n.Gather(&acc) if a := len(acc.Metrics); a != 1 { t.Errorf("got %v, expected %v", a, 1) } acc.AssertContainsFields(t, "nats_json_test", map[string]interface{}{ "a": float64(5), "b_c": float64(6), }) }
// Gathers data from a particular server // Parameters: // acc : The telegraf Accumulator to use // serverURL: endpoint to send request to // service : the service being queried // // Returns: // error: Any error that may have occurred func (h *HttpJson) gatherServer( acc telegraf.Accumulator, serverURL string, ) error { resp, responseTime, err := h.sendRequest(serverURL) if err != nil { return err } var msrmnt_name string if h.Name == "" { msrmnt_name = "httpjson" } else { msrmnt_name = "httpjson_" + h.Name } tags := map[string]string{ "server": serverURL, } parser, err := parsers.NewJSONParser(msrmnt_name, h.TagKeys, tags) if err != nil { return err } metrics, err := parser.Parse([]byte(resp)) if err != nil { return err } for _, metric := range metrics { fields := make(map[string]interface{}) for k, v := range metric.Fields() { fields[k] = v } fields["response_time"] = responseTime acc.AddFields(metric.Name(), fields, metric.Tags()) } return nil }
func TestRunParserJSONMsg(t *testing.T) { var testmsg = []byte("{\"a\": 5, \"b\": {\"c\": 6}}\n") listener, in := newTestTcpListener() acc := testutil.Accumulator{} listener.acc = &acc defer close(listener.done) listener.parser, _ = parsers.NewJSONParser("udp_json_test", []string{}, nil) listener.wg.Add(1) go listener.tcpParser() in <- testmsg time.Sleep(time.Millisecond * 25) listener.Gather(&acc) acc.AssertContainsFields(t, "udp_json_test", map[string]interface{}{ "a": float64(5), "b_c": float64(6), }) }
func TestConfig_LoadDirectory(t *testing.T) { c := NewConfig() err := c.LoadConfig("./testdata/single_plugin.toml") if err != nil { t.Error(err) } err = c.LoadDirectory("./testdata/subconfig") if err != nil { t.Error(err) } memcached := inputs.Inputs["memcached"]().(*memcached.Memcached) memcached.Servers = []string{"localhost"} filter := models.Filter{ NameDrop: []string{"metricname2"}, NamePass: []string{"metricname1"}, FieldDrop: []string{"other", "stuff"}, FieldPass: []string{"some", "strings"}, TagDrop: []models.TagFilter{ models.TagFilter{ Name: "badtag", Filter: []string{"othertag"}, }, }, TagPass: []models.TagFilter{ models.TagFilter{ Name: "goodtag", Filter: []string{"mytag"}, }, }, IsActive: true, } assert.NoError(t, filter.CompileFilter()) mConfig := &models.InputConfig{ Name: "memcached", Filter: filter, Interval: 5 * time.Second, } mConfig.Tags = make(map[string]string) assert.Equal(t, memcached, c.Inputs[0].Input, "Testdata did not produce a correct memcached struct.") assert.Equal(t, mConfig, c.Inputs[0].Config, "Testdata did not produce correct memcached metadata.") ex := inputs.Inputs["exec"]().(*exec.Exec) p, err := parsers.NewJSONParser("exec", nil, nil) assert.NoError(t, err) ex.SetParser(p) ex.Command = "/usr/bin/myothercollector --foo=bar" eConfig := &models.InputConfig{ Name: "exec", MeasurementSuffix: "_myothercollector", } eConfig.Tags = make(map[string]string) assert.Equal(t, ex, c.Inputs[1].Input, "Merged Testdata did not produce a correct exec struct.") assert.Equal(t, eConfig, c.Inputs[1].Config, "Merged Testdata did not produce correct exec metadata.") memcached.Servers = []string{"192.168.1.1"} assert.Equal(t, memcached, c.Inputs[2].Input, "Testdata did not produce a correct memcached struct.") assert.Equal(t, mConfig, c.Inputs[2].Config, "Testdata did not produce correct memcached metadata.") pstat := inputs.Inputs["procstat"]().(*procstat.Procstat) pstat.PidFile = "/var/run/grafana-server.pid" pConfig := &models.InputConfig{Name: "procstat"} pConfig.Tags = make(map[string]string) assert.Equal(t, pstat, c.Inputs[3].Input, "Merged Testdata did not produce a correct procstat struct.") assert.Equal(t, pConfig, c.Inputs[3].Config, "Merged Testdata did not produce correct procstat metadata.") }