Golang Accumulator.AssertContainsTaggedFields方法代碼示例

func TestSNMPGet2(t *testing.T) {
	get1 := Data{
		Name: "oid1",
		Oid:  "ifNumber",
	}
	h := Host{
		Address:   testutil.GetLocalHost() + ":31161",
		Community: "telegraf",
		Version:   2,
		Timeout:   2.0,
		Retries:   2,
		Collect:   []string{"oid1"},
	}
	s := Snmp{
		SnmptranslateFile: "./testdata/oids.txt",
		Host:              []Host{h},
		Get:               []Data{get1},
	}

	var acc testutil.Accumulator
	err := s.Gather(&acc)
	require.NoError(t, err)

	acc.AssertContainsTaggedFields(t,
		"ifNumber",
		map[string]interface{}{
			"ifNumber": int(4),
		},
		map[string]string{
			"instance": "0",
			"host":     testutil.GetLocalHost(),
		},
	)
}

func TestGatherGlob(t *testing.T) {
	dir := getTestdataDir()
	fs := NewFileStat()
	fs.Md5 = true
	fs.Files = []string{
		dir + "*.log",
	}

	acc := testutil.Accumulator{}
	fs.Gather(&acc)

	tags1 := map[string]string{
		"file": dir + "log1.log",
	}
	fields1 := map[string]interface{}{
		"size_bytes": int64(0),
		"exists":     int64(1),
		"md5_sum":    "d41d8cd98f00b204e9800998ecf8427e",
	}
	acc.AssertContainsTaggedFields(t, "filestat", fields1, tags1)

	tags2 := map[string]string{
		"file": dir + "log2.log",
	}
	fields2 := map[string]interface{}{
		"size_bytes": int64(0),
		"exists":     int64(1),
		"md5_sum":    "d41d8cd98f00b204e9800998ecf8427e",
	}
	acc.AssertContainsTaggedFields(t, "filestat", fields2, tags2)
}

// Test that test_a.log line gets parsed even though we don't have the correct
// pattern available for test_b.log
func TestGrokParseLogFilesOneBad(t *testing.T) {
	thisdir := getCurrentDir()
	p := &grok.Parser{
		Patterns:           []string{"%{TEST_LOG_A}", "%{TEST_LOG_BAD}"},
		CustomPatternFiles: []string{thisdir + "grok/testdata/test-patterns"},
	}
	assert.NoError(t, p.Compile())

	logparser := &LogParserPlugin{
		FromBeginning: true,
		Files:         []string{thisdir + "grok/testdata/test_a.log"},
		GrokParser:    p,
	}

	acc := testutil.Accumulator{}
	acc.SetDebug(true)
	assert.NoError(t, logparser.Start(&acc))

	time.Sleep(time.Millisecond * 500)
	logparser.Stop()

	acc.AssertContainsTaggedFields(t, "logparser_grok",
		map[string]interface{}{
			"clientip":      "192.168.1.1",
			"myfloat":       float64(1.25),
			"response_time": int64(5432),
			"myint":         int64(101),
		},
		map[string]string{"response_code": "200"})
}

// Test that the proper values are ignored or collected for class=Cassandra
func TestHttpJsonCassandraMultiValue(t *testing.T) {
	cassandra := genJolokiaClientStub(validCassandraMultiValueJSON, 200, Servers, []string{ReadLatencyMetric})

	var acc testutil.Accumulator
	err := cassandra.Gather(&acc)

	assert.Nil(t, err)
	assert.Equal(t, 1, len(acc.Metrics))

	fields := map[string]interface{}{
		"ReadLatency_999thPercentile": 20.0,
		"ReadLatency_99thPercentile":  10.0,
		"ReadLatency_Count":           400.0,
		"ReadLatency_DurationUnit":    "microseconds",
		"ReadLatency_Max":             30.0,
		"ReadLatency_MeanRate":        3.0,
		"ReadLatency_Min":             1.0,
		"ReadLatency_RateUnit":        "events/second",
	}

	tags := map[string]string{
		"cassandra_host": "10.10.10.10",
		"mname":          "ReadLatency",
		"keyspace":       "test_keyspace1",
		"scope":          "test_table",
	}
	acc.AssertContainsTaggedFields(t, "cassandraTable", fields, tags)
}

// Test that the proper values are ignored or collected for class=Java
func TestHttpJsonJavaMultiValue(t *testing.T) {
	cassandra := genJolokiaClientStub(validJavaMultiValueJSON, 200,
		MultipleServers, []string{HeapMetric})

	var acc testutil.Accumulator
	acc.SetDebug(true)
	err := cassandra.Gather(&acc)

	assert.Nil(t, err)
	assert.Equal(t, 2, len(acc.Metrics))

	fields := map[string]interface{}{
		"HeapMemoryUsage_init":      67108864.0,
		"HeapMemoryUsage_committed": 456130560.0,
		"HeapMemoryUsage_max":       477626368.0,
		"HeapMemoryUsage_used":      203288528.0,
	}
	tags1 := map[string]string{
		"cassandra_host": "10.10.10.10",
		"mname":          "HeapMemoryUsage",
	}

	tags2 := map[string]string{
		"cassandra_host": "10.10.10.11",
		"mname":          "HeapMemoryUsage",
	}
	acc.AssertContainsTaggedFields(t, "javaMemory", fields, tags1)
	acc.AssertContainsTaggedFields(t, "javaMemory", fields, tags2)
}

func TestMultipleEvents(t *testing.T) {
	var acc testutil.Accumulator
	md := &MandrillWebhook{Path: "/mandrill", acc: &acc}
	resp := postWebhooks(md, "["+SendEventJSON()+","+HardBounceEventJSON()+"]")
	if resp.Code != http.StatusOK {
		t.Errorf("POST send returned HTTP status code %v.\nExpected %v", resp.Code, http.StatusOK)
	}

	fields := map[string]interface{}{
		"id": "id1",
	}

	tags := map[string]string{
		"event": "send",
	}

	acc.AssertContainsTaggedFields(t, "mandrill_webhooks", fields, tags)

	fields = map[string]interface{}{
		"id": "id2",
	}

	tags = map[string]string{
		"event": "hard_bounce",
	}
	acc.AssertContainsTaggedFields(t, "mandrill_webhooks", fields, tags)
}

func TestPhpFpmGeneratesMetrics_From_Http(t *testing.T) {
	sv := statServer{}
	ts := httptest.NewServer(sv)
	defer ts.Close()

	r := &phpfpm{
		Urls: []string{ts.URL},
	}

	var acc testutil.Accumulator

	err := r.Gather(&acc)
	require.NoError(t, err)

	tags := map[string]string{
		"pool": "www",
	}

	fields := map[string]interface{}{
		"accepted_conn":        int64(3),
		"listen_queue":         int64(1),
		"max_listen_queue":     int64(0),
		"listen_queue_len":     int64(0),
		"idle_processes":       int64(1),
		"active_processes":     int64(1),
		"total_processes":      int64(2),
		"max_active_processes": int64(1),
		"max_children_reached": int64(2),
		"slow_requests":        int64(1),
	}

	acc.AssertContainsTaggedFields(t, "phpfpm", fields, tags)
}

func TestRunParser(t *testing.T) {
	var testmsg = []byte(testMsg)

	listener, in := newTestTcpListener()
	acc := testutil.Accumulator{}
	listener.acc = &acc
	defer close(listener.done)

	listener.parser, _ = parsers.NewInfluxParser()
	listener.wg.Add(1)
	go listener.tcpParser()

	in <- testmsg
	time.Sleep(time.Millisecond * 25)
	listener.Gather(&acc)

	if a := acc.NFields(); a != 1 {
		t.Errorf("got %v, expected %v", a, 1)
	}

	acc.AssertContainsTaggedFields(t, "cpu_load_short",
		map[string]interface{}{"value": float64(12)},
		map[string]string{"host": "server01"},
	)
}

func TestZfsGeneratesMetrics(t *testing.T) {
	var acc testutil.Accumulator

	z := &Zfs{
		KstatMetrics: []string{"vdev_cache_stats"},
		sysctl:       mock_sysctl,
		zpool:        mock_zpool,
	}
	err := z.Gather(&acc)
	require.NoError(t, err)

	//four pool, vdev_cache_stats metrics
	tags := map[string]string{
		"pools": "freenas-boot::red1::temp1::temp2",
	}
	intMetrics := getKstatMetricsVdevOnly()

	acc.AssertContainsTaggedFields(t, "zfs", intMetrics, tags)

	acc.Metrics = nil

	z = &Zfs{
		KstatMetrics: []string{"zfetchstats", "vdev_cache_stats"},
		sysctl:       mock_sysctl,
		zpool:        mock_zpool,
	}
	err = z.Gather(&acc)
	require.NoError(t, err)

	//four pool, vdev_cache_stats and zfetchstatus metrics
	intMetrics = getKstatMetricsVdevAndZfetch()

	acc.AssertContainsTaggedFields(t, "zfs", intMetrics, tags)
}

func TestSNMPEasyGet6(t *testing.T) {
	h := Host{
		Address:   "127.0.0.1:31161",
		Community: "telegraf",
		Version:   2,
		Timeout:   2.0,
		Retries:   2,
		GetOids:   []string{"1.3.6.1.2.1.2.1.0"},
	}
	s := Snmp{
		SnmptranslateFile: "./testdata/oids.txt",
		Host:              []Host{h},
	}

	var acc testutil.Accumulator
	err := s.Gather(&acc)
	require.NoError(t, err)

	acc.AssertContainsTaggedFields(t,
		"ifNumber",
		map[string]interface{}{
			"ifNumber": int(4),
		},
		map[string]string{
			"instance": "0",
			"host":     "127.0.0.1",
		},
	)
}

func TestSNMPGet1(t *testing.T) {
	get1 := Data{
		Name: "oid1",
		Unit: "octets",
		Oid:  ".1.3.6.1.2.1.2.2.1.16.1",
	}
	h := Host{
		Address:   "127.0.0.1:31161",
		Community: "telegraf",
		Version:   2,
		Timeout:   2.0,
		Retries:   2,
		Collect:   []string{"oid1"},
	}
	s := Snmp{
		Host: []Host{h},
		Get:  []Data{get1},
	}

	var acc testutil.Accumulator
	err := s.Gather(&acc)
	require.NoError(t, err)

	acc.AssertContainsTaggedFields(t,
		"oid1",
		map[string]interface{}{
			"oid1": uint(543846),
		},
		map[string]string{
			"unit": "octets",
			"host": "127.0.0.1",
		},
	)
}

func TestTailFromEnd(t *testing.T) {
	tmpfile, err := ioutil.TempFile("", "")
	require.NoError(t, err)
	defer os.Remove(tmpfile.Name())
	_, err = tmpfile.WriteString("cpu,mytag=foo usage_idle=100\n")
	require.NoError(t, err)

	tt := NewTail()
	tt.Files = []string{tmpfile.Name()}
	p, _ := parsers.NewInfluxParser()
	tt.SetParser(p)
	defer tt.Stop()
	defer tmpfile.Close()

	acc := testutil.Accumulator{}
	require.NoError(t, tt.Start(&acc))
	time.Sleep(time.Millisecond * 100)

	_, err = tmpfile.WriteString("cpu,othertag=foo usage_idle=100\n")
	require.NoError(t, err)
	require.NoError(t, tt.Gather(&acc))
	time.Sleep(time.Millisecond * 50)

	acc.AssertContainsTaggedFields(t, "cpu",
		map[string]interface{}{
			"usage_idle": float64(100),
		},
		map[string]string{
			"othertag": "foo",
		})
	assert.Len(t, acc.Metrics, 1)
}

func TestMetricContainsServerAndDomainAndRecordTypeTags(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping network-dependent test in short mode.")
	}
	var dnsConfig = DnsQuery{
		Servers: servers,
		Domains: domains,
	}
	var acc testutil.Accumulator
	tags := map[string]string{
		"server":      "8.8.8.8",
		"domain":      "google.com",
		"record_type": "NS",
	}
	fields := map[string]interface{}{}

	err := dnsConfig.Gather(&acc)
	assert.NoError(t, err)
	metric, ok := acc.Get("dns_query")
	require.True(t, ok)
	queryTime, _ := metric.Fields["query_time_ms"].(float64)

	fields["query_time_ms"] = queryTime
	acc.AssertContainsTaggedFields(t, "dns_query", fields, tags)
}

func TestMissingDelayColumnNTPQ(t *testing.T) {
	resetVars()
	tt := tester{
		ret: []byte(missingDelayNTPQ),
		err: nil,
	}
	n := &NTPQ{
		runQ: tt.runqTest,
	}

	acc := testutil.Accumulator{}
	assert.NoError(t, n.Gather(&acc))

	fields := map[string]interface{}{
		"when":   int64(101),
		"poll":   int64(256),
		"reach":  int64(37),
		"offset": float64(233.010),
		"jitter": float64(17.462),
	}
	tags := map[string]string{
		"remote": "*uschi5-ntp-002.",
		"refid":  "10.177.80.46",
		"type":   "u",
	}
	acc.AssertContainsTaggedFields(t, "ntpq", fields, tags)
}

func TestTailFromBeginning(t *testing.T) {
	tmpfile, err := ioutil.TempFile("", "")
	require.NoError(t, err)
	defer os.Remove(tmpfile.Name())

	tt := NewTail()
	tt.FromBeginning = true
	tt.Files = []string{tmpfile.Name()}
	p, _ := parsers.NewInfluxParser()
	tt.SetParser(p)
	defer tt.Stop()
	defer tmpfile.Close()

	acc := testutil.Accumulator{}
	require.NoError(t, tt.Start(&acc))

	_, err = tmpfile.WriteString("cpu,mytag=foo usage_idle=100\n")
	require.NoError(t, err)
	require.NoError(t, tt.Gather(&acc))
	// arbitrary sleep to wait for message to show up
	time.Sleep(time.Millisecond * 250)

	acc.AssertContainsTaggedFields(t, "cpu",
		map[string]interface{}{
			"usage_idle": float64(100),
		},
		map[string]string{
			"mytag": "foo",
		})
}