Múltiples mecanismos determinan si los tramos generados por sus aplicaciones son enviados a Datadog (ingresados). La lógica detrás de estos mecanismos está en los SDKs y en el Agente de Datadog. Dependiendo de la configuración, todo o parte del tráfico generado por los servicios instrumentados es ingerido.

Cada tramo ingresado tiene una razón de ingestión única que se refiere a uno de los mecanismos descritos en esta página. Las métricas de uso datadog.estimated_usage.apm.ingested_bytes y datadog.estimated_usage.apm.ingested_spans están etiquetadas por ingestion_reason.

Utilice el tablero de Razones de Ingestión para investigar cada razón de ingestión en contexto e identificar en qué opciones de configuración enfocarse.

Muestreo basado en la cabecera

El mecanismo de muestreo predeterminado se llama muestreo basado en la cabecera. La decisión de mantener o descartar una traza se toma al inicio del tramo raíz y luego se propaga a otros servicios como parte de su contexto de solicitud (por ejemplo, como un encabezado de solicitud HTTP).

Debido a que la decisión se toma al inicio de la traza y se comunica a todas las partes, la traza se mantiene o se descarta en su totalidad.

Puedes establecer tasas de muestreo para el muestreo basado en la cabecera en dos lugares:

• En el nivel de Agente (predeterminado)
• En el nivel de SDK: cualquier mecanismo de SDK anula la configuración del Agente.

En el Agente

ingestion_reason: auto

El Agente de Datadog envía continuamente tasas de muestreo a los SDKs para aplicar en la raíz de las trazas. El Agente ajusta las tasas para lograr un objetivo de diez trazas por segundo en total, distribuidas a los servicios dependiendo del tráfico.

Por ejemplo, si el servicio A tiene más tráfico que el servicio B, el Agente podría variar la tasa de muestreo para A de tal manera que A no mantenga más de siete trazas por segundo, y ajustar de manera similar la tasa de muestreo para B de tal manera que B no mantenga más de tres trazas por segundo, para un total de 10 trazas por segundo.

Remote Configuration

La configuración de la tasa de muestreo en el Agente se puede configurar de forma remota si estás utilizando la versión del Agente 7.42.0 o superior. Para comenzar, configura Remote Configuration y luego configura el parámetro ingestion_reason desde la Ingestion Control page. Remote Configuration te permite cambiar el parámetro sin reiniciar el Agent. La configuración establecida de forma remota tiene prioridad sobre las configuraciones locales, incluidas las variables de entorno y la configuración de datadog.yaml.

Configuración local

Establece el objetivo de trazas por segundo del Agent en su archivo de configuración principal (datadog.yaml) o como una variable de entorno:

@param target_traces_per_second - integer - optional - default: 10
@env DD_APM_TARGET_TPS - integer - optional - default: 10

Notas:

• La tasa de muestreo de trazas por segundo establecida en el Datadog Agent solo se aplica a los SDKs de Datadog. No tiene efecto en otros SDKs como los SDKs de OpenTelemetry.
• El objetivo no es un valor fijo. En realidad, fluctúa dependiendo de los picos de tráfico y otros factores.

Los tramos de las trazas muestreadas por las tasas de muestreo automáticas del Datadog Agent están etiquetados con la razón de ingestión auto. La etiqueta ingestion_reason también se establece en métricas de uso. Los servicios que utilizan este mecanismo predeterminado están etiquetados como Automatic en la columna de Configuración de la Ingestion Control Page.

En SDKs: reglas definidas por el usuario

ingestion_reason: rule

Para un control más granular, utiliza las opciones de configuración de muestreo del SDK:

• Establece una tasa de muestreo específica que se aplique a la raíz de la traza por nombre de servicio o recurso, sobrescribiendo el mecanismo predeterminado del Agent.
• Establece un límite de tasa en el número de trazas ingresadas por segundo. El límite de tasa predeterminado es de 100 trazas por segundo por instancia de servicio. Al utilizar el mecanismo predeterminado del Agent, se ignora el limitador de tasa.

Nota: Las reglas de muestreo también son controles de muestreo basados en la cabeza. Si el tráfico para un servicio es mayor que el máximo configurado de trazas por segundo, entonces las trazas se descartan en la raíz. No crea trazas incompletas.

La configuración se puede establecer mediante variables de entorno o directamente en el código:

# using system property
java -Ddd.trace.sampling.rules='[{"service": "my-service", "resource": "GET /checkout", "sample_rate":1},{"service": "my-service", "sample_rate":0.2}]' -javaagent:dd-java-agent.jar -jar my-app.jar

# using environment variables
export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "resource":"GET /checkout", "sample_rate": 1},{"service": "my-service", "sample_rate": 0.2}]'

export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "resource": "GET /checkout", "sample_rate": 1},{"service": "my-service", "sample_rate": 0.2}]'

export DD_TRACE_SAMPLE_RATE=0.1
export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "sample_rate": 0.5}]'

export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "resource": "GET /checkout", "sample_rate": 1},{"service": "my-service", "sample_rate": 0.2}]'

tracer.init({
    ingestion: {
        sampler: {
            sampleRate: 0.1,
            rules: [
                { sampleRate: 0.5, service: 'my-service' }
            ]
        }
    }
});

export DD_TRACE_SAMPLE_RATE=0.1
export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "resource":"GET /checkout", "sample_rate": 1},{"service": "my-service", "sample_rate": 0.2}]'

export DD_TRACE_SAMPLE_RATE=0.1
export DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "sample_rate": 0.5}]'

#using powershell
$env:DD_TRACE_SAMPLE_RATE=0.1
$env:DD_TRACE_SAMPLING_RULES='[{"service": "my-service", "sample_rate": 0.5}]'

#using JSON file   
{
    "DD_TRACE_SAMPLE_RATE": "0.1",
    "DD_TRACE_SAMPLING_RULES": "[{\"service\": \"my-service\", \"resource\": \"GET /checkout\", \"sample_rate\": 0.5}]"
}

Nota: Todos los tramos de una traza muestreada utilizando una configuración de SDK están etiquetados con la razón de ingestión rule. Los servicios configurados con reglas de muestreo definidas por el usuario están marcados como Configured en la columna de Configuración de la Ingestion Control Page.

Errores y trazas raras

Para las trazas que no son capturadas por el muestreo basado en el encabezado, dos mecanismos adicionales de muestreo del Agente de Datadog capturan trazas críticas y diversas que de otro modo serían descartadas. Estos muestreadores mantienen un conjunto diverso de trazas locales (tramos del mismo servidor) al capturar todas las combinaciones de un conjunto predeterminado de etiquetas:

• Trazas de error: El muestreo de errores proporciona visibilidad sobre posibles fallas del sistema.
• Trazas raras: El muestreo de trazas raras mantiene visibilidad sobre servicios y recursos de bajo tráfico en su sistema.

Nota: Los muestreadores de errores y raros son ignorados para los servicios para los cuales estableció reglas de muestreo de biblioteca.

Trazas de error

ingestion_reason: error

El muestreador de errores captura partes de trazas que contienen tramos de error no capturados por el muestreo basado en el encabezado, a una tasa de hasta 10 trazas por segundo por Agente. Esto ayuda a mantener visibilidad sobre errores cuando la tasa de muestreo basada en el encabezado es baja.

Con la versión 7.33 del Agente en adelante, puede configurar el muestreador de errores en el archivo de configuración principal del Agente (datadog.yaml) o con variables de entorno:

@param errors_per_second - integer - optional - default: 10
@env DD_APM_ERROR_TPS - integer - optional - default: 10

Notas:

1. Establezca el parámetro en 0 para deshabilitar el muestreador de errores.
2. El muestreador de errores captura trazas de error locales a nivel de agente. Si la traza es distribuida, la traza completa puede no ser enviada a Datadog.
3. Por defecto, los tramos eliminados por las reglas del SDK o lógica personalizada como manual.drop están excluidos bajo el muestreador de errores.

Datadog Agent 7.42.0 y superior

El muestreo de errores es configurable de forma remota si está utilizando la versión del agente 7.42.0 o superior. Siga la documentación para habilitar la configuración remota en sus Agentes. Con la configuración remota, puede habilitar la recolección de tramos raros sin reiniciar el Datadog Agent.

Datadog Agent 6/7.41.0 y superior

Para anular el comportamiento predeterminado de modo que los tramos descartados por las reglas del SDK o lógica personalizada, como manual.drop sean incluidos por el muestreador de errores, habilite la función con: DD_APM_FEATURES=error_rare_sample_tracer_drop en el Datadog Agent (o el contenedor dedicado del Trace Agent dentro del pod del Datadog Agent en Kubernetes).

Datadog Agent 6/7.33 a 6/7.40.x

El comportamiento predeterminado del muestreo de errores no se puede cambiar para estas versiones del Agente. Actualice el Datadog Agent a Datadog Agent 6/7.41.0 y superior.

Trazas raras

ingestion_reason: rare

El muestreador raro envía un conjunto de tramos raros a Datadog. Captura combinaciones de env, service, name, resource, error.type y http.status de hasta 5 trazas por segundo por agente. Esto ayuda a mantener la visibilidad en recursos de bajo tráfico cuando la tasa de muestreo basada en cabeza es baja.

Nota: El muestreador raro captura trazas locales a nivel de agente. Si la traza es distribuida, no hay garantía de que la traza completa se envíe a Datadog.

Datadog Agent 7.42.0 y superior

El muestreo raro es configurable de forma remota si está utilizando la versión del Agente 7.42.0 o superior. Siga la documentación para habilitar la configuración remota en sus Agentes. Con la configuración remota, puede cambiar el valor del parámetro sin reiniciar el Datadog Agent.

Datadog Agent 6/7.41.0 y superior

Por defecto, el muestreador raro está no habilitado.

Nota: Cuando está habilitado, los tramos descartados por las reglas del SDK o lógica personalizada como manual.drop son excluidos bajo este muestreador.

Para configurar el muestreador raro, actualice la apm_config.enable_rare_sampler configuración en el archivo de configuración principal del Agente (datadog.yaml) o con la variable de entorno DD_APM_ENABLE_RARE_SAMPLER:

@params apm_config.enable_rare_sampler - boolean - optional - default: false
@env DD_APM_ENABLE_RARE_SAMPLER - boolean - optional - default: false

Para evaluar los tramos descartados por las reglas del SDK o lógica personalizada como manual.drop, habilite la función con: DD_APM_FEATURES=error_rare_sample_tracer_drop en el Trace Agent.

Datadog Agent 6/7.33 a 6/7.40.x

Por defecto, el muestreador raro está habilitado.

Nota: Cuando está habilitado, los tramos descartados por las reglas del SDK o lógica personalizada como manual.drop son excluidos bajo este muestreador. Para incluir estos tramos en esta lógica, actualice a Datadog Agent 6.41.0/7.41.0 o superior.

Para cambiar la configuración predeterminada del muestreador raro, actualice la apm_config.disable_rare_sampler configuración en el archivo de configuración principal del Datadog Agent (datadog.yaml) o con la variable de entorno DD_APM_DISABLE_RARE_SAMPLER:

@params apm_config.disable_rare_sampler - boolean - optional - default: false
@env DD_APM_DISABLE_RARE_SAMPLER - boolean - optional - default: false

Forzar retención y descarte

ingestion_reason: manual

El mecanismo de muestreo basado en cabeza puede ser anulado a nivel de SDK. Por ejemplo, si necesita monitorear una transacción crítica, puede forzar que la traza asociada se mantenga. Por otro lado, para información innecesaria o repetitiva como las verificaciones de salud, puede forzar que la traza se descarte.

• Establecer Mantener Manualmente en un tramo para indicar que este y todos los tramos hijos deben ser ingeridos. La traza resultante puede parecer incompleta en la interfaz de usuario si el tramo en cuestión no es el tramo raíz de la traza.

• Establecer Descartar Manualmente en un tramo para asegurarse de que ningún tramo hijo sea ingerido. Los muestreadores de error y raro son ignorados en el Datadog Agent.

import datadog.trace.api.DDTags;
import io.opentracing.Span;
import datadog.trace.api.Trace;
import io.opentracing.util.GlobalTracer;

public class MyClass {
    @Trace
    public static void myMethod() {
        // grab the active span out of the traced method
        Span span = GlobalTracer.get().activeSpan();
        // Always keep the trace
        span.setTag(DDTags.MANUAL_KEEP, true);
        // method impl follows
    }
}

import datadog.trace.api.DDTags;
import io.opentracing.Span;
import datadog.trace.api.Trace;
import io.opentracing.util.GlobalTracer;

public class MyClass {
    @Trace
    public static void myMethod() {
        // grab the active span out of the traced method
        Span span = GlobalTracer.get().activeSpan();
        // Always Drop the trace
        span.setTag(DDTags.MANUAL_DROP, true);
        // method impl follows
    }
}

from ddtrace import tracer
from ddtrace.constants import MANUAL_DROP_KEY, MANUAL_KEEP_KEY

@tracer.wrap()
def handler():
    span = tracer.current_span()
    # Always Keep the Trace
    span.set_tag(MANUAL_KEEP_KEY)
    # method impl follows

from ddtrace import tracer
from ddtrace.constants import MANUAL_DROP_KEY, MANUAL_KEEP_KEY

@tracer.wrap()
def handler():
    span = tracer.current_span()
    # Always Drop the Trace
    span.set_tag(MANUAL_DROP_KEY)
    # method impl follows

Datadog::Tracing.trace(name, options) do |span, trace|
  trace.keep! # Affects the active trace
  # Method implementation follows
end

Datadog::Tracing.trace(name, options) do |span, trace|
  trace.reject! # Affects the active trace
  # Method implementation follows
end

package main

import (
    "log"
    "net/http"
    "github.com/DataDog/dd-trace-go/v2/ddtrace/ext" 
    "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
)

func handler(w http.ResponseWriter, r *http.Request) {
    // Create a span for a web request at the /posts URL.
    span := tracer.StartSpan("web.request", tracer.ResourceName("/posts"))
    defer span.Finish()

    // Always keep this trace:
    span.SetTag(ext.ManualKeep, true)
    //method impl follows

}

package main

import (
    "log"
    "net/http"

    "github.com/DataDog/dd-trace-go/v2/ddtrace/ext"
    "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
)

func handler(w http.ResponseWriter, r *http.Request) {
    // Create a span for a web request at the /posts URL.
    span := tracer.StartSpan("web.request", tracer.ResourceName("/posts"))
    defer span.Finish()

    // Always drop this trace:
    span.SetTag(ext.ManualDrop, true)
    //method impl follows
}

const tracer = require('dd-trace')
const tags = require('dd-trace/ext/tags')

const span = tracer.startSpan('web.request')

// Always keep the trace
span.setTag(tags.MANUAL_KEEP)
//method impl follows

const tracer = require('dd-trace')
const tags = require('dd-trace/ext/tags')

const span = tracer.startSpan('web.request')

// Always drop the trace
span.setTag(tags.MANUAL_DROP)
//method impl follows

using Datadog.Trace;

using(var scope = Tracer.Instance.StartActive("my-operation"))
{
    var span = scope.Span;

    // Always keep this trace
    span.SetTag(Datadog.Trace.Tags.ManualKeep, "true");
    //method impl follows
}

using Datadog.Trace;

using(var scope = Tracer.Instance.StartActive("my-operation"))
{
    var span = scope.Span;

    // Always drop this trace
    span.SetTag(Datadog.Trace.Tags.ManualDrop, "true");
    //method impl follows
}

<?php
  $tracer = \DDTrace\GlobalTracer::get();
  $span = $tracer->getActiveSpan();

  if (null !== $span) {
    // Always keep this trace
    $span->setTag(\DDTrace\Tag::MANUAL_KEEP, true);
  }
?>

<?php
  $tracer = \DDTrace\GlobalTracer::get();
  $span = $tracer->getActiveSpan();

  if (null !== $span) {
    // Always drop this trace
    $span->setTag(\DDTrace\Tag::MANUAL_DROP, true);
  }
?>

...
#include <datadog/tags.h>
#include <datadog/trace_segment.h>
#include <datadog/sampling_priority.h>
...

dd::SpanConfig span_cfg;
span_cfg.resource = "operation_name";

auto span = tracer.create_span(span_cfg);
// Always keep this trace
span.trace_segment().override_sampling_priority(int(dd::SamplingPriority::USER_KEEP));
//method impl follows

...
#include <datadog/tags.h>
#include <datadog/trace_segment.h>
#include <datadog/sampling_priority.h>
...

using namespace dd = datadog::tracing;

dd::SpanConfig span_cfg;
span_cfg.resource = "operation_name";

auto another_span = tracer.create_span(span_cfg);
// Always drop this trace
span.trace_segment().override_sampling_priority(int(dd::SamplingPriority::USER_DROP));
//method impl follows

Establecer Mantener Manualmente antes de la propagación del contexto. Si se establece después de la propagación del contexto, toda la traza puede no ser mantenida a través de los servicios. Debido a que esta decisión se establece en el cliente de trazado, la traza aún puede ser descartada por el Datadog Agent o el servidor según las reglas de muestreo.

Tramos individuales

ingestion_reason: single_span

Si necesita muestrear un tramo específico pero no necesita la traza completa, los SDK permiten establecer una tasa de muestreo para un solo tramo.

Por ejemplo, si está construyendo métricas a partir de tramos para monitorear servicios específicos, puede configurar reglas de muestreo de tramos para que estas métricas se basen en el 100% del tráfico de la aplicación, sin ingerir el 100% de las trazas para todas las solicitudes que fluyen a través del servicio.

Esta función está disponible para Datadog Agent v7.40.0+.

Nota: Las reglas de muestreo de tramos individuales no pueden ser utilizadas para descartar tramos que son mantenidos por muestreo basado en cabeza, solo para mantener tramos adicionales que son descartados por muestreo basado en cabeza.

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"resource": "POST /api/create_issue", "tags": { "priority":"high" }, "sample_rate":1.0}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

@env DD_SPAN_SAMPLING_RULES=[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]

#using powershell
$env:DD_SPAN_SAMPLING_RULES='[{"service": "my-service", "name": "http.request", "sample_rate":1.0, "max_per_second": 50}]'

#using JSON file   
{
    "DD_SPAN_SAMPLING_RULES": "[{\"service\": \"my-service\", \"name\": \"http.request\", \"sample_rate\": 1.0, \"max_per_second\": 50}]"
}

Tramos ingeridos del producto

Trazas de RUM

ingestion_reason:rum

Una solicitud de una aplicación web o móvil genera una traza cuando los servicios de backend están instrumentados. La integración de APM con Real User Monitoring vincula las solicitudes de aplicaciones web y móviles a sus trazas de backend correspondientes, para que puedas ver todos tus datos de frontend y backend a través de una sola lente.

A partir de la versión 4.30.0 del SDK del navegador RUM, puedes controlar los volúmenes ingeridos y mantener un muestreo de las trazas de backend configurando el parámetro de inicialización traceSampleRate. Establece traceSampleRate en un número entre 0 y 100. Si no se establece ningún valor traceSampleRate, se envía un 100% de las trazas provenientes de las solicitudes del navegador a Datadog por defecto.

También puedes controlar la tasa de muestreo de trazas en otros SDKs:

Trazas Synthetic

ingestion_reason:synthetics y ingestion_reason:synthetics-browser

Las pruebas de HTTP y navegador generan trazas cuando los servicios de backend están instrumentados. La integración de APM con Synthetic Testing vincula tus pruebas sintéticas con las trazas de backend correspondientes. Navega desde una ejecución de prueba que falló hasta la causa raíz del problema observando la traza generada por esa ejecución de prueba.

Por defecto, el 100% de las pruebas Synthetic de HTTP y de navegador generan trazas de backend.

Otros productos

Algunas razones adicionales de ingesta se atribuyen a los tramos que son generados por productos específicos de Datadog:

Mecanismos de ingesta en OpenTelemetry

ingestion_reason:otel

Dependiendo de tu configuración con los OpenTelemetry SDKs (usando el OpenTelemetry Collector o el Datadog Agent), tienes múltiples formas de controlar el muestreo de ingesta. Consulta Ingestion Sampling with OpenTelemetry para obtener detalles sobre las opciones disponibles para el muestreo a nivel del OpenTelemetry SDK, el OpenTelemetry Collector y el Datadog Agent en varias configuraciones de OpenTelemetry.

Lectura adicional

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

Controles de IngestiónDOCUMENTACIÓN Retención de TrazasDOCUMENTACIÓN Métricas de UsoDOCUMENTACIÓN Optimizando Datadog a gran escala: Observabilidad rentable en ZendeskBLOG Limitación de tasa APM y retenciónCENTRO DE APRENDIZAJE