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", "host": 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))) }
// Test that the proper values are ignored or collected func TestHttpJson200(t *testing.T) { httpjson := genMockHttpJson(validJSON, 200) var acc testutil.Accumulator err := httpjson.Gather(&acc) require.NoError(t, err) assert.Equal(t, 8, len(acc.Points)) for _, service := range httpjson.Services { for _, srv := range service.Servers { require.NoError(t, acc.ValidateTaggedValue( fmt.Sprintf("%s_parent_child", service.Name), 3.0, map[string]string{"server": srv}, ), ) require.NoError(t, acc.ValidateTaggedValue( fmt.Sprintf("%s_integer", service.Name), 4.0, map[string]string{"server": srv}, ), ) } } }
func TestNginxGeneratesMetrics(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { var rsp string if r.URL.Path == "/stub_status" { rsp = sampleResponse } else { panic("Cannot handle request") } fmt.Fprintln(w, rsp) })) defer ts.Close() n := &Nginx{ Urls: []string{fmt.Sprintf("%s/stub_status", ts.URL)}, } var acc testutil.Accumulator err := n.Gather(&acc) require.NoError(t, err) metrics := []struct { name string value uint64 }{ {"active", 585}, {"accepts", 85340}, {"handled", 85340}, {"requests", 35085}, {"reading", 4}, {"writing", 135}, {"waiting", 446}, } addr, err := url.Parse(ts.URL) if err != nil { panic(err) } host, _, _ := net.SplitHostPort(addr.Host) tags := map[string]string{"server": host} for _, m := range metrics { assert.NoError(t, acc.ValidateTaggedValue(m.name, m.value, tags)) } }
// Test that Gather works on a ping with no transmitted packets, even though the // command returns an error func TestBadPingGather(t *testing.T) { var acc testutil.Accumulator p := Ping{ Urls: []string{"www.amazon.com"}, pingHost: mockErrorHostPinger, } p.Gather(&acc) tags := map[string]string{"url": "www.amazon.com"} assert.NoError(t, acc.ValidateTaggedValue("packets_transmitted", 2, tags)) assert.NoError(t, acc.ValidateTaggedValue("packets_received", 0, tags)) assert.NoError(t, acc.ValidateTaggedValue("percent_packet_loss", 100.0, tags)) assert.NoError(t, acc.ValidateTaggedValue("average_response_ms", 0.0, tags)) }
// Test that Gather works on a ping with lossy packets func TestLossyPingGather(t *testing.T) { var acc testutil.Accumulator p := Ping{ Urls: []string{"www.google.com"}, pingHost: mockLossyHostPinger, } p.Gather(&acc) tags := map[string]string{"url": "www.google.com"} assert.NoError(t, acc.ValidateTaggedValue("packets_transmitted", 5, tags)) assert.NoError(t, acc.ValidateTaggedValue("packets_received", 3, tags)) assert.NoError(t, acc.ValidateTaggedValue("percent_packet_loss", 40.0, tags)) assert.NoError(t, acc.ValidateTaggedValue("average_response_ms", 44.033, tags)) }
func TestElasticsearch(t *testing.T) { es := NewElasticsearch() es.Servers = []string{"http://example.com:9200"} es.client.Transport = newTransportMock(http.StatusOK, statsResponse) var acc testutil.Accumulator if err := es.Gather(&acc); err != nil { t.Fatal(err) } tags := map[string]string{ "cluster_name": "es-testcluster", "node_attribute_master": "true", "node_id": "SDFsfSDFsdfFSDSDfSFDSDF", "node_name": "test.host.com", "node_host": "test", } testTables := []map[string]float64{ indicesExpected, osExpected, processExpected, jvmExpected, threadPoolExpected, networkExpected, fsExpected, transportExpected, httpExpected, breakersExpected, } for _, testTable := range testTables { for k, v := range testTable { assert.NoError(t, acc.ValidateTaggedValue(k, v, tags)) } } }
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://*****:*****@", 1)}, } var acc testutil.Accumulator err := r.Gather(&acc) require.NoError(t, err) tags := map[string]string{ "host": ts.Listener.Addr().String(), "proxy": "be_app", "sv": "host0", } assert.NoError(t, acc.ValidateTaggedValue("stot", uint64(171014), tags)) checkInt := []struct { name string value uint64 }{ {"bin", 5557055817}, {"scur", 288}, {"qmax", 81}, {"http_response.1xx", 0}, {"http_response.2xx", 1314093}, {"http_response.3xx", 537036}, {"http_response.4xx", 123452}, {"dreq", 1102}, {"dresp", 80}, {"wretr", 17}, {"wredis", 19}, {"ereq", 95740}, {"econ", 0}, {"eresp", 0}, {"req_rate", 35}, {"req_rate_max", 140}, {"req_tot", 1987928}, {"bin", 5557055817}, {"bout", 24096715169}, {"rate", 18}, {"rate_max", 102}, {"throttle", 13}, {"lbtot", 114}, } 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) }
func TestSystemStats_GenerateStats(t *testing.T) { var mps MockPS defer mps.AssertExpectations(t) var acc testutil.Accumulator cts := cpu.CPUTimesStat{ CPU: "cpu0", User: 3.1, System: 8.2, Idle: 80.1, Nice: 1.3, Iowait: 0.2, Irq: 0.1, Softirq: 0.11, Steal: 0.0001, Guest: 8.1, GuestNice: 0.324, Stolen: 0.051, } cts2 := cpu.CPUTimesStat{ CPU: "cpu0", User: 11.4, // increased by 8.3 System: 10.9, // increased by 2.7 Idle: 158.8699, // increased by 78.7699 (for total increase of 100) Nice: 2.5, // increased by 1.2 Iowait: 0.7, // increased by 0.5 Irq: 1.2, // increased by 1.1 Softirq: 0.31, // increased by 0.2 Steal: 0.0002, // increased by 0.0001 Guest: 12.9, // increased by 4.8 GuestNice: 2.524, // increased by 2.2 Stolen: 0.281, // increased by 0.23 } mps.On("CPUTimes").Return([]cpu.CPUTimesStat{cts}, nil) du := &disk.DiskUsageStat{ Path: "/", Fstype: "ext4", Total: 128, Free: 23, InodesTotal: 1234, InodesFree: 234, } mps.On("DiskUsage").Return([]*disk.DiskUsageStat{du}, nil) diskio := disk.DiskIOCountersStat{ ReadCount: 888, WriteCount: 5341, ReadBytes: 100000, WriteBytes: 200000, ReadTime: 7123, WriteTime: 9087, Name: "sda1", IoTime: 123552, SerialNumber: "ab-123-ad", } mps.On("DiskIO").Return(map[string]disk.DiskIOCountersStat{"sda1": diskio}, nil) netio := net.NetIOCountersStat{ Name: "eth0", BytesSent: 1123, BytesRecv: 8734422, PacketsSent: 781, PacketsRecv: 23456, Errin: 832, Errout: 8, Dropin: 7, Dropout: 1, } mps.On("NetIO").Return([]net.NetIOCountersStat{netio}, nil) vms := &mem.VirtualMemoryStat{ Total: 12400, Available: 7600, Used: 5000, UsedPercent: 47.1, Free: 1235, Active: 8134, Inactive: 1124, Buffers: 771, Cached: 4312, Wired: 134, Shared: 2142, } mps.On("VMStat").Return(vms, nil) sms := &mem.SwapMemoryStat{ Total: 8123, Used: 1232, Free: 6412, UsedPercent: 12.2, Sin: 7, Sout: 830, } mps.On("SwapStat").Return(sms, nil) 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) mps2 := MockPS{} mps2.On("CPUTimes").Return([]cpu.CPUTimesStat{cts2}, nil) cs.ps = &mps2 // Should have added cpu percentages too err = cs.Gather(&acc) require.NoError(t, err) numCPUPoints = len(acc.Points) - (preCPUPoints + numCPUPoints) expectedCPUPoints = 24 assert.Equal(t, numCPUPoints, expectedCPUPoints) assertContainsTaggedFloat(t, acc, "user", 11.4, 0, cputags) assertContainsTaggedFloat(t, acc, "system", 10.9, 0, cputags) assertContainsTaggedFloat(t, acc, "idle", 158.8699, 0, cputags) assertContainsTaggedFloat(t, acc, "nice", 2.5, 0, cputags) assertContainsTaggedFloat(t, acc, "iowait", 0.7, 0, cputags) assertContainsTaggedFloat(t, acc, "irq", 1.2, 0, cputags) assertContainsTaggedFloat(t, acc, "softirq", 0.31, 0, cputags) assertContainsTaggedFloat(t, acc, "steal", 0.0002, 0, cputags) assertContainsTaggedFloat(t, acc, "guest", 12.9, 0, cputags) assertContainsTaggedFloat(t, acc, "guestNice", 2.524, 0, cputags) assertContainsTaggedFloat(t, acc, "stolen", 0.281, 0, cputags) assertContainsTaggedFloat(t, acc, "busy", 42.7152, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageUser", 8.3, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageSystem", 2.7, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageIdle", 78.7699, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageNice", 1.2, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageIowait", 0.5, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageIrq", 1.1, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageSoftirq", 0.2, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageSteal", 0.0001, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageGuest", 4.8, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageGuestNice", 2.2, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageStolen", 0.23, 0.0005, cputags) assertContainsTaggedFloat(t, acc, "percentageBusy", 21.2301, 0.0005, cputags) err = (&DiskStats{&mps}).Gather(&acc) require.NoError(t, err) tags := map[string]string{ "path": "/", "fstype": "ext4", } assert.True(t, acc.CheckTaggedValue("total", uint64(128), tags)) assert.True(t, acc.CheckTaggedValue("used", uint64(105), tags)) assert.True(t, acc.CheckTaggedValue("free", uint64(23), tags)) assert.True(t, acc.CheckTaggedValue("inodes_total", uint64(1234), tags)) assert.True(t, acc.CheckTaggedValue("inodes_free", uint64(234), tags)) assert.True(t, acc.CheckTaggedValue("inodes_used", uint64(1000), tags)) err = (&NetIOStats{ps: &mps, skipChecks: true}).Gather(&acc) require.NoError(t, err) ntags := map[string]string{ "interface": "eth0", } assert.NoError(t, acc.ValidateTaggedValue("bytes_sent", uint64(1123), ntags)) assert.NoError(t, acc.ValidateTaggedValue("bytes_recv", uint64(8734422), ntags)) assert.NoError(t, acc.ValidateTaggedValue("packets_sent", uint64(781), ntags)) assert.NoError(t, acc.ValidateTaggedValue("packets_recv", uint64(23456), ntags)) assert.NoError(t, acc.ValidateTaggedValue("err_in", uint64(832), ntags)) assert.NoError(t, acc.ValidateTaggedValue("err_out", uint64(8), ntags)) assert.NoError(t, acc.ValidateTaggedValue("drop_in", uint64(7), ntags)) assert.NoError(t, acc.ValidateTaggedValue("drop_out", uint64(1), ntags)) err = (&DiskIOStats{&mps}).Gather(&acc) require.NoError(t, err) dtags := map[string]string{ "name": "sda1", "serial": "ab-123-ad", } assert.True(t, acc.CheckTaggedValue("reads", uint64(888), dtags)) assert.True(t, acc.CheckTaggedValue("writes", uint64(5341), dtags)) assert.True(t, acc.CheckTaggedValue("read_bytes", uint64(100000), dtags)) assert.True(t, acc.CheckTaggedValue("write_bytes", uint64(200000), dtags)) assert.True(t, acc.CheckTaggedValue("read_time", uint64(7123), dtags)) assert.True(t, acc.CheckTaggedValue("write_time", uint64(9087), dtags)) assert.True(t, acc.CheckTaggedValue("io_time", uint64(123552), dtags)) err = (&MemStats{&mps}).Gather(&acc) require.NoError(t, err) vmtags := map[string]string(nil) assert.True(t, acc.CheckTaggedValue("total", uint64(12400), vmtags)) assert.True(t, acc.CheckTaggedValue("available", uint64(7600), vmtags)) assert.True(t, acc.CheckTaggedValue("used", uint64(5000), vmtags)) assert.True(t, acc.CheckTaggedValue("used_perc", float64(47.1), vmtags)) assert.True(t, acc.CheckTaggedValue("free", uint64(1235), vmtags)) assert.True(t, acc.CheckTaggedValue("active", uint64(8134), vmtags)) assert.True(t, acc.CheckTaggedValue("inactive", uint64(1124), vmtags)) assert.True(t, acc.CheckTaggedValue("buffers", uint64(771), vmtags)) assert.True(t, acc.CheckTaggedValue("cached", uint64(4312), vmtags)) assert.True(t, acc.CheckTaggedValue("wired", uint64(134), vmtags)) assert.True(t, acc.CheckTaggedValue("shared", uint64(2142), vmtags)) acc.Points = nil err = (&SwapStats{&mps}).Gather(&acc) require.NoError(t, err) swaptags := map[string]string(nil) assert.NoError(t, acc.ValidateTaggedValue("total", uint64(8123), swaptags)) assert.NoError(t, acc.ValidateTaggedValue("used", uint64(1232), swaptags)) assert.NoError(t, acc.ValidateTaggedValue("used_perc", float64(12.2), swaptags)) assert.NoError(t, acc.ValidateTaggedValue("free", uint64(6412), swaptags)) assert.NoError(t, acc.ValidateTaggedValue("in", uint64(7), swaptags)) assert.NoError(t, acc.ValidateTaggedValue("out", uint64(830), swaptags)) }