Golang Accumulator.CheckValue方法代码示例

func TestHaproxyGeneratesMetricsWithoutAuthentication(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprint(w, csvOutputSample)
	}))
	defer ts.Close()

	r := &haproxy{
		Servers: []string{ts.URL},
	}

	var acc testutil.Accumulator

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

	tags := map[string]string{
		"proxy":  "be_app",
		"server": ts.Listener.Addr().String(),
		"sv":     "host0",
	}

	assert.NoError(t, acc.ValidateTaggedValue("stot", uint64(171014), tags))
	assert.NoError(t, acc.ValidateTaggedValue("scur", uint64(1), tags))
	assert.NoError(t, acc.ValidateTaggedValue("rate", uint64(3), tags))
	assert.Equal(t, true, acc.CheckValue("bin", uint64(5557055817)))
}

func TestExec(t *testing.T) {
	runner := newRunnerMock([]byte(validJson), nil)
	command := Command{Command: "testcommand arg1", Name: "mycollector"}
	e := &Exec{runner: runner, Commands: []*Command{&command}}

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

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mycollector_num_processes", 82},
		{"mycollector_cpu_used", 8234},
		{"mycollector_cpu_free", 32},
		{"mycollector_percent", 0.81},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	assert.Equal(t, len(acc.Points), 4, "non-numeric measurements should be ignored")
}

// Test that the parser parses kafka messages into points
func TestRunParserAndGather(t *testing.T) {
	k, in := NewTestKafka()
	defer close(k.done)

	go k.parser()
	in <- saramaMsg(testMsg)
	time.Sleep(time.Millisecond)

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

	assert.Equal(t, len(acc.Points), 1)
	assert.True(t, acc.CheckValue("cpu_load_short", 23422.0))
}

func TestHTTPApache(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		fmt.Fprintln(w, apacheStatus)
	}))
	defer ts.Close()

	a := Apache{
		Urls: []string{ts.URL},
	}

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

	testInt := []struct {
		measurement string
		value       float64
	}{
		{"TotalAccesses", 1.29811861e+08},
		{"TotalkBytes", 5.213701865e+09},
		{"CPULoad", 6.51929},
		{"Uptime", 941553},
		{"ReqPerSec", 137.87},
		{"BytesPerSec", 5.67024e+06},
		{"BytesPerReq", 41127.4},
		{"BusyWorkers", 270},
		{"IdleWorkers", 630},
		{"ConnsTotal", 1451},
		{"ConnsAsyncWriting", 32},
		{"ConnsAsyncKeepAlive", 945},
		{"ConnsAsyncClosing", 205},
		{"scboard_waiting", 630},
		{"scboard_starting", 0},
		{"scboard_reading", 157},
		{"scboard_sending", 113},
		{"scboard_keepalive", 0},
		{"scboard_dnslookup", 0},
		{"scboard_closing", 0},
		{"scboard_logging", 0},
		{"scboard_finishing", 0},
		{"scboard_idle_cleanup", 0},
		{"scboard_open", 2850},
	}

	for _, test := range testInt {
		assert.True(t, acc.CheckValue(test.measurement, test.value))
	}
}

// Test that the parser parses kafka messages into points
func TestRunParserAndGather(t *testing.T) {
	k, in := NewTestKafka()
	defer close(k.done)

	go k.parser()
	in <- saramaMsg(testMsg)
	time.Sleep(time.Millisecond)

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

	assert.Equal(t, len(acc.Points), 1)
	fmt.Printf("%T\n", acc.Points[0].Fields["temperature"])
	assert.True(t, acc.CheckValue("sensordata", 100.0))
}

func TestReadAerospikeStatsNoNamespace(t *testing.T) {
	// Also test for re-writing
	var acc testutil.Accumulator
	stats := map[string]string{
		"stat-write-errs": "12345",
		"stat_read_reqs":  "12345",
	}
	readAerospikeStats(stats, &acc, "host1", "")
	for k := range stats {
		if k == "stat-write-errs" {
			k = "stat_write_errs"
		}
		assert.True(t, acc.HasMeasurement(k))
		assert.True(t, acc.CheckValue(k, int64(12345)))
	}
}

func TestExecOneNotEnoughTimeAndOneEnoughTime(t *testing.T) {
	runner := newRunnerMock([]byte(validJson), nil)
	clock := newClockMock(time.Unix(baseTimeSeconds+5, 0))
	notEnoughTimeCommand := Command{
		Command:   "testcommand arg1",
		Name:      "mycollector",
		Interval:  10,
		lastRunAt: time.Unix(baseTimeSeconds, 0),
	}
	enoughTimeCommand := Command{
		Command:   "testcommand arg1",
		Name:      "mycollector",
		Interval:  3,
		lastRunAt: time.Unix(baseTimeSeconds, 0),
	}

	e := &Exec{
		runner:   runner,
		clock:    clock,
		Commands: []*Command{&notEnoughTimeCommand, &enoughTimeCommand},
	}

	var acc testutil.Accumulator
	initialPoints := len(acc.Points)
	err := e.Gather(&acc)
	deltaPoints := len(acc.Points) - initialPoints
	require.NoError(t, err)

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mycollector_num_processes", 82},
		{"mycollector_cpu_used", 8234},
		{"mycollector_cpu_free", 32},
		{"mycollector_percent", 0.81},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	assert.Equal(t, deltaPoints, 4, "Only one command should have been run")
}

func TestPhpFpmGeneratesMetrics(t *testing.T) {
	//We create a fake server to return test data
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprint(w, outputSample)
	}))
	defer ts.Close()

	//Now we tested again above server, with our authentication data
	r := &phpfpm{
		Urls: []string{ts.URL},
	}

	var acc testutil.Accumulator

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

	tags := map[string]string{
		"url":  ts.Listener.Addr().String(),
		"pool": "www",
	}
	assert.NoError(t, acc.ValidateTaggedValue("accepted_conn", int64(3), tags))

	checkInt := []struct {
		name  string
		value int64
	}{
		{"accepted_conn", 3},
		{"listen_queue", 1},
		{"max_listen_queue", 0},
		{"listen_queue_len", 0},
		{"idle_processes", 1},
		{"active_processes", 1},
		{"total_processes", 2},
		{"max_active_processes", 1},
		{"max_children_reached", 2},
		{"slow_requests", 1},
	}

	for _, c := range checkInt {
		assert.Equal(t, true, acc.CheckValue(c.name, c.value))
	}
}

func TestExecUninitializedLastRunAt(t *testing.T) {
	runner := newRunnerMock([]byte(validJson), nil)
	clock := newClockMock(time.Unix(baseTimeSeconds, 0))
	command := Command{
		Command:  "testcommand arg1",
		Name:     "mycollector",
		Interval: math.MaxInt32,
		// Uninitialized lastRunAt should default to time.Unix(0, 0), so this should
		// run no matter what the interval is
	}

	e := &Exec{
		runner:   runner,
		clock:    clock,
		Commands: []*Command{&command},
	}

	var acc testutil.Accumulator
	initialPoints := len(acc.Points)
	err := e.Gather(&acc)
	deltaPoints := len(acc.Points) - initialPoints
	require.NoError(t, err)

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mycollector_num_processes", 82},
		{"mycollector_cpu_used", 8234},
		{"mycollector_cpu_free", 32},
		{"mycollector_percent", 0.81},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	assert.Equal(t, deltaPoints, 4, "non-numeric measurements should be ignored")
}

func TestHaproxyGeneratesMetricsWithAuthentication(t *testing.T) {
	//We create a fake server to return test data
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		username, password, ok := r.BasicAuth()
		if !ok {
			w.WriteHeader(http.StatusNotFound)
			fmt.Fprint(w, "Unauthorized")
			return
		}

		if username == "user" && password == "password" {
			fmt.Fprint(w, csvOutputSample)
		} else {
			w.WriteHeader(http.StatusNotFound)
			fmt.Fprint(w, "Unauthorized")
		}
	}))
	defer ts.Close()

	//Now we tested again above server, with our authentication data
	r := &haproxy{
		Servers: []string{strings.Replace(ts.URL, "http://", "http://user:[email protected]", 1)},
	}

	var acc testutil.Accumulator

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

	tags := map[string]string{
		"server": ts.Listener.Addr().String(),
		"proxy":  "be_app",
		"sv":     "host0",
	}

	assert.NoError(t, acc.ValidateTaggedValue("stot", uint64(171014), tags))

	checkInt := []struct {
		name  string
		value uint64
	}{

		{"qmax", 81},
		{"scur", 288},
		{"smax", 713},
		{"bin", 5557055817},
		{"bout", 24096715169},
		{"dreq", 1102},
		{"dresp", 80},
		{"ereq", 95740},
		{"econ", 0},
		{"eresp", 0},
		{"wretr", 17},
		{"wredis", 19},
		{"active_servers", 1},
		{"backup_servers", 0},
		{"downtime", 0},
		{"throttle", 13},
		{"lbtot", 114},
		{"rate", 18},
		{"rate_max", 102},
		{"check_duration", 1},
		{"http_response.1xx", 0},
		{"http_response.2xx", 1314093},
		{"http_response.3xx", 537036},
		{"http_response.4xx", 123452},
		{"http_response.5xx", 11966},
		{"req_rate", 35},
		{"req_rate_max", 140},
		{"req_tot", 1987928},
		{"cli_abort", 0},
		{"srv_abort", 0},
		{"qtime", 0},
		{"ctime", 2},
		{"rtime", 23},
		{"ttime", 545},
	}

	for _, c := range checkInt {
		assert.Equal(t, true, acc.CheckValue(c.name, c.value))
	}

	//Here, we should get error because we don't pass authentication data
	r = &haproxy{
		Servers: []string{ts.URL},
	}

	err = r.Gather(&acc)
	require.Error(t, err)
}

//.........这里部分代码省略.........
			Pgpgin:                  5,
			Pgpgout:                 6,
			Pgfault:                 7,
			Pgmajfault:              8,
			InactiveAnon:            9,
			ActiveAnon:              10,
			InactiveFile:            11,
			ActiveFile:              12,
			Unevictable:             13,
			HierarchicalMemoryLimit: 14,
			TotalCache:              15,
			TotalRSS:                16,
			TotalRSSHuge:            17,
			TotalMappedFile:         18,
			TotalPgpgIn:             19,
			TotalPgpgOut:            20,
			TotalPgFault:            21,
			TotalPgMajFault:         22,
			TotalInactiveAnon:       23,
			TotalActiveAnon:         24,
			TotalInactiveFile:       25,
			TotalActiveFile:         26,
			TotalUnevictable:        27,
		},
	}

	mps.On("DockerStat").Return([]*DockerContainerStat{ds}, nil)

	ss := &SystemStats{ps: &mps}

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

	assert.True(t, acc.CheckValue("load1", 0.3))
	assert.True(t, acc.CheckValue("load5", 1.5))
	assert.True(t, acc.CheckValue("load15", 0.8))

	cs := NewCPUStats(&mps)

	cputags := map[string]string{
		"cpu": "cpu0",
	}

	preCPUPoints := len(acc.Points)
	err = cs.Gather(&acc)
	require.NoError(t, err)
	numCPUPoints := len(acc.Points) - preCPUPoints

	expectedCPUPoints := 12
	assert.Equal(t, numCPUPoints, expectedCPUPoints)

	// Computed values are checked with delta > 0 becasue of floating point arithmatic
	// imprecision
	assertContainsTaggedFloat(t, acc, "user", 3.1, 0, cputags)
	assertContainsTaggedFloat(t, acc, "system", 8.2, 0, cputags)
	assertContainsTaggedFloat(t, acc, "idle", 80.1, 0, cputags)
	assertContainsTaggedFloat(t, acc, "nice", 1.3, 0, cputags)
	assertContainsTaggedFloat(t, acc, "iowait", 0.2, 0, cputags)
	assertContainsTaggedFloat(t, acc, "irq", 0.1, 0, cputags)
	assertContainsTaggedFloat(t, acc, "softirq", 0.11, 0, cputags)
	assertContainsTaggedFloat(t, acc, "steal", 0.0001, 0, cputags)
	assertContainsTaggedFloat(t, acc, "guest", 8.1, 0, cputags)
	assertContainsTaggedFloat(t, acc, "guestNice", 0.324, 0, cputags)
	assertContainsTaggedFloat(t, acc, "stolen", 0.051, 0, cputags)
	assertContainsTaggedFloat(t, acc, "busy", 21.4851, 0.0005, cputags)

func TestRedisGeneratesMetrics(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	l, err := net.Listen("tcp", ":0")
	require.NoError(t, err)

	defer l.Close()

	go func() {
		c, err := l.Accept()
		if err != nil {
			return
		}

		buf := bufio.NewReader(c)

		for {
			line, err := buf.ReadString('\n')
			if err != nil {
				return
			}

			if line != "info\r\n" {
				return
			}

			fmt.Fprintf(c, "$%d\n", len(testOutput))
			c.Write([]byte(testOutput))
		}
	}()

	addr := fmt.Sprintf("redis://%s", l.Addr().String())

	r := &Redis{
		Servers: []string{addr},
	}

	var acc testutil.Accumulator

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

	checkInt := []struct {
		name  string
		value uint64
	}{
		{"uptime", 238},
		{"clients", 1},
		{"used_memory", 1003936},
		{"used_memory_rss", 811008},
		{"used_memory_peak", 1003936},
		{"used_memory_lua", 33792},
		{"rdb_changes_since_last_save", 0},
		{"total_connections_received", 2},
		{"total_commands_processed", 1},
		{"instantaneous_ops_per_sec", 0},
		{"sync_full", 0},
		{"sync_partial_ok", 0},
		{"sync_partial_err", 0},
		{"expired_keys", 0},
		{"evicted_keys", 0},
		{"keyspace_hits", 0},
		{"keyspace_misses", 0},
		{"pubsub_channels", 0},
		{"pubsub_patterns", 0},
		{"latest_fork_usec", 0},
		{"connected_slaves", 0},
		{"master_repl_offset", 0},
		{"repl_backlog_active", 0},
		{"repl_backlog_size", 1048576},
		{"repl_backlog_histlen", 0},
	}

	for _, c := range checkInt {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mem_fragmentation_ratio", 0.81},
		{"used_cpu_sys", 0.14},
		{"used_cpu_user", 0.05},
		{"used_cpu_sys_children", 0.00},
		{"used_cpu_user_children", 0.00},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}
}

func TestDisqueCanPullStatsFromMultipleServers(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test in short mode")
	}

	l, err := net.Listen("tcp", "localhost:0")
	require.NoError(t, err)

	defer l.Close()

	go func() {
		c, err := l.Accept()
		if err != nil {
			return
		}

		buf := bufio.NewReader(c)

		for {
			line, err := buf.ReadString('\n')
			if err != nil {
				return
			}

			if line != "info\r\n" {
				return
			}

			fmt.Fprintf(c, "$%d\n", len(testOutput))
			c.Write([]byte(testOutput))
		}
	}()

	addr := fmt.Sprintf("disque://%s", l.Addr().String())

	r := &Disque{
		Servers: []string{addr},
	}

	var acc testutil.Accumulator

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

	checkInt := []struct {
		name  string
		value uint64
	}{
		{"uptime", 1452705},
		{"clients", 31},
		{"blocked_clients", 13},
		{"used_memory", 1840104},
		{"used_memory_rss", 3227648},
		{"used_memory_peak", 89603656},
		{"total_connections_received", 5062777},
		{"total_commands_processed", 12308396},
		{"instantaneous_ops_per_sec", 18},
		{"latest_fork_usec", 1644},
		{"registered_jobs", 360},
		{"registered_queues", 12},
	}

	for _, c := range checkInt {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mem_fragmentation_ratio", 1.75},
		{"used_cpu_sys", 19585.73},
		{"used_cpu_user", 11255.96},
		{"used_cpu_sys_children", 1.75},
		{"used_cpu_user_children", 1.91},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}
}

func TestRedis_ParseMetrics(t *testing.T) {
	var acc testutil.Accumulator
	tags := map[string]string{"host": "redis.net"}
	rdr := bufio.NewReader(strings.NewReader(testOutput))

	err := gatherInfoOutput(rdr, &acc, tags)
	require.NoError(t, err)

	checkInt := []struct {
		name  string
		value uint64
	}{
		{"uptime", 238},
		{"clients", 1},
		{"used_memory", 1003936},
		{"used_memory_rss", 811008},
		{"used_memory_peak", 1003936},
		{"used_memory_lua", 33792},
		{"rdb_changes_since_last_save", 0},
		{"total_connections_received", 2},
		{"total_commands_processed", 1},
		{"instantaneous_ops_per_sec", 0},
		{"sync_full", 0},
		{"sync_partial_ok", 0},
		{"sync_partial_err", 0},
		{"expired_keys", 0},
		{"evicted_keys", 0},
		{"keyspace_hits", 0},
		{"keyspace_misses", 0},
		{"pubsub_channels", 0},
		{"pubsub_patterns", 0},
		{"latest_fork_usec", 0},
		{"connected_slaves", 0},
		{"master_repl_offset", 0},
		{"repl_backlog_active", 0},
		{"repl_backlog_size", 1048576},
		{"repl_backlog_histlen", 0},
		{"keys", 2},
		{"expires", 0},
		{"avg_ttl", 0},
	}

	for _, c := range checkInt {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"mem_fragmentation_ratio", 0.81},
		{"used_cpu_sys", 0.14},
		{"used_cpu_user", 0.05},
		{"used_cpu_sys_children", 0.00},
		{"used_cpu_user_children", 0.00},
	}

	for _, c := range checkFloat {
		assert.True(t, acc.CheckValue(c.name, c.value))
	}
}

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

	pa := PuppetAgent{
		Location: "last_run_summary.yaml",
	}
	pa.Gather(&acc)

	checkInt := []struct {
		name  string
		value int64
	}{
		{"events_failure", 0},
		{"events_total", 0},
		{"events_success", 0},
		{"resources_failed", 0},
		{"resources_scheduled", 0},
		{"resources_changed", 0},
		{"resources_skipped", 0},
		{"resources_total", 109},
		{"resources_failedtorestart", 0},
		{"resources_restarted", 0},
		{"resources_outofsync", 0},
		{"changes_total", 0},
		{"time_lastrun", 1444936531},
		{"version_config", 1444936521},
	}

	for _, c := range checkInt {
		assert.Equal(t, true, acc.CheckValue(c.name, c.value))
	}

	checkFloat := []struct {
		name  string
		value float64
	}{
		{"time_user", 0.004331},
		{"time_schedule", 0.001123},
		{"time_filebucket", 0.000353},
		{"time_file", 0.441472},
		{"time_exec", 0.508123},
		{"time_anchor", 0.000555},
		{"time_sshauthorizedkey", 0.000764},
		{"time_service", 1.807795},
		{"time_package", 1.325788},
		{"time_total", 8.85354707064819},
		{"time_configretrieval", 4.75567007064819},
		{"time_cron", 0.000584},
	}

	for _, f := range checkFloat {
		assert.Equal(t, true, acc.CheckValue(f.name, f.value))
	}

	checkString := []struct {
		name  string
		value string
	}{
		{"version_puppet", "3.7.5"},
	}

	for _, s := range checkString {
		assert.Equal(t, true, acc.CheckValue(s.name, s.value))
	}

}