Logging with NLog in Xamarin Forms

This post is a quick demo of how to add logging to a Xamarin Forms application using the NLog library. The complete source code is available here.

NLog is a popular logging library for .net and it’s compatible for Xamarin so it’s a natural choice if you want to add logging to your Xamarin app. It isn’t PCL compatible though, so you do need an implementation for each platform. This isn’t a major problem, and you might want to set the logger up differently for each platform anyway.

Let’s dive into the code…

using System;
namespace LoggingDemo
{
    public interface ILogger
    {
        void Trace(string text, params object[] args);
        void Debug(string text, params object[] args);
        void Info(string text, params object[] args);
        void Warn(string text, params object[] args);
        void Error(string text, params object[] args);
        void Fatal(string text, params object[] args);
    }
}

using System;
using System.Diagnostics.Contracts;
namespace LoggingDemo
{
    public interface ILogManager
    {
        ILogger GetLog([System.Runtime.CompilerServices.CallerFilePath]string callerFilePath = "");
    }
}

In the cross platform project we define a couple of interfaces, ILogManager and ILogger. ILogManager is responsible for creating instances of the ILogger class. ILogger contains the logging message.

In this demo the code for the IOS and Android implementations of the interfaces is pretty much the same. Let’s look at the IOS version…

using NLog;
using NLog.Config;
using NLog.Targets;
using Foundation;
using LoggingDemo.iOS;
using Xamarin.Forms;

[assembly: Dependency(typeof(NLogManager))]
namespace LoggingDemo.iOS
{
    public class NLogManager : ILogManager
    {
        public NLogManager()
        {
            var config = new LoggingConfiguration();

            var consoleTarget = new ConsoleTarget();
            config.AddTarget("console", consoleTarget);

            var consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget);
            config.LoggingRules.Add(consoleRule);

            var fileTarget = new FileTarget();
            string folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            fileTarget.FileName = Path.Combine(folder, "Log.txt");
            config.AddTarget("file", fileTarget);

            var fileRule = new LoggingRule("*", LogLevel.Warn, fileTarget);
            config.LoggingRules.Add(fileRule);

            LogManager.Configuration = config;
        }

        public ILogger GetLog([System.Runtime.CompilerServices.CallerFilePath] string callerFilePath = "")
        {
            string fileName = callerFilePath;

            if (fileName.Contains("/"))
            {
                fileName = fileName.Substring(fileName.LastIndexOf("/", StringComparison.CurrentCultureIgnoreCase) + 1);
            }

            var logger = LogManager.GetLogger(fileName);
            return new NLogLogger(logger);  
        }
    }
}

The NLogManager configures the logging in its constructor. Here we are logging all log entries to the console and logs of warning or above into a file called log.txt. The GetLog function returns an instance of a logger. It uses the CallerFilePath attribute to set the name of the log entries.

using System;
using System.Diagnostics.Contracts;
namespace LoggingDemo
{
    public interface ILogManager
    {
        ILogger GetLog([System.Runtime.CompilerServices.CallerFilePath]string callerFilePath = "");
    }
}

The implementation of ILogger is really simple. It just gives us a bunch of functions to log messages of various levels.

In both of these classes we use the Dependency attribute so that the shared project knows about it.

Now let’s look at using the loggers. The demo app has one screen with buttons which create log entries.

using System;
using System.Collections.Generic;

using Xamarin.Forms;

namespace LoggingDemo
{
    public partial class MainPage : ContentPage
    {
        private static ILogger logger = DependencyService.Get<ILogManager>().GetLog();

        public MainPage()
        {
            InitializeComponent();
        }

        private void Trace_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Trace Clicked");
        }

        private void Debug_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Debug Clicked");
        }

        private void Info_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Info Clicked");
        }

        private void Warn_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Warn Clicked");
        }

        private void Error_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Error Clicked");
        }

        private void Fatal_Clicked(Object sender, EventArgs args)
        {
            logger.Trace("Fatal Clicked");
        }
    }
}

We set the logger up as a static variable of the class. Also, the dependency service will create one global static interface of the log manager (this is default behaviour and is easy to forget).

And just to prove it works, here are some log messages appearing in the console…