Les services gèrent souvent des endpoints dont vous ne souhaitez peut-être pas tracer le trafic (par exemple, les vérifications de santé). Ce guide explique les approches suivantes pour exclure ce trafic :

• Échantillonnage : Utilisez lorsque vous souhaitez que les requêtes restent visibles dans les métriques de trace, mais réduisez le volume d’ingestion des traces.
• Filtrage dans l’Agent Datadog : Utilisez pour exclure complètement les requêtes (y compris des métriques de trace) dans tous les services rapportant à l’Agent.
• Configuration du traceur : Utilisez lorsque la logique de filtrage doit être appliquée par service ou dépend du contexte spécifique à l’application (par exemple, les attributs de requête ou l’état d’exécution).

Si vous avez besoin d’aide pour décider quelle option est la plus pertinente pour votre cas d’utilisation, contactez le support Datadog.

Échantillonnage

Si vous souhaitez que le span soit inclus dans les métriques de trace mais que vous ne voulez pas qu’il soit ingéré, utilisez des règles d’échantillonnage. Pour plus d’informations sur l’échantillonnage, consultez Contrôles d’ingestion.

Utilisation des règles d’échantillonnage

L’approche recommandée est d’utiliser des règles d’échantillonnage, qui vous permettent d’échantillonner les traces en fonction des noms de ressources, des noms de services, des balises et des noms d’opération :

DD_TRACE_SAMPLING_RULES='[{"resource": "GET healthcheck", "sample_rate": 0.0}]'

Ou d’échantillonner en fonction des balises d’URL HTTP :

DD_TRACE_SAMPLING_RULES='[{"tags": {"http.url": "http://.*/healthcheck$"}, "sample_rate": 0.0}]'

Filtrage dans l’Agent Datadog

Si vous ne souhaitez pas que le span soit ingéré ou reflété dans les métriques de trace, utilisez le filtrage dans l’Agent Datadog.

Le composant Trace Agent au sein de l’Agent Datadog dispose de deux méthodes pour empêcher l’envoi de certaines traces : filtrage par balises de span ou filtrage par ressources. Si des traces sont supprimées en raison de ces paramètres, les métriques de trace excluent ces requêtes.

Configurer l’Agent de Trace pour ignorer certaines traces ou ressources s’applique à tous les services qui envoient des traces à cet Agent Datadog. Si vous avez des exigences spécifiques à l’application, utilisez la configuration du Tracer à la place.

Ignorer les traces basées sur des balises de span

À partir de l’Agent Datadog 6.27.0/7.27.0, l’option balises de filtre supprime les traces avec des spans racines qui correspondent aux balises de span spécifiées. Cette option s’applique à tous les services qui envoient des traces à cet Agent Datadog. Les traces qui sont supprimées en raison des balises de filtre ne sont pas incluses dans les métriques de trace.

Comportement de correspondance :

L’option des balises de filtre nécessite une correspondance exacte de chaîne. Pour le filtrage basé sur des regex, voir Ignorer en fonction des ressources.

Lorsque vous spécifiez plusieurs balises, le filtre utilise la logique OU: les traces sont supprimées si le span racine correspond à l’une des balises. Pour faire correspondre plusieurs conditions simultanément, ajoutez une balise personnalisée qui représente ces critères combinés.

Configuration :

Vous pouvez spécifier des balises de span à exiger ou à rejeter en utilisant une liste de clés et de valeurs séparées par des espaces dans les variables d’environnement :

DD_APM_FILTER_TAGS_REQUIRE

Collecte uniquement les traces qui ont des spans racines avec une correspondance exacte pour les balises de span et les valeurs spécifiées. Si cela ne correspond pas à cette règle, la trace est supprimée. Par exemple, DD_APM_FILTER_TAGS_REQUIRE="key1:value1 key2:value2". Dans l’Agent Datadog 7.49+, des expressions régulières peuvent être fournies avec DD_APM_FILTER_TAGS_REGEX_REQUIRE.

DD_APM_FILTER_TAGS_REJECT Rejette les traces qui ont des spans racines avec une correspondance exacte pour les balises de span et valeurs spécifiées. Si cela correspond à cette règle, la trace est supprimée. Par exemple, DD_APM_FILTER_TAGS_REJECT="key1:value1 key2:value2". Dans Datadog Agent 7.49+, des expressions régulières peuvent être fournies avec DD_APM_FILTER_TAGS_REGEX_REJECT.

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  override:
    nodeAgent:
      containers:
        trace-agent:
          env:
            - name: DD_APM_FILTER_TAGS_REJECT
              value: tag_key1:tag_val2 tag_key2:tag_val2

kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml

agents:
  containers:
    traceAgent:
      env:
        - name: DD_APM_FILTER_TAGS_REJECT
          value: tag_key1:tag_val2 tag_key2:tag_val2

helm upgrade -f datadog-values.yaml <RELEASE NAME> datadog/datadog

apm_config:
  filter_tags:
    require: ["db:sql", "db.instance:mysql"]
    reject: ["outcome:success", "key2:value2"]

apm_config:
  filter_tags:
    reject: ["http.url:http://localhost:5050/healthcheck"]

Balises de span disponibles

Sur le backend, Datadog crée les balises de span suivantes sur les spans après ingestion.

Remarque : Ces balises ne peuvent pas être utilisées pour supprimer des traces au niveau de l’Agent Datadog. L’agent filtre uniquement en fonction des balises disponibles avant l’ingestion.

Communications réseau

Requêtes HTTP

Base de données

File d’attente de messages

Appels de procédure à distance

Erreurs

Ignorer les traces basées sur les ressources

L’option ignore resources permet d’exclure les ressources si le span racine global de la trace correspond à certains critères. Voir Exclure les ressources de la collecte. Cette option s’applique à tous les services qui envoient des traces à cet Agent Datadog particulier. Les traces qui sont ignorées en raison des ressources à ignorer ne sont pas incluses dans les métriques de trace.

Vous pouvez spécifier les ressources à ignorer soit dans le fichier de configuration de l’Agent, datadog.yaml, soit avec la variable d’environnement DD_APM_IGNORE_RESOURCES. Voir les exemples ci-dessous.

Utilisation de datadog.yaml :

apm_config:
## @param ignore_resources - list of strings - optional
## A list of regular expressions can be provided to exclude certain traces based on their resource name.
## All entries must be surrounded by double quotes and separated by commas.

  ignore_resources: ["(GET|POST) /healthcheck","API::NotesController#index"]

Utilisation de DD_APM_IGNORE_RESOURCES :

DD_APM_IGNORE_RESOURCES="(GET|POST) /healthcheck,API::NotesController#index"

Notes :

• Lors de l’utilisation du format de variable d’environnement (DD_APM_IGNORE_RESOURCES), les valeurs doivent être fournies sous forme de liste de chaînes séparées par des virgules.
• La syntaxe regex que l’Agent de Trace accepte est évaluée par regexp de Go.
• Selon votre stratégie de déploiement, vous devrez peut-être ajuster la regex en échappant les caractères spéciaux.
• Si vous utilisez des conteneurs dédiés avec Kubernetes, assurez-vous que la variable d’environnement pour l’option de ressource à ignorer est appliquée au conteneur trace-agent.

Exemple

Considérez une trace qui contient des appels à /api/healthcheck dont vous ne souhaitez pas avoir de traces :

Notez le nom de ressource de la span racine globale.

• Nom de l’opération : rack.request
• Nom de la ressource : Api::HealthchecksController#index
• Http.url : /api/healthcheck

Pour utiliser correctement l’option de ressource à ignorer, la règle regex écrite doit correspondre au nom de la ressource, Api::HealthchecksController#index. Quelques options regex sont possibles, mais pour filtrer exactement les traces de cette ressource telles qu’elles sont, une regex potentielle à utiliser est Api::HealthchecksController#index$.

La syntaxe peut varier en fonction de votre déploiement 

apm_config:
  ignore_resources: Api::HealthchecksController#index$

apm_config:
  ignore_resources: ["value1","Api::HealthchecksController#index$"]

    environment:
      // other Datadog Agent environment variables
      - DD_APM_IGNORE_RESOURCES=Api::HealthchecksController#index$$

    environment:
      // other Datadog Agent environment variables
      - DD_APM_IGNORE_RESOURCES="value1","Api::HealthchecksController#index$$"

docker run -d --name datadog-agent \
              --cgroupns host \
              --pid host \
              -v /var/run/docker.sock:/var/run/docker.sock:ro \
              -v /proc/:/host/proc/:ro \
              -v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \
              -e DD_API_KEY=<> \
              -e DD_APM_IGNORE_RESOURCES="Api::HealthchecksController#index$" \
              -e DD_APM_ENABLED=true \
              -e DD_APM_NON_LOCAL_TRAFFIC=true \
              registry.datadoghq.com/agent:latest

              -e DD_APM_IGNORE_RESOURCES=["value1","Api::HealthchecksController#index$"] \

    - name: trace-agent
        image: "registry.datadoghq.com/agent:latest"
        imagePullPolicy: IfNotPresent
        command: ["trace-agent", "-config=/etc/datadog-agent/datadog.yaml"]
        resources: {}
        ports:
        - containerPort: 8126
          hostPort: 8126
          name: traceport
          protocol: TCP
        env:
        - name: DD_API_KEY
          valueFrom:
            secretKeyRef:
              name: "datadog-secret"
              key: api-key
        - name: DD_KUBERNETES_KUBELET_HOST
          valueFrom:
            fieldRef:
              fieldPath: status.hostIP
        - name: KUBERNETES
          value: "yes"
        - name: DOCKER_HOST
          value: unix:///host/var/run/docker.sock
        - name: DD_LOG_LEVEL
          value: "INFO"
        - name: DD_APM_ENABLED
          value: "true"
        - name: DD_APM_NON_LOCAL_TRAFFIC
          value: "true"
        - name: DD_APM_RECEIVER_PORT
          value: "8126"
        - name: DD_KUBELET_TLS_VERIFY
          value: "false"
        - name: DD_APM_IGNORE_RESOURCES
          value: "Api::HealthchecksController#index$"

        - name: DD_APM_IGNORE_RESOURCES
          value: '"value1","Api::HealthchecksController#index$"'

    traceAgent:
      # agents.containers.traceAgent.env -- Additional environment variables for the trace-agent container
      env:
        - name: DD_APM_IGNORE_RESOURCES
          value: Api::HealthchecksController#index$

        - name: DD_APM_IGNORE_RESOURCES
          value: value1, Api::HealthchecksController#index$

helm install dd-agent -f values.yaml \
  --set datadog.apiKeyExistingSecret="datadog-secret" \
  --set agents.containers.traceAgent.env[0].name=DD_APM_IGNORE_RESOURCES, \
    agents.containers.traceAgent.env[0].value="Api::HealthchecksController#index$" \
  datadog/datadog

    "environment": [
	// other environment variables for the Datadog Agent
        {
          "name": "DD_APM_IGNORE_RESOURCES",
          "value": "Api::HealthchecksController#index$"
        }
     ]

Configuration du traceur

Certains traceurs de langage peuvent supprimer des traces avant qu’elles ne soient envoyées à l’Agent Datadog. Utilisez cette option si vous avez des exigences spécifiques à l’application.

Datadog::Tracing.before_flush(
   Datadog::Tracing::Pipeline::SpanFilter.new { |span| span.resource =~ /Api::HealthchecksController#index/ }
)

from ddtrace.trace import tracer
from ddtrace.trace import TraceFilter
import re

class CustomFilter(TraceFilter):
    def __init__(self, pattern):
        self.pattern = re.compile(pattern)

    def process_trace(self, trace):
        for span in trace:
            if span.get_tag('http.url') and self.pattern.match(span.get_tag('http.url')):
                return None  # Drop the trace
        return trace  # Keep the trace

# Configure the SDK with your custom filter
tracer.configure(trace_processors=[CustomFilter(r'http://.*/healthcheck$')])

const tracer = require('dd-trace').init();
tracer.use('http', {
  // incoming http requests match on the path
  server: {
    blocklist: ['/healthcheck']
  },
  // outgoing http requests match on a full URL
  client: {
    blocklist: ['https://telemetry.example.org/api/v1/record']
  }
})

//import http

public class GreetingController {
   static {
       // In a class static block to avoid initializing multiple times.
       GlobalTracer.get().addTraceInterceptor(new TraceInterceptor() {
           @Override
           public Collection<? extends MutableSpan> onTraceComplete(Collection<? extends MutableSpan> trace) {
               for (MutableSpan span : trace) {
                   if ("GET /healthcheck".contentEquals(span.getResourceName())) {
                       return Collections.emptyList();
                   }
               }
               return trace;
           }
           @Override
           public int priority() {
               return 200;  // Some unique number
           }
       });
   }
}