more

Author: pavelsavara

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

@@ -25,7 +25,6 @@ namespace Microsoft.AspNetCore.Components.RenderTree;
 // dispatching events to them, and notifying when the user interface is being updated.
 public abstract partial class Renderer : IDisposable, IAsyncDisposable
 {
-    private readonly RenderingMetrics? _renderingMetrics;
     private readonly object _lockObject = new();
     private readonly IServiceProvider _serviceProvider;
     private readonly Dictionary<int, ComponentState> _componentStateById = new Dictionary<int, ComponentState>();
@@ -35,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;
 
@@ -92,6 +92,7 @@ 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;
 
@@ -931,7 +932,7 @@ private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
     {
         var componentState = renderQueueEntry.ComponentState;
         Log.RenderingComponent(_logger, componentState);
-        var startTime = _renderingMetrics != null ? Stopwatch.GetTimestamp() : 0;
+        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)

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

@@ -12,16 +12,22 @@ internal sealed class RenderingMetrics : IDisposable
     public const string MeterName = "Microsoft.AspNetCore.Components.Rendering";
 
     private readonly Meter _meter;
-    private readonly Counter<long> _renderCounter;
+    private readonly Counter<long> _renderTotalCounter;
+    private readonly UpDownCounter<long> _renderActiveCounter;
     private readonly Histogram<double> _renderDuration;
 
     public RenderingMetrics(IMeterFactory meterFactory)
     {
         _meter = meterFactory.Create(MeterName);
 
-        _renderCounter = _meter.CreateCounter<long>(
+        _renderTotalCounter = _meter.CreateCounter<long>(
             "aspnetcore.components.rendering.count",
-            unit: "{render}",
+            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>(
@@ -36,18 +42,25 @@ public void RenderStart(string componentType)
         var tags = new TagList();
         tags = InitializeRequestTags(componentType, tags);
 
-        _renderCounter.Add(1, 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);
 
-        // Tags must match request start.
-        if (_renderCounter.Enabled)
+        if (_renderActiveCounter.Enabled)
         {
-            _renderCounter.Add(-1, tags);
+            _renderActiveCounter.Add(-1, tags);
         }
 
         if (_renderDuration.Enabled)
@@ -68,7 +81,7 @@ private static TagList InitializeRequestTags(string componentType, TagList tags)
         return tags;
     }
 
-    public bool IsEnabled() => _renderCounter.Enabled || _renderDuration.Enabled;
+    public bool IsDurationEnabled() => _renderDuration.Enabled;
 
     public void Dispose()
     {

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 @@ internal sealed partial class CircuitFactory : ICircuitFactory
     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 @@ public async ValueTask<CircuitHost> CreateCircuitHostAsync(
             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 @@ internal partial class CircuitHost : IAsyncDisposable
     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 @@ public CircuitHost(
         RemoteJSRuntime jsRuntime,
         RemoteNavigationManager navigationManager,
         CircuitHandler[] circuitHandlers,
+        CircuitMetrics circuitMetrics,
         ILogger logger)
     {
         CircuitId = circuitId;
@@ -64,6 +69,7 @@ public CircuitHost(
         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 @@ await Renderer.Dispatcher.InvokeAsync(async () =>
     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 @@ private async Task OnCircuitOpenedAsync(CancellationToken cancellationToken)
     public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
     {
         Log.ConnectionUp(_logger, CircuitId, Client.ConnectionId);
+        _circuitMetrics?.OnConnectionUp();
 
         Renderer.Dispatcher.AssertAccess();
 
@@ -288,6 +297,7 @@ public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
     public async Task OnConnectionDownAsync(CancellationToken cancellationToken)
     {
         Log.ConnectionDown(_logger, CircuitId, Client.ConnectionId);
+        _circuitMetrics?.OnConnectionDown();
 
         Renderer.Dispatcher.AssertAccess();
 
@@ -317,6 +327,7 @@ public async Task OnConnectionDownAsync(CancellationToken cancellationToken)
     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>();

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

@@ -26,7 +26,8 @@
 
     <Compile Include="$(SharedSourceRoot)ValueStopwatch\*.cs" />
     <Compile Include="$(SharedSourceRoot)LinkerFlags.cs" LinkBase="Shared" />
-    <Compile Include="$(SharedSourceRoot)\PooledArrayBufferWriter.cs" LinkBase="Shared" />
+    <Compile Include="$(SharedSourceRoot)PooledArrayBufferWriter.cs" LinkBase="Shared" />
+    <Compile Include="$(SharedSourceRoot)Metrics\MetricsConstants.cs" LinkBase="Shared" />
 
     <!-- Add a project dependency without reference output assemblies to enforce build order -->
     <!-- Applying workaround for https://github.com/microsoft/msbuild/issues/2661 and https://github.com/dotnet/sdk/issues/952 -->

src/Shared/Metrics/MetricsConstants.cs

@@ -10,4 +10,7 @@ internal static class MetricsConstants
 
     // Not based on a standard. Larger bucket sizes for longer lasting operations, e.g. HTTP connection duration. See https://github.com/open-telemetry/semantic-conventions/issues/336
     public static readonly IReadOnlyList<double> LongSecondsBucketBoundaries = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 30, 60, 120, 300];
+
+    // For Blazor/signalR sessions, which can last a long time.
+    public static readonly IReadOnlyList<double> VeryLongSecondsBucketBoundaries = [0.5, 1, 2, 5, 10, 30, 60, 120, 300, 600, 1500, 60*60, 2 * 60 * 60, 4 * 60 * 60];
 }