Envío de métricas: DogStatsD

Mientras que StatsD solo acepta métricas, DogStatsD acepta los tres tipos de datos principales de Datadog: métricas, eventos y checks de servicios. Esta sección muestra los casos de uso típicos de métricas divididos por tipos de métrica y presenta las opciones muestreo de índices y etiquetado de métricas, específicas de DogStatsD.

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

Nota: Dependiendo del método de envío utilizado, el tipo real de métrica almacenado en Datadog puede diferir del tipo de métrica enviado. Al enviar un tipo de métrica RATE a través de DogStatsD, la métrica aparece como GAUGE en la aplicación, para garantizar una comparación adecuada entre los distintos Agents.

Funciones

Después de instalar DogStatsD, las siguientes funciones están disponibles para enviar tus métricas a Datadog, según tu tipo de métrica. Las funciones comparten los siguientes parámetros:

ParámetroTipoObligatorioDescripción
<METRIC_NAME>CadenaSíNombre de la métrica que se va a enviar.
<METRIC_VALUE>DobleSíValor asociado a tu métrica.
<SAMPLE_RATE>DobleNoLa frecuencia de muestreo que se aplicará a la métrica toma un valor entre 0 (se muestrea todo, por lo que no se envía nada) y 1 (sin muestreo). Para obtener más información, consulta la sección Frecuencia de muestreo.
<TAGS>Lista de cadenasNoLista de etiquetas (tags) para aplicar a la métrica. Para obtener más información, consulta la sección Etiquetado de métricas.
<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. Se almacena como un tipo RATE en Datadog. Cada valor de la serie temporal almacenada es un delta normalizado en el tiempo del valor de la métrica durante el periodo de descarga de StatsD.
decrement(<METRIC_NAME>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Se utiliza para disminuir una métrica COUNT. Se almacena como un tipo RATE en Datadog. Cada valor de la serie temporal almacenada es un delta normalizado en el tiempo del valor de la métrica durante el periodo de descarga de StatsD.
count(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Utilizado para incrementar una métrica COUNT desde un Value arbitrario. Almacenado como un tipo RATE en Datadog. Cada valor de la serie temporal almacenada es un delta normalizado en el tiempo del valor de la métrica durante el periodo de descarga de StatsD.

Nota: El tipo de métrica COUNT puede mostrar un valor decimal en Datadog, ya que se normalizan durante el intervalo de vaciado para informar unidades por segundo.

Ejemplos de códigos

Emite una métrica COUNT almacenada como métrica RATE a Datadog. Para obtener más información sobre el tipo de métrica COUNT, consulta la documentación sobre tipos de métricas.

Ejecuta el siguiente código para enviar una métrica de DogStatsD COUNT a Datadog. Recuerda flush/close el 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 con 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, los datos de tus métricas estarán disponibles para su representación gráfica en Datadog:

Incremento/Reducción

Debido a que el valor se envía como COUNT, se almacena como RATE en Datadog. Para obtener recuentos sin procesar en Datadog, aplica una función a tu serie, como por ejemplo una función Suma acumulativa o Integral:

Incremento/Reducción con sumas acumulativas

GAUGE

gauge(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo GAUGE en Datadog. Cada valor de la serie temporal almacenada es el último valor de medición enviado para la métrica durante el periodo de descarga de StatsD.

Ejemplos de códigos

Emite una métrica GAUGE almacenada como métrica GAUGE a Datadog. Para obtener más información sobre el tipo de métrica GAUGE, consulta la documentación sobre tipos de métricas.

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

Nota: Las llamadas para el envío de métricas son asíncronas. Si quieres asegurarte de que se envíen las métricas, llama a flush antes de que se cierre el programa.

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, los datos de tus métricas estarán disponibles en Datadog:

Gauge

SET

set(<METRIC_NAME>, <METRIC_VALUE>, <SAMPLE_RATE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo GAUGE en Datadog. Cada valor de la serie temporal almacenada es el recuento de valores únicos enviados a StatsD para una métrica durante el periodo de descarga.

Ejemplos de códigos

Emite una métrica SET almacenada como GAUGE a Datadog.

Ejecuta el siguiente código para enviar una métrica de DogStatsD SET 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)
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, los datos de tus métricas estarán disponibles para su representación gráfica en Datadog:

Set

HISTOGRAM

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

Configuración

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

Ejemplos de códigos

El tipo de métrica HISTOGRAM es específico de DogStatsD. Emite una métrica HISTOGRAM almacenada como métrica GAUGE y RATE a Datadog. Para obtener más información sobre el tipo HISTOGRAM, consulta la documentación sobre tipos de métricas.

Ejecuta el siguiente código para enviar una métrica de 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 genera las siguientes métricas:

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

Después de ejecutar el código anterior, los datos de tus métricas estarán disponibles para su representación gráfica en Datadog:

Histogram

TIMER

La métrica TIMER en DogStatsD es una implementación del tipo de métrica HISTOGRAM (no confundir con los temporizadores en el StatsD estándar). Solo mide datos de temporización: 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étrica almacenados (GAUGE, RATE) dependen de la métrica. Consulta la documentación tipo de métrica HISTOGRAM para obtener más información.
Configuración

Para TIMER, se aplica la configuración de HISTOGRAM.

Ejemplos de códigos

Emite una métrica TIMER almacenada como métrica GAUGE y RATE a Datadog. Para obtener más información sobre el tipo HISTOGRAM, consulta la documentación sobre tipos de métricas. Recuerda flush/close el 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 gestor 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 métricas de temporizador, calcula la distribución estadística de los tiempos de entrega y envía las siguientes métricas a Datadog:

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

DogStatsD trata a TIMER como una métrica HISTOGRAM. Tanto si utilizas el tipo de métrica TIMER como si utilizas el tipo HISTOGRAM, estarás enviando los mismos datos a Datadog. Después de ejecutar el código anterior, los datos de tus métricas estarán disponibles para su representación gráfica en Datadog:

Timer

DISTRIBUCIÓN

distribution(<METRIC_NAME>, <METRIC_VALUE>, <TAGS>, <CARDINALITY>)
Almacenado como un tipo DISTRIBUTION en Datadog. Consulta la Documentación de distribución dedicada para obtener más información.

Ejemplos de códigos

El tipo de métrica DISTRIBUTION es específico de DogStatsD. Emite una métrica DISTRIBUTION almacenada como métrica DISTRIBUTION a Datadog. Para obtener más información sobre el tipo DISTRIBUTION, consulta la documentación sobre tipos de métricas.

Ejecuta el siguiente código para enviar una métrica de DogStatsD DISTRIBUTION 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.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.gauge', 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 sum, count, average, minimum, maximum, 50th percentile (mediana), 75th percentile, 90th percentile, 95th percentile y 99th percentile. Las distribuciones pueden utilizarse para medir la distribución de cualquier tipo de valor, como el tamaño de los archivos cargados o los resultados de exámenes de clase.

Opciones de envío de métricas

Frecuencias de muestreo

Debido a que la sobrecarga del envío de paquetes UDP puede ser demasiado grande para algunas rutas de código de rendimiento intensivo, los clientes DogStatsD admiten el muestreo (sólo envían métricas un porcentaje del tiempo). Es útil si muestreas muchas métricas y el cliente DogStatsD no está en el mismo host que el servidor DogStatsD. Esto ayuda a reducir el tráfico, pero se pierde precisión y granularidad.

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

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

Tipo de métricasCorrección de la frecuencia de muestreo
COUNTLos valores recibidos se multiplican por (1/<SAMPLE_RATE>). Es razonable suponer que para un punto de datos recibido, las 1/<SAMPLE_RATE> han sido realmente muestreadas con el mismo valor.
GAUGESin corrección. El valor recibido se mantiene tal cual.
SETSin corrección. El valor recibido se mantiene tal cual.
HISTOGRAMLa estadística histogram.count es una métrica COUNT y recibe la corrección indicada anteriormente. Otras estadísticas son las métricas gauge y no “se corrigen”.
DISTRIBUTIONLos valores recibidos se cuentan (1/<SAMPLE_RATE>). Es razonable suponer que para un punto de datos recibido, las 1/<SAMPLE_RATE> han sido realmente muestreadas con el mismo valor.

Ejemplos de códigos

El siguiente código solo envía puntos la mitad de las veces:

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

Añade etiquetas a cualquier métrica que envíes a DogStatsD con el parámetro tags.

Ejemplos de códigos

El siguiente código solo añade 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 una matriz:

<?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 host

La etiqueta de host es asignada automáticamente por el Datadog Agent, agregando las métricas. Las métricas enviadas con una etiqueta de host que no coincida con el nombre de host del Agent pierden la referencia al host original. La etiqueta de host enviada anula cualquier nombre de host recopilado o configurado en el Agent.

Referencias adicionales

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

Presentación de DogStatsDDOCUMENTACIÓN more more Tipos de métricas de DatadogDOCUMENTACIÓN more more