Pour transmettre vos logs C# à Datadog, utilisez l’une des méthodes suivantes :

• Enregistrez dans un fichier puis suivez ce fichier avec votre Agent Datadog
• Activez la journalisation sans agent.
• Utilisez le sink Serilog.

Journalisation par file-tail avec l’Agent Datadog

L’approche recommandée pour la collecte de journaux C# consiste à consigner vos journaux dans un fichier, puis à suivre ce fichier avec votre Agent Datadog. Cela permet à l’Agent Datadog d’enrichir les journaux avec des métadonnées supplémentaires.

Datadog vous recommande fortement de configurer votre bibliothèque de journalisation de façon à générer vos logs au format JSON. Vous n’aurez ainsi pas besoin de créer de règles de parsing personnalisées.

La journalisation par file-tail prend en charge les frameworks suivants :

• Serilog
• NLog
• log4net

Configurez votre logger

PM> Install-Package Serilog.Sinks.File

// Instantiate the logger
var log = new LoggerConfiguration()  // using Serilog;

    // using Serilog.Formatting.Json;
    .WriteTo.File(new JsonFormatter(renderMessage: true), "log.json")

    // using Serilog.Formatting.Compact;
    // .WriteTo.File(new RenderedCompactJsonFormatter(), "log.json")

    .CreateLogger();

// An example
var position = new { Latitude = 25, Longitude = 134 };
var elapsedMs = 34;

log.Information("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs);

{
  "MessageTemplate": "Processed {@Position} in {Elapsed:000} ms.",
  "Level": "Information",
  "Timestamp": "2016-09-02T15:02:29.648Z",
  "Renderings": {"Elapsed": [{"Format": "000", "Rendering": "034"}]},
  "RenderedMessage":"Processed { Latitude: 25, Longitude: 134 } in 034 ms.",
  "Properties": {"Position": {"Latitude": 25, "Longitude": 134}, "Elapsed": 34}
}

{
  "@t": "2020-05-20T04:15:28.6898801Z",
  "@m": "Processed { Latitude: 25, Longitude: 134 } in 034 ms.",
  "@i": "d1eb2146",
  "Position": {"Latitude": 25, "Longitude": 134 },
  "Elapsed": 34
}

PM> Install-Package NLog

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!--
  See https://github.com/nlog/nlog/wiki/Configuration-file
  for information on customizing logging rules and outputs.
   -->
  <targets async="true">
    <!-- Write logs as Json into a file -->
    <target name="json-file" xsi:type="File" fileName="application-logs.json">
      <layout xsi:type="JsonLayout">
        <attribute name="date" layout="${date:universalTime=true:format=o}" />
        <attribute name="level" layout="${level:upperCase=true}"/>
        <attribute name="message" layout="${message}" />
        <attribute name="exception" layout="${exception:format=ToString}" />
      </layout>
    </target>

  </targets>
  <rules>
    <!-- Log all events to the json-file target -->
    <logger name="*" writeTo="json-file" minlevel="Trace" />
  </rules>
</nlog>

using NLog;

namespace Datadog
{
    class Program
    {
        // Initialize a logger
        private static Logger logger = LogManager.GetCurrentClassLogger();

        static void Main(string[] args)
        {
            // Log a simple debug message
            logger.Debug("This is my first step");

            // your code continues here ...
        }
    }
}

PM> Install-Package log4net
PM> Install-Package log4net.Ext.Json

<?xml version="1.0" encoding="utf-8"?>
<configuration>

  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
  </configSections>

  <log4net>
    <root>
      <level value="DEBUG" />
      <appender-ref ref="JsonFileAppender" />
    </root>
    <appender name="JsonFileAppender" type="log4net.Appender.FileAppender">
      <threshold value="DEBUG"/>
      <file value="application-logs.json" />
      <encoding type="System.Text.UTF8Encoding" />
      <appendToFile value="true" />
      <layout type="log4net.Layout.SerializedLayout, log4net.Ext.Json">
        <decorator type="log4net.Layout.Decorators.StandardTypesDecorator, log4net.Ext.Json" />
        <default />
        <!--explicit default members-->
        <remove value="ndc" />
        <remove value="message" />
        <!--remove the default preformatted message member-->
        <member value="message:messageobject" />
        <!--add raw message-->
      </layout>
    </appender>
  </log4net>

  <!-- The rest of your configuration starts here ... -->

using log4net;

namespace Datadog
{
    class Program
    {
        // Get the current class logger
        private static ILog logger = LogManager.GetLogger(typeof(Program));

        static void Main(string[] args)
        {

           // Load the configure fom App.config
           XmlConfigurator.Configure();

           // Log a simple debug message
           logger.Debug("This is my first debug message");

           // your code continues here ...
        }
    }
}

{
  "level": "DEBUG",
  "message": "This is my debug message",
  "date": "2016-05-24 15:53:35.7175",
  "appname": "Datadog.vshost.exe",
  "logger": "Datadog.Program",
  "thread": "10"
}

<param name="ConversionPattern" value="%date{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread] %logger %method:%line - %message%n" />

Configurer l’Agent Datadog

Une fois la collecte de logs activée, configurez la collecte de logs personnalisée pour suivre vos fichiers de logs et les transmettre à Datadog.

1. Créez un dossier csharp.d/ dans le conf.d/ répertoire de configuration de l’Agent.

2. Créez un fichier conf.yaml dans csharp.d/ avec le contenu suivant :

   init_config:
   
   instances:
   
   ##Log section
   logs:
   
     - type: file
       path: "<path_to_your_csharp_log>.log"
       service: <service_name>
       source: csharp
       sourcecategory: sourcecode
       # For multiline logs, if they start by the date with the format yyyy-mm-dd uncomment the following processing rule
       #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])
   

3. Assurez-vous que l’utilisateur de l’Agent a des permissions de lecture sur le fichier journal.

4. Redémarrez l’Agent.

5. Exécutez la sous-commande d’état de l’Agent et recherchez csharp sous la section Checks pour confirmer que les journaux sont soumis avec succès à Datadog.

Si les journaux sont au format JSON, Datadog analyse automatiquement les messages de journal pour extraire les attributs des journaux. Utilisez le Log Explorer pour visualiser et dépanner vos journaux.

Connectez votre service à travers les journaux et les traces

Si APM est activé pour cette application, connectez vos journaux et traces en ajoutant automatiquement des identifiants de trace, des identifiants de span, env, service et version à vos journaux en suivant les instructions APM .NET

**Remarque ** : Si le SDK Datadog injecte service dans vos journaux, cela remplace la valeur définie dans la configuration de l’Agent.

Journalisation sans agent avec APM

Il est possible de diffuser des journaux de votre application vers Datadog directement, sans apporter de modifications au code, en utilisant la bibliothèque d’instrumentation automatique APM .NET. Cette approche envoie les journaux directement à Datadog, donc elle ne bénéficie pas des fonctionnalités telles que le nettoyage des données sensibles qui sont fournies par l’agent Datadog. Pour cette raison, nous recommandons d’utiliser la journalisation par file tail lorsque cela est possible, mais elle est utile dans les environnements où cela n’est pas possible (lors de l’utilisation de Azure App Service par exemple). Il convient de noter que vous pourrez toujours compter sur les capacités de nettoyage côté serveur effectuées par Sensitive Data Scanner.

Le logging sans Agent (ou « transmission directe des logs ») est compatible avec les frameworks suivants :

• Serilog (v1.0+)
• NLog (v2.1+)
• log4net (v1.0+)
• Microsoft.Extensions.Logging (2.0+)

Aucune modification du code de votre application n’est requise, et vous n’aurez pas non plus à installer des dépendances supplémentaires pour votre application.

Configurer le SDK Datadog

La journalisation sans agent n’est disponible que lors de l’utilisation d’APM avec instrumentation automatique. Pour commencer, instrumentez votre application comme décrit dans les documents suivants :

• applications .NET Core/.NET 5+
• applications .NET Framework

Une fois l’installation effectuée, vérifiez que vous recevez correctement les traces.

Activer la journalisation sans agent

Pour activer le logging sans Agent, définissez les variables d’environnement suivantes :

DD_API_KEY

Votre clé API Datadog pour envoyer vos journaux à Datadog.

DD_SITE

Le nom de votre site Datadog. Choisissez parmi l’un des exemples suivants :
Exemple: datadoghq.com (US1), datadoghq.eu (UE), us3.datadoghq.com (US3), us5.datadoghq.com (US5), ap1.datadoghq.com (AP1), ap2.datadoghq.com (AP2), ddog-gov.com (US1-FED), us2.ddog-gov.com (US2-FED)
Par défaut: datadoghq.com (US1)

DD_LOGS_INJECTION

Active la connexion des journaux et des traces 9 :
Par défaut : true
Activé par défaut à partir de la version 3.24.0 de Tracer.

DD_LOGS_DIRECT_SUBMISSION_INTEGRATIONS

Active la journalisation sans agent. Activez cette option pour votre cadre de journalisation en la définissant sur Serilog, NLog, Log4Net ou ILogger (pour Microsoft.Extensions.Logging). Si vous utilisez plusieurs cadres de journalisation, utilisez une liste de variables séparées par des points-virgules.
Exemple : Serilog;Log4Net;NLog

Redémarrez votre application après avoir défini ces variables d’environnement.

Configuration supplémentaire

Vous pouvez configurer plus en détail certains aspects de la collecte de logs sans Agent à l’aide des variables d’environnement suivantes :

DD_LOGS_DIRECT_SUBMISSION_MINIMUM_LEVEL

Permet de filtrer les journaux par niveau avant qu’ils ne soient envoyés à Datadog. Définissez sur l’une des valeurs suivantes: Verbose, Debug, Information, Warning, Error, Critical. Ceci correspond aux niveaux équivalents dans les cadres de journalisation pris en charge.
Par défaut: Information

DD_LOGS_DIRECT_SUBMISSION_HOST

Définissez le nom de la machine hôte associé aux journaux. Si non fourni, le nom de l’hôte sera recherché automatiquement.
Par défaut : Déterminé automatiquement

DD_LOGS_DIRECT_SUBMISSION_TAGS

Si spécifié, ajoute tous les tags spécifiés à tous les spans générés. Si non fourni, utilisera DD_TAGS à la place.
Exemple : layer:api, team:intake Notez que le délimiteur est une virgule et un espace : , .

Les variables de configuration suivantes ne doivent généralement pas être modifiées, mais vous pouvez les définir si vous le souhaitez.

DD_LOGS_DIRECT_SUBMISSION_URL

Définit l’URL où les journaux doivent être soumis. Utilise le domaine fourni dans DD_SITE par défaut.
Par défaut : :443 (based on DD_SITE)

DD_LOGS_DIRECT_SUBMISSION_SOURCE

Définit la règle d’analyse pour les journaux soumis. Doit toujours être défini sur csharp, sauf si vous avez un pipeline personnalisé.
Par défaut: csharp

DD_LOGS_DIRECT_SUBMISSION_MAX_BATCH_SIZE

Définit le nombre maximum de journaux à envoyer à la fois. Prend en compte les limites en place pour l’API.
Par défaut: 1000

DD_LOGS_DIRECT_SUBMISSION_MAX_QUEUE_SIZE

Définit le nombre maximum de journaux à conserver dans la file d’attente interne à tout moment avant de supprimer les messages de journal.
Par défaut : 100000

DD_LOGS_DIRECT_SUBMISSION_BATCH_PERIOD_SECONDS

Définit le temps d’attente (en secondes) avant de vérifier les nouveaux journaux à envoyer.
Par défaut : 1

Si vous utilisez l’Microsoft.Extensions.Logging intégration, vous pouvez filtrer les journaux envoyés à Datadog en utilisant les capacités standard intégrées dans ILogger. Utilisez la clé "Datadog" pour identifier le fournisseur de soumission directe et définissez les niveaux de journal minimum pour chaque espace de noms. Par exemple, ajouter ce qui suit à votre appSettings.json empêcherait l’envoi de tout journal avec un niveau inférieur à Warning à Datadog. Introduit dans le SDK .NET v2.20.0.

{
  "Logging": {
    "Datadog": {
      "LogLevel": {
        "Microsoft.AspNetCore": "Warning"
      },
    }
  }
}

Journalisation sans agent avec le sink Serilog

S’il n’est pas possible d’utiliser la journalisation par file-tail ou la journalisation sans agent APM, et que vous utilisez le Serilogframework, vous pouvez alors utiliser le Datadog Serilog sink pour envoyer des journaux directement à Datadog.

Installez le Datadog Serilog sink dans votre application, qui envoie des événements et des journaux à Datadog. Par défaut, le sink transfère les journaux via HTTPS sur le port 443. Exécutez la commande suivante dans la console du gestionnaire de paquets :

PM> Install-Package Serilog.Sinks.Datadog.Logs

Ensuite, initialisez le logger directement dans votre application. Assurez-vous d’ajouter votre <API_KEY>.

using (var log = new LoggerConfiguration()
    .WriteTo.DatadogLogs("<API_KEY>", configuration: new DatadogConfiguration(){ Url = "" })
    .CreateLogger())
{
    // Some code
}

Désormais, les nouveaux logs sont directement envoyés à Datadog.

Lectures complémentaires

Documentation, liens et articles supplémentaires utiles:

Comment recueillir, personnaliser et analyser des logs C#BLOG Associer vos logs .NET à vos tracesDOCUMENTATION Apprendre à traiter vos logsDOCUMENTATION En savoir plus sur le parsingDOCUMENTATION Apprendre à explorer vos logsDOCUMENTATION Effectuer des analyses de logsDOCUMENTATION Guide de dépannage pour la collecte de logsFAQ Entrée du glossaire pour le terme « tail » (suivi)GLOSSAIRE Paquet Serilog.Sinks.Datadog.LogsPAQUET GITHUB