prepare 5.8.0 release (#110)

Author: eli-darkly

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to the LaunchDarkly .NET Server-Side SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.8.0] - 2019-10-01
+### Added:
+- Added support for upcoming LaunchDarkly experimentation features. See `ILdClient.Track(string, User, LdValue, double)`.
+ 
+### Fixed:
+- Fixed a bug due to incorrect use of a lock that could cause a read from `InMemoryFeatureStore` to fail if done at the same time as an update. (Thanks, [JeffAshton](https://github.com/launchdarkly/dotnet-server-sdk/pull/109)!)
+
 ## [5.7.1] - 2019-09-13
 _(The changes below were originally released in 5.7.0, but that release was broken; 5.7.1 is its replacement.)_
 

src/LaunchDarkly.ServerSdk/FeatureFlag.cs

@@ -33,6 +33,8 @@ internal class FeatureFlag : IVersionedData, IFlagEventProperties
         internal List<JToken> Variations { get; private set; }
         [JsonProperty(PropertyName = "trackEvents")]
         public bool TrackEvents { get; private set; }
+        [JsonProperty(PropertyName = "trackEventsFallthrough")]
+        public bool TrackEventsFallthrough { get; private set; }
         [JsonProperty(PropertyName = "debugEventsUntilDate")]
         public long? DebugEventsUntilDate { get; private set; }
         [JsonProperty(PropertyName = "deleted")]
@@ -43,7 +45,7 @@ internal class FeatureFlag : IVersionedData, IFlagEventProperties
         [JsonConstructor]
         internal FeatureFlag(string key, int version, bool on, List<Prerequisite> prerequisites, string salt,
             List<Target> targets, List<Rule> rules, VariationOrRollout fallthrough, int? offVariation,
-            List<JToken> variations, bool trackEvents, long? debugEventsUntilDate,
+            List<JToken> variations, bool trackEvents, bool trackEventsFallthrough, long? debugEventsUntilDate,
             bool deleted, bool clientSide)
         {
             Key = key;
@@ -57,6 +59,7 @@ internal FeatureFlag(string key, int version, bool on, List<Prerequisite> prereq
             OffVariation = offVariation;
             Variations = variations;
             TrackEvents = trackEvents;
+            TrackEventsFallthrough = trackEventsFallthrough;
             DebugEventsUntilDate = debugEventsUntilDate;
             Deleted = deleted;
             ClientSide = clientSide;
@@ -66,6 +69,13 @@ internal FeatureFlag()
         {
         }
 
+        internal FeatureFlag(string key, int version, bool deleted)
+        {
+            Key = key;
+            Version = version;
+            Deleted = deleted;
+        }
+        
         internal struct EvalResult
         {
             internal EvaluationDetail<LdValue> Result;
@@ -77,13 +87,21 @@ internal EvalResult(EvaluationDetail<LdValue> result, IList<FeatureRequestEvent>
                 PrerequisiteEvents = events;
             }
         }
-
+        
         int IFlagEventProperties.EventVersion => Version;
 
         // This method is called by EventFactory to determine if extra tracking should be
-        // enabled for an event, based on the evaluation reason. It is not enabled yet.
+        // enabled for an event, based on the evaluation reason.
         bool IFlagEventProperties.IsExperiment(EvaluationReason reason)
         {
+            switch (reason)
+            {
+                case EvaluationReason.Fallthrough _:
+                    return TrackEventsFallthrough;
+                case EvaluationReason.RuleMatch r:
+                    return r.RuleIndex >= 0 && Rules != null && r.RuleIndex < Rules.Count &&
+                        Rules[r.RuleIndex].TrackEvents;
+            }
             return false;
         }
 

src/LaunchDarkly.ServerSdk/ILdClient.cs

@@ -355,6 +355,22 @@ public interface ILdClient : ILdCommonClient
         // passing null for data will not be an ambiguous method call.
 
         /// <summary>
+        /// Tracks that a user performed an event, and provides an additional numeric value for custom metrics.
+        /// </summary>
+        /// <remarks>
+        /// As of this version’s release date, the LaunchDarkly service does not support the <c>metricValue</c>
+        /// parameter. As a result, calling this overload of <c>Track</c> will not yet produce any different
+        /// behavior from calling <see cref="Track(string, JToken, User)"/> without a <c>metricValue</c>. Refer
+        /// to the SDK reference guide for the latest status:
+        /// https://docs.launchdarkly.com/docs/dotnet-sdk-reference#section-track
+        /// </remarks>
+        /// <param name="name">the name of the event</param>
+        /// <param name="user">the user that performed the event</param>
+        /// <param name="data">additional data associated with the event, or null</param>
+        /// <param name="metricValue">A numeric value used by the LaunchDarkly experimentation feature in numeric custom
+        /// metrics. This field will also be returned as part of the custom event for Data Export.</param>
+        void Track(string name, User user, LdValue data, double metricValue);
+
         /// Tracks that a user performed an event.
         /// </summary>
         /// <remarks>

src/LaunchDarkly.ServerSdk/LaunchDarkly.ServerSdk.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <Version>5.7.1</Version>
+    <Version>5.8.0</Version>
     <TargetFrameworks>netstandard1.4;netstandard1.6;netstandard2.0;net45</TargetFrameworks>
     <PackageLicenseUrl>https://raw.githubusercontent.com/launchdarkly/dotnet-server-sdk/master/LICENSE</PackageLicenseUrl>
     <DebugType>portable</DebugType>

src/LaunchDarkly.ServerSdk/LdClient.cs

@@ -432,6 +432,16 @@ public void Track(string name, User user, LdValue data)
             _eventProcessor.SendEvent(EventFactory.Default.NewCustomEvent(name, user, data));
         }
 
+        /// <inheritdoc/>
+        public void Track(string name, User user, LdValue data, double metricValue)
+        {
+            if (user == null || user.Key == null)
+            {
+                Log.Warn("Track called with null user or null user key");
+            }
+            _eventProcessor.SendEvent(EventFactory.Default.NewCustomEvent(name, user, data, metricValue));
+        }
+
         /// <inheritdoc/>
         public void Identify(User user)
         {

src/LaunchDarkly.ServerSdk/Rule.cs

@@ -11,11 +11,15 @@ internal class Rule : VariationOrRollout
         [JsonProperty(PropertyName = "clauses")]
         internal List<Clause> Clauses { get; private set; }
 
+        [JsonProperty(PropertyName = "trackEvents")]
+        internal bool TrackEvents { get; private set; }
+
         [JsonConstructor]
-        internal Rule(string id, int? variation, Rollout rollout, List<Clause> clauses) : base(variation, rollout)
+        internal Rule(string id, int? variation, Rollout rollout, List<Clause> clauses, bool trackEvents) : base(variation, rollout)
         {
             Id = id;
             Clauses = clauses;
+            TrackEvents = trackEvents;
         }
 
         internal bool MatchesUser(User user, IFeatureStore store)

src/LaunchDarkly.ServerSdk/VersionedDataKind.cs

@@ -115,7 +115,7 @@ internal FeaturesVersionedDataKind() : base("features", typeof(FeatureFlag), "/f
 
         public override FeatureFlag MakeDeletedItem(string key, int version)
         {
-            return new FeatureFlag(key, version, false, null, "", null, null, null, null, null, false, null, true, false);
+            return new FeatureFlag(key, version, true);
         }
 
         public override IEnumerable<string> GetDependencyKeys(IVersionedData item)

test/LaunchDarkly.ServerSdk.Tests/FeatureFlagBuilder.cs

@@ -19,6 +19,7 @@ internal class FeatureFlagBuilder
         private int? _offVariation;
         private List<JToken> _variations;
         private bool _trackEvents;
+        private bool _trackEventsFallthrough;
         private long? _debugEventsUntilDate;
         private bool _deleted;
         private bool _clientSide;
@@ -41,6 +42,7 @@ internal FeatureFlagBuilder(FeatureFlag from)
             _offVariation = from.OffVariation;
             _variations = from.Variations;
             _trackEvents = from.TrackEvents;
+            _trackEventsFallthrough = from.TrackEventsFallthrough;
             _debugEventsUntilDate = from.DebugEventsUntilDate;
             _deleted = from.Deleted;
             _clientSide = from.ClientSide;
@@ -50,7 +52,7 @@ internal FeatureFlag Build()
         {
             return new FeatureFlag(_key, _version, _on, _prerequisites, _salt,
                 _targets, _rules, _fallthrough, _offVariation, _variations,
-                _trackEvents, _debugEventsUntilDate, _deleted, _clientSide);
+                _trackEvents, _trackEventsFallthrough, _debugEventsUntilDate, _deleted, _clientSide);
         }
 
         internal FeatureFlagBuilder Version(int version)
@@ -71,6 +73,11 @@ internal FeatureFlagBuilder Prerequisites(List<Prerequisite> prerequisites)
             return this;
         }
 
+        internal FeatureFlagBuilder Prerequisites(params Prerequisite[] prerequisites)
+        {
+            return Prerequisites(new List<Prerequisite>(prerequisites));
+        }
+
         internal FeatureFlagBuilder Salt(string salt)
         {
             _salt = salt;
@@ -83,12 +90,22 @@ internal FeatureFlagBuilder Targets(List<Target> targets)
             return this;
         }
 
+        internal FeatureFlagBuilder Targets(params Target[] targets)
+        {
+            return Targets(new List<Target>(targets));
+        }
+
         internal FeatureFlagBuilder Rules(List<Rule> rules)
         {
             _rules = rules;
             return this;
         }
 
+        internal FeatureFlagBuilder Rules(params Rule[] rules)
+        {
+            return Rules(new List<Rule>(rules));
+        }
+
         internal FeatureFlagBuilder Fallthrough(VariationOrRollout fallthrough)
         {
             _fallthrough = fallthrough;
@@ -113,12 +130,23 @@ internal FeatureFlagBuilder Variations(List<JToken> variations)
             return this;
         }
 
+        internal FeatureFlagBuilder Variations(params JToken[] variations)
+        {
+            return Variations(new List<JToken>(variations));
+        }
+
         internal FeatureFlagBuilder TrackEvents(bool trackEvents)
         {
             _trackEvents = trackEvents;
             return this;
         }
 
+        internal FeatureFlagBuilder TrackEventsFallthrough(bool trackEventsFallthrough)
+        {
+            _trackEventsFallthrough = trackEventsFallthrough;
+            return this;
+        }
+
         internal FeatureFlagBuilder DebugEventsUntilDate(long? debugEventsUntilDate)
         {
             _debugEventsUntilDate = debugEventsUntilDate;
@@ -139,19 +167,120 @@ internal FeatureFlagBuilder Deleted(bool deleted)
 
         internal FeatureFlagBuilder OffWithValue(JToken value)
         {
-            _on = false;
-            _offVariation = 0;
-            _variations = new List<JToken> { value };
-            return this;
+            return On(false).OffVariation(0).Variations(value);
         }
 
         internal FeatureFlagBuilder BooleanWithClauses(params Clause[] clauses)
         {
-            _on = true;
-            _offVariation = 0;
-            _variations = new List<JToken> { new JValue(false), new JValue(true) };
-            _rules = new List<Rule> { new Rule("id", 1, null, new List<Clause>(clauses)) };
+            return On(true).OffVariation(0)
+                .Variations(new JValue(false), new JValue(true))
+                .Rules(new RuleBuilder().Id("id").Variation(1).Clauses(clauses).Build());
+        }
+    }
+
+    internal class RuleBuilder
+    {
+        private string _id = "";
+        private int? _variation = null;
+        private Rollout _rollout = null;
+        private List<Clause> _clauses = new List<Clause>();
+        private bool _trackEvents = false;
+
+        internal Rule Build()
+        {
+            return new Rule(_id, _variation, _rollout, _clauses, _trackEvents);
+        }
+
+        internal RuleBuilder Id(string id)
+        {
+            _id = id;
+            return this;
+        }
+
+        internal RuleBuilder Variation(int? variation)
+        {
+            _variation = variation;
+            return this;
+        }
+
+        internal RuleBuilder Rollout(Rollout rollout)
+        {
+            _rollout = rollout;
+            return this;
+        }
+
+        internal RuleBuilder Clauses(List<Clause> clauses)
+        {
+            _clauses = clauses;
+            return this;
+        }
+
+        internal RuleBuilder Clauses(params Clause[] clauses)
+        {
+            return Clauses(new List<Clause>(clauses));
+        }
+
+        internal RuleBuilder TrackEvents(bool trackEvents)
+        {
+            _trackEvents = trackEvents;
+            return this;
+        }
+    }
+
+    internal class ClauseBuilder
+    {
+        private string _attribute;
+        private string _op;
+        private List<JValue> _values = new List<JValue>();
+        private bool _negate;
+
+        internal Clause Build()
+        {
+            return new Clause(_attribute, _op, _values, _negate);
+        }
+
+        public ClauseBuilder Attribute(string attribute)
+        {
+            _attribute = attribute;
+            return this;
+        }
+
+        public ClauseBuilder Op(string op)
+        {
+            _op = op;
             return this;
         }
+
+        public ClauseBuilder Values(List<JValue> values)
+        {
+            _values = values;
+            return this;
+        }
+
+        public ClauseBuilder Values(params JValue[] values)
+        {
+            return Values(new List<JValue>(values));
+        }
+
+        public ClauseBuilder Negate(bool negate)
+        {
+            _negate = negate;
+            return this;
+        }
+
+        public ClauseBuilder KeyIs(string key)
+        {
+            return Attribute("key").Op("in").Values(new JValue(key));
+        }
+
+        public static Clause ShouldMatchUser(User user)
+        {
+            return new ClauseBuilder().KeyIs(user.Key).Build();
+        }
+
+        public static Clause ShouldNotMatchUser(User user)
+        {
+            return new ClauseBuilder().KeyIs(user.Key).Negate(true).Build();
+        }
     }
 }