LogEventBuilder - Updated LogEvent-property so it always returns LogE…

…vent
NLog · Sep 3, 2022 · 64dd9c0 · 64dd9c0
1 parent 1cc0d03
commit 64dd9c0
Show file tree

Hide file tree

Showing 3 changed files with 74 additions and 17 deletions.
diff --git a/src/NLog/LogEventBuilder.cs b/src/NLog/LogEventBuilder.cs
@@ -58,7 +58,6 @@ public LogEventBuilder([NotNull] ILogger logger)
             _logEvent = new LogEventInfo() { LoggerName = _logger.Name };
         }
 
-
         /// <summary>
         /// Initializes a new instance of the <see cref="LogEventBuilder"/> class.
         /// </summary>
@@ -91,7 +90,7 @@ public LogEventBuilder([NotNull] ILogger logger, [NotNull] LogLevel logLevel)
         /// Logging event that will be written
         /// </summary>
         [CanBeNull]
-        public LogEventInfo LogEvent => _logEvent;
+        public LogEventInfo LogEvent => _logEvent is null ? null : ResolveLogEvent(_logEvent);
 
         /// <summary>
         /// Sets a per-event context property on the logging event.
@@ -121,7 +120,7 @@ public LogEventBuilder Properties([NotNull] IEnumerable<KeyValuePair<string, obj
 
             if (_logEvent is null)
                 return this;
-            
+
             foreach (var property in properties)
                 _logEvent.Properties[property.Key] = property.Value;
             return this;
@@ -305,16 +304,52 @@ public LogEventBuilder Message(IFormatProvider formatProvider, [Localizable(fals
         {
             if (_logEvent != null)
             {
-                if (logLevel != null)
-                    _logEvent.Level = logLevel;
-                else if (_logEvent.Level == null)
-                    _logEvent.Level = _logEvent.Exception != null ? LogLevel.Error : LogLevel.Info;
-                if (_logEvent.Message == null)
-                    _logEvent.Message = _logEvent.Exception != null ? _logEvent.Exception.Message : string.Empty;
-                if (_logEvent.CallSiteInformation == null && _logEvent.Level != LogLevel.Off)
+                var logEvent = ResolveLogEvent(_logEvent, logLevel);
+                if (logEvent.CallSiteInformation is null && _logger.IsEnabled(logEvent.Level))
+                {
                     _logEvent.SetCallerInfo(null, callerMemberName, callerFilePath, callerLineNumber);
-                _logger.Log(_logEvent);
+                }
+                _logger.Log(logEvent);
+            }
+        }
+
+        /// <summary>
+        /// Writes the log event to the underlying logger.
+        /// </summary>
+        /// <param name="wrapperType">Type of custom Logger wrapper.</param>
+#if !NET35
+        public void Log(Type wrapperType)
+#else
+        public void Log(Type wrapperType)
+#endif
+        {
+            if (_logEvent != null)
+            {
+                var logEvent = ResolveLogEvent(_logEvent);
+                _logger.Log(wrapperType, logEvent);
+            }
+        }
+
+        private LogEventInfo ResolveLogEvent(LogEventInfo logEvent, LogLevel logLevel = null)
+        {
+            if (logLevel is null)
+            {
+                if (logEvent.Level is null)
+                    logEvent.Level = logEvent.Exception != null ? LogLevel.Error : LogLevel.Info;
             }
+            else
+            {
+                logEvent.Level = logLevel;
+            }
+
+            if (logEvent.Message is null && logEvent.Exception != null && _logger.IsEnabled(logEvent.Level))
+            {
+                logEvent.FormatProvider = NLog.Internal.ExceptionMessageFormatProvider.Instance;
+                logEvent.Message = "{0}";
+                logEvent.Parameters = new object[1] { logEvent.Exception };
+            }
+
+            return logEvent;
         }
     }
 }
diff --git a/tests/NLog.UnitTests/Fluent/LogEventBuilderTests.cs b/tests/NLog.UnitTests/Fluent/LogEventBuilderTests.cs
@@ -335,7 +335,7 @@ public void LogBuilder_exception_only()
                 .Exception(ex)
                 .Log();
 
-            var expectedEvent = new LogEventInfo(LogLevel.Error, "logger1", ex.Message) { Exception = ex };
+            var expectedEvent = LogEventInfo.Create(LogLevel.Error, "logger1", null, ex);
             AssertLastLogEventTarget(expectedEvent);
         }
 

diff --git a/tests/NLog.UnitTests/LayoutRenderers/CallSite/CallSiteTests.cs b/tests/NLog.UnitTests/LayoutRenderers/CallSite/CallSiteTests.cs
@@ -633,6 +633,10 @@ public void When_Wrapped_Ignore_Wrapper_Methods_In_Callstack()
             var wrappedLogger = new MyWrapper(logFactory);
             wrappedLogger.Log("wrapped");
             logFactory.AssertDebugLastMessage($"{currentMethodFullName}|wrapped");
+
+            var fluentLogger = new MyFluentWrapper(logFactory);
+            fluentLogger.Log("wrapped");
+            logFactory.AssertDebugLastMessage($"{currentMethodFullName}|wrapped");
         }
 
         [Fact]
@@ -1022,12 +1026,12 @@ public void Log(string what)
                 InternalLog(typeof(BaseWrapper), what);
             }
 
-            public void Log(Type type, string what) //overloaded with type for composition
+            public void Log(Type wrapperType, string what) //overloaded with type for composition
             {
-                InternalLog(type, what);
+                InternalLog(wrapperType, what);
             }
 
-            protected abstract void InternalLog(Type type, string what);
+            protected abstract void InternalLog(Type wrapperType, string what);
         }
 
         public class MyWrapper : BaseWrapper
@@ -1039,14 +1043,32 @@ public MyWrapper(LogFactory logFactory)
                 _wrapperLogger = logFactory.GetLogger("WrappedLogger");
             }
 
-            protected override void InternalLog(Type type, string what) //added type for composition
+            protected override void InternalLog(Type wrapperType, string what) //added type for composition
             {
                 LogEventInfo info = new LogEventInfo(LogLevel.Warn, _wrapperLogger.Name, what);
 
                 // Provide BaseWrapper as wrapper type.
                 // Expected: UserStackFrame should point to the method that calls a 
                 // method of BaseWrapper.
-                _wrapperLogger.Log(type, info);
+                _wrapperLogger.Log(wrapperType, info);
+            }
+        }
+
+        public class MyFluentWrapper : BaseWrapper
+        {
+            private readonly Logger _wrapperLogger;
+
+            public MyFluentWrapper(LogFactory logFactory)
+            {
+                _wrapperLogger = logFactory.GetLogger("WrappedLogger");
+            }
+
+            protected override void InternalLog(Type wrapperType, string what) //added type for composition
+            {
+                // Provide BaseWrapper as wrapper type.
+                // Expected: UserStackFrame should point to the method that calls a 
+                // method of BaseWrapper.
+                _wrapperLogger.ForWarnEvent().Message(what).Log(wrapperType);
             }
         }