aboutsummaryrefslogtreecommitdiffstats
path: root/metrics/metrics_test.go
blob: 726fba34758af3a7aad3906aee0332bc5896c8ee (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package metrics

import (
    "fmt"
    "io/ioutil"
    "log"
    "sync"
    "testing"
)

const FANOUT = 128

// Stop the compiler from complaining during debugging.
var (
    _ = ioutil.Discard
    _ = log.LstdFlags
)

func BenchmarkMetrics(b *testing.B) {
    r := NewRegistry()
    c := NewRegisteredCounter("counter", r)
    g := NewRegisteredGauge("gauge", r)
    gf := NewRegisteredGaugeFloat64("gaugefloat64", r)
    h := NewRegisteredHistogram("histogram", r, NewUniformSample(100))
    m := NewRegisteredMeter("meter", r)
    t := NewRegisteredTimer("timer", r)
    RegisterDebugGCStats(r)
    RegisterRuntimeMemStats(r)
    b.ResetTimer()
    ch := make(chan bool)

    wgD := &sync.WaitGroup{}
    /*
        wgD.Add(1)
        go func() {
            defer wgD.Done()
            //log.Println("go CaptureDebugGCStats")
            for {
                select {
                case <-ch:
                    //log.Println("done CaptureDebugGCStats")
                    return
                default:
                    CaptureDebugGCStatsOnce(r)
                }
            }
        }()
    //*/

    wgR := &sync.WaitGroup{}
    //*
    wgR.Add(1)
    go func() {
        defer wgR.Done()
        //log.Println("go CaptureRuntimeMemStats")
        for {
            select {
            case <-ch:
                //log.Println("done CaptureRuntimeMemStats")
                return
            default:
                CaptureRuntimeMemStatsOnce(r)
            }
        }
    }()
    //*/

    wgW := &sync.WaitGroup{}
    /*
        wgW.Add(1)
        go func() {
            defer wgW.Done()
            //log.Println("go Write")
            for {
                select {
                case <-ch:
                    //log.Println("done Write")
                    return
                default:
                    WriteOnce(r, ioutil.Discard)
                }
            }
        }()
    //*/

    wg := &sync.WaitGroup{}
    wg.Add(FANOUT)
    for i := 0; i < FANOUT; i++ {
        go func(i int) {
            defer wg.Done()
            //log.Println("go", i)
            for i := 0; i < b.N; i++ {
                c.Inc(1)
                g.Update(int64(i))
                gf.Update(float64(i))
                h.Update(int64(i))
                m.Mark(1)
                t.Update(1)
            }
            //log.Println("done", i)
        }(i)
    }
    wg.Wait()
    close(ch)
    wgD.Wait()
    wgR.Wait()
    wgW.Wait()
}

func Example() {
    c := NewCounter()
    Register("money", c)
    c.Inc(17)

    // Threadsafe registration
    t := GetOrRegisterTimer("db.get.latency", nil)
    t.Time(func() {})
    t.Update(1)

    fmt.Println(c.Count())
    fmt.Println(t.Min())
    // Output: 17
    // 1
}