initial

Author: pavelsavara

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;
@@ -24,6 +25,7 @@ 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>();
@@ -90,6 +92,9 @@ public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory,
         _logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Components.RenderTree.Renderer");
         _componentFactory = new ComponentFactory(componentActivator, this);
 
+        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 +931,15 @@ private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
     {
         var componentState = renderQueueEntry.ComponentState;
         Log.RenderingComponent(_logger, componentState);
+        var startTime = _renderingMetrics != null ? 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,91 @@
+// 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> _renderCounter;
+    private readonly Histogram<double> _renderDuration;
+
+    public RenderingMetrics(IMeterFactory meterFactory)
+    {
+        _meter = meterFactory.Create(MeterName);
+
+        _renderCounter = _meter.CreateCounter<long>(
+            "aspnetcore.components.rendering.count",
+            unit: "{render}",
+            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);
+
+        _renderCounter.Add(1, tags);
+    }
+
+    public void RenderEnd(string componentType, Exception? exception, long startTimestamp, long currentTimestamp)
+    {
+        var tags = new TagList();
+        tags = InitializeRequestTags(componentType, tags);
+
+        // Tags must match request start.
+        if (_renderCounter.Enabled)
+        {
+            _renderCounter.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 IsEnabled() => _renderCounter.Enabled || _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;
+    }
+}