Innovabit.DotNet.Interceptors.FeatureGates.Abstractions 2.0.117

Innovabit.DotNet.Interceptors.FeatureGates.Abstractions

Feature flags on methods for Innovabit.DotNet.Interceptors via a [FeatureGate] attribute. This is the provider-agnostic base: it ships the interceptor, the attribute and the IFeatureGateEvaluator abstraction. Pick a provider to read the flags:

• Innovabit.DotNet.Interceptors.FeatureGates.FeatureManagement — Microsoft.FeatureManagement.

Why not an if at the top of the method

Because the if cannot be forgotten on the second caller, and because removing the feature later is deleting an attribute rather than hunting through branches for the ones that belong to it.

Usage

services.AddFeatureManagement();

services
    .AddInterceptors()
    .AddFeatureManagementGates();     // or .AddFeatureGateEvaluator<MyEvaluator>()

services.AddScopedWithInterception<ICheckoutService, CheckoutService>();

[FeatureGate("checkout-v2")]                     // the whole class is behind the flag
public class CheckoutService : ICheckoutService
{
    public Task<Order> PlaceAsync(Basket basket) { ... }

    // …and this one is behind a narrower flag of its own.
    [FeatureGate("checkout-v2-express", WhenDisabled = DisabledBehaviour.ReturnDefault)]
    public Task<Order?> PlaceExpressAsync(Basket basket) { ... }
}

[FeatureGate]

Throw raises FeatureDisabledException, carrying the operation and the flag. It is the default because a caller that reaches a method behind a flag it does not know about has a bug, and a loud one is easier to find than a silent no-op.

ReturnDefault hands back null, 0, or a completed Task without running the method. Use it where the feature is genuinely optional and the caller is written to cope with nothing coming back.

The attribute works on a method and on a class, where it applies to every method; a method-level gate replaces the class's, so one method can sit behind a narrower flag than the rest of its type. Put it on the implementation, not the interface.

Ordering

The interceptor runs at InterceptorOrders.FeatureGate (25) — almost outermost, and outside auditing (50) on purpose. A method that is switched off did not happen, so there is no attempt worth recording; a call that was refused is a different thing, and that is why authorization sits inside auditing rather than outside it.

Writing an evaluator

public sealed class TenantFeatureGateEvaluator(ITenantContext tenant) : IFeatureGateEvaluator
{
    public ValueTask<bool> IsEnabledAsync(string feature, CancellationToken cancellationToken = default)
        => new(tenant.Current.EnabledFeatures.Contains(feature));
}

services.AddInterceptors().AddFeatureGateEvaluator<TenantFeatureGateEvaluator>();

Decide what an unknown flag means and say so. The bundled provider treats it as off: a typo in a feature name that defaulted to "on" would ship the unfinished feature.

Registering the interceptor without an evaluator makes resolving an intercepted service fail, rather than letting everything through unnoticed.

License

MIT