Is any way to turn off dependent features?

[VladyslavLishchyna]

Hi community!

I have question that I try to solve, if I have "FeatureA" and "FeatureB" and code of "FeatureA" use "FeatureB" inside.
I can turnoff they separately, but will be nice to have mechanism to turnoff dependent features, in this case automatically turnoff "FeatureA" when "FeatureB" turned off.

Maybe you know some solution for it ?

I tried to solve it by create specific IFeatureFilter but I can`t use IFeatureManager as constructor parameter, in this case application frozen, looks like some circular dependency inside.

[rossgrambo]

I don't know of a solution currently, but I'll look around. Do your FeatureA and FeatureB use filters? If so, could you share which filter types you use (Targeting, TimeWindow, Custom)?

[VladyslavLishchyna]

I don't know of a solution currently, but I'll look around. Do your FeatureA and FeatureB use filters? If so, could you share which filter types you use (Targeting, TimeWindow, Custom)?

HI, thanks for you attention. No this features don`t use filters

[zhiyuanliang-ms]

Hey, Vladyslav (@VladyslavLishchyna)

Thank you for sharing your request for a new feature. To help us better understand your use case and come up with a solution,
Could you please give us a practical scenario in which dependent feature flag would provide clear benefits?

[zhiyuanliang-ms]

Vladyslav (@VladyslavLishchyna)

I tried to solve it by create specific IFeatureFilter but I can`t use IFeatureManager as constructor parameter, in this case application frozen, looks like some circular dependency inside.

I have a solution that uses feature filter + Lazy<T>

sample.zip

I have a parameterized feature filter which takes Lazy<IFeatureManager> in the constructor.

using Microsoft.FeatureManagement;
using Microsoft.Extensions.Configuration;

namespace CircularDependency
{
    [FilterAlias("ParentFeature")]
    public class ParentFeatureFilter : IFeatureFilter
    {
        private readonly Lazy<IFeatureManager> _featureManager;

        public ParentFeatureFilter(Lazy<IFeatureManager> featureManager)
        {
            _featureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager));
        }

        public async Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
        {
            string parentFeature = context.Parameters.GetSection("Name").Get<string>();


            if (!string.IsNullOrEmpty(parentFeature))
            {
                return await _featureManager.Value.IsEnabledAsync(parentFeature);
            }

            return false;
        }
    }
}

Here is how I register thems:

using CircularDependency;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.FeatureManagement;

IConfiguration configuration = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

var services = new ServiceCollection();

services.AddSingleton(configuration);

services.AddFeatureManagement()
    .AddFeatureFilter<TestFilter>();

// Register Lazy factories for feature manager types.
services.AddSingleton<Lazy<IFeatureManager>>(sp => new Lazy<IFeatureManager>(() => sp.GetRequiredService<IFeatureManager>()));

var serviceProvider = services.BuildServiceProvider();

IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();

bool isFeatureAEnabled = await featureManager.IsEnabledAsync("FeatureA");
bool isFeatureBEnabled = await featureManager.IsEnabledAsync("FeatureB");

Console.WriteLine($"Is FeatureA enabled? {isFeatureAEnabled}");
Console.WriteLine($"Is FeatureB enabled? {isFeatureBEnabled}");

Here is the feature flag configuration

{
  "feature_management": {
    "feature_flags": [
      {
        "id": "FeatureA",
        "enabled": true,
        "conditions": {
          "client_filters": [
            {
              "name": "ParentFeature",
              "parameters": {
                "Name":  "FeatureB"
              }
            }
          ]
        }
      },
      {
        "id": "FeatureB",
        "enabled": true
      }
    ]
  }
}

[VladyslavLishchyna]

Zhiyuan Liang (@zhiyuanliang-ms) Thank you very much for your attention to this issue, an example in which I needed it is an internal system that has a large number of connectors (Kubernetes, Bitbucket, Docker registry, etc) and a large number of features based on these connectors. And for example, a feature that removes from the Docker Registry those Docker images that are not used in Kubernetes. It is logical that this feature can be used only when both Kubernetes and Docker Registry features are enabled and working

[VladyslavLishchyna]

Zhiyuan Liang (@zhiyuanliang-ms) thanks for your example, I think its only one possible way in this case

[zhiyuanliang-ms]

Hey, Vladyslav (@VladyslavLishchyna)

an example in which I needed it is an internal system that has a large number of connectors (Kubernetes, Bitbucket, Docker registry, etc) and a large number of features based on these connectors. And for example, a feature that removes from the Docker Registry those Docker images that are not used in Kubernetes. It is logical that this feature can be used only when both Kubernetes and Docker Registry features are enabled and working

Conceptually, the feature filter mechanism itself provides a way to dynamically turn a feature flag on or off. Your scenario also falls within the scope of dynamically enabling feature flags, so I believe using a feature filter is the correct approach.

As for how to determine the condition that “both Kubernetes and Docker Registry features are enabled,” I think there are many possible approaches. One option is to check whether the corresponding feature flags are enabled (which is where the idea of dependent feature flags comes into play). However, I believe there should also be other ways to determine whether these two features are enabled, such as checking environment variables, and so on.

thanks for your example, I think its only one possible way in this case

You are welcome. Would you take this solution? If yes, I will close this issue. ;)

[VladyslavLishchyna]

Zhiyuan Liang (@zhiyuanliang-ms) sure, I think right now its good solution

[zhiyuanliang-ms]

Hey, Vladyslav (@VladyslavLishchyna) Updated the sample I pasted. Now, it is a parameterized filter.

[jimmyca15]

Hello Vladyslav (@VladyslavLishchyna)

We are looking for some input as we consider adding this functionality built-in to the library. Is it enough to say that the desire here is to be able to turn off a group of features at once? If so we, we may consider to introduce the capability to group features rather than introduce dependency chains.

[VladyslavLishchyna]

Hi, I think it's will work for most cases. In my specific case I have a lot of features and they have difficult relations so dependency chain would be much more better. But I think it's really specific case

[drago-draganov]

What if a Feature Flag can belong to multiple groups?