- DI feedback

- new set of rendering metrics
- draft of trimming for WASM

Author: pavelsavara

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -1,4 +1,5 @@
 #nullable enable
+Microsoft.AspNetCore.Components.Infrastructure.RenderingMetricsServiceCollectionExtensions
 Microsoft.AspNetCore.Components.NavigationManager.OnNotFound -> System.EventHandler<Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs!>!
 Microsoft.AspNetCore.Components.NavigationManager.NotFound() -> void
 Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs
@@ -10,4 +11,5 @@ Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateAttri
 Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateAttribute.SupplyParameterFromPersistentComponentStateAttribute() -> void
 Microsoft.Extensions.DependencyInjection.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions
 static Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponentStateServiceCollectionExtensions.AddPersistentServiceRegistration<TService>(Microsoft.Extensions.DependencyInjection.IServiceCollection! services, Microsoft.AspNetCore.Components.IComponentRenderMode! componentRenderMode) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
+static Microsoft.AspNetCore.Components.Infrastructure.RenderingMetricsServiceCollectionExtensions.AddRenderingMetrics(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.Extensions.DependencyInjection.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddSupplyValueFromPersistentComponentStateProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

src/Components/Components/src/RegisterRenderingMetricsServiceCollectionExtensions.cs

@@ -0,0 +1,31 @@
+// 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.Components.Rendering;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.AspNetCore.Components.Infrastructure;
+
+/// <summary>
+/// Infrastructure APIs for registering diagnostic metrics.
+/// </summary>
+public static class RenderingMetricsServiceCollectionExtensions
+{
+    /// <summary>
+    /// Registers component rendering metrics
+    /// </summary>
+    /// <param name="services">The <see cref="IServiceCollection"/>.</param>
+    /// <returns>The <see cref="IServiceCollection"/>.</returns>
+    public static IServiceCollection AddRenderingMetrics(
+        IServiceCollection services)
+    {
+        if (RenderingMetrics.IsMetricsSupported)
+        {
+            services.AddMetrics();
+            services.TryAddSingleton<RenderingMetrics>();
+        }
+
+        return services;
+    }
+}

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

@@ -5,7 +5,6 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Diagnostics.Metrics;
 using System.Linq;
 using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.Reflection;
@@ -30,7 +29,7 @@ public abstract partial class Renderer : IDisposable, IAsyncDisposable
     private readonly Dictionary<int, ComponentState> _componentStateById = new Dictionary<int, ComponentState>();
     private readonly Dictionary<IComponent, ComponentState> _componentStateByComponent = new Dictionary<IComponent, ComponentState>();
     private readonly RenderBatchBuilder _batchBuilder = new RenderBatchBuilder();
-    private readonly Dictionary<ulong, (int RenderedByComponentId, EventCallback Callback)> _eventBindings = new();
+    private readonly Dictionary<ulong, (int RenderedByComponentId, EventCallback Callback, string? attributeName)> _eventBindings = new();
     private readonly Dictionary<ulong, ulong> _eventHandlerIdReplacements = new Dictionary<ulong, ulong>();
     private readonly ILogger _logger;
     private readonly ComponentFactory _componentFactory;
@@ -91,17 +90,18 @@ public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory,
         // logger name in here as a string literal.
         _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>();
-        Debug.Assert(meterFactory != null, "IMeterFactory should be registered in DI");
-        _renderingMetrics = new RenderingMetrics(meterFactory);
+        if (RenderingMetrics.IsMetricsSupported)
+        {
+            _renderingMetrics = serviceProvider.GetService<RenderingMetrics>();
+        }
 
         ServiceProviderCascadingValueSuppliers = serviceProvider.GetService<ICascadingValueSupplier>() is null
             ? Array.Empty<ICascadingValueSupplier>()
             : serviceProvider.GetServices<ICascadingValueSupplier>().ToArray();
     }
 
+    internal RenderingMetrics? RenderingMetrics => RenderingMetrics.IsMetricsSupported ? _renderingMetrics : null;
+
     internal ICascadingValueSupplier[] ServiceProviderCascadingValueSuppliers { get; }
 
     internal HotReloadManager HotReloadManager { get; set; } = HotReloadManager.Default;
@@ -437,12 +437,14 @@ public virtual Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo? fie
     {
         Dispatcher.AssertAccess();
 
+        var eventStartTimestamp = RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsEventDurationEnabled ? Stopwatch.GetTimestamp() : 0;
+
         if (waitForQuiescence)
         {
             _pendingTasks ??= new();
         }
 
-        var (renderedByComponentId, callback) = GetRequiredEventBindingEntry(eventHandlerId);
+        var (renderedByComponentId, callback, attributeName) = GetRequiredEventBindingEntry(eventHandlerId);
 
         // If this event attribute was rendered by a component that's since been disposed, don't dispatch the event at all.
         // This can occur because event handler disposal is deferred, so event handler IDs can outlive their components.
@@ -484,9 +486,38 @@ public virtual Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo? fie
             _isBatchInProgress = true;
 
             task = callback.InvokeAsync(eventArgs);
+
+            // collect metrics
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsEventDurationEnabled)
+            {
+                var receiverName = (callback.Receiver?.GetType() ?? callback.Delegate.Target?.GetType())?.FullName;
+                RenderingMetrics.EventSyncEnd(eventStartTimestamp, Stopwatch.GetTimestamp(), receiverName, attributeName);
+                task.ContinueWith(t =>
+                {
+                    if (!t.IsFaulted)
+                    {
+                        RenderingMetrics.EventAsyncEnd(eventStartTimestamp, Stopwatch.GetTimestamp(), receiverName, attributeName);
+                    }
+                }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+            }
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsEventExceptionEnabled)
+            {
+                task.ContinueWith(t =>
+                {
+                    if (t.IsFaulted)
+                    {
+                        var receiverName = (callback.Receiver?.GetType() ?? callback.Delegate.Target?.GetType())?.FullName;
+                        RenderingMetrics.EventFailed(t.Exception.GetType().FullName, receiverName, attributeName);
+                    }
+                }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+            }
         }
         catch (Exception e)
         {
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsEventExceptionEnabled)
+            {
+                RenderingMetrics.EventFailed(e.GetType().FullName, Component.GetType().FullName, attributeName);
+            }
             HandleExceptionViaErrorBoundary(e, receiverComponentState);
             return Task.CompletedTask;
         }
@@ -497,6 +528,10 @@ public virtual Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo? fie
             // Since the task has yielded - process any queued rendering work before we return control
             // to the caller.
             ProcessPendingRender();
+
+            //callback.Receiver
+            //callback.Delegate.Method.
+
         }
 
         // Task completed synchronously or is still running. We already processed all of the rendering
@@ -638,15 +673,15 @@ internal void AssignEventHandlerId(int renderedByComponentId, ref RenderTreeFram
             //
             // When that happens we intentionally box the EventCallback because we need to hold on to
             // the receiver.
-            _eventBindings.Add(id, (renderedByComponentId, callback));
+            _eventBindings.Add(id, (renderedByComponentId, callback, frame.AttributeName));
         }
         else if (frame.AttributeValueField is MulticastDelegate @delegate)
         {
             // This is the common case for a delegate, where the receiver of the event
             // is the same as delegate.Target. In this case since the receiver is implicit we can
             // avoid boxing the EventCallback object and just re-hydrate it on the other side of the
             // render tree.
-            _eventBindings.Add(id, (renderedByComponentId, new EventCallback(@delegate.Target as IHandleEvent, @delegate)));
+            _eventBindings.Add(id, (renderedByComponentId, new EventCallback(@delegate.Target as IHandleEvent, @delegate), frame.AttributeName));
         }
 
         // NOTE: we do not to handle EventCallback<T> here. EventCallback<T> is only used when passing
@@ -690,7 +725,7 @@ internal void TrackReplacedEventHandlerId(ulong oldEventHandlerId, ulong newEven
         _eventHandlerIdReplacements.Add(oldEventHandlerId, newEventHandlerId);
     }
 
-    private (int RenderedByComponentId, EventCallback Callback) GetRequiredEventBindingEntry(ulong eventHandlerId)
+    private (int RenderedByComponentId, EventCallback Callback, string? attributeName) GetRequiredEventBindingEntry(ulong eventHandlerId)
     {
         if (!_eventBindings.TryGetValue(eventHandlerId, out var entry))
         {
@@ -756,6 +791,7 @@ private void ProcessRenderQueue()
 
         _isBatchInProgress = true;
         var updateDisplayTask = Task.CompletedTask;
+        var batchStartTimestamp = RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsBatchDurationEnabled ? Stopwatch.GetTimestamp() : 0;
 
         try
         {
@@ -787,6 +823,11 @@ private void ProcessRenderQueue()
             // Fire off the execution of OnAfterRenderAsync, but don't wait for it
             // if there is async work to be done.
             _ = InvokeRenderCompletedCalls(batch.UpdatedComponents, updateDisplayTask);
+
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsBatchDurationEnabled)
+            {
+                _renderingMetrics.BatchEnd(batchStartTimestamp, Stopwatch.GetTimestamp(), batch.UpdatedComponents.Count);
+            }
         }
         catch (Exception e)
         {
@@ -815,6 +856,10 @@ private Task InvokeRenderCompletedCalls(ArrayRange<RenderTreeDiff> updatedCompon
     {
         if (updateDisplayTask.IsCanceled)
         {
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsBatchExceptionEnabled)
+            {
+                _renderingMetrics.BatchFailed(typeof(TaskCanceledException).FullName);
+            }
             // The display update was canceled.
             // This can be due to a timeout on the components server-side case, or the renderer being disposed.
 
@@ -825,6 +870,11 @@ private Task InvokeRenderCompletedCalls(ArrayRange<RenderTreeDiff> updatedCompon
         }
         if (updateDisplayTask.IsFaulted)
         {
+            if (RenderingMetrics.IsMetricsSupported && RenderingMetrics != null && RenderingMetrics.IsBatchExceptionEnabled)
+            {
+                _renderingMetrics.BatchFailed(updateDisplayTask.Exception.GetType().FullName);
+            }
+
             // The display update failed so we don't care any more about running on render completed
             // fallbacks as the entire rendering process is going to be torn down.
             HandleException(updateDisplayTask.Exception);
@@ -933,15 +983,13 @@ private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
     {
         var componentState = renderQueueEntry.ComponentState;
         Log.RenderingComponent(_logger, componentState);
-        var startTime = (_renderingMetrics != null && _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/ComponentState.cs

@@ -23,6 +23,7 @@ public class ComponentState : IAsyncDisposable
     private RenderTreeBuilder _nextRenderTree;
     private ArrayBuilder<RenderTreeFrame>? _latestDirectParametersSnapshot; // Lazily instantiated
     private bool _componentWasDisposed;
+    private readonly string? _componentTypeName;
 
     /// <summary>
     /// Constructs an instance of <see cref="ComponentState"/>.
@@ -51,6 +52,11 @@ public ComponentState(Renderer renderer, int componentId, IComponent component,
             _hasCascadingParameters = true;
             _hasAnyCascadingParameterSubscriptions = AddCascadingParameterSubscriptions();
         }
+
+        if (RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && (_renderer.RenderingMetrics.IsDiffDurationEnabled || _renderer.RenderingMetrics.IsStateDurationEnabled || _renderer.RenderingMetrics.IsStateExceptionEnabled))
+        {
+            _componentTypeName = component.GetType().FullName;
+        }
     }
 
     private static ComponentState? GetSectionOutletLogicalParent(Renderer renderer, SectionOutlet sectionOutlet)
@@ -102,6 +108,7 @@ internal void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment re
 
         _nextRenderTree.Clear();
 
+        var diffStartTimestamp = RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsDiffDurationEnabled ? Stopwatch.GetTimestamp() : 0;
         try
         {
             renderFragment(_nextRenderTree);
@@ -118,6 +125,8 @@ internal void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment re
         // We don't want to make errors from this be recoverable, because there's no legitimate reason for them to happen
         _nextRenderTree.AssertTreeIsValid(Component);
 
+        var startCount = batchBuilder.EditsBuffer.Count;
+
         // Swap the old and new tree builders
         (CurrentRenderTree, _nextRenderTree) = (_nextRenderTree, CurrentRenderTree);
 
@@ -129,6 +138,15 @@ internal void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment re
             CurrentRenderTree.GetFrames());
         batchBuilder.UpdatedComponentDiffs.Append(diff);
         batchBuilder.InvalidateParameterViews();
+
+        if (RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsDiffDurationEnabled)
+        {
+            _renderer.RenderingMetrics.DiffEnd(
+                diffStartTimestamp,
+                Stopwatch.GetTimestamp(),
+                _componentTypeName,
+                batchBuilder.EditsBuffer.Count - startCount);
+        }
     }
 
     // Callers expect this method to always return a faulted task.
@@ -231,14 +249,48 @@ internal void NotifyCascadingValueChanged(in ParameterViewLifetime lifetime)
     // a consistent set to the recipient.
     private void SupplyCombinedParameters(ParameterView directAndCascadingParameters)
     {
-        // Normalise sync and async exceptions into a Task
+        // Normalize sync and async exceptions into a Task
         Task setParametersAsyncTask;
         try
         {
+            var stateStartTimestamp = RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsStateDurationEnabled ? Stopwatch.GetTimestamp() : 0;
+
             setParametersAsyncTask = Component.SetParametersAsync(directAndCascadingParameters);
+
+            // collect metrics
+            if (RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsStateDurationEnabled)
+            {
+                _renderer.RenderingMetrics.StateSyncEnd(stateStartTimestamp, Stopwatch.GetTimestamp(), _componentTypeName);
+                setParametersAsyncTask.ContinueWith(t =>
+                {
+                    if (!t.IsFaulted)
+                    {
+                        _renderer.RenderingMetrics.StateAsyncEnd(stateStartTimestamp, Stopwatch.GetTimestamp(), _componentTypeName);
+                    }
+                }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+            }
+            if (RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsStateExceptionEnabled)
+            {
+                setParametersAsyncTask.ContinueWith(t =>
+                {
+                    if (t.IsFaulted)
+                    {
+                        _renderer.RenderingMetrics.StateFailed(t.Exception.GetType().FullName, _componentTypeName);
+                    }
+                    else if (t.IsCanceled)
+                    {
+                        _renderer.RenderingMetrics.StateFailed(typeof(TaskCanceledException).FullName, _componentTypeName);
+                    }
+                }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+            }
         }
         catch (Exception ex)
         {
+            if (RenderingMetrics.IsMetricsSupported && _renderer.RenderingMetrics != null && _renderer.RenderingMetrics.IsStateExceptionEnabled)
+            {
+                _renderer.RenderingMetrics.StateFailed(ex.GetType().FullName, _componentTypeName);
+            }
+
             setParametersAsyncTask = Task.FromException(ex);
         }