refactor and more test coverage

Author: hjgraca

libraries/src/AWS.Lambda.Powertools.Tracing/Internal/XRayRecorder.cs

@@ -137,7 +137,6 @@ public void EndSubsegment()
         catch (Exception e) when (IsSerializationError(e))
         {
             // This is a JSON serialization error - handle it aggressively
-            Console.WriteLine("JSON serialization error detected in Tracing utility - attempting recovery");
             Console.WriteLine($"Error: {e.Message}");
 
             HandleSerializationError(e);
@@ -191,16 +190,12 @@ private void HandleSerializationError(Exception originalException)
         try
         {
             // Strategy 1: Try to clear and recreate with minimal data
-            Console.WriteLine("Attempting serialization error recovery - Strategy 1: Clear and recreate");
-
             _awsxRayRecorder.TraceContext.ClearEntity();
             _awsxRayRecorder.BeginSubsegment("Tracing_Sanitized");
             _awsxRayRecorder.AddAnnotation("SerializationError", true);
             _awsxRayRecorder.AddMetadata("Error", "Type", "JSON Serialization Error");
             _awsxRayRecorder.AddMetadata("Error", "Message", SanitizeValueForMetadata(originalException.Message));
             _awsxRayRecorder.EndSubsegment();
-
-            Console.WriteLine("Serialization error recovery successful");
         }
         catch (Exception e2)
         {
@@ -213,8 +208,6 @@ private void HandleSerializationError(Exception originalException)
                 _awsxRayRecorder.BeginSubsegment("Tracing_Error");
                 _awsxRayRecorder.AddAnnotation("Error", "SerializationFailed");
                 _awsxRayRecorder.EndSubsegment();
-
-                Console.WriteLine("Minimal serialization error recovery successful");
             }
             catch (Exception e3)
             {
@@ -388,7 +381,7 @@ private static object SanitizeValueRecursive(object value, int depth)
             return collectionResult;
 
         // Handle complex objects
-        return SanitizeComplexObject(value, type, depth);
+        return SanitizeComplexObject(value, type);
     }
 
     /// <summary>
@@ -557,13 +550,11 @@ private static object SanitizeEnumerable(System.Collections.IEnumerable enumerab
     /// </summary>
     /// <param name="value">The object to sanitize</param>
     /// <param name="type">The object type</param>
-    /// <param name="depth">Current recursion depth</param>
     /// <returns>Sanitized string representation</returns>
-    private static object SanitizeComplexObject(object value, Type type, int depth)
+    private static object SanitizeComplexObject(object value, Type type)
     {
         try
         {
-            // For Native AOT compatibility, we avoid reflection and convert to string
             // This ensures the object can be serialized without issues
             return $"[{type.Name}] {value.ToString()}";
         }

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/EntityLevelSanitizationTests.cs

@@ -153,4 +153,132 @@ public void SanitizeCurrentEntitySafely_WithComplexProblematicData_HandlesAllSce
             Assert.Fail($"EndSubsegment with null entity should not throw: {ex.Message}");
         }
     }
+
+    [Fact]
+    public void SanitizeCurrentEntitySafely_WithProblematicData_SanitizesSuccessfully()
+    {
+        // Arrange
+        var mockAwsXRayRecorder = Substitute.For<IAWSXRayRecorder>();
+        var mockConfigurations = Substitute.For<IPowertoolsConfigurations>();
+        mockConfigurations.IsLambdaEnvironment.Returns(true);
+        
+        // Create a real subsegment to test actual sanitization
+        var subsegment = new Subsegment("TestSegment");
+        
+        // Add problematic data to the subsegment (only metadata, not annotations with DateTime)
+        subsegment.AddMetadata("test", "problematic_ulong", 42ul);
+        subsegment.AddMetadata("test", "problematic_guid", Guid.NewGuid());
+        subsegment.AddMetadata("test", "problematic_datetime", DateTime.Now);
+        subsegment.AddAnnotation("safe_annotation", "safe_value");
+        
+        var mockTraceContext = Substitute.For<Amazon.XRay.Recorder.Core.Internal.Context.ITraceContext>();
+        mockTraceContext.GetEntity().Returns(subsegment);
+        mockAwsXRayRecorder.TraceContext.Returns(mockTraceContext);
+        
+        var recorder = new XRayRecorder(mockAwsXRayRecorder, mockConfigurations);
+
+        // Act & Assert - Should not throw
+        try
+        {
+            recorder.EndSubsegment();
+            
+            // Verify that EndSubsegment was called
+            mockAwsXRayRecorder.Received(1).EndSubsegment();
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"EndSubsegment with problematic data should not throw: {ex.Message}");
+        }
+    }
+
+    [Fact]
+    public void SanitizeEntityMetadata_WithReflectionFailure_HandlesGracefully()
+    {
+        // Arrange
+        var mockAwsXRayRecorder = Substitute.For<IAWSXRayRecorder>();
+        var mockConfigurations = Substitute.For<IPowertoolsConfigurations>();
+        mockConfigurations.IsLambdaEnvironment.Returns(true);
+        
+        // Create a subsegment and make GetEntity throw an exception to simulate reflection failure
+        var mockTraceContext = Substitute.For<Amazon.XRay.Recorder.Core.Internal.Context.ITraceContext>();
+        mockTraceContext.GetEntity().Returns(x => throw new Exception("Reflection error"));
+        mockAwsXRayRecorder.TraceContext.Returns(mockTraceContext);
+        
+        var recorder = new XRayRecorder(mockAwsXRayRecorder, mockConfigurations);
+
+        // Act & Assert - Should not throw
+        try
+        {
+            recorder.EndSubsegment();
+            
+            // Verify that EndSubsegment was still called despite the reflection error
+            mockAwsXRayRecorder.Received(1).EndSubsegment();
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"EndSubsegment with reflection failure should not throw: {ex.Message}");
+        }
+    }
+
+    [Fact]
+    public void SanitizeEntityAnnotations_WithNullAnnotations_HandlesGracefully()
+    {
+        // Arrange
+        var mockAwsXRayRecorder = Substitute.For<IAWSXRayRecorder>();
+        var mockConfigurations = Substitute.For<IPowertoolsConfigurations>();
+        mockConfigurations.IsLambdaEnvironment.Returns(true);
+        
+        // Create a subsegment with null annotations property (simulated)
+        var subsegment = new Subsegment("TestSegment");
+        
+        var mockTraceContext = Substitute.For<Amazon.XRay.Recorder.Core.Internal.Context.ITraceContext>();
+        mockTraceContext.GetEntity().Returns(subsegment);
+        mockAwsXRayRecorder.TraceContext.Returns(mockTraceContext);
+        
+        var recorder = new XRayRecorder(mockAwsXRayRecorder, mockConfigurations);
+
+        // Act & Assert - Should not throw
+        try
+        {
+            recorder.EndSubsegment();
+            
+            // Verify that EndSubsegment was called
+            mockAwsXRayRecorder.Received(1).EndSubsegment();
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"EndSubsegment with null annotations should not throw: {ex.Message}");
+        }
+    }
+
+    [Fact]
+    public void SanitizeEntityHttpInformation_WithNullHttp_HandlesGracefully()
+    {
+        // Arrange
+        var mockAwsXRayRecorder = Substitute.For<IAWSXRayRecorder>();
+        var mockConfigurations = Substitute.For<IPowertoolsConfigurations>();
+        mockConfigurations.IsLambdaEnvironment.Returns(true);
+        
+        // Create a subsegment with null HTTP property (simulated)
+        var subsegment = new Subsegment("TestSegment");
+        
+        var mockTraceContext = Substitute.For<Amazon.XRay.Recorder.Core.Internal.Context.ITraceContext>();
+        mockTraceContext.GetEntity().Returns(subsegment);
+        mockAwsXRayRecorder.TraceContext.Returns(mockTraceContext);
+        
+        var recorder = new XRayRecorder(mockAwsXRayRecorder, mockConfigurations);
+
+        // Act & Assert - Should not throw
+        try
+        {
+            recorder.EndSubsegment();
+            
+            // Verify that EndSubsegment was called
+            mockAwsXRayRecorder.Received(1).EndSubsegment();
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"EndSubsegment with null HTTP info should not throw: {ex.Message}");
+        }
+    }
 }