Add metrics factory

Author: JamesNK

src/Hosting/Abstractions/src/MetricsPrototype/DefaultMetricsFactory.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Metrics;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.AspNetCore.Hosting.Abstractions.MetricsPrototype;
+
+internal class DefaultMetricsFactory : IMetricsFactory
+{
+    private readonly IOptions<MetricsOptions> _options;
+
+    public DefaultMetricsFactory(IOptions<MetricsOptions> options)
+    {
+        _options = options;
+    }
+
+    public Meter CreateMeter(string name)
+    {
+        // TODO: Configure meter with default tags.
+        return new Meter(name);
+    }
+
+    public Meter CreateMeter(MeterOptions options)
+    {
+        // TODO: Configure meter with default tags.
+        return new Meter(options.Name, options.Version);
+    }
+}

src/Hosting/Abstractions/src/MetricsPrototype/IMetricsFactory.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.Metrics;
+
+namespace Microsoft.Extensions.Metrics;
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable RS0016 // Add public types and members to the declared API
+public sealed class MetricsOptions
+{
+    public string? ContainerId { get; set; }
+    public IDictionary<string, string> DefaultTags { get; } = new Dictionary<string, string>();
+}
+
+public sealed class MeterOptions
+{
+    public required string Name { get; set; }
+    public string? Version { get; set; }
+}
+
+public interface IMetricsFactory
+{
+    Meter CreateMeter(string name);
+    Meter CreateMeter(MeterOptions options);
+}
+#pragma warning restore RS0016 // Add public types and members to the declared API
+#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

src/Hosting/Abstractions/src/MetricsPrototype/MetricsServiceExtensions.cs

@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Hosting.Abstractions.MetricsPrototype;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Metrics;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable RS0016 // Add public types and members to the declared API
+public static class MetricsServiceExtensions
+{
+    public static IServiceCollection AddMetrics(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.TryAddSingleton<IMetricsFactory, DefaultMetricsFactory>();
+
+        return services;
+    }
+
+    public static IServiceCollection AddMetrics(this IServiceCollection services, Action<MetricsOptions> configure)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddMetrics();
+        services.Configure(configure);
+
+        return services;
+    }
+}
+#pragma warning restore RS0016 // Add public types and members to the declared API
+#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member

src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs

@@ -62,12 +62,12 @@ public GenericWebHostBuilder(IHostBuilder builder, WebHostBuilderOptions options
 #pragma warning restore CS0618 // Type or member is obsolete
 
             services.Configure<GenericWebHostServiceOptions>(options =>
-        {
-            // Set the options
-            options.WebHostOptions = webHostOptions;
-            // Store and forward any startup errors
-            options.HostingStartupExceptions = _hostingStartupErrors;
-        });
+            {
+                // Set the options
+                options.WebHostOptions = webHostOptions;
+                // Store and forward any startup errors
+                options.HostingStartupExceptions = _hostingStartupErrors;
+            });
 
             // REVIEW: This is bad since we don't own this type. Anybody could add one of these and it would mess things up
             // We need to flow this differently
@@ -80,6 +80,9 @@ public GenericWebHostBuilder(IHostBuilder builder, WebHostBuilderOptions options
             services.TryAddScoped<IMiddlewareFactory, MiddlewareFactory>();
             services.TryAddSingleton<IApplicationBuilderFactory, ApplicationBuilderFactory>();
 
+            services.AddMetrics();
+            services.TryAddSingleton<HostingMetrics>();
+
             // IMPORTANT: This needs to run *before* direct calls on the builder (like UseStartup)
             _hostingStartupWebHostBuilder?.ConfigureServices(webhostContext, services);
 

src/Hosting/Hosting/src/GenericHost/GenericWebHostService.cs

@@ -26,7 +26,8 @@ public GenericWebHostService(IOptions<GenericWebHostServiceOptions> options,
                                  IApplicationBuilderFactory applicationBuilderFactory,
                                  IEnumerable<IStartupFilter> startupFilters,
                                  IConfiguration configuration,
-                                 IWebHostEnvironment hostingEnvironment)
+                                 IWebHostEnvironment hostingEnvironment,
+                                 HostingMetrics hostingMetrics)
     {
         Options = options.Value;
         Server = server;
@@ -40,6 +41,7 @@ public GenericWebHostService(IOptions<GenericWebHostServiceOptions> options,
         StartupFilters = startupFilters;
         Configuration = configuration;
         HostingEnvironment = hostingEnvironment;
+        HostingMetrics = hostingMetrics;
     }
 
     public GenericWebHostServiceOptions Options { get; }
@@ -55,6 +57,7 @@ public GenericWebHostService(IOptions<GenericWebHostServiceOptions> options,
     public IEnumerable<IStartupFilter> StartupFilters { get; }
     public IConfiguration Configuration { get; }
     public IWebHostEnvironment HostingEnvironment { get; }
+    public HostingMetrics HostingMetrics { get; }
 
     public async Task StartAsync(CancellationToken cancellationToken)
     {
@@ -153,7 +156,7 @@ static string ExpandPorts(string ports, string scheme)
             application = ErrorPageBuilder.BuildErrorPageApplication(HostingEnvironment.ContentRootFileProvider, Logger, showDetailedErrors, ex);
         }
 
-        var httpApplication = new HostingApplication(application, Logger, DiagnosticListener, ActivitySource, Propagator, HttpContextFactory);
+        var httpApplication = new HostingApplication(application, Logger, DiagnosticListener, ActivitySource, Propagator, HttpContextFactory, HostingMetrics);
 
         await Server.StartAsync(httpApplication, cancellationToken);
         HostingEventSource.Log.ServerReady();

src/Hosting/Hosting/src/Internal/HostingApplication.cs

@@ -23,10 +23,11 @@ public HostingApplication(
         DiagnosticListener diagnosticSource,
         ActivitySource activitySource,
         DistributedContextPropagator propagator,
-        IHttpContextFactory httpContextFactory)
+        IHttpContextFactory httpContextFactory,
+        HostingMetrics metrics)
     {
         _application = application;
-        _diagnostics = new HostingApplicationDiagnostics(logger, diagnosticSource, activitySource, propagator);
+        _diagnostics = new HostingApplicationDiagnostics(logger, diagnosticSource, activitySource, propagator, metrics);
         if (httpContextFactory is DefaultHttpContextFactory factory)
         {
             _defaultHttpContextFactory = factory;

src/Hosting/Hosting/src/Internal/HostingApplicationDiagnostics.cs

@@ -28,26 +28,29 @@ internal sealed class HostingApplicationDiagnostics
     private readonly ActivitySource _activitySource;
     private readonly DiagnosticListener _diagnosticListener;
     private readonly DistributedContextPropagator _propagator;
+    private readonly HostingMetrics _metrics;
     private readonly ILogger _logger;
 
     public HostingApplicationDiagnostics(
         ILogger logger,
         DiagnosticListener diagnosticListener,
         ActivitySource activitySource,
-        DistributedContextPropagator propagator)
+        DistributedContextPropagator propagator,
+        HostingMetrics metrics)
     {
         _logger = logger;
         _diagnosticListener = diagnosticListener;
         _activitySource = activitySource;
         _propagator = propagator;
+        _metrics = metrics;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void BeginRequest(HttpContext httpContext, HostingApplication.Context context)
     {
         long startTimestamp = 0;
 
-        if (HostingEventSource.Log.IsEnabled())
+        if (HostingEventSource.Log.IsEnabled() || _metrics.IsEnabled())
         {
             context.EventLogEnabled = true;
             // To keep the hot path short we defer logging in this function to non-inlines

src/Hosting/Hosting/src/Internal/HostingEventSource.cs

@@ -19,6 +19,10 @@ internal sealed class HostingEventSource : EventSource
     private long _currentRequests;
     private long _failedRequests;
 
+    public long TotalRequests => Volatile.Read(ref _totalRequests);
+    public long CurrentRequests => Volatile.Read(ref _currentRequests);
+    public long FailedRequests => Volatile.Read(ref _failedRequests);
+
     internal HostingEventSource()
         : this("Microsoft.AspNetCore.Hosting")
     {
@@ -90,23 +94,23 @@ protected override void OnEventCommand(EventCommandEventArgs command)
             // This is the convention for initializing counters in the RuntimeEventSource (lazily on the first enable command).
             // They aren't disabled afterwards...
 
-            _requestsPerSecondCounter ??= new IncrementingPollingCounter("requests-per-second", this, () => Volatile.Read(ref _totalRequests))
+            _requestsPerSecondCounter ??= new IncrementingPollingCounter("requests-per-second", this, () => TotalRequests)
             {
                 DisplayName = "Request Rate",
                 DisplayRateTimeScale = TimeSpan.FromSeconds(1)
             };
 
-            _totalRequestsCounter ??= new PollingCounter("total-requests", this, () => Volatile.Read(ref _totalRequests))
+            _totalRequestsCounter ??= new PollingCounter("total-requests", this, () => TotalRequests)
             {
                 DisplayName = "Total Requests",
             };
 
-            _currentRequestsCounter ??= new PollingCounter("current-requests", this, () => Volatile.Read(ref _currentRequests))
+            _currentRequestsCounter ??= new PollingCounter("current-requests", this, () => CurrentRequests)
             {
                 DisplayName = "Current Requests"
             };
 
-            _failedRequestsCounter ??= new PollingCounter("failed-requests", this, () => Volatile.Read(ref _failedRequests))
+            _failedRequestsCounter ??= new PollingCounter("failed-requests", this, () => FailedRequests)
             {
                 DisplayName = "Failed Requests"
             };

src/Hosting/Hosting/src/Internal/HostingMetrics.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Metrics;
+
+namespace Microsoft.AspNetCore.Hosting;
+
+internal class HostingMetrics : IDisposable
+{
+    private readonly Meter _meter;
+    private readonly ObservableCounter<long> _totalRequestsCounter;
+    private readonly ObservableUpDownCounter<long> _currentRequestsCounter;
+    private readonly ObservableCounter<long> _failedRequestsCounter;
+
+    public HostingMetrics(IMetricsFactory metricsFactory)
+    {
+        _meter = metricsFactory.CreateMeter("Microsoft.AspNetCore.Hosting");
+
+        _totalRequestsCounter = _meter.CreateObservableCounter<long>(
+            "total-requests",
+            () => HostingEventSource.Log.TotalRequests,
+            description: "Total Requests");
+
+        _currentRequestsCounter = _meter.CreateObservableUpDownCounter<long>(
+            "current-requests",
+            () => HostingEventSource.Log.CurrentRequests,
+            description: "Current Requests");
+
+        _failedRequestsCounter = _meter.CreateObservableCounter<long>(
+            "failed-requests",
+            () => HostingEventSource.Log.FailedRequests,
+            description: "Failed Requests");
+    }
+
+    public void Dispose()
+    {
+        _meter.Dispose();
+    }
+
+    public bool IsEnabled() => _totalRequestsCounter.Enabled || _currentRequestsCounter.Enabled || _failedRequestsCounter.Enabled;
+}

src/Hosting/Hosting/src/Internal/WebHost.cs

@@ -141,7 +141,8 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
         var activitySource = _applicationServices.GetRequiredService<ActivitySource>();
         var propagator = _applicationServices.GetRequiredService<DistributedContextPropagator>();
         var httpContextFactory = _applicationServices.GetRequiredService<IHttpContextFactory>();
-        var hostingApp = new HostingApplication(application, _logger, diagnosticSource, activitySource, propagator, httpContextFactory);
+        var hostingMetrics = _applicationServices.GetRequiredService<HostingMetrics>();
+        var hostingApp = new HostingApplication(application, _logger, diagnosticSource, activitySource, propagator, httpContextFactory, hostingMetrics);
         await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);
         _startedServer = true;
 

src/Hosting/Hosting/src/WebHostBuilder.cs

@@ -294,6 +294,9 @@ private IServiceCollection BuildCommonServices(out AggregateException? hostingSt
         services.AddOptions();
         services.AddLogging();
 
+        services.AddMetrics();
+        services.TryAddSingleton<HostingMetrics>();
+
         services.AddTransient<IServiceProviderFactory<IServiceCollection>, DefaultServiceProviderFactory>();
 
         if (!string.IsNullOrEmpty(_options.StartupAssembly))

src/Hosting/Hosting/test/Fakes/TestMetricsFactory.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Metrics;
+
+namespace Microsoft.AspNetCore.Hosting.Fakes;
+
+public class TestMetricsFactory : IMetricsFactory
+{
+    private readonly List<Meter> _meters = new List<Meter>();
+
+    public IReadOnlyList<Meter> Meters => _meters;
+
+    public Meter CreateMeter(string name)
+    {
+        var meter = new Meter(name);
+        _meters.Add(meter);
+        return meter;
+    }
+
+    public Meter CreateMeter(MeterOptions options)
+    {
+        var meter = new Meter(options.Name, options.Version);
+        _meters.Add(meter);
+        return meter;
+    }
+}

src/Hosting/Hosting/test/HostingApplicationDiagnosticsTests.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Reflection;
+using Microsoft.AspNetCore.Hosting.Fakes;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
 using Microsoft.Extensions.Logging;
@@ -590,7 +591,8 @@ private static HostingApplication CreateApplication(out FeatureCollection featur
             diagnosticListener ?? new NoopDiagnosticListener(),
             activitySource ?? new ActivitySource("Microsoft.AspNetCore"),
             DistributedContextPropagator.CreateDefaultPropagator(),
-            httpContextFactory.Object);
+            httpContextFactory.Object,
+            new HostingMetrics(new TestMetricsFactory()));
 
         return hostingApplication;
     }