Dogstatsd metrics exporter

exporter/metric/dogstatsd/dogstatsd.go

@@ -0,0 +1,77 @@
+// Copyright 2019, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dogstatsd // import "go.opentelemetry.io/otel/exporter/metric/dogstatsd"
+
+import (
+ "bytes"
+
+ "go.opentelemetry.io/otel/exporter/metric/internal/statsd"
+ export "go.opentelemetry.io/otel/sdk/export/metric"
+)
+
+type (
+ Config = statsd.Config
+
+ // Exporter implements a dogstatsd-format statsd exporter,
+ // which encodes label sets as indepenent fields in the
+ // output.
+ //
+ // TODO: find a link for this syntax. It's been copied out of
+ // code, not a specification:
+ //
+ // https:/stripe/veneur/blob/master/sinks/datadog/datadog.go
+ Exporter struct {
+ *statsd.Exporter
+ *statsd.LabelEncoder
+ }
+)
+
+var (
+ _ export.Exporter = &Exporter{}
+ _ export.LabelEncoder = &Exporter{}
+)
+
+// New returns a new Dogstatsd-syntax exporter. This type implements
+// the metric.LabelEncoder interface, allowing the SDK's unique label
+// encoding to be pre-computed for the exporter and stored in the
+// LabelSet.
+func New(config Config) (*Exporter, error) {
+ exp := &Exporter{
+ LabelEncoder: statsd.NewLabelEncoder(),
+ }
+
+ var err error
+ exp.Exporter, err = statsd.NewExporter(config, exp)
+ return exp, err
+}
+
+// AppendName is part of the stats-internal adapter interface.
+func (*Exporter) AppendName(rec export.Record, buf *bytes.Buffer) {
+ _, _ = buf.WriteString(rec.Descriptor().Name())
+}
+
+// AppendTags is part of the stats-internal adapter interface.
+func (e *Exporter) AppendTags(rec export.Record, buf *bytes.Buffer) {
+ labels := rec.Labels()
+
+ if labels.Encoder() != e {
+ // TODO: This case could be handled by directly
+ // encoding the labels at this point, but presently it
+ // should not occur.
+ panic("Should have self-encoded labels")
+ }
+
+ _, _ = buf.WriteString(labels.Encoded())
+}

exporter/metric/dogstatsd/example_test.go

@@ -0,0 +1,87 @@
+package dogstatsd_test
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "log"
+ "sync"
+ "time"
+
+ "go.opentelemetry.io/otel/api/key"
+ "go.opentelemetry.io/otel/api/metric"
+ "go.opentelemetry.io/otel/exporter/metric/dogstatsd"
+ "go.opentelemetry.io/otel/sdk/metric/batcher/ungrouped"
+ "go.opentelemetry.io/otel/sdk/metric/controller/push"
+ "go.opentelemetry.io/otel/sdk/metric/selector/simple"
+)
+
+func ExampleNew() {
+ // Create a "server"
+ wg := &sync.WaitGroup{}
+ wg.Add(1)
+
+ reader, writer := io.Pipe()
+
+ go func() {
+ defer wg.Done()
+
+ for {
+ var buf [4096]byte
+ n, err := reader.Read(buf[:])
+ if err == io.EOF {
+ return
+ } else if err != nil {
+ log.Fatal("Read err: ", err)
+ } else if n >= len(buf) {
+ log.Fatal("Read small buffer: ", n)
+ } else {
+ fmt.Print(string(buf[0:n]))
+ }
+ }
+ }()
+
+ // Create a meter
+ selector := simple.NewWithExactMeasure()
+ exporter, err := dogstatsd.New(dogstatsd.Config{
+ // The Writer field provides test support.
+ Writer: writer,
+
+ // In real code, use the URL field:
+ //
+ // URL: fmt.Sprint("unix://", path),
+ })
+ if err != nil {
+ log.Fatal("Could not initialize dogstatsd exporter:", err)
+ }
+ // The ungrouped batcher ensures that the export sees the full
+ // set of labels as dogstatsd tags.
+ batcher := ungrouped.New(selector, false)
+
+ // The pusher automatically recognizes that the exporter
+ // implements the LabelEncoder interface, which ensures the
+ // export encoding for labels is encoded in the LabelSet.
+ pusher := push.New(batcher, exporter, time.Hour)
+ pusher.Start()
+
+ ctx := context.Background()
+
+ key := key.New("key")
+
+ // pusher implements the metric.MeterProvider interface:
+ meter := pusher.GetMeter("example")
+
+ // Create and update a single counter:
+ counter := meter.NewInt64Counter("a.counter", metric.WithKeys(key))
+ labels := meter.Labels(key.String("value"))
+
+ counter.Add(ctx, 100, labels)
+
+ // Flush the exporter, close the pipe, and wait for the reader.
+ pusher.Stop()
+ writer.Close()
+ wg.Wait()
+
+ // Output:
+ // a.counter:100|c|#key:value
+}