chore: Logging AOT Support

docs/core/logging.md

@@ -11,6 +11,7 @@ The logging utility provides a Lambda optimized logger with output structured as
 * Log Lambda event when instructed (disabled by default)
 * Log sampling enables DEBUG log level for a percentage of requests (disabled by default)
 * Append additional keys to structured log at any point in time
+* Ahead-of-Time compilation to native code support [AOT](https://docs.aws.amazon.com/lambda/latest/dg/dotnet-native-aot.html) from version 1.6.0
 
 ## Installation
 
@@ -22,6 +23,12 @@ Powertools for AWS Lambda (.NET) are available as NuGet packages. You can instal
 
 ## Getting started
 
+!!! info
+
+    AOT Support
+    If loooking for AOT specific configurations navigate to the [AOT section](#aot-support)    
+
+
 Logging requires two settings:
 
 Setting | Description | Environment variable | Attribute parameter
@@ -166,6 +173,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"
@@ -656,3 +667,127 @@ You can customize the structure (keys and values) of your log entries by impleme
         }
     }
     ```
+
+## AOT Support
+
+Logging utility supports native AOT serialization by default without any changes needed.
+
+!!! info
+
+    In case you want to use the `LogEvent`, `Custom Log Formatter` features or serialize your own types when Logging events it is required 
+    that you do some changes in your Lambda `Main` method.
+
+### Configure
+
+The change needed is to replace `SourceGeneratorLambdaJsonSerializer` with `PowertoolsSourceGeneratorSerializer`. 
+
+This change enables Powertools to construct an instance of JsonSerializerOptions that is used to customize the serialization and deserialization of the Lambda JSON events and your own types.
+
+=== "Before"
+
+    ```csharp
+     Func<APIGatewayHttpApiV2ProxyRequest, ILambdaContext, Task<APIGatewayHttpApiV2ProxyResponse>> handler = FunctionHandler;
+     await LambdaBootstrapBuilder.Create(handler, new SourceGeneratorLambdaJsonSerializer<MyCustomJsonSerializerContext>())
+         .Build()
+         .RunAsync();
+    ```
+
+=== "After"
+
+    ```csharp hl_lines="2"
+    Func<APIGatewayHttpApiV2ProxyRequest, ILambdaContext, Task<APIGatewayHttpApiV2ProxyResponse>> handler = FunctionHandler;
+    await LambdaBootstrapBuilder.Create(handler, new PowertoolsSourceGeneratorSerializer<MyCustomJsonSerializerContext>())
+        .Build()
+        .RunAsync();
+    ```
+
+For example when you have your own Demo type 
+
+```csharp
+public class Demo
+{
+    public string Name { get; set; }
+    public Headers Headers { get; set; }
+}
+```
+
+To be able to serialize it in AOT you have to have your own `JsonSerializerContext`
+
+```csharp
+[JsonSerializable(typeof(APIGatewayHttpApiV2ProxyRequest))]
+[JsonSerializable(typeof(APIGatewayHttpApiV2ProxyResponse))]
+[JsonSerializable(typeof(Demo))]
+public partial class MyCustomJsonSerializerContext : JsonSerializerContext
+{
+}
+```
+
+When you change to `PowertoolsSourceGeneratorSerializer<MyCustomJsonSerializerContext>` we are 
+combining your `JsonSerializerContext` types with Powertools `JsonSerializerContext`. This allows Powertools to serialize your types and Lambda events.
+
+### Custom Log Formatter
+
+To be able to use a custom log formatter with AOT we need to pass an instance of ` ILogFormatter` to `PowertoolsSourceGeneratorSerializer` 
+instead of using the static `Logger.UseFormatter` in the Function contructor.
+
+=== "Function Main method"
+
+    ```csharp hl_lines="5"
+
+    Func<APIGatewayHttpApiV2ProxyRequest, ILambdaContext, Task<APIGatewayHttpApiV2ProxyResponse>> handler = FunctionHandler;
+    await LambdaBootstrapBuilder.Create(handler, 
+        new PowertoolsSourceGeneratorSerializer<LambdaFunctionJsonSerializerContext>
+        ( 
+            new CustomLogFormatter()
+        )
+    )
+    .Build()
+    .RunAsync();
+
+    ```
+
+=== "CustomLogFormatter.cs"
+
+    ```csharp
+    public class CustomLogFormatter : ILogFormatter
+    {
+        public object FormatLogEntry(LogEntry logEntry)
+        {
+            return new
+            {
+                Message = logEntry.Message,
+                Service = logEntry.Service,
+                CorrelationIds = new
+                {
+                    AwsRequestId = logEntry.LambdaContext?.AwsRequestId,
+                    XRayTraceId = logEntry.XRayTraceId,
+                    CorrelationId = logEntry.CorrelationId
+                },
+                LambdaFunction = new
+                {
+                    Name = logEntry.LambdaContext?.FunctionName,
+                    Arn = logEntry.LambdaContext?.InvokedFunctionArn,
+                    MemoryLimitInMB = logEntry.LambdaContext?.MemoryLimitInMB,
+                    Version = logEntry.LambdaContext?.FunctionVersion,
+                    ColdStart = logEntry.ColdStart,
+                },
+                Level = logEntry.Level.ToString(),
+                Timestamp = logEntry.Timestamp.ToString("o"),
+                Logger = new
+                {
+                Name = logEntry.Name,
+                SampleRate = logEntry.SamplingRate
+                },
+            };
+        }
+    }
+    ```
+
+### Anonymous types
+
+!!! note
+
+    Although we support anonymous type serialization by converting to a `Dictionary<string, object>`, 
+    this is not a best practice and is not recommendede when using native AOT. 
+
+    Recommendation is to use concrete classes and add them to your `JsonSerializerContext`.

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;
             }
         }