feat: Add Metrics Hook

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "dotnet.defaultSolution": "DotnetSdkContrib.sln"
+}

src/OpenFeature.Contrib.Hooks.Otel/MetricsConstants.cs

@@ -0,0 +1,23 @@
+namespace OpenFeature.Contrib.Hooks.Otel
+{
+    internal static class MetricsConstants
+    {
+        internal const string Unit = "double";
+
+        internal const string ActiveCountName = "feature_flag.evaluation_active_count";
+        internal const string RequestsTotalName = "feature_flag.evaluation_requests_total";
+        internal const string SuccessTotalName = "feature_flag.evaluation_success_total";
+        internal const string ErrorTotalName = "feature_flag.evaluation_error_total";
+
+        internal const string ActiveDescription = "active flag evaluations counter";
+        internal const string RequestsDescription = "feature flag evaluation request counter";
+        internal const string SuccessDescription = "feature flag evaluation success counter";
+        internal const string ErrorDescription = "feature flag evaluation error counter";
+
+        internal const string KeyAttr = "key";
+        internal const string ProviderNameAttr = "provider_name";
+        internal const string VariantAttr = "variant";
+        internal const string ReasonAttr = "reason";
+        internal const string ExceptionAttr = "exception";
+    }
+}

src/OpenFeature.Contrib.Hooks.Otel/MetricsHook.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using System.Reflection;
+using System.Threading.Tasks;
+using OpenFeature.Model;
+
+namespace OpenFeature.Contrib.Hooks.Otel
+{
+    /// <summary>
+    /// Represents a hook for capturing metrics related to flag evaluations.
+    /// The meter name is "OpenFeature.Contrib.Hooks.Otel".
+    /// </summary>
+    public class MetricsHook : Hook
+    {
+        private static readonly AssemblyName AssemblyName = typeof(MetricsHook).Assembly.GetName();
+        private static readonly string InstrumentationName = AssemblyName.Name;
+        private static readonly string InstrumentationVersion = AssemblyName.Version.ToString();
+
+        private readonly UpDownCounter<double> _evaluationActiveUpDownCounter;
+        private readonly Counter<double> _evaluationRequestCounter;
+        private readonly Counter<double> _evaluationSuccessCounter;
+        private readonly Counter<double> _evaluationErrorCounter;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MetricsHook"/> class.
+        /// </summary>
+        public MetricsHook()
+        {
+            var meter = new Meter(InstrumentationName, InstrumentationVersion);
+
+            _evaluationActiveUpDownCounter = meter.CreateUpDownCounter<double>(MetricsConstants.ActiveCountName, MetricsConstants.Unit, MetricsConstants.ActiveDescription);
+            _evaluationRequestCounter = meter.CreateCounter<double>(MetricsConstants.RequestsTotalName, MetricsConstants.Unit, MetricsConstants.RequestsDescription);
+            _evaluationSuccessCounter = meter.CreateCounter<double>(MetricsConstants.SuccessTotalName, MetricsConstants.Unit, MetricsConstants.SuccessDescription);
+            _evaluationErrorCounter = meter.CreateCounter<double>(MetricsConstants.ErrorTotalName, MetricsConstants.Unit, MetricsConstants.ErrorDescription);
+        }
+
+        /// <summary>
+        /// Executes before the flag evaluation and captures metrics related to the evaluation.
+        /// The metrics are captured in the following order:
+        /// 1. The active count is incremented. (feature_flag.evaluation_active_count)
+        /// 2. The request count is incremented. (feature_flag.evaluation_requests_total)
+        /// </summary>
+        /// <typeparam name="T">The type of the flag value.</typeparam>
+        /// <param name="context">The hook context.</param>
+        /// <param name="hints">The optional hints.</param>
+        /// <returns>The evaluation context.</returns>
+        public override Task<EvaluationContext> Before<T>(HookContext<T> context, IReadOnlyDictionary<string, object> hints = null)
+        {
+            var tagList = new TagList
+            {
+                { MetricsConstants.KeyAttr, context.FlagKey },
+                { MetricsConstants.ProviderNameAttr, context.ProviderMetadata.Name }
+            };
+
+            _evaluationActiveUpDownCounter.Add(1, tagList);
+            _evaluationRequestCounter.Add(1, tagList);
+
+            return base.Before(context, hints);
+        }
+
+
+        /// <summary>
+        /// Executes after the flag evaluation and captures metrics related to the evaluation.
+        /// The metrics are captured in the following order:
+        /// 1. The success count is incremented. (feature_flag.evaluation_success_total)
+        /// </summary>
+        /// <typeparam name="T">The type of the flag value.</typeparam>
+        /// <param name="context">The hook context.</param>
+        /// <param name="details">The flag evaluation details.</param>
+        /// <param name="hints">The optional hints.</param>
+        /// <returns>The evaluation context.</returns>
+        public override Task After<T>(HookContext<T> context, FlagEvaluationDetails<T> details, IReadOnlyDictionary<string, object> hints = null)
+        {
+            var tagList = new TagList
+            {
+                { MetricsConstants.KeyAttr, context.FlagKey },
+                { MetricsConstants.ProviderNameAttr, context.ProviderMetadata.Name },
+                { MetricsConstants.VariantAttr, details.Variant ?? details.Value?.ToString() },
+                { MetricsConstants.ReasonAttr, details.Reason ?? "UNKNOWN" }
+            };
+
+            _evaluationSuccessCounter.Add(1, tagList);
+
+            return base.After(context, details, hints);
+        }
+
+        /// <summary>
+        /// Executes when an error occurs during flag evaluation and captures metrics related to the error.
+        /// The metrics are captured in the following order:
+        /// 1. The error count is incremented. (feature_flag.evaluation_error_total)
+        /// </summary>
+        /// <typeparam name="T">The type of the flag value.</typeparam>
+        /// <param name="context">The hook context.</param>
+        /// <param name="error">The exception that occurred.</param>
+        /// <param name="hints">The optional hints.</param>
+        /// <returns>The evaluation context.</returns>
+        public override Task Error<T>(HookContext<T> context, Exception error, IReadOnlyDictionary<string, object> hints = null)
+        {
+            var tagList = new TagList
+            {
+                { MetricsConstants.KeyAttr, context.FlagKey },
+                { MetricsConstants.ProviderNameAttr, context.ProviderMetadata.Name },
+                { MetricsConstants.ExceptionAttr, error?.Message ?? "Unknown error" }
+            };
+
+            _evaluationErrorCounter.Add(1, tagList);
+
+            return base.Error(context, error, hints);
+        }
+
+        /// <summary>
+        /// Executes after the flag evaluation is complete and captures metrics related to the evaluation.
+        /// The active count is decremented. (feature_flag.evaluation_active_count)
+        /// </summary>
+        /// <typeparam name="T">The type of the flag value.</typeparam>
+        /// <param name="context">The hook context.</param>
+        /// <param name="hints">The optional hints.</param>
+        /// <returns>The evaluation context.</returns>
+        public override Task Finally<T>(HookContext<T> context, IReadOnlyDictionary<string, object> hints = null)
+        {
+            var tagList = new TagList
+            {
+                { MetricsConstants.KeyAttr, context.FlagKey },
+                { MetricsConstants.ProviderNameAttr, context.ProviderMetadata.Name }
+            };
+
+            _evaluationActiveUpDownCounter.Add(-1, tagList);
+
+            return base.Finally(context, hints);
+        }
+    }
+}

src/OpenFeature.Contrib.Hooks.Otel/README.md

@@ -4,14 +4,15 @@
 
 - open-feature/dotnet-sdk >= v1.0
 
-## Usage
+## Usage - Traces
 
 For this hook to function correctly a global `TracerProvider` must be set, an example of how to do this can be found below.
 
 The `open telemetry hook` taps into the after and error methods of the hook lifecycle to write `events` and `attributes` to an existing `span`.
 For this, an active span must be set in the `Tracer`, otherwise the hook will no-op.
 
 ### Example
+
 The following example demonstrates the use of the `OpenTelemetry hook` with the `OpenFeature dotnet-sdk`. The traces are sent to a `jaeger` OTLP collector running at `localhost:4317`.
 
 ```csharp
@@ -31,7 +32,7 @@ namespace OpenFeatureTestApp
 			var tracerProvider = Sdk.CreateTracerProviderBuilder()
                     .AddSource("my-tracer")
                     .ConfigureResource(r => r.AddService("jaeger-test"))
-                    .AddOtlpExporter(o => 
+                    .AddOtlpExporter(o =>
                     {
                         o.ExportProcessorType = ExportProcessorType.Simple;
                     })
@@ -64,6 +65,54 @@ In case something went wrong during a feature flag evaluation, you will see an e
 
 ![](./assets/otlp-error.png)
 
+## Usage - Metrics
+
+For this hook to function correctly a global `MeterProvider` must be set, an example of how to do this can be found below.
+
+### Example
+
+The following example demonstrates the use of the `OpenTelemetry hook` with the `OpenFeature dotnet-sdk`. The metrics are sent to the `console`.
+
+```csharp
+using OpenFeature.Contrib.Providers.Flagd;
+using OpenFeature;
+using OpenFeature.Contrib.Hooks.Otel;
+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.Contrib.Hooks.Otel")
+                    .ConfigureResource(r => r.AddService("openfeature-test"))
+                    .AddConsoleExporter()
+                    .Build();
+
+            // add the Otel Hook 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.GetBooleanValue("myBoolFlag", false, null);
+
+            // Print the value of the 'myBoolFlag' feature flag
+            System.Console.WriteLine(val.Result.ToString());
+        }
+    }
+}
+```
+
+After running this example, you should be able to see some metrics being generated into the console.
+
 ## License
 
 Apache 2.0 - See [LICENSE](./../../LICENSE) for more information.