Merge pull request #22 from segmentio/v3

V3

Author: achille-roussel

README.md

@@ -29,13 +29,15 @@ import (
 )
 
 func main() {
-    // Creates a new datadog client reporting the state of the default stats
-    // engine to localhost:8125.
-    dd := datadog.NewDefaultClient()
+    // Creates a new datadog client publishing metrics to localhost:8125
+    dd := datadog.NewClient("localhost:8125")
 
-    // Close the client before the application terminates to ensure the latest
-    // state of the stats engine was reported.
-    defer dd.Close()
+    // Register the client so it receives metrics from the default engine.
+    stats.Register(dd)
+
+    // Flush the default stats engine on return to ensure all buffered
+    // metrics are sent to the dogstatsd server.
+    defer stats.Flush()
 
     // That's it! Metrics produced by the application will now be reported!
     // ...
@@ -58,8 +60,8 @@ import (
 )
 
 func main() {
-    dd := datadog.NewDefaultClient()
-    defer dd.Close()
+    stats.Register(datadog.NewClient("localhost:8125"))
+    defer stats.Flush()
 
     // Increment counters.
     stats.Incr("user.login")
@@ -93,11 +95,11 @@ import (
 
 
 func main() {
-     dd := datadog.NewDefaultClient()
-     defer dd.Close()
+     stats.Register(datadog.NewClient("localhost:8125"))
+     defer stats.Flush()
 
     // Start a new collector for the current process, reporting Go metrics.
-    c := procstats.StartCollector(procstats.NewGoMetrics(nil))
+    c := procstats.StartCollector(procstats.NewGoMetrics())
 
     // Gracefully stops stats collection.
     defer c.Close()
@@ -125,13 +127,12 @@ import (
 )
 
 func main() {
-     dd := datadog.NewDefaultClient()
-     defer dd.Close()
+     stats.Register(datadog.NewClient("localhost:8125"))
+     defer stats.Flush()
 
     // ...
 
     http.ListenAndServe(":8080", httpstats.NewHandler(
-        nil, // use the default stats engine
         http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
             // This HTTP handler is automatically reporting metrics for all
             // requests it handles.
@@ -159,14 +160,13 @@ import (
 )
 
 func main() {
-     dd := datadog.NewDefaultClient()
-     defer dd.Close()
+     stats.Register(datadog.NewClient("localhost:8125"))
+     defer stats.Flush()
 
     // Make a new HTTP client with a transport that will report HTTP metrics,
     // set the engine to nil to use the default.
     httpc := &http.Client{
         Transport: httpstats.NewTransport(
-            nil, // use the default stats engine
             &http.Transport{},
         ),
     }
@@ -188,12 +188,11 @@ import (
 )
 
 func main() {
-     dd := datadog.NewDefaultClient()
-     defer dd.Close()
+     stats.Register(datadog.NewClient("localhost:8125"))
+     defer stats.Flush()
 
-    // Wraps the default HTTP client's transport, set the engine to nil to use
-    // the default.
-    http.DefaultClient.Transport = httpstats.NewTransport(nil, http.DefaultClient.Transport)
+    // Wraps the default HTTP client's transport.
+    http.DefaultClient.Transport = httpstats.NewTransport(http.DefaultClient.Transport)
 
     // ...
 }

clock.go

@@ -18,17 +18,18 @@ func (c *Clock) Name() string {
 
 // Tags returns the list of tags set on the clock.
 //
-// The returned slice is a copy of the internal slice maintained by the clock,
-// the program owns it and can safely modify it without affecting the clock.
+// The method returns a reference to the clock's internal tag slice, it does
+// not make a copy. It's expected that the program will treat this value as a
+// read-only list and won't modify its content.
 func (c *Clock) Tags() []Tag {
 	return c.metric.Tags()
 }
 
-// Clone returns a copy of the clock, potentially setting tags on the returned
+// WithTags returns a copy of the clock, potentially setting tags on the returned
 // object.
-func (c *Clock) Clone(tags ...Tag) *Clock {
+func (c *Clock) WithTags(tags ...Tag) *Clock {
 	return &Clock{
-		metric: c.metric.Clone(tags...),
+		metric: *c.metric.WithTags(tags...),
 		last:   c.last,
 	}
 }
@@ -69,9 +70,6 @@ func (c *Clock) StopAt(now time.Time) {
 
 func (c *Clock) observe(stamp string, now time.Time) {
 	h := c.metric
-	h.key += "&stamp=" + stamp
-	h.tags = make([]Tag, 0, len(c.metric.tags)+1)
-	h.tags = append(h.tags, c.metric.tags...)
 	h.tags = append(h.tags, Tag{"stamp", stamp})
 	h.Observe(now.Sub(c.last).Seconds())
 	c.last = now

clock_test.go

@@ -0,0 +1,70 @@
+package stats
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestClockStart(t *testing.T) {
+	h := &handler{}
+	e := NewEngine("E")
+	e.Register(h)
+
+	m := e.Timer("A")
+	c := m.Start()
+	c.Stamp("1")
+	c.Stamp("2")
+	c.Stamp("3")
+	c.Stop()
+
+	for i := range h.metrics {
+		if h.metrics[i].Value == 0 {
+			t.Error("clock time value should not be zero")
+		}
+		h.metrics[i].Value = 0 // unpredictable
+	}
+
+	if !reflect.DeepEqual(h.metrics, []Metric{
+		{
+			Type:      HistogramType,
+			Namespace: "E",
+			Name:      "A",
+			Tags:      []Tag{{"stamp", "1"}},
+		},
+		{
+			Type:      HistogramType,
+			Namespace: "E",
+			Name:      "A",
+			Tags:      []Tag{{"stamp", "2"}},
+		},
+		{
+			Type:      HistogramType,
+			Namespace: "E",
+			Name:      "A",
+			Tags:      []Tag{{"stamp", "3"}},
+		},
+		{
+			Type:      HistogramType,
+			Namespace: "E",
+			Name:      "A",
+			Tags:      []Tag{{"stamp", "total"}},
+		},
+	}) {
+		t.Error("bad metrics:", h.metrics)
+	}
+}
+
+func TestClockWithTags(t *testing.T) {
+	e := NewEngine("E")
+	m := e.Timer("A", Tag{"base", "tag"})
+	c1 := m.Start()
+	c2 := c1.WithTags(Tag{"extra", "tag"})
+
+	if name := c2.Name(); name != "A" {
+		t.Error("bad clock name:", name)
+	}
+
+	if tags := c2.Tags(); !reflect.DeepEqual(tags, []Tag{{"base", "tag"}, {"extra", "tag"}}) {
+		t.Error("bad clock tags:", tags)
+	}
+}

cmd/dogstatsd/main.go

@@ -88,7 +88,7 @@ func client(cmd string, args ...string) {
 		}
 	}
 
-	dd := datadog.NewClient(datadog.ClientConfig{Address: addr})
+	dd := datadog.NewClient(addr)
 	defer dd.Close()
 
 	switch cmd {

counter.go

@@ -1,59 +1,61 @@
 package stats
 
-import "time"
+import "sync"
 
-// Counter is an immutable data strcture that can be used to represent metrics
-// that accumulate values.
+// A Counter represent a metric that is monotonically increasing.
 type Counter struct {
-	eng  *Engine // the parent engine
-	key  string  // cached metric key
-	name string  // the name of the counter
-	tags []Tag   // the tags set on the counter
-}
-
-// C returns a new counter that produces metrics on the default engine.
-func C(name string, tags ...Tag) Counter {
-	return MakeCounter(nil, name, tags...)
-}
-
-// MakeCounter returns a new counter that produces metrics on the given engine.
-func MakeCounter(engine *Engine, name string, tags ...Tag) Counter {
-	return makeCounter(engine, name, copyTags(tags))
+	mutex sync.Mutex
+	value float64 // current value of the counter
+	eng   *Engine // the engine to produce metrics on
+	name  string  // the name of the counter
+	tags  []Tag   // the tags set on the counter
 }
 
 // Name returns the name of the counter.
-func (c Counter) Name() string {
+func (c *Counter) Name() string {
 	return c.name
 }
 
 // Tags returns the list of tags set on the counter.
 //
-// The returned slice is a copy of the internal slice maintained by the counter,
-// the program owns it and can safely modify it without affecting the counter.
-func (c Counter) Tags() []Tag {
-	return copyTags(c.tags)
+// The method returns a reference to the counter's internal tag slice, it does
+// not make a copy. It's expected that the program will treat this value as a
+// read-only list and won't modify its content.
+func (c *Counter) Tags() []Tag {
+	return c.tags
 }
 
-// Clone returns a copy of the counter, potentially setting tags on the returned
+// Value returns the current value of the counter.
+func (c *Counter) Value() float64 {
+	return c.value
+}
+
+// WithTags returns a copy of the counter, potentially setting tags on the returned
 // object.
-func (c Counter) Clone(tags ...Tag) Counter {
-	if len(tags) == 0 {
-		return c
+//
+// The internal value of the returned counter is set to zero.
+func (c *Counter) WithTags(tags ...Tag) *Counter {
+	return &Counter{
+		eng:  c.eng,
+		name: c.name,
+		tags: concatTags(c.tags, tags),
 	}
-	return makeCounter(c.eng, c.name, concatTags(c.tags, tags))
 }
 
 // Incr increments the counter by a value of 1.
-func (c Counter) Incr() {
+func (c *Counter) Incr() {
 	c.Add(1)
 }
 
 // Add adds a value to the counter.
 //
 // Note that most data collection systems expect counters to be monotonically
 // increasing so the program should not call this method with negative values.
-func (c Counter) Add(value float64) {
-	c.eng.Add(CounterType, c.key, c.name, c.tags, value, time.Now())
+func (c *Counter) Add(value float64) {
+	c.mutex.Lock()
+	c.value += value
+	c.mutex.Unlock()
+	c.eng.Add(c.name, value, c.tags...)
 }
 
 // Set sets the value of the counter.
@@ -64,16 +66,13 @@ func (c Counter) Add(value float64) {
 //
 // This method is useful for reporting values of counters that aren't managed
 // by the application itself, like CPU ticks for example.
-func (c Counter) Set(value float64) {
-	c.eng.Add(CounterType, c.key, c.name, c.tags, value, time.Now())
-}
-
-func makeCounter(eng *Engine, name string, tags []Tag) Counter {
-	sortTags(tags)
-	return Counter{
-		eng:  eng,
-		key:  MetricKey(name, tags),
-		name: name,
-		tags: tags,
+func (c *Counter) Set(value float64) {
+	c.mutex.Lock()
+	if value < c.value {
+		c.value = value
+	} else {
+		c.value, value = value, value-c.value
 	}
+	c.mutex.Unlock()
+	c.eng.Add(c.name, value, c.tags...)
 }