package module
Version: v0.29.0 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Feb 14, 2022 License: Apache-2.0 Imports: 11 Imported by: 0



Package datadog provides a DataDog exporter.

Deprecated: This package is no longer supported.




View Source
const (
	// DefaultStatsAddrUDP specifies the default protocol (UDP) and address
	// for the DogStatsD service.
	DefaultStatsAddrUDP = "localhost:8125"


This section is empty.


func SemVersion added in v0.25.0

func SemVersion() string

SemVersion is the semantic version to be supplied to tracer/meter creation.

func Version added in v0.25.0

func Version() string

Version is the current release version of the DataDog exporter.


type Exporter

type Exporter struct {
	// contains filtered or unexported fields

Exporter forwards metrics to a DataDog agent

package main

import (


	controller ""
	semconv ""

type TestUDPServer struct {

func main() {
	const testHostPort = ":8159"
	selector := simple.NewWithInexpensiveDistribution()
	exp, err := NewExporter(Options{
		StatsAddr:     testHostPort,
		Tags:          []string{"env:dev"},
		StatsDOptions: []statsd.Option{statsd.WithoutTelemetry()},
	if err != nil {
	s, err := getTestServer(testHostPort)
	if err != nil {
	defer s.Close()

	go func() {
		defer exp.Close()
		processor := basic.NewFactory(selector, exp)
		cont := controller.New(processor, controller.WithExporter(exp), controller.WithCollectPeriod(time.Second*10),
		ctx := context.Background()
		err := cont.Start(ctx)
		if err != nil {

		defer func() { handleErr(cont.Stop(ctx)) }()
		meter := global.Meter("marwandist")
		m := metric.Must(meter).NewInt64Counter("mycounter")
		meter.RecordBatch(context.Background(), []attribute.KeyValue{attribute.Int("l", 1)},
			m.Measurement(1), m.Measurement(50), m.Measurement(100))

	statsChan := make(chan []byte, 1)
	timedOutChan, stopChan := make(chan struct{}), make(chan struct{})
	defer close(stopChan)

	go s.ReadPackets(statsChan, 500*time.Millisecond, timedOutChan, stopChan)

	for {
		select {
		case d := <-statsChan:
			// only look for "max" value, since we don't want to rely on
			// specifics of OpenTelemetry aggregator calculations
			// "max" is something that will always exist and always be the same
			statLine := string(d)
		case <-timedOutChan:
			_, _ = fmt.Fprintln(os.Stderr, "Server timed out waiting for packets")
		case <-time.After(2 * time.Second):
			fmt.Println("no data received after 1 second")


func getTestServer(addr string) (*TestUDPServer, error) {
	udpAddr, err := net.ResolveUDPAddr("udp", addr)
	if err != nil {
		return nil, err

	conn, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		return nil, err
	return &TestUDPServer{conn}, nil

// ReadPackets reads one "transmission" at a time from the UDP connection
// In the case of StatsD, there is one transmission per stat.
// If there is nothing on the connection for longer than maxIdleTime, the
// routine will return, assuming that everything has been sent
// doneChan is an output channel that is closed when ReadPackets returns
// stopChan is an input channel that tells ReadPackets to exit
func (s TestUDPServer) ReadPackets(
	xferChan chan []byte,
	maxIdleTime time.Duration,
	doneChan chan<- struct{},
	stopChan <-chan struct{}) {

	const readTimeout = 50 * time.Millisecond
	var timeouts int

	buffer := make([]byte, 1500)
	defer close(doneChan)
	n := 0
	for {
		select {
		case <-stopChan:
			_ = s.SetReadDeadline(time.Now().Add(readTimeout))
			nn, _, err := s.ReadFrom(buffer[n:])
			if err == nil {
				timeouts = 0
				data := make([]byte, nn)
				_ = copy(data, buffer[n:n+nn])
				xferChan <- data
				n += nn
			} else {
				if nerr, ok := err.(*net.OpError); ok && nerr.Timeout() {
					if time.Duration(timeouts)*readTimeout > maxIdleTime {
				// give connection some time to connect
				time.Sleep(2 * time.Millisecond)


func handleErr(err error) {
	if err != nil {
		fmt.Println("Encountered error: ", err.Error())


func NewExporter

func NewExporter(opts Options) (*Exporter, error)

NewExporter exports to a datadog client

func (*Exporter) Close

func (e *Exporter) Close() error

Close cloess the underlying datadog client which flushes any pending buffers

func (*Exporter) Export

func (*Exporter) TemporalityFor added in v0.27.0

TemporalityFor returns export.DeltaExporter for statsd-derived exporters

type Options

type Options struct {
	// StatsAddr specifies the host[:port] address for DogStatsD. It defaults
	// to DefaultStatsAddrUDP.
	StatsAddr string

	// Tags specifies a set of global tags to attach to each metric.
	Tags []string

	// UseDistribution uses a DataDog Distribution type instead of Histogram
	UseDistribution bool

	// MetricNameFormatter lets you customize the metric name that gets sent to
	// datadog before exporting
	MetricNameFormatter func(namespace, name string) string

	// StatsD specific Options
	StatsDOptions []statsd.Option

Options contains options for configuring the exporter.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL