diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/AWS.Lambda.Powertools.Metrics.csproj b/libraries/src/AWS.Lambda.Powertools.Metrics/AWS.Lambda.Powertools.Metrics.csproj
index 0e90e99b..e20deb7e 100644
--- a/libraries/src/AWS.Lambda.Powertools.Metrics/AWS.Lambda.Powertools.Metrics.csproj
+++ b/libraries/src/AWS.Lambda.Powertools.Metrics/AWS.Lambda.Powertools.Metrics.csproj
@@ -11,4 +11,8 @@
         <ProjectReference Include="..\AWS.Lambda.Powertools.Common\AWS.Lambda.Powertools.Common.csproj" PrivateAssets="All" />
     </ItemGroup>
 
+    <ItemGroup>
+      <PackageReference Include="Amazon.Lambda.Core" />
+    </ItemGroup>
+
 </Project>
diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/Internal/MetricsAspect.cs b/libraries/src/AWS.Lambda.Powertools.Metrics/Internal/MetricsAspect.cs
index abbefc5f..a72e205e 100644
--- a/libraries/src/AWS.Lambda.Powertools.Metrics/Internal/MetricsAspect.cs
+++ b/libraries/src/AWS.Lambda.Powertools.Metrics/Internal/MetricsAspect.cs
@@ -17,6 +17,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using Amazon.Lambda.Core;
 using AspectInjector.Broker;
 using AWS.Lambda.Powertools.Common;
 
@@ -34,11 +35,6 @@ public class MetricsAspect
     /// </summary>
     private static bool _isColdStart;
 
-    /// <summary>
-    ///     Specify to clear Lambda Context on exit
-    /// </summary>
-    private bool _clearLambdaContext;
-
     /// <summary>
     ///     Gets the metrics instance.
     /// </summary>
@@ -100,14 +96,14 @@ public void Before(
             var nameSpace = _metricsInstance.GetNamespace();
             var service = _metricsInstance.GetService();
             Dictionary<string, string> dimensions = null;
-
-            _clearLambdaContext = PowertoolsLambdaContext.Extract(eventArgs);
-
-            if (PowertoolsLambdaContext.Instance is not null)
+            
+            var context = GetContext(eventArgs);
+            
+            if (context is not null)
             {
                 dimensions = new Dictionary<string, string>
                 {
-                    { "FunctionName", PowertoolsLambdaContext.Instance.FunctionName }
+                    { "FunctionName", context.FunctionName }
                 };
             }
 
@@ -129,8 +125,6 @@ public void Before(
     public void Exit()
     {
         _metricsInstance.Flush();
-        if (_clearLambdaContext)
-            PowertoolsLambdaContext.Clear();
     }
 
 
@@ -142,6 +136,21 @@ internal static void ResetForTest()
         _metricsInstance = null;
         _isColdStart = true;
         Metrics.ResetForTest();
-        PowertoolsLambdaContext.Clear();
+    }
+    
+    /// <summary>
+    /// Gets the Lambda context
+    /// </summary>
+    /// <param name="args"></param>
+    /// <returns></returns>
+    private static ILambdaContext GetContext(AspectEventArgs args)
+    {
+        var index = Array.FindIndex(args.Method.GetParameters(), p => p.ParameterType == typeof(ILambdaContext));
+        if (index >= 0)
+        {
+            return (ILambdaContext)args.Args[index];
+        }
+
+        return null;
     }
 }
\ No newline at end of file
diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricResolution.cs b/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricResolution.cs
index 2112c1c5..3929beec 100644
--- a/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricResolution.cs
+++ b/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricResolution.cs
@@ -1,4 +1,3 @@
-using System.Runtime.Serialization;
 using System.Text.Json.Serialization;
 
 namespace AWS.Lambda.Powertools.Metrics;
@@ -6,6 +5,7 @@ namespace AWS.Lambda.Powertools.Metrics;
 /// <summary>
 /// Enum MetricResolution
 /// </summary>
+[JsonConverter(typeof(MetricResolutionJsonConverter))]
 public enum MetricResolution
 {
     /// <summary>
diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricUnit.cs b/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricUnit.cs
index 132b10f3..2fbb389d 100644
--- a/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricUnit.cs
+++ b/libraries/src/AWS.Lambda.Powertools.Metrics/Model/MetricUnit.cs
@@ -24,7 +24,7 @@ namespace AWS.Lambda.Powertools.Metrics;
 #if NET8_0_OR_GREATER
 [JsonConverter(typeof(JsonStringEnumConverter<MetricUnit>))]
 #else
-[JsonConverter(typeof(StringEnumConverter))]
+[JsonConverter(typeof(JsonStringEnumConverter))]
 #endif
 public enum MetricUnit
 {
diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/MetricResolutionJsonConverter.cs b/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/MetricResolutionJsonConverter.cs
new file mode 100644
index 00000000..710b1a2a
--- /dev/null
+++ b/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/MetricResolutionJsonConverter.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace AWS.Lambda.Powertools.Metrics;
+
+/// <summary>
+/// Class MetricResolutionJsonConverter.
+/// Implements the <see cref="System.Text.Json.Serialization.JsonConverter{T}" />
+/// </summary>
+/// <seealso cref="System.Text.Json.Serialization.JsonConverter{T}" />
+public class MetricResolutionJsonConverter : JsonConverter<MetricResolution>
+{
+    /// <summary>
+    /// Reads the JSON representation of the object.
+    /// </summary>
+    /// <param name="reader">The <see cref="T:Utf8JsonReader" /> to read from.</param>
+    /// <param name="typeToConvert">The <see cref="T:System.Type" /> being converted.</param>
+    /// <param name="options">The <see cref="T:Utf8JsonSerializerOptions" /> being used.</param>
+    /// <returns>The object value.</returns>
+    public override MetricResolution Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var stringValue = reader.GetString();
+            if (int.TryParse(stringValue, out int value))
+            {
+                return (MetricResolution)value;
+            }
+        }
+        else if (reader.TokenType == JsonTokenType.Number)
+        {
+            return (MetricResolution)reader.GetInt32();
+        }
+
+        throw new JsonException();
+    }
+
+    /// <summary>
+    /// Writes the JSON representation of the object.
+    /// </summary>
+    /// <param name="writer">The <see cref="T:Utf8JsonWriter" /> to write to.</param>
+    /// <param name="value">The value to convert.</param>
+    /// <param name="options">The <see cref="T:Utf8JsonSerializerOptions" /> being used.</param>
+    public override void Write(Utf8JsonWriter writer, MetricResolution value, JsonSerializerOptions options)
+    {
+        writer.WriteNumberValue((int)value);
+    }
+}
\ No newline at end of file
diff --git a/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/StringEnumConverter.cs b/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/StringEnumConverter.cs
deleted file mode 100644
index 242ee90b..00000000
--- a/libraries/src/AWS.Lambda.Powertools.Metrics/Serializer/StringEnumConverter.cs
+++ /dev/null
@@ -1,102 +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;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.Serialization;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace AWS.Lambda.Powertools.Metrics;
-
-#if NET6_0
-
-/// <summary>
-///     Class StringEnumConverter.
-///     Implements the <see cref="System.Text.Json.Serialization.JsonConverterFactory" />
-///     .NET 6 only
-/// </summary>
-/// <seealso cref="System.Text.Json.Serialization.JsonConverterFactory" />
-public class StringEnumConverter : JsonConverterFactory
-{
-    /// <summary>
-    ///     The allow integer values
-    /// </summary>
-    private readonly bool _allowIntegerValues;
-
-    /// <summary>
-    ///     The base converter
-    /// </summary>
-    private readonly JsonStringEnumConverter _baseConverter;
-
-    /// <summary>
-    ///     The naming policy
-    /// </summary>
-    private readonly JsonNamingPolicy _namingPolicy;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="StringEnumConverter" /> class.
-    /// </summary>
-    public StringEnumConverter() : this(null)
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="StringEnumConverter" /> class.
-    /// </summary>
-    /// <param name="namingPolicy">The naming policy.</param>
-    /// <param name="allowIntegerValues">if set to <c>true</c> [allow integer values].</param>
-    private StringEnumConverter(JsonNamingPolicy namingPolicy = null, bool allowIntegerValues = true)
-    {
-        _namingPolicy = namingPolicy;
-        _allowIntegerValues = allowIntegerValues;
-        _baseConverter = new JsonStringEnumConverter(namingPolicy, allowIntegerValues);
-    }
-
-    /// <summary>
-    ///     When overridden in a derived class, determines whether the converter instance can convert the specified object
-    ///     type.
-    /// </summary>
-    /// <param name="typeToConvert">The type of the object to check whether it can be converted by this converter instance.</param>
-    /// <returns>
-    ///     <see langword="true" /> if the instance can convert the specified object type; otherwise,
-    ///     <see langword="false" />.
-    /// </returns>
-    public override bool CanConvert(Type typeToConvert)
-    {
-        return _baseConverter.CanConvert(typeToConvert);
-    }
-    
-    /// <summary>
-    ///     Creates a converter for a specified type.
-    /// </summary>
-    /// <param name="typeToConvert">The type handled by the converter.</param>
-    /// <param name="options">The serialization options to use.</param>
-    /// <returns>A converter for which type is compatible with <paramref name="typeToConvert" />.</returns>
-    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
-    {
-        var query = from field in typeToConvert.GetFields(BindingFlags.Public | BindingFlags.Static)
-            let attr = field.GetCustomAttribute<EnumMemberAttribute>()
-            where attr != null
-            select (field.Name, attr.Value);
-        var dictionary = query.ToDictionary(p => p.Item1, p => p.Item2);
-        return dictionary.Count > 0
-            ? new JsonStringEnumConverter(new DictionaryLookupNamingPolicy(dictionary, _namingPolicy),
-                _allowIntegerValues).CreateConverter(typeToConvert, options)
-            : _baseConverter.CreateConverter(typeToConvert, options);
-    }
-}
-#endif
\ No newline at end of file
diff --git a/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandler.cs b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandler.cs
index 8ae59b9f..8447575d 100644
--- a/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandler.cs
+++ b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandler.cs
@@ -169,8 +169,14 @@ public void HandleWithLambdaContext(ILambdaContext context)
     }
 
     [Metrics(Namespace = "ns", Service = "svc")]
-    public void HandleWithLambdaContextAndMetrics(TestLambdaContext context)
+    public void HandleColdStartNoContext()
     {
         Metrics.AddMetric("MyMetric", 1);
     }
+    
+    [Metrics(Namespace = "ns", Service = "svc", CaptureColdStart = true)]
+    public void HandleWithParamAndLambdaContext(string input, ILambdaContext context)
+    {
+        
+    }
 }
\ No newline at end of file
diff --git a/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandlerTests.cs b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandlerTests.cs
index 556d6cce..075da0a0 100644
--- a/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandlerTests.cs
+++ b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/Handlers/FunctionHandlerTests.cs
@@ -88,6 +88,46 @@ public void When_LambdaContext_Should_Add_FunctioName_Dimension_CaptureColdStart
             "\"Metrics\":[{\"Name\":\"ColdStart\",\"Unit\":\"Count\"}],\"Dimensions\":[[\"FunctionName\"],[\"Service\"]]}]}",
             metricsOutput);
     }
+    
+    [Fact]
+    public void When_LambdaContext_And_Parameter_Should_Add_FunctioName_Dimension_CaptureColdStart()
+    {
+        // Arrange
+        var context = new TestLambdaContext
+        {
+            FunctionName = "My Function with context"
+        };
+        
+        // Act
+        _handler.HandleWithParamAndLambdaContext("Hello",context);
+        var metricsOutput = _consoleOut.ToString();
+        
+        // Assert
+        Assert.Contains(
+            "\"FunctionName\":\"My Function with context\"",
+            metricsOutput);
+        
+        Assert.Contains(
+            "\"Metrics\":[{\"Name\":\"ColdStart\",\"Unit\":\"Count\"}],\"Dimensions\":[[\"FunctionName\"],[\"Service\"]]}]}",
+            metricsOutput);
+    }
+    
+    [Fact]
+    public void When_No_LambdaContext_Should_Not_Add_FunctioName_Dimension_CaptureColdStart()
+    {
+        // Act
+        _handler.HandleColdStartNoContext();
+        var metricsOutput = _consoleOut.ToString();
+        
+        // Assert
+        Assert.DoesNotContain(
+            "\"FunctionName\"",
+            metricsOutput);
+        
+        Assert.Contains(
+            "\"Metrics\":[{\"Name\":\"MyMetric\",\"Unit\":\"None\"}],\"Dimensions\":[[\"Service\"]]}]},\"Service\":\"svc\",\"MyMetric\":1}",
+            metricsOutput);
+    }
 
     public void Dispose()
     {
diff --git a/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/SerializationTests.cs b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/SerializationTests.cs
new file mode 100644
index 00000000..2433c5a2
--- /dev/null
+++ b/libraries/tests/AWS.Lambda.Powertools.Metrics.Tests/SerializationTests.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Text.Json;
+using Xunit;
+
+namespace AWS.Lambda.Powertools.Metrics.Tests;
+
+[Collection("Sequential")]
+public class SerializationTests
+{
+    [Fact]
+    public void Metrics_Resolution_JsonConverter()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new MetricResolutionJsonConverter());
+
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>(1, options);
+            Assert.Equal(MetricResolution.High, myInt);
+            Assert.Equal("1", JsonSerializer.Serialize(myInt, options));
+        }
+
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>("1", options);
+            Assert.Equal(MetricResolution.High, myInt);
+            Assert.Equal("1", JsonSerializer.Serialize(myInt, options));
+        }
+
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>("60", options);
+            Assert.Equal(MetricResolution.Standard, myInt);
+            Assert.Equal("60", JsonSerializer.Serialize(myInt, options));
+        }
+
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>("0", options);
+            Assert.Equal(MetricResolution.Default, myInt);
+            Assert.Equal("0", JsonSerializer.Serialize(myInt, options));
+        }
+
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>(@"""1""", options);
+            Assert.Equal(MetricResolution.High, myInt);
+            Assert.Equal("1", JsonSerializer.Serialize(myInt, options));
+        }
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>(@"""60""", options);
+            Assert.Equal(MetricResolution.Standard, myInt);
+            Assert.Equal("60", JsonSerializer.Serialize(myInt, options));
+        }
+        {
+            var myInt = JsonSerializer.Deserialize<MetricResolution>(@"""0""", options);
+            Assert.Equal(MetricResolution.Default, myInt);
+            Assert.Equal("0", JsonSerializer.Serialize(myInt, options));
+        }
+    }
+
+    [Fact]
+    public void Metrics_Resolution_JsonConverter_Exception()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new MetricResolutionJsonConverter());
+
+        {
+            Action act = () => JsonSerializer.Deserialize<MetricResolution>("1.3", options);
+            Assert.Throws<JsonException>(act);
+        }
+        
+        {
+            Action act = () => JsonSerializer.Deserialize<MetricResolution>(@"""1.3""", options);
+            Assert.Throws<JsonException>(act);
+        }
+        
+        {
+            Action act = () => JsonSerializer.Deserialize<MetricResolution>(@"""abc""", options);
+            Assert.Throws<JsonException>(act);
+        }
+    }
+}
\ No newline at end of file
diff --git a/version.json b/version.json
index ec7a6148..9fb16922 100644
--- a/version.json
+++ b/version.json
@@ -1,7 +1,7 @@
 {
 	"Core": {
 		"Logging": "1.5.1",
-		"Metrics": "1.7.0",
+		"Metrics": "1.7.1",
 		"Tracing": "1.4.2"
 	},
 	"Utilities": {