Envío de métricas: DogStatsD

Mientras que StatsD acepta solo métricas, DogStatsD acepta los tres tipos de datos principales de Datadog: métricas, eventos y verificaciones de servicio. Esta sección muestra casos de uso típicos para métricas desglosadas por tipos de métricas, e introduce tasas de muestreo y opciones de etiquetado de métricas específicas de DogStatsD.

Los tipos de métricas COUNT, GAUGE y SET son familiares para los usuarios de StatsD. TIMER de StatsD es un subconjunto de HISTOGRAM en DogStatsD. Además, puedes enviar tipos de métricas HISTOGRAMA y DISTRIBUCIÓN utilizando DogStatsD.

Nota: Dependiendo del método de envío utilizado, el tipo de métrica real almacenado en Datadog puede diferir del tipo de métrica enviado. Para obtener métricas de TASA a través de DogStatsD, envía ya sea una métrica COUNT o HISTOGRAM. Los valores de las métricas COUNT y de <HISTOGRAM>.count son deltas normalizados en el tiempo del valor de la métrica durante el período de vaciado de StatsD.

Funciones

Después de que instales DogStatsD, las siguientes funciones están disponibles para enviar tus métricas a Datadog dependiendo de su tipo de métrica. Las funciones tienen los siguientes parámetros compartidos:

ParámetroTipoRequeridoDescripción
<METRIC_NAME>CadenaSíNombre de la métrica a enviar.
<METRIC_VALUE>DoubleYesValor asociado con tu métrica.
<SAMPLE_RATE>DobleNoLa tasa de muestreo que se aplicará a la métrica. Toma un valor entre 0 (todo se muestrea, por lo que no se envía nada) y 1 (sin muestreo). Consulta la sección Tasa de Muestreo para aprender más.
<TAGS>Lista de cadenasNoUna lista de etiquetas para aplicar a la métrica. Consulta la sección Etiquetado de Métricas para aprender más.
<CARDINALITY>EnumNoLa cardinalidad de etiquetas para asignar a esta métrica.

COUNT

increment(<METRIC_NAME>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY> )
Se utiliza para incrementar una métrica COUNT. Almacenado como un tipo RATE en Datadog. Cada valor en las series temporales almacenadas es un delta normalizado en el tiempo del valor de la métrica durante el período de vaciado de StatsD.
decrement(<METRIC_NAME>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Se utiliza para decrementar una métrica COUNT. Almacenado como un tipo RATE en Datadog. Cada valor en las series temporales almacenadas es un delta normalizado en el tiempo del valor de la métrica durante el período de vaciado de StatsD.
count(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Se utiliza para incrementar una métrica COUNT de un Value arbitrario. Almacenado como un tipo RATE en Datadog. Cada valor en las series temporales almacenadas es un delta normalizado en el tiempo del valor de la métrica durante el período de vaciado de StatsD.

Nota: Las métricas de tipo COUNT pueden mostrar un valor decimal dentro de Datadog ya que están normalizadas durante el intervalo de vaciado para reportar unidades por segundo.

Ejemplos de código

Envía una métrica COUNT almacenada como una métrica RATE a Datadog. Aprende más sobre el tipo COUNT en la documentación de tipos de métricas.

Ejecuta el siguiente código para enviar una métrica DogStatsD COUNT a Datadog. Recuerda flush/close al cliente cuando ya no sea necesario.

from datadog import initialize, statsd
import time

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)

while(1):
  statsd.increment('example_metric.increment', tags=["environment:dev"])
  statsd.decrement('example_metric.decrement', tags=["environment:dev"])
  time.sleep(10)

Nota: statsd.count no es compatible en Python.

require 'datadog/statsd'

statsd = Datadog::Statsd.new('localhost', 8125, tags: ['environment:dev'])

while true do
    statsd.increment('example_metric.increment')
    statsd.increment('example_metric.increment', tags: ['another:tag'])
    statsd.decrement('example_metric.decrement')
    statsd.count('example_metric.count', 2)
    sleep 10
end

package main

import (
	"log"
	"time"

	"github.com/DataDog/datadog-go/v5/statsd"
)

func main() {
	statsd, err := statsd.New("127.0.0.1:8125")
	if err != nil {
		log.Fatal(err)
	}
	for true {

		statsd.Incr("example_metric.increment", []string{"environment:dev"}, 1)
		statsd.Decr("example_metric.decrement", []string{"environment:dev"}, 1)
		statsd.Count("example_metric.count", 2, []string{"environment:dev"}, 1)
		time.Sleep(10 * time.Second)
	}
}

import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;
import java.util.Random;

public class DogStatsdClient {

    public static void main(String[] args) throws Exception {

        StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .prefix("statsd")
            .hostname("localhost")
            .port(8125)
            .build();
        while (true) {
            Statsd.incrementCounter("example_metric.increment", new String[]{"environment:dev"});
            Statsd.decrementCounter("example_metric.decrement", new String[]{"environment:dev"});
            Statsd.count("example_metric.count", 2, new String[]{"environment:dev"});
            Thread.sleep(100000);
        }
    }
}

using StatsdClient;
using System;

public class DogStatsdClient
{
    public static void Main()
    {
        var dogstatsdConfig = new StatsdConfig
        {
            StatsdServerName = "127.0.0.1",
            StatsdPort = 8125,
        };

        using (var dogStatsdService = new DogStatsdService())
        {
            if (!dogStatsdService.Configure(dogstatsdConfig))
                throw new InvalidOperationException("Cannot initialize DogstatsD. Set optionalExceptionHandler argument in the `Configure` method for more information.");
            var random = new Random(0);

            while (true)
            {
                dogStatsdService.Increment("example_metric.increment", tags: new[] {"environment:dev"}, cardinality: Cardinality.Low);
                dogStatsdService.Decrement("example_metric.decrement", tags: new[] {"environment:dev"}, cardinality: Cardinality.High);
                dogStatsdService.Counter("example_metric.count", 2, tags: new[] {"environment:dev"});
                System.Threading.Thread.Sleep(random.Next(100000));
            }
        }
    }
}

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

while (TRUE) {
    $statsd->increment('example_metric.increment', 1, array('environment'=>'dev'), 'low');
    $statsd->decrement('example_metric.decrement', 1, array('environment'=>'dev'), 'high');
    sleep(10);
}

const tracer = require('dd-trace');
tracer.init();

tracer.dogstatsd.increment('example_metric.increment', 1, { environment: 'dev' });
tracer.dogstatsd.decrement('example_metric.decrement', 1, { environment: 'dev' });

Después de ejecutar el código anterior, sus datos de métricas están disponibles para graficar en Datadog:

Incrementar Decrementar

Dado que el valor se envía como un COUNT, se almacena como RATE en Datadog. Para obtener conteos brutos dentro de Datadog, aplica una función a tu serie como la función Suma Acumulativa o Integral:

Incrementar Decrementar con Cumsum

GAUGE

gauge(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo GAUGE en Datadog. Cada valor en las series temporales almacenadas es el último valor de gauge enviado para la métrica durante el período de vaciado de StatsD.

Ejemplos de código

Envía una métrica GAUGE almacenada como una métrica GAUGE a Datadog. Aprende más sobre el tipo GAUGE en la documentación de tipos de métricas.

Ejecuta el siguiente código para enviar una métrica DogStatsD GAUGE a Datadog. Recuerda flush/close al cliente cuando ya no sea necesario.

Nota: Las llamadas de envío de métricas son asincrónicas. Si deseas asegurarte de que las métricas se envíen, llama a flush antes de que el programa finalice.

from datadog import initialize, statsd
import time

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)

i = 0

while(1):
  i += 1
  statsd.gauge('example_metric.gauge', i, tags=["environment:dev"], cardinality="low")
  time.sleep(10)

require 'datadog/statsd'

statsd = Datadog::Statsd.new('localhost', 8125)

i = 0

while true do
    i += 1
    statsd.gauge('example_metric.gauge', i, tags: ['environment:dev'], cardinality: 'low')
    sleep 10
end

package main

import (
	"log"
	"time"

	"github.com/DataDog/datadog-go/v5/statsd"
)

func main() {
	statsd, err := statsd.New("127.0.0.1:8125")
	if err != nil {
		log.Fatal(err)
	}
	var i float64
	for true {
		i += 1
		statsd.Gauge("example_metric.gauge", i, []string{"environment:dev"}, 1, CardinalityHigh)
		time.Sleep(10 * time.Second)
	}
}

import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;
import java.util.Random;

public class DogStatsdClient {

    public static void main(String[] args) throws Exception {

        StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .prefix("statsd").
            .hostname("localhost")
            .port(8125)
            .build();
        for (int i = 0; true; i++) {
            Statsd.recordGaugeValue("example_metric.gauge", i, new String[]{"environment:dev"});
            Thread.sleep(10000);
        }
    }
}

using StatsdClient;
using System;

public class DogStatsdClient
{
    public static void Main()
    {
        var dogstatsdConfig = new StatsdConfig
        {
            StatsdServerName = "127.0.0.1",
            StatsdPort = 8125,
        };

        using (var dogStatsdService = new DogStatsdService())
        {
            if (!dogStatsdService.Configure(dogstatsdConfig))
                throw new InvalidOperationException("Cannot initialize DogstatsD. Set optionalExceptionHandler argument in the `Configure` method for more information.");
            var random = new Random(0);

            for (int i = 0; true; i++)
            {
                dogStatsdService.Gauge("example_metric.gauge", i, tags: new[] {"environment:dev"}, cardinality: Cardinality.High);
                System.Threading.Thread.Sleep(100000);
            }
        }
    }
}

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

$i = 0;
while (TRUE) {
    $i++;
    $statsd->gauge('example_metric.gauge', $i, array('environment'=>'dev'), 'low');
    sleep(10);
}

const tracer = require('dd-trace');
tracer.init();

let i = 0;
while(true) {
  i++;
  tracer.dogstatsd.gauge('example_metric.gauge', i, { environment: 'dev' });
}

Después de ejecutar el código anterior, tus datos de métricas están disponibles para graficar en Datadog:

Gauge

ESTABLECER

set(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo GAUGE en Datadog. Cada valor en las series temporales almacenadas es el conteo de valores únicos enviados a StatsD para una métrica durante el período de vaciado.

Ejemplos de código

Envía una métrica SET almacenada como una métrica GAUGE a Datadog.

Ejecuta el siguiente código para enviar una métrica DogStatsD SET a Datadog. Recuerda flush/close al cliente cuando ya no sea necesario.

from datadog import initialize, statsd
import time
import random

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)
i = 0
while(1):
  i += 1
  statsd.set('example_metric.set', i, tags=["environment:dev"])
  time.sleep(random.randint(0, 10))

require 'datadog/statsd'

statsd = Datadog::Statsd.new('localhost', 8125)

i = 0
while true do
    i += 1
    statsd.set('example_metric.gauge', i, tags: ['environment:dev'])
    sleep rand 10
end

package main

import (
	"fmt"
	"log"
	"math/rand"
	"time"

	"github.com/DataDog/datadog-go/v5/statsd"
)

func main() {
	statsd, err := statsd.New("127.0.0.1:8125")
	if err != nil {
		log.Fatal(err)
	}
	var i float64
	for true {
		i += 1
		statsd.Set("example_metric.set", fmt.Sprintf("%f", i), []string{"environment:dev"}, 1)
		time.Sleep(time.Duration(rand.Intn(10)) * time.Second)
	}
}

import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;
import java.util.Random;

public class DogStatsdClient {

    public static void main(String[] args) throws Exception {

        StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .prefix("statsd").
            .hostname("localhost")
            .port(8125)
            .build();
        for (int i = 0; true; i++) {
            Statsd.recordSetValue("example_metric.set", i, new String[]{"environment:dev"});
            Thread.sleep(random.NextInt(10000));
        }
    }
}

using StatsdClient;
using System;

public class DogStatsdClient
{
    public static void Main()
    {
        var dogstatsdConfig = new StatsdConfig
        {
            StatsdServerName = "127.0.0.1",
            StatsdPort = 8125,
        };

        using (var dogStatsdService = new DogStatsdService())
        {
            if (!dogStatsdService.Configure(dogstatsdConfig))
                throw new InvalidOperationException("Cannot initialize DogstatsD. Set optionalExceptionHandler argument in the `Configure` method for more information.");
            var random = new Random(0);

            for (int i = 0; true; i++)
            {
                dogStatsdService.Set("example_metric.set", i, tags: new[] {"environment:dev"});
                System.Threading.Thread.Sleep(random.Next(100000));
            }
        }
    }
}

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

$i = 0;

while (TRUE) {
    $i++;
    $statsd->set('example_metric.set', $i, 1, array('environment'=>'dev'), 'low');
    sleep(rand(0, 10));
}

Después de ejecutar el código anterior, tus datos de métricas están disponibles para graficar en Datadog:

Set

HISTOGRAMA

histogram(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Dado que se envían múltiples métricas, los tipos de métricas almacenadas (GAUGE, RATE) dependen de la métrica. Consulta la documentación del tipo de métrica HISTOGRAMA para aprender más.

Configuración

  • Configura la agregación para enviar a Datadog con el parámetro histogram_aggregates en tu archivo de configuración datadog.yaml. Por defecto, solo se envían las agregaciones max, median, avg y count.
  • Configura la agregación de percentiles para enviar a Datadog con el parámetro histogram_percentiles en tu archivo de configuración datadog.yaml. Por defecto, solo se envía el percentil 95pc.

Ejemplos de código

El tipo de métrica HISTOGRAM es específico de DogStatsD. Envía una métrica HISTOGRAM—almacenada como una métrica GAUGE y RATE—a Datadog. Aprende más sobre el tipo HISTOGRAM en la documentación de tipos de métricas.

Ejecuta el siguiente código para enviar una métrica DogStatsD HISTOGRAM a Datadog. Recuerda flush/close el cliente cuando ya no sea necesario.

from datadog import initialize, statsd
import time
import random

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)

while(1):
  statsd.histogram('example_metric.histogram', random.randint(0, 20), tags=["environment:dev"])
  time.sleep(2)

require 'datadog/statsd'

statsd = Datadog::Statsd.new('localhost', 8125)

while true do
    statsd.histogram('example_metric.histogram', rand 20, tags: ['environment:dev'])
    sleep 2
end

package main

import (
	"log"
	"math/rand"
	"time"

	"github.com/DataDog/datadog-go/v5/statsd"
)

func main() {
	statsd, err := statsd.New("127.0.0.1:8125")
	if err != nil {
		log.Fatal(err)
	}

	for true {
		statsd.Histogram("example_metric.histogram", float64(rand.Intn(20)), []string{"environment:dev"}, 1)
		time.Sleep(2 * time.Second)
	}
}

import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;
import java.util.Random;

public class DogStatsdClient {

    public static void main(String[] args) throws Exception {

        StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .prefix("statsd").
            .hostname("localhost")
            .port(8125)
            .build();
        while (true) {
            Statsd.recordHistogramValue("example_metric.histogram", new Random().nextInt(20), new String[]{"environment:dev"});
            Thread.sleep(2000);
        }
    }
}

using StatsdClient;
using System;

public class DogStatsdClient
{
    public static void Main()
    {
        var dogstatsdConfig = new StatsdConfig
        {
            StatsdServerName = "127.0.0.1",
            StatsdPort = 8125,
        };

        using (var dogStatsdService = new DogStatsdService())
        {
            if (!dogStatsdService.Configure(dogstatsdConfig))
                throw new InvalidOperationException("Cannot initialize DogstatsD. Set optionalExceptionHandler argument in the `Configure` method for more information.");
            var random = new Random(0);

            while (true)
            {
                dogStatsdService.Histogram("example_metric.histogram", random.Next(20), tags: new[] {"environment:dev"}, Cardinality: Cardinality.High);
                System.Threading.Thread.Sleep(2000);
            }
        }
    }
}

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

while (TRUE) {
    $statsd->histogram('example_metric.histogram', rand(0, 20), 1, array('environment'=>'dev'), 'low');
    sleep(2);
}

La instrumentación anterior produce las siguientes métricas:

MétricaDescripción
example_metric.histogram.countNúmero de veces que se muestreó esta métrica
example_metric.histogram.avgPromedio de los valores muestreados
example_metric.histogram.medianValor muestreado mediano
example_metric.histogram.maxValor muestreado máximo
example_metric.histogram.95percentileValor muestreado del percentil 95

Después de ejecutar el código anterior, tus datos de métricas están disponibles para graficar en Datadog:

Histograma

TIMER

TIMER el tipo de métrica en DogStatsD es una implementación del tipo de métrica HISTOGRAM (no debe confundirse con TIMER en el StatsD estándar). Mide solo datos de tiempo: por ejemplo, la cantidad de tiempo que tarda en ejecutarse una sección de código.

timed(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Dado que se envían múltiples métricas, los tipos de métricas almacenadas (GAUGE, RATE) dependen de la métrica. Consulta la documentación del tipo de métrica HISTOGRAMA para aprender más.
Configuración

Para un TIMER, se aplican las reglas de configuración HISTOGRAM .

Ejemplos de código

Envía una métrica TIMER—almacenada como una métrica GAUGE y RATE—a Datadog. Aprenda más sobre el tipo HISTOGRAM en la documentación de tipos de métricas. Recuerde flush/close al cliente cuando ya no sea necesario.

En Python, los temporizadores se crean con un decorador.

from datadog import initialize, statsd
import time
import random

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)

@statsd.timed('example_metric.timer', tags=["environment:dev,function:my_function"])
def my_function():
  time.sleep(random.randint(0, 10))

while(1):
  my_function()

o con un administrador de contexto:

from datadog import statsd
import time
import random

def my_function():

  # First some stuff you don't want to time
  sleep(1)

  # Now start the timer
  with statsd.timed('example_metric.timer', tags=["environment:dev"]):
    # do something to be measured
    sleep(random.randint(0, 10))

while(1):
  my_function()

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

function runfunction() {
    sleep(rand(0, 20));
}

while (TRUE) {
  $start_time = microtime(TRUE);
  runfunction();
  $statsd->microtiming('example_metric.timer', microtime(TRUE) - $start_time);
}

A medida que DogStatsD recibe los datos de la métrica del temporizador, calcula la distribución estadística de los tiempos de renderizado y envía las siguientes métricas a Datadog:

MétricaDescripción
example_metric.timer.countNúmero de veces que se muestreó esta métrica
example_metric.timer.avgTiempo promedio de los valores muestreados
example_metric.timer.medianValor muestreado mediano
example_metric.timer.maxValor muestreado máximo
example_metric.timer.95percentileValor muestreado del percentil 95

DogStatsD trata TIMER como una métrica HISTOGRAM. Ya sea que use el tipo de métrica TIMER o HISTOGRAM, está enviando los mismos datos a Datadog. Después de ejecutar el código anterior, sus datos de métricas están disponibles para graficar en Datadog:

Temporizador

DISTRIBUCIÓN

distribution(<METRIC_NAME>, <METRIC_VALUE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo DISTRIBUTION en Datadog. Consulte la documentación dedicada de Distribución para aprender más.

Ejemplos de código

El tipo de métrica DISTRIBUTION es específico de DogStatsD. Emita una métrica DISTRIBUTION—almacenada como una métrica DISTRIBUTION—a Datadog. Aprenda más sobre el tipo DISTRIBUTION en la documentación de tipos de métricas.

Ejecute el siguiente código para enviar una métrica DISTRIBUTION de DogStatsD a Datadog. Recuerde flush/close al cliente cuando ya no sea necesario.

from datadog import initialize, statsd
import time
import random

options = {
    'statsd_host':'127.0.0.1',
    'statsd_port':8125
}

initialize(**options)

while(1):
  statsd.distribution('example_metric.distribution', random.randint(0, 20), tags=["environment:dev"])
  time.sleep(2)

require 'datadog/statsd'

statsd = Datadog::Statsd.new('localhost', 8125)

while true do
    statsd.distribution('example_metric.distribution', rand 20, tags: ['environment:dev'])
    sleep 2
end

package main

import (
	"log"
	"math/rand"
	"time"

	"github.com/DataDog/datadog-go/v5/statsd"
)

func main() {
	statsd, err := statsd.New("127.0.0.1:8125")
	if err != nil {
		log.Fatal(err)
	}

	for true {
		statsd.Distribution("example_metric.distribution", float64(rand.Intn(20)), []string{"environment:dev"}, 1)
		time.Sleep(2 * time.Second)
	}
}

import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;
import java.util.Random;

public class DogStatsdClient {

    public static void main(String[] args) throws Exception {

        StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .prefix("statsd").
            .hostname("localhost")
            .port(8125)
            .build();
        while (true) {
            Statsd.recordDistributionValue("example_metric.distribution", new Random().nextInt(20), new String[]{"environment:dev"});
            Thread.sleep(2000);
        }
    }
}

using StatsdClient;
using System;

public class DogStatsdClient
{
    public static void Main()
    {
        var dogstatsdConfig = new StatsdConfig
        {
            StatsdServerName = "127.0.0.1",
            StatsdPort = 8125,
        };

        using (var dogStatsdService = new DogStatsdService())
        {
            if (!dogStatsdService.Configure(dogstatsdConfig))
                throw new InvalidOperationException("Cannot initialize DogstatsD. Set optionalExceptionHandler argument in the `Configure` method for more information.");
            var random = new Random(0);

            while (true)
            {
                dogStatsdService.Distribution("example_metric.distribution", random.Next(20), tags: new[] {"environment:dev"});
                System.Threading.Thread.Sleep(2000);
            }
        }
    }
}

<?php

require __DIR__ . '/vendor/autoload.php';

use DataDog\DogStatsd;

$statsd = new DogStatsd(
    array('host' => '127.0.0.1',
          'port' => 8125,
     )
  );

while (TRUE) {
    $statsd->distribution('example_metric.distribution', rand(0, 20), 1, array('environment'=>'dev'), 'high');
    sleep(2);
}

const tracer = require('dd-trace');
tracer.init();

while(true) {
  tracer.dogstatsd.distribution('example_metric.distribution', Math.random() * 20, { environment: 'dev' });
  await new Promise(r => setTimeout(r, 2000));
}

La instrumentación anterior calcula el sum, count, average, minimum, maximum, 50th percentile (mediana), 75th percentile, 90th percentile, 95th percentile y 99th percentile. Las distribuciones se pueden usar para medir la distribución de cualquier tipo de valor, como el tamaño de los archivos subidos o las calificaciones de los exámenes en el aula.

Opciones de envío de métricas

Tasas de muestreo

Dado que la sobrecarga de enviar paquetes UDP puede ser demasiado grande para algunos caminos de código intensivos en rendimiento, los clientes de DogStatsD soportan muestreo (enviando métricas solo un porcentaje del tiempo). Es útil si se muestrean muchas métricas y su cliente de DogStatsD no se encuentra en el mismo servidor que el servidor de DogStatsD. La compensación consiste en reducir el tráfico, pero se pierde algo de precisión y granularidad.

Una tasa de muestreo de 1 envía métricas el 100% del tiempo, mientras que una tasa de muestreo de 0 envía métricas el 0% del tiempo.

Antes de enviar una métrica a Datadog, DogStatsD utiliza el <SAMPLE_RATE> para corregir el valor de la métrica dependiendo del tipo de métrica (para estimar el valor sin muestreo):

Tipo de métricaCorrección de tasa de muestreo
COUNTLos valores recibidos se multiplican por (1/<SAMPLE_RATE>). Es razonable suponer que por un punto de datos recibido, 1/<SAMPLE_RATE> fueron realmente muestreados con el mismo valor.
GAUGESin corrección. El valor recibido se mantiene tal como está.
SETSin corrección. El valor recibido se mantiene tal como está.
HISTOGRAMLa estadística histogram.count es una métrica de CONTADOR y recibe la corrección mencionada anteriormente. Otras estadísticas son métricas de gauge y no son “corregidas”.
DISTRIBUTIONLos valores recibidos se cuentan (1/<SAMPLE_RATE>) veces. Es razonable suponer que por cada punto de datos recibido, 1/<SAMPLE_RATE> fueron realmente muestreados con el mismo valor.

Ejemplos de código

El siguiente código solo envía puntos la mitad del tiempo:

statsd.increment('loop.count', sample_rate=0.5)

statsd.increment('loop.count', :sample_rate => 0.5)

statsd.Incr("example_metric.increment", []string{}, 0.5)

Statsd.incrementCounter("example_metric.increment", sampleRate=0.5);

dogStatsdService.Increment("example_metric.increment", sampleRate: 0.5);

<? php
$statsd->increment('example_metric.increment', $sampleRate->0.5);

Etiquetado de métricas

Agregue etiquetas a cualquier métrica que envíe a DogStatsD con el parámetro tags.

Ejemplos de código

El siguiente código solo agrega las etiquetas environment:dev y account:local a la métrica example_metric.increment:

statsd.increment('example_metric.increment', tags=["environment:dev","account:local"])

statsd.increment('example_metric.increment', tags: ['environment:dev','account:local'])

statsd.Incr("example_metric.increment", []string{"environment:dev","account:local"}, 1)

Statsd.incrementCounter("example_metric.increment", new String[]{"environment:dev","account:local"});

dogStatsdService.Increment("example_metric.increment", tags: new[] {"environment:dev","account:local"})

El argumento tags puede ser una cadena:

$statsd->increment('example_metric.increment', 1.0, "environment:dev,account:local");

o un arreglo:

<?php
$statsd->increment('example_metric.increment', 1.0, array('environment' => 'dev', 'account' => 'local'));

tracer.dogstatsd.increment('example_metric.increment', 1, { environment: 'dev', account: 'local' });

Etiqueta de servidor

La etiqueta de servidor se asigna automáticamente por el Agente de Datadog que agrega las métricas. Las métricas enviadas con una etiqueta de servidor que no coincide con el nombre del servidor del Agente pierden referencia al servidor original. La etiqueta de servidor enviada anula cualquier nombre de servidor recopilado o configurado en el Agente.

Lectura adicional

Más enlaces, artículos y documentación útiles:

Introducción a DogStatsDDOCUMENTATION more more Tipos de métricas de DatadogDOCUMENTATION more more