From 6c1dcd1a7dd2d18ef8a9bff9d054f5e2d52adeb0 Mon Sep 17 00:00:00 2001
From: aurelien <aurelien.sauvageau@free.fr>
Date: Wed, 14 Nov 2018 17:52:56 +0100
Subject: [PATCH] manage Microsoft logs by NLog (#4080)

* now Microsoft log (Microsoft.*) are correctly supported by Nlog

* Microsoft log are now not logged under level info if tracing is not enabled.

* remove unused prefix NLog.

* Revert "Microsoft log are now not logged under level info if tracing is not enabled."

This reverts commit 00e94204e03030abb3e2d6b86abbe9046ca2aac6.

* microsoft logs in console are preserved.
Only service log is clean of microsoft logs when tracing is not enabled.

* change loglevel min to debug

* Microsoft logs can be reactivate when Enhanced logging is set to true.

* adjust min & max level of serviceMicrosoftRule

* clean Microsoft logs in all NLog targets
---
 src/Jackett.Common/Utils/LoggingSetup.cs | 34 ++++++++++++++++++++++--
 src/Jackett.Server/Helper.cs             | 26 ++++++++++++++++++
 src/Jackett.Server/Program.cs            |  6 +++++
 3 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/src/Jackett.Common/Utils/LoggingSetup.cs b/src/Jackett.Common/Utils/LoggingSetup.cs
index c052684e7..54a637dcb 100644
--- a/src/Jackett.Common/Utils/LoggingSetup.cs
+++ b/src/Jackett.Common/Utils/LoggingSetup.cs
@@ -20,8 +20,8 @@ namespace Jackett.Common.Utils
             ConfigurationItemFactory.Default.LayoutRenderers.RegisterDefinition("simpledatetime", typeof(SimpleDateTimeRenderer));
 
             var logConfig = new LoggingConfiguration();
+
             var logFile = new FileTarget();
-            logConfig.AddTarget("file", logFile);
             logFile.Layout = "${longdate} ${level} ${message} ${exception:format=ToString}";
             logFile.FileName = Path.Combine(settings.DataFolder, logFileName);
             logFile.ArchiveFileName = Path.Combine(settings.DataFolder, logFileName + ".{#####}.txt");
@@ -29,24 +29,54 @@ namespace Jackett.Common.Utils
             logFile.MaxArchiveFiles = 5;
             logFile.KeepFileOpen = false;
             logFile.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;
+            logConfig.AddTarget("file", logFile);
+
+            var microsoftRule = new LoggingRule();
+            microsoftRule.LoggerNamePattern = "Microsoft.*";
+            microsoftRule.SetLoggingLevels(LogLevel.Warn, LogLevel.Fatal);
+            microsoftRule.Final = true;
+            microsoftRule.Targets.Add(logFile);
+
+            var microsoftDebugRule = new LoggingRule();
+            microsoftDebugRule.LoggerNamePattern = "Microsoft.*";
+            microsoftDebugRule.SetLoggingLevels(LogLevel.Debug, LogLevel.Info);
+            microsoftDebugRule.Final = true;
+            if (settings.TracingEnabled)
+            {
+                microsoftDebugRule.Targets.Add(logFile);
+            }
+            logConfig.LoggingRules.Add(microsoftDebugRule);
+
             var logFileRule = new LoggingRule("*", logLevel, logFile);
             logConfig.LoggingRules.Add(logFileRule);
 
             if (!fileOnly)
             {
                 var logConsole = new ColoredConsoleTarget();
+                logConsole.Layout = "${simpledatetime} ${level} ${message} ${exception:format=ToString}";
                 logConfig.AddTarget("console", logConsole);
 
-                logConsole.Layout = "${simpledatetime} ${level} ${message} ${exception:format=ToString}";
                 var logConsoleRule = new LoggingRule("*", logLevel, logConsole);
                 logConfig.LoggingRules.Add(logConsoleRule);
 
                 var logService = new LogCacheService();
                 logConfig.AddTarget("service", logService);
+
                 var serviceRule = new LoggingRule("*", logLevel, logService);
                 logConfig.LoggingRules.Add(serviceRule);
+
+                microsoftRule.Targets.Add(logConsole);
+                microsoftRule.Targets.Add(logService);
+
+                if (settings.TracingEnabled)
+                {
+                    microsoftDebugRule.Targets.Add(logConsole);
+                    microsoftDebugRule.Targets.Add(logService);
+                }
             }
 
+            logConfig.LoggingRules.Add(microsoftRule);
+
             return logConfig;
         }
 
diff --git a/src/Jackett.Server/Helper.cs b/src/Jackett.Server/Helper.cs
index 20e0b3213..7c4f817b8 100644
--- a/src/Jackett.Server/Helper.cs
+++ b/src/Jackett.Server/Helper.cs
@@ -140,6 +140,32 @@ namespace Jackett.Server
         {
             foreach (var rule in LogManager.Configuration.LoggingRules)
             {
+                if (rule.LoggerNamePattern == "Microsoft.*")
+                {
+                    if (!rule.Levels.Contains(LogLevel.Debug))
+                    {
+                        //don't change the first microsoftRule
+                        continue;
+                    }
+
+                    var targets = LogManager.Configuration.ConfiguredNamedTargets;
+                    if (level == LogLevel.Debug)
+                    {
+                        foreach (var target in targets)
+                        {
+                            rule.Targets.Add(target);
+                        }
+                    }
+                    else
+                    {
+                        foreach (var target in targets)
+                        {
+                            rule.Targets.Remove(target);
+                        }
+                    }
+                    continue;
+                }
+
                 if (level == LogLevel.Debug)
                 {
                     if (!rule.Levels.Contains(LogLevel.Debug))
diff --git a/src/Jackett.Server/Program.cs b/src/Jackett.Server/Program.cs
index e4c180409..533447e7b 100644
--- a/src/Jackett.Server/Program.cs
+++ b/src/Jackett.Server/Program.cs
@@ -7,6 +7,7 @@ using Jackett.Common.Utils;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using NLog;
 using NLog.Web;
 using System;
@@ -184,6 +185,11 @@ namespace Jackett.Server
                 .PreferHostingUrls(true)
                 .UseConfiguration(Configuration)
                 .UseStartup<Startup>()
+                .ConfigureLogging(logging =>
+                {
+                    logging.ClearProviders();
+                    logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
+                })
                 .UseNLog();
     }
 }