feat: add variation Id to evaluation detail (#23)

* add new property'ValueId' to EvalDetail

* some refactoring

* fixed bug

* more asserts

* revert csproj file encoding change

* fixed typo

* nit

* fixed xml comment

---------

Co-authored-by: deleteLater <mikcczhang@gmail.com>

Author: terriblesheep

src/FeatBit.ServerSdk/Evaluation/EvalDetail.cs

@@ -23,19 +23,26 @@ public class EvalDetail<TValue>
         /// </summary>
         public TValue Value { get; set; }
 
+        /// <summary>
+        /// The id of the flag value that was returned.
+        /// </summary>
+        public string ValueId { get; set; }
+
         /// <summary>
         /// Constructs a new EvalDetail instance.
         /// </summary>
         /// <param name="key">the flag key</param>
         /// <param name="kind">the reason kind</param>
         /// <param name="reason">the evaluation reason</param>
         /// <param name="value">the flag value</param>
-        public EvalDetail(string key, ReasonKind kind, string reason, TValue value)
+        /// <param name="valueId">the id of flag value</param>
+        public EvalDetail(string key, ReasonKind kind, string reason, TValue value, string valueId)
         {
             Key = key;
             Kind = kind;
             Reason = reason;
             Value = value;
+            ValueId = valueId;
         }
     }
 }

src/FeatBit.ServerSdk/Evaluation/EvalResult.cs

@@ -1,3 +1,5 @@
+using FeatBit.Sdk.Server.Model;
+
 namespace FeatBit.Sdk.Server.Evaluation
 {
     internal class EvalResult
@@ -6,42 +8,45 @@ internal class EvalResult
 
         public string Reason { get; set; }
 
-        public string Value { get; set; }
+        public Variation Variation { get; set; }
 
-        private EvalResult(ReasonKind kind, string reason, string value)
+        private EvalResult(ReasonKind kind, string reason, Variation variation)
         {
             Kind = kind;
             Reason = reason;
-            Value = value;
+            Variation = variation;
         }
 
         // Indicates that the caller provided a flag key that did not match any known flag.
-        public static readonly EvalResult FlagNotFound =
-            new EvalResult(ReasonKind.Error, "flag not found", string.Empty);
+        public static readonly EvalResult FlagNotFound = new(ReasonKind.Error, "flag not found", Variation.Empty);
 
         // Indicates that there was an internal inconsistency in the flag data, e.g. a rule specified a nonexistent
         // variation. 
-        public static readonly EvalResult MalformedFlag =
-            new EvalResult(ReasonKind.Error, "malformed flag", string.Empty);
+        public static readonly EvalResult MalformedFlag = new(ReasonKind.Error, "malformed flag", Variation.Empty);
 
-        public static EvalResult FlagOff(string value)
+        public static EvalResult FlagOff(Variation variation)
         {
-            return new EvalResult(ReasonKind.Off, "flag off", value);
+            return new EvalResult(ReasonKind.Off, "flag off", variation);
         }
 
-        public static EvalResult Targeted(string value)
+        public static EvalResult Targeted(Variation variation)
         {
-            return new EvalResult(ReasonKind.TargetMatch, "target match", value);
+            return new EvalResult(ReasonKind.TargetMatch, "target match", variation);
         }
 
-        public static EvalResult RuleMatched(string value, string ruleName)
+        public static EvalResult RuleMatched(string ruleName, Variation value)
         {
             return new EvalResult(ReasonKind.RuleMatch, $"match rule {ruleName}", value);
         }
 
-        public static EvalResult Fallthrough(string value)
+        public static EvalResult Fallthrough(Variation variation)
+        {
+            return new EvalResult(ReasonKind.Fallthrough, "fall through targets and rules", variation);
+        }
+
+        public EvalDetail<string> AsEvalDetail(string key)
         {
-            return new EvalResult(ReasonKind.Fallthrough, "fall through targets and rules", value);
+            return new EvalDetail<string>(key, Kind, Reason, Variation.Value, Variation.Id);
         }
     }
 

src/FeatBit.ServerSdk/Evaluation/Evaluator.cs

@@ -27,7 +27,7 @@ public Evaluator(IMemoryStore store)
 
             return Evaluate(flag, context.FbUser);
 
-            (EvalResult EvalResult, EvalEvent evalEvent) FlagNotFound() => (EvalResult.FlagNotFound, null);
+            (EvalResult evalResult, EvalEvent evalEvent) FlagNotFound() => (EvalResult.FlagNotFound, null);
         }
 
         public (EvalResult evalResult, EvalEvent evalEvent) Evaluate(FeatureFlag flag, FbUser user)
@@ -91,19 +91,19 @@ public Evaluator(IMemoryStore store)
 
             return Fallthrough();
 
-            (EvalResult EvalResult, EvalEvent evalEvent) MalformedFlag() => (EvalResult.MalformedFlag, null);
+            (EvalResult evalResult, EvalEvent evalEvent) MalformedFlag() => (EvalResult.MalformedFlag, null);
 
-            (EvalResult EvalResult, EvalEvent evalEvent) FlagOff(Variation variation) =>
-                (EvalResult.FlagOff(variation.Value), new EvalEvent(user, flagKey, variation, false));
+            (EvalResult evalResult, EvalEvent evalEvent) FlagOff(Variation variation) =>
+                (EvalResult.FlagOff(variation), new EvalEvent(user, flagKey, variation, false));
 
-            (EvalResult EvalResult, EvalEvent evalEvent) Targeted(Variation variation, bool exptIncludeAllTargets) =>
-                (EvalResult.Targeted(variation.Value), new EvalEvent(user, flagKey, variation, exptIncludeAllTargets));
+            (EvalResult evalResult, EvalEvent evalEvent) Targeted(Variation variation, bool exptIncludeAllTargets) =>
+                (EvalResult.Targeted(variation), new EvalEvent(user, flagKey, variation, exptIncludeAllTargets));
 
-            (EvalResult EvalResult, EvalEvent evalEvent) RuleMatched(TargetRule rule, RolloutVariation rolloutVariation)
+            (EvalResult evalResult, EvalEvent evalEvent) RuleMatched(TargetRule rule, RolloutVariation rolloutVariation)
             {
                 var variation = flag.GetVariation(rolloutVariation.Id);
 
-                var evalResult = EvalResult.RuleMatched(variation.Value, rule.Name);
+                var evalResult = EvalResult.RuleMatched(rule.Name, variation);
 
                 var sendToExperiment = IsSendToExperiment(
                     flag.ExptIncludeAllTargets,
@@ -116,11 +116,11 @@ public Evaluator(IMemoryStore store)
                 return (evalResult, evalEvent);
             }
 
-            (EvalResult EvalResult, EvalEvent evalEvent) Fallthrough()
+            (EvalResult evalResult, EvalEvent evalEvent) Fallthrough()
             {
                 var variation = flag.GetVariation(defaultVariation.Id);
 
-                var evalResult = EvalResult.Fallthrough(variation.Value);
+                var evalResult = EvalResult.Fallthrough(variation);
 
                 var sendToExperiment = IsSendToExperiment(
                     flag.ExptIncludeAllTargets,

src/FeatBit.ServerSdk/FbClient.cs

@@ -248,8 +248,8 @@ public EvalDetail<string>[] GetAllVariations(FbUser user)
                 .Find<FeatureFlag>(x => x.StoreKey.StartsWith(StoreKeys.FlagPrefix))
                 .Select(flag =>
                 {
-                    var evalResult = _evaluator.Evaluate(flag, user).evalResult;
-                    return new EvalDetail<string>(flag.Key, evalResult.Kind, evalResult.Reason, evalResult.Value);
+                    var (evalResult, _) = _evaluator.Evaluate(flag, user);
+                    return evalResult.AsEvalDetail(flag.Key);
                 })
                 .ToArray();
 
@@ -290,7 +290,7 @@ private EvalDetail<TValue> EvaluateCore<TValue>(
             if (!Initialized)
             {
                 // Flag evaluation before client initialized; always returning default value
-                return new EvalDetail<TValue>(key, ReasonKind.ClientNotReady, "client not ready", defaultValue);
+                return new EvalDetail<TValue>(key, ReasonKind.ClientNotReady, "client not ready", defaultValue, string.Empty);
             }
 
             var ctx = new EvaluationContext
@@ -303,16 +303,17 @@ private EvalDetail<TValue> EvaluateCore<TValue>(
             if (evalResult.Kind == ReasonKind.Error)
             {
                 // error happened when evaluate flag, return default value 
-                return new EvalDetail<TValue>(key, evalResult.Kind, evalResult.Reason, defaultValue);
+                return new EvalDetail<TValue>(key, evalResult.Kind, evalResult.Reason, defaultValue, string.Empty);
             }
 
             // record evaluation event
             _eventProcessor.Record(evalEvent);
 
-            return converter(evalResult.Value, out var typedValue)
-                ? new EvalDetail<TValue>(key, evalResult.Kind, evalResult.Reason, typedValue)
+            var variation = evalResult.Variation;
+            return converter(variation.Value, out var typedValue)
+                ? new EvalDetail<TValue>(key, evalResult.Kind, evalResult.Reason, typedValue, variation.Id)
                 // type mismatch, return default value
-                : new EvalDetail<TValue>(key, ReasonKind.WrongType, "type mismatch", defaultValue);
+                : new EvalDetail<TValue>(key, ReasonKind.WrongType, "type mismatch", defaultValue, string.Empty);
         }
     }
 }

src/FeatBit.ServerSdk/IFbClient.cs

@@ -182,7 +182,7 @@ public interface IFbClient
     /// Returns the variation of all feature flags for a given user, which can be passed to front-end code.
     /// </summary>
     /// <param name="user">a given user</param>
-    /// <returns>an <see cref="EvalResult"/> array</returns>
+    /// <returns>an <see cref="EvalDetail{T}"/> array</returns>
     EvalDetail<string>[] GetAllVariations(FbUser user);
 
     /// <summary>

src/FeatBit.ServerSdk/Model/Variation.cs

@@ -5,5 +5,11 @@ internal sealed class Variation
         public string Id { get; set; }
 
         public string Value { get; set; }
+
+        public static readonly Variation Empty = new()
+        {
+            Id = string.Empty,
+            Value = string.Empty
+        };
     }
 }

tests/FeatBit.ServerSdk.Tests/Evaluation/EvaluatorTests.cs

@@ -5,6 +5,9 @@ namespace FeatBit.Sdk.Server.Evaluation;
 
 public class EvaluatorTests
 {
+    private static readonly Variation TrueVariation = new() { Id = "trueId", Value = "true" };
+    private static readonly Variation FalseVariation = new() { Id = "falseId", Value = "false" };
+
     [Fact]
     public void EvaluateFlagNotFound()
     {
@@ -19,8 +22,8 @@ public void EvaluateFlagNotFound()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.Error, evalResult.Kind);
-        Assert.Equal(string.Empty, evalResult.Value);
         Assert.Equal("flag not found", evalResult.Reason);
+        Assert.Equivalent(Variation.Empty, evalResult.Variation);
 
         Assert.Null(evalEvent);
     }
@@ -33,7 +36,7 @@ public void EvaluateMalformedFlag()
             .Key("hello")
             .IsEnabled(false)
             .DisabledVariationId("not-exist-variation-id")
-            .Variations(new Variation { Id = "trueId", Value = "true" })
+            .Variations(TrueVariation)
             .Build();
         store.Populate(new[] { malformedFlag });
 
@@ -47,8 +50,8 @@ public void EvaluateMalformedFlag()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.Error, evalResult.Kind);
-        Assert.Equal(string.Empty, evalResult.Value);
         Assert.Equal("malformed flag", evalResult.Reason);
+        Assert.Equivalent(Variation.Empty, evalResult.Variation);
 
         Assert.Null(evalEvent);
     }
@@ -61,7 +64,7 @@ public void EvaluateFlagOffResult()
             .Key("hello")
             .IsEnabled(false)
             .DisabledVariationId("trueId")
-            .Variations(new Variation { Id = "trueId", Value = "true" })
+            .Variations(TrueVariation)
             .Build();
         store.Populate(new[] { flag });
 
@@ -75,8 +78,8 @@ public void EvaluateFlagOffResult()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.Off, evalResult.Kind);
-        Assert.Equal("true", evalResult.Value);
         Assert.Equal("flag off", evalResult.Reason);
+        Assert.Equivalent(TrueVariation, evalResult.Variation);
 
         // flag is off
         Assert.False(evalEvent.SendToExperiment);
@@ -87,11 +90,7 @@ public void EvaluateTargetedResult()
     {
         var store = new DefaultMemoryStore();
 
-        var variations = new Variation[]
-        {
-            new() { Id = "trueId", Value = "true" },
-            new() { Id = "falseId", Value = "false" }
-        };
+        var variations = new[] { TrueVariation, FalseVariation };
         var targetUser = new TargetUser
         {
             VariationId = "falseId", KeyIds = new List<string> { "u1" }
@@ -115,8 +114,8 @@ public void EvaluateTargetedResult()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.TargetMatch, evalResult.Kind);
-        Assert.Equal("false", evalResult.Value);
         Assert.Equal("target match", evalResult.Reason);
+        Assert.Equivalent(FalseVariation, evalResult.Variation);
 
         // ExptIncludeAllTargets is true by default
         Assert.True(evalEvent.SendToExperiment);
@@ -127,11 +126,7 @@ public void EvaluatorRuleMatchedResult()
     {
         var store = new DefaultMemoryStore();
 
-        var variations = new Variation[]
-        {
-            new() { Id = "trueId", Value = "true" },
-            new() { Id = "falseId", Value = "false" }
-        };
+        var variations = new[] { TrueVariation, FalseVariation };
         var customRule = new TargetRule
         {
             Name = "open for vip & svip",
@@ -178,8 +173,8 @@ public void EvaluatorRuleMatchedResult()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.RuleMatch, evalResult.Kind);
-        Assert.Equal("true", evalResult.Value);
         Assert.Equal($"match rule {customRule.Name}", evalResult.Reason);
+        Assert.Equivalent(TrueVariation, evalResult.Variation);
 
         // customRule.IncludedInExpt is false
         Assert.False(evalEvent.SendToExperiment);
@@ -230,8 +225,8 @@ public void EvaluateFallthroughResult()
         var (evalResult, evalEvent) = evaluator.Evaluate(context);
 
         Assert.Equal(ReasonKind.Fallthrough, evalResult.Kind);
-        Assert.Equal("false", evalResult.Value);
         Assert.Equal("fall through targets and rules", evalResult.Reason);
+        Assert.Equivalent(FalseVariation, evalResult.Variation);
 
         Assert.True(evalEvent.SendToExperiment);
     }

tests/FeatBit.ServerSdk.Tests/FbClientTests.cs

@@ -62,6 +62,7 @@ public void GetVariationDetail()
         var variationDetail = client.BoolVariationDetail("returns-true", user);
         Assert.Equal("returns-true", variationDetail.Key);
         Assert.True(variationDetail.Value);
+        Assert.Equal("3da96792-debf-4878-905a-c9b5f9178cd0", variationDetail.ValueId);
         Assert.Equal(ReasonKind.Fallthrough, variationDetail.Kind);
         Assert.Equal("fall through targets and rules", variationDetail.Reason);
 
@@ -80,6 +81,7 @@ public void GetAllVariations()
         var result0 = results[0];
         Assert.Equal("returns-true", result0.Key);
         Assert.Equal("true", result0.Value);
+        Assert.Equal("3da96792-debf-4878-905a-c9b5f9178cd0", result0.ValueId);
         Assert.Equal(ReasonKind.Fallthrough, result0.Kind);
         Assert.Equal("fall through targets and rules", result0.Reason);
     }