Add support for feature management variants and telemetry

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureAllocation.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeatureAllocation
+    {
+        [JsonPropertyName("default_when_disabled")]
+        public string DefaultWhenDisabled { get; set; }
+
+        [JsonPropertyName("default_when_enabled")]
+        public string DefaultWhenEnabled { get; set; }
+
+        [JsonPropertyName("user")]
+        public IEnumerable<FeatureUserAllocation> User { get; set; }
+
+        [JsonPropertyName("group")]
+        public IEnumerable<FeatureGroupAllocation> Group { get; set; }
+
+        [JsonPropertyName("percentile")]
+        public IEnumerable<FeaturePercentileAllocation> Percentile { get; set; }
+
+        [JsonPropertyName("seed")]
+        public string Seed { get; set; }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureFlag.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
+using System.Collections.Generic;
 using System.Text.Json.Serialization;
 
 namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
@@ -15,5 +16,14 @@ internal class FeatureFlag
 
         [JsonPropertyName("conditions")]
         public FeatureConditions Conditions { get; set; }
+
+        [JsonPropertyName("variants")]
+        public IEnumerable<FeatureVariant> Variants { get; set; }
+
+        [JsonPropertyName("allocation")]
+        public FeatureAllocation Allocation { get; set; }
+
+        [JsonPropertyName("telemetry")]
+        public FeatureTelemetry Telemetry { get; set; }
     }
 }

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureGroupAllocation.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeatureGroupAllocation
+    {
+        [JsonPropertyName("variant")]
+        public string Variant { get; set; }
+
+        [JsonPropertyName("groups")]
+        public IEnumerable<string> Groups { get; set; }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureManagementConstants.cs

@@ -9,6 +9,27 @@ internal class FeatureManagementConstants
         public const string ContentType = "application/vnd.microsoft.appconfig.ff+json";
         public const string SectionName = "FeatureManagement";
         public const string EnabledFor = "EnabledFor";
+        public const string Variants = "Variants";
+        public const string Allocation = "Allocation";
+        public const string User = "User";
+        public const string Group = "Group";
+        public const string Percentile = "Percentile";
+        public const string Telemetry = "Telemetry";
+        public const string Enabled = "Enabled";
+        public const string Metadata = "Metadata";
         public const string RequirementType = "RequirementType";
+        public const string Name = "Name";
+        public const string Parameters = "Parameters";
+        public const string Variant = "Variant";
+        public const string ConfigurationValue = "ConfigurationValue";
+        public const string ConfigurationReference = "ConfigurationReference";
+        public const string StatusOverride = "StatusOverride";
+        public const string DefaultWhenDisabled = "DefaultWhenDisabled";
+        public const string DefaultWhenEnabled = "DefaultWhenEnabled";
+        public const string Users = "Users";
+        public const string Groups = "Groups";
+        public const string From = "From";
+        public const string To = "To";
+        public const string Seed = "Seed";
     }
 }

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureManagementKeyValueAdapter.cs

@@ -27,14 +27,16 @@ public Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Configura
 
             var keyValues = new List<KeyValuePair<string, string>>();
 
+            string featureFlagPath = $"{FeatureManagementConstants.SectionName}:{featureFlag.Id}";
+
             if (featureFlag.Enabled)
             {
                 //if (featureFlag.Conditions?.ClientFilters == null)
                 if (featureFlag.Conditions?.ClientFilters == null || !featureFlag.Conditions.ClientFilters.Any()) // workaround since we are not yet setting client filters to null
                 {
                     //
                     // Always on
-                    keyValues.Add(new KeyValuePair<string, string>($"{FeatureManagementConstants.SectionName}:{featureFlag.Id}", true.ToString()));
+                    keyValues.Add(new KeyValuePair<string, string>(featureFlagPath, true.ToString()));
                 }
                 else
                 {
@@ -44,11 +46,13 @@ public Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Configura
                     {
                         ClientFilter clientFilter = featureFlag.Conditions.ClientFilters[i];
 
-                        keyValues.Add(new KeyValuePair<string, string>($"{FeatureManagementConstants.SectionName}:{featureFlag.Id}:{FeatureManagementConstants.EnabledFor}:{i}:Name", clientFilter.Name));
+                        string clientFiltersPath = $"{featureFlagPath}:{FeatureManagementConstants.EnabledFor}:{i}";
+
+                        keyValues.Add(new KeyValuePair<string, string>($"{clientFiltersPath}:{FeatureManagementConstants.Name}", clientFilter.Name));
 
                         foreach (KeyValuePair<string, string> kvp in new JsonFlattener().FlattenJson(clientFilter.Parameters))
                         {
-                            keyValues.Add(new KeyValuePair<string, string>($"{FeatureManagementConstants.SectionName}:{featureFlag.Id}:{FeatureManagementConstants.EnabledFor}:{i}:Parameters:{kvp.Key}", kvp.Value));
+                            keyValues.Add(new KeyValuePair<string, string>($"{clientFiltersPath}:{FeatureManagementConstants.Parameters}:{kvp.Key}", kvp.Value));
                         }
                     }
 
@@ -57,7 +61,7 @@ public Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Configura
                     if (featureFlag.Conditions.RequirementType != null)
                     {
                         keyValues.Add(new KeyValuePair<string, string>(
-                            $"{FeatureManagementConstants.SectionName}:{featureFlag.Id}:{FeatureManagementConstants.RequirementType}", 
+                            $"{featureFlagPath}:{FeatureManagementConstants.RequirementType}", 
                             featureFlag.Conditions.RequirementType));
                     }
                 }
@@ -67,6 +71,135 @@ public Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Configura
                 keyValues.Add(new KeyValuePair<string, string>($"{FeatureManagementConstants.SectionName}:{featureFlag.Id}", false.ToString()));
             }
 
+            if (featureFlag.Variants != null)
+            {
+                int i = 0;
+
+                foreach (FeatureVariant featureVariant in featureFlag.Variants)
+                {
+                    string variantsPath = $"{featureFlagPath}:{FeatureManagementConstants.Variants}:{i}";
+
+                    keyValues.Add(new KeyValuePair<string, string>($"{variantsPath}:{FeatureManagementConstants.Name}", featureVariant.Name));
+
+                    if (featureVariant.ConfigurationValue != null)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{variantsPath}:{FeatureManagementConstants.ConfigurationValue}", featureVariant.ConfigurationValue));
+                    }
+
+                    if (featureVariant.ConfigurationReference != null)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{variantsPath}:{FeatureManagementConstants.ConfigurationReference}", featureVariant.ConfigurationReference));
+                    }
+
+                    if (featureVariant.StatusOverride != null)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{variantsPath}:{FeatureManagementConstants.StatusOverride}", featureVariant.StatusOverride));
+                    }
+
+                    i++;
+                }
+            }
+
+            if (featureFlag.Allocation != null)
+            {
+                FeatureAllocation allocation = featureFlag.Allocation;
+
+                string allocationPath = $"{featureFlagPath}:{FeatureManagementConstants.Allocation}";
+
+                if (allocation.DefaultWhenDisabled != null)
+                {
+                    keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.DefaultWhenDisabled}", allocation.DefaultWhenDisabled));
+                }
+
+                if (allocation.DefaultWhenEnabled != null)
+                {
+                    keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.DefaultWhenEnabled}", allocation.DefaultWhenEnabled));
+                }
+
+                if (allocation.User != null)
+                {
+                    int i = 0;
+
+                    foreach (FeatureUserAllocation userAllocation in allocation.User)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.User}:{i}:{FeatureManagementConstants.Variant}", userAllocation.Variant));
+
+                        int j = 0;
+
+                        foreach (string user in userAllocation.Users)
+                        {
+                            keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.User}:{i}:{FeatureManagementConstants.Users}:{j}", user));
+
+                            j++;
+                        }
+
+                        i++;
+                    }
+                }
+
+                if (allocation.Group != null)
+                {
+                    int i = 0;
+
+                    foreach (FeatureGroupAllocation groupAllocation in allocation.Group)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Group}:{i}:{FeatureManagementConstants.Variant}", groupAllocation.Variant));
+
+                        int j = 0;
+
+                        foreach (string group in groupAllocation.Groups)
+                        {
+                            keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Group}:{i}:{FeatureManagementConstants.Groups}:{j}", group));
+
+                            j++;
+                        }
+
+                        i++;
+                    }
+                }
+
+                if (allocation.Percentile != null)
+                {
+                    int i = 0;
+
+                    foreach (FeaturePercentileAllocation percentileAllocation in allocation.Percentile)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Percentile}:{i}:{FeatureManagementConstants.Variant}", percentileAllocation.Variant));
+
+                        keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Percentile}:{i}:{FeatureManagementConstants.From}", percentileAllocation.From.ToString()));
+
+                        keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Percentile}:{i}:{FeatureManagementConstants.To}", percentileAllocation.To.ToString()));
+
+                        i++;
+                    }
+                }
+
+                if (allocation.Seed != null)
+                {
+                    keyValues.Add(new KeyValuePair<string, string>($"{allocationPath}:{FeatureManagementConstants.Seed}", allocation.Seed));
+                }
+            }
+
+            if (featureFlag.Telemetry != null)
+            {
+                FeatureTelemetry telemetry = featureFlag.Telemetry;
+
+                string telemetryPath = $"{featureFlagPath}:{FeatureManagementConstants.Telemetry}";
+
+                if (telemetry.Enabled)
+                {
+                    keyValues.Add(new KeyValuePair<string, string>($"{telemetryPath}:{FeatureManagementConstants.Enabled}", telemetry.Enabled.ToString()));
+                }
+
+                if (telemetry.Metadata != null)
+                {
+                    foreach (KeyValuePair<string, string> kvp in telemetry.Metadata)
+                    {
+                        keyValues.Add(new KeyValuePair<string, string>($"{telemetryPath}:{FeatureManagementConstants.Metadata}:{kvp.Key}", kvp.Value));
+                    }
+                }
+            }
+
             return Task.FromResult<IEnumerable<KeyValuePair<string, string>>>(keyValues);
         }
 

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeaturePercentileAllocation.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeaturePercentileAllocation
+    {
+        [JsonPropertyName("variant")]
+        public string Variant { get; set; }
+
+        [JsonPropertyName("from")]
+        public double From { get; set; }
+
+        [JsonPropertyName("to")]
+        public double To { get; set; }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureTelemetry.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeatureTelemetry
+    {
+        [JsonPropertyName("enabled")]
+        public bool Enabled { get; set; }
+
+        [JsonPropertyName("metadata")]
+        public IReadOnlyDictionary<string, string> Metadata { get; set; }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureUserAllocation.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeatureUserAllocation
+    {
+        [JsonPropertyName("variant")]
+        public string Variant { get; set; }
+
+        [JsonPropertyName("users")]
+        public IEnumerable<string> Users { get; set; }
+    }
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureVariant.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
+{
+    internal class FeatureVariant
+    {
+        [JsonPropertyName("name")]
+        public string Name { get; set; }
+
+        [JsonPropertyName("configuration_value")]
+        public string ConfigurationValue { get; set; }
+
+        [JsonPropertyName("configuration_reference")]
+        public string ConfigurationReference { get; set; }
+
+        [JsonPropertyName("status_override")]
+        public string StatusOverride { get; set; }
+    }
+}