Après avoir configuré la collecte de logs, vous pouvez personnaliser la configuration de votre collection :

• Filtrer les journaux
  • Exclure en cas de correspondance
  • Inclure en cas de correspondance
  • Exclure les journaux tronqués
• Masquer les données sensibles de vos journaux
• Agrégation multi-lignes
• Agrégation automatique des journaux multi-lignes
• Règles de traitement des journaux couramment utilisées
• Suivre les répertoires en utilisant des jokers
  • Prioriser les fichiers suivis par date de modification
• Encodages des fichiers journaux
• Règles de traitement globales
• Lectures complémentaires

Pour appliquer une règle de traitement à tous les journaux collectés par un agent Datadog, voir la section Règles de traitement globales.

Notes :

• Si vous configurez plusieurs règles de traitement, elles sont appliquées séquentiellement et chaque règle est appliquée sur le résultat de la précédente.
• Les motifs de règles de traitement doivent être conformes à la syntaxe regexp de Golang.
• Le paramètre log_processing_rules est utilisé dans les configurations d’intégration pour personnaliser votre configuration de collecte de journaux. Lors de la configuration principale de l’Agent, le paramètre processing_rules est utilisé pour définir des règles de traitement globales.

Filtrer les journaux

Pour envoyer uniquement un sous-ensemble spécifique de journaux à Datadog, utilisez le paramètre log_processing_rules dans votre fichier de configuration avec le type exclude_at_match ou include_at_match.

Exclure en cas de correspondance

Par exemple, pour filtrer les journaux contenant une adresse e-mail Datadog, utilisez le log_processing_rules suivant :

logs:
  - type: file
    path: /my/test/file.log
    service: cardpayment
    source: java
    log_processing_rules:
    - type: exclude_at_match
      name: exclude_datadoghq_users
      ## Regexp can be anything
      pattern: \[email protected]

 labels:
    com.datadoghq.ad.logs: >-
      [{
        "source": "java",
        "service": "cardpayment",
        "log_processing_rules": [{
          "type": "exclude_at_match",
          "name": "exclude_datadoghq_users",
          "pattern" : "\\[email protected]"
        }]
      }]

apiVersion: apps/v1
metadata:
  name: cardpayment
spec:
  selector:
    matchLabels:
      app: cardpayment
  template:
    metadata:
      annotations:
        ad.datadoghq.com/<CONTAINER_NAME>.logs: >-
          [{
            "source": "java",
            "service": "cardpayment",
            "log_processing_rules": [{
              "type": "exclude_at_match",
              "name": "exclude_datadoghq_users",
              "pattern" : "\\[email protected]"
            }]
          }]
      labels:
        app: cardpayment
      name: cardpayment
    spec:
      containers:
        - name: '<CONTAINER_NAME>'
          image: cardpayment:latest

Inclure en cas de correspondance

Par exemple, utilisez la log_processing_rules configuration suivante pour filtrer les journaux contenant une adresse e-mail Datadog :

logs:
  - type: file
    path: /my/test/file.log
    service: cardpayment
    source: java
    log_processing_rules:
    - type: include_at_match
      name: include_datadoghq_users
      ## Regexp can be anything
      pattern: \[email protected]

logs:
  - type: file
    path: /my/test/file.log
    service: cardpayment
    source: java
    log_processing_rules:
    - type: include_at_match
      name: include_datadoghq_users
      pattern: abc|123

logs:
  - type: file
    path: /my/test/file.log
    service: cardpayment
    source: java
    log_processing_rules:
    - type: include_at_match
      name: include_datadoghq_users
      pattern: "abc\
|123\
|\\[email protected]"

 labels:
    com.datadoghq.ad.logs: >-
      [{
        "source": "java",
        "service": "cardpayment",
        "log_processing_rules": [{
          "type": "include_at_match",
          "name": "include_datadoghq_users",
          "pattern" : "\\[email protected]"
        }]
      }]

apiVersion: apps/v1
metadata:
  name: cardpayment
spec:
  selector:
    matchLabels:
      app: cardpayment
  template:
    metadata:
      annotations:
        ad.datadoghq.com/<CONTAINER_NAME>.logs: >-
          [{
            "source": "java",
            "service": "cardpayment",
            "log_processing_rules": [{
              "type": "include_at_match",
              "name": "include_datadoghq_users",
              "pattern" : "\\[email protected]"
            }]
          }]
      labels:
        app: cardpayment
      name: cardpayment
    spec:
      containers:
        - name: '<CONTAINER_NAME>'
          image: cardpayment:latest

Exclure les journaux tronqués

Par exemple, pour filtrer les journaux tronqués :

logs:
  - type: file
    path: /my/test/file.log
    service: cardpayment
    source: java
    log_processing_rules:
    - type: exclude_truncated

 labels:
    com.datadoghq.ad.logs: >-
      [{
        "source": "java",
        "service": "cardpayment",
        "log_processing_rules": [{
          "type": "exclude_truncated"
        }]
      }]

apiVersion: apps/v1
metadata:
  name: cardpayment
spec:
  selector:
    matchLabels:
      app: cardpayment
  template:
    metadata:
      annotations:
        ad.datadoghq.com/<CONTAINER_NAME>.logs: >-
          [{
            "source": "java",
            "service": "cardpayment",
            "log_processing_rules": [{
              "type": "exclude_truncated"
            }]
          }]
      labels:
        app: cardpayment
      name: cardpayment
    spec:
      containers:
        - name: '<CONTAINER_NAME>'
          image: cardpayment:latest

Masquer les données sensibles de vos journaux

Si vos journaux contiennent des informations sensibles à masquer, configurez l’Agent Datadog pour masquer les séquences sensibles en utilisant le paramètre log_processing_rules dans votre fichier de configuration avec le type mask_sequences.

Cela remplace tous les groupes correspondants par la valeur du paramètre replace_placeholder.

Par exemple, pour effacer un numéro de carte bancaire :

logs:
 - type: file
   path: /my/test/file.log
   service: cardpayment
   source: java
   log_processing_rules:
      - type: mask_sequences
        name: mask_credit_cards
        replace_placeholder: "[masked_credit_card]"
        ##One pattern that contains capture groups
        pattern: (?:4[0-9]{12}(?:[0-9]{3})?|[25][1-7][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})

 labels:
    com.datadoghq.ad.logs: >-
      [{
        "source": "java",
        "service": "cardpayment",
        "log_processing_rules": [{
          "type": "mask_sequences",
          "name": "mask_credit_cards",
          "replace_placeholder": "[masked_credit_card]",
          "pattern" : "(?:4[0-9]{12}(?:[0-9]{3})?|[25][1-7][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})"
        }]
      }]

apiVersion: apps/v1
metadata:
  name: cardpayment
spec:
  selector:
    matchLabels:
      app: cardpayment
  template:
    metadata:
      annotations:
        ad.datadoghq.com/<CONTAINER_NAME>.logs: >-
          [{
            "source": "java",
            "service": "cardpayment",
            "log_processing_rules": [{
              "type": "mask_sequences",
              "name": "mask_credit_cards",
              "replace_placeholder": "[masked_credit_card]",
              "pattern" : "(?:4[0-9]{12}(?:[0-9]{3})?|[25][1-7][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})"
            }]
          }]
      labels:
        app: cardpayment
      name: cardpayment
    spec:
      containers:
        - name: '<CONTAINER_NAME>'
          image: cardpayment:latest

Avec la version 7.17+ de l’Agent, la chaîne replace_placeholder peut étendre les références aux groupes de capture tels que $1, $2 et ainsi de suite. Si vous souhaitez qu’une chaîne suive le groupe de capture sans espace entre les deux, utilisez le format ${<GROUP_NUMBER>}.

Par exemple, pour masquer les informations utilisateur du journal User email: [email protected], utilisez :

• pattern: "(User email: )[^@]*@(.*)"
• replace_placeholder: "$1 masked_user@${2}"

Cela envoie le journal suivant à Datadog : User email: [email protected]

Agrégation automatique des journaux multi-lignes

La détection automatique des journaux multi-lignes est utile lorsque vous avez de nombreuses sources de journaux avec des formats complexes ou lorsque vous n’avez pas le temps de configurer chaque source individuellement. Cette fonctionnalité détecte et agrège automatiquement les journaux multi-lignes sans nécessiter que vous écriviez des motifs regex personnalisés.

Consultez la documentation Auto Multi-line Detection and Aggregation (en anglais).

Pour la prise en charge héritée de cette fonctionnalité, consultez la documentation Automatic Multi-line Detection and Aggregation (Legacy) (en anglais).

Agrégation manuelle des journaux multi-lignes

Les règles manuelles multi-lignes vous donnent un contrôle précis sur l’agrégation des journaux lorsque vous connaissez vos formats de journaux. Cette approche est idéale pour garantir un traitement cohérent des journaux avec des motifs regex personnalisés adaptés à votre structure de journaux spécifique.

Si vos journaux ne sont pas envoyés en JSON et que vous souhaitez agréger plusieurs lignes en une seule entrée, configurez l’Agent Datadog pour détecter un nouveau journal à l’aide d’un motif regex spécifique au lieu d’avoir un journal par ligne. Utilisez le type multi_line dans le paramètre log_processing_rules pour agréger toutes les lignes en une seule entrée jusqu’à ce que le motif donné soit détecté à nouveau.

Par exemple, chaque ligne de journal Java commence par un horodatage au format yyyy-dd-mm. Ces lignes incluent une trace de pile qui peut être envoyée sous forme de deux journaux :

2018-01-03T09:24:24.983Z UTC Exception in thread "main" java.lang.NullPointerException
        at com.example.myproject.Book.getTitle(Book.java:16)
        at com.example.myproject.Author.getBookTitles(Author.java:25)
        at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
2018-01-03T09:26:24.365Z UTC starting upload of /my/file.gz

logs:
 - type: file
   path: /var/log/pg_log.log
   service: database
   source: postgresql
   log_processing_rules:
      - type: multi_line
        name: new_log_start_with_date
        pattern: \d{4}\-(0?[1-9]|1[012])\-(0?[1-9]|[12][0-9]|3[01])

 labels:
    com.datadoghq.ad.logs: >-
      [{
        "source": "postgresql",
        "service": "database",
        "log_processing_rules": [{
          "type": "multi_line",
          "name": "log_start_with_date",
          "pattern" : "\\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])"
        }]
      }]

apiVersion: apps/v1
metadata:
  name: postgres
spec:
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      annotations:
        ad.datadoghq.com/<CONTAINER_NAME>.logs: >-
          [{
            "source": "postgresql",
            "service": "database",
            "log_processing_rules": [{
              "type": "multi_line",
              "name": "log_start_with_date",
              "pattern" : "\\d{4}-(0?[1-9]|1[012])-(0?[1-9]|[12][0-9]|3[01])"
            }]
          }]
      labels:
        app: database
      name: postgres
    spec:
      containers:
        - name: '<CONTAINER_NAME>'
          image: postgres:latest

Exemples supplémentaires :

Règles de traitement des journaux couramment utilisées

Consultez la section FAQ sur les règles de traitement des logs couramment utilisées pour obtenir une liste d’exemples.

Suivre les répertoires en utilisant des caractères génériques

Si vos fichiers journaux sont étiquetés par date ou tous stockés dans le même répertoire, configurez votre Agent Datadog pour les surveiller tous et détecter automatiquement les nouveaux en utilisant des caractères génériques dans l’attribut path. Si vous souhaitez exclure certains fichiers correspondant au path choisi, listez-les dans l’attribut exclude_paths.

• Utilisation de path: /var/log/myapp/*.log :

  • Correspond à tous les fichiers .log contenus dans le répertoire /var/log/myapp/.
  • Ne correspond pas à /var/log/myapp/myapp.conf.

• Utilisation de path: /var/log/myapp/*/*.log :

  • Correspond à /var/log/myapp/log/myfile.log.
  • Correspond à /var/log/myapp/errorLog/myerrorfile.log
  • Ne correspond pas à /var/log/myapp/mylogfile.log.

Exemple de configuration pour Linux :

logs:
  - type: file
    path: /var/log/myapp/log/*.log
    exclude_paths:
      - /var/log/myapp/log/debug.log
      - /var/log/myapp/log/trace.log
    service: mywebapp
    source: go

L’exemple ci-dessus correspond à /var/log/myapp/log/myfile.log et exclut /var/log/myapp/log/debug.log et /var/log/myapp/log/trace.log.

Exemple de configuration pour Windows :

logs:
  - type: file
    path: C:\\MyApp\\*.log
    exclude_paths:
      - C:\\MyApp\\MyLog.*.log
    service: mywebapp
    source: csharp

L’exemple ci-dessus correspond à C:\\MyApp\\MyLog.log et exclut C:\\MyApp\\MyLog.20230101.log et C:\\MyApp\\MyLog.20230102.log.

Remarque :

• L’Agent nécessite des autorisations de lecture et d’exécution sur un répertoire pour lister tous les fichiers disponibles dans celui-ci.
• Les valeurs de path et exclude_paths sont sensibles à la casse.

Prioriser les fichiers suivis par date de modification

Cette fonctionnalité nécessite la version 7.40.0 ou une version ultérieure de l’Agent.

L’Agent limite le nombre de fichiers qu’il peut suivre simultanément avec le paramètre logs_config.open_files_limit. Si le nombre de fichiers correspondant à vos sources de journaux configurées (comme les caractères génériques) est dans la limite, l’Agent suit tous ces fichiers. Si plus de fichiers correspondent à la limite autorisée, l’Agent priorise en triant les noms de fichiers dans l’ordre lexicographique inverse, de sorte que les fichiers avec des horodatages plus récents ou des numéros plus élevés soient suivis en premier.

Si les noms de fichiers ne suivent pas des modèles séquentiels ou horodatés, l’ordre par défaut peut ne pas être idéal. Pour prioriser par date de modification à la place, définissez logs_config.file_wildcard_selection_mode sur by_modification_time. Avec ce paramètre, l’Agent suit en premier les fichiers les plus récemment modifiés.

Exemple :

• open_files_limit = 500
• Votre motif générique correspond à 700 fichiers.
• Avec by_name : l’Agent suit les 500 fichiers dont les noms sont les plus élevés dans l’ordre lexicographique inverse (par exemple, app.log.700 à app.log.201).
• Avec by_modification_time : l’Agent suit les 500 fichiers les plus récemment écrits, indépendamment de leurs noms.

logs_enabled: true
logs_config:
 [...]
  open_files_limit: 500

  ## @param file_wildcard_selection_mode - string - optional - default: by_name
  ## The strategy used to prioritize wildcard matches if they exceed open_files_limit.
  ## Choices:
  ##   - by_name: files are sorted in reverse lexicographic order (default).
  ##   - by_modification_time: files are sorted by modification time, with the most recent first.
  ## WARNING: by_modification_time is less performant and increases disk I/O.
  file_wildcard_selection_mode: by_modification_time

Pour restaurer le comportement par défaut, retirez l’entrée logs_config.file_wildcard_selection_mode ou définissez-la explicitement sur by_name.

Encodages des fichiers journaux

Par défaut, l’Agent Datadog suppose que les journaux utilisent l’encodage UTF-8. Si vos journaux d’application utilisent un encodage différent, spécifiez le paramètre encoding dans le paramètre de configuration des journaux.

La liste ci-dessous donne les valeurs d’encodage prises en charge. Si vous fournissez une valeur non prise en charge, l’Agent ignore la valeur et lit le fichier en tant qu’UTF-8.

• utf-16-le - UTF-16 little-endian (Agent Datadog v6.23/v7.23)
• utf-16-be - UTF-16 big-endian (Agent Datadog v6.23/v7.23)
• shift-jis - Shift-JIS (Agent Datadog v6.34/v7.34)

Exemple de configuration :

logs:
  - type: file
    path: /test/log/hello-world.log
    tags: key:value
    service: utf-16-logs
    source: mysql
    encoding: utf-16-be

Remarque : Le paramètre encoding n’est applicable que lorsque le paramètre type est défini sur file.

Règles de traitement globales

Pour l’Agent Datadog v6.10+, les règles de traitement exclude_at_match, include_at_match et mask_sequences peuvent être définies globalement dans le fichier de configuration principal de l’Agent ou via une variable d’environnement. La règle exclude_truncated est disponible à partir de l’Agent v7.69.

logs_config:
  processing_rules:
    - type: exclude_at_match
      name: exclude_healthcheck
      pattern: healthcheck
    - type: mask_sequences
      name: mask_user_email
      pattern: \[email protected]
      replace_placeholder: "MASKED_EMAIL"

DD_LOGS_CONFIG_PROCESSING_RULES='[{"type": "mask_sequences", "name": "mask_user_email", "replace_placeholder": "MASKED_EMAIL", "pattern" : "\\[email protected]"}]'

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  override:
    nodeAgent:
      env:
        - name: DD_LOGS_CONFIG_PROCESSING_RULES
          value: '[{"type": "mask_sequences", "name": "mask_user_email", "replace_placeholder": "MASKED_EMAIL", "pattern" : "\\[email protected]"}]'

datadog:
  env:
    - name: DD_LOGS_CONFIG_PROCESSING_RULES
      value: '[{"type": "mask_sequences", "name": "mask_user_email", "replace_placeholder": "MASKED_EMAIL", "pattern" : "\\[email protected]"}]'

Remarque : L’Agent Datadog ne démarre pas le collecteur de journaux s’il y a un problème de format dans les règles de traitement globales. Exécutez la sous-commande d’état de l’Agent pour résoudre tout problème.

FAQ sur l’agrégation de journaux multi-lignes

1. Quand devrais-je utiliser des règles multi-lignes manuelles plutôt que la détection automatique des multi-lignes ?

Si vous connaissez le format de vos journaux, vous devriez utiliser des règles multi-lignes manuelles pour un contrôle précis. Si vous envoyez beaucoup de journaux multi-lignes, et que vous n’êtes pas sûr de leur format ou que vous n’avez pas les moyens de configurer toutes les sources individuellement, vous devriez utiliser la détection automatique des multi-lignes.

2. Que se passe-t-il lorsqu’un motif multi-lignes ne correspond à aucun journal ?

Toutes les lignes de journal non-JSON sont traitées individuellement comme des entrées de journal séparées. Toutes les lignes de journal au format JSON sont traitées comme une seule ligne, et seul le premier format JSON valide est pris en compte ; les autres sont rejetées.

3. Que se passe-t-il lorsqu’il y a à la fois des règles globales et des règles spécifiques à l’intégration ? Les règles spécifiques à l’intégration remplacent complètement les règles globales pour l’intégration particulière.

Lectures complémentaires

Documentation, liens et articles supplémentaires utiles:

Commencer avec Logging without Limits™DOCUMENTATION Utiliser l'Agent Datadog pour la collecte de logs uniquementDOCUMENTATION Découvrir comment traiter vos logsDOCUMENTATION En savoir plus sur le parsingDOCUMENTATION Fonctionnalité Live Tail de DatadogDOCUMENTATION Découvrir comment explorer vos logsDOCUMENTATION Entrée du glossaire pour le terme « tail » (suivi)GLOSSAIRE