feat(gofeatureflag): Support flag metadata

thomaspoignant · thomaspoignant · commit 81bbce265e9f · 2025-02-04T22:24:48.000+01:00
Signed-off-by: Thomas Poignant &lt;thomas.poignant@gofeatureflag.org&gt;
diff --git a/src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagProvider.cs b/src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagProvider.cs
@@ -10,6 +10,7 @@
 using System.Threading.Tasks;
 using OpenFeature.Constant;
 using OpenFeature.Contrib.Providers.GOFeatureFlag.exception;
+using OpenFeature.Contrib.Providers.GOFeatureFlag.helpers;
 using OpenFeature.Model;
 
 namespace OpenFeature.Contrib.Providers.GOFeatureFlag
@@ -97,7 +98,8 @@ public override async Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(str
             {
                 var resp = await CallApi(flagKey, defaultValue, context);
                 return new ResolutionDetails<bool>(flagKey, bool.Parse(resp.value.ToString()), ErrorType.None,
-                    resp.reason, resp.variationType);
+                    resp.reason, resp.variationType, null,
+                    resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));
             }
             catch (FormatException e)
             {
@@ -121,7 +123,8 @@ public override async Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(str
         /// <exception cref="FlagNotFoundError">If the flag does not exists</exception>
         /// <exception cref="GeneralError">If an unknown error happen</exception>
         /// <exception cref="FlagDisabled">If the flag is disabled</exception>
-        public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue,
+        public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey,
+            string defaultValue,
             EvaluationContext context = null, CancellationToken cancellationToken = default)
         {
             try
@@ -130,7 +133,7 @@ public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(st
                 if (!(resp.value is JsonElement element && element.ValueKind == JsonValueKind.String))
                     throw new TypeMismatchError($"flag value {flagKey} had unexpected type");
                 return new ResolutionDetails<string>(flagKey, resp.value.ToString(), ErrorType.None, resp.reason,
-                    resp.variationType);
+                    resp.variationType, null, resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));
             }
             catch (FormatException e)
             {
@@ -161,7 +164,8 @@ public override async Task<ResolutionDetails<int>> ResolveIntegerValueAsync(stri
             {
                 var resp = await CallApi(flagKey, defaultValue, context);
                 return new ResolutionDetails<int>(flagKey, int.Parse(resp.value.ToString()), ErrorType.None,
-                    resp.reason, resp.variationType);
+                    resp.reason, resp.variationType, null,
+                    resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));
             }
             catch (FormatException e)
             {
@@ -185,15 +189,17 @@ public override async Task<ResolutionDetails<int>> ResolveIntegerValueAsync(stri
         /// <exception cref="FlagNotFoundError">If the flag does not exists</exception>
         /// <exception cref="GeneralError">If an unknown error happen</exception>
         /// <exception cref="FlagDisabled">If the flag is disabled</exception>
-        public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue,
+        public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey,
+            double defaultValue,
             EvaluationContext context = null, CancellationToken cancellationToken = default)
         {
             try
             {
                 var resp = await CallApi(flagKey, defaultValue, context);
                 return new ResolutionDetails<double>(flagKey,
                     double.Parse(resp.value.ToString(), CultureInfo.InvariantCulture), ErrorType.None,
-                    resp.reason, resp.variationType);
+                    resp.reason, resp.variationType, null,
+                    resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));
             }
             catch (FormatException e)
             {
@@ -217,7 +223,8 @@ public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(st
         /// <exception cref="FlagNotFoundError">If the flag does not exists</exception>
         /// <exception cref="GeneralError">If an unknown error happen</exception>
         /// <exception cref="FlagDisabled">If the flag is disabled</exception>
-        public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue,
+        public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey,
+            Value defaultValue,
             EvaluationContext context = null, CancellationToken cancellationToken = default)
         {
             try
@@ -227,7 +234,7 @@ public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(
                 {
                     var value = ConvertValue((JsonElement)resp.value);
                     return new ResolutionDetails<Value>(flagKey, value, ErrorType.None, resp.reason,
-                        resp.variationType);
+                        resp.variationType, null, resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));
                 }
 
                 throw new TypeMismatchError($"flag value {flagKey} had unexpected type");
@@ -285,6 +292,7 @@ private async Task<GoFeatureFlagResponse> CallApi<T>(string flagKey, T defaultVa
             if ("FLAG_NOT_FOUND".Equals(goffResp.errorCode))
                 throw new FlagNotFoundError($"flag {flagKey} was not found in your configuration");
 
+            if (goffResp.metadata != null) goffResp.metadata = DictionaryConverter.ConvertDictionary(goffResp.metadata);
             return goffResp;
         }
 
diff --git a/src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagResponse.cs b/src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagResponse.cs
@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace OpenFeature.Contrib.Providers.GOFeatureFlag
 {
     /// <summary>
@@ -39,5 +41,10 @@ public class GoFeatureFlagResponse
         ///     value contains the result of the flag.
         /// </summary>
         public object value { get; set; }
+
+        /// <summary>
+        ///     metadata contains the metadata of the flag.
+        /// </summary>
+        public Dictionary<string, object> metadata { get; set; }
     }
 }
diff --git a/src/OpenFeature.Contrib.Providers.GOFeatureFlag/helpers/DictionaryConverter.cs b/src/OpenFeature.Contrib.Providers.GOFeatureFlag/helpers/DictionaryConverter.cs
@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+
+namespace OpenFeature.Contrib.Providers.GOFeatureFlag.helpers
+{
+    public static class DictionaryConverter
+    {
+        public static Dictionary<string, object> ConvertDictionary(Dictionary<string, object> inputDictionary)
+        {
+            return inputDictionary.ToDictionary(
+                kvp => kvp.Key,
+                kvp => ConvertValue(kvp.Value)
+            );
+        }
+
+        public static object ConvertValue(object value)
+        {
+            if (value is JsonElement jsonElement)
+                switch (jsonElement.ValueKind)
+                {
+                    case JsonValueKind.String:
+                        return jsonElement.GetString();
+                    case JsonValueKind.Number:
+                        if (jsonElement.TryGetInt32(out var intValue)) return intValue;
+
+                        if (jsonElement.TryGetDouble(out var doubleValue)) return doubleValue;
+                        return jsonElement.GetRawText(); // Fallback to string if not int or double
+                    case JsonValueKind.True:
+                        return true;
+                    case JsonValueKind.False:
+                        return false;
+                    case JsonValueKind.Null:
+                        return null;
+                    case JsonValueKind.Object:
+                        return ConvertDictionary(
+                            JsonSerializer
+                                .Deserialize<Dictionary<string, object>>(jsonElement
+                                    .GetRawText())); //Recursive for nested objects
+                    case JsonValueKind.Array:
+                        var array = new List<object>();
+                        foreach (var element in jsonElement.EnumerateArray()) array.Add(ConvertValue(element));
+
+                        return array;
+                    default:
+                        return jsonElement.GetRawText(); // Handle other types as needed
+                }
+
+            return value; // Return original value if not a JsonElement
+        }
+    }
+}
diff --git a/test/OpenFeature.Contrib.Providers.GOFeatureFlag.Test/GoFeatureFlagProviderTest.cs b/test/OpenFeature.Contrib.Providers.GOFeatureFlag.Test/GoFeatureFlagProviderTest.cs
@@ -56,6 +56,8 @@ private static HttpMessageHandler InitMock()
             "{\"trackEvents\":true,\"variationType\":\"True\",\"failed\":false,\"version\":\"\",\"reason\":\"CUSTOM_REASON\",\"errorCode\":\"\",\"value\":true}");
         mockHttp.When($"{prefixEval}does_not_exists{suffixEval}").Respond(mediaType,
             "{\"trackEvents\":true,\"variationType\":\"defaultSdk\",\"failed\":true,\"version\":\"\",\"reason\":\"ERROR\",\"errorCode\":\"FLAG_NOT_FOUND\",\"value\":\"\"}");
+        mockHttp.When($"{prefixEval}integer_with_metadata{suffixEval}").Respond(mediaType,
+            "{\"trackEvents\":true,\"variationType\":\"True\",\"failed\":false,\"version\":\"\",\"reason\":\"TARGETING_MATCH\",\"errorCode\":\"\",\"value\":100, \"metadata\": {\"key1\": \"key1\", \"key2\":1, \"key3\":1.345, \"key4\":true}}");
         return mockHttp;
     }
 
@@ -560,4 +562,28 @@ public async Task should_use_object_default_value_if_flag_not_found()
         Assert.Equal(ErrorType.FlagNotFound, res.Result.ErrorType);
         Assert.Equal("flag does_not_exists was not found in your configuration", res.Result.ErrorMessage);
     }
-}
+
+    [Fact]
+    public async Task should_resolve_a_flag_with_metadata()
+    {
+        var g = new GoFeatureFlagProvider(new GoFeatureFlagProviderOptions
+        {
+            Endpoint = baseUrl,
+            HttpMessageHandler = _mockHttp,
+            Timeout = new TimeSpan(1000 * TimeSpan.TicksPerMillisecond)
+        });
+        await Api.Instance.SetProviderAsync(g);
+        var client = Api.Instance.GetClient("test-client");
+        var res = client.GetIntegerDetailsAsync("integer_with_metadata", 1200, _defaultEvaluationCtx);
+        Assert.NotNull(res.Result);
+        Assert.Equal(100, res.Result.Value);
+        Assert.Equal(ErrorType.None, res.Result.ErrorType);
+        Assert.Equal(Reason.TargetingMatch, res.Result.Reason);
+        Assert.Equal("True", res.Result.Variant);
+        Assert.NotNull(res.Result.FlagMetadata);
+        Assert.Equal("key1", res.Result.FlagMetadata.GetString("key1"));
+        Assert.Equal(1, res.Result.FlagMetadata.GetInt("key2"));
+        Assert.Equal(1.345, res.Result.FlagMetadata.GetDouble("key3"));
+        Assert.True(res.Result.FlagMetadata.GetBool("key4"));
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`using System.Threading.Tasks;`
`11`	`11`	`using OpenFeature.Constant;`
`12`	`12`	`using OpenFeature.Contrib.Providers.GOFeatureFlag.exception;`
	`13`	`+using OpenFeature.Contrib.Providers.GOFeatureFlag.helpers;`
`13`	`14`	`using OpenFeature.Model;`
`14`	`15`
`15`	`16`	`namespace OpenFeature.Contrib.Providers.GOFeatureFlag`
`@@ -97,7 +98,8 @@ public override async Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(str`
`97`	`98`	`{`
`98`	`99`	`var resp = await CallApi(flagKey, defaultValue, context);`
`99`	`100`	`return new ResolutionDetails<bool>(flagKey, bool.Parse(resp.value.ToString()), ErrorType.None,`
`100`		`- resp.reason, resp.variationType);`
	`101`	`+ resp.reason, resp.variationType, null,`
	`102`	`+ resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));`
`101`	`103`	`}`
`102`	`104`	`catch (FormatException e)`
`103`	`105`	`{`
`@@ -121,7 +123,8 @@ public override async Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(str`
`121`	`123`	`/// <exception cref="FlagNotFoundError">If the flag does not exists</exception>`
`122`	`124`	`/// <exception cref="GeneralError">If an unknown error happen</exception>`
`123`	`125`	`/// <exception cref="FlagDisabled">If the flag is disabled</exception>`
`124`		`- public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue,`
	`126`	`+ public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey,`
	`127`	`+ string defaultValue,`
`125`	`128`	`EvaluationContext context = null, CancellationToken cancellationToken = default)`
`126`	`129`	`{`
`127`	`130`	`try`
`@@ -130,7 +133,7 @@ public override async Task<ResolutionDetails<string>> ResolveStringValueAsync(st`
`130`	`133`	`if (!(resp.value is JsonElement element && element.ValueKind == JsonValueKind.String))`
`131`	`134`	`throw new TypeMismatchError($"flag value {flagKey} had unexpected type");`
`132`	`135`	`return new ResolutionDetails<string>(flagKey, resp.value.ToString(), ErrorType.None, resp.reason,`
`133`		`- resp.variationType);`
	`136`	`+ resp.variationType, null, resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));`
`134`	`137`	`}`
`135`	`138`	`catch (FormatException e)`
`136`	`139`	`{`
`@@ -161,7 +164,8 @@ public override async Task<ResolutionDetails<int>> ResolveIntegerValueAsync(stri`
`161`	`164`	`{`
`162`	`165`	`var resp = await CallApi(flagKey, defaultValue, context);`
`163`	`166`	`return new ResolutionDetails<int>(flagKey, int.Parse(resp.value.ToString()), ErrorType.None,`
`164`		`- resp.reason, resp.variationType);`
	`167`	`+ resp.reason, resp.variationType, null,`
	`168`	`+ resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));`
`165`	`169`	`}`
`166`	`170`	`catch (FormatException e)`
`167`	`171`	`{`
`@@ -185,15 +189,17 @@ public override async Task<ResolutionDetails<int>> ResolveIntegerValueAsync(stri`
`185`	`189`	`/// <exception cref="FlagNotFoundError">If the flag does not exists</exception>`
`186`	`190`	`/// <exception cref="GeneralError">If an unknown error happen</exception>`
`187`	`191`	`/// <exception cref="FlagDisabled">If the flag is disabled</exception>`
`188`		`- public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue,`
	`192`	`+ public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey,`
	`193`	`+ double defaultValue,`
`189`	`194`	`EvaluationContext context = null, CancellationToken cancellationToken = default)`
`190`	`195`	`{`
`191`	`196`	`try`
`192`	`197`	`{`
`193`	`198`	`var resp = await CallApi(flagKey, defaultValue, context);`
`194`	`199`	`return new ResolutionDetails<double>(flagKey,`
`195`	`200`	`double.Parse(resp.value.ToString(), CultureInfo.InvariantCulture), ErrorType.None,`
`196`		`- resp.reason, resp.variationType);`
	`201`	`+ resp.reason, resp.variationType, null,`
	`202`	`+ resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));`
`197`	`203`	`}`
`198`	`204`	`catch (FormatException e)`
`199`	`205`	`{`
`@@ -217,7 +223,8 @@ public override async Task<ResolutionDetails<double>> ResolveDoubleValueAsync(st`
`217`	`223`	`/// <exception cref="FlagNotFoundError">If the flag does not exists</exception>`
`218`	`224`	`/// <exception cref="GeneralError">If an unknown error happen</exception>`
`219`	`225`	`/// <exception cref="FlagDisabled">If the flag is disabled</exception>`
`220`		`- public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue,`
	`226`	`+ public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey,`
	`227`	`+ Value defaultValue,`
`221`	`228`	`EvaluationContext context = null, CancellationToken cancellationToken = default)`
`222`	`229`	`{`
`223`	`230`	`try`
`@@ -227,7 +234,7 @@ public override async Task<ResolutionDetails<Value>> ResolveStructureValueAsync(`
`227`	`234`	`{`
`228`	`235`	`var value = ConvertValue((JsonElement)resp.value);`
`229`	`236`	`return new ResolutionDetails<Value>(flagKey, value, ErrorType.None, resp.reason,`
`230`		`- resp.variationType);`
	`237`	`+ resp.variationType, null, resp.metadata == null ? null : new ImmutableMetadata(resp.metadata));`
`231`	`238`	`}`
`232`	`239`
`233`	`240`	`throw new TypeMismatchError($"flag value {flagKey} had unexpected type");`
`@@ -285,6 +292,7 @@ private async Task<GoFeatureFlagResponse> CallApi<T>(string flagKey, T defaultVa`
`285`	`292`	`if ("FLAG_NOT_FOUND".Equals(goffResp.errorCode))`
`286`	`293`	`throw new FlagNotFoundError($"flag {flagKey} was not found in your configuration");`
`287`	`294`
	`295`	`+ if (goffResp.metadata != null) goffResp.metadata = DictionaryConverter.ConvertDictionary(goffResp.metadata);`
`288`	`296`	`return goffResp;`
`289`	`297`	`}`
`290`	`298`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+using System.Collections.Generic;`
	`2`	`+`
`1`	`3`	`namespace OpenFeature.Contrib.Providers.GOFeatureFlag`
`2`	`4`	`{`
`3`	`5`	`/// <summary>`
`@@ -39,5 +41,10 @@ public class GoFeatureFlagResponse`
`39`	`41`	`/// value contains the result of the flag.`
`40`	`42`	`/// </summary>`
`41`	`43`	`public object value { get; set; }`
	`44`	`+`
	`45`	`+ /// <summary>`
	`46`	`+ /// metadata contains the metadata of the flag.`
	`47`	`+ /// </summary>`
	`48`	`+ public Dictionary<string, object> metadata { get; set; }`
`42`	`49`	`}`
`43`	`50`	`}`