Using NLog.net in SOA with ILogReceiverServer

• Download demo (no EXE) - 139.7 KB
• Download demo - 1.1 MB

Introduction

We have implemented NLog.net in our service oriented architecture. It can log different levels exception/message to your selected data storage.

Background

There are many articles about how to implement NLog.net but there is not a good article about how to implement ILogReceiverServer interface inside a SOA system. The tip will show you how to do that.

This demo has 7 parts.

1. The external DLL which is NLog.dll, you can get it from Nuget and put in a solution folder to share it between different projects.
2. Data storage, we will focus on using a SqlServer database as our log data storage.

   Here is the script to create the table:

   SQL

   SET ANSI_PADDING ON
   GO
   
   CREATE TABLE [dbo].[EventLogs](
       [ID] [bigint] IDENTITY(1,1) NOT NULL,
       [ActivityID] [varchar](20) NOT NULL,
       [Source] [varchar](100) NOT NULL,
       [SubSource] [varchar](150) NOT NULL,
       [DateTimeStamp] [datetime] NOT NULL,
       [LogLevel] [varchar](20) NOT NULL,
       [MachineName] [varchar](50) NOT NULL,
       [WindowsID] [varchar](50) NOT NULL,
       [StackTrace] [varchar](max) NOT NULL,
       [Logger] [varchar](100) NOT NULL,
       [Exception] [varchar](max) NOT NULL,
       [LogMessage] [varchar](max) NOT NULL,
    CONSTRAINT [PK_EventLogs] PRIMARY KEY CLUSTERED 
   (
       [ID] ASC
   )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
   ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
   
   GO
   
   SET ANSI_PADDING OFF

3. DataAccess layer

   We use the following code to insert logs.

   It will take NLog's LogEventInfo as parameter and parse out the properties to insert.

   C#

   public void InsertLog(LogEventInfo ev)
   {
     try
               {
                   using (SqlConnection connection = new SqlConnection(DBConn))
                   {
                       SqlCommand command = new SqlCommand(CommandText, connection);
   
                       foreach (DBParameter p in DBParameters)
                       {
                           command.Parameters.AddWithValue(p.Name, ev.Properties[p.Layout]);
                       }
   
                       try
                       {
                           connection.Open();
                           Int32 rowsAffected = command.ExecuteNonQuery();
                           Console.WriteLine("RowsAffected: {0}", rowsAffected);
                       }
                       catch (Exception ex)
                       {
                           logger.Error(ex);
                       }
                   }
               }
               catch (Exception ex)
               {
                   logger.Error(ex);
               }
           }

   We will build the DBParameters by reading the NLog.config file.

   C#

   protected List<DBParameter> DBParameters { get; set; }
   
           public void ReadNLogConfigure()
           {
               try
               {
                   string myString = "";
   
                   using (System.IO.StreamReader myFile = new System.IO.StreamReader(AppDomain.CurrentDomain.BaseDirectory + "NLog.config"))
                   {
                       myString = myFile.ReadToEnd();
                   }
                   myString = myString.Replace("xmlns=\"http://www.nlog-project.org/schemas/NLog.xsd\"", "");
                   myString = myString.Replace("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"", "");
                   myString = myString.Replace("xsi:", "");
   
                   XmlDocument xDoc = new XmlDocument();
                   xDoc.LoadXml(myString);
   
                   //XmlNamespaceManager nsmgr = new XmlNamespaceManager(xDoc.NameTable);
                   //nsmgr.AddNamespace(string.Empty, "http://www.nlog-project.org/schemas/NLog.xsd");
                   //nsmgr.AddNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
   
                   XmlNode xn = xDoc.SelectSingleNode("//target[@type=\"Database\"]");//,nsmgr);
   
                   DBParameters = new List<DBParameter>();
                   if (xn != null)
                   {
                       DBConn = xn.Attributes["connectionString"].Value;
                       CommandText = xn.Attributes["commandText"].Value;
   
                       foreach (XmlNode xp in xn.SelectNodes("parameter"))
                       {
                           DBParameter dp = new DBParameter();
                           dp.Name = xp.Attributes["name"].Value;
                           //dp.Layout = xp.Attributes["layout"].Value.Replace("${", "").Replace("}", "");
                           dp.Layout = xp.Attributes["name"].Value.Replace("@", "");
                           DBParameters.Add(dp);
                       }
                   }
               }
               catch (Exception ex)
               {
                   logger.Error(ex);
               }
           }

4. NLogService WCF service.

   We have two services.

   LogReceiverServer: This will accept the log request from client.

   C#

   public class LogReceiverServer : ILogReceiverServer
       {
   
           public void ProcessLogMessages(NLogEvents nevents)
           {
               var events = nevents.ToEventInfo("Client.");
               Console.WriteLine("in: {0} {1}", nevents.Events.Length, events.Count);
   
               LogDataBaseAccess logToDB = new LogDataBaseAccess();
   
               foreach (var ev in events)
               {
                   var logger = LogManager.GetLogger(ev.LoggerName);
   
                   //logger.Log(ev);
                   logToDB.InsertLog(ev);
               }
           }
       }

   NLogConfigService: This will let you config log level from server to client.

   C#

   public class NLogConfigService : INLogConfigService
       {
           public string GetLogLevel(string userID)
           {
               if (userID == "Grant")
                   return "Error";
               else
                   return "Trace";
           }
       }

   So we can control which level we want the client to be.

5. NLogReceiverServiceHost

   This is the WCF host for our service by a Windows Form application.

   C#

   private void F_Main_Load(object sender, EventArgs e)
           {
               try
               {
                   StringBuilder sb = new StringBuilder();
                   //host the service here
                   ServiceHost host = new ServiceHost(typeof(NLogService.LogReceiverServer));
                   host.Open();
                   sb.Append("LogReceiverServer is running"+Environment.NewLine);
   
                   host = new ServiceHost(typeof(NLogService.NLogConfigService));
                   host.Open();
                   sb.Append("NLogConfigService is running" + Environment.NewLine);
   
                   lbServiceStatus.Text = sb.ToString();
               }
               catch (Exception ex)
               {
                   MessageBox.Show(ex.Message);
               }
           }

6. NLogDemo

   This is the client side Windows Form application.

   C#

   private void cmdLogAll_Click(object sender, EventArgs e)
           {
               logger.Trace("This is a Trace message");
               logger.Debug("This is a Debug message");
               logger.Info("This is an Info message");
   
               logger.Warn("This is a Warn message");
               logger.Error("This is an Error message");
               logger.Fatal("This is a Fatal error message");
           }
   
           private void cmdLogException_Click(object sender, EventArgs e)
           {
               try
               {
                   int i = 10;
                   int j = 0;
                   int k = i / j;
               }
               catch (Exception ex)
               {
                   logger.ErrorException("This is an Error message", ex);
               }
           }

7. Utility

   This module provides a function to let you reconfig client's log level.

   C#

   public static void Reconfigure(LogLevel logLevel)
       {
           foreach (var rule in LogManager.Configuration.LoggingRules)
           {
               rule.DisableLoggingForLevel(LogLevel.Trace);
               rule.DisableLoggingForLevel(LogLevel.Debug);
               rule.DisableLoggingForLevel(LogLevel.Info);
               rule.DisableLoggingForLevel(LogLevel.Warn);
               rule.DisableLoggingForLevel(LogLevel.Error);
               rule.DisableLoggingForLevel(LogLevel.Fatal);
   
               EnableHigherLevel(rule, logLevel);
           }
   
           //Call to update existing Loggers created with GetLogger() or
           //GetCurrentClassLogger()
           LogManager.ReconfigExistingLoggers();
       }
   
       public static void EnableHigherLevel(LoggingRule rule, LogLevel logLevel)
       {
           //Trace - Very detailed log messages, potentially of a high frequency and volume
           //Debug -Less detailed and/or less frequent debugging messages
           //Info - Informational messages
           //Warn - Warnings which don't appear to the user of the application
           //Error - Error messages
           //Fatal - Fatal error messages. After a fatal error, the application usually terminates.
   
           switch (logLevel.ToString())
           {
               case "Trace":
                   rule.EnableLoggingForLevel(LogLevel.Trace);
                   rule.EnableLoggingForLevel(LogLevel.Debug);
                   rule.EnableLoggingForLevel(LogLevel.Info);
                   rule.EnableLoggingForLevel(LogLevel.Warn);
                   rule.EnableLoggingForLevel(LogLevel.Error);
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
   
                   break;
               case "Debug":
                   rule.EnableLoggingForLevel(LogLevel.Debug);
                   rule.EnableLoggingForLevel(LogLevel.Info);
                   rule.EnableLoggingForLevel(LogLevel.Warn);
                   rule.EnableLoggingForLevel(LogLevel.Error);
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
   
                   break;
               case "Info":
                   rule.EnableLoggingForLevel(LogLevel.Info);
                   rule.EnableLoggingForLevel(LogLevel.Warn);
                   rule.EnableLoggingForLevel(LogLevel.Error);
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
   
                   break;
               case "Warn":
                   rule.EnableLoggingForLevel(LogLevel.Warn);
                   rule.EnableLoggingForLevel(LogLevel.Error);
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
   
                   break;
               case "Error":
                   rule.EnableLoggingForLevel(LogLevel.Error);
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
   
                   break;
               case "Fatal":
                   rule.EnableLoggingForLevel(LogLevel.Fatal);
                   break;
               default:
                   break;
           }
       }
   

Points of Interest

Use NLog in SOA system.