Blazor - rendering metrics

src/Components/Components/src/Microsoft.AspNetCore.Components.csproj

@@ -23,6 +23,7 @@
     <Compile Include="$(SharedSourceRoot)Debugger\DictionaryItemDebugView.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)Debugger\DictionaryDebugView.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)UrlDecoder\UrlDecoder.cs" LinkBase="Shared" />
+    <Compile Include="$(SharedSourceRoot)Metrics\MetricsConstants.cs" LinkBase="Shared" />
   </ItemGroup>
 
   <Import Project="Microsoft.AspNetCore.Components.Routing.targets" />

src/Components/Components/src/RenderTree/Renderer.cs

@@ -5,6 +5,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Metrics;
 using System.Linq;
 using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.Reflection;
@@ -33,6 +34,7 @@ public abstract partial class Renderer : IDisposable, IAsyncDisposable
     private readonly Dictionary<ulong, ulong> _eventHandlerIdReplacements = new Dictionary<ulong, ulong>();
     private readonly ILogger _logger;
     private readonly ComponentFactory _componentFactory;
+    private readonly RenderingMetrics? _renderingMetrics;
     private Dictionary<int, ParameterView>? _rootComponentsLatestParameters;
     private Task? _ongoingQuiescenceTask;
 
@@ -90,6 +92,10 @@ public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory,
         _logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Components.RenderTree.Renderer");
         _componentFactory = new ComponentFactory(componentActivator, this);
 
+        // TODO register RenderingMetrics as singleton in DI
+        var meterFactory = serviceProvider.GetService<IMeterFactory>();
+        _renderingMetrics = meterFactory != null ? new RenderingMetrics(meterFactory) : null;
+
         ServiceProviderCascadingValueSuppliers = serviceProvider.GetService<ICascadingValueSupplier>() is null
             ? Array.Empty<ICascadingValueSupplier>()
             : serviceProvider.GetServices<ICascadingValueSupplier>().ToArray();
@@ -926,12 +932,15 @@ private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
     {
         var componentState = renderQueueEntry.ComponentState;
         Log.RenderingComponent(_logger, componentState);
+        var startTime = ((bool)_renderingMetrics?.IsDurationEnabled()) ? Stopwatch.GetTimestamp() : 0;
+        _renderingMetrics?.RenderStart(componentState.Component.GetType().FullName);
         componentState.RenderIntoBatch(_batchBuilder, renderQueueEntry.RenderFragment, out var renderFragmentException);
         if (renderFragmentException != null)
         {
             // If this returns, the error was handled by an error boundary. Otherwise it throws.
             HandleExceptionViaErrorBoundary(renderFragmentException, componentState);
         }
+        _renderingMetrics?.RenderEnd(componentState.Component.GetType().FullName, renderFragmentException, startTime, Stopwatch.GetTimestamp());
 
         // Process disposal queue now in case it causes further component renders to be enqueued
         ProcessDisposalQueueInExistingBatch();

src/Components/Components/src/Rendering/RenderingMetrics.cs

@@ -0,0 +1,104 @@
+// 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;
+using System.Diagnostics.Metrics;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.Components.Rendering;
+
+internal sealed class RenderingMetrics : IDisposable
+{
+    public const string MeterName = "Microsoft.AspNetCore.Components.Rendering";
+
+    private readonly Meter _meter;
+    private readonly Counter<long> _renderTotalCounter;
+    private readonly UpDownCounter<long> _renderActiveCounter;
+    private readonly Histogram<double> _renderDuration;
+
+    public RenderingMetrics(IMeterFactory meterFactory)
+    {
+        _meter = meterFactory.Create(MeterName);
+
+        _renderTotalCounter = _meter.CreateCounter<long>(
+            "aspnetcore.components.rendering.count",
+            unit: "{renders}",
+            description: "Number of component renders performed.");
+
+        _renderActiveCounter = _meter.CreateUpDownCounter<long>(
+            "aspnetcore.components.rendering.active_renders",
+            unit: "{renders}",
+            description: "Number of component renders performed.");
+
+        _renderDuration = _meter.CreateHistogram<double>(
+            "aspnetcore.components.rendering.duration",
+            unit: "ms",
+            description: "Duration of component rendering operations per component.",
+            advice: new InstrumentAdvice<double> { HistogramBucketBoundaries = MetricsConstants.ShortSecondsBucketBoundaries });
+    }
+
+    public void RenderStart(string componentType)
+    {
+        var tags = new TagList();
+        tags = InitializeRequestTags(componentType, tags);
+
+        if (_renderActiveCounter.Enabled)
+        {
+            _renderActiveCounter.Add(1, tags);
+        }
+        if (_renderTotalCounter.Enabled)
+        {
+            _renderTotalCounter.Add(1, tags);
+        }
+    }
+
+    public void RenderEnd(string componentType, Exception? exception, long startTimestamp, long currentTimestamp)
+    {
+        // Tags must match request start.
+        var tags = new TagList();
+        tags = InitializeRequestTags(componentType, tags);
+
+        if (_renderActiveCounter.Enabled)
+        {
+            _renderActiveCounter.Add(-1, tags);
+        }
+
+        if (_renderDuration.Enabled)
+        {
+            if (exception != null)
+            {
+                TryAddTag(ref tags, "error.type", exception.GetType().FullName);
+            }
+
+            var duration = Stopwatch.GetElapsedTime(startTimestamp, currentTimestamp);
+            _renderDuration.Record(duration.TotalMilliseconds, tags);
+        }
+    }
+
+    private static TagList InitializeRequestTags(string componentType, TagList tags)
+    {
+        tags.Add("component.type", componentType);
+        return tags;
+    }
+
+    public bool IsDurationEnabled() => _renderDuration.Enabled;
+
+    public void Dispose()
+    {
+        _meter.Dispose();
+    }
+
+    private static bool TryAddTag(ref TagList tags, string name, object? value)
+    {
+        for (var i = 0; i < tags.Count; i++)
+        {
+            if (tags[i].Key == name)
+            {
+                return false;
+            }
+        }
+
+        tags.Add(new KeyValuePair<string, object?>(name, value));
+        return true;
+    }
+}

src/Components/Server/src/Circuits/CircuitFactory.cs

@@ -1,6 +1,7 @@
 // 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 System.Linq;
 using System.Security.Claims;
 using Microsoft.AspNetCore.Components.Infrastructure;
@@ -20,18 +21,22 @@
     private readonly CircuitIdFactory _circuitIdFactory;
     private readonly CircuitOptions _options;
     private readonly ILogger _logger;
+    private readonly CircuitMetrics? _circuitMetrics;
 
     public CircuitFactory(
         IServiceScopeFactory scopeFactory,
         ILoggerFactory loggerFactory,
         CircuitIdFactory circuitIdFactory,
+        CircuitMetrics? circuitMetrics,
         IOptions<CircuitOptions> options)
     {
         _scopeFactory = scopeFactory;
         _loggerFactory = loggerFactory;
         _circuitIdFactory = circuitIdFactory;
         _options = options.Value;
         _logger = _loggerFactory.CreateLogger<CircuitFactory>();
+
+        _circuitMetrics = circuitMetrics;
     }
 
     public async ValueTask<CircuitHost> CreateCircuitHostAsync(
@@ -104,6 +109,7 @@
             jsRuntime,
             navigationManager,
             circuitHandlers,
+            _circuitMetrics,
             _loggerFactory.CreateLogger<CircuitHost>());
         Log.CreatedCircuit(_logger, circuitHost);
 

src/Components/Server/src/Circuits/CircuitHost.cs

@@ -1,6 +1,8 @@
 // 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;
+using System.Diagnostics.Metrics;
 using System.Globalization;
 using System.Linq;
 using System.Security.Claims;
@@ -23,11 +25,13 @@
     private readonly CircuitOptions _options;
     private readonly RemoteNavigationManager _navigationManager;
     private readonly ILogger _logger;
+    private readonly CircuitMetrics? _circuitMetrics;
     private Func<Func<Task>, Task> _dispatchInboundActivity;
     private CircuitHandler[] _circuitHandlers;
     private bool _initialized;
     private bool _isFirstUpdate = true;
     private bool _disposed;
+    private long _startTime;
 
     // This event is fired when there's an unrecoverable exception coming from the circuit, and
     // it need so be torn down. The registry listens to this even so that the circuit can
@@ -47,6 +51,7 @@
         RemoteJSRuntime jsRuntime,
         RemoteNavigationManager navigationManager,
         CircuitHandler[] circuitHandlers,
+        CircuitMetrics circuitMetrics,
         ILogger logger)
     {
         CircuitId = circuitId;
@@ -64,6 +69,7 @@
         JSRuntime = jsRuntime ?? throw new ArgumentNullException(nameof(jsRuntime));
         _navigationManager = navigationManager ?? throw new ArgumentNullException(nameof(navigationManager));
         _circuitHandlers = circuitHandlers ?? throw new ArgumentNullException(nameof(circuitHandlers));
+        _circuitMetrics = circuitMetrics;
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
         Services = scope.ServiceProvider;
@@ -230,6 +236,8 @@
     private async Task OnCircuitOpenedAsync(CancellationToken cancellationToken)
     {
         Log.CircuitOpened(_logger, CircuitId);
+        _startTime = ((bool)_circuitMetrics?.IsDurationEnabled()) ? Stopwatch.GetTimestamp() : 0;
+        _circuitMetrics?.OnCircuitOpened();
 
         Renderer.Dispatcher.AssertAccess();
 
@@ -259,6 +267,7 @@
     public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
     {
         Log.ConnectionUp(_logger, CircuitId, Client.ConnectionId);
+        _circuitMetrics?.OnConnectionUp();
 
         Renderer.Dispatcher.AssertAccess();
 
@@ -288,6 +297,7 @@
     public async Task OnConnectionDownAsync(CancellationToken cancellationToken)
     {
         Log.ConnectionDown(_logger, CircuitId, Client.ConnectionId);
+        _circuitMetrics?.OnConnectionDown();
 
         Renderer.Dispatcher.AssertAccess();
 
@@ -317,6 +327,7 @@
     private async Task OnCircuitDownAsync(CancellationToken cancellationToken)
     {
         Log.CircuitClosed(_logger, CircuitId);
+        _circuitMetrics?.OnCircuitDown(_startTime, Stopwatch.GetTimestamp());
 
         List<Exception> exceptions = null;
 

src/Components/Server/src/Circuits/CircuitMetrics.cs

@@ -0,0 +1,108 @@
+// 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;
+using System.Diagnostics.Metrics;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.Components.Server.Circuits;
+
+internal sealed class CircuitMetrics : IDisposable
+{
+    public const string MeterName = "Microsoft.AspNetCore.Components.Server.Circuits";
+
+    private readonly Meter _meter;
+    private readonly Counter<long> _circuitTotalCounter;
+    private readonly UpDownCounter<long> _circuitActiveCounter;
+    private readonly UpDownCounter<long> _circuitConnectedCounter;
+    private readonly Histogram<double> _circuitDuration;
+
+    public CircuitMetrics(IMeterFactory meterFactory)
+    {
+        _meter = meterFactory.Create(MeterName);
+
+        _circuitTotalCounter = _meter.CreateCounter<long>(
+            "aspnetcore.components.circuits.count",
+            unit: "{circuits}",
+            description: "Number of active circuits.");
+
+        _circuitActiveCounter = _meter.CreateUpDownCounter<long>(
+            "aspnetcore.components.circuits.active_circuits",
+            unit: "{circuits}",
+            description: "Number of active circuits.");
+
+        _circuitConnectedCounter = _meter.CreateUpDownCounter<long>(
+            "aspnetcore.components.circuits.connected_circuits",
+            unit: "{circuits}",
+            description: "Number of disconnected circuits.");
+
+        _circuitDuration = _meter.CreateHistogram<double>(
+            "aspnetcore.components.circuits.duration",
+            unit: "s",
+            description: "Duration of circuit.",
+            advice: new InstrumentAdvice<double> { HistogramBucketBoundaries = MetricsConstants.VeryLongSecondsBucketBoundaries });
+    }
+
+    public void OnCircuitOpened()
+    {
+        var tags = new TagList();
+
+        if (_circuitActiveCounter.Enabled)
+        {
+            _circuitActiveCounter.Add(1, tags);
+        }
+        if (_circuitTotalCounter.Enabled)
+        {
+            _circuitTotalCounter.Add(1, tags);
+        }
+    }
+
+    public void OnConnectionUp()
+    {
+        var tags = new TagList();
+
+        if (_circuitConnectedCounter.Enabled)
+        {
+            _circuitConnectedCounter.Add(1, tags);
+        }
+    }
+
+    public void OnConnectionDown()
+    {
+        var tags = new TagList();
+
+        if (_circuitConnectedCounter.Enabled)
+        {
+            _circuitConnectedCounter.Add(-1, tags);
+        }
+    }
+
+    public void OnCircuitDown(long startTimestamp, long currentTimestamp)
+    {
+        // Tags must match request start.
+        var tags = new TagList();
+
+        if (_circuitActiveCounter.Enabled)
+        {
+            _circuitActiveCounter.Add(-1, tags);
+        }
+
+        if (_circuitConnectedCounter.Enabled)
+        {
+            _circuitConnectedCounter.Add(-1, tags);
+        }
+
+        if (_circuitDuration.Enabled)
+        {
+            var duration = Stopwatch.GetElapsedTime(startTimestamp, currentTimestamp);
+            _circuitDuration.Record(duration.TotalSeconds, tags);
+        }
+    }
+
+    public bool IsDurationEnabled() => _circuitDuration.Enabled;
+
+    public void Dispose()
+    {
+        _meter.Dispose();
+    }
+}

src/Components/Server/src/DependencyInjection/ComponentServiceCollectionExtensions.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Metrics;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.AspNetCore.Components.Forms;
@@ -60,6 +61,12 @@ public static IServerSideBlazorBuilder AddServerSideBlazor(this IServiceCollecti
         // Here we add a bunch of services that don't vary in any way based on the
         // user's configuration. So even if the user has multiple independent server-side
         // Components entrypoints, this lot is the same and repeated registrations are a no-op.
+
+        services.TryAddSingleton(s =>
+        {
+            var meterFactory = s.GetService<IMeterFactory>();
+            return meterFactory != null ? new CircuitMetrics(meterFactory) : null;
+        });
         services.TryAddSingleton<ICircuitFactory, CircuitFactory>();
         services.TryAddSingleton<ICircuitHandleRegistry, CircuitHandleRegistry>();
         services.TryAddSingleton<RootTypeCache>();