Comment Thread-Safe est NLog?

Je n'ai pas vraiment de réponse à votre problème, mais j'ai quelques observations et quelques questions:

Selon votre code, il semble que vous souhaitiez créer un enregistreur par thread et que vous souhaitiez avoir ce journal dans un fichier nommé pour une valeur d'id transmise. Ainsi, l'enregistreur dont l'id est " abc " se connecterait à "x:\abc.log"," def " se connecterait à "x:\def.journal", et ainsi de suite. Je soupçonne que vous pouvez le faire via la configuration NLog plutôt que par programmation. Je ne sais pas si il serait mieux, ou si NLog aurait le même problème que vous rencontrez.

Ma première impression est que vous faites beaucoup de travail: créer une cible de fichier par thread, créer une nouvelle règle par thread, obtenir une nouvelle instance de logger, etc., que vous n'avez peut-être pas besoin de faire pour accomplir ce que vous voulez accomplir.

Je sais que NLog permet au fichier de sortie d'être nommé dynamiquement, basé sur au moins certains des LayoutRenderers NLog. Par exemple, je sais que ce travaux:

fileName="${level}.log"

Et vous donnera des noms de fichiers comme ceci:

Trace.log
Debug.log
Info.log
Warn.log
Error.log
Fatal.log

Ainsi, par exemple, il semble que vous puissiez utiliser un modèle comme celui-ci pour créer des fichiers de sortie basés sur l'id de thread:

fileName="${threadid}.log"

Et si vous finissiez par avoir des threads 101 et 102, alors vous auriez deux fichiers journaux: 101.journal et 102.journal.

Dans votre cas, vous voulez nommer le fichier en fonction de votre propre id. Vous pouvez stocker l'id dans le MappedDiagnosticContext (qui est un dictionnaire qui vous permet de stocker paires nom-valeur thread-local), puis référencez-le dans votre modèle.

Votre modèle pour votre nom de fichier ressemblerait à ceci:

fileName="${mdc:myid}.log"

Donc, dans votre code, vous pouvez faire ceci:

         public class ThreadManager
         {
           //Get one logger per type.
           private static readonly Logger logger = LogManager.GetCurrentClassLogger();

           protected override void OnDoWork(DoWorkEventArgs e)
           {
             // Set the desired id into the thread context
             NLog.MappedDiagnosticsContext.Set("myid", myRandomID);

             logger.Info("Hello from thread {0}, myid {1}", Thread.CurrentThread.ManagedThreadId, myRandomID);
             base.OnDoWork(e);  

             //Clear out the random id when the thread work is finished.
             NLog.MappedDiagnosticsContext.Remove("myid");
           }
         }

Quelque chose comme ça devrait permettre à votre classe ThreadManager d'avoir un seul enregistreur nommé "ThreadManager". Chaque fois qu'il enregistre un message, il enregistre la chaîne formatée dans L'appel Info. Si l'enregistreur est configuré pour se connecter à la cible du fichier (dans le fichier de configuration, créez une règle qui envoie "*.ThreadManager " à une cible de fichier dont la disposition du nom de fichier est quelque chose comme ceci:

fileName="${basedir}/${mdc:myid}.log"

Au moment où un message est enregistré, NLog déterminera quel devrait être le nom de fichier, en fonction de la valeur de la disposition du nom de fichier (c'est-à-dire qu'il applique les jetons de formatage au moment du journal). Si le fichier existe, le message y est écrit. Si le fichier n'existe pas encore, le fichier est créé et le message est enregistré à elle.

Si chaque thread a un id aléatoire comme " aaaaaaaaaaaa", "aaaaaaaaaaab"," aaaaaaaaaaac", alors vous devriez obtenir des fichiers journaux comme ceci:

aaaaaaaaaaaa.log
aaaaaaaaaaab.log
aaaaaaaaaaac.log

Et ainsi de suite.

Si vous pouvez le faire de cette façon, alors votre vie devrait être plus simple car vous n'avez pas à toute cette configuration programmatique de NLog (création de règles et de cibles de fichiers). Et vous pouvez laisser NLog s'inquiéter de la création des noms de fichiers de sortie.

Je ne sais pas pour sûr que cela fonctionnera mieux que ce que vous faisiez. Ou, même si c'est le cas, vous pourriez vraiment besoin de ce que vous êtes faire de votre image plus grande. Il devrait être assez facile de tester pour voir que cela fonctionne même (c'est-à-dire que vous pouvez nommer votre fichier de sortie en fonction d'une valeur dans le MappedDiagnosticContext). Si cela fonctionne pour que, vous pouvez l'essayer pour votre cas où vous créez des milliers de threads.

Mise à jour:

Voici un exemple de code:

Utilisation de ce programme:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using NLog;
using System.Threading;
using System.Threading.Tasks;

namespace NLogMultiFileTest
{
  class Program
  {
    public static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {

      int totalThreads = 50;
      TaskCreationOptions tco = TaskCreationOptions.None;
      Task task = null;

      logger.Info("Enter Main");

      Task[] allTasks = new Task[totalThreads];
      for (int i = 0; i < totalThreads; i++)
      {
        int ii = i;
        task = Task.Factory.StartNew(() =>
        {
          MDC.Set("id", "_" + ii.ToString() + "_");
          logger.Info("Enter delegate.  i = {0}", ii);
          logger.Info("Hello! from delegate.  i = {0}", ii);
          logger.Info("Exit delegate.  i = {0}", ii);
          MDC.Remove("id");
        });

        allTasks[i] = task;
      }

      logger.Info("Wait on tasks");

      Task.WaitAll(allTasks);

      logger.Info("Tasks finished");

      logger.Info("Exit Main");
    }
  }
}

Et ce NLog.fichier de configuration:

<?xml version="1.0" encoding="utf-8" ?>
<!-- 
  This file needs to be put in the application directory. Make sure to set 
  'Copy to Output Directory' option in Visual Studio.
  -->
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <targets>
        <target name="file" xsi:type="File" layout="${longdate} | ${processid} | ${threadid} | ${logger} | ${level} | id=${mdc:id} | ${message}" fileName="${basedir}/log_${mdc:item=id}.txt" />
    </targets>

    <rules>
        <logger name="*" minlevel="Debug" writeTo="file" />
    </rules>
</nlog>

Je suis en mesure d'obtenir un fichier journal pour chaque exécution de la délégué. Le fichier journal est nommé pour le " id " stocké dans le MDC (MappedDiagnosticContext).

Donc, quand j'exécute l'exemple de programme, j'obtiens 50 fichiers journaux, dont chacun a trois lignes "Enter...", "Bonjour...", "Sortie...". Chaque fichier est nommé log__X_.txt où X est la valeur du compteur capturé (ii), donc j'ai log_0.txt, log_1.txt, log_1.TXT, etc, log_49.txt. Chaque fichier journal contient uniquement les messages de journal relatifs à une exécution délégué.

Est-ce similaire à ce que vous voulez faire? Mon exemple de programme utilise des tâches plutôt que des threads parce que je l'avais déjà écrit il y a quelque temps. Je pense que la technique doit s'adapter à ce que vous faites assez facilement.

Vous pouvez également le faire de cette façon (obtenir un nouvel enregistreur pour chaque exécution du délégué), en utilisant le même NLog.fichier de configuration:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using NLog;
using System.Threading;
using System.Threading.Tasks;

namespace NLogMultiFileTest
{
  class Program
  {
    public static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {

      int totalThreads = 50;
      TaskCreationOptions tco = TaskCreationOptions.None;
      Task task = null;

      logger.Info("Enter Main");

      Task[] allTasks = new Task[totalThreads];
      for (int i = 0; i < totalThreads; i++)
      {
        int ii = i;
        task = Task.Factory.StartNew(() =>
        {
          Logger innerLogger = LogManager.GetLogger(ii.ToString());
          MDC.Set("id", "_" + ii.ToString() + "_");
          innerLogger.Info("Enter delegate.  i = {0}", ii);
          innerLogger.Info("Hello! from delegate.  i = {0}", ii);
          innerLogger.Info("Exit delegate.  i = {0}", ii);
          MDC.Remove("id");
        });

        allTasks[i] = task;
      }

      logger.Info("Wait on tasks");

      Task.WaitAll(allTasks);

      logger.Info("Tasks finished");

      logger.Info("Exit Main");
    }
  }
}