Photo par pxhere.com

Monitorer vos applications mobiles Xamarin avec NLog

NLog est l’un des meilleurs outils pour monitorer votre application avec des fichiers locaux. Découvrez comment!

Posted by Damien Aicheh on June 06, 2019 · 9 mins

Dans mon précédent tutoriel J’ai expliqué pourquoi il était important de monitorer votre application, voyons un exemple avec NLog.

Maintenant que nous savons pourquoi il est important d’avoir des logs au cours du cycle de développement de votre application, commençons par utiliser NLog et créons un service de log réutilisable dans toutes vos applications.

Installation rapide

Tout d’abord dans votre projet de plateforme, vous devez installer le paquetage NLog.Config et, si ce n’est pas fait, ajoutez automatiquement un fichier NLog.config en tant que EmbeddedResource dans votre application.

Configurer NLog.config

Ce fichier de configuration sera utilisé pour spécifier:

  • Où les logs doivent être sauvegardés sur votre disque mobile
  • Le format voulu pour les logs
  • Si vous souhaitez que vos journaux soient imprimés dans la console et / ou dans un fichier

Puisque chaque plateforme a un OS différent, les paths pour sauvegarder les fichiers de logs ne sont pas les mêmes.

Voici l’implémentation de NLog.config pour votre projet Xamarin.Android:

<?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"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true"
      throwExceptions="false"
      internalLogFile="c:\temp\nlog-internal.log">

  <targets>
    <target xsi:type="File" name="f" fileName="${specialfolder:folder=MyDocuments}/logs/${shortdate}.log" layout="${longdate} ${uppercase:${level}} ${message}" />
    <target xsi:type="Console" name="console" layout="${longdate} ${uppercase:${level}} ${message}" />
  </targets>

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

Et maintenant, l’implémentation pour le projet Xamarin.iOS :

<?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"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true" 
      throwExceptions="false">

  <targets>
    <target xsi:type="File" name="f" fileName="${specialfolder:folder=MyDocuments}/../Library/logs/${shortdate}.log" layout="${longdate} ${uppercase:${level}} ${message}" />
    <target xsi:type="Console" name="console" layout="${longdate} ${uppercase:${level}} ${message}" />
  </targets>

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

Charger le fichier de configuration

Chaque plateforme ayant un emplacement différent de NLog.config, nous devons donc le récupérer dans l’assembly pour chaque projet plateforme.

Ajoutez une nouvelle méthode nommée Bootstraping à votre MainActivity.cs et appelez-la dans le OnCreate pour Xamarin.Android, même chose pour Xamarin.iOS dans le AppDelegate.cs dans la méthode FinishedLaunching:

private void Bootstraping()
{
    var assembly = this.GetType().Assembly;
    var assemblyName = assembly.GetName().Name;
}

Maintenant que nous avons le chemin de l’assembly, nous pouvons créer une nouvelle classe appelée LogService dans notre projet de code partagé (projet .Net Standard par exemple). Nous devons y ajouter le package NLog pour créer un Logger. Le LogService initialisera notre logger et disposera de toutes les méthodes pour enregistrer toutes les données.

Voici la méthode d’initialisation de cette classe:

private Logger logger; 

public void Initialize(Assembly assembly, string assemblyName)
{
    var location = $"{assemblyName}.NLog.config";
    var stream = assembly.GetManifestResourceStream(location);
    LogManager.Configuration = new XmlLoggingConfiguration(XmlReader.Create(stream), null);
    this.logger = LogManager.GetCurrentClassLogger();
} 

Implémenter un service de log réutilisable

Le LogService

Nous avons préparé tout ce dont nous avions besoin pour pouvoir créer plusieurs méthodes pour enregistrer notre contenu, il est temps de le mettre en œuvre ! Voici la classe complète :

public class LogService : ILogService
{
    private Logger logger;

    public void Initialize(Assembly assembly, string assemblyName)
    {
        var location = $"{assemblyName}.NLog.config";
        var stream = assembly.GetManifestResourceStream(location);
        LogManager.Configuration = new XmlLoggingConfiguration(XmlReader.Create(stream), null);
        this.logger = LogManager.GetCurrentClassLogger();
    }

    public void LogDebug(string message)
    {
        this.logger.Info(message);
    }

    public void LogError(string message)
    {
        this.logger.Error(message);
    }

    public void LogFatal(string message)
    {
        this.logger.Fatal(message);
    }

    public void LogInfo(string message)
    {
        this.logger.Info(message);
    }

    public void LogWarning(string message)
    {
        this.logger.Warn(message);
    }
} 

J’ai appelé la méthode de base de l’objet logger seulement pour vous montrer un exemple simple, mais utile. N’hésitez pas à l’adapter selon vos besoins. Je vous recommande de créer l’interface associée pour que cette classe puisse utiliser l’injection de dépendance. L’idée sous-jacente à l’implémentation d’une interface est que, si vous devez remplacer NLog par un autre outil à l’avenir, ce sera plus simple, vous devrez simplement modifier le contenu des méthodes implémentés par le LogService.

Démarrer le logger

Retournez à votre méthode Bootstrapping dans chaque plateforme et démarrez le LogService:

new LogService().Initialize(assembly, assemblyName); 

Où puis-je voir mes fichiers de logs?

Vous voudrez probablement voir si tout est configuré correctement et vérifier ce que le logger écrit dans le fichier. Pour se faire, appelez cette ligne dans votre code partagé pour obtenir le chemin des données de l’application :

 System.Diagnostics.Debug.WriteLine($"App folder path :{Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)}");

Ensuite, pour votre simulateur iOS, ouvrez un terminal et accédez au chemin du dossier de l’application, les fichiers de logs se trouveront dans Library/logs, comme nous l’avons configuré dans le fichier NLog.config.

Sous Android, c’est un peu différent, avec votre émulateur ouvert, allez sur votre terminal et trouvez votre appareil en utilisant:

adb devices

Copiez l’id de l’émulateur dans la liste et ouvrez-lui un shell:

adb -s EMULATOR_ID_TO_REPLACE shell

Ensuite, accédez au dossier de l’application, les logs se trouveront à l’intérieur du dossier /logs/, comme indiqué dans le fichier NLog.config.

Pour récupérer facilement ces logs, un bon moyen serait une méthode qui récupère le fichier de log le plus récent et l’envoie par mail directement à partir de votre application.

Touche finale

J’ai créé un exemple simple et complet de ce code en utilisant l’injection de dépendance avec MvvmLightLibs pour vous montrer comment l’utiliser dans un projet, et comment il est facile de le réutiliser dans votre projet et améliorer votre application.

Vous trouverez un exemple de code sur ce répertoire Github.

Happy codding !

Vous avez aimé ce tutoriel ? Laissez une étoile sur le répertoire Github associé !

N'hésitez pas à me suivre sur pour ne pas rater mon prochain tutoriel !