mirror of https://github.com/ethereum/go-ethereum
metrics: pull library and introduce ResettingTimer and InfluxDB reporter (#15910)
* go-metrics: fork library and introduce ResettingTimer and InfluxDB reporter. * vendor: change nonsense/go-metrics to ethersphere/go-metrics * go-metrics: add tests. move ResettingTimer logic from reporter to type. * all, metrics: pull in metrics package in go-ethereum * metrics/test: make sure metrics are enabled for tests * metrics: apply gosimple rules * metrics/exp, internal/debug: init expvar endpoint when starting pprof server * internal/debug: tiny comment formatting fixpull/15980/merge
Anton Evangelatov
7 years ago
committed by
Péter Szilágyi
parent
7f74bdf8dd
commit
ae9f97221a
@ -0,0 +1 @@ |
|||||||
|
This repo has been forked from https://github.com/rcrowley/go-metrics at commit e181e09 |
||||||
@ -0,0 +1,77 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import "testing" |
||||||
|
|
||||||
|
func BenchmarkCounter(b *testing.B) { |
||||||
|
c := NewCounter() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
c.Inc(1) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterClear(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Inc(1) |
||||||
|
c.Clear() |
||||||
|
if count := c.Count(); 0 != count { |
||||||
|
t.Errorf("c.Count(): 0 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterDec1(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Dec(1) |
||||||
|
if count := c.Count(); -1 != count { |
||||||
|
t.Errorf("c.Count(): -1 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterDec2(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Dec(2) |
||||||
|
if count := c.Count(); -2 != count { |
||||||
|
t.Errorf("c.Count(): -2 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterInc1(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Inc(1) |
||||||
|
if count := c.Count(); 1 != count { |
||||||
|
t.Errorf("c.Count(): 1 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterInc2(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Inc(2) |
||||||
|
if count := c.Count(); 2 != count { |
||||||
|
t.Errorf("c.Count(): 2 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterSnapshot(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
c.Inc(1) |
||||||
|
snapshot := c.Snapshot() |
||||||
|
c.Inc(1) |
||||||
|
if count := snapshot.Count(); 1 != count { |
||||||
|
t.Errorf("c.Count(): 1 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestCounterZero(t *testing.T) { |
||||||
|
c := NewCounter() |
||||||
|
if count := c.Count(); 0 != count { |
||||||
|
t.Errorf("c.Count(): 0 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterCounter(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredCounter("foo", r).Inc(47) |
||||||
|
if c := GetOrRegisterCounter("foo", r); 47 != c.Count() { |
||||||
|
t.Fatal(c) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,48 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"runtime" |
||||||
|
"runtime/debug" |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkDebugGCStats(b *testing.B) { |
||||||
|
r := NewRegistry() |
||||||
|
RegisterDebugGCStats(r) |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
CaptureDebugGCStatsOnce(r) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestDebugGCStatsBlocking(t *testing.T) { |
||||||
|
if g := runtime.GOMAXPROCS(0); g < 2 { |
||||||
|
t.Skipf("skipping TestDebugGCMemStatsBlocking with GOMAXPROCS=%d\n", g) |
||||||
|
return |
||||||
|
} |
||||||
|
ch := make(chan int) |
||||||
|
go testDebugGCStatsBlocking(ch) |
||||||
|
var gcStats debug.GCStats |
||||||
|
t0 := time.Now() |
||||||
|
debug.ReadGCStats(&gcStats) |
||||||
|
t1 := time.Now() |
||||||
|
t.Log("i++ during debug.ReadGCStats:", <-ch) |
||||||
|
go testDebugGCStatsBlocking(ch) |
||||||
|
d := t1.Sub(t0) |
||||||
|
t.Log(d) |
||||||
|
time.Sleep(d) |
||||||
|
t.Log("i++ during time.Sleep:", <-ch) |
||||||
|
} |
||||||
|
|
||||||
|
func testDebugGCStatsBlocking(ch chan int) { |
||||||
|
i := 0 |
||||||
|
for { |
||||||
|
select { |
||||||
|
case ch <- i: |
||||||
|
return |
||||||
|
default: |
||||||
|
i++ |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,225 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import "testing" |
||||||
|
|
||||||
|
func BenchmarkEWMA(b *testing.B) { |
||||||
|
a := NewEWMA1() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
a.Update(1) |
||||||
|
a.Tick() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestEWMA1(t *testing.T) { |
||||||
|
a := NewEWMA1() |
||||||
|
a.Update(3) |
||||||
|
a.Tick() |
||||||
|
if rate := a.Rate(); 0.6 != rate { |
||||||
|
t.Errorf("initial a.Rate(): 0.6 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.22072766470286553 != rate { |
||||||
|
t.Errorf("1 minute a.Rate(): 0.22072766470286553 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.08120116994196772 != rate { |
||||||
|
t.Errorf("2 minute a.Rate(): 0.08120116994196772 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.029872241020718428 != rate { |
||||||
|
t.Errorf("3 minute a.Rate(): 0.029872241020718428 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.01098938333324054 != rate { |
||||||
|
t.Errorf("4 minute a.Rate(): 0.01098938333324054 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.004042768199451294 != rate { |
||||||
|
t.Errorf("5 minute a.Rate(): 0.004042768199451294 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.0014872513059998212 != rate { |
||||||
|
t.Errorf("6 minute a.Rate(): 0.0014872513059998212 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.0005471291793327122 != rate { |
||||||
|
t.Errorf("7 minute a.Rate(): 0.0005471291793327122 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.00020127757674150815 != rate { |
||||||
|
t.Errorf("8 minute a.Rate(): 0.00020127757674150815 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 7.404588245200814e-05 != rate { |
||||||
|
t.Errorf("9 minute a.Rate(): 7.404588245200814e-05 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 2.7239957857491083e-05 != rate { |
||||||
|
t.Errorf("10 minute a.Rate(): 2.7239957857491083e-05 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 1.0021020474147462e-05 != rate { |
||||||
|
t.Errorf("11 minute a.Rate(): 1.0021020474147462e-05 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 3.6865274119969525e-06 != rate { |
||||||
|
t.Errorf("12 minute a.Rate(): 3.6865274119969525e-06 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 1.3561976441886433e-06 != rate { |
||||||
|
t.Errorf("13 minute a.Rate(): 1.3561976441886433e-06 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 4.989172314621449e-07 != rate { |
||||||
|
t.Errorf("14 minute a.Rate(): 4.989172314621449e-07 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 1.8354139230109722e-07 != rate { |
||||||
|
t.Errorf("15 minute a.Rate(): 1.8354139230109722e-07 != %v\n", rate) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestEWMA5(t *testing.T) { |
||||||
|
a := NewEWMA5() |
||||||
|
a.Update(3) |
||||||
|
a.Tick() |
||||||
|
if rate := a.Rate(); 0.6 != rate { |
||||||
|
t.Errorf("initial a.Rate(): 0.6 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.49123845184678905 != rate { |
||||||
|
t.Errorf("1 minute a.Rate(): 0.49123845184678905 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.4021920276213837 != rate { |
||||||
|
t.Errorf("2 minute a.Rate(): 0.4021920276213837 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.32928698165641596 != rate { |
||||||
|
t.Errorf("3 minute a.Rate(): 0.32928698165641596 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.269597378470333 != rate { |
||||||
|
t.Errorf("4 minute a.Rate(): 0.269597378470333 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.2207276647028654 != rate { |
||||||
|
t.Errorf("5 minute a.Rate(): 0.2207276647028654 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.18071652714732128 != rate { |
||||||
|
t.Errorf("6 minute a.Rate(): 0.18071652714732128 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.14795817836496392 != rate { |
||||||
|
t.Errorf("7 minute a.Rate(): 0.14795817836496392 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.12113791079679326 != rate { |
||||||
|
t.Errorf("8 minute a.Rate(): 0.12113791079679326 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.09917933293295193 != rate { |
||||||
|
t.Errorf("9 minute a.Rate(): 0.09917933293295193 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.08120116994196763 != rate { |
||||||
|
t.Errorf("10 minute a.Rate(): 0.08120116994196763 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.06648189501740036 != rate { |
||||||
|
t.Errorf("11 minute a.Rate(): 0.06648189501740036 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.05443077197364752 != rate { |
||||||
|
t.Errorf("12 minute a.Rate(): 0.05443077197364752 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.04456414692860035 != rate { |
||||||
|
t.Errorf("13 minute a.Rate(): 0.04456414692860035 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.03648603757513079 != rate { |
||||||
|
t.Errorf("14 minute a.Rate(): 0.03648603757513079 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.0298722410207183831020718428 != rate { |
||||||
|
t.Errorf("15 minute a.Rate(): 0.0298722410207183831020718428 != %v\n", rate) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestEWMA15(t *testing.T) { |
||||||
|
a := NewEWMA15() |
||||||
|
a.Update(3) |
||||||
|
a.Tick() |
||||||
|
if rate := a.Rate(); 0.6 != rate { |
||||||
|
t.Errorf("initial a.Rate(): 0.6 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.5613041910189706 != rate { |
||||||
|
t.Errorf("1 minute a.Rate(): 0.5613041910189706 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.5251039914257684 != rate { |
||||||
|
t.Errorf("2 minute a.Rate(): 0.5251039914257684 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.4912384518467888184678905 != rate { |
||||||
|
t.Errorf("3 minute a.Rate(): 0.4912384518467888184678905 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.459557003018789 != rate { |
||||||
|
t.Errorf("4 minute a.Rate(): 0.459557003018789 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.4299187863442732 != rate { |
||||||
|
t.Errorf("5 minute a.Rate(): 0.4299187863442732 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.4021920276213831 != rate { |
||||||
|
t.Errorf("6 minute a.Rate(): 0.4021920276213831 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.37625345116383313 != rate { |
||||||
|
t.Errorf("7 minute a.Rate(): 0.37625345116383313 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.3519877317060185 != rate { |
||||||
|
t.Errorf("8 minute a.Rate(): 0.3519877317060185 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.3292869816564153165641596 != rate { |
||||||
|
t.Errorf("9 minute a.Rate(): 0.3292869816564153165641596 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.3080502714195546 != rate { |
||||||
|
t.Errorf("10 minute a.Rate(): 0.3080502714195546 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.2881831806538789 != rate { |
||||||
|
t.Errorf("11 minute a.Rate(): 0.2881831806538789 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.26959737847033216 != rate { |
||||||
|
t.Errorf("12 minute a.Rate(): 0.26959737847033216 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.2522102307052083 != rate { |
||||||
|
t.Errorf("13 minute a.Rate(): 0.2522102307052083 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.23594443252115815 != rate { |
||||||
|
t.Errorf("14 minute a.Rate(): 0.23594443252115815 != %v\n", rate) |
||||||
|
} |
||||||
|
elapseMinute(a) |
||||||
|
if rate := a.Rate(); 0.2207276647028646247028654470286553 != rate { |
||||||
|
t.Errorf("15 minute a.Rate(): 0.2207276647028646247028654470286553 != %v\n", rate) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func elapseMinute(a EWMA) { |
||||||
|
for i := 0; i < 12; i++ { |
||||||
|
a.Tick() |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,59 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import "testing" |
||||||
|
|
||||||
|
func BenchmarkGuageFloat64(b *testing.B) { |
||||||
|
g := NewGaugeFloat64() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
g.Update(float64(i)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGaugeFloat64(t *testing.T) { |
||||||
|
g := NewGaugeFloat64() |
||||||
|
g.Update(float64(47.0)) |
||||||
|
if v := g.Value(); float64(47.0) != v { |
||||||
|
t.Errorf("g.Value(): 47.0 != %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGaugeFloat64Snapshot(t *testing.T) { |
||||||
|
g := NewGaugeFloat64() |
||||||
|
g.Update(float64(47.0)) |
||||||
|
snapshot := g.Snapshot() |
||||||
|
g.Update(float64(0)) |
||||||
|
if v := snapshot.Value(); float64(47.0) != v { |
||||||
|
t.Errorf("g.Value(): 47.0 != %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterGaugeFloat64(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredGaugeFloat64("foo", r).Update(float64(47.0)) |
||||||
|
t.Logf("registry: %v", r) |
||||||
|
if g := GetOrRegisterGaugeFloat64("foo", r); float64(47.0) != g.Value() { |
||||||
|
t.Fatal(g) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestFunctionalGaugeFloat64(t *testing.T) { |
||||||
|
var counter float64 |
||||||
|
fg := NewFunctionalGaugeFloat64(func() float64 { |
||||||
|
counter++ |
||||||
|
return counter |
||||||
|
}) |
||||||
|
fg.Value() |
||||||
|
fg.Value() |
||||||
|
if counter != 2 { |
||||||
|
t.Error("counter != 2") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterFunctionalGaugeFloat64(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredFunctionalGaugeFloat64("foo", r, func() float64 { return 47 }) |
||||||
|
if g := GetOrRegisterGaugeFloat64("foo", r); 47 != g.Value() { |
||||||
|
t.Fatal(g) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,68 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkGuage(b *testing.B) { |
||||||
|
g := NewGauge() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
g.Update(int64(i)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGauge(t *testing.T) { |
||||||
|
g := NewGauge() |
||||||
|
g.Update(int64(47)) |
||||||
|
if v := g.Value(); 47 != v { |
||||||
|
t.Errorf("g.Value(): 47 != %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGaugeSnapshot(t *testing.T) { |
||||||
|
g := NewGauge() |
||||||
|
g.Update(int64(47)) |
||||||
|
snapshot := g.Snapshot() |
||||||
|
g.Update(int64(0)) |
||||||
|
if v := snapshot.Value(); 47 != v { |
||||||
|
t.Errorf("g.Value(): 47 != %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterGauge(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredGauge("foo", r).Update(47) |
||||||
|
if g := GetOrRegisterGauge("foo", r); 47 != g.Value() { |
||||||
|
t.Fatal(g) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestFunctionalGauge(t *testing.T) { |
||||||
|
var counter int64 |
||||||
|
fg := NewFunctionalGauge(func() int64 { |
||||||
|
counter++ |
||||||
|
return counter |
||||||
|
}) |
||||||
|
fg.Value() |
||||||
|
fg.Value() |
||||||
|
if counter != 2 { |
||||||
|
t.Error("counter != 2") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterFunctionalGauge(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredFunctionalGauge("foo", r, func() int64 { return 47 }) |
||||||
|
if g := GetOrRegisterGauge("foo", r); 47 != g.Value() { |
||||||
|
t.Fatal(g) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func ExampleGetOrRegisterGauge() { |
||||||
|
m := "server.bytes_sent" |
||||||
|
g := GetOrRegisterGauge(m, nil) |
||||||
|
g.Update(47) |
||||||
|
fmt.Println(g.Value()) // Output: 47
|
||||||
|
} |
||||||
@ -0,0 +1,22 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"net" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func ExampleGraphite() { |
||||||
|
addr, _ := net.ResolveTCPAddr("net", ":2003") |
||||||
|
go Graphite(DefaultRegistry, 1*time.Second, "some.prefix", addr) |
||||||
|
} |
||||||
|
|
||||||
|
func ExampleGraphiteWithConfig() { |
||||||
|
addr, _ := net.ResolveTCPAddr("net", ":2003") |
||||||
|
go GraphiteWithConfig(GraphiteConfig{ |
||||||
|
Addr: addr, |
||||||
|
Registry: DefaultRegistry, |
||||||
|
FlushInterval: 1 * time.Second, |
||||||
|
DurationUnit: time.Millisecond, |
||||||
|
Percentiles: []float64{0.5, 0.75, 0.99, 0.999}, |
||||||
|
}) |
||||||
|
} |
||||||
@ -0,0 +1,95 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import "testing" |
||||||
|
|
||||||
|
func BenchmarkHistogram(b *testing.B) { |
||||||
|
h := NewHistogram(NewUniformSample(100)) |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
h.Update(int64(i)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterHistogram(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
s := NewUniformSample(100) |
||||||
|
NewRegisteredHistogram("foo", r, s).Update(47) |
||||||
|
if h := GetOrRegisterHistogram("foo", r, s); 1 != h.Count() { |
||||||
|
t.Fatal(h) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestHistogram10000(t *testing.T) { |
||||||
|
h := NewHistogram(NewUniformSample(100000)) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
h.Update(int64(i)) |
||||||
|
} |
||||||
|
testHistogram10000(t, h) |
||||||
|
} |
||||||
|
|
||||||
|
func TestHistogramEmpty(t *testing.T) { |
||||||
|
h := NewHistogram(NewUniformSample(100)) |
||||||
|
if count := h.Count(); 0 != count { |
||||||
|
t.Errorf("h.Count(): 0 != %v\n", count) |
||||||
|
} |
||||||
|
if min := h.Min(); 0 != min { |
||||||
|
t.Errorf("h.Min(): 0 != %v\n", min) |
||||||
|
} |
||||||
|
if max := h.Max(); 0 != max { |
||||||
|
t.Errorf("h.Max(): 0 != %v\n", max) |
||||||
|
} |
||||||
|
if mean := h.Mean(); 0.0 != mean { |
||||||
|
t.Errorf("h.Mean(): 0.0 != %v\n", mean) |
||||||
|
} |
||||||
|
if stdDev := h.StdDev(); 0.0 != stdDev { |
||||||
|
t.Errorf("h.StdDev(): 0.0 != %v\n", stdDev) |
||||||
|
} |
||||||
|
ps := h.Percentiles([]float64{0.5, 0.75, 0.99}) |
||||||
|
if 0.0 != ps[0] { |
||||||
|
t.Errorf("median: 0.0 != %v\n", ps[0]) |
||||||
|
} |
||||||
|
if 0.0 != ps[1] { |
||||||
|
t.Errorf("75th percentile: 0.0 != %v\n", ps[1]) |
||||||
|
} |
||||||
|
if 0.0 != ps[2] { |
||||||
|
t.Errorf("99th percentile: 0.0 != %v\n", ps[2]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestHistogramSnapshot(t *testing.T) { |
||||||
|
h := NewHistogram(NewUniformSample(100000)) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
h.Update(int64(i)) |
||||||
|
} |
||||||
|
snapshot := h.Snapshot() |
||||||
|
h.Update(0) |
||||||
|
testHistogram10000(t, snapshot) |
||||||
|
} |
||||||
|
|
||||||
|
func testHistogram10000(t *testing.T, h Histogram) { |
||||||
|
if count := h.Count(); 10000 != count { |
||||||
|
t.Errorf("h.Count(): 10000 != %v\n", count) |
||||||
|
} |
||||||
|
if min := h.Min(); 1 != min { |
||||||
|
t.Errorf("h.Min(): 1 != %v\n", min) |
||||||
|
} |
||||||
|
if max := h.Max(); 10000 != max { |
||||||
|
t.Errorf("h.Max(): 10000 != %v\n", max) |
||||||
|
} |
||||||
|
if mean := h.Mean(); 5000.5 != mean { |
||||||
|
t.Errorf("h.Mean(): 5000.5 != %v\n", mean) |
||||||
|
} |
||||||
|
if stdDev := h.StdDev(); 2886.751331514372 != stdDev { |
||||||
|
t.Errorf("h.StdDev(): 2886.751331514372 != %v\n", stdDev) |
||||||
|
} |
||||||
|
ps := h.Percentiles([]float64{0.5, 0.75, 0.99}) |
||||||
|
if 5000.5 != ps[0] { |
||||||
|
t.Errorf("median: 5000.5 != %v\n", ps[0]) |
||||||
|
} |
||||||
|
if 7500.75 != ps[1] { |
||||||
|
t.Errorf("75th percentile: 7500.75 != %v\n", ps[1]) |
||||||
|
} |
||||||
|
if 9900.99 != ps[2] { |
||||||
|
t.Errorf("99th percentile: 9900.99 != %v\n", ps[2]) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,19 @@ |
|||||||
|
Copyright (c) 2015 Vincent Rischmann |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
of this software and associated documentation files (the "Software"), to deal |
||||||
|
in the Software without restriction, including without limitation the rights |
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
copies of the Software, and to permit persons to whom the Software is |
||||||
|
furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in |
||||||
|
all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||||
|
THE SOFTWARE. |
||||||
@ -0,0 +1,30 @@ |
|||||||
|
go-metrics-influxdb |
||||||
|
=================== |
||||||
|
|
||||||
|
This is a reporter for the [go-metrics](https://github.com/rcrowley/go-metrics) library which will post the metrics to [InfluxDB](https://influxdb.com/). |
||||||
|
|
||||||
|
Note |
||||||
|
---- |
||||||
|
|
||||||
|
This is only compatible with InfluxDB 0.9+. |
||||||
|
|
||||||
|
Usage |
||||||
|
----- |
||||||
|
|
||||||
|
```go |
||||||
|
import "github.com/vrischmann/go-metrics-influxdb" |
||||||
|
|
||||||
|
go influxdb.InfluxDB( |
||||||
|
metrics.DefaultRegistry, // metrics registry |
||||||
|
time.Second * 10, // interval |
||||||
|
"http://localhost:8086", // the InfluxDB url |
||||||
|
"mydb", // your InfluxDB database |
||||||
|
"myuser", // your InfluxDB user |
||||||
|
"mypassword", // your InfluxDB password |
||||||
|
) |
||||||
|
``` |
||||||
|
|
||||||
|
License |
||||||
|
------- |
||||||
|
|
||||||
|
go-metrics-influxdb is licensed under the MIT license. See the LICENSE file for details. |
||||||
@ -0,0 +1,227 @@ |
|||||||
|
package influxdb |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"log" |
||||||
|
uurl "net/url" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/metrics" |
||||||
|
"github.com/influxdata/influxdb/client" |
||||||
|
) |
||||||
|
|
||||||
|
type reporter struct { |
||||||
|
reg metrics.Registry |
||||||
|
interval time.Duration |
||||||
|
|
||||||
|
url uurl.URL |
||||||
|
database string |
||||||
|
username string |
||||||
|
password string |
||||||
|
namespace string |
||||||
|
tags map[string]string |
||||||
|
|
||||||
|
client *client.Client |
||||||
|
|
||||||
|
cache map[string]int64 |
||||||
|
} |
||||||
|
|
||||||
|
// InfluxDB starts a InfluxDB reporter which will post the from the given metrics.Registry at each d interval.
|
||||||
|
func InfluxDB(r metrics.Registry, d time.Duration, url, database, username, password, namespace string) { |
||||||
|
InfluxDBWithTags(r, d, url, database, username, password, namespace, nil) |
||||||
|
} |
||||||
|
|
||||||
|
// InfluxDBWithTags starts a InfluxDB reporter which will post the from the given metrics.Registry at each d interval with the specified tags
|
||||||
|
func InfluxDBWithTags(r metrics.Registry, d time.Duration, url, database, username, password, namespace string, tags map[string]string) { |
||||||
|
u, err := uurl.Parse(url) |
||||||
|
if err != nil { |
||||||
|
log.Printf("unable to parse InfluxDB url %s. err=%v", url, err) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
rep := &reporter{ |
||||||
|
reg: r, |
||||||
|
interval: d, |
||||||
|
url: *u, |
||||||
|
database: database, |
||||||
|
username: username, |
||||||
|
password: password, |
||||||
|
namespace: namespace, |
||||||
|
tags: tags, |
||||||
|
cache: make(map[string]int64), |
||||||
|
} |
||||||
|
if err := rep.makeClient(); err != nil { |
||||||
|
log.Printf("unable to make InfluxDB client. err=%v", err) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
rep.run() |
||||||
|
} |
||||||
|
|
||||||
|
func (r *reporter) makeClient() (err error) { |
||||||
|
r.client, err = client.NewClient(client.Config{ |
||||||
|
URL: r.url, |
||||||
|
Username: r.username, |
||||||
|
Password: r.password, |
||||||
|
}) |
||||||
|
|
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (r *reporter) run() { |
||||||
|
intervalTicker := time.Tick(r.interval) |
||||||
|
pingTicker := time.Tick(time.Second * 5) |
||||||
|
|
||||||
|
for { |
||||||
|
select { |
||||||
|
case <-intervalTicker: |
||||||
|
if err := r.send(); err != nil { |
||||||
|
log.Printf("unable to send to InfluxDB. err=%v", err) |
||||||
|
} |
||||||
|
case <-pingTicker: |
||||||
|
_, _, err := r.client.Ping() |
||||||
|
if err != nil { |
||||||
|
log.Printf("got error while sending a ping to InfluxDB, trying to recreate client. err=%v", err) |
||||||
|
|
||||||
|
if err = r.makeClient(); err != nil { |
||||||
|
log.Printf("unable to make InfluxDB client. err=%v", err) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (r *reporter) send() error { |
||||||
|
var pts []client.Point |
||||||
|
|
||||||
|
r.reg.Each(func(name string, i interface{}) { |
||||||
|
now := time.Now() |
||||||
|
namespace := r.namespace |
||||||
|
|
||||||
|
switch metric := i.(type) { |
||||||
|
case metrics.Counter: |
||||||
|
v := metric.Count() |
||||||
|
l := r.cache[name] |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.count", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"value": v - l, |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
r.cache[name] = v |
||||||
|
case metrics.Gauge: |
||||||
|
ms := metric.Snapshot() |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.gauge", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"value": ms.Value(), |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
case metrics.GaugeFloat64: |
||||||
|
ms := metric.Snapshot() |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.gauge", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"value": ms.Value(), |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
case metrics.Histogram: |
||||||
|
ms := metric.Snapshot() |
||||||
|
ps := ms.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999, 0.9999}) |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.histogram", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"count": ms.Count(), |
||||||
|
"max": ms.Max(), |
||||||
|
"mean": ms.Mean(), |
||||||
|
"min": ms.Min(), |
||||||
|
"stddev": ms.StdDev(), |
||||||
|
"variance": ms.Variance(), |
||||||
|
"p50": ps[0], |
||||||
|
"p75": ps[1], |
||||||
|
"p95": ps[2], |
||||||
|
"p99": ps[3], |
||||||
|
"p999": ps[4], |
||||||
|
"p9999": ps[5], |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
case metrics.Meter: |
||||||
|
ms := metric.Snapshot() |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.meter", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"count": ms.Count(), |
||||||
|
"m1": ms.Rate1(), |
||||||
|
"m5": ms.Rate5(), |
||||||
|
"m15": ms.Rate15(), |
||||||
|
"mean": ms.RateMean(), |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
case metrics.Timer: |
||||||
|
ms := metric.Snapshot() |
||||||
|
ps := ms.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999, 0.9999}) |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.timer", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"count": ms.Count(), |
||||||
|
"max": ms.Max(), |
||||||
|
"mean": ms.Mean(), |
||||||
|
"min": ms.Min(), |
||||||
|
"stddev": ms.StdDev(), |
||||||
|
"variance": ms.Variance(), |
||||||
|
"p50": ps[0], |
||||||
|
"p75": ps[1], |
||||||
|
"p95": ps[2], |
||||||
|
"p99": ps[3], |
||||||
|
"p999": ps[4], |
||||||
|
"p9999": ps[5], |
||||||
|
"m1": ms.Rate1(), |
||||||
|
"m5": ms.Rate5(), |
||||||
|
"m15": ms.Rate15(), |
||||||
|
"meanrate": ms.RateMean(), |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
case metrics.ResettingTimer: |
||||||
|
t := metric.Snapshot() |
||||||
|
|
||||||
|
if len(t.Values()) > 0 { |
||||||
|
ps := t.Percentiles([]float64{50, 95, 99}) |
||||||
|
val := t.Values() |
||||||
|
pts = append(pts, client.Point{ |
||||||
|
Measurement: fmt.Sprintf("%s%s.span", namespace, name), |
||||||
|
Tags: r.tags, |
||||||
|
Fields: map[string]interface{}{ |
||||||
|
"count": len(val), |
||||||
|
"max": val[len(val)-1], |
||||||
|
"mean": t.Mean(), |
||||||
|
"min": val[0], |
||||||
|
"p50": ps[0], |
||||||
|
"p95": ps[1], |
||||||
|
"p99": ps[2], |
||||||
|
}, |
||||||
|
Time: now, |
||||||
|
}) |
||||||
|
} |
||||||
|
} |
||||||
|
}) |
||||||
|
|
||||||
|
bps := client.BatchPoints{ |
||||||
|
Points: pts, |
||||||
|
Database: r.database, |
||||||
|
} |
||||||
|
|
||||||
|
_, err := r.client.Write(bps) |
||||||
|
return err |
||||||
|
} |
||||||
@ -0,0 +1,5 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
func init() { |
||||||
|
Enabled = true |
||||||
|
} |
||||||
@ -0,0 +1,31 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"encoding/json" |
||||||
|
"io" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
// MarshalJSON returns a byte slice containing a JSON representation of all
|
||||||
|
// the metrics in the Registry.
|
||||||
|
func (r *StandardRegistry) MarshalJSON() ([]byte, error) { |
||||||
|
return json.Marshal(r.GetAll()) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteJSON writes metrics from the given registry periodically to the
|
||||||
|
// specified io.Writer as JSON.
|
||||||
|
func WriteJSON(r Registry, d time.Duration, w io.Writer) { |
||||||
|
for range time.Tick(d) { |
||||||
|
WriteJSONOnce(r, w) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// WriteJSONOnce writes metrics from the given registry to the specified
|
||||||
|
// io.Writer as JSON.
|
||||||
|
func WriteJSONOnce(r Registry, w io.Writer) { |
||||||
|
json.NewEncoder(w).Encode(r) |
||||||
|
} |
||||||
|
|
||||||
|
func (p *PrefixedRegistry) MarshalJSON() ([]byte, error) { |
||||||
|
return json.Marshal(p.GetAll()) |
||||||
|
} |
||||||
@ -0,0 +1,28 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/json" |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
func TestRegistryMarshallJSON(t *testing.T) { |
||||||
|
b := &bytes.Buffer{} |
||||||
|
enc := json.NewEncoder(b) |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("counter", NewCounter()) |
||||||
|
enc.Encode(r) |
||||||
|
if s := b.String(); "{\"counter\":{\"count\":0}}\n" != s { |
||||||
|
t.Fatalf(s) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryWriteJSONOnce(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("counter", NewCounter()) |
||||||
|
b := &bytes.Buffer{} |
||||||
|
WriteJSONOnce(r, b) |
||||||
|
if s := b.String(); s != "{\"counter\":{\"count\":0}}\n" { |
||||||
|
t.Fail() |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,102 @@ |
|||||||
|
package librato |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/json" |
||||||
|
"fmt" |
||||||
|
"io/ioutil" |
||||||
|
"net/http" |
||||||
|
) |
||||||
|
|
||||||
|
const Operations = "operations" |
||||||
|
const OperationsShort = "ops" |
||||||
|
|
||||||
|
type LibratoClient struct { |
||||||
|
Email, Token string |
||||||
|
} |
||||||
|
|
||||||
|
// property strings
|
||||||
|
const ( |
||||||
|
// display attributes
|
||||||
|
Color = "color" |
||||||
|
DisplayMax = "display_max" |
||||||
|
DisplayMin = "display_min" |
||||||
|
DisplayUnitsLong = "display_units_long" |
||||||
|
DisplayUnitsShort = "display_units_short" |
||||||
|
DisplayStacked = "display_stacked" |
||||||
|
DisplayTransform = "display_transform" |
||||||
|
// special gauge display attributes
|
||||||
|
SummarizeFunction = "summarize_function" |
||||||
|
Aggregate = "aggregate" |
||||||
|
|
||||||
|
// metric keys
|
||||||
|
Name = "name" |
||||||
|
Period = "period" |
||||||
|
Description = "description" |
||||||
|
DisplayName = "display_name" |
||||||
|
Attributes = "attributes" |
||||||
|
|
||||||
|
// measurement keys
|
||||||
|
MeasureTime = "measure_time" |
||||||
|
Source = "source" |
||||||
|
Value = "value" |
||||||
|
|
||||||
|
// special gauge keys
|
||||||
|
Count = "count" |
||||||
|
Sum = "sum" |
||||||
|
Max = "max" |
||||||
|
Min = "min" |
||||||
|
SumSquares = "sum_squares" |
||||||
|
|
||||||
|
// batch keys
|
||||||
|
Counters = "counters" |
||||||
|
Gauges = "gauges" |
||||||
|
|
||||||
|
MetricsPostUrl = "https://metrics-api.librato.com/v1/metrics" |
||||||
|
) |
||||||
|
|
||||||
|
type Measurement map[string]interface{} |
||||||
|
type Metric map[string]interface{} |
||||||
|
|
||||||
|
type Batch struct { |
||||||
|
Gauges []Measurement `json:"gauges,omitempty"` |
||||||
|
Counters []Measurement `json:"counters,omitempty"` |
||||||
|
MeasureTime int64 `json:"measure_time"` |
||||||
|
Source string `json:"source"` |
||||||
|
} |
||||||
|
|
||||||
|
func (self *LibratoClient) PostMetrics(batch Batch) (err error) { |
||||||
|
var ( |
||||||
|
js []byte |
||||||
|
req *http.Request |
||||||
|
resp *http.Response |
||||||
|
) |
||||||
|
|
||||||
|
if len(batch.Counters) == 0 && len(batch.Gauges) == 0 { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
if js, err = json.Marshal(batch); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
if req, err = http.NewRequest("POST", MetricsPostUrl, bytes.NewBuffer(js)); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
req.Header.Set("Content-Type", "application/json") |
||||||
|
req.SetBasicAuth(self.Email, self.Token) |
||||||
|
|
||||||
|
if resp, err = http.DefaultClient.Do(req); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
if resp.StatusCode != http.StatusOK { |
||||||
|
var body []byte |
||||||
|
if body, err = ioutil.ReadAll(resp.Body); err != nil { |
||||||
|
body = []byte(fmt.Sprintf("(could not fetch response body for error: %s)", err)) |
||||||
|
} |
||||||
|
err = fmt.Errorf("Unable to post to Librato: %d %s %s", resp.StatusCode, resp.Status, string(body)) |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,235 @@ |
|||||||
|
package librato |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"log" |
||||||
|
"math" |
||||||
|
"regexp" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/metrics" |
||||||
|
) |
||||||
|
|
||||||
|
// a regexp for extracting the unit from time.Duration.String
|
||||||
|
var unitRegexp = regexp.MustCompile(`[^\\d]+$`) |
||||||
|
|
||||||
|
// a helper that turns a time.Duration into librato display attributes for timer metrics
|
||||||
|
func translateTimerAttributes(d time.Duration) (attrs map[string]interface{}) { |
||||||
|
attrs = make(map[string]interface{}) |
||||||
|
attrs[DisplayTransform] = fmt.Sprintf("x/%d", int64(d)) |
||||||
|
attrs[DisplayUnitsShort] = string(unitRegexp.Find([]byte(d.String()))) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
type Reporter struct { |
||||||
|
Email, Token string |
||||||
|
Namespace string |
||||||
|
Source string |
||||||
|
Interval time.Duration |
||||||
|
Registry metrics.Registry |
||||||
|
Percentiles []float64 // percentiles to report on histogram metrics
|
||||||
|
TimerAttributes map[string]interface{} // units in which timers will be displayed
|
||||||
|
intervalSec int64 |
||||||
|
} |
||||||
|
|
||||||
|
func NewReporter(r metrics.Registry, d time.Duration, e string, t string, s string, p []float64, u time.Duration) *Reporter { |
||||||
|
return &Reporter{e, t, "", s, d, r, p, translateTimerAttributes(u), int64(d / time.Second)} |
||||||
|
} |
||||||
|
|
||||||
|
func Librato(r metrics.Registry, d time.Duration, e string, t string, s string, p []float64, u time.Duration) { |
||||||
|
NewReporter(r, d, e, t, s, p, u).Run() |
||||||
|
} |
||||||
|
|
||||||
|
func (self *Reporter) Run() { |
||||||
|
log.Printf("WARNING: This client has been DEPRECATED! It has been moved to https://github.com/mihasya/go-metrics-librato and will be removed from rcrowley/go-metrics on August 5th 2015") |
||||||
|
ticker := time.Tick(self.Interval) |
||||||
|
metricsApi := &LibratoClient{self.Email, self.Token} |
||||||
|
for now := range ticker { |
||||||
|
var metrics Batch |
||||||
|
var err error |
||||||
|
if metrics, err = self.BuildRequest(now, self.Registry); err != nil { |
||||||
|
log.Printf("ERROR constructing librato request body %s", err) |
||||||
|
continue |
||||||
|
} |
||||||
|
if err := metricsApi.PostMetrics(metrics); err != nil { |
||||||
|
log.Printf("ERROR sending metrics to librato %s", err) |
||||||
|
continue |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// calculate sum of squares from data provided by metrics.Histogram
|
||||||
|
// see http://en.wikipedia.org/wiki/Standard_deviation#Rapid_calculation_methods
|
||||||
|
func sumSquares(s metrics.Sample) float64 { |
||||||
|
count := float64(s.Count()) |
||||||
|
sumSquared := math.Pow(count*s.Mean(), 2) |
||||||
|
sumSquares := math.Pow(count*s.StdDev(), 2) + sumSquared/count |
||||||
|
if math.IsNaN(sumSquares) { |
||||||
|
return 0.0 |
||||||
|
} |
||||||
|
return sumSquares |
||||||
|
} |
||||||
|
func sumSquaresTimer(t metrics.Timer) float64 { |
||||||
|
count := float64(t.Count()) |
||||||
|
sumSquared := math.Pow(count*t.Mean(), 2) |
||||||
|
sumSquares := math.Pow(count*t.StdDev(), 2) + sumSquared/count |
||||||
|
if math.IsNaN(sumSquares) { |
||||||
|
return 0.0 |
||||||
|
} |
||||||
|
return sumSquares |
||||||
|
} |
||||||
|
|
||||||
|
func (self *Reporter) BuildRequest(now time.Time, r metrics.Registry) (snapshot Batch, err error) { |
||||||
|
snapshot = Batch{ |
||||||
|
// coerce timestamps to a stepping fn so that they line up in Librato graphs
|
||||||
|
MeasureTime: (now.Unix() / self.intervalSec) * self.intervalSec, |
||||||
|
Source: self.Source, |
||||||
|
} |
||||||
|
snapshot.Gauges = make([]Measurement, 0) |
||||||
|
snapshot.Counters = make([]Measurement, 0) |
||||||
|
histogramGaugeCount := 1 + len(self.Percentiles) |
||||||
|
r.Each(func(name string, metric interface{}) { |
||||||
|
if self.Namespace != "" { |
||||||
|
name = fmt.Sprintf("%s.%s", self.Namespace, name) |
||||||
|
} |
||||||
|
measurement := Measurement{} |
||||||
|
measurement[Period] = self.Interval.Seconds() |
||||||
|
switch m := metric.(type) { |
||||||
|
case metrics.Counter: |
||||||
|
if m.Count() > 0 { |
||||||
|
measurement[Name] = fmt.Sprintf("%s.%s", name, "count") |
||||||
|
measurement[Value] = float64(m.Count()) |
||||||
|
measurement[Attributes] = map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
} |
||||||
|
snapshot.Counters = append(snapshot.Counters, measurement) |
||||||
|
} |
||||||
|
case metrics.Gauge: |
||||||
|
measurement[Name] = name |
||||||
|
measurement[Value] = float64(m.Value()) |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, measurement) |
||||||
|
case metrics.GaugeFloat64: |
||||||
|
measurement[Name] = name |
||||||
|
measurement[Value] = m.Value() |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, measurement) |
||||||
|
case metrics.Histogram: |
||||||
|
if m.Count() > 0 { |
||||||
|
gauges := make([]Measurement, histogramGaugeCount) |
||||||
|
s := m.Sample() |
||||||
|
measurement[Name] = fmt.Sprintf("%s.%s", name, "hist") |
||||||
|
measurement[Count] = uint64(s.Count()) |
||||||
|
measurement[Max] = float64(s.Max()) |
||||||
|
measurement[Min] = float64(s.Min()) |
||||||
|
measurement[Sum] = float64(s.Sum()) |
||||||
|
measurement[SumSquares] = sumSquares(s) |
||||||
|
gauges[0] = measurement |
||||||
|
for i, p := range self.Percentiles { |
||||||
|
gauges[i+1] = Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%.2f", measurement[Name], p), |
||||||
|
Value: s.Percentile(p), |
||||||
|
Period: measurement[Period], |
||||||
|
} |
||||||
|
} |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, gauges...) |
||||||
|
} |
||||||
|
case metrics.Meter: |
||||||
|
measurement[Name] = name |
||||||
|
measurement[Value] = float64(m.Count()) |
||||||
|
snapshot.Counters = append(snapshot.Counters, measurement) |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "1min"), |
||||||
|
Value: m.Rate1(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "5min"), |
||||||
|
Value: m.Rate5(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "15min"), |
||||||
|
Value: m.Rate15(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
) |
||||||
|
case metrics.Timer: |
||||||
|
measurement[Name] = name |
||||||
|
measurement[Value] = float64(m.Count()) |
||||||
|
snapshot.Counters = append(snapshot.Counters, measurement) |
||||||
|
if m.Count() > 0 { |
||||||
|
libratoName := fmt.Sprintf("%s.%s", name, "timer.mean") |
||||||
|
gauges := make([]Measurement, histogramGaugeCount) |
||||||
|
gauges[0] = Measurement{ |
||||||
|
Name: libratoName, |
||||||
|
Count: uint64(m.Count()), |
||||||
|
Sum: m.Mean() * float64(m.Count()), |
||||||
|
Max: float64(m.Max()), |
||||||
|
Min: float64(m.Min()), |
||||||
|
SumSquares: sumSquaresTimer(m), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: self.TimerAttributes, |
||||||
|
} |
||||||
|
for i, p := range self.Percentiles { |
||||||
|
gauges[i+1] = Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.timer.%2.0f", name, p*100), |
||||||
|
Value: m.Percentile(p), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: self.TimerAttributes, |
||||||
|
} |
||||||
|
} |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, gauges...) |
||||||
|
snapshot.Gauges = append(snapshot.Gauges, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "rate.1min"), |
||||||
|
Value: m.Rate1(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "rate.5min"), |
||||||
|
Value: m.Rate5(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
Measurement{ |
||||||
|
Name: fmt.Sprintf("%s.%s", name, "rate.15min"), |
||||||
|
Value: m.Rate15(), |
||||||
|
Period: int64(self.Interval.Seconds()), |
||||||
|
Attributes: map[string]interface{}{ |
||||||
|
DisplayUnitsLong: Operations, |
||||||
|
DisplayUnitsShort: OperationsShort, |
||||||
|
DisplayMin: "0", |
||||||
|
}, |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
}) |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,73 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkMeter(b *testing.B) { |
||||||
|
m := NewMeter() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
m.Mark(1) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterMeter(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredMeter("foo", r).Mark(47) |
||||||
|
if m := GetOrRegisterMeter("foo", r); 47 != m.Count() { |
||||||
|
t.Fatal(m) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestMeterDecay(t *testing.T) { |
||||||
|
ma := meterArbiter{ |
||||||
|
ticker: time.NewTicker(time.Millisecond), |
||||||
|
meters: make(map[*StandardMeter]struct{}), |
||||||
|
} |
||||||
|
m := newStandardMeter() |
||||||
|
ma.meters[m] = struct{}{} |
||||||
|
go ma.tick() |
||||||
|
m.Mark(1) |
||||||
|
rateMean := m.RateMean() |
||||||
|
time.Sleep(100 * time.Millisecond) |
||||||
|
if m.RateMean() >= rateMean { |
||||||
|
t.Error("m.RateMean() didn't decrease") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestMeterNonzero(t *testing.T) { |
||||||
|
m := NewMeter() |
||||||
|
m.Mark(3) |
||||||
|
if count := m.Count(); 3 != count { |
||||||
|
t.Errorf("m.Count(): 3 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestMeterStop(t *testing.T) { |
||||||
|
l := len(arbiter.meters) |
||||||
|
m := NewMeter() |
||||||
|
if len(arbiter.meters) != l+1 { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l+1, len(arbiter.meters)) |
||||||
|
} |
||||||
|
m.Stop() |
||||||
|
if len(arbiter.meters) != l { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l, len(arbiter.meters)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestMeterSnapshot(t *testing.T) { |
||||||
|
m := NewMeter() |
||||||
|
m.Mark(1) |
||||||
|
if snapshot := m.Snapshot(); m.RateMean() != snapshot.RateMean() { |
||||||
|
t.Fatal(snapshot) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestMeterZero(t *testing.T) { |
||||||
|
m := NewMeter() |
||||||
|
if count := m.Count(); 0 != count { |
||||||
|
t.Errorf("m.Count(): 0 != %v\n", count) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,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
|
||||||
|
} |
||||||
@ -0,0 +1,21 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"net" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func ExampleOpenTSDB() { |
||||||
|
addr, _ := net.ResolveTCPAddr("net", ":2003") |
||||||
|
go OpenTSDB(DefaultRegistry, 1*time.Second, "some.prefix", addr) |
||||||
|
} |
||||||
|
|
||||||
|
func ExampleOpenTSDBWithConfig() { |
||||||
|
addr, _ := net.ResolveTCPAddr("net", ":2003") |
||||||
|
go OpenTSDBWithConfig(OpenTSDBConfig{ |
||||||
|
Addr: addr, |
||||||
|
Registry: DefaultRegistry, |
||||||
|
FlushInterval: 1 * time.Second, |
||||||
|
DurationUnit: time.Millisecond, |
||||||
|
}) |
||||||
|
} |
||||||
@ -0,0 +1,305 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkRegistry(b *testing.B) { |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("foo", NewCounter()) |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
r.Each(func(string, interface{}) {}) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistry(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("foo", NewCounter()) |
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, iface interface{}) { |
||||||
|
i++ |
||||||
|
if "foo" != name { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
if _, ok := iface.(Counter); !ok { |
||||||
|
t.Fatal(iface) |
||||||
|
} |
||||||
|
}) |
||||||
|
if 1 != i { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
r.Unregister("foo") |
||||||
|
i = 0 |
||||||
|
r.Each(func(string, interface{}) { i++ }) |
||||||
|
if 0 != i { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryDuplicate(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
if err := r.Register("foo", NewCounter()); nil != err { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
if err := r.Register("foo", NewGauge()); nil == err { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, iface interface{}) { |
||||||
|
i++ |
||||||
|
if _, ok := iface.(Counter); !ok { |
||||||
|
t.Fatal(iface) |
||||||
|
} |
||||||
|
}) |
||||||
|
if 1 != i { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryGet(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("foo", NewCounter()) |
||||||
|
if count := r.Get("foo").(Counter).Count(); 0 != count { |
||||||
|
t.Fatal(count) |
||||||
|
} |
||||||
|
r.Get("foo").(Counter).Inc(1) |
||||||
|
if count := r.Get("foo").(Counter).Count(); 1 != count { |
||||||
|
t.Fatal(count) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryGetOrRegister(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
|
||||||
|
// First metric wins with GetOrRegister
|
||||||
|
_ = r.GetOrRegister("foo", NewCounter()) |
||||||
|
m := r.GetOrRegister("foo", NewGauge()) |
||||||
|
if _, ok := m.(Counter); !ok { |
||||||
|
t.Fatal(m) |
||||||
|
} |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, iface interface{}) { |
||||||
|
i++ |
||||||
|
if name != "foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
if _, ok := iface.(Counter); !ok { |
||||||
|
t.Fatal(iface) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryGetOrRegisterWithLazyInstantiation(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
|
||||||
|
// First metric wins with GetOrRegister
|
||||||
|
_ = r.GetOrRegister("foo", NewCounter) |
||||||
|
m := r.GetOrRegister("foo", NewGauge) |
||||||
|
if _, ok := m.(Counter); !ok { |
||||||
|
t.Fatal(m) |
||||||
|
} |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, iface interface{}) { |
||||||
|
i++ |
||||||
|
if name != "foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
if _, ok := iface.(Counter); !ok { |
||||||
|
t.Fatal(iface) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRegistryUnregister(t *testing.T) { |
||||||
|
l := len(arbiter.meters) |
||||||
|
r := NewRegistry() |
||||||
|
r.Register("foo", NewCounter()) |
||||||
|
r.Register("bar", NewMeter()) |
||||||
|
r.Register("baz", NewTimer()) |
||||||
|
if len(arbiter.meters) != l+2 { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l+2, len(arbiter.meters)) |
||||||
|
} |
||||||
|
r.Unregister("foo") |
||||||
|
r.Unregister("bar") |
||||||
|
r.Unregister("baz") |
||||||
|
if len(arbiter.meters) != l { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l+2, len(arbiter.meters)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedChildRegistryGetOrRegister(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
pr := NewPrefixedChildRegistry(r, "prefix.") |
||||||
|
|
||||||
|
_ = pr.GetOrRegister("foo", NewCounter()) |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedRegistryGetOrRegister(t *testing.T) { |
||||||
|
r := NewPrefixedRegistry("prefix.") |
||||||
|
|
||||||
|
_ = r.GetOrRegister("foo", NewCounter()) |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedRegistryRegister(t *testing.T) { |
||||||
|
r := NewPrefixedRegistry("prefix.") |
||||||
|
err := r.Register("foo", NewCounter()) |
||||||
|
c := NewCounter() |
||||||
|
Register("bar", c) |
||||||
|
if err != nil { |
||||||
|
t.Fatal(err.Error()) |
||||||
|
} |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedRegistryUnregister(t *testing.T) { |
||||||
|
r := NewPrefixedRegistry("prefix.") |
||||||
|
|
||||||
|
_ = r.Register("foo", NewCounter()) |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
|
||||||
|
r.Unregister("foo") |
||||||
|
|
||||||
|
i = 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
}) |
||||||
|
|
||||||
|
if i != 0 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedRegistryGet(t *testing.T) { |
||||||
|
pr := NewPrefixedRegistry("prefix.") |
||||||
|
name := "foo" |
||||||
|
pr.Register(name, NewCounter()) |
||||||
|
|
||||||
|
fooCounter := pr.Get(name) |
||||||
|
if fooCounter == nil { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestPrefixedChildRegistryGet(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
pr := NewPrefixedChildRegistry(r, "prefix.") |
||||||
|
name := "foo" |
||||||
|
pr.Register(name, NewCounter()) |
||||||
|
fooCounter := pr.Get(name) |
||||||
|
if fooCounter == nil { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestChildPrefixedRegistryRegister(t *testing.T) { |
||||||
|
r := NewPrefixedChildRegistry(DefaultRegistry, "prefix.") |
||||||
|
err := r.Register("foo", NewCounter()) |
||||||
|
c := NewCounter() |
||||||
|
Register("bar", c) |
||||||
|
if err != nil { |
||||||
|
t.Fatal(err.Error()) |
||||||
|
} |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.foo" { |
||||||
|
t.Fatal(name) |
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestChildPrefixedRegistryOfChildRegister(t *testing.T) { |
||||||
|
r := NewPrefixedChildRegistry(NewRegistry(), "prefix.") |
||||||
|
r2 := NewPrefixedChildRegistry(r, "prefix2.") |
||||||
|
err := r.Register("foo2", NewCounter()) |
||||||
|
if err != nil { |
||||||
|
t.Fatal(err.Error()) |
||||||
|
} |
||||||
|
err = r2.Register("baz", NewCounter()) |
||||||
|
c := NewCounter() |
||||||
|
Register("bars", c) |
||||||
|
|
||||||
|
i := 0 |
||||||
|
r2.Each(func(name string, m interface{}) { |
||||||
|
i++ |
||||||
|
if name != "prefix.prefix2.baz" { |
||||||
|
//t.Fatal(name)
|
||||||
|
} |
||||||
|
}) |
||||||
|
if i != 1 { |
||||||
|
t.Fatal(i) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestWalkRegistries(t *testing.T) { |
||||||
|
r := NewPrefixedChildRegistry(NewRegistry(), "prefix.") |
||||||
|
r2 := NewPrefixedChildRegistry(r, "prefix2.") |
||||||
|
err := r.Register("foo2", NewCounter()) |
||||||
|
if err != nil { |
||||||
|
t.Fatal(err.Error()) |
||||||
|
} |
||||||
|
err = r2.Register("baz", NewCounter()) |
||||||
|
c := NewCounter() |
||||||
|
Register("bars", c) |
||||||
|
|
||||||
|
_, prefix := findPrefix(r2, "") |
||||||
|
if "prefix.prefix2." != prefix { |
||||||
|
t.Fatal(prefix) |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
@ -0,0 +1,237 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"math" |
||||||
|
"sort" |
||||||
|
"sync" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
// Initial slice capacity for the values stored in a ResettingTimer
|
||||||
|
const InitialResettingTimerSliceCap = 10 |
||||||
|
|
||||||
|
// ResettingTimer is used for storing aggregated values for timers, which are reset on every flush interval.
|
||||||
|
type ResettingTimer interface { |
||||||
|
Values() []int64 |
||||||
|
Snapshot() ResettingTimer |
||||||
|
Percentiles([]float64) []int64 |
||||||
|
Mean() float64 |
||||||
|
Time(func()) |
||||||
|
Update(time.Duration) |
||||||
|
UpdateSince(time.Time) |
||||||
|
} |
||||||
|
|
||||||
|
// GetOrRegisterResettingTimer returns an existing ResettingTimer or constructs and registers a
|
||||||
|
// new StandardResettingTimer.
|
||||||
|
func GetOrRegisterResettingTimer(name string, r Registry) ResettingTimer { |
||||||
|
if nil == r { |
||||||
|
r = DefaultRegistry |
||||||
|
} |
||||||
|
return r.GetOrRegister(name, NewResettingTimer).(ResettingTimer) |
||||||
|
} |
||||||
|
|
||||||
|
// NewRegisteredResettingTimer constructs and registers a new StandardResettingTimer.
|
||||||
|
func NewRegisteredResettingTimer(name string, r Registry) ResettingTimer { |
||||||
|
c := NewResettingTimer() |
||||||
|
if nil == r { |
||||||
|
r = DefaultRegistry |
||||||
|
} |
||||||
|
r.Register(name, c) |
||||||
|
return c |
||||||
|
} |
||||||
|
|
||||||
|
// NewResettingTimer constructs a new StandardResettingTimer
|
||||||
|
func NewResettingTimer() ResettingTimer { |
||||||
|
if !Enabled { |
||||||
|
return NilResettingTimer{} |
||||||
|
} |
||||||
|
return &StandardResettingTimer{ |
||||||
|
values: make([]int64, 0, InitialResettingTimerSliceCap), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NilResettingTimer is a no-op ResettingTimer.
|
||||||
|
type NilResettingTimer struct { |
||||||
|
} |
||||||
|
|
||||||
|
// Values is a no-op.
|
||||||
|
func (NilResettingTimer) Values() []int64 { return nil } |
||||||
|
|
||||||
|
// Snapshot is a no-op.
|
||||||
|
func (NilResettingTimer) Snapshot() ResettingTimer { return NilResettingTimer{} } |
||||||
|
|
||||||
|
// Time is a no-op.
|
||||||
|
func (NilResettingTimer) Time(func()) {} |
||||||
|
|
||||||
|
// Update is a no-op.
|
||||||
|
func (NilResettingTimer) Update(time.Duration) {} |
||||||
|
|
||||||
|
// Percentiles panics.
|
||||||
|
func (NilResettingTimer) Percentiles([]float64) []int64 { |
||||||
|
panic("Percentiles called on a NilResettingTimer") |
||||||
|
} |
||||||
|
|
||||||
|
// Mean panics.
|
||||||
|
func (NilResettingTimer) Mean() float64 { |
||||||
|
panic("Mean called on a NilResettingTimer") |
||||||
|
} |
||||||
|
|
||||||
|
// UpdateSince is a no-op.
|
||||||
|
func (NilResettingTimer) UpdateSince(time.Time) {} |
||||||
|
|
||||||
|
// StandardResettingTimer is the standard implementation of a ResettingTimer.
|
||||||
|
// and Meter.
|
||||||
|
type StandardResettingTimer struct { |
||||||
|
values []int64 |
||||||
|
mutex sync.Mutex |
||||||
|
} |
||||||
|
|
||||||
|
// Values returns a slice with all measurements.
|
||||||
|
func (t *StandardResettingTimer) Values() []int64 { |
||||||
|
return t.values |
||||||
|
} |
||||||
|
|
||||||
|
// Snapshot resets the timer and returns a read-only copy of its contents.
|
||||||
|
func (t *StandardResettingTimer) Snapshot() ResettingTimer { |
||||||
|
t.mutex.Lock() |
||||||
|
defer t.mutex.Unlock() |
||||||
|
currentValues := t.values |
||||||
|
t.values = make([]int64, 0, InitialResettingTimerSliceCap) |
||||||
|
|
||||||
|
return &ResettingTimerSnapshot{ |
||||||
|
values: currentValues, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Percentiles panics.
|
||||||
|
func (t *StandardResettingTimer) Percentiles([]float64) []int64 { |
||||||
|
panic("Percentiles called on a StandardResettingTimer") |
||||||
|
} |
||||||
|
|
||||||
|
// Mean panics.
|
||||||
|
func (t *StandardResettingTimer) Mean() float64 { |
||||||
|
panic("Mean called on a StandardResettingTimer") |
||||||
|
} |
||||||
|
|
||||||
|
// Record the duration of the execution of the given function.
|
||||||
|
func (t *StandardResettingTimer) Time(f func()) { |
||||||
|
ts := time.Now() |
||||||
|
f() |
||||||
|
t.Update(time.Since(ts)) |
||||||
|
} |
||||||
|
|
||||||
|
// Record the duration of an event.
|
||||||
|
func (t *StandardResettingTimer) Update(d time.Duration) { |
||||||
|
t.mutex.Lock() |
||||||
|
defer t.mutex.Unlock() |
||||||
|
t.values = append(t.values, int64(d)) |
||||||
|
} |
||||||
|
|
||||||
|
// Record the duration of an event that started at a time and ends now.
|
||||||
|
func (t *StandardResettingTimer) UpdateSince(ts time.Time) { |
||||||
|
t.mutex.Lock() |
||||||
|
defer t.mutex.Unlock() |
||||||
|
t.values = append(t.values, int64(time.Since(ts))) |
||||||
|
} |
||||||
|
|
||||||
|
// ResettingTimerSnapshot is a point-in-time copy of another ResettingTimer.
|
||||||
|
type ResettingTimerSnapshot struct { |
||||||
|
values []int64 |
||||||
|
mean float64 |
||||||
|
thresholdBoundaries []int64 |
||||||
|
calculated bool |
||||||
|
} |
||||||
|
|
||||||
|
// Snapshot returns the snapshot.
|
||||||
|
func (t *ResettingTimerSnapshot) Snapshot() ResettingTimer { return t } |
||||||
|
|
||||||
|
// Time panics.
|
||||||
|
func (*ResettingTimerSnapshot) Time(func()) { |
||||||
|
panic("Time called on a ResettingTimerSnapshot") |
||||||
|
} |
||||||
|
|
||||||
|
// Update panics.
|
||||||
|
func (*ResettingTimerSnapshot) Update(time.Duration) { |
||||||
|
panic("Update called on a ResettingTimerSnapshot") |
||||||
|
} |
||||||
|
|
||||||
|
// UpdateSince panics.
|
||||||
|
func (*ResettingTimerSnapshot) UpdateSince(time.Time) { |
||||||
|
panic("UpdateSince called on a ResettingTimerSnapshot") |
||||||
|
} |
||||||
|
|
||||||
|
// Values returns all values from snapshot.
|
||||||
|
func (t *ResettingTimerSnapshot) Values() []int64 { |
||||||
|
return t.values |
||||||
|
} |
||||||
|
|
||||||
|
// Percentiles returns the boundaries for the input percentiles.
|
||||||
|
func (t *ResettingTimerSnapshot) Percentiles(percentiles []float64) []int64 { |
||||||
|
t.calc(percentiles) |
||||||
|
|
||||||
|
return t.thresholdBoundaries |
||||||
|
} |
||||||
|
|
||||||
|
// Mean returns the mean of the snapshotted values
|
||||||
|
func (t *ResettingTimerSnapshot) Mean() float64 { |
||||||
|
if !t.calculated { |
||||||
|
t.calc([]float64{}) |
||||||
|
} |
||||||
|
|
||||||
|
return t.mean |
||||||
|
} |
||||||
|
|
||||||
|
func (t *ResettingTimerSnapshot) calc(percentiles []float64) { |
||||||
|
sort.Sort(Int64Slice(t.values)) |
||||||
|
|
||||||
|
count := len(t.values) |
||||||
|
if count > 0 { |
||||||
|
min := t.values[0] |
||||||
|
max := t.values[count-1] |
||||||
|
|
||||||
|
cumulativeValues := make([]int64, count) |
||||||
|
cumulativeValues[0] = min |
||||||
|
for i := 1; i < count; i++ { |
||||||
|
cumulativeValues[i] = t.values[i] + cumulativeValues[i-1] |
||||||
|
} |
||||||
|
|
||||||
|
t.thresholdBoundaries = make([]int64, len(percentiles)) |
||||||
|
|
||||||
|
thresholdBoundary := max |
||||||
|
|
||||||
|
for i, pct := range percentiles { |
||||||
|
if count > 1 { |
||||||
|
var abs float64 |
||||||
|
if pct >= 0 { |
||||||
|
abs = pct |
||||||
|
} else { |
||||||
|
abs = 100 + pct |
||||||
|
} |
||||||
|
// poor man's math.Round(x):
|
||||||
|
// math.Floor(x + 0.5)
|
||||||
|
indexOfPerc := int(math.Floor(((abs / 100.0) * float64(count)) + 0.5)) |
||||||
|
if pct >= 0 { |
||||||
|
indexOfPerc -= 1 // index offset=0
|
||||||
|
} |
||||||
|
thresholdBoundary = t.values[indexOfPerc] |
||||||
|
} |
||||||
|
|
||||||
|
t.thresholdBoundaries[i] = thresholdBoundary |
||||||
|
} |
||||||
|
|
||||||
|
sum := cumulativeValues[count-1] |
||||||
|
t.mean = float64(sum) / float64(count) |
||||||
|
} else { |
||||||
|
t.thresholdBoundaries = make([]int64, len(percentiles)) |
||||||
|
t.mean = 0 |
||||||
|
} |
||||||
|
|
||||||
|
t.calculated = true |
||||||
|
} |
||||||
|
|
||||||
|
// Int64Slice attaches the methods of sort.Interface to []int64, sorting in increasing order.
|
||||||
|
type Int64Slice []int64 |
||||||
|
|
||||||
|
func (s Int64Slice) Len() int { return len(s) } |
||||||
|
func (s Int64Slice) Less(i, j int) bool { return s[i] < s[j] } |
||||||
|
func (s Int64Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } |
||||||
@ -0,0 +1,106 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func TestResettingTimer(t *testing.T) { |
||||||
|
tests := []struct { |
||||||
|
values []int64 |
||||||
|
start int |
||||||
|
end int |
||||||
|
wantP50 int64 |
||||||
|
wantP95 int64 |
||||||
|
wantP99 int64 |
||||||
|
wantMean float64 |
||||||
|
wantMin int64 |
||||||
|
wantMax int64 |
||||||
|
}{ |
||||||
|
{ |
||||||
|
values: []int64{}, |
||||||
|
start: 1, |
||||||
|
end: 11, |
||||||
|
wantP50: 5, wantP95: 10, wantP99: 10, |
||||||
|
wantMin: 1, wantMax: 10, wantMean: 5.5, |
||||||
|
}, |
||||||
|
{ |
||||||
|
values: []int64{}, |
||||||
|
start: 1, |
||||||
|
end: 101, |
||||||
|
wantP50: 50, wantP95: 95, wantP99: 99, |
||||||
|
wantMin: 1, wantMax: 100, wantMean: 50.5, |
||||||
|
}, |
||||||
|
{ |
||||||
|
values: []int64{1}, |
||||||
|
start: 0, |
||||||
|
end: 0, |
||||||
|
wantP50: 1, wantP95: 1, wantP99: 1, |
||||||
|
wantMin: 1, wantMax: 1, wantMean: 1, |
||||||
|
}, |
||||||
|
{ |
||||||
|
values: []int64{0}, |
||||||
|
start: 0, |
||||||
|
end: 0, |
||||||
|
wantP50: 0, wantP95: 0, wantP99: 0, |
||||||
|
wantMin: 0, wantMax: 0, wantMean: 0, |
||||||
|
}, |
||||||
|
{ |
||||||
|
values: []int64{}, |
||||||
|
start: 0, |
||||||
|
end: 0, |
||||||
|
wantP50: 0, wantP95: 0, wantP99: 0, |
||||||
|
wantMin: 0, wantMax: 0, wantMean: 0, |
||||||
|
}, |
||||||
|
{ |
||||||
|
values: []int64{1, 10}, |
||||||
|
start: 0, |
||||||
|
end: 0, |
||||||
|
wantP50: 1, wantP95: 10, wantP99: 10, |
||||||
|
wantMin: 1, wantMax: 10, wantMean: 5.5, |
||||||
|
}, |
||||||
|
} |
||||||
|
for ind, tt := range tests { |
||||||
|
timer := NewResettingTimer() |
||||||
|
|
||||||
|
for i := tt.start; i < tt.end; i++ { |
||||||
|
tt.values = append(tt.values, int64(i)) |
||||||
|
} |
||||||
|
|
||||||
|
for _, v := range tt.values { |
||||||
|
timer.Update(time.Duration(v)) |
||||||
|
} |
||||||
|
|
||||||
|
snap := timer.Snapshot() |
||||||
|
|
||||||
|
ps := snap.Percentiles([]float64{50, 95, 99}) |
||||||
|
|
||||||
|
val := snap.Values() |
||||||
|
|
||||||
|
if len(val) > 0 { |
||||||
|
if tt.wantMin != val[0] { |
||||||
|
t.Fatalf("%d: min: got %d, want %d", ind, val[0], tt.wantMin) |
||||||
|
} |
||||||
|
|
||||||
|
if tt.wantMax != val[len(val)-1] { |
||||||
|
t.Fatalf("%d: max: got %d, want %d", ind, val[len(val)-1], tt.wantMax) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if tt.wantMean != snap.Mean() { |
||||||
|
t.Fatalf("%d: mean: got %.2f, want %.2f", ind, snap.Mean(), tt.wantMean) |
||||||
|
} |
||||||
|
|
||||||
|
if tt.wantP50 != ps[0] { |
||||||
|
t.Fatalf("%d: p50: got %d, want %d", ind, ps[0], tt.wantP50) |
||||||
|
} |
||||||
|
|
||||||
|
if tt.wantP95 != ps[1] { |
||||||
|
t.Fatalf("%d: p95: got %d, want %d", ind, ps[1], tt.wantP95) |
||||||
|
} |
||||||
|
|
||||||
|
if tt.wantP99 != ps[2] { |
||||||
|
t.Fatalf("%d: p99: got %d, want %d", ind, ps[2], tt.wantP99) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,88 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"runtime" |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkRuntimeMemStats(b *testing.B) { |
||||||
|
r := NewRegistry() |
||||||
|
RegisterRuntimeMemStats(r) |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRuntimeMemStats(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
RegisterRuntimeMemStats(r) |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
zero := runtimeMetrics.MemStats.PauseNs.Count() // Get a "zero" since GC may have run before these tests.
|
||||||
|
runtime.GC() |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
if count := runtimeMetrics.MemStats.PauseNs.Count(); 1 != count-zero { |
||||||
|
t.Fatal(count - zero) |
||||||
|
} |
||||||
|
runtime.GC() |
||||||
|
runtime.GC() |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
if count := runtimeMetrics.MemStats.PauseNs.Count(); 3 != count-zero { |
||||||
|
t.Fatal(count - zero) |
||||||
|
} |
||||||
|
for i := 0; i < 256; i++ { |
||||||
|
runtime.GC() |
||||||
|
} |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
if count := runtimeMetrics.MemStats.PauseNs.Count(); 259 != count-zero { |
||||||
|
t.Fatal(count - zero) |
||||||
|
} |
||||||
|
for i := 0; i < 257; i++ { |
||||||
|
runtime.GC() |
||||||
|
} |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
if count := runtimeMetrics.MemStats.PauseNs.Count(); 515 != count-zero { // We lost one because there were too many GCs between captures.
|
||||||
|
t.Fatal(count - zero) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRuntimeMemStatsNumThread(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
RegisterRuntimeMemStats(r) |
||||||
|
CaptureRuntimeMemStatsOnce(r) |
||||||
|
|
||||||
|
if value := runtimeMetrics.NumThread.Value(); value < 1 { |
||||||
|
t.Fatalf("got NumThread: %d, wanted at least 1", value) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestRuntimeMemStatsBlocking(t *testing.T) { |
||||||
|
if g := runtime.GOMAXPROCS(0); g < 2 { |
||||||
|
t.Skipf("skipping TestRuntimeMemStatsBlocking with GOMAXPROCS=%d\n", g) |
||||||
|
} |
||||||
|
ch := make(chan int) |
||||||
|
go testRuntimeMemStatsBlocking(ch) |
||||||
|
var memStats runtime.MemStats |
||||||
|
t0 := time.Now() |
||||||
|
runtime.ReadMemStats(&memStats) |
||||||
|
t1 := time.Now() |
||||||
|
t.Log("i++ during runtime.ReadMemStats:", <-ch) |
||||||
|
go testRuntimeMemStatsBlocking(ch) |
||||||
|
d := t1.Sub(t0) |
||||||
|
t.Log(d) |
||||||
|
time.Sleep(d) |
||||||
|
t.Log("i++ during time.Sleep:", <-ch) |
||||||
|
} |
||||||
|
|
||||||
|
func testRuntimeMemStatsBlocking(ch chan int) { |
||||||
|
i := 0 |
||||||
|
for { |
||||||
|
select { |
||||||
|
case ch <- i: |
||||||
|
return |
||||||
|
default: |
||||||
|
i++ |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,363 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"math/rand" |
||||||
|
"runtime" |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
// Benchmark{Compute,Copy}{1000,1000000} demonstrate that, even for relatively
|
||||||
|
// expensive computations like Variance, the cost of copying the Sample, as
|
||||||
|
// approximated by a make and copy, is much greater than the cost of the
|
||||||
|
// computation for small samples and only slightly less for large samples.
|
||||||
|
func BenchmarkCompute1000(b *testing.B) { |
||||||
|
s := make([]int64, 1000) |
||||||
|
for i := 0; i < len(s); i++ { |
||||||
|
s[i] = int64(i) |
||||||
|
} |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
SampleVariance(s) |
||||||
|
} |
||||||
|
} |
||||||
|
func BenchmarkCompute1000000(b *testing.B) { |
||||||
|
s := make([]int64, 1000000) |
||||||
|
for i := 0; i < len(s); i++ { |
||||||
|
s[i] = int64(i) |
||||||
|
} |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
SampleVariance(s) |
||||||
|
} |
||||||
|
} |
||||||
|
func BenchmarkCopy1000(b *testing.B) { |
||||||
|
s := make([]int64, 1000) |
||||||
|
for i := 0; i < len(s); i++ { |
||||||
|
s[i] = int64(i) |
||||||
|
} |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
sCopy := make([]int64, len(s)) |
||||||
|
copy(sCopy, s) |
||||||
|
} |
||||||
|
} |
||||||
|
func BenchmarkCopy1000000(b *testing.B) { |
||||||
|
s := make([]int64, 1000000) |
||||||
|
for i := 0; i < len(s); i++ { |
||||||
|
s[i] = int64(i) |
||||||
|
} |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
sCopy := make([]int64, len(s)) |
||||||
|
copy(sCopy, s) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkExpDecaySample257(b *testing.B) { |
||||||
|
benchmarkSample(b, NewExpDecaySample(257, 0.015)) |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkExpDecaySample514(b *testing.B) { |
||||||
|
benchmarkSample(b, NewExpDecaySample(514, 0.015)) |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkExpDecaySample1028(b *testing.B) { |
||||||
|
benchmarkSample(b, NewExpDecaySample(1028, 0.015)) |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkUniformSample257(b *testing.B) { |
||||||
|
benchmarkSample(b, NewUniformSample(257)) |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkUniformSample514(b *testing.B) { |
||||||
|
benchmarkSample(b, NewUniformSample(514)) |
||||||
|
} |
||||||
|
|
||||||
|
func BenchmarkUniformSample1028(b *testing.B) { |
||||||
|
benchmarkSample(b, NewUniformSample(1028)) |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySample10(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(100, 0.99) |
||||||
|
for i := 0; i < 10; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
if size := s.Count(); 10 != size { |
||||||
|
t.Errorf("s.Count(): 10 != %v\n", size) |
||||||
|
} |
||||||
|
if size := s.Size(); 10 != size { |
||||||
|
t.Errorf("s.Size(): 10 != %v\n", size) |
||||||
|
} |
||||||
|
if l := len(s.Values()); 10 != l { |
||||||
|
t.Errorf("len(s.Values()): 10 != %v\n", l) |
||||||
|
} |
||||||
|
for _, v := range s.Values() { |
||||||
|
if v > 10 || v < 0 { |
||||||
|
t.Errorf("out of range [0, 10): %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySample100(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(1000, 0.01) |
||||||
|
for i := 0; i < 100; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
if size := s.Count(); 100 != size { |
||||||
|
t.Errorf("s.Count(): 100 != %v\n", size) |
||||||
|
} |
||||||
|
if size := s.Size(); 100 != size { |
||||||
|
t.Errorf("s.Size(): 100 != %v\n", size) |
||||||
|
} |
||||||
|
if l := len(s.Values()); 100 != l { |
||||||
|
t.Errorf("len(s.Values()): 100 != %v\n", l) |
||||||
|
} |
||||||
|
for _, v := range s.Values() { |
||||||
|
if v > 100 || v < 0 { |
||||||
|
t.Errorf("out of range [0, 100): %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySample1000(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(100, 0.99) |
||||||
|
for i := 0; i < 1000; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
if size := s.Count(); 1000 != size { |
||||||
|
t.Errorf("s.Count(): 1000 != %v\n", size) |
||||||
|
} |
||||||
|
if size := s.Size(); 100 != size { |
||||||
|
t.Errorf("s.Size(): 100 != %v\n", size) |
||||||
|
} |
||||||
|
if l := len(s.Values()); 100 != l { |
||||||
|
t.Errorf("len(s.Values()): 100 != %v\n", l) |
||||||
|
} |
||||||
|
for _, v := range s.Values() { |
||||||
|
if v > 1000 || v < 0 { |
||||||
|
t.Errorf("out of range [0, 1000): %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// This test makes sure that the sample's priority is not amplified by using
|
||||||
|
// nanosecond duration since start rather than second duration since start.
|
||||||
|
// The priority becomes +Inf quickly after starting if this is done,
|
||||||
|
// effectively freezing the set of samples until a rescale step happens.
|
||||||
|
func TestExpDecaySampleNanosecondRegression(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(100, 0.99) |
||||||
|
for i := 0; i < 100; i++ { |
||||||
|
s.Update(10) |
||||||
|
} |
||||||
|
time.Sleep(1 * time.Millisecond) |
||||||
|
for i := 0; i < 100; i++ { |
||||||
|
s.Update(20) |
||||||
|
} |
||||||
|
v := s.Values() |
||||||
|
avg := float64(0) |
||||||
|
for i := 0; i < len(v); i++ { |
||||||
|
avg += float64(v[i]) |
||||||
|
} |
||||||
|
avg /= float64(len(v)) |
||||||
|
if avg > 16 || avg < 14 { |
||||||
|
t.Errorf("out of range [14, 16]: %v\n", avg) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySampleRescale(t *testing.T) { |
||||||
|
s := NewExpDecaySample(2, 0.001).(*ExpDecaySample) |
||||||
|
s.update(time.Now(), 1) |
||||||
|
s.update(time.Now().Add(time.Hour+time.Microsecond), 1) |
||||||
|
for _, v := range s.values.Values() { |
||||||
|
if v.k == 0.0 { |
||||||
|
t.Fatal("v.k == 0.0") |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySampleSnapshot(t *testing.T) { |
||||||
|
now := time.Now() |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(100, 0.99) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
s.(*ExpDecaySample).update(now.Add(time.Duration(i)), int64(i)) |
||||||
|
} |
||||||
|
snapshot := s.Snapshot() |
||||||
|
s.Update(1) |
||||||
|
testExpDecaySampleStatistics(t, snapshot) |
||||||
|
} |
||||||
|
|
||||||
|
func TestExpDecaySampleStatistics(t *testing.T) { |
||||||
|
now := time.Now() |
||||||
|
rand.Seed(1) |
||||||
|
s := NewExpDecaySample(100, 0.99) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
s.(*ExpDecaySample).update(now.Add(time.Duration(i)), int64(i)) |
||||||
|
} |
||||||
|
testExpDecaySampleStatistics(t, s) |
||||||
|
} |
||||||
|
|
||||||
|
func TestUniformSample(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewUniformSample(100) |
||||||
|
for i := 0; i < 1000; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
if size := s.Count(); 1000 != size { |
||||||
|
t.Errorf("s.Count(): 1000 != %v\n", size) |
||||||
|
} |
||||||
|
if size := s.Size(); 100 != size { |
||||||
|
t.Errorf("s.Size(): 100 != %v\n", size) |
||||||
|
} |
||||||
|
if l := len(s.Values()); 100 != l { |
||||||
|
t.Errorf("len(s.Values()): 100 != %v\n", l) |
||||||
|
} |
||||||
|
for _, v := range s.Values() { |
||||||
|
if v > 1000 || v < 0 { |
||||||
|
t.Errorf("out of range [0, 100): %v\n", v) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestUniformSampleIncludesTail(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewUniformSample(100) |
||||||
|
max := 100 |
||||||
|
for i := 0; i < max; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
v := s.Values() |
||||||
|
sum := 0 |
||||||
|
exp := (max - 1) * max / 2 |
||||||
|
for i := 0; i < len(v); i++ { |
||||||
|
sum += int(v[i]) |
||||||
|
} |
||||||
|
if exp != sum { |
||||||
|
t.Errorf("sum: %v != %v\n", exp, sum) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestUniformSampleSnapshot(t *testing.T) { |
||||||
|
s := NewUniformSample(100) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
snapshot := s.Snapshot() |
||||||
|
s.Update(1) |
||||||
|
testUniformSampleStatistics(t, snapshot) |
||||||
|
} |
||||||
|
|
||||||
|
func TestUniformSampleStatistics(t *testing.T) { |
||||||
|
rand.Seed(1) |
||||||
|
s := NewUniformSample(100) |
||||||
|
for i := 1; i <= 10000; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
testUniformSampleStatistics(t, s) |
||||||
|
} |
||||||
|
|
||||||
|
func benchmarkSample(b *testing.B, s Sample) { |
||||||
|
var memStats runtime.MemStats |
||||||
|
runtime.ReadMemStats(&memStats) |
||||||
|
pauseTotalNs := memStats.PauseTotalNs |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
s.Update(1) |
||||||
|
} |
||||||
|
b.StopTimer() |
||||||
|
runtime.GC() |
||||||
|
runtime.ReadMemStats(&memStats) |
||||||
|
b.Logf("GC cost: %d ns/op", int(memStats.PauseTotalNs-pauseTotalNs)/b.N) |
||||||
|
} |
||||||
|
|
||||||
|
func testExpDecaySampleStatistics(t *testing.T, s Sample) { |
||||||
|
if count := s.Count(); 10000 != count { |
||||||
|
t.Errorf("s.Count(): 10000 != %v\n", count) |
||||||
|
} |
||||||
|
if min := s.Min(); 107 != min { |
||||||
|
t.Errorf("s.Min(): 107 != %v\n", min) |
||||||
|
} |
||||||
|
if max := s.Max(); 10000 != max { |
||||||
|
t.Errorf("s.Max(): 10000 != %v\n", max) |
||||||
|
} |
||||||
|
if mean := s.Mean(); 4965.98 != mean { |
||||||
|
t.Errorf("s.Mean(): 4965.98 != %v\n", mean) |
||||||
|
} |
||||||
|
if stdDev := s.StdDev(); 2959.825156930727 != stdDev { |
||||||
|
t.Errorf("s.StdDev(): 2959.825156930727 != %v\n", stdDev) |
||||||
|
} |
||||||
|
ps := s.Percentiles([]float64{0.5, 0.75, 0.99}) |
||||||
|
if 4615 != ps[0] { |
||||||
|
t.Errorf("median: 4615 != %v\n", ps[0]) |
||||||
|
} |
||||||
|
if 7672 != ps[1] { |
||||||
|
t.Errorf("75th percentile: 7672 != %v\n", ps[1]) |
||||||
|
} |
||||||
|
if 9998.99 != ps[2] { |
||||||
|
t.Errorf("99th percentile: 9998.99 != %v\n", ps[2]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUniformSampleStatistics(t *testing.T, s Sample) { |
||||||
|
if count := s.Count(); 10000 != count { |
||||||
|
t.Errorf("s.Count(): 10000 != %v\n", count) |
||||||
|
} |
||||||
|
if min := s.Min(); 37 != min { |
||||||
|
t.Errorf("s.Min(): 37 != %v\n", min) |
||||||
|
} |
||||||
|
if max := s.Max(); 9989 != max { |
||||||
|
t.Errorf("s.Max(): 9989 != %v\n", max) |
||||||
|
} |
||||||
|
if mean := s.Mean(); 4748.14 != mean { |
||||||
|
t.Errorf("s.Mean(): 4748.14 != %v\n", mean) |
||||||
|
} |
||||||
|
if stdDev := s.StdDev(); 2826.684117548333 != stdDev { |
||||||
|
t.Errorf("s.StdDev(): 2826.684117548333 != %v\n", stdDev) |
||||||
|
} |
||||||
|
ps := s.Percentiles([]float64{0.5, 0.75, 0.99}) |
||||||
|
if 4599 != ps[0] { |
||||||
|
t.Errorf("median: 4599 != %v\n", ps[0]) |
||||||
|
} |
||||||
|
if 7380.5 != ps[1] { |
||||||
|
t.Errorf("75th percentile: 7380.5 != %v\n", ps[1]) |
||||||
|
} |
||||||
|
if 9986.429999999998 != ps[2] { |
||||||
|
t.Errorf("99th percentile: 9986.429999999998 != %v\n", ps[2]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestUniformSampleConcurrentUpdateCount would expose data race problems with
|
||||||
|
// concurrent Update and Count calls on Sample when test is called with -race
|
||||||
|
// argument
|
||||||
|
func TestUniformSampleConcurrentUpdateCount(t *testing.T) { |
||||||
|
if testing.Short() { |
||||||
|
t.Skip("skipping in short mode") |
||||||
|
} |
||||||
|
s := NewUniformSample(100) |
||||||
|
for i := 0; i < 100; i++ { |
||||||
|
s.Update(int64(i)) |
||||||
|
} |
||||||
|
quit := make(chan struct{}) |
||||||
|
go func() { |
||||||
|
t := time.NewTicker(10 * time.Millisecond) |
||||||
|
for { |
||||||
|
select { |
||||||
|
case <-t.C: |
||||||
|
s.Update(rand.Int63()) |
||||||
|
case <-quit: |
||||||
|
t.Stop() |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
}() |
||||||
|
for i := 0; i < 1000; i++ { |
||||||
|
s.Count() |
||||||
|
time.Sleep(5 * time.Millisecond) |
||||||
|
} |
||||||
|
quit <- struct{}{} |
||||||
|
} |
||||||
@ -0,0 +1,101 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"math" |
||||||
|
"testing" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
func BenchmarkTimer(b *testing.B) { |
||||||
|
tm := NewTimer() |
||||||
|
b.ResetTimer() |
||||||
|
for i := 0; i < b.N; i++ { |
||||||
|
tm.Update(1) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestGetOrRegisterTimer(t *testing.T) { |
||||||
|
r := NewRegistry() |
||||||
|
NewRegisteredTimer("foo", r).Update(47) |
||||||
|
if tm := GetOrRegisterTimer("foo", r); 1 != tm.Count() { |
||||||
|
t.Fatal(tm) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestTimerExtremes(t *testing.T) { |
||||||
|
tm := NewTimer() |
||||||
|
tm.Update(math.MaxInt64) |
||||||
|
tm.Update(0) |
||||||
|
if stdDev := tm.StdDev(); 4.611686018427388e+18 != stdDev { |
||||||
|
t.Errorf("tm.StdDev(): 4.611686018427388e+18 != %v\n", stdDev) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestTimerStop(t *testing.T) { |
||||||
|
l := len(arbiter.meters) |
||||||
|
tm := NewTimer() |
||||||
|
if len(arbiter.meters) != l+1 { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l+1, len(arbiter.meters)) |
||||||
|
} |
||||||
|
tm.Stop() |
||||||
|
if len(arbiter.meters) != l { |
||||||
|
t.Errorf("arbiter.meters: %d != %d\n", l, len(arbiter.meters)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestTimerFunc(t *testing.T) { |
||||||
|
tm := NewTimer() |
||||||
|
tm.Time(func() { time.Sleep(50e6) }) |
||||||
|
if max := tm.Max(); 45e6 > max || max > 55e6 { |
||||||
|
t.Errorf("tm.Max(): 45e6 > %v || %v > 55e6\n", max, max) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestTimerZero(t *testing.T) { |
||||||
|
tm := NewTimer() |
||||||
|
if count := tm.Count(); 0 != count { |
||||||
|
t.Errorf("tm.Count(): 0 != %v\n", count) |
||||||
|
} |
||||||
|
if min := tm.Min(); 0 != min { |
||||||
|
t.Errorf("tm.Min(): 0 != %v\n", min) |
||||||
|
} |
||||||
|
if max := tm.Max(); 0 != max { |
||||||
|
t.Errorf("tm.Max(): 0 != %v\n", max) |
||||||
|
} |
||||||
|
if mean := tm.Mean(); 0.0 != mean { |
||||||
|
t.Errorf("tm.Mean(): 0.0 != %v\n", mean) |
||||||
|
} |
||||||
|
if stdDev := tm.StdDev(); 0.0 != stdDev { |
||||||
|
t.Errorf("tm.StdDev(): 0.0 != %v\n", stdDev) |
||||||
|
} |
||||||
|
ps := tm.Percentiles([]float64{0.5, 0.75, 0.99}) |
||||||
|
if 0.0 != ps[0] { |
||||||
|
t.Errorf("median: 0.0 != %v\n", ps[0]) |
||||||
|
} |
||||||
|
if 0.0 != ps[1] { |
||||||
|
t.Errorf("75th percentile: 0.0 != %v\n", ps[1]) |
||||||
|
} |
||||||
|
if 0.0 != ps[2] { |
||||||
|
t.Errorf("99th percentile: 0.0 != %v\n", ps[2]) |
||||||
|
} |
||||||
|
if rate1 := tm.Rate1(); 0.0 != rate1 { |
||||||
|
t.Errorf("tm.Rate1(): 0.0 != %v\n", rate1) |
||||||
|
} |
||||||
|
if rate5 := tm.Rate5(); 0.0 != rate5 { |
||||||
|
t.Errorf("tm.Rate5(): 0.0 != %v\n", rate5) |
||||||
|
} |
||||||
|
if rate15 := tm.Rate15(); 0.0 != rate15 { |
||||||
|
t.Errorf("tm.Rate15(): 0.0 != %v\n", rate15) |
||||||
|
} |
||||||
|
if rateMean := tm.RateMean(); 0.0 != rateMean { |
||||||
|
t.Errorf("tm.RateMean(): 0.0 != %v\n", rateMean) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func ExampleGetOrRegisterTimer() { |
||||||
|
m := "account.create.latency" |
||||||
|
t := GetOrRegisterTimer(m, nil) |
||||||
|
t.Update(47) |
||||||
|
fmt.Println(t.Max()) // Output: 47
|
||||||
|
} |
||||||
@ -0,0 +1,22 @@ |
|||||||
|
package metrics |
||||||
|
|
||||||
|
import ( |
||||||
|
"sort" |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
func TestMetricsSorting(t *testing.T) { |
||||||
|
var namedMetrics = namedMetricSlice{ |
||||||
|
{name: "zzz"}, |
||||||
|
{name: "bbb"}, |
||||||
|
{name: "fff"}, |
||||||
|
{name: "ggg"}, |
||||||
|
} |
||||||
|
|
||||||
|
sort.Sort(namedMetrics) |
||||||
|
for i, name := range []string{"bbb", "fff", "ggg", "zzz"} { |
||||||
|
if namedMetrics[i].name != name { |
||||||
|
t.Fail() |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,20 @@ |
|||||||
|
The MIT License (MIT) |
||||||
|
|
||||||
|
Copyright (c) 2013-2016 Errplane Inc. |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||||
|
this software and associated documentation files (the "Software"), to deal in |
||||||
|
the Software without restriction, including without limitation the rights to |
||||||
|
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
||||||
|
the Software, and to permit persons to whom the Software is furnished to do so, |
||||||
|
subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all |
||||||
|
copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
||||||
|
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
||||||
|
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
||||||
|
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
||||||
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||||||
@ -0,0 +1,62 @@ |
|||||||
|
- # List |
||||||
|
- bootstrap 3.3.5 [MIT LICENSE](https://github.com/twbs/bootstrap/blob/master/LICENSE) |
||||||
|
- collectd.org [ISC LICENSE](https://github.com/collectd/go-collectd/blob/master/LICENSE) |
||||||
|
- github.com/BurntSushi/toml [MIT LICENSE](https://github.com/BurntSushi/toml/blob/master/COPYING) |
||||||
|
- github.com/RoaringBitmap/roaring [APACHE LICENSE](https://github.com/RoaringBitmap/roaring/blob/master/LICENSE) |
||||||
|
- github.com/beorn7/perks [MIT LICENSE](https://github.com/beorn7/perks/blob/master/LICENSE) |
||||||
|
- github.com/bmizerany/pat [MIT LICENSE](https://github.com/bmizerany/pat#license) |
||||||
|
- github.com/boltdb/bolt [MIT LICENSE](https://github.com/boltdb/bolt/blob/master/LICENSE) |
||||||
|
- github.com/cespare/xxhash [MIT LICENSE](https://github.com/cespare/xxhash/blob/master/LICENSE.txt) |
||||||
|
- github.com/clarkduvall/hyperloglog [MIT LICENSE](https://github.com/clarkduvall/hyperloglog/blob/master/LICENSE) |
||||||
|
- github.com/davecgh/go-spew/spew [ISC LICENSE](https://github.com/davecgh/go-spew/blob/master/LICENSE) |
||||||
|
- github.com/dgrijalva/jwt-go [MIT LICENSE](https://github.com/dgrijalva/jwt-go/blob/master/LICENSE) |
||||||
|
- github.com/dgryski/go-bits [MIT LICENSE](https://github.com/dgryski/go-bits/blob/master/LICENSE) |
||||||
|
- github.com/dgryski/go-bitstream [MIT LICENSE](https://github.com/dgryski/go-bitstream/blob/master/LICENSE) |
||||||
|
- github.com/glycerine/go-unsnap-stream [MIT LICENSE](https://github.com/glycerine/go-unsnap-stream/blob/master/LICENSE) |
||||||
|
- github.com/gogo/protobuf/proto [BSD LICENSE](https://github.com/gogo/protobuf/blob/master/LICENSE) |
||||||
|
- github.com/golang/protobuf [BSD LICENSE](https://github.com/golang/protobuf/blob/master/LICENSE) |
||||||
|
- github.com/golang/snappy [BSD LICENSE](https://github.com/golang/snappy/blob/master/LICENSE) |
||||||
|
- github.com/google/go-cmp [BSD LICENSE](https://github.com/google/go-cmp/blob/master/LICENSE) |
||||||
|
- github.com/influxdata/influxql [MIT LICENSE](https://github.com/influxdata/influxql/blob/master/LICENSE) |
||||||
|
- github.com/influxdata/usage-client [MIT LICENSE](https://github.com/influxdata/usage-client/blob/master/LICENSE.txt) |
||||||
|
- github.com/influxdata/yamux [MOZILLA PUBLIC LICENSE](https://github.com/influxdata/yamux/blob/master/LICENSE) |
||||||
|
- github.com/influxdata/yarpc [MIT LICENSE](https://github.com/influxdata/yarpc/blob/master/LICENSE) |
||||||
|
- github.com/jsternberg/zap-logfmt [MIT LICENSE](https://github.com/jsternberg/zap-logfmt/blob/master/LICENSE) |
||||||
|
- github.com/jwilder/encoding [MIT LICENSE](https://github.com/jwilder/encoding/blob/master/LICENSE) |
||||||
|
- github.com/mattn/go-isatty [MIT LICENSE](https://github.com/mattn/go-isatty/blob/master/LICENSE) |
||||||
|
- github.com/matttproud/golang_protobuf_extensions [APACHE LICENSE](https://github.com/matttproud/golang_protobuf_extensions/blob/master/LICENSE) |
||||||
|
- github.com/opentracing/opentracing-go [MIT LICENSE](https://github.com/opentracing/opentracing-go/blob/master/LICENSE) |
||||||
|
- github.com/paulbellamy/ratecounter [MIT LICENSE](https://github.com/paulbellamy/ratecounter/blob/master/LICENSE) |
||||||
|
- github.com/peterh/liner [MIT LICENSE](https://github.com/peterh/liner/blob/master/COPYING) |
||||||
|
- github.com/philhofer/fwd [MIT LICENSE](https://github.com/philhofer/fwd/blob/master/LICENSE.md) |
||||||
|
- github.com/prometheus/client_golang [MIT LICENSE](https://github.com/prometheus/client_golang/blob/master/LICENSE) |
||||||
|
- github.com/prometheus/client_model [MIT LICENSE](https://github.com/prometheus/client_model/blob/master/LICENSE) |
||||||
|
- github.com/prometheus/common [APACHE LICENSE](https://github.com/prometheus/common/blob/master/LICENSE) |
||||||
|
- github.com/prometheus/procfs [APACHE LICENSE](https://github.com/prometheus/procfs/blob/master/LICENSE) |
||||||
|
- github.com/rakyll/statik [APACHE LICENSE](https://github.com/rakyll/statik/blob/master/LICENSE) |
||||||
|
- github.com/retailnext/hllpp [BSD LICENSE](https://github.com/retailnext/hllpp/blob/master/LICENSE) |
||||||
|
- github.com/tinylib/msgp [MIT LICENSE](https://github.com/tinylib/msgp/blob/master/LICENSE) |
||||||
|
- go.uber.org/atomic [MIT LICENSE](https://github.com/uber-go/atomic/blob/master/LICENSE.txt) |
||||||
|
- go.uber.org/multierr [MIT LICENSE](https://github.com/uber-go/multierr/blob/master/LICENSE.txt) |
||||||
|
- go.uber.org/zap [MIT LICENSE](https://github.com/uber-go/zap/blob/master/LICENSE.txt) |
||||||
|
- golang.org/x/crypto [BSD LICENSE](https://github.com/golang/crypto/blob/master/LICENSE) |
||||||
|
- golang.org/x/net [BSD LICENSE](https://github.com/golang/net/blob/master/LICENSE) |
||||||
|
- golang.org/x/sys [BSD LICENSE](https://github.com/golang/sys/blob/master/LICENSE) |
||||||
|
- golang.org/x/text [BSD LICENSE](https://github.com/golang/text/blob/master/LICENSE) |
||||||
|
- golang.org/x/time [BSD LICENSE](https://github.com/golang/time/blob/master/LICENSE) |
||||||
|
- jquery 2.1.4 [MIT LICENSE](https://github.com/jquery/jquery/blob/master/LICENSE.txt) |
||||||
|
- github.com/xlab/treeprint [MIT LICENSE](https://github.com/xlab/treeprint/blob/master/LICENSE) |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,306 @@ |
|||||||
|
# InfluxDB Client |
||||||
|
|
||||||
|
[](http://godoc.org/github.com/influxdata/influxdb/client/v2) |
||||||
|
|
||||||
|
## Description |
||||||
|
|
||||||
|
**NOTE:** The Go client library now has a "v2" version, with the old version |
||||||
|
being deprecated. The new version can be imported at |
||||||
|
`import "github.com/influxdata/influxdb/client/v2"`. It is not backwards-compatible. |
||||||
|
|
||||||
|
A Go client library written and maintained by the **InfluxDB** team. |
||||||
|
This package provides convenience functions to read and write time series data. |
||||||
|
It uses the HTTP protocol to communicate with your **InfluxDB** cluster. |
||||||
|
|
||||||
|
|
||||||
|
## Getting Started |
||||||
|
|
||||||
|
### Connecting To Your Database |
||||||
|
|
||||||
|
Connecting to an **InfluxDB** database is straightforward. You will need a host |
||||||
|
name, a port and the cluster user credentials if applicable. The default port is |
||||||
|
8086. You can customize these settings to your specific installation via the |
||||||
|
**InfluxDB** configuration file. |
||||||
|
|
||||||
|
Though not necessary for experimentation, you may want to create a new user |
||||||
|
and authenticate the connection to your database. |
||||||
|
|
||||||
|
For more information please check out the |
||||||
|
[Admin Docs](https://docs.influxdata.com/influxdb/latest/administration/). |
||||||
|
|
||||||
|
For the impatient, you can create a new admin user _bubba_ by firing off the |
||||||
|
[InfluxDB CLI](https://github.com/influxdata/influxdb/blob/master/cmd/influx/main.go). |
||||||
|
|
||||||
|
```shell |
||||||
|
influx |
||||||
|
> create user bubba with password 'bumblebeetuna' |
||||||
|
> grant all privileges to bubba |
||||||
|
``` |
||||||
|
|
||||||
|
And now for good measure set the credentials in you shell environment. |
||||||
|
In the example below we will use $INFLUX_USER and $INFLUX_PWD |
||||||
|
|
||||||
|
Now with the administrivia out of the way, let's connect to our database. |
||||||
|
|
||||||
|
NOTE: If you've opted out of creating a user, you can omit Username and Password in |
||||||
|
the configuration below. |
||||||
|
|
||||||
|
```go |
||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"log" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/influxdata/influxdb/client/v2" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
MyDB = "square_holes" |
||||||
|
username = "bubba" |
||||||
|
password = "bumblebeetuna" |
||||||
|
) |
||||||
|
|
||||||
|
|
||||||
|
func main() { |
||||||
|
// Create a new HTTPClient |
||||||
|
c, err := client.NewHTTPClient(client.HTTPConfig{ |
||||||
|
Addr: "http://localhost:8086", |
||||||
|
Username: username, |
||||||
|
Password: password, |
||||||
|
}) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create a new point batch |
||||||
|
bp, err := client.NewBatchPoints(client.BatchPointsConfig{ |
||||||
|
Database: MyDB, |
||||||
|
Precision: "s", |
||||||
|
}) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create a point and add to batch |
||||||
|
tags := map[string]string{"cpu": "cpu-total"} |
||||||
|
fields := map[string]interface{}{ |
||||||
|
"idle": 10.1, |
||||||
|
"system": 53.3, |
||||||
|
"user": 46.6, |
||||||
|
} |
||||||
|
|
||||||
|
pt, err := client.NewPoint("cpu_usage", tags, fields, time.Now()) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
bp.AddPoint(pt) |
||||||
|
|
||||||
|
// Write the batch |
||||||
|
if err := c.Write(bp); err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
``` |
||||||
|
|
||||||
|
### Inserting Data |
||||||
|
|
||||||
|
Time series data aka *points* are written to the database using batch inserts. |
||||||
|
The mechanism is to create one or more points and then create a batch aka |
||||||
|
*batch points* and write these to a given database and series. A series is a |
||||||
|
combination of a measurement (time/values) and a set of tags. |
||||||
|
|
||||||
|
In this sample we will create a batch of a 1,000 points. Each point has a time and |
||||||
|
a single value as well as 2 tags indicating a shape and color. We write these points |
||||||
|
to a database called _square_holes_ using a measurement named _shapes_. |
||||||
|
|
||||||
|
NOTE: You can specify a RetentionPolicy as part of the batch points. If not |
||||||
|
provided InfluxDB will use the database _default_ retention policy. |
||||||
|
|
||||||
|
```go |
||||||
|
|
||||||
|
func writePoints(clnt client.Client) { |
||||||
|
sampleSize := 1000 |
||||||
|
|
||||||
|
bp, err := client.NewBatchPoints(client.BatchPointsConfig{ |
||||||
|
Database: "systemstats", |
||||||
|
Precision: "us", |
||||||
|
}) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
rand.Seed(time.Now().UnixNano()) |
||||||
|
for i := 0; i < sampleSize; i++ { |
||||||
|
regions := []string{"us-west1", "us-west2", "us-west3", "us-east1"} |
||||||
|
tags := map[string]string{ |
||||||
|
"cpu": "cpu-total", |
||||||
|
"host": fmt.Sprintf("host%d", rand.Intn(1000)), |
||||||
|
"region": regions[rand.Intn(len(regions))], |
||||||
|
} |
||||||
|
|
||||||
|
idle := rand.Float64() * 100.0 |
||||||
|
fields := map[string]interface{}{ |
||||||
|
"idle": idle, |
||||||
|
"busy": 100.0 - idle, |
||||||
|
} |
||||||
|
|
||||||
|
pt, err := client.NewPoint( |
||||||
|
"cpu_usage", |
||||||
|
tags, |
||||||
|
fields, |
||||||
|
time.Now(), |
||||||
|
) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
bp.AddPoint(pt) |
||||||
|
} |
||||||
|
|
||||||
|
if err := clnt.Write(bp); err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
#### Uint64 Support |
||||||
|
|
||||||
|
The `uint64` data type is supported if your server is version `1.4.0` or |
||||||
|
greater. To write a data point as an unsigned integer, you must insert |
||||||
|
the point as `uint64`. You cannot use `uint` or any of the other |
||||||
|
derivatives because previous versions of the client have supported |
||||||
|
writing those types as an integer. |
||||||
|
|
||||||
|
### Querying Data |
||||||
|
|
||||||
|
One nice advantage of using **InfluxDB** the ability to query your data using familiar |
||||||
|
SQL constructs. In this example we can create a convenience function to query the database |
||||||
|
as follows: |
||||||
|
|
||||||
|
```go |
||||||
|
// queryDB convenience function to query the database |
||||||
|
func queryDB(clnt client.Client, cmd string) (res []client.Result, err error) { |
||||||
|
q := client.Query{ |
||||||
|
Command: cmd, |
||||||
|
Database: MyDB, |
||||||
|
} |
||||||
|
if response, err := clnt.Query(q); err == nil { |
||||||
|
if response.Error() != nil { |
||||||
|
return res, response.Error() |
||||||
|
} |
||||||
|
res = response.Results |
||||||
|
} else { |
||||||
|
return res, err |
||||||
|
} |
||||||
|
return res, nil |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
#### Creating a Database |
||||||
|
|
||||||
|
```go |
||||||
|
_, err := queryDB(clnt, fmt.Sprintf("CREATE DATABASE %s", MyDB)) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
#### Count Records |
||||||
|
|
||||||
|
```go |
||||||
|
q := fmt.Sprintf("SELECT count(%s) FROM %s", "value", MyMeasurement) |
||||||
|
res, err := queryDB(clnt, q) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
count := res[0].Series[0].Values[0][1] |
||||||
|
log.Printf("Found a total of %v records\n", count) |
||||||
|
``` |
||||||
|
|
||||||
|
#### Find the last 10 _shapes_ records |
||||||
|
|
||||||
|
```go |
||||||
|
q := fmt.Sprintf("SELECT * FROM %s LIMIT %d", MyMeasurement, 10) |
||||||
|
res, err = queryDB(clnt, q) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
for i, row := range res[0].Series[0].Values { |
||||||
|
t, err := time.Parse(time.RFC3339, row[0].(string)) |
||||||
|
if err != nil { |
||||||
|
log.Fatal(err) |
||||||
|
} |
||||||
|
val := row[1].(string) |
||||||
|
log.Printf("[%2d] %s: %s\n", i, t.Format(time.Stamp), val) |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
### Using the UDP Client |
||||||
|
|
||||||
|
The **InfluxDB** client also supports writing over UDP. |
||||||
|
|
||||||
|
```go |
||||||
|
func WriteUDP() { |
||||||
|
// Make client |
||||||
|
c, err := client.NewUDPClient("localhost:8089") |
||||||
|
if err != nil { |
||||||
|
panic(err.Error()) |
||||||
|
} |
||||||
|
|
||||||
|
// Create a new point batch |
||||||
|
bp, _ := client.NewBatchPoints(client.BatchPointsConfig{ |
||||||
|
Precision: "s", |
||||||
|
}) |
||||||
|
|
||||||
|
// Create a point and add to batch |
||||||
|
tags := map[string]string{"cpu": "cpu-total"} |
||||||
|
fields := map[string]interface{}{ |
||||||
|
"idle": 10.1, |
||||||
|
"system": 53.3, |
||||||
|
"user": 46.6, |
||||||
|
} |
||||||
|
pt, err := client.NewPoint("cpu_usage", tags, fields, time.Now()) |
||||||
|
if err != nil { |
||||||
|
panic(err.Error()) |
||||||
|
} |
||||||
|
bp.AddPoint(pt) |
||||||
|
|
||||||
|
// Write the batch |
||||||
|
c.Write(bp) |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
### Point Splitting |
||||||
|
|
||||||
|
The UDP client now supports splitting single points that exceed the configured |
||||||
|
payload size. The logic for processing each point is listed here, starting with |
||||||
|
an empty payload. |
||||||
|
|
||||||
|
1. If adding the point to the current (non-empty) payload would exceed the |
||||||
|
configured size, send the current payload. Otherwise, add it to the current |
||||||
|
payload. |
||||||
|
1. If the point is smaller than the configured size, add it to the payload. |
||||||
|
1. If the point has no timestamp, just try to send the entire point as a single |
||||||
|
UDP payload, and process the next point. |
||||||
|
1. Since the point has a timestamp, re-use the existing measurement name, |
||||||
|
tagset, and timestamp and create multiple new points by splitting up the |
||||||
|
fields. The per-point length will be kept close to the configured size, |
||||||
|
staying under it if possible. This does mean that one large field, maybe a |
||||||
|
long string, could be sent as a larger-than-configured payload. |
||||||
|
|
||||||
|
The above logic attempts to respect configured payload sizes, but not sacrifice |
||||||
|
any data integrity. Points without a timestamp can't be split, as that may |
||||||
|
cause fields to have differing timestamps when processed by the server. |
||||||
|
|
||||||
|
## Go Docs |
||||||
|
|
||||||
|
Please refer to |
||||||
|
[http://godoc.org/github.com/influxdata/influxdb/client/v2](http://godoc.org/github.com/influxdata/influxdb/client/v2) |
||||||
|
for documentation. |
||||||
|
|
||||||
|
## See Also |
||||||
|
|
||||||
|
You can also examine how the client library is used by the |
||||||
|
[InfluxDB CLI](https://github.com/influxdata/influxdb/blob/master/cmd/influx/main.go). |
||||||
@ -0,0 +1,840 @@ |
|||||||
|
// Package client implements a now-deprecated client for InfluxDB;
|
||||||
|
// use github.com/influxdata/influxdb/client/v2 instead.
|
||||||
|
package client // import "github.com/influxdata/influxdb/client"
|
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"crypto/tls" |
||||||
|
"encoding/json" |
||||||
|
"errors" |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
"io/ioutil" |
||||||
|
"net" |
||||||
|
"net/http" |
||||||
|
"net/url" |
||||||
|
"strconv" |
||||||
|
"strings" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/influxdata/influxdb/models" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
// DefaultHost is the default host used to connect to an InfluxDB instance
|
||||||
|
DefaultHost = "localhost" |
||||||
|
|
||||||
|
// DefaultPort is the default port used to connect to an InfluxDB instance
|
||||||
|
DefaultPort = 8086 |
||||||
|
|
||||||
|
// DefaultTimeout is the default connection timeout used to connect to an InfluxDB instance
|
||||||
|
DefaultTimeout = 0 |
||||||
|
) |
||||||
|
|
||||||
|
// Query is used to send a command to the server. Both Command and Database are required.
|
||||||
|
type Query struct { |
||||||
|
Command string |
||||||
|
Database string |
||||||
|
|
||||||
|
// Chunked tells the server to send back chunked responses. This places
|
||||||
|
// less load on the server by sending back chunks of the response rather
|
||||||
|
// than waiting for the entire response all at once.
|
||||||
|
Chunked bool |
||||||
|
|
||||||
|
// ChunkSize sets the maximum number of rows that will be returned per
|
||||||
|
// chunk. Chunks are either divided based on their series or if they hit
|
||||||
|
// the chunk size limit.
|
||||||
|
//
|
||||||
|
// Chunked must be set to true for this option to be used.
|
||||||
|
ChunkSize int |
||||||
|
} |
||||||
|
|
||||||
|
// ParseConnectionString will parse a string to create a valid connection URL
|
||||||
|
func ParseConnectionString(path string, ssl bool) (url.URL, error) { |
||||||
|
var host string |
||||||
|
var port int |
||||||
|
|
||||||
|
h, p, err := net.SplitHostPort(path) |
||||||
|
if err != nil { |
||||||
|
if path == "" { |
||||||
|
host = DefaultHost |
||||||
|
} else { |
||||||
|
host = path |
||||||
|
} |
||||||
|
// If they didn't specify a port, always use the default port
|
||||||
|
port = DefaultPort |
||||||
|
} else { |
||||||
|
host = h |
||||||
|
port, err = strconv.Atoi(p) |
||||||
|
if err != nil { |
||||||
|
return url.URL{}, fmt.Errorf("invalid port number %q: %s\n", path, err) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
u := url.URL{ |
||||||
|
Scheme: "http", |
||||||
|
} |
||||||
|
if ssl { |
||||||
|
u.Scheme = "https" |
||||||
|
} |
||||||
|
|
||||||
|
u.Host = net.JoinHostPort(host, strconv.Itoa(port)) |
||||||
|
|
||||||
|
return u, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Config is used to specify what server to connect to.
|
||||||
|
// URL: The URL of the server connecting to.
|
||||||
|
// Username/Password are optional. They will be passed via basic auth if provided.
|
||||||
|
// UserAgent: If not provided, will default "InfluxDBClient",
|
||||||
|
// Timeout: If not provided, will default to 0 (no timeout)
|
||||||
|
type Config struct { |
||||||
|
URL url.URL |
||||||
|
UnixSocket string |
||||||
|
Username string |
||||||
|
Password string |
||||||
|
UserAgent string |
||||||
|
Timeout time.Duration |
||||||
|
Precision string |
||||||
|
WriteConsistency string |
||||||
|
UnsafeSsl bool |
||||||
|
} |
||||||
|
|
||||||
|
// NewConfig will create a config to be used in connecting to the client
|
||||||
|
func NewConfig() Config { |
||||||
|
return Config{ |
||||||
|
Timeout: DefaultTimeout, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Client is used to make calls to the server.
|
||||||
|
type Client struct { |
||||||
|
url url.URL |
||||||
|
unixSocket string |
||||||
|
username string |
||||||
|
password string |
||||||
|
httpClient *http.Client |
||||||
|
userAgent string |
||||||
|
precision string |
||||||
|
} |
||||||
|
|
||||||
|
const ( |
||||||
|
// ConsistencyOne requires at least one data node acknowledged a write.
|
||||||
|
ConsistencyOne = "one" |
||||||
|
|
||||||
|
// ConsistencyAll requires all data nodes to acknowledge a write.
|
||||||
|
ConsistencyAll = "all" |
||||||
|
|
||||||
|
// ConsistencyQuorum requires a quorum of data nodes to acknowledge a write.
|
||||||
|
ConsistencyQuorum = "quorum" |
||||||
|
|
||||||
|
// ConsistencyAny allows for hinted hand off, potentially no write happened yet.
|
||||||
|
ConsistencyAny = "any" |
||||||
|
) |
||||||
|
|
||||||
|
// NewClient will instantiate and return a connected client to issue commands to the server.
|
||||||
|
func NewClient(c Config) (*Client, error) { |
||||||
|
tlsConfig := &tls.Config{ |
||||||
|
InsecureSkipVerify: c.UnsafeSsl, |
||||||
|
} |
||||||
|
|
||||||
|
tr := &http.Transport{ |
||||||
|
TLSClientConfig: tlsConfig, |
||||||
|
} |
||||||
|
|
||||||
|
if c.UnixSocket != "" { |
||||||
|
// No need for compression in local communications.
|
||||||
|
tr.DisableCompression = true |
||||||
|
|
||||||
|
tr.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) { |
||||||
|
return net.Dial("unix", c.UnixSocket) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
client := Client{ |
||||||
|
url: c.URL, |
||||||
|
unixSocket: c.UnixSocket, |
||||||
|
username: c.Username, |
||||||
|
password: c.Password, |
||||||
|
httpClient: &http.Client{Timeout: c.Timeout, Transport: tr}, |
||||||
|
userAgent: c.UserAgent, |
||||||
|
precision: c.Precision, |
||||||
|
} |
||||||
|
if client.userAgent == "" { |
||||||
|
client.userAgent = "InfluxDBClient" |
||||||
|
} |
||||||
|
return &client, nil |
||||||
|
} |
||||||
|
|
||||||
|
// SetAuth will update the username and passwords
|
||||||
|
func (c *Client) SetAuth(u, p string) { |
||||||
|
c.username = u |
||||||
|
c.password = p |
||||||
|
} |
||||||
|
|
||||||
|
// SetPrecision will update the precision
|
||||||
|
func (c *Client) SetPrecision(precision string) { |
||||||
|
c.precision = precision |
||||||
|
} |
||||||
|
|
||||||
|
// Query sends a command to the server and returns the Response
|
||||||
|
func (c *Client) Query(q Query) (*Response, error) { |
||||||
|
return c.QueryContext(context.Background(), q) |
||||||
|
} |
||||||
|
|
||||||
|
// QueryContext sends a command to the server and returns the Response
|
||||||
|
// It uses a context that can be cancelled by the command line client
|
||||||
|
func (c *Client) QueryContext(ctx context.Context, q Query) (*Response, error) { |
||||||
|
u := c.url |
||||||
|
|
||||||
|
u.Path = "query" |
||||||
|
values := u.Query() |
||||||
|
values.Set("q", q.Command) |
||||||
|
values.Set("db", q.Database) |
||||||
|
if q.Chunked { |
||||||
|
values.Set("chunked", "true") |
||||||
|
if q.ChunkSize > 0 { |
||||||
|
values.Set("chunk_size", strconv.Itoa(q.ChunkSize)) |
||||||
|
} |
||||||
|
} |
||||||
|
if c.precision != "" { |
||||||
|
values.Set("epoch", c.precision) |
||||||
|
} |
||||||
|
u.RawQuery = values.Encode() |
||||||
|
|
||||||
|
req, err := http.NewRequest("POST", u.String(), nil) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
req.Header.Set("User-Agent", c.userAgent) |
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
req = req.WithContext(ctx) |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
var response Response |
||||||
|
if q.Chunked { |
||||||
|
cr := NewChunkedResponse(resp.Body) |
||||||
|
for { |
||||||
|
r, err := cr.NextResponse() |
||||||
|
if err != nil { |
||||||
|
// If we got an error while decoding the response, send that back.
|
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if r == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
response.Results = append(response.Results, r.Results...) |
||||||
|
if r.Err != nil { |
||||||
|
response.Err = r.Err |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} else { |
||||||
|
dec := json.NewDecoder(resp.Body) |
||||||
|
dec.UseNumber() |
||||||
|
if err := dec.Decode(&response); err != nil { |
||||||
|
// Ignore EOF errors if we got an invalid status code.
|
||||||
|
if !(err == io.EOF && resp.StatusCode != http.StatusOK) { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// If we don't have an error in our json response, and didn't get StatusOK,
|
||||||
|
// then send back an error.
|
||||||
|
if resp.StatusCode != http.StatusOK && response.Error() == nil { |
||||||
|
return &response, fmt.Errorf("received status code %d from server", resp.StatusCode) |
||||||
|
} |
||||||
|
return &response, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Write takes BatchPoints and allows for writing of multiple points with defaults
|
||||||
|
// If successful, error is nil and Response is nil
|
||||||
|
// If an error occurs, Response may contain additional information if populated.
|
||||||
|
func (c *Client) Write(bp BatchPoints) (*Response, error) { |
||||||
|
u := c.url |
||||||
|
u.Path = "write" |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
for _, p := range bp.Points { |
||||||
|
err := checkPointTypes(p) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
if p.Raw != "" { |
||||||
|
if _, err := b.WriteString(p.Raw); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} else { |
||||||
|
for k, v := range bp.Tags { |
||||||
|
if p.Tags == nil { |
||||||
|
p.Tags = make(map[string]string, len(bp.Tags)) |
||||||
|
} |
||||||
|
p.Tags[k] = v |
||||||
|
} |
||||||
|
|
||||||
|
if _, err := b.WriteString(p.MarshalString()); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if err := b.WriteByte('\n'); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
req, err := http.NewRequest("POST", u.String(), &b) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
req.Header.Set("Content-Type", "") |
||||||
|
req.Header.Set("User-Agent", c.userAgent) |
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
precision := bp.Precision |
||||||
|
if precision == "" { |
||||||
|
precision = "ns" |
||||||
|
} |
||||||
|
|
||||||
|
params := req.URL.Query() |
||||||
|
params.Set("db", bp.Database) |
||||||
|
params.Set("rp", bp.RetentionPolicy) |
||||||
|
params.Set("precision", precision) |
||||||
|
params.Set("consistency", bp.WriteConsistency) |
||||||
|
req.URL.RawQuery = params.Encode() |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
var response Response |
||||||
|
body, err := ioutil.ReadAll(resp.Body) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK { |
||||||
|
var err = fmt.Errorf(string(body)) |
||||||
|
response.Err = err |
||||||
|
return &response, err |
||||||
|
} |
||||||
|
|
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// WriteLineProtocol takes a string with line returns to delimit each write
|
||||||
|
// If successful, error is nil and Response is nil
|
||||||
|
// If an error occurs, Response may contain additional information if populated.
|
||||||
|
func (c *Client) WriteLineProtocol(data, database, retentionPolicy, precision, writeConsistency string) (*Response, error) { |
||||||
|
u := c.url |
||||||
|
u.Path = "write" |
||||||
|
|
||||||
|
r := strings.NewReader(data) |
||||||
|
|
||||||
|
req, err := http.NewRequest("POST", u.String(), r) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
req.Header.Set("Content-Type", "") |
||||||
|
req.Header.Set("User-Agent", c.userAgent) |
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
params := req.URL.Query() |
||||||
|
params.Set("db", database) |
||||||
|
params.Set("rp", retentionPolicy) |
||||||
|
params.Set("precision", precision) |
||||||
|
params.Set("consistency", writeConsistency) |
||||||
|
req.URL.RawQuery = params.Encode() |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
var response Response |
||||||
|
body, err := ioutil.ReadAll(resp.Body) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK { |
||||||
|
err := fmt.Errorf(string(body)) |
||||||
|
response.Err = err |
||||||
|
return &response, err |
||||||
|
} |
||||||
|
|
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Ping will check to see if the server is up
|
||||||
|
// Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
|
||||||
|
func (c *Client) Ping() (time.Duration, string, error) { |
||||||
|
now := time.Now() |
||||||
|
u := c.url |
||||||
|
u.Path = "ping" |
||||||
|
|
||||||
|
req, err := http.NewRequest("GET", u.String(), nil) |
||||||
|
if err != nil { |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
req.Header.Set("User-Agent", c.userAgent) |
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
version := resp.Header.Get("X-Influxdb-Version") |
||||||
|
return time.Since(now), version, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Structs
|
||||||
|
|
||||||
|
// Message represents a user message.
|
||||||
|
type Message struct { |
||||||
|
Level string `json:"level,omitempty"` |
||||||
|
Text string `json:"text,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// Result represents a resultset returned from a single statement.
|
||||||
|
type Result struct { |
||||||
|
Series []models.Row |
||||||
|
Messages []*Message |
||||||
|
Err error |
||||||
|
} |
||||||
|
|
||||||
|
// MarshalJSON encodes the result into JSON.
|
||||||
|
func (r *Result) MarshalJSON() ([]byte, error) { |
||||||
|
// Define a struct that outputs "error" as a string.
|
||||||
|
var o struct { |
||||||
|
Series []models.Row `json:"series,omitempty"` |
||||||
|
Messages []*Message `json:"messages,omitempty"` |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// Copy fields to output struct.
|
||||||
|
o.Series = r.Series |
||||||
|
o.Messages = r.Messages |
||||||
|
if r.Err != nil { |
||||||
|
o.Err = r.Err.Error() |
||||||
|
} |
||||||
|
|
||||||
|
return json.Marshal(&o) |
||||||
|
} |
||||||
|
|
||||||
|
// UnmarshalJSON decodes the data into the Result struct
|
||||||
|
func (r *Result) UnmarshalJSON(b []byte) error { |
||||||
|
var o struct { |
||||||
|
Series []models.Row `json:"series,omitempty"` |
||||||
|
Messages []*Message `json:"messages,omitempty"` |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
dec := json.NewDecoder(bytes.NewBuffer(b)) |
||||||
|
dec.UseNumber() |
||||||
|
err := dec.Decode(&o) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
r.Series = o.Series |
||||||
|
r.Messages = o.Messages |
||||||
|
if o.Err != "" { |
||||||
|
r.Err = errors.New(o.Err) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Response represents a list of statement results.
|
||||||
|
type Response struct { |
||||||
|
Results []Result |
||||||
|
Err error |
||||||
|
} |
||||||
|
|
||||||
|
// MarshalJSON encodes the response into JSON.
|
||||||
|
func (r *Response) MarshalJSON() ([]byte, error) { |
||||||
|
// Define a struct that outputs "error" as a string.
|
||||||
|
var o struct { |
||||||
|
Results []Result `json:"results,omitempty"` |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// Copy fields to output struct.
|
||||||
|
o.Results = r.Results |
||||||
|
if r.Err != nil { |
||||||
|
o.Err = r.Err.Error() |
||||||
|
} |
||||||
|
|
||||||
|
return json.Marshal(&o) |
||||||
|
} |
||||||
|
|
||||||
|
// UnmarshalJSON decodes the data into the Response struct
|
||||||
|
func (r *Response) UnmarshalJSON(b []byte) error { |
||||||
|
var o struct { |
||||||
|
Results []Result `json:"results,omitempty"` |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
dec := json.NewDecoder(bytes.NewBuffer(b)) |
||||||
|
dec.UseNumber() |
||||||
|
err := dec.Decode(&o) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
r.Results = o.Results |
||||||
|
if o.Err != "" { |
||||||
|
r.Err = errors.New(o.Err) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Error returns the first error from any statement.
|
||||||
|
// Returns nil if no errors occurred on any statements.
|
||||||
|
func (r *Response) Error() error { |
||||||
|
if r.Err != nil { |
||||||
|
return r.Err |
||||||
|
} |
||||||
|
for _, result := range r.Results { |
||||||
|
if result.Err != nil { |
||||||
|
return result.Err |
||||||
|
} |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// duplexReader reads responses and writes it to another writer while
|
||||||
|
// satisfying the reader interface.
|
||||||
|
type duplexReader struct { |
||||||
|
r io.Reader |
||||||
|
w io.Writer |
||||||
|
} |
||||||
|
|
||||||
|
func (r *duplexReader) Read(p []byte) (n int, err error) { |
||||||
|
n, err = r.r.Read(p) |
||||||
|
if err == nil { |
||||||
|
r.w.Write(p[:n]) |
||||||
|
} |
||||||
|
return n, err |
||||||
|
} |
||||||
|
|
||||||
|
// ChunkedResponse represents a response from the server that
|
||||||
|
// uses chunking to stream the output.
|
||||||
|
type ChunkedResponse struct { |
||||||
|
dec *json.Decoder |
||||||
|
duplex *duplexReader |
||||||
|
buf bytes.Buffer |
||||||
|
} |
||||||
|
|
||||||
|
// NewChunkedResponse reads a stream and produces responses from the stream.
|
||||||
|
func NewChunkedResponse(r io.Reader) *ChunkedResponse { |
||||||
|
resp := &ChunkedResponse{} |
||||||
|
resp.duplex = &duplexReader{r: r, w: &resp.buf} |
||||||
|
resp.dec = json.NewDecoder(resp.duplex) |
||||||
|
resp.dec.UseNumber() |
||||||
|
return resp |
||||||
|
} |
||||||
|
|
||||||
|
// NextResponse reads the next line of the stream and returns a response.
|
||||||
|
func (r *ChunkedResponse) NextResponse() (*Response, error) { |
||||||
|
var response Response |
||||||
|
if err := r.dec.Decode(&response); err != nil { |
||||||
|
if err == io.EOF { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
// A decoding error happened. This probably means the server crashed
|
||||||
|
// and sent a last-ditch error message to us. Ensure we have read the
|
||||||
|
// entirety of the connection to get any remaining error text.
|
||||||
|
io.Copy(ioutil.Discard, r.duplex) |
||||||
|
return nil, errors.New(strings.TrimSpace(r.buf.String())) |
||||||
|
} |
||||||
|
r.buf.Reset() |
||||||
|
return &response, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Point defines the fields that will be written to the database
|
||||||
|
// Measurement, Time, and Fields are required
|
||||||
|
// Precision can be specified if the time is in epoch format (integer).
|
||||||
|
// Valid values for Precision are n, u, ms, s, m, and h
|
||||||
|
type Point struct { |
||||||
|
Measurement string |
||||||
|
Tags map[string]string |
||||||
|
Time time.Time |
||||||
|
Fields map[string]interface{} |
||||||
|
Precision string |
||||||
|
Raw string |
||||||
|
} |
||||||
|
|
||||||
|
// MarshalJSON will format the time in RFC3339Nano
|
||||||
|
// Precision is also ignored as it is only used for writing, not reading
|
||||||
|
// Or another way to say it is we always send back in nanosecond precision
|
||||||
|
func (p *Point) MarshalJSON() ([]byte, error) { |
||||||
|
point := struct { |
||||||
|
Measurement string `json:"measurement,omitempty"` |
||||||
|
Tags map[string]string `json:"tags,omitempty"` |
||||||
|
Time string `json:"time,omitempty"` |
||||||
|
Fields map[string]interface{} `json:"fields,omitempty"` |
||||||
|
Precision string `json:"precision,omitempty"` |
||||||
|
}{ |
||||||
|
Measurement: p.Measurement, |
||||||
|
Tags: p.Tags, |
||||||
|
Fields: p.Fields, |
||||||
|
Precision: p.Precision, |
||||||
|
} |
||||||
|
// Let it omit empty if it's really zero
|
||||||
|
if !p.Time.IsZero() { |
||||||
|
point.Time = p.Time.UTC().Format(time.RFC3339Nano) |
||||||
|
} |
||||||
|
return json.Marshal(&point) |
||||||
|
} |
||||||
|
|
||||||
|
// MarshalString renders string representation of a Point with specified
|
||||||
|
// precision. The default precision is nanoseconds.
|
||||||
|
func (p *Point) MarshalString() string { |
||||||
|
pt, err := models.NewPoint(p.Measurement, models.NewTags(p.Tags), p.Fields, p.Time) |
||||||
|
if err != nil { |
||||||
|
return "# ERROR: " + err.Error() + " " + p.Measurement |
||||||
|
} |
||||||
|
if p.Precision == "" || p.Precision == "ns" || p.Precision == "n" { |
||||||
|
return pt.String() |
||||||
|
} |
||||||
|
return pt.PrecisionString(p.Precision) |
||||||
|
} |
||||||
|
|
||||||
|
// UnmarshalJSON decodes the data into the Point struct
|
||||||
|
func (p *Point) UnmarshalJSON(b []byte) error { |
||||||
|
var normal struct { |
||||||
|
Measurement string `json:"measurement"` |
||||||
|
Tags map[string]string `json:"tags"` |
||||||
|
Time time.Time `json:"time"` |
||||||
|
Precision string `json:"precision"` |
||||||
|
Fields map[string]interface{} `json:"fields"` |
||||||
|
} |
||||||
|
var epoch struct { |
||||||
|
Measurement string `json:"measurement"` |
||||||
|
Tags map[string]string `json:"tags"` |
||||||
|
Time *int64 `json:"time"` |
||||||
|
Precision string `json:"precision"` |
||||||
|
Fields map[string]interface{} `json:"fields"` |
||||||
|
} |
||||||
|
|
||||||
|
if err := func() error { |
||||||
|
var err error |
||||||
|
dec := json.NewDecoder(bytes.NewBuffer(b)) |
||||||
|
dec.UseNumber() |
||||||
|
if err = dec.Decode(&epoch); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// Convert from epoch to time.Time, but only if Time
|
||||||
|
// was actually set.
|
||||||
|
var ts time.Time |
||||||
|
if epoch.Time != nil { |
||||||
|
ts, err = EpochToTime(*epoch.Time, epoch.Precision) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
p.Measurement = epoch.Measurement |
||||||
|
p.Tags = epoch.Tags |
||||||
|
p.Time = ts |
||||||
|
p.Precision = epoch.Precision |
||||||
|
p.Fields = normalizeFields(epoch.Fields) |
||||||
|
return nil |
||||||
|
}(); err == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
dec := json.NewDecoder(bytes.NewBuffer(b)) |
||||||
|
dec.UseNumber() |
||||||
|
if err := dec.Decode(&normal); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
normal.Time = SetPrecision(normal.Time, normal.Precision) |
||||||
|
p.Measurement = normal.Measurement |
||||||
|
p.Tags = normal.Tags |
||||||
|
p.Time = normal.Time |
||||||
|
p.Precision = normal.Precision |
||||||
|
p.Fields = normalizeFields(normal.Fields) |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Remove any notion of json.Number
|
||||||
|
func normalizeFields(fields map[string]interface{}) map[string]interface{} { |
||||||
|
newFields := map[string]interface{}{} |
||||||
|
|
||||||
|
for k, v := range fields { |
||||||
|
switch v := v.(type) { |
||||||
|
case json.Number: |
||||||
|
jv, e := v.Float64() |
||||||
|
if e != nil { |
||||||
|
panic(fmt.Sprintf("unable to convert json.Number to float64: %s", e)) |
||||||
|
} |
||||||
|
newFields[k] = jv |
||||||
|
default: |
||||||
|
newFields[k] = v |
||||||
|
} |
||||||
|
} |
||||||
|
return newFields |
||||||
|
} |
||||||
|
|
||||||
|
// BatchPoints is used to send batched data in a single write.
|
||||||
|
// Database and Points are required
|
||||||
|
// If no retention policy is specified, it will use the databases default retention policy.
|
||||||
|
// If tags are specified, they will be "merged" with all points. If a point already has that tag, it will be ignored.
|
||||||
|
// If time is specified, it will be applied to any point with an empty time.
|
||||||
|
// Precision can be specified if the time is in epoch format (integer).
|
||||||
|
// Valid values for Precision are n, u, ms, s, m, and h
|
||||||
|
type BatchPoints struct { |
||||||
|
Points []Point `json:"points,omitempty"` |
||||||
|
Database string `json:"database,omitempty"` |
||||||
|
RetentionPolicy string `json:"retentionPolicy,omitempty"` |
||||||
|
Tags map[string]string `json:"tags,omitempty"` |
||||||
|
Time time.Time `json:"time,omitempty"` |
||||||
|
Precision string `json:"precision,omitempty"` |
||||||
|
WriteConsistency string `json:"-"` |
||||||
|
} |
||||||
|
|
||||||
|
// UnmarshalJSON decodes the data into the BatchPoints struct
|
||||||
|
func (bp *BatchPoints) UnmarshalJSON(b []byte) error { |
||||||
|
var normal struct { |
||||||
|
Points []Point `json:"points"` |
||||||
|
Database string `json:"database"` |
||||||
|
RetentionPolicy string `json:"retentionPolicy"` |
||||||
|
Tags map[string]string `json:"tags"` |
||||||
|
Time time.Time `json:"time"` |
||||||
|
Precision string `json:"precision"` |
||||||
|
} |
||||||
|
var epoch struct { |
||||||
|
Points []Point `json:"points"` |
||||||
|
Database string `json:"database"` |
||||||
|
RetentionPolicy string `json:"retentionPolicy"` |
||||||
|
Tags map[string]string `json:"tags"` |
||||||
|
Time *int64 `json:"time"` |
||||||
|
Precision string `json:"precision"` |
||||||
|
} |
||||||
|
|
||||||
|
if err := func() error { |
||||||
|
var err error |
||||||
|
if err = json.Unmarshal(b, &epoch); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// Convert from epoch to time.Time
|
||||||
|
var ts time.Time |
||||||
|
if epoch.Time != nil { |
||||||
|
ts, err = EpochToTime(*epoch.Time, epoch.Precision) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
bp.Points = epoch.Points |
||||||
|
bp.Database = epoch.Database |
||||||
|
bp.RetentionPolicy = epoch.RetentionPolicy |
||||||
|
bp.Tags = epoch.Tags |
||||||
|
bp.Time = ts |
||||||
|
bp.Precision = epoch.Precision |
||||||
|
return nil |
||||||
|
}(); err == nil { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
if err := json.Unmarshal(b, &normal); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
normal.Time = SetPrecision(normal.Time, normal.Precision) |
||||||
|
bp.Points = normal.Points |
||||||
|
bp.Database = normal.Database |
||||||
|
bp.RetentionPolicy = normal.RetentionPolicy |
||||||
|
bp.Tags = normal.Tags |
||||||
|
bp.Time = normal.Time |
||||||
|
bp.Precision = normal.Precision |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// utility functions
|
||||||
|
|
||||||
|
// Addr provides the current url as a string of the server the client is connected to.
|
||||||
|
func (c *Client) Addr() string { |
||||||
|
if c.unixSocket != "" { |
||||||
|
return c.unixSocket |
||||||
|
} |
||||||
|
return c.url.String() |
||||||
|
} |
||||||
|
|
||||||
|
// checkPointTypes ensures no unsupported types are submitted to influxdb, returning error if they are found.
|
||||||
|
func checkPointTypes(p Point) error { |
||||||
|
for _, v := range p.Fields { |
||||||
|
switch v.(type) { |
||||||
|
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool, string, nil: |
||||||
|
return nil |
||||||
|
default: |
||||||
|
return fmt.Errorf("unsupported point type: %T", v) |
||||||
|
} |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// helper functions
|
||||||
|
|
||||||
|
// EpochToTime takes a unix epoch time and uses precision to return back a time.Time
|
||||||
|
func EpochToTime(epoch int64, precision string) (time.Time, error) { |
||||||
|
if precision == "" { |
||||||
|
precision = "s" |
||||||
|
} |
||||||
|
var t time.Time |
||||||
|
switch precision { |
||||||
|
case "h": |
||||||
|
t = time.Unix(0, epoch*int64(time.Hour)) |
||||||
|
case "m": |
||||||
|
t = time.Unix(0, epoch*int64(time.Minute)) |
||||||
|
case "s": |
||||||
|
t = time.Unix(0, epoch*int64(time.Second)) |
||||||
|
case "ms": |
||||||
|
t = time.Unix(0, epoch*int64(time.Millisecond)) |
||||||
|
case "u": |
||||||
|
t = time.Unix(0, epoch*int64(time.Microsecond)) |
||||||
|
case "n": |
||||||
|
t = time.Unix(0, epoch) |
||||||
|
default: |
||||||
|
return time.Time{}, fmt.Errorf("Unknown precision %q", precision) |
||||||
|
} |
||||||
|
return t, nil |
||||||
|
} |
||||||
|
|
||||||
|
// SetPrecision will round a time to the specified precision
|
||||||
|
func SetPrecision(t time.Time, precision string) time.Time { |
||||||
|
switch precision { |
||||||
|
case "n": |
||||||
|
case "u": |
||||||
|
return t.Round(time.Microsecond) |
||||||
|
case "ms": |
||||||
|
return t.Round(time.Millisecond) |
||||||
|
case "s": |
||||||
|
return t.Round(time.Second) |
||||||
|
case "m": |
||||||
|
return t.Round(time.Minute) |
||||||
|
case "h": |
||||||
|
return t.Round(time.Hour) |
||||||
|
} |
||||||
|
return t |
||||||
|
} |
||||||
@ -0,0 +1,635 @@ |
|||||||
|
// Package client (v2) is the current official Go client for InfluxDB.
|
||||||
|
package client // import "github.com/influxdata/influxdb/client/v2"
|
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"crypto/tls" |
||||||
|
"encoding/json" |
||||||
|
"errors" |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
"io/ioutil" |
||||||
|
"mime" |
||||||
|
"net/http" |
||||||
|
"net/url" |
||||||
|
"strconv" |
||||||
|
"strings" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/influxdata/influxdb/models" |
||||||
|
) |
||||||
|
|
||||||
|
// HTTPConfig is the config data needed to create an HTTP Client.
|
||||||
|
type HTTPConfig struct { |
||||||
|
// Addr should be of the form "http://host:port"
|
||||||
|
// or "http://[ipv6-host%zone]:port".
|
||||||
|
Addr string |
||||||
|
|
||||||
|
// Username is the influxdb username, optional.
|
||||||
|
Username string |
||||||
|
|
||||||
|
// Password is the influxdb password, optional.
|
||||||
|
Password string |
||||||
|
|
||||||
|
// UserAgent is the http User Agent, defaults to "InfluxDBClient".
|
||||||
|
UserAgent string |
||||||
|
|
||||||
|
// Timeout for influxdb writes, defaults to no timeout.
|
||||||
|
Timeout time.Duration |
||||||
|
|
||||||
|
// InsecureSkipVerify gets passed to the http client, if true, it will
|
||||||
|
// skip https certificate verification. Defaults to false.
|
||||||
|
InsecureSkipVerify bool |
||||||
|
|
||||||
|
// TLSConfig allows the user to set their own TLS config for the HTTP
|
||||||
|
// Client. If set, this option overrides InsecureSkipVerify.
|
||||||
|
TLSConfig *tls.Config |
||||||
|
} |
||||||
|
|
||||||
|
// BatchPointsConfig is the config data needed to create an instance of the BatchPoints struct.
|
||||||
|
type BatchPointsConfig struct { |
||||||
|
// Precision is the write precision of the points, defaults to "ns".
|
||||||
|
Precision string |
||||||
|
|
||||||
|
// Database is the database to write points to.
|
||||||
|
Database string |
||||||
|
|
||||||
|
// RetentionPolicy is the retention policy of the points.
|
||||||
|
RetentionPolicy string |
||||||
|
|
||||||
|
// Write consistency is the number of servers required to confirm write.
|
||||||
|
WriteConsistency string |
||||||
|
} |
||||||
|
|
||||||
|
// Client is a client interface for writing & querying the database.
|
||||||
|
type Client interface { |
||||||
|
// Ping checks that status of cluster, and will always return 0 time and no
|
||||||
|
// error for UDP clients.
|
||||||
|
Ping(timeout time.Duration) (time.Duration, string, error) |
||||||
|
|
||||||
|
// Write takes a BatchPoints object and writes all Points to InfluxDB.
|
||||||
|
Write(bp BatchPoints) error |
||||||
|
|
||||||
|
// Query makes an InfluxDB Query on the database. This will fail if using
|
||||||
|
// the UDP client.
|
||||||
|
Query(q Query) (*Response, error) |
||||||
|
|
||||||
|
// Close releases any resources a Client may be using.
|
||||||
|
Close() error |
||||||
|
} |
||||||
|
|
||||||
|
// NewHTTPClient returns a new Client from the provided config.
|
||||||
|
// Client is safe for concurrent use by multiple goroutines.
|
||||||
|
func NewHTTPClient(conf HTTPConfig) (Client, error) { |
||||||
|
if conf.UserAgent == "" { |
||||||
|
conf.UserAgent = "InfluxDBClient" |
||||||
|
} |
||||||
|
|
||||||
|
u, err := url.Parse(conf.Addr) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} else if u.Scheme != "http" && u.Scheme != "https" { |
||||||
|
m := fmt.Sprintf("Unsupported protocol scheme: %s, your address"+ |
||||||
|
" must start with http:// or https://", u.Scheme) |
||||||
|
return nil, errors.New(m) |
||||||
|
} |
||||||
|
|
||||||
|
tr := &http.Transport{ |
||||||
|
TLSClientConfig: &tls.Config{ |
||||||
|
InsecureSkipVerify: conf.InsecureSkipVerify, |
||||||
|
}, |
||||||
|
} |
||||||
|
if conf.TLSConfig != nil { |
||||||
|
tr.TLSClientConfig = conf.TLSConfig |
||||||
|
} |
||||||
|
return &client{ |
||||||
|
url: *u, |
||||||
|
username: conf.Username, |
||||||
|
password: conf.Password, |
||||||
|
useragent: conf.UserAgent, |
||||||
|
httpClient: &http.Client{ |
||||||
|
Timeout: conf.Timeout, |
||||||
|
Transport: tr, |
||||||
|
}, |
||||||
|
transport: tr, |
||||||
|
}, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Ping will check to see if the server is up with an optional timeout on waiting for leader.
|
||||||
|
// Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
|
||||||
|
func (c *client) Ping(timeout time.Duration) (time.Duration, string, error) { |
||||||
|
now := time.Now() |
||||||
|
u := c.url |
||||||
|
u.Path = "ping" |
||||||
|
|
||||||
|
req, err := http.NewRequest("GET", u.String(), nil) |
||||||
|
if err != nil { |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
|
||||||
|
req.Header.Set("User-Agent", c.useragent) |
||||||
|
|
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
if timeout > 0 { |
||||||
|
params := req.URL.Query() |
||||||
|
params.Set("wait_for_leader", fmt.Sprintf("%.0fs", timeout.Seconds())) |
||||||
|
req.URL.RawQuery = params.Encode() |
||||||
|
} |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
body, err := ioutil.ReadAll(resp.Body) |
||||||
|
if err != nil { |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
|
||||||
|
if resp.StatusCode != http.StatusNoContent { |
||||||
|
var err = fmt.Errorf(string(body)) |
||||||
|
return 0, "", err |
||||||
|
} |
||||||
|
|
||||||
|
version := resp.Header.Get("X-Influxdb-Version") |
||||||
|
return time.Since(now), version, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Close releases the client's resources.
|
||||||
|
func (c *client) Close() error { |
||||||
|
c.transport.CloseIdleConnections() |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// client is safe for concurrent use as the fields are all read-only
|
||||||
|
// once the client is instantiated.
|
||||||
|
type client struct { |
||||||
|
// N.B - if url.UserInfo is accessed in future modifications to the
|
||||||
|
// methods on client, you will need to syncronise access to url.
|
||||||
|
url url.URL |
||||||
|
username string |
||||||
|
password string |
||||||
|
useragent string |
||||||
|
httpClient *http.Client |
||||||
|
transport *http.Transport |
||||||
|
} |
||||||
|
|
||||||
|
// BatchPoints is an interface into a batched grouping of points to write into
|
||||||
|
// InfluxDB together. BatchPoints is NOT thread-safe, you must create a separate
|
||||||
|
// batch for each goroutine.
|
||||||
|
type BatchPoints interface { |
||||||
|
// AddPoint adds the given point to the Batch of points.
|
||||||
|
AddPoint(p *Point) |
||||||
|
// AddPoints adds the given points to the Batch of points.
|
||||||
|
AddPoints(ps []*Point) |
||||||
|
// Points lists the points in the Batch.
|
||||||
|
Points() []*Point |
||||||
|
|
||||||
|
// Precision returns the currently set precision of this Batch.
|
||||||
|
Precision() string |
||||||
|
// SetPrecision sets the precision of this batch.
|
||||||
|
SetPrecision(s string) error |
||||||
|
|
||||||
|
// Database returns the currently set database of this Batch.
|
||||||
|
Database() string |
||||||
|
// SetDatabase sets the database of this Batch.
|
||||||
|
SetDatabase(s string) |
||||||
|
|
||||||
|
// WriteConsistency returns the currently set write consistency of this Batch.
|
||||||
|
WriteConsistency() string |
||||||
|
// SetWriteConsistency sets the write consistency of this Batch.
|
||||||
|
SetWriteConsistency(s string) |
||||||
|
|
||||||
|
// RetentionPolicy returns the currently set retention policy of this Batch.
|
||||||
|
RetentionPolicy() string |
||||||
|
// SetRetentionPolicy sets the retention policy of this Batch.
|
||||||
|
SetRetentionPolicy(s string) |
||||||
|
} |
||||||
|
|
||||||
|
// NewBatchPoints returns a BatchPoints interface based on the given config.
|
||||||
|
func NewBatchPoints(conf BatchPointsConfig) (BatchPoints, error) { |
||||||
|
if conf.Precision == "" { |
||||||
|
conf.Precision = "ns" |
||||||
|
} |
||||||
|
if _, err := time.ParseDuration("1" + conf.Precision); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
bp := &batchpoints{ |
||||||
|
database: conf.Database, |
||||||
|
precision: conf.Precision, |
||||||
|
retentionPolicy: conf.RetentionPolicy, |
||||||
|
writeConsistency: conf.WriteConsistency, |
||||||
|
} |
||||||
|
return bp, nil |
||||||
|
} |
||||||
|
|
||||||
|
type batchpoints struct { |
||||||
|
points []*Point |
||||||
|
database string |
||||||
|
precision string |
||||||
|
retentionPolicy string |
||||||
|
writeConsistency string |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) AddPoint(p *Point) { |
||||||
|
bp.points = append(bp.points, p) |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) AddPoints(ps []*Point) { |
||||||
|
bp.points = append(bp.points, ps...) |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) Points() []*Point { |
||||||
|
return bp.points |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) Precision() string { |
||||||
|
return bp.precision |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) Database() string { |
||||||
|
return bp.database |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) WriteConsistency() string { |
||||||
|
return bp.writeConsistency |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) RetentionPolicy() string { |
||||||
|
return bp.retentionPolicy |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) SetPrecision(p string) error { |
||||||
|
if _, err := time.ParseDuration("1" + p); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
bp.precision = p |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) SetDatabase(db string) { |
||||||
|
bp.database = db |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) SetWriteConsistency(wc string) { |
||||||
|
bp.writeConsistency = wc |
||||||
|
} |
||||||
|
|
||||||
|
func (bp *batchpoints) SetRetentionPolicy(rp string) { |
||||||
|
bp.retentionPolicy = rp |
||||||
|
} |
||||||
|
|
||||||
|
// Point represents a single data point.
|
||||||
|
type Point struct { |
||||||
|
pt models.Point |
||||||
|
} |
||||||
|
|
||||||
|
// NewPoint returns a point with the given timestamp. If a timestamp is not
|
||||||
|
// given, then data is sent to the database without a timestamp, in which case
|
||||||
|
// the server will assign local time upon reception. NOTE: it is recommended to
|
||||||
|
// send data with a timestamp.
|
||||||
|
func NewPoint( |
||||||
|
name string, |
||||||
|
tags map[string]string, |
||||||
|
fields map[string]interface{}, |
||||||
|
t ...time.Time, |
||||||
|
) (*Point, error) { |
||||||
|
var T time.Time |
||||||
|
if len(t) > 0 { |
||||||
|
T = t[0] |
||||||
|
} |
||||||
|
|
||||||
|
pt, err := models.NewPoint(name, models.NewTags(tags), fields, T) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
return &Point{ |
||||||
|
pt: pt, |
||||||
|
}, nil |
||||||
|
} |
||||||
|
|
||||||
|
// String returns a line-protocol string of the Point.
|
||||||
|
func (p *Point) String() string { |
||||||
|
return p.pt.String() |
||||||
|
} |
||||||
|
|
||||||
|
// PrecisionString returns a line-protocol string of the Point,
|
||||||
|
// with the timestamp formatted for the given precision.
|
||||||
|
func (p *Point) PrecisionString(precison string) string { |
||||||
|
return p.pt.PrecisionString(precison) |
||||||
|
} |
||||||
|
|
||||||
|
// Name returns the measurement name of the point.
|
||||||
|
func (p *Point) Name() string { |
||||||
|
return string(p.pt.Name()) |
||||||
|
} |
||||||
|
|
||||||
|
// Tags returns the tags associated with the point.
|
||||||
|
func (p *Point) Tags() map[string]string { |
||||||
|
return p.pt.Tags().Map() |
||||||
|
} |
||||||
|
|
||||||
|
// Time return the timestamp for the point.
|
||||||
|
func (p *Point) Time() time.Time { |
||||||
|
return p.pt.Time() |
||||||
|
} |
||||||
|
|
||||||
|
// UnixNano returns timestamp of the point in nanoseconds since Unix epoch.
|
||||||
|
func (p *Point) UnixNano() int64 { |
||||||
|
return p.pt.UnixNano() |
||||||
|
} |
||||||
|
|
||||||
|
// Fields returns the fields for the point.
|
||||||
|
func (p *Point) Fields() (map[string]interface{}, error) { |
||||||
|
return p.pt.Fields() |
||||||
|
} |
||||||
|
|
||||||
|
// NewPointFrom returns a point from the provided models.Point.
|
||||||
|
func NewPointFrom(pt models.Point) *Point { |
||||||
|
return &Point{pt: pt} |
||||||
|
} |
||||||
|
|
||||||
|
func (c *client) Write(bp BatchPoints) error { |
||||||
|
var b bytes.Buffer |
||||||
|
|
||||||
|
for _, p := range bp.Points() { |
||||||
|
if _, err := b.WriteString(p.pt.PrecisionString(bp.Precision())); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
if err := b.WriteByte('\n'); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
u := c.url |
||||||
|
u.Path = "write" |
||||||
|
req, err := http.NewRequest("POST", u.String(), &b) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
req.Header.Set("Content-Type", "") |
||||||
|
req.Header.Set("User-Agent", c.useragent) |
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
params := req.URL.Query() |
||||||
|
params.Set("db", bp.Database()) |
||||||
|
params.Set("rp", bp.RetentionPolicy()) |
||||||
|
params.Set("precision", bp.Precision()) |
||||||
|
params.Set("consistency", bp.WriteConsistency()) |
||||||
|
req.URL.RawQuery = params.Encode() |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
body, err := ioutil.ReadAll(resp.Body) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK { |
||||||
|
var err = fmt.Errorf(string(body)) |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Query defines a query to send to the server.
|
||||||
|
type Query struct { |
||||||
|
Command string |
||||||
|
Database string |
||||||
|
Precision string |
||||||
|
Chunked bool |
||||||
|
ChunkSize int |
||||||
|
Parameters map[string]interface{} |
||||||
|
} |
||||||
|
|
||||||
|
// NewQuery returns a query object.
|
||||||
|
// The database and precision arguments can be empty strings if they are not needed for the query.
|
||||||
|
func NewQuery(command, database, precision string) Query { |
||||||
|
return Query{ |
||||||
|
Command: command, |
||||||
|
Database: database, |
||||||
|
Precision: precision, |
||||||
|
Parameters: make(map[string]interface{}), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// NewQueryWithParameters returns a query object.
|
||||||
|
// The database and precision arguments can be empty strings if they are not needed for the query.
|
||||||
|
// parameters is a map of the parameter names used in the command to their values.
|
||||||
|
func NewQueryWithParameters(command, database, precision string, parameters map[string]interface{}) Query { |
||||||
|
return Query{ |
||||||
|
Command: command, |
||||||
|
Database: database, |
||||||
|
Precision: precision, |
||||||
|
Parameters: parameters, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Response represents a list of statement results.
|
||||||
|
type Response struct { |
||||||
|
Results []Result |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// Error returns the first error from any statement.
|
||||||
|
// It returns nil if no errors occurred on any statements.
|
||||||
|
func (r *Response) Error() error { |
||||||
|
if r.Err != "" { |
||||||
|
return fmt.Errorf(r.Err) |
||||||
|
} |
||||||
|
for _, result := range r.Results { |
||||||
|
if result.Err != "" { |
||||||
|
return fmt.Errorf(result.Err) |
||||||
|
} |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Message represents a user message.
|
||||||
|
type Message struct { |
||||||
|
Level string |
||||||
|
Text string |
||||||
|
} |
||||||
|
|
||||||
|
// Result represents a resultset returned from a single statement.
|
||||||
|
type Result struct { |
||||||
|
Series []models.Row |
||||||
|
Messages []*Message |
||||||
|
Err string `json:"error,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// Query sends a command to the server and returns the Response.
|
||||||
|
func (c *client) Query(q Query) (*Response, error) { |
||||||
|
u := c.url |
||||||
|
u.Path = "query" |
||||||
|
|
||||||
|
jsonParameters, err := json.Marshal(q.Parameters) |
||||||
|
|
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
req, err := http.NewRequest("POST", u.String(), nil) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
req.Header.Set("Content-Type", "") |
||||||
|
req.Header.Set("User-Agent", c.useragent) |
||||||
|
|
||||||
|
if c.username != "" { |
||||||
|
req.SetBasicAuth(c.username, c.password) |
||||||
|
} |
||||||
|
|
||||||
|
params := req.URL.Query() |
||||||
|
params.Set("q", q.Command) |
||||||
|
params.Set("db", q.Database) |
||||||
|
params.Set("params", string(jsonParameters)) |
||||||
|
if q.Chunked { |
||||||
|
params.Set("chunked", "true") |
||||||
|
if q.ChunkSize > 0 { |
||||||
|
params.Set("chunk_size", strconv.Itoa(q.ChunkSize)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if q.Precision != "" { |
||||||
|
params.Set("epoch", q.Precision) |
||||||
|
} |
||||||
|
req.URL.RawQuery = params.Encode() |
||||||
|
|
||||||
|
resp, err := c.httpClient.Do(req) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
defer resp.Body.Close() |
||||||
|
|
||||||
|
// If we lack a X-Influxdb-Version header, then we didn't get a response from influxdb
|
||||||
|
// but instead some other service. If the error code is also a 500+ code, then some
|
||||||
|
// downstream loadbalancer/proxy/etc had an issue and we should report that.
|
||||||
|
if resp.Header.Get("X-Influxdb-Version") == "" && resp.StatusCode >= http.StatusInternalServerError { |
||||||
|
body, err := ioutil.ReadAll(resp.Body) |
||||||
|
if err != nil || len(body) == 0 { |
||||||
|
return nil, fmt.Errorf("received status code %d from downstream server", resp.StatusCode) |
||||||
|
} |
||||||
|
|
||||||
|
return nil, fmt.Errorf("received status code %d from downstream server, with response body: %q", resp.StatusCode, body) |
||||||
|
} |
||||||
|
|
||||||
|
// If we get an unexpected content type, then it is also not from influx direct and therefore
|
||||||
|
// we want to know what we received and what status code was returned for debugging purposes.
|
||||||
|
if cType, _, _ := mime.ParseMediaType(resp.Header.Get("Content-Type")); cType != "application/json" { |
||||||
|
// Read up to 1kb of the body to help identify downstream errors and limit the impact of things
|
||||||
|
// like downstream serving a large file
|
||||||
|
body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1024)) |
||||||
|
if err != nil || len(body) == 0 { |
||||||
|
return nil, fmt.Errorf("expected json response, got empty body, with status: %v", resp.StatusCode) |
||||||
|
} |
||||||
|
|
||||||
|
return nil, fmt.Errorf("expected json response, got %q, with status: %v and response body: %q", cType, resp.StatusCode, body) |
||||||
|
} |
||||||
|
|
||||||
|
var response Response |
||||||
|
if q.Chunked { |
||||||
|
cr := NewChunkedResponse(resp.Body) |
||||||
|
for { |
||||||
|
r, err := cr.NextResponse() |
||||||
|
if err != nil { |
||||||
|
// If we got an error while decoding the response, send that back.
|
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if r == nil { |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
response.Results = append(response.Results, r.Results...) |
||||||
|
if r.Err != "" { |
||||||
|
response.Err = r.Err |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} else { |
||||||
|
dec := json.NewDecoder(resp.Body) |
||||||
|
dec.UseNumber() |
||||||
|
decErr := dec.Decode(&response) |
||||||
|
|
||||||
|
// ignore this error if we got an invalid status code
|
||||||
|
if decErr != nil && decErr.Error() == "EOF" && resp.StatusCode != http.StatusOK { |
||||||
|
decErr = nil |
||||||
|
} |
||||||
|
// If we got a valid decode error, send that back
|
||||||
|
if decErr != nil { |
||||||
|
return nil, fmt.Errorf("unable to decode json: received status code %d err: %s", resp.StatusCode, decErr) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// If we don't have an error in our json response, and didn't get statusOK
|
||||||
|
// then send back an error
|
||||||
|
if resp.StatusCode != http.StatusOK && response.Error() == nil { |
||||||
|
return &response, fmt.Errorf("received status code %d from server", resp.StatusCode) |
||||||
|
} |
||||||
|
return &response, nil |
||||||
|
} |
||||||
|
|
||||||
|
// duplexReader reads responses and writes it to another writer while
|
||||||
|
// satisfying the reader interface.
|
||||||
|
type duplexReader struct { |
||||||
|
r io.Reader |
||||||
|
w io.Writer |
||||||
|
} |
||||||
|
|
||||||
|
func (r *duplexReader) Read(p []byte) (n int, err error) { |
||||||
|
n, err = r.r.Read(p) |
||||||
|
if err == nil { |
||||||
|
r.w.Write(p[:n]) |
||||||
|
} |
||||||
|
return n, err |
||||||
|
} |
||||||
|
|
||||||
|
// ChunkedResponse represents a response from the server that
|
||||||
|
// uses chunking to stream the output.
|
||||||
|
type ChunkedResponse struct { |
||||||
|
dec *json.Decoder |
||||||
|
duplex *duplexReader |
||||||
|
buf bytes.Buffer |
||||||
|
} |
||||||
|
|
||||||
|
// NewChunkedResponse reads a stream and produces responses from the stream.
|
||||||
|
func NewChunkedResponse(r io.Reader) *ChunkedResponse { |
||||||
|
resp := &ChunkedResponse{} |
||||||
|
resp.duplex = &duplexReader{r: r, w: &resp.buf} |
||||||
|
resp.dec = json.NewDecoder(resp.duplex) |
||||||
|
resp.dec.UseNumber() |
||||||
|
return resp |
||||||
|
} |
||||||
|
|
||||||
|
// NextResponse reads the next line of the stream and returns a response.
|
||||||
|
func (r *ChunkedResponse) NextResponse() (*Response, error) { |
||||||
|
var response Response |
||||||
|
|
||||||
|
if err := r.dec.Decode(&response); err != nil { |
||||||
|
if err == io.EOF { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
// A decoding error happened. This probably means the server crashed
|
||||||
|
// and sent a last-ditch error message to us. Ensure we have read the
|
||||||
|
// entirety of the connection to get any remaining error text.
|
||||||
|
io.Copy(ioutil.Discard, r.duplex) |
||||||
|
return nil, errors.New(strings.TrimSpace(r.buf.String())) |
||||||
|
} |
||||||
|
|
||||||
|
r.buf.Reset() |
||||||
|
return &response, nil |
||||||
|
} |
||||||
@ -0,0 +1,112 @@ |
|||||||
|
package client |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
"net" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
// UDPPayloadSize is a reasonable default payload size for UDP packets that
|
||||||
|
// could be travelling over the internet.
|
||||||
|
UDPPayloadSize = 512 |
||||||
|
) |
||||||
|
|
||||||
|
// UDPConfig is the config data needed to create a UDP Client.
|
||||||
|
type UDPConfig struct { |
||||||
|
// Addr should be of the form "host:port"
|
||||||
|
// or "[ipv6-host%zone]:port".
|
||||||
|
Addr string |
||||||
|
|
||||||
|
// PayloadSize is the maximum size of a UDP client message, optional
|
||||||
|
// Tune this based on your network. Defaults to UDPPayloadSize.
|
||||||
|
PayloadSize int |
||||||
|
} |
||||||
|
|
||||||
|
// NewUDPClient returns a client interface for writing to an InfluxDB UDP
|
||||||
|
// service from the given config.
|
||||||
|
func NewUDPClient(conf UDPConfig) (Client, error) { |
||||||
|
var udpAddr *net.UDPAddr |
||||||
|
udpAddr, err := net.ResolveUDPAddr("udp", conf.Addr) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
conn, err := net.DialUDP("udp", nil, udpAddr) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
payloadSize := conf.PayloadSize |
||||||
|
if payloadSize == 0 { |
||||||
|
payloadSize = UDPPayloadSize |
||||||
|
} |
||||||
|
|
||||||
|
return &udpclient{ |
||||||
|
conn: conn, |
||||||
|
payloadSize: payloadSize, |
||||||
|
}, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Close releases the udpclient's resources.
|
||||||
|
func (uc *udpclient) Close() error { |
||||||
|
return uc.conn.Close() |
||||||
|
} |
||||||
|
|
||||||
|
type udpclient struct { |
||||||
|
conn io.WriteCloser |
||||||
|
payloadSize int |
||||||
|
} |
||||||
|
|
||||||
|
func (uc *udpclient) Write(bp BatchPoints) error { |
||||||
|
var b = make([]byte, 0, uc.payloadSize) // initial buffer size, it will grow as needed
|
||||||
|
var d, _ = time.ParseDuration("1" + bp.Precision()) |
||||||
|
|
||||||
|
var delayedError error |
||||||
|
|
||||||
|
var checkBuffer = func(n int) { |
||||||
|
if len(b) > 0 && len(b)+n > uc.payloadSize { |
||||||
|
if _, err := uc.conn.Write(b); err != nil { |
||||||
|
delayedError = err |
||||||
|
} |
||||||
|
b = b[:0] |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
for _, p := range bp.Points() { |
||||||
|
p.pt.Round(d) |
||||||
|
pointSize := p.pt.StringSize() + 1 // include newline in size
|
||||||
|
//point := p.pt.RoundedString(d) + "\n"
|
||||||
|
|
||||||
|
checkBuffer(pointSize) |
||||||
|
|
||||||
|
if p.Time().IsZero() || pointSize <= uc.payloadSize { |
||||||
|
b = p.pt.AppendString(b) |
||||||
|
b = append(b, '\n') |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
points := p.pt.Split(uc.payloadSize - 1) // account for newline character
|
||||||
|
for _, sp := range points { |
||||||
|
checkBuffer(sp.StringSize() + 1) |
||||||
|
b = sp.AppendString(b) |
||||||
|
b = append(b, '\n') |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if len(b) > 0 { |
||||||
|
if _, err := uc.conn.Write(b); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
return delayedError |
||||||
|
} |
||||||
|
|
||||||
|
func (uc *udpclient) Query(q Query) (*Response, error) { |
||||||
|
return nil, fmt.Errorf("Querying via UDP is not supported") |
||||||
|
} |
||||||
|
|
||||||
|
func (uc *udpclient) Ping(timeout time.Duration) (time.Duration, string, error) { |
||||||
|
return 0, "", nil |
||||||
|
} |
||||||
@ -0,0 +1,48 @@ |
|||||||
|
package models |
||||||
|
|
||||||
|
import ( |
||||||
|
"errors" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
// ConsistencyLevel represent a required replication criteria before a write can
|
||||||
|
// be returned as successful.
|
||||||
|
//
|
||||||
|
// The consistency level is handled in open-source InfluxDB but only applicable to clusters.
|
||||||
|
type ConsistencyLevel int |
||||||
|
|
||||||
|
const ( |
||||||
|
// ConsistencyLevelAny allows for hinted handoff, potentially no write happened yet.
|
||||||
|
ConsistencyLevelAny ConsistencyLevel = iota |
||||||
|
|
||||||
|
// ConsistencyLevelOne requires at least one data node acknowledged a write.
|
||||||
|
ConsistencyLevelOne |
||||||
|
|
||||||
|
// ConsistencyLevelQuorum requires a quorum of data nodes to acknowledge a write.
|
||||||
|
ConsistencyLevelQuorum |
||||||
|
|
||||||
|
// ConsistencyLevelAll requires all data nodes to acknowledge a write.
|
||||||
|
ConsistencyLevelAll |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
// ErrInvalidConsistencyLevel is returned when parsing the string version
|
||||||
|
// of a consistency level.
|
||||||
|
ErrInvalidConsistencyLevel = errors.New("invalid consistency level") |
||||||
|
) |
||||||
|
|
||||||
|
// ParseConsistencyLevel converts a consistency level string to the corresponding ConsistencyLevel const.
|
||||||
|
func ParseConsistencyLevel(level string) (ConsistencyLevel, error) { |
||||||
|
switch strings.ToLower(level) { |
||||||
|
case "any": |
||||||
|
return ConsistencyLevelAny, nil |
||||||
|
case "one": |
||||||
|
return ConsistencyLevelOne, nil |
||||||
|
case "quorum": |
||||||
|
return ConsistencyLevelQuorum, nil |
||||||
|
case "all": |
||||||
|
return ConsistencyLevelAll, nil |
||||||
|
default: |
||||||
|
return 0, ErrInvalidConsistencyLevel |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,32 @@ |
|||||||
|
package models // import "github.com/influxdata/influxdb/models"
|
||||||
|
|
||||||
|
// from stdlib hash/fnv/fnv.go
|
||||||
|
const ( |
||||||
|
prime64 = 1099511628211 |
||||||
|
offset64 = 14695981039346656037 |
||||||
|
) |
||||||
|
|
||||||
|
// InlineFNV64a is an alloc-free port of the standard library's fnv64a.
|
||||||
|
// See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function.
|
||||||
|
type InlineFNV64a uint64 |
||||||
|
|
||||||
|
// NewInlineFNV64a returns a new instance of InlineFNV64a.
|
||||||
|
func NewInlineFNV64a() InlineFNV64a { |
||||||
|
return offset64 |
||||||
|
} |
||||||
|
|
||||||
|
// Write adds data to the running hash.
|
||||||
|
func (s *InlineFNV64a) Write(data []byte) (int, error) { |
||||||
|
hash := uint64(*s) |
||||||
|
for _, c := range data { |
||||||
|
hash ^= uint64(c) |
||||||
|
hash *= prime64 |
||||||
|
} |
||||||
|
*s = InlineFNV64a(hash) |
||||||
|
return len(data), nil |
||||||
|
} |
||||||
|
|
||||||
|
// Sum64 returns the uint64 of the current resulting hash.
|
||||||
|
func (s *InlineFNV64a) Sum64() uint64 { |
||||||
|
return uint64(*s) |
||||||
|
} |
||||||
@ -0,0 +1,44 @@ |
|||||||
|
package models // import "github.com/influxdata/influxdb/models"
|
||||||
|
|
||||||
|
import ( |
||||||
|
"reflect" |
||||||
|
"strconv" |
||||||
|
"unsafe" |
||||||
|
) |
||||||
|
|
||||||
|
// parseIntBytes is a zero-alloc wrapper around strconv.ParseInt.
|
||||||
|
func parseIntBytes(b []byte, base int, bitSize int) (i int64, err error) { |
||||||
|
s := unsafeBytesToString(b) |
||||||
|
return strconv.ParseInt(s, base, bitSize) |
||||||
|
} |
||||||
|
|
||||||
|
// parseUintBytes is a zero-alloc wrapper around strconv.ParseUint.
|
||||||
|
func parseUintBytes(b []byte, base int, bitSize int) (i uint64, err error) { |
||||||
|
s := unsafeBytesToString(b) |
||||||
|
return strconv.ParseUint(s, base, bitSize) |
||||||
|
} |
||||||
|
|
||||||
|
// parseFloatBytes is a zero-alloc wrapper around strconv.ParseFloat.
|
||||||
|
func parseFloatBytes(b []byte, bitSize int) (float64, error) { |
||||||
|
s := unsafeBytesToString(b) |
||||||
|
return strconv.ParseFloat(s, bitSize) |
||||||
|
} |
||||||
|
|
||||||
|
// parseBoolBytes is a zero-alloc wrapper around strconv.ParseBool.
|
||||||
|
func parseBoolBytes(b []byte) (bool, error) { |
||||||
|
return strconv.ParseBool(unsafeBytesToString(b)) |
||||||
|
} |
||||||
|
|
||||||
|
// unsafeBytesToString converts a []byte to a string without a heap allocation.
|
||||||
|
//
|
||||||
|
// It is unsafe, and is intended to prepare input to short-lived functions
|
||||||
|
// that require strings.
|
||||||
|
func unsafeBytesToString(in []byte) string { |
||||||
|
src := *(*reflect.SliceHeader)(unsafe.Pointer(&in)) |
||||||
|
dst := reflect.StringHeader{ |
||||||
|
Data: src.Data, |
||||||
|
Len: src.Len, |
||||||
|
} |
||||||
|
s := *(*string)(unsafe.Pointer(&dst)) |
||||||
|
return s |
||||||
|
} |
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,62 @@ |
|||||||
|
package models |
||||||
|
|
||||||
|
import ( |
||||||
|
"sort" |
||||||
|
) |
||||||
|
|
||||||
|
// Row represents a single row returned from the execution of a statement.
|
||||||
|
type Row struct { |
||||||
|
Name string `json:"name,omitempty"` |
||||||
|
Tags map[string]string `json:"tags,omitempty"` |
||||||
|
Columns []string `json:"columns,omitempty"` |
||||||
|
Values [][]interface{} `json:"values,omitempty"` |
||||||
|
Partial bool `json:"partial,omitempty"` |
||||||
|
} |
||||||
|
|
||||||
|
// SameSeries returns true if r contains values for the same series as o.
|
||||||
|
func (r *Row) SameSeries(o *Row) bool { |
||||||
|
return r.tagsHash() == o.tagsHash() && r.Name == o.Name |
||||||
|
} |
||||||
|
|
||||||
|
// tagsHash returns a hash of tag key/value pairs.
|
||||||
|
func (r *Row) tagsHash() uint64 { |
||||||
|
h := NewInlineFNV64a() |
||||||
|
keys := r.tagsKeys() |
||||||
|
for _, k := range keys { |
||||||
|
h.Write([]byte(k)) |
||||||
|
h.Write([]byte(r.Tags[k])) |
||||||
|
} |
||||||
|
return h.Sum64() |
||||||
|
} |
||||||
|
|
||||||
|
// tagKeys returns a sorted list of tag keys.
|
||||||
|
func (r *Row) tagsKeys() []string { |
||||||
|
a := make([]string, 0, len(r.Tags)) |
||||||
|
for k := range r.Tags { |
||||||
|
a = append(a, k) |
||||||
|
} |
||||||
|
sort.Strings(a) |
||||||
|
return a |
||||||
|
} |
||||||
|
|
||||||
|
// Rows represents a collection of rows. Rows implements sort.Interface.
|
||||||
|
type Rows []*Row |
||||||
|
|
||||||
|
// Len implements sort.Interface.
|
||||||
|
func (p Rows) Len() int { return len(p) } |
||||||
|
|
||||||
|
// Less implements sort.Interface.
|
||||||
|
func (p Rows) Less(i, j int) bool { |
||||||
|
// Sort by name first.
|
||||||
|
if p[i].Name != p[j].Name { |
||||||
|
return p[i].Name < p[j].Name |
||||||
|
} |
||||||
|
|
||||||
|
// Sort by tag set hash. Tags don't have a meaningful sort order so we
|
||||||
|
// just compute a hash and sort by that instead. This allows the tests
|
||||||
|
// to receive rows in a predictable order every time.
|
||||||
|
return p[i].tagsHash() < p[j].tagsHash() |
||||||
|
} |
||||||
|
|
||||||
|
// Swap implements sort.Interface.
|
||||||
|
func (p Rows) Swap(i, j int) { p[i], p[j] = p[j], p[i] } |
||||||
@ -0,0 +1,42 @@ |
|||||||
|
package models |
||||||
|
|
||||||
|
// Statistic is the representation of a statistic used by the monitoring service.
|
||||||
|
type Statistic struct { |
||||||
|
Name string `json:"name"` |
||||||
|
Tags map[string]string `json:"tags"` |
||||||
|
Values map[string]interface{} `json:"values"` |
||||||
|
} |
||||||
|
|
||||||
|
// NewStatistic returns an initialized Statistic.
|
||||||
|
func NewStatistic(name string) Statistic { |
||||||
|
return Statistic{ |
||||||
|
Name: name, |
||||||
|
Tags: make(map[string]string), |
||||||
|
Values: make(map[string]interface{}), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// StatisticTags is a map that can be merged with others without causing
|
||||||
|
// mutations to either map.
|
||||||
|
type StatisticTags map[string]string |
||||||
|
|
||||||
|
// Merge creates a new map containing the merged contents of tags and t.
|
||||||
|
// If both tags and the receiver map contain the same key, the value in tags
|
||||||
|
// is used in the resulting map.
|
||||||
|
//
|
||||||
|
// Merge always returns a usable map.
|
||||||
|
func (t StatisticTags) Merge(tags map[string]string) map[string]string { |
||||||
|
// Add everything in tags to the result.
|
||||||
|
out := make(map[string]string, len(tags)) |
||||||
|
for k, v := range tags { |
||||||
|
out[k] = v |
||||||
|
} |
||||||
|
|
||||||
|
// Only add values from t that don't appear in tags.
|
||||||
|
for k, v := range t { |
||||||
|
if _, ok := tags[k]; !ok { |
||||||
|
out[k] = v |
||||||
|
} |
||||||
|
} |
||||||
|
return out |
||||||
|
} |
||||||
@ -0,0 +1,74 @@ |
|||||||
|
package models |
||||||
|
|
||||||
|
// Helper time methods since parsing time can easily overflow and we only support a
|
||||||
|
// specific time range.
|
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"math" |
||||||
|
"time" |
||||||
|
) |
||||||
|
|
||||||
|
const ( |
||||||
|
// MinNanoTime is the minumum time that can be represented.
|
||||||
|
//
|
||||||
|
// 1677-09-21 00:12:43.145224194 +0000 UTC
|
||||||
|
//
|
||||||
|
// The two lowest minimum integers are used as sentinel values. The
|
||||||
|
// minimum value needs to be used as a value lower than any other value for
|
||||||
|
// comparisons and another separate value is needed to act as a sentinel
|
||||||
|
// default value that is unusable by the user, but usable internally.
|
||||||
|
// Because these two values need to be used for a special purpose, we do
|
||||||
|
// not allow users to write points at these two times.
|
||||||
|
MinNanoTime = int64(math.MinInt64) + 2 |
||||||
|
|
||||||
|
// MaxNanoTime is the maximum time that can be represented.
|
||||||
|
//
|
||||||
|
// 2262-04-11 23:47:16.854775806 +0000 UTC
|
||||||
|
//
|
||||||
|
// The highest time represented by a nanosecond needs to be used for an
|
||||||
|
// exclusive range in the shard group, so the maximum time needs to be one
|
||||||
|
// less than the possible maximum number of nanoseconds representable by an
|
||||||
|
// int64 so that we don't lose a point at that one time.
|
||||||
|
MaxNanoTime = int64(math.MaxInt64) - 1 |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
minNanoTime = time.Unix(0, MinNanoTime).UTC() |
||||||
|
maxNanoTime = time.Unix(0, MaxNanoTime).UTC() |
||||||
|
|
||||||
|
// ErrTimeOutOfRange gets returned when time is out of the representable range using int64 nanoseconds since the epoch.
|
||||||
|
ErrTimeOutOfRange = fmt.Errorf("time outside range %d - %d", MinNanoTime, MaxNanoTime) |
||||||
|
) |
||||||
|
|
||||||
|
// SafeCalcTime safely calculates the time given. Will return error if the time is outside the
|
||||||
|
// supported range.
|
||||||
|
func SafeCalcTime(timestamp int64, precision string) (time.Time, error) { |
||||||
|
mult := GetPrecisionMultiplier(precision) |
||||||
|
if t, ok := safeSignedMult(timestamp, mult); ok { |
||||||
|
tme := time.Unix(0, t).UTC() |
||||||
|
return tme, CheckTime(tme) |
||||||
|
} |
||||||
|
|
||||||
|
return time.Time{}, ErrTimeOutOfRange |
||||||
|
} |
||||||
|
|
||||||
|
// CheckTime checks that a time is within the safe range.
|
||||||
|
func CheckTime(t time.Time) error { |
||||||
|
if t.Before(minNanoTime) || t.After(maxNanoTime) { |
||||||
|
return ErrTimeOutOfRange |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Perform the multiplication and check to make sure it didn't overflow.
|
||||||
|
func safeSignedMult(a, b int64) (int64, bool) { |
||||||
|
if a == 0 || b == 0 || a == 1 || b == 1 { |
||||||
|
return a * b, true |
||||||
|
} |
||||||
|
if a == MinNanoTime || b == MaxNanoTime { |
||||||
|
return 0, false |
||||||
|
} |
||||||
|
c := a * b |
||||||
|
return c, c/b == a |
||||||
|
} |
||||||
@ -0,0 +1,7 @@ |
|||||||
|
// +build uint uint64
|
||||||
|
|
||||||
|
package models |
||||||
|
|
||||||
|
func init() { |
||||||
|
EnableUintSupport() |
||||||
|
} |
||||||
@ -0,0 +1,115 @@ |
|||||||
|
// Package escape contains utilities for escaping parts of InfluxQL
|
||||||
|
// and InfluxDB line protocol.
|
||||||
|
package escape // import "github.com/influxdata/influxdb/pkg/escape"
|
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
// Codes is a map of bytes to be escaped.
|
||||||
|
var Codes = map[byte][]byte{ |
||||||
|
',': []byte(`\,`), |
||||||
|
'"': []byte(`\"`), |
||||||
|
' ': []byte(`\ `), |
||||||
|
'=': []byte(`\=`), |
||||||
|
} |
||||||
|
|
||||||
|
// Bytes escapes characters on the input slice, as defined by Codes.
|
||||||
|
func Bytes(in []byte) []byte { |
||||||
|
for b, esc := range Codes { |
||||||
|
in = bytes.Replace(in, []byte{b}, esc, -1) |
||||||
|
} |
||||||
|
return in |
||||||
|
} |
||||||
|
|
||||||
|
const escapeChars = `," =` |
||||||
|
|
||||||
|
// IsEscaped returns whether b has any escaped characters,
|
||||||
|
// i.e. whether b seems to have been processed by Bytes.
|
||||||
|
func IsEscaped(b []byte) bool { |
||||||
|
for len(b) > 0 { |
||||||
|
i := bytes.IndexByte(b, '\\') |
||||||
|
if i < 0 { |
||||||
|
return false |
||||||
|
} |
||||||
|
|
||||||
|
if i+1 < len(b) && strings.IndexByte(escapeChars, b[i+1]) >= 0 { |
||||||
|
return true |
||||||
|
} |
||||||
|
b = b[i+1:] |
||||||
|
} |
||||||
|
return false |
||||||
|
} |
||||||
|
|
||||||
|
// AppendUnescaped appends the unescaped version of src to dst
|
||||||
|
// and returns the resulting slice.
|
||||||
|
func AppendUnescaped(dst, src []byte) []byte { |
||||||
|
var pos int |
||||||
|
for len(src) > 0 { |
||||||
|
next := bytes.IndexByte(src[pos:], '\\') |
||||||
|
if next < 0 || pos+next+1 >= len(src) { |
||||||
|
return append(dst, src...) |
||||||
|
} |
||||||
|
|
||||||
|
if pos+next+1 < len(src) && strings.IndexByte(escapeChars, src[pos+next+1]) >= 0 { |
||||||
|
if pos+next > 0 { |
||||||
|
dst = append(dst, src[:pos+next]...) |
||||||
|
} |
||||||
|
src = src[pos+next+1:] |
||||||
|
pos = 0 |
||||||
|
} else { |
||||||
|
pos += next + 1 |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return dst |
||||||
|
} |
||||||
|
|
||||||
|
// Unescape returns a new slice containing the unescaped version of in.
|
||||||
|
func Unescape(in []byte) []byte { |
||||||
|
if len(in) == 0 { |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
if bytes.IndexByte(in, '\\') == -1 { |
||||||
|
return in |
||||||
|
} |
||||||
|
|
||||||
|
i := 0 |
||||||
|
inLen := len(in) |
||||||
|
|
||||||
|
// The output size will be no more than inLen. Preallocating the
|
||||||
|
// capacity of the output is faster and uses less memory than
|
||||||
|
// letting append() do its own (over)allocation.
|
||||||
|
out := make([]byte, 0, inLen) |
||||||
|
|
||||||
|
for { |
||||||
|
if i >= inLen { |
||||||
|
break |
||||||
|
} |
||||||
|
if in[i] == '\\' && i+1 < inLen { |
||||||
|
switch in[i+1] { |
||||||
|
case ',': |
||||||
|
out = append(out, ',') |
||||||
|
i += 2 |
||||||
|
continue |
||||||
|
case '"': |
||||||
|
out = append(out, '"') |
||||||
|
i += 2 |
||||||
|
continue |
||||||
|
case ' ': |
||||||
|
out = append(out, ' ') |
||||||
|
i += 2 |
||||||
|
continue |
||||||
|
case '=': |
||||||
|
out = append(out, '=') |
||||||
|
i += 2 |
||||||
|
continue |
||||||
|
} |
||||||
|
} |
||||||
|
out = append(out, in[i]) |
||||||
|
i += 1 |
||||||
|
} |
||||||
|
return out |
||||||
|
} |
||||||
@ -0,0 +1,21 @@ |
|||||||
|
package escape |
||||||
|
|
||||||
|
import "strings" |
||||||
|
|
||||||
|
var ( |
||||||
|
escaper = strings.NewReplacer(`,`, `\,`, `"`, `\"`, ` `, `\ `, `=`, `\=`) |
||||||
|
unescaper = strings.NewReplacer(`\,`, `,`, `\"`, `"`, `\ `, ` `, `\=`, `=`) |
||||||
|
) |
||||||
|
|
||||||
|
// UnescapeString returns unescaped version of in.
|
||||||
|
func UnescapeString(in string) string { |
||||||
|
if strings.IndexByte(in, '\\') == -1 { |
||||||
|
return in |
||||||
|
} |
||||||
|
return unescaper.Replace(in) |
||||||
|
} |
||||||
|
|
||||||
|
// String returns the escaped version of in.
|
||||||
|
func String(in string) string { |
||||||
|
return escaper.Replace(in) |
||||||
|
} |
||||||
@ -1,87 +0,0 @@ |
|||||||
package metrics |
|
||||||
|
|
||||||
import ( |
|
||||||
"encoding/json" |
|
||||||
"io" |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
// MarshalJSON returns a byte slice containing a JSON representation of all
|
|
||||||
// the metrics in the Registry.
|
|
||||||
func (r *StandardRegistry) MarshalJSON() ([]byte, error) { |
|
||||||
data := make(map[string]map[string]interface{}) |
|
||||||
r.Each(func(name string, i interface{}) { |
|
||||||
values := make(map[string]interface{}) |
|
||||||
switch metric := i.(type) { |
|
||||||
case Counter: |
|
||||||
values["count"] = metric.Count() |
|
||||||
case Gauge: |
|
||||||
values["value"] = metric.Value() |
|
||||||
case GaugeFloat64: |
|
||||||
values["value"] = metric.Value() |
|
||||||
case Healthcheck: |
|
||||||
values["error"] = nil |
|
||||||
metric.Check() |
|
||||||
if err := metric.Error(); nil != err { |
|
||||||
values["error"] = metric.Error().Error() |
|
||||||
} |
|
||||||
case Histogram: |
|
||||||
h := metric.Snapshot() |
|
||||||
ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) |
|
||||||
values["count"] = h.Count() |
|
||||||
values["min"] = h.Min() |
|
||||||
values["max"] = h.Max() |
|
||||||
values["mean"] = h.Mean() |
|
||||||
values["stddev"] = h.StdDev() |
|
||||||
values["median"] = ps[0] |
|
||||||
values["75%"] = ps[1] |
|
||||||
values["95%"] = ps[2] |
|
||||||
values["99%"] = ps[3] |
|
||||||
values["99.9%"] = ps[4] |
|
||||||
case Meter: |
|
||||||
m := metric.Snapshot() |
|
||||||
values["count"] = m.Count() |
|
||||||
values["1m.rate"] = m.Rate1() |
|
||||||
values["5m.rate"] = m.Rate5() |
|
||||||
values["15m.rate"] = m.Rate15() |
|
||||||
values["mean.rate"] = m.RateMean() |
|
||||||
case Timer: |
|
||||||
t := metric.Snapshot() |
|
||||||
ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) |
|
||||||
values["count"] = t.Count() |
|
||||||
values["min"] = t.Min() |
|
||||||
values["max"] = t.Max() |
|
||||||
values["mean"] = t.Mean() |
|
||||||
values["stddev"] = t.StdDev() |
|
||||||
values["median"] = ps[0] |
|
||||||
values["75%"] = ps[1] |
|
||||||
values["95%"] = ps[2] |
|
||||||
values["99%"] = ps[3] |
|
||||||
values["99.9%"] = ps[4] |
|
||||||
values["1m.rate"] = t.Rate1() |
|
||||||
values["5m.rate"] = t.Rate5() |
|
||||||
values["15m.rate"] = t.Rate15() |
|
||||||
values["mean.rate"] = t.RateMean() |
|
||||||
} |
|
||||||
data[name] = values |
|
||||||
}) |
|
||||||
return json.Marshal(data) |
|
||||||
} |
|
||||||
|
|
||||||
// WriteJSON writes metrics from the given registry periodically to the
|
|
||||||
// specified io.Writer as JSON.
|
|
||||||
func WriteJSON(r Registry, d time.Duration, w io.Writer) { |
|
||||||
for _ = range time.Tick(d) { |
|
||||||
WriteJSONOnce(r, w) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// WriteJSONOnce writes metrics from the given registry to the specified
|
|
||||||
// io.Writer as JSON.
|
|
||||||
func WriteJSONOnce(r Registry, w io.Writer) { |
|
||||||
json.NewEncoder(w).Encode(r) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *PrefixedRegistry) MarshalJSON() ([]byte, error) { |
|
||||||
return json.Marshal(p.underlying) |
|
||||||
} |
|
||||||
@ -1,13 +0,0 @@ |
|||||||
// Go port of Coda Hale's Metrics library
|
|
||||||
//
|
|
||||||
// <https://github.com/rcrowley/go-metrics>
|
|
||||||
//
|
|
||||||
// Coda Hale's original work: <https://github.com/codahale/metrics>
|
|
||||||
package metrics |
|
||||||
|
|
||||||
// UseNilMetrics is checked by the constructor functions for all of the
|
|
||||||
// standard metrics. If it is true, the metric returned is a stub.
|
|
||||||
//
|
|
||||||
// This global kill-switch helps quantify the observer effect and makes
|
|
||||||
// for less cluttered pprof profiles.
|
|
||||||
var UseNilMetrics bool = false |
|
||||||
Loading…
Reference in new issue