Merge pull request #927 from aws-powertools/chore/ptenv-ua

chore: Add missing PTENV to user agent

Author: hjgraca

libraries/src/AWS.Lambda.Powertools.Common/Core/ISystemWrapper.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,41 +43,72 @@ 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;
     }
 
     /// <inheritdoc />
     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}";
     }
-}
+}