feat: Add Dependency Injection extensions for Adding Flagd Provider (#410)

Signed-off-by: Kyle Julian <[email protected]>
Co-authored-by: Todd Baert <[email protected]>
Co-authored-by: André Silva <[email protected]>

Author: 3 people

src/OpenFeature.Contrib.Providers.Flagd/DependencyInjection/FeatureBuilderExtensions.cs

@@ -0,0 +1,79 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using OpenFeature.Contrib.Providers.Flagd;
+using OpenFeature.Contrib.Providers.Flagd.DependencyInjection;
+
+namespace OpenFeature.DependencyInjection.Providers.Flagd;
+
+/// <summary>
+/// Extension methods for configuring the <see cref="OpenFeatureBuilder"/>.
+/// </summary>
+public static class FeatureBuilderExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="FlagdProvider"/> to the <see cref="OpenFeatureBuilder"/> with default <see cref="FlagdProviderOptions"/> configuration.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddFlagdProvider(this OpenFeatureBuilder builder)
+    {
+        builder.Services.AddOptions<FlagdProviderOptions>(FlagdProviderOptions.DefaultName);
+        return builder.AddProvider(sp => CreateProvider(sp, null));
+    }
+
+    /// <summary>
+    /// Adds the <see cref="FlagdProvider"/> to the <see cref="OpenFeatureBuilder"/> with <see cref="FlagdProviderOptions"/> configuration.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <param name="options">Options to configure <see cref="FlagdProvider"/>.</param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddFlagdProvider(this OpenFeatureBuilder builder, Action<FlagdProviderOptions> options)
+    {
+        builder.Services.Configure(FlagdProviderOptions.DefaultName, options);
+        return builder.AddProvider(sp => CreateProvider(sp, null));
+    }
+
+    /// <summary>
+    /// Adds the <see cref="FlagdProvider"/> to the <see cref="OpenFeatureBuilder"/> with a specific domain and default <see cref="FlagdProviderOptions"/> configuration.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <param name="domain">The unique domain of the provider.</param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddFlagdProvider(this OpenFeatureBuilder builder, string domain)
+    {
+        builder.Services.AddOptions<FlagdProviderOptions>(domain);
+        return builder.AddProvider(domain, CreateProvider);
+    }
+
+    /// <summary>
+    /// Adds the <see cref="FlagdProvider"/> to the <see cref="OpenFeatureBuilder"/> with a specific domain and <see cref="FlagdProviderOptions"/> configuration.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <param name="domain">The unique domain of the provider.</param>
+    /// <param name="options">Options to configure <see cref="FlagdProvider"/>.</param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddFlagdProvider(this OpenFeatureBuilder builder, string domain, Action<FlagdProviderOptions> options)
+    {
+        builder.Services.Configure(domain, options);
+        return builder.AddProvider(domain, CreateProvider);
+    }
+
+    private static FlagdProvider CreateProvider(IServiceProvider provider, string domain)
+    {
+        var optionsMonitor = provider.GetRequiredService<IOptionsMonitor<FlagdProviderOptions>>();
+        var logger = provider.GetService<ILogger<FlagdProvider>>();
+        logger ??= NullLogger<FlagdProvider>.Instance;
+
+        var options = string.IsNullOrEmpty(domain)
+            ? optionsMonitor.Get(FlagdProviderOptions.DefaultName)
+            : optionsMonitor.Get(domain);
+
+        var config = options.ToFlagdConfig();
+        config.Logger = logger;
+
+        return new FlagdProvider(config);
+    }
+}

src/OpenFeature.Contrib.Providers.Flagd/DependencyInjection/FlagdProviderOptions.cs

@@ -0,0 +1,64 @@
+using OpenFeature.Contrib.Providers.Flagd;
+
+namespace OpenFeature.DependencyInjection.Providers.Flagd;
+
+/// <summary>
+/// Configuration options for the Flagd provider.
+/// </summary>
+public record FlagdProviderOptions
+{
+    /// <summary>
+    /// Default name for the Flagd provider.
+    /// </summary>
+    public const string DefaultName = "FlagdProvider";
+
+    /// <summary>
+    /// The host for the provider to connect to. Defaults to "localhost".
+    /// </summary>
+    public string Host { get; set; } = "localhost";
+
+    /// <summary>
+    /// The Port property of the config. Defaults to 8013.
+    /// </summary>
+    public int Port { get; set; } = 8013;
+
+    /// <summary>
+    /// Use TLS for communication between the provider and the host. Defaults to false.
+    /// </summary>
+    public bool UseTls { get; set; } = false;
+
+    /// <summary>
+    /// Enable/disable the local cache for static flag values. Defaults to false.
+    /// </summary>
+    public bool CacheEnabled { get; set; } = false;
+
+    /// <summary>
+    /// The maximum size of the cache. Defaults to 10.
+    /// </summary>
+    public int MaxCacheSize { get; set; } = 10;
+
+    /// <summary>
+    /// Path to the certificate file. Defaults to empty string.
+    /// </summary>
+    public string CertificatePath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Path to the socket. Defaults to empty string.
+    /// </summary>
+    public string SocketPath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Maximum number of times the connection to the event stream should be re-attempted. Defaults to 3.
+    /// </summary>
+    public int MaxEventStreamRetries { get; set; } = 3;
+
+    /// <summary>
+    /// Which type of resolver to use. Defaults to <see cref="ResolverType.RPC"/>.
+    /// </summary>
+    public ResolverType ResolverType { get; set; } = ResolverType.RPC;
+
+    /// <summary>
+    /// Source selector for the in-process provider. Defaults to empty string.
+    /// </summary>
+    public string SourceSelector { get; set; } = string.Empty;
+}

src/OpenFeature.Contrib.Providers.Flagd/DependencyInjection/FlagdProviderOptionsExtensions.cs

@@ -0,0 +1,30 @@
+using System;
+using OpenFeature.DependencyInjection.Providers.Flagd;
+
+namespace OpenFeature.Contrib.Providers.Flagd.DependencyInjection;
+
+internal static class FlagdProviderOptionsExtensions
+{
+    public static FlagdConfig ToFlagdConfig(this FlagdProviderOptions options)
+    {
+        if (options == null)
+        {
+            throw new ArgumentNullException(nameof(options), "FlagdProviderOptions cannot be null.");
+        }
+
+        var config = FlagdConfig.Builder()
+            .WithHost(options.Host)
+            .WithPort(options.Port)
+            .WithTls(options.UseTls)
+            .WithCache(options.CacheEnabled)
+            .WithMaxCacheSize(options.MaxCacheSize)
+            .WithCertificatePath(options.CertificatePath)
+            .WithSocketPath(options.SocketPath)
+            .WithMaxEventStreamRetries(options.MaxEventStreamRetries)
+            .WithResolverType(options.ResolverType)
+            .WithSourceSelector(options.SourceSelector)
+            .Build();
+
+        return config;
+    }
+}

src/OpenFeature.Contrib.Providers.Flagd/OpenFeature.Contrib.Providers.Flagd.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <PackageId>OpenFeature.Contrib.Providers.Flagd</PackageId>
@@ -36,8 +36,11 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0"
-      Condition="'$(TargetFramework)' == 'netstandard2.0'" />
-    <PackageReference Include="OpenFeature" Version="[2.0,3.0)" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" Condition="'$(TargetFramework)' == 'netstandard2.0'" />
+    <PackageReference Include="OpenFeature" Version="$(OpenFeatureVersion)" />
+    <PackageReference Include="OpenFeature.DependencyInjection" Version="$(OpenFeatureVersion)" />
   </ItemGroup>
+  <PropertyGroup>
+    <OpenFeatureVersion>[2.2,2.99999]</OpenFeatureVersion> 
+  </PropertyGroup>
 </Project>

src/OpenFeature.Contrib.Providers.Flagd/README.md

@@ -13,19 +13,23 @@ The flagd Flag provider allows you to connect to your flagd instance.
 We will first install the **OpenFeature SDK** and the **flagd provider**.
 
 ### .NET Cli
+
 ```shell
 dotnet add package OpenFeature.Contrib.Providers.Flagd
 ```
+
 ### Package Manager
 
 ```shell
 NuGet\Install-Package OpenFeature.Contrib.Providers.Flagd
 ```
+
 ### Package Reference
 
 ```xml
 <PackageReference Include="OpenFeature.Contrib.Providers.Flagd" />
 ```
+
 ### Packet cli
 
 ```shell
@@ -76,6 +80,80 @@ namespace OpenFeatureTestApp
 }
 ```
 
+## Using the flagd Provider with the OpenFeature SDK and Dependency Injection
+
+You can also use the flagd Provider with the OpenFeature SDK and Dependency Injection. The following example shows how to do this using Microsoft.Extensions.DependencyInjection:
+
+Before you start, make sure you have the `OpenFeature.Hosting` NuGet package installed:
+
+```shell
+dotnet add package OpenFeature.Hosting
+```
+
+Or with Package Manager:
+
+```shell
+NuGet\Install-Package OpenFeature.Hosting
+```
+
+Now you can set up Dependency Injection with OpenFeature and the flagd Provider in your `Program.cs` file. When not specifying any configuration options, the flagd Provider will use the default values for the variables as described below.
+
+```csharp
+using OpenFeature;
+using OpenFeature.DependencyInjection.Providers.Flagd;
+
+namespace OpenFeatureTestApp
+{
+    class Hello {
+        static void Main(string[] args) {
+            var builder = WebApplication.CreateBuilder(args);
+
+            builder.Services.AddOpenFeature(config =>
+            {
+                config.AddHostedFeatureLifecycle()
+                    .AddFlagdProvider();
+            });
+
+            var app = builder.Build();
+
+            // ... ommitted for brevity
+        }
+    }
+}
+```
+
+You can override the default configuration options by specifying properties on the `FlagdProviderOptions` on the `AddFlagdProvider` method.
+
+```csharp
+using OpenFeature;
+using OpenFeature.DependencyInjection.Providers.Flagd;
+
+namespace OpenFeatureTestApp
+{
+    class Hello {
+        static void Main(string[] args) {
+            var builder = WebApplication.CreateBuilder(args);
+
+            builder.Services.AddOpenFeature(config =>
+            {
+                config.AddHostedFeatureLifecycle()
+                    .AddFlagdProvider(o =>
+                    {
+                        o.Host = builder.Configuration["FlagdProviderOptions:Host"];
+                        o.Port = int.Parse(builder.Configuration["FlagdProviderOptions:Port"] ?? "8013");
+
+                        // other configurations can be set here
+                    });
+            });
+
+            var app = builder.Build();
+
+            // ... ommitted for brevity
+        }
+    }
+}
+```
+
 ### Configuring the FlagdProvider
 
 The URI of the flagd server to which the `flagd Provider` connects to can either be passed directly to the constructor, or be configured using the following environment variables: