ok high iq solutions is bad for compatibility

Torch.Server/Program.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using NLog;
+using NLog.Config;
 using NLog.Targets;
 using Torch.Utils;
 
@@ -12,7 +14,6 @@ namespace Torch.Server
         {
             var isService = Environment.GetEnvironmentVariable("TORCH_SERVICE")
                 ?.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase) ?? false;
-            Target.Register<LogViewerTarget>(nameof(LogViewerTarget));
             //Ensures that all the files are downloaded in the Torch directory.
             var workingDir = AppContext.BaseDirectory;
             var binDir = Path.Combine(Environment.GetEnvironmentVariable("TORCH_GAME_PATH") ?? workingDir, "DedicatedServer64");
@@ -46,6 +47,14 @@ namespace Torch.Server
             {
                 instancePath = Directory.CreateDirectory(instanceName).FullName;
             }
+            
+            var oldNlog = Path.Combine(workingDir, "NLog.config");
+            var newNlog = Path.Combine(instancePath, "NLog.config");
+            if (File.Exists(oldNlog))
+                File.Move(oldNlog, newNlog, true);
+            else if (!File.Exists(newNlog))
+                using (var f = File.Create(newNlog))
+                    typeof(Program).Assembly.GetManifestResourceStream("Torch.Server.NLog.config")!.CopyTo(f);
 
             var oldTorchCfg = Path.Combine(workingDir, "Torch.cfg");
             var torchCfg = Path.Combine(instancePath, "Torch.cfg");
@@ -64,6 +73,12 @@ namespace Torch.Server
 
             var handler = new UnhandledExceptionHandler(config.Data, isService);
             AppDomain.CurrentDomain.UnhandledException += handler.OnUnhandledException;
+            
+            Target.Register<LogViewerTarget>(nameof(LogViewerTarget));
+            TorchLogManager.RegisterTargets(Environment.GetEnvironmentVariable("TORCH_LOG_EXTENSIONS_PATH") ??
+                                            Path.Combine(instancePath, "LoggingExtensions"));
+            
+            TorchLogManager.SetConfiguration(new XmlLoggingConfiguration(newNlog));
 
             var initializer = new Initializer(workingDir, config);
             if (!initializer.Initialize(args))

Torch.Server/Torch.Server.csproj

@@ -160,6 +160,6 @@
   </ItemGroup>
   <ItemGroup>
     <Page Remove="Views\WorldSelectControl.xaml" />
-    <None Include="..\NLog.config" Visible="false" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="Always" />
+    <EmbeddedResource Include="..\NLog.config" Visible="false" />
   </ItemGroup>
 </Project>

Torch/Patches/GameAnalyticsPatch.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using NLog;
 using NLog.Config;
 using Torch.Managers.PatchManager;
+using Torch.Utils;
 
 namespace Torch.Patches
 {
@@ -36,16 +37,13 @@ namespace Torch.Patches
                 _log.Warn("GALogger constructor is unknown.  Logging may not function.");
                 return;
             }
-            ctx.GetPattern(ctor).Prefixes.Add(typeof(GameAnalyticsPatch).GetMethod(nameof(PatchLogger),
-                BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public));
+            ctx.GetPattern(ctor).AddPrefix(nameof(PatchLogger));
         }
 
         private static void FixLogging()
         {
+            TorchLogManager.RestoreGlobalConfiguration();
             _setLogger(null, LogManager.GetLogger("GameAnalytics"));
-            if (!(LogManager.Configuration is XmlLoggingConfiguration))
-                LogManager.Configuration = new XmlLoggingConfiguration(Path.Combine(
-                    Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) ?? Environment.CurrentDirectory, "NLog.config"));
         }
 
         private static bool PatchLogger()

Torch/Utils/TorchLogManager.cs

@@ -0,0 +1,41 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using NLog;
+using NLog.Config;
+using NLog.Targets;
+
+namespace Torch.Utils;
+
+public static class TorchLogManager
+{
+    private static AssemblyLoadContext LoadContext = new("TorchLog");
+
+    public static LoggingConfiguration Configuration { get; private set; }
+
+    public static void SetConfiguration(LoggingConfiguration configuration)
+    {
+        Configuration = configuration;
+        LogManager.Configuration = configuration;
+        LogManager.ReconfigExistingLoggers();
+    }
+
+    public static void RegisterTargets(string dir)
+    {
+        if (!Directory.Exists(dir)) return;
+        
+        foreach (var type in Directory.EnumerateFiles(dir, "*.dll").Select(LoadContext.LoadFromAssemblyPath)
+                     .SelectMany(b => b.ExportedTypes)
+                     .Where(b => b.GetCustomAttribute<TargetAttribute>() is { }))
+        {
+            Target.Register(type.GetCustomAttribute<TargetAttribute>()!.Name, type);
+        }
+    }
+
+    public static void RestoreGlobalConfiguration()
+    {
+        SetConfiguration(Configuration);
+    }
+}