Enhances FeatureManager to throw an exception for missing feature filters.

README.md

@@ -298,6 +298,17 @@ When a feature filter is registered to be used for a feature flag, the alias use
 
 This can be overridden through the use of the `FilterAliasAttribute`. A feature filter can be decorated with this attribute to declare the name that should be used in configuration to reference this feature filter within a feature flag.
 
+### Missing Feature Filters
+
+If a feature is configured to be enabled for a specific feature filter and that feature filter hasn't been registered, then an exception will be thrown when the feature is evaluated. The exception can be disabled by using the feature management options. 
+
+```
+services.Configure<FeatureManagementOptions>(options =>
+{
+    options.IgnoreMissingFeatureFilters = true;
+});
+```
+
 ### Using HttpContext
 
 Feature filters can evaluate whether a feature should be enabled based off the properties of an HTTP Request. This is performed by inspecting the HTTP Context. A feature filter can get a reference to the HTTP Context by obtaining an `IHttpContextAccessor` through dependency injection.

src/Microsoft.FeatureManagement/FeatureManagementError.cs

@@ -0,0 +1,13 @@
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// An error that can occur during feature management.
+    /// </summary>
+    public enum FeatureManagementError
+    {
+        /// <summary>
+        /// A feature filter that was listed for feature evaluation was not found.
+        /// </summary>
+        MissingFeatureFilter
+    }
+}

src/Microsoft.FeatureManagement/FeatureManagementException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// Represents errors that occur during feature management.
+    /// </summary>
+    public class FeatureManagementException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FeatureManagementException"/> class.
+        /// </summary>
+        /// <param name="errorType">The feature management error that the exception represents.</param>
+        /// <param name="message">Error message for the exception.</param>
+        public FeatureManagementException(FeatureManagementError errorType, string message)
+            : base(message)
+        {
+            Error = errorType;
+        }
+
+        /// <summary>
+        /// The feature management error that the exception represents.
+        /// </summary>
+        public FeatureManagementError Error { get; set; }
+    }
+}

src/Microsoft.FeatureManagement/FeatureManagementOptions.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// Options that control the behavior of the feature management system.
+    /// </summary>
+    public class FeatureManagementOptions
+    {
+        /// <summary>
+        /// Controls the behavior of feature evaluation when dependent feature filters are missing.
+        /// If missing feature filters are not ignored an exception will be thrown when attempting to evaluate a feature that depends on a missing feature filter.
+        /// </summary>
+        public bool IgnoreMissingFeatureFilters { get; set; }
+    }
+}

src/Microsoft.FeatureManagement/FeatureManager.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 //
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -21,15 +22,22 @@ class FeatureManager : IFeatureManager
         private readonly ILogger _logger;
         private readonly ConcurrentDictionary<string, IFeatureFilterMetadata> _filterMetadataCache;
         private readonly ConcurrentDictionary<string, ContextualFeatureFilterEvaluator> _contextualFeatureFilterCache;
-
-        public FeatureManager(IFeatureSettingsProvider settingsProvider, IEnumerable<IFeatureFilterMetadata> featureFilters, IEnumerable<ISessionManager> sessionManagers, ILoggerFactory loggerFactory)
+        private readonly FeatureManagementOptions _options;
+
+        public FeatureManager(
+            IFeatureSettingsProvider settingsProvider,
+            IEnumerable<IFeatureFilterMetadata> featureFilters,
+            IEnumerable<ISessionManager> sessionManagers,
+            ILoggerFactory loggerFactory,
+            IOptions<FeatureManagementOptions> options)
         {
             _settingsProvider = settingsProvider;
             _featureFilters = featureFilters ?? throw new ArgumentNullException(nameof(featureFilters));
             _sessionManagers = sessionManagers ?? throw new ArgumentNullException(nameof(sessionManagers));
             _logger = loggerFactory.CreateLogger<FeatureManager>();
             _filterMetadataCache = new ConcurrentDictionary<string, IFeatureFilterMetadata>();
             _contextualFeatureFilterCache = new ConcurrentDictionary<string, ContextualFeatureFilterEvaluator>();
+            _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
         }
 
         public Task<bool> IsEnabledAsync(string feature)
@@ -78,7 +86,16 @@ private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appCo
 
                         if (filter == null)
                         {
-                            _logger.LogWarning($"Feature filter '{featureFilterSettings.Name}' specified for feature '{feature}' was not found.");
+                            string errorMessage = $"The feature filter '{featureFilterSettings.Name}' specified for feature '{feature}' was not found.";
+
+                            if (!_options.IgnoreMissingFeatureFilters)
+                            {
+                                throw new FeatureManagementException(FeatureManagementError.MissingFeatureFilter, errorMessage);
+                            }
+                            else
+                            {
+                                _logger.LogWarning(errorMessage);
+                            }
 
                             continue;
                         }

tests/Tests.FeatureManagement/FeatureManagement.cs

@@ -24,6 +24,7 @@ public class FeatureManagement
         private const string OnFeature = "OnTestFeature";
         private const string OffFeature = "OffFeature";
         private const string ConditionalFeature = "ConditionalFeature";
+        private const string ContextualFeature = "ContextualFeature";
 
         [Fact]
         public async Task ReadsConfiguration()
@@ -75,18 +76,20 @@ public async Task Integrates()
             IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
 
             TestServer testServer = new TestServer(WebHost.CreateDefaultBuilder().ConfigureServices(services =>
+                {
+                    services
+                        .AddSingleton(config)
+                        .AddFeatureManagement()
+                        .AddFeatureFilter<TestFilter>();
+
+                    services.AddMvcCore(o =>
+                    {
+
+                        o.Filters.AddForFeature<MvcFilter>(ConditionalFeature);
+                    });
+                })
+            .Configure(app =>
             {
-                services
-                    .AddSingleton(config)
-                    .AddFeatureManagement()
-                    .AddFeatureFilter<TestFilter>();
-
-                services.AddMvcCore(o => {
-
-                    o.Filters.AddForFeature<MvcFilter>(ConditionalFeature);
-                });
-            })
-            .Configure(app => {
 
                 app.UseForFeature(ConditionalFeature, a => a.Use(async (ctx, next) =>
                 {
@@ -123,14 +126,14 @@ public async Task GatesFeatures()
             IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
 
             TestServer testServer = new TestServer(WebHost.CreateDefaultBuilder().ConfigureServices(services =>
-            {
-                services
-                    .AddSingleton(config)
-                    .AddFeatureManagement()
-                    .AddFeatureFilter<TestFilter>();
+                {
+                    services
+                        .AddSingleton(config)
+                        .AddFeatureManagement()
+                        .AddFeatureFilter<TestFilter>();
 
-                services.AddMvcCore();
-            })
+                    services.AddMvcCore();
+                })
             .Configure(app => app.UseMvc()));
 
             IEnumerable<IFeatureFilterMetadata> featureFilters = testServer.Host.Services.GetRequiredService<IEnumerable<IFeatureFilterMetadata>>();
@@ -269,11 +272,11 @@ public async Task UsesContext()
 
             context.AccountId = "NotEnabledAccount";
 
-            Assert.False(await featureManager.IsEnabledAsync(ConditionalFeature, context));
+            Assert.False(await featureManager.IsEnabledAsync(ContextualFeature, context));
 
             context.AccountId = "abc";
 
-            Assert.True(await featureManager.IsEnabledAsync(ConditionalFeature, context));
+            Assert.True(await featureManager.IsEnabledAsync(ContextualFeature, context));
         }
 
         [Fact]
@@ -297,5 +300,52 @@ public void LimitsFeatureFilterImplementations()
                     .AddFeatureFilter<InvalidFeatureFilter2>();
             });
         }
+
+        [Fact]
+        public async Task ThrowsExceptionForMissingFeatureFilter()
+        {
+            IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
+
+            var services = new ServiceCollection();
+
+            services
+                .AddSingleton(config)
+                .AddFeatureManagement();
+
+            ServiceProvider serviceProvider = services.BuildServiceProvider();
+
+            IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
+
+            FeatureManagementException e = await Assert.ThrowsAsync<FeatureManagementException>(async () => await featureManager.IsEnabledAsync(ConditionalFeature));
+
+            Assert.Equal(FeatureManagementError.MissingFeatureFilter, e.Error);
+        }
+
+        [Fact]
+        public async Task SwallowsExceptionForMissingFeatureFilter()
+        {
+            IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
+
+            var services = new ServiceCollection();
+
+            services
+                .Configure<FeatureManagementOptions>(options =>
+                {
+                    options.IgnoreMissingFeatureFilters = true;
+                });
+
+            services
+                .AddSingleton(config)
+                .AddFeatureManagement();
+
+            ServiceProvider serviceProvider = services.BuildServiceProvider();
+
+            IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
+
+            var isEnabled = await featureManager.IsEnabledAsync(ConditionalFeature);
+
+            Assert.False(isEnabled);
+        }
+
     }
 }

tests/Tests.FeatureManagement/appsettings.json

@@ -16,14 +16,6 @@
           "Parameters": {
             "P1": "V1"
           }
-        },
-        {
-          "Name": "ContextualTest",
-          "Parameters": {
-            "AllowedAccounts": [
-              "abc"
-            ]
-          }
         }
       ]
     },
@@ -33,6 +25,18 @@
           "Name": "Test"
         }
       ]
+    },
+    "ContextualFeature": {
+      "EnabledFor": [
+        {
+          "Name": "ContextualTest",
+          "Parameters": {
+            "AllowedAccounts": [
+              "abc"
+            ]
+          }
+        }
+      ]
     }
   }
 }