Name: OpenFeature
Author: OpenFeature Authors

OpenFeature v2.8.1 — nugetz

dotnet new console

dotnet add package OpenFeature

public async Task Example()
{
    // Register your feature flag provider
    try
    {
        await Api.Instance.SetProviderAsync(new InMemoryProvider());
    }
    catch (Exception ex)
    {
        // Log error
    }

    // Create a new client
    FeatureClient client = Api.Instance.GetClient();

    // Evaluate your feature flag
    bool v2Enabled = await client.GetBooleanValueAsync("v2_enabled", false);

    if ( v2Enabled )
    {
        // Do some work
    }
}

Status	Features	Description
✅	Providers	Integrate with a commercial, open source, or in-house feature management tool.
✅	Targeting	Contextually-aware flag evaluation using evaluation context.
✅	Hooks	Add functionality to various stages of the flag evaluation life-cycle.
✅	Tracking	Associate user actions with feature flag evaluations.
✅	Logging	Integrate with popular logging packages.
✅	Domains	Logically bind clients with providers.
✅	Eventing	React to state changes in the provider or flag management system.
✅	Shutdown	Gracefully clean up a provider during application shutdown.
✅	Transaction Context Propagation	Set a specific evaluation context for a transaction (e.g. an HTTP request or a thread).
✅	Extending	Extend OpenFeature with custom providers and hooks.
🔬	DependencyInjection	Integrate OpenFeature with .NET's dependency injection for streamlined provider setup.

try
{
    await Api.Instance.SetProviderAsync(new MyProvider());
}
catch (Exception ex)
{
    // Log error
}

// set a value to the global context
EvaluationContextBuilder builder = EvaluationContext.Builder();
builder.Set("region", "us-east-1");
EvaluationContext apiCtx = builder.Build();
Api.Instance.SetContext(apiCtx);

// set a value to the client context
builder = EvaluationContext.Builder();
builder.Set("region", "us-east-1");
EvaluationContext clientCtx = builder.Build();
var client = Api.Instance.GetClient();
client.SetContext(clientCtx);

// set a value to the invocation context
builder = EvaluationContext.Builder();
builder.Set("region", "us-east-1");
EvaluationContext reqCtx = builder.Build();

bool flagValue = await client.GetBooleanValuAsync("some-flag", false, reqCtx);

// add a hook globally, to run on all evaluations
Api.Instance.AddHooks(new ExampleGlobalHook());

// add a hook on this client, to run on all evaluations made by this client
var client = Api.Instance.GetClient();
client.AddHooks(new ExampleClientHook());

// add a hook for this evaluation only
var value = await client.GetBooleanValueAsync("boolFlag", false, context, new FlagEvaluationOptions(new ExampleInvocationHook()));

using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = loggerFactory.CreateLogger("Program");

var client = Api.Instance.GetClient();
client.AddHooks(new LoggingHook(logger));

try
{
    // registering the default provider
    await Api.Instance.SetProviderAsync(new LocalProvider());

    // registering a provider to a domain
    await Api.Instance.SetProviderAsync("clientForCache", new CachedProvider());
}
catch (Exception ex)
{
    // Log error
}

// a client backed by default provider
FeatureClient clientDefault = Api.Instance.GetClient();

// a client backed by CachedProvider
FeatureClient scopedClient = Api.Instance.GetClient("clientForCache");

public static void EventHandler(ProviderEventPayload eventDetails)
{
    Console.WriteLine(eventDetails.Type);
}

EventHandlerDelegate callback = EventHandler;
// add an implementation of the EventHandlerDelegate for the PROVIDER_READY event
Api.Instance.AddHandler(ProviderEventTypes.ProviderReady, callback);

EventHandlerDelegate callback = EventHandler;

var myClient = Api.Instance.GetClient("my-client");

try
{
    var provider = new ExampleProvider();
    await Api.Instance.SetProviderAsync(myClient.GetMetadata().Name, provider);
}
catch (Exception ex)
{
    // Log error
}

myClient.AddHandler(ProviderEventTypes.ProviderReady, callback);

var client = Api.Instance.GetClient();
client.Track("visited-promo-page", trackingEventDetails: new TrackingEventDetailsBuilder().SetValue(99.77).Set("currency", "USD").Build());

// Shut down all providers
await Api.Instance.ShutdownAsync();

// registering the AsyncLocalTransactionContextPropagator
Api.Instance.SetTransactionContextPropagator(new AsyncLocalTransactionContextPropagator());

// adding userId to transaction context
EvaluationContext transactionContext = EvaluationContext.Builder()
    .Set("userId", userId)
    .Build();
Api.Instance.SetTransactionContext(transactionContext);

public class MyProvider : FeatureProvider
{
    public override Metadata GetMetadata()
    {
        return new Metadata("My Provider");
    }

    public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
    {
        // resolve a boolean flag value
    }

    public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
    {
        // resolve a string flag value
    }

    public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext context = null)
    {
        // resolve an int flag value
    }

    public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
    {
        // resolve a double flag value
    }

    public override Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
    {
        // resolve an object flag value
    }
}

public class MyHook : Hook
{
  public ValueTask<EvaluationContext> BeforeAsync<T>(HookContext<T> context,
      IReadOnlyDictionary<string, object> hints = null)
  {
    // code to run before flag evaluation
  }

  public ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
      IReadOnlyDictionary<string, object>? hints = null)
  {
    // code to run after successful flag evaluation
  }

  public ValueTask ErrorAsync<T>(HookContext<T> context, Exception error,
      IReadOnlyDictionary<string, object>? hints = null)
  {
    // code to run if there's an error during before hooks or during flag evaluation
  }

  public ValueTask FinallyAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> evaluationDetails, IReadOnlyDictionary<string, object> hints = null)
  {
    // code to run after all other stages, regardless of success/failure
  }
}

    class TimingHook : Hook
    {
        public ValueTask<EvaluationContext> BeforeAsync<T>(HookContext<T> context,
            IReadOnlyDictionary<string, object>? hints = null)
        {
            context.Data.Set("beforeTime", DateTime.Now);
            return ValueTask.FromResult(context.EvaluationContext);
        }

        public ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
            IReadOnlyDictionary<string, object>? hints = null)
        {
            var beforeTime = context.Data.Get("beforeTime") as DateTime?;
            var duration = DateTime.Now - beforeTime;
            Console.WriteLine($"Duration: {duration}");
            return ValueTask.CompletedTask;
        }
    }

dotnet add package OpenFeature.DependencyInjection
dotnet add package OpenFeature.Hosting

builder.Services.AddOpenFeature(featureBuilder => {
    featureBuilder
        .AddHostedFeatureLifecycle() // From Hosting package
        .AddInMemoryProvider();
});

builder.Services.AddOpenFeature(featureBuilder => {
    featureBuilder
        .AddContext((contextBuilder, serviceProvider) => { /* Custom context configuration */ })
        .AddHook<LoggingHook>()
        .AddHandler(ProviderEventTypes.ProviderReady, (eventDetails) => { /* Handle event */ });
});

builder.Services.AddOpenFeature(featureBuilder => {
    featureBuilder
        .AddHostedFeatureLifecycle()
        .AddContext((contextBuilder, serviceProvider) => { /* Custom context configuration */ })
        .AddHook((serviceProvider) => new LoggingHook( /* Custom configuration */ ))
        .AddHook(new MetricsHook())
        .AddInMemoryProvider("name1")
        .AddInMemoryProvider("name2")
        .AddPolicyName(options => {
            // Custom logic to select a default provider
            options.DefaultNameSelector = serviceProvider => "name1";
        });
});

services.AddOpenFeature(builder =>
{
    builder.AddProvider(provider =>
    {
        // Resolve services or configurations as needed
        var variants = new Dictionary<string, bool> { { "on", true } };
        var flags = new Dictionary<string, Flag>
        {
            { "feature-key", new Flag<bool>(variants, "on") }
        };

        // Register a custom provider, such as InMemoryProvider
        return new InMemoryProvider(flags);
    });
});

services.AddOpenFeature(builder =>
{
    builder.AddProvider("my-domain", (provider, domain) =>
    {
        // Resolve services or configurations as needed for the domain
        var variants = new Dictionary<string, bool> { { "on", true } };
        var flags = new Dictionary<string, Flag>
        {
            { $"{domain}-feature-key", new Flag<bool>(variants, "on") }
        };

        // Register a domain-scoped custom provider such as InMemoryProvider
        return new InMemoryProvider(flags);
    });
});

Tag Name	Description	Source
feature_flag.key	The lookup key of the feature flag	Hook context flag key
feature_flag.provider.name	The name of the feature flag provider	Provider metadata
feature_flag.result.reason	The reason code which shows how a feature flag value was determined	Evaluation details
feature_flag.result.variant	A semantic identifier for an evaluated flag value	Evaluation details
feature_flag.result.value	The evaluated value of the feature flag	Evaluation details
feature_flag.context.id	The unique identifier for the flag evaluation context	Flag metadata (if available)
feature_flag.set.id	The identifier of the flag set to which the feature flag belongs	Flag metadata (if available)
feature_flag.version	The version of the ruleset used during the evaluation	Flag metadata (if available)
error.type	Describes a class of error the operation ended with	Evaluation details (if error)
error.message	A message explaining the nature of an error occurring during flag evaluation	Evaluation details (if error)

using OpenFeature.Contrib.Providers.Flagd;
using OpenFeature.Hooks;
using OpenTelemetry.Exporter;
using OpenTelemetry.Resources;
using OpenTelemetry;
using OpenTelemetry.Trace;

namespace OpenFeatureTestApp
{
    class Hello {
        static void Main(string[] args) {

            // set up the OpenTelemetry OTLP exporter
            var tracerProvider = Sdk.CreateTracerProviderBuilder()
                    .AddSource("my-tracer")
                    .ConfigureResource(r => r.AddService("jaeger-test"))
                    .AddOtlpExporter(o =>
                    {
                        o.ExportProcessorType = ExportProcessorType.Simple;
                    })
                    .Build();

            // add the TraceEnricherHook to the OpenFeature instance
            OpenFeature.Api.Instance.AddHooks(new TraceEnricherHook());

            var flagdProvider = new FlagdProvider(new Uri("http://localhost:8013"));

            // Set the flagdProvider as the provider for the OpenFeature SDK
            OpenFeature.Api.Instance.SetProvider(flagdProvider);

            var client = OpenFeature.Api.Instance.GetClient("my-app");

            var val = client.GetBooleanValueAsync("myBoolFlag", false, null);

            // Print the value of the 'myBoolFlag' feature flag
            System.Console.WriteLine(val.Result.ToString());
        }
    }
}

var options = TraceEnricherHookOptions.CreateBuilder()
    .WithTag("custom_dimension_key", "custom_dimension_value")
    .Build();

OpenFeature.Api.Instance.AddHooks(new TraceEnricherHook(options));

var options = TraceEnricherHookOptions.CreateBuilder()
    .WithFlagEvaluationMetadata("boolean", s => s.GetBool("boolean"))
    .Build();

Metric key	Description	Unit	Dimensions
feature_flag.evaluation_requests_total	Number of evaluation requests	request	key, provider name
feature_flag.evaluation_success_total	Flag evaluation successes	impression	key, provider name, reason
feature_flag.evaluation_error_total	Flag evaluation errors	1	key, provider name, exception
feature_flag.evaluation_active_count	Active flag evaluations counter	1	key, provider name

using OpenFeature.Contrib.Providers.Flagd;
using OpenFeature;
using OpenFeature.Hooks;
using OpenTelemetry;
using OpenTelemetry.Metrics;

namespace OpenFeatureTestApp
{
    class Hello {
        static void Main(string[] args) {

            // set up the OpenTelemetry OTLP exporter
            var meterProvider = Sdk.CreateMeterProviderBuilder()
                    .AddMeter("OpenFeature")
                    .ConfigureResource(r => r.AddService("openfeature-test"))
                    .AddConsoleExporter()
                    .Build();

            // add the MetricsHook to the OpenFeature instance
            OpenFeature.Api.Instance.AddHooks(new MetricsHook());

            var flagdProvider = new FlagdProvider(new Uri("http://localhost:8013"));

            // Set the flagdProvider as the provider for the OpenFeature SDK
            OpenFeature.Api.Instance.SetProvider(flagdProvider);

            var client = OpenFeature.Api.Instance.GetClient("my-app");

            var val = client.GetBooleanValueAsync("myBoolFlag", false, null);

            // Print the value of the 'myBoolFlag' feature flag
            System.Console.WriteLine(val.Result.ToString());
        }
    }
}

var options = MetricsHookOptions.CreateBuilder()
    .WithCustomDimension("custom_dimension_key", "custom_dimension_value")
    .Build();

OpenFeature.Api.Instance.AddHooks(new MetricsHook(options));

var options = MetricsHookOptions.CreateBuilder()
    .WithFlagEvaluationMetadata("boolean", s => s.GetBool("boolean"))
    .Build();

OpenFeature/OpenFeaturev2.8.1

Get Started

Readme

.NET SDK

🚀 Quick start

Requirements

Install

Usage

Samples

🌟 Features

Providers

Targeting

Hooks

Logging

Logging Hook

Domains

Eventing

Tracking

Shutdown

Transaction Context Propagation

Extending

Develop a provider

Develop a hook

Dependency Injection

Installation

Usage Examples

Registering a Custom Provider

Adding a Domain-Scoped Provider

Trace Enricher Hook

Example

Metrics Hook

Example

⭐️ Support the project

🤝 Contributing

Thanks to everyone who has already contributed