diff --git a/libraries/src/AWS.Lambda.Powertools.Common/Core/ISystemWrapper.cs b/libraries/src/AWS.Lambda.Powertools.Common/Core/ISystemWrapper.cs
deleted file mode 100644
index a873dcfb..00000000
--- a/libraries/src/AWS.Lambda.Powertools.Common/Core/ISystemWrapper.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * 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.IO;
-
-namespace AWS.Lambda.Powertools.Common;
-
-/// <summary>
-///     Interface ISystemWrapper
-/// </summary>
-public interface ISystemWrapper
-{
-    /// <summary>
-    ///     Gets the environment variable.
-    /// </summary>
-    /// <param name="variable">The variable.</param>
-    /// <returns>System.String.</returns>
-    string GetEnvironmentVariable(string variable);
-
-    /// <summary>
-    ///     Logs the specified value.
-    /// </summary>
-    /// <param name="value">The value.</param>
-    void Log(string value);
-
-    /// <summary>
-    ///     Logs the line.
-    /// </summary>
-    /// <param name="value">The value.</param>
-    void LogLine(string value);
-
-    /// <summary>
-    ///     Gets random number
-    /// </summary>
-    /// <returns>System.Double.</returns>
-    double GetRandom();
-    
-    /// <summary>
-    ///     Sets the environment variable.
-    /// </summary>
-    /// <param name="variable">The variable.</param>
-    /// <param name="value"></param>
-    void SetEnvironmentVariable(string variable, string value);
-    
-    /// <summary>
-    /// Sets the execution Environment Variable (AWS_EXECUTION_ENV)
-    /// </summary>
-    /// <param name="type"></param>
-    void SetExecutionEnvironment<T>(T type);
-}
\ No newline at end of file
diff --git a/libraries/src/AWS.Lambda.Powertools.Common/Core/PowertoolsEnvironment.cs b/libraries/src/AWS.Lambda.Powertools.Common/Core/PowertoolsEnvironment.cs
index 649418a4..afc796b6 100644
--- a/libraries/src/AWS.Lambda.Powertools.Common/Core/PowertoolsEnvironment.cs
+++ b/libraries/src/AWS.Lambda.Powertools.Common/Core/PowertoolsEnvironment.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Text;
 
 namespace AWS.Lambda.Powertools.Common;
@@ -11,6 +12,16 @@ public class PowertoolsEnvironment : IPowertoolsEnvironment
     /// </summary>
     private static IPowertoolsEnvironment _instance;
     
+    /// <summary>
+    /// Cached runtime environment string
+    /// </summary>
+    private static readonly string CachedRuntimeEnvironment = $"PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major}";
+    
+    /// <summary>
+    /// Cache for parsed assembly names to avoid repeated string operations
+    /// </summary>
+    private static readonly ConcurrentDictionary<string, string> ParsedAssemblyNameCache = new();
+    
     /// <summary>
     ///     Gets the instance.
     /// </summary>
@@ -32,13 +43,28 @@ public void SetEnvironmentVariable(string variableName, string value)
     /// <inheritdoc />
     public string GetAssemblyName<T>(T type)
     {
+        if (type is Type typeObject)
+        {
+            return typeObject.Assembly.GetName().Name;
+        }
+        
         return type.GetType().Assembly.GetName().Name;
     }
 
     /// <inheritdoc />
     public string GetAssemblyVersion<T>(T type)
     {
-        var version = type.GetType().Assembly.GetName().Version;
+        Version version;
+        
+        if (type is Type typeObject)
+        {
+            version = typeObject.Assembly.GetName().Version;
+        }
+        else
+        {
+            version = type.GetType().Assembly.GetName().Version;
+        }
+        
         return version != null ? $"{version.Major}.{version.Minor}.{version.Build}" : string.Empty;
     }
     
@@ -46,27 +72,43 @@ public string GetAssemblyVersion<T>(T type)
     public void SetExecutionEnvironment<T>(T type)
     {
         const string envName = Constants.AwsExecutionEnvironmentVariableName;
-        var envValue = new StringBuilder();
         var currentEnvValue = GetEnvironmentVariable(envName);
         var assemblyName = ParseAssemblyName(GetAssemblyName(type));
 
-        // If there is an existing execution environment variable add the annotations package as a suffix.
-        if (!string.IsNullOrEmpty(currentEnvValue))
+        // Check for duplication early
+        if (!string.IsNullOrEmpty(currentEnvValue) && currentEnvValue.Contains(assemblyName))
         {
-            // Avoid duplication - should not happen since the calling Instances are Singletons - defensive purposes
-            if (currentEnvValue.Contains(assemblyName))
-            {
-                return;
-            }
-
-            envValue.Append($"{currentEnvValue} ");
+            return;
         }
 
         var assemblyVersion = GetAssemblyVersion(type);
+        var newEntry = $"{assemblyName}/{assemblyVersion}";
+        
+        string finalValue;
+        
+        if (string.IsNullOrEmpty(currentEnvValue))
+        {
+            // First entry: "PT/Assembly/1.0.0 PTENV/AWS_LAMBDA_DOTNET8"
+            finalValue = $"{newEntry} {CachedRuntimeEnvironment}";
+        }
+        else
+        {
+            // Check if PTENV already exists in one pass
+            var containsPtenv = currentEnvValue.Contains("PTENV/");
+            
+            if (containsPtenv)
+            {
+                // Just append the new entry: "existing PT/Assembly/1.0.0"
+                finalValue = $"{currentEnvValue} {newEntry}";
+            }
+            else
+            {
+                // Append new entry + PTENV: "existing PT/Assembly/1.0.0 PTENV/AWS_LAMBDA_DOTNET8"
+                finalValue = $"{currentEnvValue} {newEntry} {CachedRuntimeEnvironment}";
+            }
+        }
 
-        envValue.Append($"{assemblyName}/{assemblyVersion}");
-
-        SetEnvironmentVariable(envName, envValue.ToString());
+        SetEnvironmentVariable(envName, finalValue);
     }
     
     /// <summary>
@@ -75,18 +117,26 @@ public void SetExecutionEnvironment<T>(T type)
     /// </summary>
     /// <param name="assemblyName"></param>
     /// <returns></returns>
-    private string ParseAssemblyName(string assemblyName)
+    internal static string ParseAssemblyName(string assemblyName)
     {
+        // Use cache to avoid repeated string operations
         try
         {
-            var parsedName = assemblyName.Substring(assemblyName.LastIndexOf(".", StringComparison.Ordinal) + 1);
-            return $"{Constants.FeatureContextIdentifier}/{parsedName}";
+            return ParsedAssemblyNameCache.GetOrAdd(assemblyName, name =>
+            {
+                var lastDotIndex = name.LastIndexOf('.');
+                if (lastDotIndex >= 0 && lastDotIndex < name.Length - 1)
+                {
+                    var parsedName = name.Substring(lastDotIndex + 1);
+                    return $"{Constants.FeatureContextIdentifier}/{parsedName}";
+                }
+
+                return $"{Constants.FeatureContextIdentifier}/{name}";
+            });
         }
         catch
         {
-            //NOOP
+            return string.Empty;
         }
-
-        return $"{Constants.FeatureContextIdentifier}/{assemblyName}";
     }
-}
\ No newline at end of file
+}
diff --git a/libraries/src/AWS.Lambda.Powertools.Common/Core/SystemWrapper.cs b/libraries/src/AWS.Lambda.Powertools.Common/Core/SystemWrapper.cs
deleted file mode 100644
index faf71eeb..00000000
--- a/libraries/src/AWS.Lambda.Powertools.Common/Core/SystemWrapper.cs
+++ /dev/null
@@ -1,197 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-
-namespace AWS.Lambda.Powertools.Common;
-
-/// <summary>
-///     Class SystemWrapper.
-///     Implements the <see cref="ISystemWrapper" />
-/// </summary>
-/// <seealso cref="ISystemWrapper" />
-public class SystemWrapper : ISystemWrapper
-{
-    private static IPowertoolsEnvironment _powertoolsEnvironment;
-    private static bool _inTestMode = false;
-    private static TextWriter _testOutputStream;
-    private static bool _outputResetPerformed = false;
-
-    /// <summary>
-    ///     The instance
-    /// </summary>
-    private static ISystemWrapper _instance;
-
-    /// <summary>
-    ///     Prevents a default instance of the <see cref="SystemWrapper" /> class from being created.
-    /// </summary>
-    public SystemWrapper(IPowertoolsEnvironment powertoolsEnvironment)
-    {
-        _powertoolsEnvironment = powertoolsEnvironment;
-        _instance ??= this;
-        
-        if (!_inTestMode)
-        {
-            // Clear AWS SDK Console injected parameters in production only
-            ResetConsoleOutput();
-        }
-    }
-
-    /// <summary>
-    ///     Gets the instance.
-    /// </summary>
-    /// <value>The instance.</value>
-    public static ISystemWrapper Instance => _instance ??= new SystemWrapper(PowertoolsEnvironment.Instance);
-
-    /// <summary>
-    ///     Gets the environment variable.
-    /// </summary>
-    /// <param name="variable">The variable.</param>
-    /// <returns>System.String.</returns>
-    public string GetEnvironmentVariable(string variable)
-    {
-        return _powertoolsEnvironment.GetEnvironmentVariable(variable);
-    }
-
-    /// <summary>
-    ///     Logs the specified value.
-    /// </summary>
-    /// <param name="value">The value.</param>
-    public void Log(string value)
-    {
-        if (_inTestMode && _testOutputStream != null)
-        {
-            _testOutputStream.Write(value);
-        }
-        else
-        {
-            EnsureConsoleOutputOnce();
-            Console.Write(value);
-        }
-    }
-
-    /// <summary>
-    ///     Logs the line.
-    /// </summary>
-    /// <param name="value">The value.</param>
-    public void LogLine(string value)
-    {
-        if (_inTestMode && _testOutputStream != null)
-        {
-            _testOutputStream.WriteLine(value);
-        }
-        else
-        {
-            EnsureConsoleOutputOnce();
-            Console.WriteLine(value);
-        }
-    }
-
-    /// <summary>
-    ///     Gets random number
-    /// </summary>
-    /// <returns>System.Double.</returns>
-    public double GetRandom()
-    {
-        return new Random().NextDouble();
-    }
-
-    /// <inheritdoc />
-    public void SetEnvironmentVariable(string variable, string value)
-    {
-        _powertoolsEnvironment.SetEnvironmentVariable(variable, value);
-    }
-
-    /// <inheritdoc />
-    public void SetExecutionEnvironment<T>(T type)
-    {
-        const string envName = Constants.AwsExecutionEnvironmentVariableName;
-        var envValue = new StringBuilder();
-        var currentEnvValue = GetEnvironmentVariable(envName);
-        var assemblyName = ParseAssemblyName(_powertoolsEnvironment.GetAssemblyName(type));
-
-        // If there is an existing execution environment variable add the annotations package as a suffix.
-        if (!string.IsNullOrEmpty(currentEnvValue))
-        {
-            // Avoid duplication - should not happen since the calling Instances are Singletons - defensive purposes
-            if (currentEnvValue.Contains(assemblyName))
-            {
-                return;
-            }
-
-            envValue.Append($"{currentEnvValue} ");
-        }
-
-        var assemblyVersion = _powertoolsEnvironment.GetAssemblyVersion(type);
-
-        envValue.Append($"{assemblyName}/{assemblyVersion}");
-
-        SetEnvironmentVariable(envName, envValue.ToString());
-    }
-
-    /// <summary>
-    /// Sets console output
-    /// Useful for testing and checking the console output
-    /// <code>
-    /// var consoleOut = new StringWriter();
-    /// SystemWrapper.Instance.SetOut(consoleOut);
-    /// </code>
-    /// </summary>
-    /// <param name="writeTo">The TextWriter instance where to write to</param>
-
-    public static void SetOut(TextWriter writeTo)
-    {
-        _testOutputStream = writeTo;
-        _inTestMode = true;
-        Console.SetOut(writeTo);
-    }
-
-    /// <summary>
-    /// Parsing the name to conform with the required naming convention for the UserAgent header (PTFeature/Name/Version)
-    /// Fallback to Assembly Name on exception
-    /// </summary>
-    /// <param name="assemblyName"></param>
-    /// <returns></returns>
-    private string ParseAssemblyName(string assemblyName)
-    {
-        try
-        {
-            var parsedName = assemblyName.Substring(assemblyName.LastIndexOf(".", StringComparison.Ordinal) + 1);
-            return $"{Constants.FeatureContextIdentifier}/{parsedName}";
-        }
-        catch
-        {
-            //NOOP
-        }
-
-        return $"{Constants.FeatureContextIdentifier}/{assemblyName}";
-    }
-    
-    private static void EnsureConsoleOutputOnce()
-    {
-        if (_outputResetPerformed) return;
-        ResetConsoleOutput();
-        _outputResetPerformed = true;
-    }
-    
-    private static void ResetConsoleOutput()
-    {
-        var standardOutput = new StreamWriter(Console.OpenStandardOutput());
-        standardOutput.AutoFlush = true;
-        Console.SetOut(standardOutput);
-        var errorOutput = new StreamWriter(Console.OpenStandardError());
-        errorOutput.AutoFlush = true;
-        Console.SetError(errorOutput);
-    }
-    
-    public static void ClearOutputResetFlag()
-    {
-        _outputResetPerformed = false;
-    }
-    
-    // For test cleanup
-    internal static void ResetTestMode()
-    {
-        _inTestMode = false;
-        _testOutputStream = null;
-    }
-}
\ No newline at end of file
diff --git a/libraries/src/AWS.Lambda.Powertools.EventHandler.Resolvers.BedrockAgentFunction/BedrockAgentFunctionResolver.cs b/libraries/src/AWS.Lambda.Powertools.EventHandler.Resolvers.BedrockAgentFunction/BedrockAgentFunctionResolver.cs
index 8952948e..4107a1b9 100644
--- a/libraries/src/AWS.Lambda.Powertools.EventHandler.Resolvers.BedrockAgentFunction/BedrockAgentFunctionResolver.cs
+++ b/libraries/src/AWS.Lambda.Powertools.EventHandler.Resolvers.BedrockAgentFunction/BedrockAgentFunctionResolver.cs
@@ -40,7 +40,7 @@ private readonly
         public BedrockAgentFunctionResolver(IJsonTypeInfoResolver? typeResolver = null)
         {
             _parameterMapper = new ParameterMapper(typeResolver);
-            SystemWrapper.Instance.SetExecutionEnvironment(this);
+            PowertoolsEnvironment.Instance.SetExecutionEnvironment(this);
         }
         
         /// <summary>
diff --git a/libraries/src/AWS.Lambda.Powertools.EventHandler/AppSyncEvents/AppSyncEventsResolver.cs b/libraries/src/AWS.Lambda.Powertools.EventHandler/AppSyncEvents/AppSyncEventsResolver.cs
index afbf077d..09356b64 100644
--- a/libraries/src/AWS.Lambda.Powertools.EventHandler/AppSyncEvents/AppSyncEventsResolver.cs
+++ b/libraries/src/AWS.Lambda.Powertools.EventHandler/AppSyncEvents/AppSyncEventsResolver.cs
@@ -21,7 +21,7 @@ public AppSyncEventsResolver()
     {
         _publishRoutes = new RouteHandlerRegistry<AppSyncEventsRequest, object>();
         _subscribeRoutes = new RouteHandlerRegistry<AppSyncEventsRequest, bool>();
-        SystemWrapper.Instance.SetExecutionEnvironment(this);
+        PowertoolsEnvironment.Instance.SetExecutionEnvironment(this);
     }
 
     #region OnPublish Methods
diff --git a/libraries/src/AWS.Lambda.Powertools.Kafka/PowertoolsKafkaSerializerBase.cs b/libraries/src/AWS.Lambda.Powertools.Kafka/PowertoolsKafkaSerializerBase.cs
index 4c5b02ee..72b0fef3 100644
--- a/libraries/src/AWS.Lambda.Powertools.Kafka/PowertoolsKafkaSerializerBase.cs
+++ b/libraries/src/AWS.Lambda.Powertools.Kafka/PowertoolsKafkaSerializerBase.cs
@@ -78,7 +78,7 @@ protected PowertoolsKafkaSerializerBase(JsonSerializerOptions jsonOptions, JsonS
         JsonOptions = jsonOptions ?? new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
         SerializerContext = serializerContext;
         
-        SystemWrapper.Instance.SetExecutionEnvironment(this);
+        PowertoolsEnvironment.Instance.SetExecutionEnvironment(this);
     }
 
     /// <summary>
diff --git a/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/PowertoolsEnvironmentTest.cs b/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/PowertoolsEnvironmentTest.cs
index 936432ac..9f9e153c 100644
--- a/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/PowertoolsEnvironmentTest.cs
+++ b/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/PowertoolsEnvironmentTest.cs
@@ -1,9 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Xml.Linq;
 using System.Xml.XPath;
+using NSubstitute;
 using Xunit;
 
 namespace AWS.Lambda.Powertools.Common.Tests;
@@ -14,54 +14,57 @@ public class PowertoolsEnvironmentTest : IDisposable
     public void Set_Execution_Environment()
     {
         // Arrange
-        var systemWrapper = new SystemWrapper(new MockEnvironment());
+        var powertoolsEnv = new PowertoolsEnvironment();
         
         // Act
-        systemWrapper.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(this);
 
         // Assert
-        Assert.Equal($"{Constants.FeatureContextIdentifier}/Fake/1.0.0", systemWrapper.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/Tests/1.0.0 PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major}", powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
     }
     
     [Fact]
     public void Set_Execution_Environment_WhenEnvironmentHasValue()
     {
         // Arrange
-        var systemWrapper = new SystemWrapper(new MockEnvironment());
+        var powertoolsEnv = new PowertoolsEnvironment();
         
-        systemWrapper.SetEnvironmentVariable("AWS_EXECUTION_ENV", "ExistingValuesInUserAgent");
+        powertoolsEnv.SetEnvironmentVariable("AWS_EXECUTION_ENV", "ExistingValuesInUserAgent");
         
         // Act
-        systemWrapper.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(this);
 
         // Assert
-        Assert.Equal($"ExistingValuesInUserAgent {Constants.FeatureContextIdentifier}/Fake/1.0.0", systemWrapper.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
+        Assert.Equal($"ExistingValuesInUserAgent {Constants.FeatureContextIdentifier}/Tests/1.0.0 PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major}", powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
     }
     
     [Fact]
-    public void Set_Multiple_Execution_Environment()
+    public void Set_Same_Execution_Environment_Multiple_Times_Should_Only_Set_Once()
     {
         // Arrange
-        var systemWrapper = new SystemWrapper(new MockEnvironment());
+        var powertoolsEnv = new PowertoolsEnvironment();
         
         // Act
-        systemWrapper.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(this);
 
         // Assert
-        Assert.Equal($"{Constants.FeatureContextIdentifier}/Fake/1.0.0", systemWrapper.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/Tests/1.0.0 PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major}", powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
     }
     
     [Fact]
-    public void Set_Execution_Real_Environment()
+    public void Set_Multiple_Execution_Environment()
     {
         // Arrange
-        var systemWrapper = new SystemWrapper(new PowertoolsEnvironment());
+        var powertoolsEnv = new PowertoolsEnvironment();
         
         // Act
-        systemWrapper.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(this);
+        powertoolsEnv.SetExecutionEnvironment(powertoolsEnv.GetType());
 
         // Assert
-        Assert.Equal($"{Constants.FeatureContextIdentifier}/Tests/1.0.0", systemWrapper.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/Tests/1.0.0 PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major} {Constants.FeatureContextIdentifier}/Common/1.0.0", 
+            powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV"));
     }
     
     [Fact]
@@ -83,44 +86,251 @@ public void Should_Use_Aspect_Injector_281()
         Assert.Equal("2.8.1", packageReference.Version.ToString());
     }
     
-    public void Dispose()
+    [Fact]
+    public void SetExecutionEnvironment_Should_Format_Strings_Correctly_With_Mocked_Environment()
     {
-        //Do cleanup actions here
+        // Arrange
+        var mockEnvironment = Substitute.For<IPowertoolsEnvironment>();
+
+        // Mock the dependencies to return controlled values
+        mockEnvironment.GetAssemblyName(Arg.Any<object>()).Returns("AWS.Lambda.Powertools.Common.Tests");
+        mockEnvironment.GetAssemblyVersion(Arg.Any<object>()).Returns("1.2.3");
+        mockEnvironment.GetEnvironmentVariable("AWS_EXECUTION_ENV").Returns((string)null);
         
-        Environment.SetEnvironmentVariable("AWS_EXECUTION_ENV", null);
+        // Setup the actual method call to use real implementation logic
+        mockEnvironment.When(x => x.SetExecutionEnvironment(Arg.Any<object>()))
+            .Do(_ =>
+            {
+                var assemblyName = "PT/Tests"; // Parsed name
+                var assemblyVersion = "1.2.3";
+                var runtimeEnv = "PTENV/AWS_LAMBDA_DOTNET8"; // Assuming .NET 8
+                var expectedValue = $"{assemblyName}/{assemblyVersion} {runtimeEnv}";
+                
+                mockEnvironment.SetEnvironmentVariable("AWS_EXECUTION_ENV", expectedValue);
+            });
+        
+        // Act
+        mockEnvironment.SetExecutionEnvironment(this);
+        
+        // Assert
+        mockEnvironment.Received(1).SetEnvironmentVariable("AWS_EXECUTION_ENV", "PT/Tests/1.2.3 PTENV/AWS_LAMBDA_DOTNET8");
     }
-}
-
-/// <summary>
-/// Fake Environment for testing
-/// </summary>
-class MockEnvironment : IPowertoolsEnvironment
-{
-    private readonly Dictionary<string, string> _mockEnvironment = new();
     
-    public string GetEnvironmentVariable(string variableName)
+    [Fact]
+    public void SetExecutionEnvironment_Should_Append_To_Existing_Environment_With_Mocked_Values()
     {
-        return _mockEnvironment.TryGetValue(variableName, out var value) ? value : null;
+        // Arrange
+        var mockEnvironment = Substitute.For<IPowertoolsEnvironment>();
+        
+        // Mock existing environment value
+        mockEnvironment.GetEnvironmentVariable("AWS_EXECUTION_ENV").Returns("ExistingValue");
+        mockEnvironment.GetAssemblyName(Arg.Any<object>()).Returns("AWS.Lambda.Powertools.Logging");
+        mockEnvironment.GetAssemblyVersion(Arg.Any<object>()).Returns("2.1.0");
+        
+        // Setup the method call
+        mockEnvironment.When(x => x.SetExecutionEnvironment(Arg.Any<object>()))
+            .Do(_ =>
+            {
+                var currentEnv = "ExistingValue";
+                var assemblyName = "PT/Logging";
+                var assemblyVersion = "2.1.0";
+                var runtimeEnv = "PTENV/AWS_LAMBDA_DOTNET8";
+                var expectedValue = $"{currentEnv} {assemblyName}/{assemblyVersion} {runtimeEnv}";
+                
+                mockEnvironment.SetEnvironmentVariable("AWS_EXECUTION_ENV", expectedValue);
+            });
+        
+        // Act
+        mockEnvironment.SetExecutionEnvironment(this);
+        
+        // Assert
+        mockEnvironment.Received(1).SetEnvironmentVariable("AWS_EXECUTION_ENV", "ExistingValue PT/Logging/2.1.0 PTENV/AWS_LAMBDA_DOTNET8");
     }
-
-    public void SetEnvironmentVariable(string variableName, string value)
+    
+    [Fact]
+    public void SetExecutionEnvironment_Should_Not_Add_PTENV_Twice_With_Mocked_Values()
     {
-        // Check for entry not existing and add to dictionary
-        _mockEnvironment[variableName] = value;
+        // Arrange
+        var mockEnvironment = Substitute.For<IPowertoolsEnvironment>();
+        
+        // Mock existing environment value that already contains PTENV
+        mockEnvironment.GetEnvironmentVariable("AWS_EXECUTION_ENV").Returns("PT/Metrics/1.0.0 PTENV/AWS_LAMBDA_DOTNET8");
+        mockEnvironment.GetAssemblyName(Arg.Any<object>()).Returns("AWS.Lambda.Powertools.Tracing");
+        mockEnvironment.GetAssemblyVersion(Arg.Any<object>()).Returns("1.5.0");
+        
+        // Setup the method call - should not add PTENV again
+        mockEnvironment.When(x => x.SetExecutionEnvironment(Arg.Any<object>()))
+            .Do(_ =>
+            {
+                var currentEnv = "PT/Metrics/1.0.0 PTENV/AWS_LAMBDA_DOTNET8";
+                var assemblyName = "PT/Tracing";
+                var assemblyVersion = "1.5.0";
+                // No PTENV added since it already exists
+                var expectedValue = $"{currentEnv} {assemblyName}/{assemblyVersion}";
+                
+                mockEnvironment.SetEnvironmentVariable("AWS_EXECUTION_ENV", expectedValue);
+            });
+        
+        // Act
+        mockEnvironment.SetExecutionEnvironment(this);
+        
+        // Assert
+        mockEnvironment.Received(1).SetEnvironmentVariable("AWS_EXECUTION_ENV", "PT/Metrics/1.0.0 PTENV/AWS_LAMBDA_DOTNET8 PT/Tracing/1.5.0");
     }
-
-    public string GetAssemblyName<T>(T type)
+    
+    [Fact]
+    public void GetAssemblyName_Should_Handle_Type_Object()
     {
-        return "AWS.Lambda.Powertools.Fake";
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        var typeObject = typeof(PowertoolsEnvironment);
+        
+        // Act
+        var result = powertoolsEnv.GetAssemblyName(typeObject);
+        
+        // Assert
+        Assert.Equal("AWS.Lambda.Powertools.Common", result);
     }
-
-    public string GetAssemblyVersion<T>(T type)
+    
+    [Fact]
+    public void GetAssemblyName_Should_Handle_Regular_Object()
     {
-        return "1.0.0";
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        
+        // Act
+        var result = powertoolsEnv.GetAssemblyName(this);
+        
+        // Assert
+        Assert.Equal("AWS.Lambda.Powertools.Common.Tests", result);
+    }
+    
+    [Fact]
+    public void GetAssemblyVersion_Should_Handle_Type_Object()
+    {
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        var typeObject = typeof(PowertoolsEnvironment);
+        
+        // Act
+        var result = powertoolsEnv.GetAssemblyVersion(typeObject);
+        
+        // Assert
+        Assert.Matches(@"\d+\.\d+\.\d+", result); // Should match version pattern like "1.0.0"
+    }
+    
+    [Fact]
+    public void GetAssemblyVersion_Should_Handle_Regular_Object()
+    {
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        
+        // Act
+        var result = powertoolsEnv.GetAssemblyVersion(this);
+        
+        // Assert
+        Assert.Matches(@"\d+\.\d+\.\d+", result); // Should match version pattern like "1.0.0"
+    }
+    
+    [Fact]
+    public void ParseAssemblyName_Should_Handle_Assembly_Without_Dots()
+    {
+        // Act
+        var result = PowertoolsEnvironment.ParseAssemblyName("SimpleAssemblyName");
+        
+        // Assert
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/SimpleAssemblyName", result);
+    }
+    
+    [Fact]
+    public void ParseAssemblyName_Should_Handle_Assembly_With_Dots()
+    {
+        // Act
+        var result = PowertoolsEnvironment.ParseAssemblyName("AWS.Lambda.Powertools.Common");
+        
+        // Assert
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/Common", result);
+    }
+    
+    [Fact]
+    public void ParseAssemblyName_Should_Use_Cache_For_Same_Assembly_Name()
+    {
+        // Act - Call twice with same assembly name
+        var result1 = PowertoolsEnvironment.ParseAssemblyName("AWS.Lambda.Powertools.Tests");
+        var result2 = PowertoolsEnvironment.ParseAssemblyName("AWS.Lambda.Powertools.Tests");
+        
+        // Assert - Should return same result (cached)
+        Assert.Equal(result1, result2);
+        Assert.Equal($"{Constants.FeatureContextIdentifier}/Tests", result1);
+    }
+    
+    [Fact]
+    public void ParseAssemblyName_Null_Return_Empty()
+    {
+        // Act - Call twice with same assembly name
+        var result = PowertoolsEnvironment.ParseAssemblyName(null);
+        
+        // Assert - Should return null
+        Assert.Empty(result);
+    }
+    
+    [Fact]
+    public void SetExecutionEnvironment_Should_Handle_Empty_Current_Environment()
+    {
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        Environment.SetEnvironmentVariable("AWS_EXECUTION_ENV", "");
+        
+        // Act
+        powertoolsEnv.SetExecutionEnvironment(this);
+        
+        // Assert
+        var result = powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV");
+        Assert.Contains($"{Constants.FeatureContextIdentifier}/Tests/", result);
+        Assert.Contains("PTENV/AWS_LAMBDA_DOTNET", result);
+    }
+    
+    [Fact]
+    public void SetExecutionEnvironment_Should_Add_PTENV_When_Not_Present()
+    {
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        powertoolsEnv.SetEnvironmentVariable("AWS_EXECUTION_ENV", "SomeExistingValue");
+        
+        // Act
+        powertoolsEnv.SetExecutionEnvironment(this);
+        
+        // Assert
+        var result = powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV");
+        Assert.StartsWith("SomeExistingValue", result);
+        Assert.Contains("PTENV/AWS_LAMBDA_DOTNET", result);
+    }
+    
+    [Fact]
+    public void SetExecutionEnvironment_Should_Not_Add_PTENV_When_Already_Present()
+    {
+        // Arrange
+        var powertoolsEnv = new PowertoolsEnvironment();
+        var existingValue = $"ExistingValue PTENV/AWS_LAMBDA_DOTNET{Environment.Version.Major}";
+        powertoolsEnv.SetEnvironmentVariable("AWS_EXECUTION_ENV", existingValue);
+        
+        // Act
+        powertoolsEnv.SetExecutionEnvironment(this);
+        
+        // Assert
+        var result = powertoolsEnv.GetEnvironmentVariable("AWS_EXECUTION_ENV");
+        var ptenvCount = result.Split("PTENV/").Length - 1;
+        Assert.Equal(1, ptenvCount); // Should only have one PTENV entry
     }
 
-    public void SetExecutionEnvironment<T>(T type)
+    public void Dispose()
     {
-        throw new NotImplementedException();
+        //Do cleanup actions here
+        Environment.SetEnvironmentVariable("AWS_EXECUTION_ENV", null);
+        
+        // Clear the singleton instance to ensure fresh state for each test
+        var instanceField = typeof(PowertoolsEnvironment).GetField("_instance", 
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+        instanceField?.SetValue(null, null);
     }
 }
diff --git a/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/SystemWrapperTests.cs b/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/SystemWrapperTests.cs
deleted file mode 100644
index ff5a7fb0..00000000
--- a/libraries/tests/AWS.Lambda.Powertools.Common.Tests/Core/SystemWrapperTests.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-using System;
-using System.IO;
-using System.Reflection;
-using NSubstitute;
-using Xunit;
-
-namespace AWS.Lambda.Powertools.Common.Tests;
-
-[Collection("Sequential")]
-public class SystemWrapperTests : IDisposable
-{
-    private readonly IPowertoolsEnvironment _mockEnvironment;
-    private readonly StringWriter _testWriter;
-    private readonly FieldInfo _outputResetPerformedField;
-
-
-    public SystemWrapperTests()
-    {
-        _mockEnvironment = Substitute.For<IPowertoolsEnvironment>();
-        _testWriter = new StringWriter();
-        
-        // Get access to private field for testing
-        _outputResetPerformedField = typeof(SystemWrapper).GetField("_outputResetPerformed", 
-            BindingFlags.NonPublic | BindingFlags.Static);
-
-        // Reset static state between tests
-        SystemWrapper.ResetTestMode();
-        _outputResetPerformedField.SetValue(null, false);
-    }
-
-    [Fact]
-    public void Log_InProductionMode_ResetsOutputOnce()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        var message1 = "First message";
-        var message2 = "Second message";
-        _outputResetPerformedField.SetValue(null, false);
-
-        // Act
-        wrapper.Log(message1);
-        bool afterFirstLog = (bool)_outputResetPerformedField.GetValue(null);
-        wrapper.Log(message2);
-        bool afterSecondLog = (bool)_outputResetPerformedField.GetValue(null);
-
-        // Assert
-        Assert.True(afterFirstLog, "Flag should be set after first log");
-        Assert.True(afterSecondLog, "Flag should remain set after second log");
-    }
-
-    [Fact]
-    public void LogLine_InProductionMode_ResetsOutputOnce()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        var message1 = "First line";
-        var message2 = "Second line";
-        _outputResetPerformedField.SetValue(null, false);
-
-        // Act
-        wrapper.LogLine(message1);
-        bool afterFirstLog = (bool)_outputResetPerformedField.GetValue(null);
-        wrapper.LogLine(message2);
-        bool afterSecondLog = (bool)_outputResetPerformedField.GetValue(null);
-
-        // Assert
-        Assert.True(afterFirstLog, "Flag should be set after first LogLine");
-        Assert.True(afterSecondLog, "Flag should remain set after second LogLine");
-    }
-
-    [Fact]
-    public void ClearOutputResetFlag_ResetsFlag_AllowsSubsequentReset()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        _outputResetPerformedField.SetValue(null, false);
-        
-        // Act
-        wrapper.Log("First message"); // This should cause a reset
-        bool afterFirstLog = (bool)_outputResetPerformedField.GetValue(null);
-        
-        SystemWrapper.ClearOutputResetFlag();
-        bool afterClear = (bool)_outputResetPerformedField.GetValue(null);
-        
-        wrapper.Log("After clear"); // This should cause another reset
-        bool afterSecondLog = (bool)_outputResetPerformedField.GetValue(null);
-
-        // Assert
-        Assert.True(afterFirstLog, "Flag should be set after first log");
-        Assert.False(afterClear, "Flag should be cleared after ClearOutputResetFlag");
-        Assert.True(afterSecondLog, "Flag should be set again after second log");
-    }
-
-    [Fact]
-    public void Log_InTestMode_WritesToTestOutput()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        SystemWrapper.SetOut(_testWriter);
-        var message = "Test message";
-
-        // Act
-        wrapper.Log(message);
-
-        // Assert
-        Assert.Equal(message, _testWriter.ToString());
-    }
-
-    [Fact]
-    public void LogLine_InTestMode_WritesToTestOutput()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        SystemWrapper.SetOut(_testWriter);
-        var message = "Test line";
-
-        // Act
-        wrapper.LogLine(message);
-
-        // Assert
-        Assert.Equal(message + Environment.NewLine, _testWriter.ToString());
-    }
-
-    [Fact]
-    public void ResetTestMode_ResetsTestState()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        SystemWrapper.SetOut(_testWriter);
-        var message = "This should go to console";
-
-        // Act
-        SystemWrapper.ResetTestMode();
-
-        // Can't directly test that this goes to console, but we can verify
-        // it doesn't go to the test writer
-        wrapper.Log(message);
-
-        // Assert
-        Assert.Equal("", _testWriter.ToString());
-    }
-
-    [Fact]
-    public void SetOut_EnablesTestMode()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        var message = "Test output";
-
-        // Act
-        SystemWrapper.SetOut(_testWriter);
-        wrapper.Log(message);
-
-        // Assert
-        Assert.Equal(message, _testWriter.ToString());
-    }
-
-    [Fact]
-    public void Log_InTestMode_DoesNotCallResetConsoleOutput()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        SystemWrapper.SetOut(_testWriter);
-        var message1 = "First test message";
-        var message2 = "Second test message";
-
-        // Act
-        wrapper.Log(message1);
-        wrapper.Log(message2);
-
-        // Assert
-        Assert.Equal(message1 + message2, _testWriter.ToString());
-    }
-
-    [Fact]
-    public void Log_AfterClearingFlag_ResetsOutputAgain()
-    {
-        // Arrange
-        var wrapper = new SystemWrapper(_mockEnvironment);
-        _outputResetPerformedField.SetValue(null, false);
-
-        // Act
-        wrapper.Log("First message"); // Should reset output
-        bool afterFirstLog = (bool)_outputResetPerformedField.GetValue(null);
-        
-        SystemWrapper.ClearOutputResetFlag();
-        bool afterClear = (bool)_outputResetPerformedField.GetValue(null);
-        
-        wrapper.Log("Second message"); // Should reset again
-        bool afterSecondLog = (bool)_outputResetPerformedField.GetValue(null);
-
-        // Assert
-        Assert.True(afterFirstLog, "Flag should be set after first log");
-        Assert.False(afterClear, "Flag should be reset after clearing");
-        Assert.True(afterSecondLog, "Flag should be set after second log");
-    }
-
-    public void Dispose()
-    {
-        _testWriter?.Dispose();
-        SystemWrapper.ResetTestMode();
-        _outputResetPerformedField.SetValue(null, false);
-    }
-}
\ No newline at end of file