Merge pull request #704 from hjgraca/fix(logging)-service-name-override

hjgraca · web-flow · commit 84765d095abd · 2025-01-27T10:11:29.000Z
chore: Fix Service override on decorator
diff --git a/libraries/src/AWS.Lambda.Powertools.Logging/Internal/LoggingAspect.cs b/libraries/src/AWS.Lambda.Powertools.Logging/Internal/LoggingAspect.cs
@@ -138,7 +138,7 @@ public void OnEntry(
             _correlationIdPath = trigger.CorrelationIdPath;
             _clearState = trigger.ClearState;
 
-            Logger.LoggerProvider ??= new LoggerProvider(_config, _powertoolsConfigurations, _systemWrapper);
+            Logger.LoggerProvider = new LoggerProvider(_config, _powertoolsConfigurations, _systemWrapper);
 
             if (!_initializeContext)
                 return;
diff --git a/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/Attributes/LoggingAttributeTest.cs b/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/Attributes/LoggingAttributeTest.cs
@@ -471,10 +471,72 @@ public void Should_Log_When_Not_Using_Decorator()
                 Arg.Is<string>(i => i.Contains("\"level\":\"Information\",\"service\":\"service_undefined\",\"name\":\"AWS.Lambda.Powertools.Logging.Logger\",\"message\":\"test\"}"))
             );
         }
+        
+        public void Dispose()
+        {
+            Environment.SetEnvironmentVariable("POWERTOOLS_LOGGER_CASE", "");
+            Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "");
+            LoggingAspect.ResetForTest();
+            PowertoolsLoggingSerializer.ClearOptions();
+        }
+    }
+    
+    [Collection("A Sequential")]
+    public class ServiceTests : IDisposable
+    {
+        private readonly TestServiceHandler _testHandler;
+        
+        public ServiceTests()
+        {
+            _testHandler = new TestServiceHandler();
+        }
+        
+        [Fact]
+        public void When_Setting_Service_Should_Override_Env()
+        {
+            // Arrange
+            var consoleOut = Substitute.For<StringWriter>();
+            SystemWrapper.Instance.SetOut(consoleOut);
+
+            // Act
+            _testHandler.LogWithEnv();
+            _testHandler.Handler();
+        
+            // Assert
+        
+            consoleOut.Received(1).WriteLine(
+                Arg.Is<string>(i => i.Contains("\"level\":\"Information\",\"service\":\"Environment Service\",\"name\":\"AWS.Lambda.Powertools.Logging.Logger\",\"message\":\"Service: Environment Service\""))
+            );
+            consoleOut.Received(1).WriteLine(
+                Arg.Is<string>(i => i.Contains("\"level\":\"Information\",\"service\":\"Attribute Service\",\"name\":\"AWS.Lambda.Powertools.Logging.Logger\",\"message\":\"Service: Attribute Service\""))
+            );            
+        }
+        
+        [Fact]
+        public void When_Setting_Service_Should_Override_Env_And_Empty()
+        {
+            // Arrange
+            var consoleOut = Substitute.For<StringWriter>();
+            SystemWrapper.Instance.SetOut(consoleOut);
+
+            // Act
+            _testHandler.LogWithAndWithoutEnv();
+            _testHandler.Handler();
+        
+            // Assert
+            
+            consoleOut.Received(2).WriteLine(
+                Arg.Is<string>(i => i.Contains("\"level\":\"Information\",\"service\":\"service_undefined\",\"name\":\"AWS.Lambda.Powertools.Logging.Logger\",\"message\":\"Service: service_undefined\""))
+            );
+            consoleOut.Received(1).WriteLine(
+                Arg.Is<string>(i => i.Contains("\"level\":\"Information\",\"service\":\"Attribute Service\",\"name\":\"AWS.Lambda.Powertools.Logging.Logger\",\"message\":\"Service: Attribute Service\""))
+            );            
+        }
 
         public void Dispose()
         {
             Environment.SetEnvironmentVariable("POWERTOOLS_LOGGER_CASE", "");
+            Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "");
             LoggingAspect.ResetForTest();
             PowertoolsLoggingSerializer.ClearOptions();
         }
diff --git a/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/Handlers/TestHandlers.cs b/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/Handlers/TestHandlers.cs
@@ -13,6 +13,7 @@
  * permissions and limitations under the License.
  */
 
+using System;
 using System.Text.Json.Serialization;
 using Amazon.Lambda.APIGatewayEvents;
 using Amazon.Lambda.ApplicationLoadBalancerEvents;
@@ -40,12 +41,13 @@ public void TestMethodDebug()
     public void LogEventNoArgs()
     {
     }
-    
-    [Logging(LogEvent = true, LoggerOutputCase = LoggerOutputCase.PascalCase, CorrelationIdPath = "/Headers/MyRequestIdHeader")]
+
+    [Logging(LogEvent = true, LoggerOutputCase = LoggerOutputCase.PascalCase,
+        CorrelationIdPath = "/Headers/MyRequestIdHeader")]
     public void LogEvent(TestObject testObject, ILambdaContext context)
     {
     }
-    
+
     [Logging(LogEvent = false)]
     public void LogEventFalse(ILambdaContext context)
     {
@@ -81,104 +83,129 @@ public void CorrelationCloudWatchEvent(CloudWatchEvent<S3ObjectCreate> cwEvent)
     public void CorrelationIdFromString(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/headers/my_request_id_header")]
     public void CorrelationIdFromStringSnake(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/Headers/MyRequestIdHeader", LoggerOutputCase = LoggerOutputCase.PascalCase)]
     public void CorrelationIdFromStringPascal(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/headers/myRequestIdHeader", LoggerOutputCase = LoggerOutputCase.CamelCase)]
     public void CorrelationIdFromStringCamel(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/headers/my_request_id_header")]
     public void CorrelationIdFromStringSnakeEnv(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/Headers/MyRequestIdHeader")]
     public void CorrelationIdFromStringPascalEnv(TestObject testObject)
     {
     }
-        
+
     [Logging(CorrelationIdPath = "/headers/myRequestIdHeader")]
     public void CorrelationIdFromStringCamelEnv(TestObject testObject)
     {
     }
-        
+
     [Logging(Service = "test", LoggerOutputCase = LoggerOutputCase.CamelCase)]
     public void HandlerService()
     {
         Logger.LogInformation("test");
     }
-        
+
     [Logging(SamplingRate = 0.5, LoggerOutputCase = LoggerOutputCase.CamelCase, LogLevel = LogLevel.Information)]
     public void HandlerSamplingRate()
     {
         Logger.LogInformation("test");
     }
-    
+
     [Logging(LogLevel = LogLevel.Critical)]
     public void TestLogLevelCritical()
     {
         Logger.LogCritical("test");
     }
-    
+
     [Logging(LogLevel = LogLevel.Critical, LogEvent = true)]
     public void TestLogLevelCriticalLogEvent(ILambdaContext context)
     {
     }
-    
+
     [Logging(LogLevel = LogLevel.Debug, LogEvent = true)]
     public void TestLogEventWithoutContext()
     {
     }
-    
+
     [Logging(LogEvent = true, SamplingRate = 0.2, Service = "my_service")]
     public void TestCustomFormatterWithDecorator(string input, ILambdaContext context)
     {
     }
-    
+
     [Logging(LogEvent = true, SamplingRate = 0.2, Service = "my_service")]
     public void TestCustomFormatterWithDecoratorNoContext(string input)
     {
     }
-    
+
     public void TestCustomFormatterNoDecorator(string input, ILambdaContext context)
     {
         Logger.LogInformation(input);
     }
-    
+
     public void TestLogNoDecorator()
     {
         Logger.LogInformation("test");
     }
-    
+
     [Logging(Service = "test", LoggerOutputCase = LoggerOutputCase.SnakeCase)]
     public void TestEnums(string input, ILambdaContext context)
     {
         Logger.LogInformation(Pet.Dog);
         Logger.LogInformation(Thing.Five);
     }
-    
+
     public enum Thing
     {
         One = 1,
         Three = 3,
         Five = 5
     }
-    
+
     [JsonConverter(typeof(JsonStringEnumConverter))]
     public enum Pet
     {
         Cat = 1,
         Dog = 3,
         Lizard = 5
     }
+}
+
+public class TestServiceHandler
+{
+    public void LogWithEnv()
+    {
+        Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "Environment Service");
+        
+        Logger.LogInformation("Service: Environment Service");
+    }
+    
+    public void LogWithAndWithoutEnv()
+    {
+        Logger.LogInformation("Service: service_undefined");
+        
+        Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "Environment Service");
+        
+        Logger.LogInformation("Service: service_undefined");
+    }
+
+    [Logging(Service = "Attribute Service")]
+    public void Handler()
+    {
+        Logger.LogInformation("Service: Attribute Service");
+    }
 }
diff --git a/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/PowertoolsLoggerTest.cs b/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/PowertoolsLoggerTest.cs
@@ -29,7 +29,7 @@
 
 namespace AWS.Lambda.Powertools.Logging.Tests
 {
-    [Collection("Sequential")]
+    [Collection("X Sequential")]
     public class PowertoolsLoggerTest : IDisposable
     {
         public PowertoolsLoggerTest()
@@ -1337,6 +1337,8 @@ public void Log_WhenMemoryStream_LogsBase64String_UnsafeRelaxedJsonEscaping()
         [Fact]
         public void Log_Set_Execution_Environment_Context()
         {
+            var _originalValue = Environment.GetEnvironmentVariable("POWERTOOLS_SERVICE_NAME");
+            
             // Arrange
             var loggerName = Guid.NewGuid().ToString();
             var assemblyName = "AWS.Lambda.Powertools.Logger";
@@ -1707,6 +1709,7 @@ public void Log_Should_Use_Powertools_Log_Level_When_Set(bool willLog, LogLevel
         public void Dispose()
         {
             PowertoolsLoggingSerializer.ClearOptions();
+            LoggingAspect.ResetForTest();
         }
     }
 }
diff --git a/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/TestSetup.cs b/libraries/tests/AWS.Lambda.Powertools.Logging.Tests/TestSetup.cs
@@ -13,6 +13,21 @@
  * permissions and limitations under the License.
  */
 
+using System.Collections.Generic;
+using System.Linq;
 using Xunit;
+using Xunit.Abstractions;
 
-[assembly: CollectionBehavior(DisableTestParallelization = true)]
+[assembly: TestCollectionOrderer("AWS.Lambda.Powertools.Logging.Tests.DisplayNameOrderer", "AWS.Lambda.Powertools.Logging.Tests")]
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
+
+
+namespace AWS.Lambda.Powertools.Logging.Tests;
+
+public class DisplayNameOrderer : ITestCollectionOrderer
+{
+    public IEnumerable<ITestCollection> OrderTestCollections(IEnumerable<ITestCollection> testCollections)
+    {
+        return testCollections.OrderBy(collection => collection.DisplayName);
+    }
+}
diff --git a/libraries/tests/e2e/functions/core/logging/Function/test/Function.Tests/FunctionTests.cs b/libraries/tests/e2e/functions/core/logging/Function/test/Function.Tests/FunctionTests.cs
@@ -23,7 +23,7 @@ public FunctionTests(ITestOutputHelper testOutputHelper)
     [Trait("Category", "AOT")]
     [Theory]
     [InlineData("E2ETestLambda_X64_AOT_NET8_logging")]
-    // [InlineData("E2ETestLambda_ARM_AOT_NET8_metrics")]
+    [InlineData("E2ETestLambda_ARM_AOT_NET8_logging")]
     public async Task AotFunctionTest(string functionName)
     {
         await TestFunction(functionName);

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`* permissions and limitations under the License.`
`14`	`14`	`*/`
`15`	`15`
	`16`	`+using System;`
`16`	`17`	`using System.Text.Json.Serialization;`
`17`	`18`	`using Amazon.Lambda.APIGatewayEvents;`
`18`	`19`	`using Amazon.Lambda.ApplicationLoadBalancerEvents;`
`@@ -40,12 +41,13 @@ public void TestMethodDebug()`
`40`	`41`	`public void LogEventNoArgs()`
`41`	`42`	`{`
`42`	`43`	`}`
`43`		`-`
`44`		`- [Logging(LogEvent = true, LoggerOutputCase = LoggerOutputCase.PascalCase, CorrelationIdPath = "/Headers/MyRequestIdHeader")]`
	`44`	`+`
	`45`	`+ [Logging(LogEvent = true, LoggerOutputCase = LoggerOutputCase.PascalCase,`
	`46`	`+ CorrelationIdPath = "/Headers/MyRequestIdHeader")]`
`45`	`47`	`public void LogEvent(TestObject testObject, ILambdaContext context)`
`46`	`48`	`{`
`47`	`49`	`}`
`48`		`-`
	`50`	`+`
`49`	`51`	`[Logging(LogEvent = false)]`
`50`	`52`	`public void LogEventFalse(ILambdaContext context)`
`51`	`53`	`{`
`@@ -81,104 +83,129 @@ public void CorrelationCloudWatchEvent(CloudWatchEvent<S3ObjectCreate> cwEvent)`
`81`	`83`	`public void CorrelationIdFromString(TestObject testObject)`
`82`	`84`	`{`
`83`	`85`	`}`
`84`		`-`
	`86`	`+`
`85`	`87`	`[Logging(CorrelationIdPath = "/headers/my_request_id_header")]`
`86`	`88`	`public void CorrelationIdFromStringSnake(TestObject testObject)`
`87`	`89`	`{`
`88`	`90`	`}`
`89`		`-`
	`91`	`+`
`90`	`92`	`[Logging(CorrelationIdPath = "/Headers/MyRequestIdHeader", LoggerOutputCase = LoggerOutputCase.PascalCase)]`
`91`	`93`	`public void CorrelationIdFromStringPascal(TestObject testObject)`
`92`	`94`	`{`
`93`	`95`	`}`
`94`		`-`
	`96`	`+`
`95`	`97`	`[Logging(CorrelationIdPath = "/headers/myRequestIdHeader", LoggerOutputCase = LoggerOutputCase.CamelCase)]`
`96`	`98`	`public void CorrelationIdFromStringCamel(TestObject testObject)`
`97`	`99`	`{`
`98`	`100`	`}`
`99`		`-`
	`101`	`+`
`100`	`102`	`[Logging(CorrelationIdPath = "/headers/my_request_id_header")]`
`101`	`103`	`public void CorrelationIdFromStringSnakeEnv(TestObject testObject)`
`102`	`104`	`{`
`103`	`105`	`}`
`104`		`-`
	`106`	`+`
`105`	`107`	`[Logging(CorrelationIdPath = "/Headers/MyRequestIdHeader")]`
`106`	`108`	`public void CorrelationIdFromStringPascalEnv(TestObject testObject)`
`107`	`109`	`{`
`108`	`110`	`}`
`109`		`-`
	`111`	`+`
`110`	`112`	`[Logging(CorrelationIdPath = "/headers/myRequestIdHeader")]`
`111`	`113`	`public void CorrelationIdFromStringCamelEnv(TestObject testObject)`
`112`	`114`	`{`
`113`	`115`	`}`
`114`		`-`
	`116`	`+`
`115`	`117`	`[Logging(Service = "test", LoggerOutputCase = LoggerOutputCase.CamelCase)]`
`116`	`118`	`public void HandlerService()`
`117`	`119`	`{`
`118`	`120`	`Logger.LogInformation("test");`
`119`	`121`	`}`
`120`		`-`
	`122`	`+`
`121`	`123`	`[Logging(SamplingRate = 0.5, LoggerOutputCase = LoggerOutputCase.CamelCase, LogLevel = LogLevel.Information)]`
`122`	`124`	`public void HandlerSamplingRate()`
`123`	`125`	`{`
`124`	`126`	`Logger.LogInformation("test");`
`125`	`127`	`}`
`126`		`-`
	`128`	`+`
`127`	`129`	`[Logging(LogLevel = LogLevel.Critical)]`
`128`	`130`	`public void TestLogLevelCritical()`
`129`	`131`	`{`
`130`	`132`	`Logger.LogCritical("test");`
`131`	`133`	`}`
`132`		`-`
	`134`	`+`
`133`	`135`	`[Logging(LogLevel = LogLevel.Critical, LogEvent = true)]`
`134`	`136`	`public void TestLogLevelCriticalLogEvent(ILambdaContext context)`
`135`	`137`	`{`
`136`	`138`	`}`
`137`		`-`
	`139`	`+`
`138`	`140`	`[Logging(LogLevel = LogLevel.Debug, LogEvent = true)]`
`139`	`141`	`public void TestLogEventWithoutContext()`
`140`	`142`	`{`
`141`	`143`	`}`
`142`		`-`
	`144`	`+`
`143`	`145`	`[Logging(LogEvent = true, SamplingRate = 0.2, Service = "my_service")]`
`144`	`146`	`public void TestCustomFormatterWithDecorator(string input, ILambdaContext context)`
`145`	`147`	`{`
`146`	`148`	`}`
`147`		`-`
	`149`	`+`
`148`	`150`	`[Logging(LogEvent = true, SamplingRate = 0.2, Service = "my_service")]`
`149`	`151`	`public void TestCustomFormatterWithDecoratorNoContext(string input)`
`150`	`152`	`{`
`151`	`153`	`}`
`152`		`-`
	`154`	`+`
`153`	`155`	`public void TestCustomFormatterNoDecorator(string input, ILambdaContext context)`
`154`	`156`	`{`
`155`	`157`	`Logger.LogInformation(input);`
`156`	`158`	`}`
`157`		`-`
	`159`	`+`
`158`	`160`	`public void TestLogNoDecorator()`
`159`	`161`	`{`
`160`	`162`	`Logger.LogInformation("test");`
`161`	`163`	`}`
`162`		`-`
	`164`	`+`
`163`	`165`	`[Logging(Service = "test", LoggerOutputCase = LoggerOutputCase.SnakeCase)]`
`164`	`166`	`public void TestEnums(string input, ILambdaContext context)`
`165`	`167`	`{`
`166`	`168`	`Logger.LogInformation(Pet.Dog);`
`167`	`169`	`Logger.LogInformation(Thing.Five);`
`168`	`170`	`}`
`169`		`-`
	`171`	`+`
`170`	`172`	`public enum Thing`
`171`	`173`	`{`
`172`	`174`	`One = 1,`
`173`	`175`	`Three = 3,`
`174`	`176`	`Five = 5`
`175`	`177`	`}`
`176`		`-`
	`178`	`+`
`177`	`179`	`[JsonConverter(typeof(JsonStringEnumConverter))]`
`178`	`180`	`public enum Pet`
`179`	`181`	`{`
`180`	`182`	`Cat = 1,`
`181`	`183`	`Dog = 3,`
`182`	`184`	`Lizard = 5`
`183`	`185`	`}`
	`186`	`+}`
	`187`	`+`
	`188`	`+public class TestServiceHandler`
	`189`	`+{`
	`190`	`+ public void LogWithEnv()`
	`191`	`+ {`
	`192`	`+ Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "Environment Service");`
	`193`	`+`
	`194`	`+ Logger.LogInformation("Service: Environment Service");`
	`195`	`+ }`
	`196`	`+`
	`197`	`+ public void LogWithAndWithoutEnv()`
	`198`	`+ {`
	`199`	`+ Logger.LogInformation("Service: service_undefined");`
	`200`	`+`
	`201`	`+ Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "Environment Service");`
	`202`	`+`
	`203`	`+ Logger.LogInformation("Service: service_undefined");`
	`204`	`+ }`
	`205`	`+`
	`206`	`+ [Logging(Service = "Attribute Service")]`
	`207`	`+ public void Handler()`
	`208`	`+ {`
	`209`	`+ Logger.LogInformation("Service: Attribute Service");`
	`210`	`+ }`
`184`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@`
`29`	`29`
`30`	`30`	`namespace AWS.Lambda.Powertools.Logging.Tests`
`31`	`31`	`{`
`32`		`- [Collection("Sequential")]`
	`32`	`+ [Collection("X Sequential")]`
`33`	`33`	`public class PowertoolsLoggerTest : IDisposable`
`34`	`34`	`{`
`35`	`35`	`public PowertoolsLoggerTest()`
`@@ -1337,6 +1337,8 @@ public void Log_WhenMemoryStream_LogsBase64String_UnsafeRelaxedJsonEscaping()`
`1337`	`1337`	`[Fact]`
`1338`	`1338`	`public void Log_Set_Execution_Environment_Context()`
`1339`	`1339`	`{`
	`1340`	`+ var _originalValue = Environment.GetEnvironmentVariable("POWERTOOLS_SERVICE_NAME");`
	`1341`	`+`
`1340`	`1342`	`// Arrange`
`1341`	`1343`	`var loggerName = Guid.NewGuid().ToString();`
`1342`	`1344`	`var assemblyName = "AWS.Lambda.Powertools.Logger";`
`@@ -1707,6 +1709,7 @@ public void Log_Should_Use_Powertools_Log_Level_When_Set(bool willLog, LogLevel`
`1707`	`1709`	`public void Dispose()`
`1708`	`1710`	`{`
`1709`	`1711`	`PowertoolsLoggingSerializer.ClearOptions();`
	`1712`	`+ LoggingAspect.ResetForTest();`
`1710`	`1713`	`}`
`1711`	`1714`	`}`
`1712`	`1715`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public FunctionTests(ITestOutputHelper testOutputHelper)`
`23`	`23`	`[Trait("Category", "AOT")]`
`24`	`24`	`[Theory]`
`25`	`25`	`[InlineData("E2ETestLambda_X64_AOT_NET8_logging")]`
`26`		`- // [InlineData("E2ETestLambda_ARM_AOT_NET8_metrics")]`
	`26`	`+ [InlineData("E2ETestLambda_ARM_AOT_NET8_logging")]`
`27`	`27`	`public async Task AotFunctionTest(string functionName)`
`28`	`28`	`{`
`29`	`29`	`await TestFunction(functionName);`