Clean tracing & Logger

Author: Jérémie Bertrand

src/Pretzel.Logic/Commands/CommandParameters.cs

@@ -105,7 +105,7 @@ public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteCo
             foreach (var engine in engines)
             {
                 if (!engine.Value.CanProcess(context)) continue;
-                Tracing.InfoFormat("Recommended engine for directory: '{0}'", engine.Key);
+                Tracing.Info("Recommended engine for directory: '{0}'", engine.Key);
                 Template = engine.Key;
                 return;
             }

src/Pretzel.Logic/Extensions/Logger.cs

@@ -2,51 +2,85 @@
 
 namespace Pretzel.Logic.Extensions
 {
+    /// <summary>
+    /// Trace for Pretzel
+    /// </summary>
     public static class Tracing
     {
-        [Obsolete("Use Tracing directly instead")]
-        public enum Category {
-            Debug,
-            Info,
-            Error
-        }
+        private static Action<string, TraceLevel> _trace;
+        private static TraceLevel _minLevel;
 
         static Tracing()
         {
-            Logger = new Logger();
+            // Do nothing by default
+            _trace = (message, TraceLevel) => { };
+            _minLevel = TraceLevel.Info;
         }
 
-        [Obsolete("Use Tracing directly instead")]
-        public static Logger Logger { get; set; }
+        internal static void SetTrace(Action<string, TraceLevel> trace)
+        {
+            _trace = trace;
+        }
 
-        public static void Debug(string message)
+        internal static void SetMinimalLevel(TraceLevel level)
         {
-            Logger.Write(message, Category.Debug);
+            _minLevel = level;
         }
 
-        public static void Info(string message)
+        /// <summary>
+        /// Trace a debug message
+        /// </summary>
+        /// <param name="message">Message to trace</param>
+        /// <param name="messageParameters">Format parameters for the message</param>
+        public static void Debug(string message, params object[] messageParameters)
         {
-            Logger.Write(message, Category.Info);
+            TraceMessage(message, messageParameters, TraceLevel.Debug);
         }
 
-        public static void Error(string message)
+        /// <summary>
+        /// Trace an info message
+        /// </summary>
+        /// <param name="message">Message to trace</param>
+        /// <param name="messageParameters">Format parameters for the message</param>
+        public static void Info(string message, params object[] messageParameters)
         {
-            Logger.Write(message, Category.Error);
+            TraceMessage(message, messageParameters, TraceLevel.Info);
         }
 
-        public static void DebugFormat(string message, params object[] messageParameters)
+        /// <summary>
+        /// Trace a warning message
+        /// </summary>
+        /// <param name="message">Message to trace</param>
+        /// <param name="messageParameters">Format parameters for the message</param>
+        public static void Warning(string message, params object[] messageParameters)
         {
-            Logger.WriteFormat(message, Category.Debug, messageParameters);
+            TraceMessage(message, messageParameters, TraceLevel.Warning);
         }
 
-        public static void InfoFormat(string message, params object[] messageParameters)
+        /// <summary>
+        /// Trace an error message
+        /// </summary>
+        /// <param name="message">Message to trace</param>
+        /// <param name="messageParameters">Format parameters for the message</param>
+        public static void Error(string message, params object[] messageParameters)
         {
-            Logger.WriteFormat(message, Category.Info, messageParameters);
+            TraceMessage(message, messageParameters, TraceLevel.Error);
         }
 
-        public static void ErrorFormat(string message, params object[] messageParameters)
+        private static void TraceMessage(string message, object[] messageParameters, TraceLevel messageLevel)
         {
-            Logger.WriteFormat(message, Category.Error, messageParameters);
+            if(messageLevel >= _minLevel)
+            {
+                _trace(string.Format(message, messageParameters), messageLevel);
+            }
         }
     }
+
+    internal enum TraceLevel
+    {
+        Debug,
+        Info,
+        Warning,
+        Error
+    }
 }

src/Pretzel.Logic/Extensions/Tracing.cs

@@ -106,7 +106,7 @@ private void ImportPost(BloggerPost post)
             }
             catch (Exception e)
             {
-                Tracing.InfoFormat("Failed to write out {0}", fileName);
+                Tracing.Info("Failed to write out {0}", fileName);
                 Tracing.Debug(e.Message);
             }
         }

src/Pretzel.Logic/Import/BloggerImport.cs

@@ -130,7 +130,7 @@ private void ProcessNodes(StringBuilder markdown, IEnumerable<HtmlNode> htmlNode
                         break;
                     default:
                         ProcessNodes(markdown, htmlNode.ChildNodes);
-                        Tracing.InfoFormat("{0}", htmlNode.OuterHtml);
+                        Tracing.Info("{0}", htmlNode.OuterHtml);
                         break;
                 }
             }

src/Pretzel.Logic/Import/HtmlToMarkdownConverter.cs

@@ -105,7 +105,6 @@
     <Compile Include="Extensibility\TagFactoryBase.cs" />
     <Compile Include="Extensions\DictionaryExtensions.cs" />
     <Compile Include="Extensions\IAssembly.cs" />
-    <Compile Include="Extensions\Logger.cs" />
     <Compile Include="Extensions\Sitemap.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Extensions\Tracing.cs" />

src/Pretzel.Logic/Pretzel.Logic.csproj

@@ -32,19 +32,19 @@ public void Create()
 
             if (!fileSystem.Directory.Exists(postPath))
             {
-                Tracing.InfoFormat("{0} folder not found", postPath);
+                Tracing.Info("{0} folder not found", postPath);
                 return;
             }
 
             if (fileSystem.File.Exists(fileSystem.Path.Combine(postPath, postName)))
             {
-                Tracing.InfoFormat("The \"{0}\" file already exists", postName);
+                Tracing.Info("The \"{0}\" file already exists", postName);
                 return;
             }
 
             fileSystem.File.WriteAllText(fileSystem.Path.Combine(postPath, postName), pageContents);
 
-            Tracing.InfoFormat("Created the \"{0}\" post ({1})", title, postName);
+            Tracing.Info("Created the \"{0}\" post ({1})", title, postName);
         }
     }
 }

src/Pretzel.Logic/Recipe/Ingredient.cs

@@ -106,7 +106,7 @@ public void Create()
             }
             catch (Exception ex)
             {
-                Tracing.ErrorFormat("Error trying to create template: {0}", ex);
+                Tracing.Error("Error trying to create template: {0}", ex);
             }
         }
 

src/Pretzel.Logic/Recipe/Recipe.cs

@@ -285,7 +285,7 @@ private Page CreatePage(SiteContext context, IConfiguration config, string file,
             }
             catch (Exception e)
             {
-                Tracing.InfoFormat("Failed to build post from File: {0}", file);
+                Tracing.Info("Failed to build post from File: {0}", file);
                 Tracing.Info(e.Message);
                 Tracing.Debug(e.ToString());
             }
@@ -353,7 +353,7 @@ private string SafeReadLine(string file)
             {
                 if (SanityCheck.IsLockedByAnotherProcess(file))
                 {
-                    Tracing.InfoFormat("File {0} is locked by another process. Skipping", file);
+                    Tracing.Info("File {0} is locked by another process. Skipping", file);
                     return string.Empty;
                 }
 

src/Pretzel.Logic/Templating/Context/SiteContextGenerator.cs

@@ -54,7 +54,7 @@ public void Process(SiteContext siteContext, bool skipFileOnError = false)
                 _lightweightMarkupEngine = new CommonMarkEngine();
             }
 
-            Tracing.DebugFormat("LightweightMarkupEngine: {0}", _lightweightMarkupEngine.GetType().Name);
+            Tracing.Debug("LightweightMarkupEngine: {0}", _lightweightMarkupEngine.GetType().Name);
 
             Context = siteContext;
             PreProcess();
@@ -234,7 +234,7 @@ private string RenderContent(string file, string contents)
             }
             catch (Exception e)
             {
-                Tracing.InfoFormat("Error ({0}) converting {1}", e.Message, file);
+                Tracing.Info("Error ({0}) converting {1}", e.Message, file);
                 Tracing.Debug(e.ToString());
                 html = String.Format("<p><b>Error converting markdown:</b><br />{0}</p><p>Original content:<br /><pre>{1}</pre></p>", e.Message, contents);
             }