Wired up the fallback loggers through the dispatcher and into the config.

Author: ivanpointer

Take2/NuLog.Tests/Unit/Configuration/XmlConfigurationProviderTests/XmlConfigProviderTests.cs

@@ -172,5 +172,21 @@ public void Should_ReadIncludeStackFrameFlag()
             // Validate
             Assert.True(config.IncludeStackFrame);
         }
+
+        /// <summary>
+        /// The config provider should read the fallback log path.
+        /// </summary>
+        [Fact(DisplayName = "Should_ReadFallbackLogPath")]
+        public void Should_ReadFallbackLogPath()
+        {
+            // Setup
+            var provider = GetConfigurationProvider("<nulog fallbackLog=\"fallbacklog.txt\"></nulog>");
+
+            // Execute
+            var config = provider.GetConfiguration();
+
+            // Validate
+            Assert.Equal("fallbacklog.txt", config.FallbackLogPath);
+        }
     }
 }

Take2/NuLog.Tests/Unit/Dispatchers/StandardDispatcherTests.cs

@@ -233,16 +233,6 @@ public void Should_FallbackLoggingNow()
                 .MustHaveHappened();
         }
 
-        /// <summary>
-        /// The dispatcher should write the fallback message to trace, if no fallback logger is set
-        /// on the dispatcher.
-        /// </summary>
-        [Fact(DisplayName = "Should_FallbackToTraceIfNoFallbackSetLater", Skip = "Not implemented yet.")]
-        public void Should_FallbackToTraceIfNoFallbackSetLater()
-        {
-            throw new NotImplementedException();
-        }
-
         /// <summary>
         /// Setup a fake target.
         /// </summary>
@@ -266,7 +256,7 @@ protected static ITagRouter FakeTagRouter()
         /// </summary>
         protected static IDispatcher GetDispatcher(IEnumerable<ITarget> targets, ITagRouter tagRouter, IFallbackLogger fallbackLogger = null)
         {
-            return new StandardDispatcher(targets, tagRouter, fallbackLogger);
+            return new StandardDispatcher(targets, tagRouter, fallbackLogger ?? A.Fake<IFallbackLogger>());
         }
     }
 

Take2/NuLog.Tests/Unit/Factories/StandardLoggerFactoryUnitTests.cs

@@ -3,6 +3,7 @@
 Source on GitHub: https://github.com/ivanpointer/NuLog */
 
 using NuLog.Configuration;
+using NuLog.FallbackLoggers;
 using NuLog.Targets;
 using System.Collections.Generic;
 using System.Linq;
@@ -392,5 +393,42 @@ public void Should_SetStackFrameFlagOnLogger()
             // Verify
             Assert.True(logger.IncludeStackFrame);
         }
+
+        /// <summary>
+        /// The factory should build a trace fallback logger when a fallback log (file path) isn't configured.
+        /// </summary>
+        [Fact(DisplayName = "Should_BuildTraceFallbackLoggerDefault")]
+        public void Should_BuildTraceFallbackLoggerDefault()
+        {
+            // Setup
+            var factory = GetLogFactory(new Config());
+
+            // Execute
+            var fallbackLogger = factory.GetFallbackLogger();
+
+            // Verify
+            Assert.NotNull(fallbackLogger);
+            Assert.True(typeof(StandardTraceFallbackLogger).IsAssignableFrom(fallbackLogger.GetType()));
+        }
+
+        /// <summary>
+        /// When a fallback path is configured, the factory should build the file fallback logger.
+        /// </summary>
+        [Fact(DisplayName = "Should_BuildFileFallbackLoggerWhenConfigured")]
+        public void Should_BuildFileFallbackLoggerWhenConfigured()
+        {
+            // Setup
+            var factory = GetLogFactory(new Config
+            {
+                FallbackLogPath = "fallbacklog.txt"
+            });
+
+            // Execute
+            var fallbackLogger = factory.GetFallbackLogger();
+
+            // Verify
+            Assert.NotNull(fallbackLogger);
+            Assert.True(typeof(StandardFileFallbackLogger).IsAssignableFrom(fallbackLogger.GetType()));
+        }
     }
 }

Take2/NuLog.Tests/Unit/FallbackLoggers/StandardFallbackLoggerBaseTests.cs

@@ -184,6 +184,72 @@ public void Should_IncludeLogEventExceptionMessage()
             Assert.Contains("LogEvent Exception: \"Log Event Exception Message!\"", text);
         }
 
+        /// <summary>
+        /// The fallback logger should write the current date/time stamp at the start of the log message.
+        /// </summary>
+        [Fact(DisplayName = "Should_SimpleMessageStartWithDateTimeStamp")]
+        public void Should_SimpleMessageStartWithDateTimeStamp()
+        {
+            // Setup
+            var fallbackLogger = GetFallbackLogger();
+            var target = A.Fake<ITarget>();
+
+            // Execute
+            fallbackLogger.Log("Simple message!");
+
+            // Verify
+            var text = fallbackLogger.LoggedMessages.Single();
+            var pattern = new Regex(@"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} | .*$");
+            var now = DateTime.Now;
+            var midDateText = now.ToString("yyyy-MM-dd hh:mm");
+            var maxDateText = now.AddSeconds(1).ToString("yyyy-MM-dd hh:mm");
+
+            Assert.True(pattern.IsMatch(text), "Text loaded from file doesn't match regular expression for starting with a date time string.");
+            Assert.True(text.StartsWith(midDateText) || text.StartsWith(maxDateText), "Text loaded from file doesn't appear to be prefixed with the current time.");
+        }
+
+        /// <summary>
+        /// The fallback logger should write the current date/time stamp at the start of the log message.
+        /// </summary>
+        [Fact(DisplayName = "Should_FormattedMessageStartWithDateTimeStamp")]
+        public void Should_FormattedMessageStartWithDateTimeStamp()
+        {
+            // Setup
+            var fallbackLogger = GetFallbackLogger();
+            var target = A.Fake<ITarget>();
+
+            // Execute
+            fallbackLogger.Log("Formatted {0}!", "message");
+
+            // Verify
+            var text = fallbackLogger.LoggedMessages.Single();
+            var pattern = new Regex(@"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} | .*$");
+            var now = DateTime.Now;
+            var midDateText = now.ToString("yyyy-MM-dd hh:mm");
+            var maxDateText = now.AddSeconds(1).ToString("yyyy-MM-dd hh:mm");
+
+            Assert.True(pattern.IsMatch(text), "Text loaded from file doesn't match regular expression for starting with a date time string.");
+            Assert.True(text.StartsWith(midDateText) || text.StartsWith(maxDateText), "Text loaded from file doesn't appear to be prefixed with the current time.");
+        }
+
+        /// <summary>
+        /// The fallback logger should format a simple message, with arguments.
+        /// </summary>
+        [Fact(DisplayName = "Should_FormatSimpleMessage")]
+        public void Should_FormatSimpleMessage()
+        {
+            // Setup
+            var fallbackLogger = GetFallbackLogger();
+            var target = A.Fake<ITarget>();
+
+            // Execute
+            fallbackLogger.Log("Formatted {0}!", "message");
+
+            // Verify
+            var text = fallbackLogger.LoggedMessages.Single();
+            Assert.Contains("Formatted message!", text);
+        }
+
         /// <summary>
         /// Gets the fallback logger under test.
         /// </summary>
@@ -207,8 +273,14 @@ public DummyStandardFallbackLogger()
 
         public override void Log(Exception exception, ITarget target, ILogEvent logEvent)
         {
-            var message = FormatMessage(exception, target, logEvent);
-            LoggedMessages.Add(message);
+            var formatted = FormatMessage(exception, target, logEvent);
+            LoggedMessages.Add(formatted);
+        }
+
+        public override void Log(string message, params object[] args)
+        {
+            var formatted = FormatMessage(message, args);
+            LoggedMessages.Add(formatted);
         }
     }
 }

Take2/NuLog.Tests/Unit/FallbackLoggers/StandardFileFallbackLoggerTests.cs

@@ -45,5 +45,61 @@ public void Should_WriteToFile()
                 }
             }
         }
+
+        /// <summary>
+        /// The standard file fallback logger should write a simple message to file.
+        /// </summary>
+        [Fact(DisplayName = "Should_WriteSimpleMessageToFile")]
+        public void Should_WriteSimpleMessageToFile()
+        {
+            try
+            {
+                // Setup
+                var fallbackLogger = new StandardFileFallbackLogger("Should_WriteSimpleMessageToFile.txt");
+                var target = A.Fake<ITarget>();
+
+                // Execute
+                fallbackLogger.Log("Hello, simple message");
+
+                // Verify
+                var text = File.ReadAllText("Should_WriteSimpleMessageToFile.txt");
+                Assert.Contains("Hello, simple message", text);
+            }
+            finally
+            {
+                if (File.Exists("Should_WriteSimpleMessageToFile.txt"))
+                {
+                    File.Delete("Should_WriteSimpleMessageToFile.txt");
+                }
+            }
+        }
+
+        /// <summary>
+        /// The standard file fallback logger should write a formatted message to file.
+        /// </summary>
+        [Fact(DisplayName = "Should_WriteFormattedMessageToFile")]
+        public void Should_WriteFormattedMessageToFile()
+        {
+            try
+            {
+                // Setup
+                var fallbackLogger = new StandardFileFallbackLogger("Should_WriteFormattedMessageToFile.txt");
+                var target = A.Fake<ITarget>();
+
+                // Execute
+                fallbackLogger.Log("Hello, simple {0}!", "message");
+
+                // Verify
+                var text = File.ReadAllText("Should_WriteFormattedMessageToFile.txt");
+                Assert.Contains("Hello, simple message!", text);
+            }
+            finally
+            {
+                if (File.Exists("Should_WriteFormattedMessageToFile.txt"))
+                {
+                    File.Delete("Should_WriteFormattedMessageToFile.txt");
+                }
+            }
+        }
     }
 }

Take2/NuLog.Tests/Unit/FallbackLoggers/StandardTraceFallbackLoggerTests.cs

@@ -50,5 +50,39 @@ public void Should_WriteToTrace()
             Assert.True(this.traceListener.Messages.Any(m => m.Contains("Hello, StandardTraceFallbackLogger!")));
             Assert.True(this.traceListener.Messages.Any(m => m.Contains("Hello, StandardTraceFallbackLogger Line Two!")));
         }
+
+        /// <summary>
+        /// A simple message should be written to trace.
+        /// </summary>
+        [Fact(DisplayName = "Should_WriteSimpleMessageToTrace")]
+        public void Should_WriteSimpleMessageToTrace()
+        {
+            // Setup
+            var fallbackLogger = new StandardTraceFallbackLogger();
+            var target = A.Fake<ITarget>();
+
+            // Execute
+            fallbackLogger.Log("Hello, Simple Message!");
+
+            // Verify
+            Assert.True(this.traceListener.Messages.Any(m => m.Contains("Hello, Simple Message!")));
+        }
+
+        /// <summary>
+        /// A formatted message should be written to trace.
+        /// </summary>
+        [Fact(DisplayName = "Should_WriteFormattedMessageToTrace")]
+        public void Should_WriteFormattedMessageToTrace()
+        {
+            // Setup
+            var fallbackLogger = new StandardTraceFallbackLogger();
+            var target = A.Fake<ITarget>();
+
+            // Execute
+            fallbackLogger.Log("Hello, Formatted {0}!", "Message");
+
+            // Verify
+            Assert.True(this.traceListener.Messages.Any(m => m.Contains("Hello, Formatted Message!")));
+        }
     }
 }

Take2/NuLog.sln

@@ -10,6 +10,9 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NuLog.CLI.PerfTune", "NuLog.CLI.PerfTune\NuLog.CLI.PerfTune.csproj", "{40A62D51-DE30-4C8A-BD5F-157189E0C8B5}"
 EndProject
 Global
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU

Take2/NuLog/Configuration/Config.cs

@@ -36,5 +36,12 @@ public class Config
         /// the logger to include the stack frame in created log events.
         /// </summary>
         public bool IncludeStackFrame { get; set; }
+
+        /// <summary>
+        /// The (optional) path to a fallback log, which is used when failure occurs when logging a
+        /// log event. Can be useful when there are problems with the logging system, such as
+        /// programming errors in components, or configuration issues.
+        /// </summary>
+        public string FallbackLogPath { get; set; }
     }
 }

Take2/NuLog/Configuration/XmlConfigurationProvider.cs

@@ -38,6 +38,9 @@ public Config GetConfiguration()
             // Get the "includeStackFrame" flag
             config.IncludeStackFrame = GetBooleanAttribute(xmlElement, "includeStackFrame");
 
+            // Get the fallback log path
+            config.FallbackLogPath = GetStringAttribute(xmlElement, "fallbackLog");
+
             // Return the built config
             return config;
         }

Take2/NuLog/Dispatchers/IFallbackLogger.cs

@@ -17,5 +17,11 @@ public interface IFallbackLogger
         /// Logs an exception that occurred while writing to the given target.
         /// </summary>
         void Log(Exception exception, ITarget target, ILogEvent logEvent);
+
+        /// <summary>
+        /// Logs an arbitrary message. Will format the message, if arguments are given, otherwise,
+        /// will just write it direct.
+        /// </summary>
+        void Log(string message, params object[] args);
     }
 }