Format exception in structured and plain logging

Author: normj

Libraries/src/Amazon.Lambda.RuntimeSupport/Bootstrap/LambdaBootstrap.cs

@@ -18,6 +18,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Amazon.Lambda.Core;
 using Amazon.Lambda.RuntimeSupport.Bootstrap;
 using Amazon.Lambda.RuntimeSupport.Helpers;
 
@@ -252,9 +253,11 @@ public static HttpClient ConstructHttpClient()
 
         private void WriteUnhandledExceptionToLog(Exception exception)
         {
-            // Console.Error.WriteLine are redirected to the IConsoleLoggerWriter which
-            // will take care of writing to the function's log stream.
+#if NET6_0_OR_GREATER
+            Client.ConsoleLogger.FormattedWriteLine(LogLevel.Error.ToString(), exception, null);
+#else
             Console.Error.WriteLine(exception);
+#endif
         }
 
 #if NET8_0_OR_GREATER

Libraries/src/Amazon.Lambda.RuntimeSupport/Helpers/Logging/DefaultLogMessageFormatter.cs

@@ -1,5 +1,7 @@
 #if NET6_0_OR_GREATER
 
+using System.Text;
+
 namespace Amazon.Lambda.RuntimeSupport.Helpers.Logging
 {
     /// <summary>
@@ -48,21 +50,53 @@ public override string FormatMessage(MessageState state)
                 message = ApplyMessageProperties(state.MessageTemplate, messageProperties, state.MessageArguments);
             }
 
+            var displayLevel = state.Level != null ? ConvertLogLevelToLabel(state.Level.Value) : null;
+
+            var sb = new StringBuilder(
+                                    25 + // Length for timestamp
+                                    (state.AwsRequestId?.Length).GetValueOrDefault() +
+                                    displayLevel.Length +
+                                    (message?.Length).GetValueOrDefault() +
+                                    5 // Padding for tabs
+                                    );
+
             if (!AddPrefix)
             {
                 return message;
             }
 
-            var displayLevel = state.Level != null ? ConvertLogLevelToLabel(state.Level.Value) : null;
 
-            if (!string.IsNullOrEmpty(displayLevel))
+            if (AddPrefix)
+            {
+                sb.Append(FormatTimestamp(state));
+                sb.Append('\t');
+                sb.Append(state.AwsRequestId);
+
+                if (!string.IsNullOrEmpty(displayLevel))
+                {
+                    sb.Append('\t');
+                    sb.Append(displayLevel);
+                }
+
+                sb.Append('\t');
+            }
+
+
+            if (!string.IsNullOrEmpty(message))
             {
-                return $"{FormatTimestamp(state)}\t{state.AwsRequestId}\t{displayLevel}\t{message ?? string.Empty}";
+                sb.Append(message);
             }
-            else
+
+            if (state.Exception != null)
             {
-                return $"{FormatTimestamp(state)}\t{state.AwsRequestId}\t{message ?? string.Empty}";
+                if (!string.IsNullOrEmpty(message))
+                {
+                    sb.Append('\n');
+                }
+                sb.Append(state.Exception.ToString());
             }
+
+            return sb.ToString();
         }
 
         /// <summary>

Libraries/src/Amazon.Lambda.RuntimeSupport/Helpers/Logging/JsonLogMessageFormatter.cs

@@ -191,11 +191,10 @@ private void WriteException(Utf8JsonWriter writer, MessageState state)
                 writer.WriteString("errorMessage", state.Exception.Message);
                 writer.WritePropertyName("stackTrace");
                 writer.WriteStartArray();
-
-                // TODO: Right now for stack trace we are just using a single array element doing a ToString to get the
-                // inner excepions. Working with the Lambda team to figure out how they want to handle inner exceptions with 
-                // stackTrace array.
-                writer.WriteStringValue(state.Exception.ToString());
+                foreach(var line in state.Exception.ToString().Split('\n'))
+                {
+                    writer.WriteStringValue(line.Trim());
+                }
                 writer.WriteEndArray();
             }
         }

Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/LogMessageFormatterTests.cs

@@ -3,6 +3,7 @@
 using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.Serialization;
 using System.Text.Json;
 using Xunit;
@@ -470,10 +471,14 @@ public void FormatJsonException()
                 Assert.Equal("This Will Fail", doc.RootElement.GetProperty("errorMessage").GetString());
                 Assert.Equal("System.ApplicationException", doc.RootElement.GetProperty("errorType").GetString());
                 Assert.Equal(JsonValueKind.Array, doc.RootElement.GetProperty("stackTrace").ValueKind);
-                Assert.Equal(ex.ToString(), doc.RootElement.GetProperty("stackTrace")[0].GetString());
 
-                // Confirm inner exceptions are being captured
-                Assert.Contains("System.NullReferenceException", doc.RootElement.GetProperty("stackTrace")[0].GetString());
+                var stackLines = ex.ToString().Split('\n').Select(x => x.Trim()).ToList();
+                var jsonExArray = doc.RootElement.GetProperty("stackTrace");
+                Assert.Equal(stackLines.Count, jsonExArray.GetArrayLength());
+                for(var i =  0; i < stackLines.Count; i++)
+                {
+                    Assert.Equal(stackLines[i], jsonExArray[i].GetString());
+                }
             }
         }