chore: Logging AOT Support

docs/core/logging.md

@@ -166,6 +166,10 @@ When debugging in non-production environments, you can instruct Logger to log th
 
 You can set a Correlation ID using `CorrelationIdPath` parameter by passing a [JSON Pointer expression](https://datatracker.ietf.org/doc/html/draft-ietf-appsawg-json-pointer-03){target="_blank"}.
 
+!!! Attention
+    The JSON Pointer expression is `case sensitive`. In the bellow example `/headers/my_request_id_header` would work but `/Headers/my_request_id_header` would not find the element.
+
+
 === "Function.cs"
 
     ```c# hl_lines="6"

libraries/src/AWS.Lambda.Powertools.Common/Core/IPowertoolsConfigurations.cs

@@ -72,7 +72,7 @@ public interface IPowertoolsConfigurations
     ///     Gets the logger sample rate.
     /// </summary>
     /// <value>The logger sample rate.</value>
-    double? LoggerSampleRate { get; }
+    double LoggerSampleRate { get; }
 
     /// <summary>
     ///     Gets a value indicating whether [logger log event].

libraries/src/AWS.Lambda.Powertools.Common/Core/PowertoolsConfigurations.cs

@@ -13,6 +13,8 @@
  * permissions and limitations under the License.
  */
 
+using System.Globalization;
+
 namespace AWS.Lambda.Powertools.Common;
 
 /// <summary>
@@ -157,10 +159,10 @@ public bool GetEnvironmentVariableOrDefault(string variable, bool defaultValue)
     ///     Gets the logger sample rate.
     /// </summary>
     /// <value>The logger sample rate.</value>
-    public double? LoggerSampleRate =>
-        double.TryParse(_systemWrapper.GetEnvironmentVariable(Constants.LoggerSampleRateNameEnv), out var result)
+    public double LoggerSampleRate =>
+        double.TryParse(_systemWrapper.GetEnvironmentVariable(Constants.LoggerSampleRateNameEnv), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture,  out var result)
             ? result
-            : null;
+            : 0;
 
     /// <summary>
     ///     Gets a value indicating whether [logger log event].

libraries/src/AWS.Lambda.Powertools.Logging/AWS.Lambda.Powertools.Logging.csproj

@@ -12,8 +12,10 @@
     <ItemGroup>
         <!--   Package versions are Centrally managed in Directory.Packages.props file  -->
         <!--   More info https://learn.microsoft.com/en-us/nuget/consume-packages/central-package-management   -->
-        <PackageReference Include="Microsoft.Extensions.Logging"/>
+        <PackageReference Include="Amazon.Lambda.Core" />
+        <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" />
+        <PackageReference Include="Microsoft.Extensions.Logging" />
         <ProjectReference Include="..\AWS.Lambda.Powertools.Common\AWS.Lambda.Powertools.Common.csproj" Condition="'$(Configuration)'=='Debug'"/>
     </ItemGroup>
-    
+
 </Project>

libraries/src/AWS.Lambda.Powertools.Logging/Internal/Converters/ExceptionConverter.cs

@@ -17,6 +17,7 @@
 using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using AWS.Lambda.Powertools.Logging.Serializers;
 
 namespace AWS.Lambda.Powertools.Logging.Internal.Converters;
 
@@ -57,15 +58,13 @@
     public override void Write(Utf8JsonWriter writer, Exception value, JsonSerializerOptions options)
     {
         var exceptionType = value.GetType();
-        var properties = exceptionType.GetProperties()
-            .Where(prop => prop.Name != nameof(Exception.TargetSite))
-            .Select(prop => new { prop.Name, Value = prop.GetValue(value) });
+        var properties = ExceptionPropertyExtractor.ExtractProperties(value);
 
         if (options.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingNull)
             properties = properties.Where(prop => prop.Value != null);
 
         var props = properties.ToArray();
-        if (!props.Any())
+        if (props.Length == 0)
             return;
 
         writer.WriteStartObject();
@@ -76,17 +75,16 @@
             switch (prop.Value)
             {
                 case IntPtr intPtr:
-                    writer.WriteNumber(ApplyPropertyNamingPolicy(prop.Name, options), intPtr.ToInt64());
+                    writer.WriteNumber(ApplyPropertyNamingPolicy(prop.Key, options), intPtr.ToInt64());
                     break;
                 case UIntPtr uIntPtr:
-                    writer.WriteNumber(ApplyPropertyNamingPolicy(prop.Name, options), uIntPtr.ToUInt64());
+                    writer.WriteNumber(ApplyPropertyNamingPolicy(prop.Key, options), uIntPtr.ToUInt64());
                     break;
                 case Type propType:
-                    writer.WriteString(ApplyPropertyNamingPolicy(prop.Name, options), propType.FullName);
+                    writer.WriteString(ApplyPropertyNamingPolicy(prop.Key, options), propType.FullName);
                     break;
-                default:
-                    writer.WritePropertyName(ApplyPropertyNamingPolicy(prop.Name, options));
-                    JsonSerializer.Serialize(writer, prop.Value, options);
+                case string propString:
+                    writer.WriteString(ApplyPropertyNamingPolicy(prop.Key, options), propString);
                     break;
             }
         }

libraries/src/AWS.Lambda.Powertools.Logging/Internal/Converters/ExceptionPropertyExtractor.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+
+namespace AWS.Lambda.Powertools.Logging.Internal.Converters;
+
+/// <summary>
+///     Class ExceptionPropertyExtractor.
+///     This class is used to extract properties from an exception object.
+///     It uses a dictionary of type to function mappings to extract specific properties based on the exception type.
+///     If no specific extractor is found, it falls back to the base Exception extractor.
+/// </summary>
+internal static class ExceptionPropertyExtractor
+{
+    /// <summary>
+    ///     The property extractors
+    /// </summary>
+    private static readonly Dictionary<Type, Func<Exception, IEnumerable<KeyValuePair<string, object>>>> PropertyExtractors = new()
+    {
+        { typeof(Exception), GetBaseExceptionProperties },
+    };
+
+    /// <summary>
+    /// Use this method to extract properties from and Exception based type
+    /// This method is used when building for native AOT    
+    /// </summary>
+    /// <param name="exception"></param>
+    /// <returns></returns>
+    public static IEnumerable<KeyValuePair<string, object>> ExtractProperties(Exception exception)
+    {
+        return GetBaseExceptionProperties(exception);
+    }
+
+    /// <summary>
+    /// Get the base Exception properties
+    /// </summary>
+    /// <param name="ex"></param>
+    /// <returns></returns>
+    private static IEnumerable<KeyValuePair<string, object>> GetBaseExceptionProperties(Exception ex)
+    {
+        yield return new KeyValuePair<string, object>(nameof(Exception.Message), ex.Message);
+        yield return new KeyValuePair<string, object>(nameof(Exception.Source), ex.Source);
+        yield return new KeyValuePair<string, object>(nameof(Exception.StackTrace), ex.StackTrace);
+    }
+}

libraries/src/AWS.Lambda.Powertools.Logging/Internal/Helpers/PowertoolsLoggerHelpers.cs

@@ -0,0 +1,43 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+using System.Linq;
+
+namespace AWS.Lambda.Powertools.Logging.Internal.Helpers;
+
+/// <summary>
+/// Class PowertoolsLoggerHelpers.
+/// </summary>
+internal static class PowertoolsLoggerHelpers
+{
+    /// <summary>
+    /// Converts an object to a dictionary.
+    /// </summary>
+    /// <param name="anonymousObject">The object to convert.</param>
+    /// <returns>
+    /// If the object has a namespace, returns the object as-is.
+    /// Otherwise, returns a dictionary representation of the object's properties.
+    /// </returns>
+    internal static object ObjectToDictionary(object anonymousObject)
+    {
+        if (anonymousObject.GetType().Namespace is not null)
+        {
+            return anonymousObject;
+        }
+
+        return anonymousObject.GetType().GetProperties()
+            .ToDictionary(prop => prop.Name, prop => ObjectToDictionary(prop.GetValue(anonymousObject, null)));
+    }
+}