Ability to monitor Blazor Server circuit activity

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

@@ -21,6 +21,7 @@ internal partial class CircuitHost : IAsyncDisposable
     private readonly CircuitHandler[] _circuitHandlers;
     private readonly RemoteNavigationManager _navigationManager;
     private readonly ILogger _logger;
+    private readonly Func<Func<Task>, Task> _dispatchInboundActivity;
     private bool _initialized;
     private bool _disposed;
 
@@ -66,6 +67,8 @@ public CircuitHost(
         Circuit = new Circuit(this);
         Handle = new CircuitHandle() { CircuitHost = this, };
 
+        _dispatchInboundActivity = BuildInboundActivityDispatcher(_circuitHandlers, Circuit);
+
         // An unhandled exception from the renderer is always fatal because it came from user code.
         Renderer.UnhandledException += ReportAndInvoke_UnhandledException;
         Renderer.UnhandledSynchronizationException += SynchronizationContext_UnhandledException;
@@ -324,7 +327,7 @@ public async Task OnRenderCompletedAsync(long renderId, string errorMessageOrNul
 
         try
         {
-            _ = Renderer.OnRenderCompletedAsync(renderId, errorMessageOrNull);
+            _ = HandleInboundActivityAsync(() => Renderer.OnRenderCompletedAsync(renderId, errorMessageOrNull));
         }
         catch (Exception e)
         {
@@ -345,12 +348,12 @@ public async Task BeginInvokeDotNetFromJS(string callId, string assemblyName, st
 
         try
         {
-            await Renderer.Dispatcher.InvokeAsync(() =>
+            await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(() =>
             {
                 Log.BeginInvokeDotNet(_logger, callId, assemblyName, methodIdentifier, dotNetObjectId);
                 var invocationInfo = new DotNetInvocationInfo(assemblyName, methodIdentifier, dotNetObjectId, callId);
                 DotNetDispatcher.BeginInvokeDotNet(JSRuntime, invocationInfo, argsJson);
-            });
+            }));
         }
         catch (Exception ex)
         {
@@ -371,7 +374,7 @@ public async Task EndInvokeJSFromDotNet(long asyncCall, bool succeeded, string a
 
         try
         {
-            await Renderer.Dispatcher.InvokeAsync(() =>
+            await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(() =>
             {
                 if (!succeeded)
                 {
@@ -384,7 +387,7 @@ await Renderer.Dispatcher.InvokeAsync(() =>
                 }
 
                 DotNetDispatcher.EndInvokeJS(JSRuntime, arguments);
-            });
+            }));
         }
         catch (Exception ex)
         {
@@ -405,11 +408,11 @@ internal async Task ReceiveByteArray(int id, byte[] data)
 
         try
         {
-            await Renderer.Dispatcher.InvokeAsync(() =>
+            await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(() =>
             {
                 Log.ReceiveByteArraySuccess(_logger, id);
                 DotNetDispatcher.ReceiveByteArray(JSRuntime, id, data);
-            });
+            }));
         }
         catch (Exception ex)
         {
@@ -430,10 +433,10 @@ internal async Task<bool> ReceiveJSDataChunk(long streamId, long chunkId, byte[]
 
         try
         {
-            return await Renderer.Dispatcher.InvokeAsync(() =>
+            return await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(() =>
             {
                 return RemoteJSDataStream.ReceiveData(JSRuntime, streamId, chunkId, chunk, error);
-            });
+            }));
         }
         catch (Exception ex)
         {
@@ -453,7 +456,7 @@ public async Task<int> SendDotNetStreamAsync(DotNetStreamReference dotNetStreamR
 
         try
         {
-            return await Renderer.Dispatcher.InvokeAsync<int>(async () => await dotNetStreamReference.Stream.ReadAsync(buffer));
+            return await Renderer.Dispatcher.InvokeAsync(async () => await dotNetStreamReference.Stream.ReadAsync(buffer));
         }
         catch (Exception ex)
         {
@@ -505,12 +508,12 @@ public async Task OnLocationChangedAsync(string uri, string state, bool intercep
 
         try
         {
-            await Renderer.Dispatcher.InvokeAsync(() =>
+            await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(() =>
             {
                 Log.LocationChange(_logger, uri, CircuitId);
                 _navigationManager.NotifyLocationChanged(uri, state, intercepted);
                 Log.LocationChangeSucceeded(_logger, uri, CircuitId);
-            });
+            }));
         }
 
         // It's up to the NavigationManager implementation to validate the URI.
@@ -547,11 +550,11 @@ public async Task OnLocationChangingAsync(int callId, string uri, string? state,
 
         try
         {
-            var shouldContinueNavigation = await Renderer.Dispatcher.InvokeAsync(async () =>
+            var shouldContinueNavigation = await HandleInboundActivityAsync(() => Renderer.Dispatcher.InvokeAsync(async () =>
             {
                 Log.LocationChanging(_logger, uri, CircuitId);
                 return await _navigationManager.HandleLocationChangingAsync(uri, state, intercepted);
-            });
+            }));
 
             await Client.SendAsync("JS.EndLocationChanging", callId, shouldContinueNavigation);
         }
@@ -589,6 +592,40 @@ public void SendPendingBatches()
         _ = Renderer.Dispatcher.InvokeAsync(Renderer.ProcessBufferedRenderBatches);
     }
 
+    // Internal for testing.
+    internal Task HandleInboundActivityAsync(Func<Task> handler)
+        => _dispatchInboundActivity(handler);
+
+    // Internal for testing.
+    internal async Task<TResult> HandleInboundActivityAsync<TResult>(Func<Task<TResult>> handler)
+    {
+        TResult result = default;
+        await _dispatchInboundActivity(async () => result = await handler());
+        return result;
+    }
+
+    private static Func<Func<Task>, Task> BuildInboundActivityDispatcher(IReadOnlyList<CircuitHandler> circuitHandlers, Circuit circuit)
+    {
+        Func<CircuitInboundActivityContext, Task>? result = null;
+
+        for (var i = circuitHandlers.Count - 1; i >= 0; i--)
+        {
+            if (circuitHandlers[i] is IHandleCircuitActivity inboundActivityHandler)
+            {
+                var next = result ?? (static (context) => context.Handler());
+                result = (context) => inboundActivityHandler.HandleInboundActivityAsync(context, next);
+            }
+        }
+
+        if (result is null)
+        {
+            // If there are no registered handlers, there is no need to allocate a context on each call.
+            return static (handler) => handler();
+        }
+
+        return (handler) => result(new(handler, circuit));
+    }
+
     private void AssertInitialized()
     {
         if (!_initialized)

src/Components/Server/src/Circuits/CircuitInboundActivityContext.cs

@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Server.Circuits;
+
+/// <summary>
+/// Contains information about inbound <see cref="Circuits.Circuit"/> activity.
+/// </summary>
+public sealed class CircuitInboundActivityContext
+{
+    internal Func<Task> Handler { get; }
+
+    /// <summary>
+    /// Gets the <see cref="Circuits.Circuit"/> associated with the activity.
+    /// </summary>
+    public Circuit Circuit { get; }
+
+    internal CircuitInboundActivityContext(Func<Task> handler, Circuit circuit)
+    {
+        Handler = handler;
+        Circuit = circuit;
+    }
+}

src/Components/Server/src/Circuits/IHandleCircuitActivity.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Server.Circuits;
+
+/// <summary>
+/// A handler to process inbound circuit activity.
+/// </summary>
+public interface IHandleCircuitActivity
+{
+    /// <summary>
+    /// Invoked when inbound activity on the circuit causes an asynchronous task to be dispatched on the server.
+    /// </summary>
+    /// <param name="context">The <see cref="CircuitInboundActivityContext"/>.</param>
+    /// <param name="next">The next handler to invoke.</param>
+    /// <returns>A <see cref="Task"/> that completes when the activity has finished.</returns>
+    Task HandleInboundActivityAsync(CircuitInboundActivityContext context, Func<CircuitInboundActivityContext, Task> next);
+}

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

@@ -1 +1,5 @@
 #nullable enable
+Microsoft.AspNetCore.Components.Server.Circuits.CircuitInboundActivityContext
+Microsoft.AspNetCore.Components.Server.Circuits.CircuitInboundActivityContext.Circuit.get -> Microsoft.AspNetCore.Components.Server.Circuits.Circuit!
+Microsoft.AspNetCore.Components.Server.Circuits.IHandleCircuitActivity
+Microsoft.AspNetCore.Components.Server.Circuits.IHandleCircuitActivity.HandleInboundActivityAsync(Microsoft.AspNetCore.Components.Server.Circuits.CircuitInboundActivityContext! context, System.Func<Microsoft.AspNetCore.Components.Server.Circuits.CircuitInboundActivityContext!, System.Threading.Tasks.Task!>! next) -> System.Threading.Tasks.Task!

src/Components/Server/test/Circuits/CircuitHostTest.cs

@@ -318,6 +318,83 @@ public async Task DisposeAsync_InvokesCircuitHandler()
         handler2.VerifyAll();
     }
 
+    [Fact]
+    public async Task HandleInboundActivityAsync_InvokesCircuitActivityHandlers()
+    {
+        // Arrange
+        var handler1 = new Mock<CircuitHandler>(MockBehavior.Strict);
+        var handler2 = new Mock<CircuitHandler>(MockBehavior.Strict);
+        var handler3 = new Mock<CircuitHandler>(MockBehavior.Strict);
+        var sequence = new MockSequence();
+
+        // We deliberately avoid making handler2 an inbound activity handler
+        var activityHandler1 = handler1.As<IHandleCircuitActivity>();
+        var activityHandler3 = handler3.As<IHandleCircuitActivity>();
+
+        var asyncLocal1 = new AsyncLocal<bool>();
+        var asyncLocal3 = new AsyncLocal<bool>();
+
+        activityHandler1
+            .InSequence(sequence)
+            .Setup(h => h.HandleInboundActivityAsync(It.IsAny<CircuitInboundActivityContext>(), It.IsAny<Func<CircuitInboundActivityContext, Task>>()))
+            .Returns(async (CircuitInboundActivityContext context, Func<CircuitInboundActivityContext, Task> next) =>
+            {
+                asyncLocal1.Value = true;
+                await next(context);
+            })
+            .Verifiable();
+
+        activityHandler3
+            .InSequence(sequence)
+            .Setup(h => h.HandleInboundActivityAsync(It.IsAny<CircuitInboundActivityContext>(), It.IsAny<Func<CircuitInboundActivityContext, Task>>()))
+            .Returns(async (CircuitInboundActivityContext context, Func<CircuitInboundActivityContext, Task> next) =>
+            {
+                asyncLocal3.Value = true;
+                await next(context);
+            })
+            .Verifiable();
+
+        var circuitHost = TestCircuitHost.Create(handlers: new[] { handler1.Object, handler2.Object, handler3.Object });
+        var asyncLocal1ValueInHandler = false;
+        var asyncLocal3ValueInHandler = false;
+
+        // Act
+        await circuitHost.HandleInboundActivityAsync(() =>
+        {
+            asyncLocal1ValueInHandler = asyncLocal1.Value;
+            asyncLocal3ValueInHandler = asyncLocal3.Value;
+            return Task.CompletedTask;
+        });
+
+        // Assert
+        activityHandler1.VerifyAll();
+        activityHandler3.VerifyAll();
+
+        Assert.False(asyncLocal1.Value);
+        Assert.False(asyncLocal3.Value);
+
+        Assert.True(asyncLocal1ValueInHandler);
+        Assert.True(asyncLocal3ValueInHandler);
+    }
+
+    [Fact]
+    public async Task HandleInboundActivityAsync_InvokesHandlerFunc_WhenNoCircuitActivityHandlersAreRegistered()
+    {
+        // Arrange
+        var circuitHost = TestCircuitHost.Create();
+        var wasHandlerFuncInvoked = false;
+
+        // Act
+        await circuitHost.HandleInboundActivityAsync(() =>
+        {
+            wasHandlerFuncInvoked = true;
+            return Task.CompletedTask;
+        });
+
+        // Assert
+        Assert.True(wasHandlerFuncInvoked);
+    }
+
     private static TestRemoteRenderer GetRemoteRenderer()
     {
         var serviceCollection = new ServiceCollection();

src/Components/test/E2ETest/ServerExecutionTests/CircuitContextTest.cs

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Components.TestServer;
+using Microsoft.AspNetCore.Components.E2ETest;
+using Microsoft.AspNetCore.Components.E2ETest.Infrastructure;
+using Microsoft.AspNetCore.Components.E2ETest.Infrastructure.ServerFixtures;
+using Microsoft.AspNetCore.E2ETesting;
+using OpenQA.Selenium;
+using TestServer;
+using Xunit.Abstractions;
+
+namespace Microsoft.AspNetCore.Components.E2ETests.ServerExecutionTests;
+
+public class CircuitContextTest : ServerTestBase<BasicTestAppServerSiteFixture<ServerStartup>>
+{
+    public CircuitContextTest(
+        BrowserFixture browserFixture,
+        BasicTestAppServerSiteFixture<ServerStartup> serverFixture,
+        ITestOutputHelper output)
+        : base(browserFixture, serverFixture, output)
+    {
+    }
+
+    protected override void InitializeAsyncCore()
+    {
+        Navigate(ServerPathBase, noReload: false);
+        Browser.MountTestComponent<CircuitContextComponent>();
+        Browser.Equal("Circuit Context", () => Browser.Exists(By.TagName("h1")).Text);
+    }
+
+    [Fact]
+    public void ComponentMethods_HaveCircuitContext()
+    {
+        Browser.Click(By.Id("trigger-click-event-button"));
+
+        Browser.True(() => HasCircuitContext("SetParametersAsync"));
+        Browser.True(() => HasCircuitContext("OnInitializedAsync"));
+        Browser.True(() => HasCircuitContext("OnParametersSetAsync"));
+        Browser.True(() => HasCircuitContext("OnAfterRenderAsync"));
+        Browser.True(() => HasCircuitContext("InvokeDotNet"));
+        Browser.True(() => HasCircuitContext("OnClickEvent"));
+
+        bool HasCircuitContext(string eventName)
+        {
+            var resultText = Browser.FindElement(By.Id($"circuit-context-result-{eventName}")).Text;
+            var result = bool.Parse(resultText);
+            return result;
+        }
+    }
+}

src/Components/test/testassets/BasicTestApp/Index.razor

@@ -10,6 +10,7 @@
         <option value="BasicTestApp.AuthTest.CascadingAuthenticationStateParent">Cascading authentication state</option>
         <option value="BasicTestApp.BindCasesComponent">bind cases</option>
         <option value="BasicTestApp.CascadingValueTest.CascadingValueSupplier">Cascading values</option>
+        <option value="@GetTestServerProjectComponent("Components.TestServer.CircuitContextComponent")">Circuit context</option>
         <option value="BasicTestApp.ComponentRefComponent">Component ref component</option>
         <option value="BasicTestApp.ConcurrentRenderParent">Concurrent rendering</option>
         <option value="BasicTestApp.ConfigurationComponent">Configuration</option>

src/Components/test/testassets/BasicTestApp/wwwroot/index.html

@@ -26,6 +26,7 @@
     </div>
 
     <!-- Used for specific test cases -->
+    <script src="js/circuitContextTest.js"></script>
     <script src="js/jsinteroptests.js"></script>
     <script src="js/renderattributestest.js"></script>
     <script src="js/webComponentPerformingJsInterop.js"></script>

src/Components/test/testassets/BasicTestApp/wwwroot/js/circuitContextTest.js

@@ -0,0 +1,5 @@
+window.circuitContextTest = {
+    invokeDotNetMethod: async (dotNetObject) => {
+        await dotNetObject.invokeMethodAsync('InvokeDotNet');
+    },
+};