Made the standard logger able to show the caller

IllusionInjector/Logging/StandardLogger.cs

@@ -4,6 +4,7 @@ using IllusionPlugin.Logging;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -60,6 +61,7 @@ namespace IllusionInjector.Logging
 
         private string logName;
         private static LogLevel showFilter = LogLevel.InfoUp;
+        private static bool showSourceClass = true;
         public static LogLevel PrintFilter { get => showFilter; set => showFilter = value; }
         private List<LogPrinter> printers = new List<LogPrinter>(defaultPrinters);
 
@@ -67,6 +69,7 @@ namespace IllusionInjector.Logging
         {
             if (ModPrefs.GetBool("IPA", "PrintDebug", false, true))
                 showFilter = LogLevel.All;
+            showSourceClass = ModPrefs.GetBool("IPA", "DebugShowCallSource", false, true);
         }
 
         internal StandardLogger(string name)
@@ -93,6 +96,15 @@ namespace IllusionInjector.Logging
             });
         }
 
+        public override void Debug(string message)
+        { // add source to message
+            var stfm = new StackTrace().GetFrame(1).GetMethod();
+            if (showSourceClass)
+                base.Debug($"{{{stfm.DeclaringType.FullName}::{stfm.Name}}} {message}");
+            else
+                base.Debug(message);
+        }
+
         internal struct LogMessage
         {
             public Level level;

IllusionPlugin/Logging/Logger.cs

@@ -107,76 +107,76 @@ namespace IllusionPlugin.Logging
         /// </summary>
         /// <param name="level">the level of the message</param>
         /// <param name="exeption">the exception to log</param>
-        public void Log(Level level, Exception exeption) => Log(level, exeption.ToString());
+        public virtual void Log(Level level, Exception exeption) => Log(level, exeption.ToString());
         /// <summary>
         /// Sends a debug message. 
         /// Equivalent to Log(Level.Debug, message);
         /// <see cref="Log(Level, string)"/>
         /// </summary>
         /// <param name="message">the message to log</param>
-        public void Debug(string message) => Log(Level.Debug, message);
+        public virtual void Debug(string message) => Log(Level.Debug, message);
         /// <summary>
         /// Sends an exception as a debug message.
         /// Equivalent to Log(Level.Debug, e);
         /// <see cref="Log(Level, Exception)"/>
         /// </summary>
         /// <param name="e">the exception to log</param>
-        public void Debug(Exception e) => Log(Level.Debug, e);
+        public virtual void Debug(Exception e) => Log(Level.Debug, e);
         /// <summary>
         /// Sends an info message. 
         /// Equivalent to Log(Level.Info, message).
         /// <see cref="Log(Level, string)"/>
         /// </summary>
         /// <param name="message">the message to log</param>
-        public void Info(string message) => Log(Level.Info, message);
+        public virtual void Info(string message) => Log(Level.Info, message);
         /// <summary>
         /// Sends an exception as an info message.
         /// Equivalent to Log(Level.Info, e);
         /// <see cref="Log(Level, Exception)"/>
         /// </summary>
         /// <param name="e">the exception to log</param>
-        public void Info(Exception e) => Log(Level.Info, e);
+        public virtual void Info(Exception e) => Log(Level.Info, e);
         /// <summary>
         /// Sends a warning message. 
         /// Equivalent to Log(Level.Warning, message).
         /// <see cref="Log(Level, string)"/>
         /// </summary>
         /// <param name="message">the message to log</param>
-        public void Warn(string message) => Log(Level.Warning, message);
+        public virtual void Warn(string message) => Log(Level.Warning, message);
         /// <summary>
         /// Sends an exception as a warning message.
         /// Equivalent to Log(Level.Warning, e);
         /// <see cref="Log(Level, Exception)"/>
         /// </summary>
         /// <param name="e">the exception to log</param>
-        public void Warn(Exception e) => Log(Level.Warning, e);
+        public virtual void Warn(Exception e) => Log(Level.Warning, e);
         /// <summary>
         /// Sends an error message. 
         /// Equivalent to Log(Level.Error, message).
         /// <see cref="Log(Level, string)"/>
         /// </summary>
         /// <param name="message">the message to log</param>
-        public void Error(string message) => Log(Level.Error, message);
+        public virtual void Error(string message) => Log(Level.Error, message);
         /// <summary>
         /// Sends an exception as an error message.
         /// Equivalent to Log(Level.Error, e);
         /// <see cref="Log(Level, Exception)"/>
         /// </summary>
         /// <param name="e">the exception to log</param>
-        public void Error(Exception e) => Log(Level.Error, e);
+        public virtual void Error(Exception e) => Log(Level.Error, e);
         /// <summary>
         /// Sends a critical message. 
         /// Equivalent to Log(Level.Critical, message).
         /// <see cref="Log(Level, string)"/>
         /// </summary>
         /// <param name="message">the message to log</param>
-        public void Critical(string message) => Log(Level.Critical, message);
+        public virtual void Critical(string message) => Log(Level.Critical, message);
         /// <summary>
         /// Sends an exception as a critical message.
         /// Equivalent to Log(Level.Critical, e);
         /// <see cref="Log(Level, Exception)"/>
         /// </summary>
         /// <param name="e">the exception to log</param>
-        public void Critical(Exception e) => Log(Level.Critical, e);
+        public virtual void Critical(Exception e) => Log(Level.Critical, e);
     }
 }