diff --git a/TUnit.Engine/Interfaces/IHookDelegateBuilder.cs b/TUnit.Engine/Interfaces/IHookDelegateBuilder.cs
index 13354c314f..1a99cc7c90 100644
--- a/TUnit.Engine/Interfaces/IHookDelegateBuilder.cs
+++ b/TUnit.Engine/Interfaces/IHookDelegateBuilder.cs
@@ -14,24 +14,24 @@ internal interface IHookDelegateBuilder
     /// </summary>
     ValueTask InitializeAsync();
 
-    ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectBeforeTestHooksAsync(Type testClassType);
-    ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectAfterTestHooksAsync(Type testClassType);
-    ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectBeforeEveryTestHooksAsync(Type testClassType);
-    ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectAfterEveryTestHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectBeforeTestHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectAfterTestHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectBeforeEveryTestHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectAfterEveryTestHooksAsync(Type testClassType);
 
-    ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectBeforeClassHooksAsync(Type testClassType);
-    ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectAfterClassHooksAsync(Type testClassType);
-    ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectBeforeEveryClassHooksAsync();
-    ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectAfterEveryClassHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectBeforeClassHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectAfterClassHooksAsync(Type testClassType);
+    ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectBeforeEveryClassHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectAfterEveryClassHooksAsync();
 
-    ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectBeforeAssemblyHooksAsync(Assembly assembly);
-    ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectAfterAssemblyHooksAsync(Assembly assembly);
-    ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectBeforeEveryAssemblyHooksAsync();
-    ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectAfterEveryAssemblyHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectBeforeAssemblyHooksAsync(Assembly assembly);
+    ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectAfterAssemblyHooksAsync(Assembly assembly);
+    ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectBeforeEveryAssemblyHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectAfterEveryAssemblyHooksAsync();
 
-    ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> CollectBeforeTestSessionHooksAsync();
-    ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> CollectAfterTestSessionHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> CollectBeforeTestSessionHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> CollectAfterTestSessionHooksAsync();
 
-    ValueTask<IReadOnlyList<Func<BeforeTestDiscoveryContext, CancellationToken, Task>>> CollectBeforeTestDiscoveryHooksAsync();
-    ValueTask<IReadOnlyList<Func<TestDiscoveryContext, CancellationToken, Task>>> CollectAfterTestDiscoveryHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<BeforeTestDiscoveryContext>>> CollectBeforeTestDiscoveryHooksAsync();
+    ValueTask<IReadOnlyList<NamedHookDelegate<TestDiscoveryContext>>> CollectAfterTestDiscoveryHooksAsync();
 }
diff --git a/TUnit.Engine/NamedHookDelegate.cs b/TUnit.Engine/NamedHookDelegate.cs
new file mode 100644
index 0000000000..a79e0f399d
--- /dev/null
+++ b/TUnit.Engine/NamedHookDelegate.cs
@@ -0,0 +1,12 @@
+namespace TUnit.Engine;
+
+/// <summary>
+/// Wraps a hook delegate with its name for activity/span creation.
+/// </summary>
+internal readonly record struct NamedHookDelegate<TContext>(string Name, string ActivityName, Func<TContext, CancellationToken, Task> Invoke)
+{
+    public NamedHookDelegate(string name, Func<TContext, CancellationToken, Task> invoke)
+        : this(name, $"hook: {name}", invoke)
+    {
+    }
+}
diff --git a/TUnit.Engine/Services/HookDelegateBuilder.cs b/TUnit.Engine/Services/HookDelegateBuilder.cs
index 0f5189d9b1..e367e7a347 100644
--- a/TUnit.Engine/Services/HookDelegateBuilder.cs
+++ b/TUnit.Engine/Services/HookDelegateBuilder.cs
@@ -17,27 +17,27 @@ internal sealed class HookDelegateBuilder : IHookDelegateBuilder
 {
     private readonly EventReceiverOrchestrator _eventReceiverOrchestrator;
     private readonly TUnitFrameworkLogger _logger;
-    private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<TestContext, CancellationToken, Task>>> _beforeTestHooksCache = new();
-    private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<TestContext, CancellationToken, Task>>> _afterTestHooksCache = new();
-    private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> _beforeClassHooksCache = new();
-    private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> _afterClassHooksCache = new();
-    private readonly ConcurrentDictionary<Assembly, IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> _beforeAssemblyHooksCache = new();
-    private readonly ConcurrentDictionary<Assembly, IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> _afterAssemblyHooksCache = new();
+    private readonly ConcurrentDictionary<Type, IReadOnlyList<NamedHookDelegate<TestContext>>> _beforeTestHooksCache = new();
+    private readonly ConcurrentDictionary<Type, IReadOnlyList<NamedHookDelegate<TestContext>>> _afterTestHooksCache = new();
+    private readonly ConcurrentDictionary<Type, IReadOnlyList<NamedHookDelegate<ClassHookContext>>> _beforeClassHooksCache = new();
+    private readonly ConcurrentDictionary<Type, IReadOnlyList<NamedHookDelegate<ClassHookContext>>> _afterClassHooksCache = new();
+    private readonly ConcurrentDictionary<Assembly, IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> _beforeAssemblyHooksCache = new();
+    private readonly ConcurrentDictionary<Assembly, IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> _afterAssemblyHooksCache = new();
 
     // Cache for GetGenericTypeDefinition() calls to avoid repeated reflection
     private static readonly ConcurrentDictionary<Type, Type> _genericTypeDefinitionCache = new();
 
     // Pre-computed global hooks (computed once at initialization)
-    private IReadOnlyList<Func<TestContext, CancellationToken, Task>>? _beforeEveryTestHooks;
-    private IReadOnlyList<Func<TestContext, CancellationToken, Task>>? _afterEveryTestHooks;
-    private IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>? _beforeTestSessionHooks;
-    private IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>? _afterTestSessionHooks;
-    private IReadOnlyList<Func<BeforeTestDiscoveryContext, CancellationToken, Task>>? _beforeTestDiscoveryHooks;
-    private IReadOnlyList<Func<TestDiscoveryContext, CancellationToken, Task>>? _afterTestDiscoveryHooks;
-    private IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>? _beforeEveryClassHooks;
-    private IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>? _afterEveryClassHooks;
-    private IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>? _beforeEveryAssemblyHooks;
-    private IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>? _afterEveryAssemblyHooks;
+    private IReadOnlyList<NamedHookDelegate<TestContext>>? _beforeEveryTestHooks;
+    private IReadOnlyList<NamedHookDelegate<TestContext>>? _afterEveryTestHooks;
+    private IReadOnlyList<NamedHookDelegate<TestSessionContext>>? _beforeTestSessionHooks;
+    private IReadOnlyList<NamedHookDelegate<TestSessionContext>>? _afterTestSessionHooks;
+    private IReadOnlyList<NamedHookDelegate<BeforeTestDiscoveryContext>>? _beforeTestDiscoveryHooks;
+    private IReadOnlyList<NamedHookDelegate<TestDiscoveryContext>>? _afterTestDiscoveryHooks;
+    private IReadOnlyList<NamedHookDelegate<ClassHookContext>>? _beforeEveryClassHooks;
+    private IReadOnlyList<NamedHookDelegate<ClassHookContext>>? _afterEveryClassHooks;
+    private IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>? _beforeEveryAssemblyHooks;
+    private IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>? _afterEveryAssemblyHooks;
 
     // Cache for processed hooks to avoid re-processing event receivers
     private readonly ConcurrentDictionary<object, bool> _processedHooks = new();
@@ -82,21 +82,21 @@ public async ValueTask InitializeAsync()
     /// Generic helper to build global hooks from Sources collections.
     /// Eliminates duplication across all BuildGlobalXXXHooksAsync methods.
     /// </summary>
-    private async Task<IReadOnlyList<Func<TContext, CancellationToken, Task>>> BuildGlobalHooksAsync<THookMethod, TContext>(
+    private async Task<IReadOnlyList<NamedHookDelegate<TContext>>> BuildGlobalHooksAsync<THookMethod, TContext>(
         IEnumerable<THookMethod> sourceHooks,
-        Func<THookMethod, Task<Func<TContext, CancellationToken, Task>>> createDelegate,
+        Func<THookMethod, ValueTask<NamedHookDelegate<TContext>>> createDelegate,
         string hookTypeName)
         where THookMethod : HookMethod
     {
         // Pre-size list if possible for better performance
         var capacity = sourceHooks is ICollection<THookMethod> coll ? coll.Count : 0;
-        var hooks = new List<(int order, int registrationIndex, Func<TContext, CancellationToken, Task> hook)>(capacity);
+        var hooks = new List<(int order, int registrationIndex, NamedHookDelegate<TContext> hook)>(capacity);
 
         foreach (var hook in sourceHooks)
         {
             await _logger.LogTraceAsync($"Creating delegate for {hookTypeName} hook: {hook.Name}").ConfigureAwait(false);
-            var hookFunc = await createDelegate(hook);
-            hooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+            var namedHook = await createDelegate(hook);
+            hooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
         }
 
         if (hooks.Count > 0)
@@ -111,54 +111,39 @@ private async Task<IReadOnlyList<Func<TContext, CancellationToken, Task>>> Build
             .ToList();
     }
 
-    private Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> BuildGlobalBeforeEveryTestHooksAsync()
+    private Task<IReadOnlyList<NamedHookDelegate<TestContext>>> BuildGlobalBeforeEveryTestHooksAsync()
         => BuildGlobalHooksAsync(Sources.BeforeEveryTestHooks, CreateStaticHookDelegateAsync, "BeforeEveryTest");
 
-    private Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> BuildGlobalAfterEveryTestHooksAsync()
+    private Task<IReadOnlyList<NamedHookDelegate<TestContext>>> BuildGlobalAfterEveryTestHooksAsync()
         => BuildGlobalHooksAsync(Sources.AfterEveryTestHooks, CreateStaticHookDelegateAsync, "AfterEveryTest");
 
-    private Task<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> BuildGlobalBeforeTestSessionHooksAsync()
-        => BuildGlobalHooksAsync(Sources.BeforeTestSessionHooks, CreateTestSessionHookDelegateAsync, "BeforeTestSession");
+    private Task<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> BuildGlobalBeforeTestSessionHooksAsync()
+        => BuildGlobalHooksAsync(Sources.BeforeTestSessionHooks, CreateStaticHookDelegateAsync, "BeforeTestSession");
 
-    private Task<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> BuildGlobalAfterTestSessionHooksAsync()
-        => BuildGlobalHooksAsync(Sources.AfterTestSessionHooks, CreateTestSessionHookDelegateAsync, "AfterTestSession");
+    private Task<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> BuildGlobalAfterTestSessionHooksAsync()
+        => BuildGlobalHooksAsync(Sources.AfterTestSessionHooks, CreateStaticHookDelegateAsync, "AfterTestSession");
 
-    private Task<IReadOnlyList<Func<BeforeTestDiscoveryContext, CancellationToken, Task>>> BuildGlobalBeforeTestDiscoveryHooksAsync()
-        => BuildGlobalHooksAsync(Sources.BeforeTestDiscoveryHooks, CreateBeforeTestDiscoveryHookDelegateAsync, "BeforeTestDiscovery");
+    private Task<IReadOnlyList<NamedHookDelegate<BeforeTestDiscoveryContext>>> BuildGlobalBeforeTestDiscoveryHooksAsync()
+        => BuildGlobalHooksAsync(Sources.BeforeTestDiscoveryHooks, CreateStaticHookDelegateAsync, "BeforeTestDiscovery");
 
-    private Task<IReadOnlyList<Func<TestDiscoveryContext, CancellationToken, Task>>> BuildGlobalAfterTestDiscoveryHooksAsync()
-        => BuildGlobalHooksAsync(Sources.AfterTestDiscoveryHooks, CreateTestDiscoveryHookDelegateAsync, "AfterTestDiscovery");
+    private Task<IReadOnlyList<NamedHookDelegate<TestDiscoveryContext>>> BuildGlobalAfterTestDiscoveryHooksAsync()
+        => BuildGlobalHooksAsync(Sources.AfterTestDiscoveryHooks, CreateStaticHookDelegateAsync, "AfterTestDiscovery");
 
-    private Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> BuildGlobalBeforeEveryClassHooksAsync()
-        => BuildGlobalHooksAsync(Sources.BeforeEveryClassHooks, CreateClassHookDelegateAsync, "BeforeEveryClass");
+    private Task<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> BuildGlobalBeforeEveryClassHooksAsync()
+        => BuildGlobalHooksAsync(Sources.BeforeEveryClassHooks, CreateStaticHookDelegateAsync, "BeforeEveryClass");
 
-    private Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> BuildGlobalAfterEveryClassHooksAsync()
-        => BuildGlobalHooksAsync(Sources.AfterEveryClassHooks, CreateClassHookDelegateAsync, "AfterEveryClass");
+    private Task<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> BuildGlobalAfterEveryClassHooksAsync()
+        => BuildGlobalHooksAsync(Sources.AfterEveryClassHooks, CreateStaticHookDelegateAsync, "AfterEveryClass");
 
-    private Task<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> BuildGlobalBeforeEveryAssemblyHooksAsync()
-        => BuildGlobalHooksAsync(Sources.BeforeEveryAssemblyHooks, CreateAssemblyHookDelegateAsync, "BeforeEveryAssembly");
+    private Task<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> BuildGlobalBeforeEveryAssemblyHooksAsync()
+        => BuildGlobalHooksAsync(Sources.BeforeEveryAssemblyHooks, CreateStaticHookDelegateAsync, "BeforeEveryAssembly");
 
-    private Task<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> BuildGlobalAfterEveryAssemblyHooksAsync()
-        => BuildGlobalHooksAsync(Sources.AfterEveryAssemblyHooks, CreateAssemblyHookDelegateAsync, "AfterEveryAssembly");
+    private Task<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> BuildGlobalAfterEveryAssemblyHooksAsync()
+        => BuildGlobalHooksAsync(Sources.AfterEveryAssemblyHooks, CreateStaticHookDelegateAsync, "AfterEveryAssembly");
 
-    private static void SortAndAddHooks<TDelegate>(
-        List<Func<TestContext, CancellationToken, Task>> target,
-        List<(int order, int registrationIndex, TDelegate hook)> hooks)
-        where TDelegate : Delegate
-    {
-        hooks.Sort((a, b) => a.order != b.order
-            ? a.order.CompareTo(b.order)
-            : a.registrationIndex.CompareTo(b.registrationIndex));
-
-        foreach (var (_, _, hook) in hooks)
-        {
-            target.Add((Func<TestContext, CancellationToken, Task>)(object)hook);
-        }
-    }
-
-    private static void SortAndAddClassHooks(
-        List<Func<ClassHookContext, CancellationToken, Task>> target,
-        List<(int order, int registrationIndex, Func<ClassHookContext, CancellationToken, Task> hook)> hooks)
+    private static void SortAndAddHooks<TContext>(
+        List<NamedHookDelegate<TContext>> target,
+        List<(int order, int registrationIndex, NamedHookDelegate<TContext> hook)> hooks)
     {
         hooks.Sort((a, b) => a.order != b.order
             ? a.order.CompareTo(b.order)
@@ -190,7 +175,7 @@ private async Task ProcessHookRegistrationAsync(HookMethod hookMethod, Cancellat
         }
     }
 
-    public async ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectBeforeTestHooksAsync(Type testClassType)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectBeforeTestHooksAsync(Type testClassType)
     {
         if (_beforeTestHooksCache.TryGetValue(testClassType, out var cachedHooks))
         {
@@ -202,22 +187,22 @@ public async ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> BuildBeforeTestHooksAsync(Type type)
+    private async Task<IReadOnlyList<NamedHookDelegate<TestContext>>> BuildBeforeTestHooksAsync(Type type)
     {
-        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, Func<TestContext, CancellationToken, Task> hook)> hooks)>();
+        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, NamedHookDelegate<TestContext> hook)> hooks)>();
 
         // Collect hooks for each type in the hierarchy
         var currentType = type;
         while (currentType != null)
         {
-            var typeHooks = new List<(int order, int registrationIndex, Func<TestContext, CancellationToken, Task> hook)>();
+            var typeHooks = new List<(int order, int registrationIndex, NamedHookDelegate<TestContext> hook)>();
 
             if (Sources.BeforeTestHooks.TryGetValue(currentType, out var sourceHooks))
             {
                 foreach (var hook in sourceHooks)
                 {
-                    var hookFunc = await CreateInstanceHookDelegateAsync(hook);
-                    typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                    var namedHook = await CreateInstanceHookDelegateAsync(hook);
+                    typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                 }
             }
 
@@ -229,8 +214,8 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
                 {
                     foreach (var hook in openTypeHooks)
                     {
-                        var hookFunc = await CreateInstanceHookDelegateAsync(hook);
-                        typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                        var namedHook = await CreateInstanceHookDelegateAsync(hook);
+                        typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                     }
                 }
             }
@@ -247,7 +232,7 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
         // Reverse the list since we collected from derived to base
         hooksByType.Reverse();
 
-        var finalHooks = new List<Func<TestContext, CancellationToken, Task>>();
+        var finalHooks = new List<NamedHookDelegate<TestContext>>();
         foreach (var (_, typeHooks) in hooksByType)
         {
             // Within each type level, sort by Order then by RegistrationIndex
@@ -257,7 +242,7 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
         return finalHooks;
     }
 
-    public async ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectAfterTestHooksAsync(Type testClassType)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectAfterTestHooksAsync(Type testClassType)
     {
         if (_afterTestHooksCache.TryGetValue(testClassType, out var cachedHooks))
         {
@@ -269,22 +254,22 @@ public async ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> BuildAfterTestHooksAsync(Type type)
+    private async Task<IReadOnlyList<NamedHookDelegate<TestContext>>> BuildAfterTestHooksAsync(Type type)
     {
-        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, Func<TestContext, CancellationToken, Task> hook)> hooks)>();
+        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, NamedHookDelegate<TestContext> hook)> hooks)>();
 
         // Collect hooks for each type in the hierarchy
         var currentType = type;
         while (currentType != null)
         {
-            var typeHooks = new List<(int order, int registrationIndex, Func<TestContext, CancellationToken, Task> hook)>();
+            var typeHooks = new List<(int order, int registrationIndex, NamedHookDelegate<TestContext> hook)>();
 
             if (Sources.AfterTestHooks.TryGetValue(currentType, out var sourceHooks))
             {
                 foreach (var hook in sourceHooks)
                 {
-                    var hookFunc = await CreateInstanceHookDelegateAsync(hook);
-                    typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                    var namedHook = await CreateInstanceHookDelegateAsync(hook);
+                    typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                 }
             }
 
@@ -296,8 +281,8 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
                 {
                     foreach (var hook in openTypeHooks)
                     {
-                        var hookFunc = await CreateInstanceHookDelegateAsync(hook);
-                        typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                        var namedHook = await CreateInstanceHookDelegateAsync(hook);
+                        typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                     }
                 }
             }
@@ -313,7 +298,7 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
         // For After hooks: derived class hooks run first
         // No need to reverse since we collected from derived to base
 
-        var finalHooks = new List<Func<TestContext, CancellationToken, Task>>();
+        var finalHooks = new List<NamedHookDelegate<TestContext>>();
         foreach (var (_, typeHooks) in hooksByType)
         {
             // Within each type level, sort by Order then by RegistrationIndex
@@ -323,17 +308,17 @@ private async Task<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Bu
         return finalHooks;
     }
 
-    public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectBeforeEveryTestHooksAsync(Type testClassType)
+    public ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectBeforeEveryTestHooksAsync(Type testClassType)
     {
-        return new ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>>(_beforeEveryTestHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>>(_beforeEveryTestHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> CollectAfterEveryTestHooksAsync(Type testClassType)
+    public ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>> CollectAfterEveryTestHooksAsync(Type testClassType)
     {
-        return new ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>>(_afterEveryTestHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<TestContext>>>(_afterEveryTestHooks ?? []);
     }
 
-    public async ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectBeforeClassHooksAsync(Type testClassType)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectBeforeClassHooksAsync(Type testClassType)
     {
         if (_beforeClassHooksCache.TryGetValue(testClassType, out var cachedHooks))
         {
@@ -345,22 +330,22 @@ public async ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, T
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> BuildBeforeClassHooksAsync(Type type)
+    private async Task<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> BuildBeforeClassHooksAsync(Type type)
     {
-        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, Func<ClassHookContext, CancellationToken, Task> hook)> hooks)>();
+        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, NamedHookDelegate<ClassHookContext> hook)> hooks)>();
 
         // Collect hooks for each type in the hierarchy
         var currentType = type;
         while (currentType != null)
         {
-            var typeHooks = new List<(int order, int registrationIndex, Func<ClassHookContext, CancellationToken, Task> hook)>();
+            var typeHooks = new List<(int order, int registrationIndex, NamedHookDelegate<ClassHookContext> hook)>();
 
             if (Sources.BeforeClassHooks.TryGetValue(currentType, out var sourceHooks))
             {
                 foreach (var hook in sourceHooks)
                 {
-                    var hookFunc = await CreateClassHookDelegateAsync(hook);
-                    typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                    var namedHook = await CreateStaticHookDelegateAsync(hook);
+                    typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                 }
             }
 
@@ -372,8 +357,8 @@ private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>
                 {
                     foreach (var hook in openTypeHooks)
                     {
-                        var hookFunc = await CreateClassHookDelegateAsync(hook);
-                        typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                        var namedHook = await CreateStaticHookDelegateAsync(hook);
+                        typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                     }
                 }
             }
@@ -388,16 +373,16 @@ private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>
 
         hooksByType.Reverse();
 
-        var finalHooks = new List<Func<ClassHookContext, CancellationToken, Task>>();
+        var finalHooks = new List<NamedHookDelegate<ClassHookContext>>();
         foreach (var (_, typeHooks) in hooksByType)
         {
-            SortAndAddClassHooks(finalHooks, typeHooks);
+            SortAndAddHooks(finalHooks, typeHooks);
         }
 
         return finalHooks;
     }
 
-    public async ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectAfterClassHooksAsync(Type testClassType)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectAfterClassHooksAsync(Type testClassType)
     {
         if (_afterClassHooksCache.TryGetValue(testClassType, out var cachedHooks))
         {
@@ -409,22 +394,22 @@ public async ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, T
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> BuildAfterClassHooksAsync(Type type)
+    private async Task<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> BuildAfterClassHooksAsync(Type type)
     {
-        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, Func<ClassHookContext, CancellationToken, Task> hook)> hooks)>();
+        var hooksByType = new List<(Type type, List<(int order, int registrationIndex, NamedHookDelegate<ClassHookContext> hook)> hooks)>();
 
         // Collect hooks for each type in the hierarchy
         var currentType = type;
         while (currentType != null)
         {
-            var typeHooks = new List<(int order, int registrationIndex, Func<ClassHookContext, CancellationToken, Task> hook)>();
+            var typeHooks = new List<(int order, int registrationIndex, NamedHookDelegate<ClassHookContext> hook)>();
 
             if (Sources.AfterClassHooks.TryGetValue(currentType, out var sourceHooks))
             {
                 foreach (var hook in sourceHooks)
                 {
-                    var hookFunc = await CreateClassHookDelegateAsync(hook);
-                    typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                    var namedHook = await CreateStaticHookDelegateAsync(hook);
+                    typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                 }
             }
 
@@ -436,8 +421,8 @@ private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>
                 {
                     foreach (var hook in openTypeHooks)
                     {
-                        var hookFunc = await CreateClassHookDelegateAsync(hook);
-                        typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
+                        var namedHook = await CreateStaticHookDelegateAsync(hook);
+                        typeHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
                     }
                 }
             }
@@ -450,16 +435,16 @@ private async Task<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>
             currentType = currentType.BaseType;
         }
 
-        var finalHooks = new List<Func<ClassHookContext, CancellationToken, Task>>();
+        var finalHooks = new List<NamedHookDelegate<ClassHookContext>>();
         foreach (var (_, typeHooks) in hooksByType)
         {
-            SortAndAddClassHooks(finalHooks, typeHooks);
+            SortAndAddHooks(finalHooks, typeHooks);
         }
 
         return finalHooks;
     }
 
-    public async ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectBeforeAssemblyHooksAsync(Assembly assembly)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectBeforeAssemblyHooksAsync(Assembly assembly)
     {
         if (_beforeAssemblyHooksCache.TryGetValue(assembly, out var cachedHooks))
         {
@@ -471,28 +456,29 @@ public async ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> BuildBeforeAssemblyHooksAsync(Assembly assembly)
+    private async Task<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> BuildBeforeAssemblyHooksAsync(Assembly assembly)
     {
         if (!Sources.BeforeAssemblyHooks.TryGetValue(assembly, out var assemblyHooks))
         {
             return [];
         }
 
-        var allHooks = new List<(int order, Func<AssemblyHookContext, CancellationToken, Task> hook)>(assemblyHooks.Count);
+        var allHooks = new List<(int order, int registrationIndex, NamedHookDelegate<AssemblyHookContext> hook)>(assemblyHooks.Count);
 
         foreach (var hook in assemblyHooks)
         {
-            var hookFunc = await CreateAssemblyHookDelegateAsync(hook);
-            allHooks.Add((hook.Order, hookFunc));
+            var namedHook = await CreateStaticHookDelegateAsync(hook);
+            allHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
         }
 
         return allHooks
-            .OrderBy(h => h.order)
-            .Select(h => h.hook)
+            .OrderBy(static h => h.order)
+            .ThenBy(static h => h.registrationIndex)
+            .Select(static h => h.hook)
             .ToList();
     }
 
-    public async ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectAfterAssemblyHooksAsync(Assembly assembly)
+    public async ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectAfterAssemblyHooksAsync(Assembly assembly)
     {
         if (_afterAssemblyHooksCache.TryGetValue(assembly, out var cachedHooks))
         {
@@ -504,73 +490,76 @@ public async ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken
         return hooks;
     }
 
-    private async Task<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> BuildAfterAssemblyHooksAsync(Assembly assembly)
+    private async Task<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> BuildAfterAssemblyHooksAsync(Assembly assembly)
     {
         if (!Sources.AfterAssemblyHooks.TryGetValue(assembly, out var assemblyHooks))
         {
             return [];
         }
 
-        var allHooks = new List<(int order, Func<AssemblyHookContext, CancellationToken, Task> hook)>(assemblyHooks.Count);
+        var allHooks = new List<(int order, int registrationIndex, NamedHookDelegate<AssemblyHookContext> hook)>(assemblyHooks.Count);
 
         foreach (var hook in assemblyHooks)
         {
-            var hookFunc = await CreateAssemblyHookDelegateAsync(hook);
-            allHooks.Add((hook.Order, hookFunc));
+            var namedHook = await CreateStaticHookDelegateAsync(hook);
+            allHooks.Add((hook.Order, hook.RegistrationIndex, namedHook));
         }
 
         return allHooks
-            .OrderBy(h => h.order)
-            .Select(h => h.hook)
+            .OrderBy(static h => h.order)
+            .ThenBy(static h => h.registrationIndex)
+            .Select(static h => h.hook)
             .ToList();
     }
 
-    public ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> CollectBeforeTestSessionHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> CollectBeforeTestSessionHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>>(_beforeTestSessionHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>>(_beforeTestSessionHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>> CollectAfterTestSessionHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>> CollectAfterTestSessionHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<TestSessionContext, CancellationToken, Task>>>(_afterTestSessionHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<TestSessionContext>>>(_afterTestSessionHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<BeforeTestDiscoveryContext, CancellationToken, Task>>> CollectBeforeTestDiscoveryHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<BeforeTestDiscoveryContext>>> CollectBeforeTestDiscoveryHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<BeforeTestDiscoveryContext, CancellationToken, Task>>>(_beforeTestDiscoveryHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<BeforeTestDiscoveryContext>>>(_beforeTestDiscoveryHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<TestDiscoveryContext, CancellationToken, Task>>> CollectAfterTestDiscoveryHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<TestDiscoveryContext>>> CollectAfterTestDiscoveryHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<TestDiscoveryContext, CancellationToken, Task>>>(_afterTestDiscoveryHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<TestDiscoveryContext>>>(_afterTestDiscoveryHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectBeforeEveryClassHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectBeforeEveryClassHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>>(_beforeEveryClassHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>>(_beforeEveryClassHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>> CollectAfterEveryClassHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>> CollectAfterEveryClassHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<ClassHookContext, CancellationToken, Task>>>(_afterEveryClassHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<ClassHookContext>>>(_afterEveryClassHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectBeforeEveryAssemblyHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectBeforeEveryAssemblyHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>>(_beforeEveryAssemblyHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>>(_beforeEveryAssemblyHooks ?? []);
     }
 
-    public ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>> CollectAfterEveryAssemblyHooksAsync()
+    public ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>> CollectAfterEveryAssemblyHooksAsync()
     {
-        return new ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>>(_afterEveryAssemblyHooks ?? []);
+        return new ValueTask<IReadOnlyList<NamedHookDelegate<AssemblyHookContext>>>(_afterEveryAssemblyHooks ?? []);
     }
 
-    private async Task<Func<TestContext, CancellationToken, Task>> CreateInstanceHookDelegateAsync(InstanceHookMethod hook)
+    private async ValueTask<NamedHookDelegate<TestContext>> CreateInstanceHookDelegateAsync(InstanceHookMethod hook)
     {
         // Process hook registration event receivers
         await ProcessHookRegistrationAsync(hook);
 
-        return async (context, cancellationToken) =>
+        var name = hook.Name;
+
+        return new NamedHookDelegate<TestContext>(name, async (context, cancellationToken) =>
         {
             // Check at EXECUTION time if a custom executor should be used
             if (context.CustomHookExecutor != null)
@@ -607,142 +596,14 @@ await customExecutor.ExecuteBeforeTestHook(
 
                 await timeoutAction();
             }
-        };
+        });
     }
 
-    private async Task<Func<TestContext, CancellationToken, Task>> CreateStaticHookDelegateAsync(StaticHookMethod<TestContext> hook)
+    private async ValueTask<NamedHookDelegate<TContext>> CreateStaticHookDelegateAsync<TContext>(StaticHookMethod<TContext> hook)
     {
-        // Process hook registration event receivers
         await ProcessHookRegistrationAsync(hook);
 
-        return (context, cancellationToken) => HookTimeoutHelper.CreateTimeoutHookAction(
-            hook,
-            context,
-            cancellationToken);
-    }
-
-    private static Func<ClassHookContext, CancellationToken, Task> CreateClassHookDelegate(StaticHookMethod<ClassHookContext> hook)
-    {
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private async Task<Func<ClassHookContext, CancellationToken, Task>> CreateClassHookDelegateAsync(StaticHookMethod<ClassHookContext> hook)
-    {
-        // Process hook registration event receivers
-        await ProcessHookRegistrationAsync(hook);
-
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private static Func<AssemblyHookContext, CancellationToken, Task> CreateAssemblyHookDelegate(StaticHookMethod<AssemblyHookContext> hook)
-    {
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private async Task<Func<AssemblyHookContext, CancellationToken, Task>> CreateAssemblyHookDelegateAsync(StaticHookMethod<AssemblyHookContext> hook)
-    {
-        // Process hook registration event receivers
-        await ProcessHookRegistrationAsync(hook);
-
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private static Func<TestSessionContext, CancellationToken, Task> CreateTestSessionHookDelegate(StaticHookMethod<TestSessionContext> hook)
-    {
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private async Task<Func<TestSessionContext, CancellationToken, Task>> CreateTestSessionHookDelegateAsync(StaticHookMethod<TestSessionContext> hook)
-    {
-        // Process hook registration event receivers
-        await ProcessHookRegistrationAsync(hook);
-
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private static Func<BeforeTestDiscoveryContext, CancellationToken, Task> CreateBeforeTestDiscoveryHookDelegate(StaticHookMethod<BeforeTestDiscoveryContext> hook)
-    {
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private async Task<Func<BeforeTestDiscoveryContext, CancellationToken, Task>> CreateBeforeTestDiscoveryHookDelegateAsync(StaticHookMethod<BeforeTestDiscoveryContext> hook)
-    {
-        // Process hook registration event receivers
-        await ProcessHookRegistrationAsync(hook);
-
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private static Func<TestDiscoveryContext, CancellationToken, Task> CreateTestDiscoveryHookDelegate(StaticHookMethod<TestDiscoveryContext> hook)
-    {
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
-    }
-
-    private async Task<Func<TestDiscoveryContext, CancellationToken, Task>> CreateTestDiscoveryHookDelegateAsync(StaticHookMethod<TestDiscoveryContext> hook)
-    {
-        // Process hook registration event receivers
-        await ProcessHookRegistrationAsync(hook);
-
-        return (context, cancellationToken) =>
-        {
-            return HookTimeoutHelper.CreateTimeoutHookAction(
-                hook,
-                context,
-                cancellationToken);
-        };
+        return new NamedHookDelegate<TContext>(hook.Name, (context, cancellationToken) =>
+            HookTimeoutHelper.CreateTimeoutHookAction(hook, context, cancellationToken));
     }
 }
diff --git a/TUnit.Engine/Services/HookExecutor.cs b/TUnit.Engine/Services/HookExecutor.cs
index 6a24647154..47911cbe38 100644
--- a/TUnit.Engine/Services/HookExecutor.cs
+++ b/TUnit.Engine/Services/HookExecutor.cs
@@ -59,7 +59,7 @@ public async ValueTask ExecuteBeforeTestSessionHooksAsync(CancellationToken canc
             try
             {
                 _contextProvider.TestSessionContext.RestoreExecutionContext();
-                await hook(_contextProvider.TestSessionContext, cancellationToken).ConfigureAwait(false);
+                await ExecuteHookWithActivityAsync(hook, _contextProvider.TestSessionContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -98,7 +98,7 @@ public async ValueTask<List<Exception>> ExecuteAfterTestSessionHooksAsync(Cancel
             try
             {
                 _contextProvider.TestSessionContext.RestoreExecutionContext();
-                await hook(_contextProvider.TestSessionContext, cancellationToken).ConfigureAwait(false);
+                await ExecuteHookWithActivityAsync(hook, _contextProvider.TestSessionContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -168,9 +168,8 @@ public async ValueTask ExecuteBeforeAssemblyHooksAsync(Assembly assembly, Cancel
         {
             try
             {
-                var context = _contextProvider.GetOrCreateAssemblyContext(assembly);
-                context.RestoreExecutionContext();
-                await hook(context, cancellationToken).ConfigureAwait(false);
+                assemblyContext.RestoreExecutionContext();
+                await ExecuteHookWithActivityAsync(hook, assemblyContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -191,6 +190,7 @@ public async ValueTask ExecuteBeforeAssemblyHooksAsync(Assembly assembly, Cancel
 
     public async ValueTask<List<Exception>> ExecuteAfterAssemblyHooksAsync(Assembly assembly, CancellationToken cancellationToken)
     {
+        var afterAssemblyContext = _contextProvider.GetOrCreateAssemblyContext(assembly);
         var hooks = await _hookCollectionService.CollectAfterAssemblyHooksAsync(assembly).ConfigureAwait(false);
 
         if (hooks.Count == 0)
@@ -208,9 +208,8 @@ public async ValueTask<List<Exception>> ExecuteAfterAssemblyHooksAsync(Assembly
         {
             try
             {
-                var context = _contextProvider.GetOrCreateAssemblyContext(assembly);
-                context.RestoreExecutionContext();
-                await hook(context, cancellationToken).ConfigureAwait(false);
+                afterAssemblyContext.RestoreExecutionContext();
+                await ExecuteHookWithActivityAsync(hook, afterAssemblyContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -283,9 +282,8 @@ public async ValueTask ExecuteBeforeClassHooksAsync(
         {
             try
             {
-                var context = _contextProvider.GetOrCreateClassContext(testClass);
-                context.RestoreExecutionContext();
-                await hook(context, cancellationToken).ConfigureAwait(false);
+                classContext.RestoreExecutionContext();
+                await ExecuteHookWithActivityAsync(hook, classContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -308,6 +306,7 @@ public async ValueTask<List<Exception>> ExecuteAfterClassHooksAsync(
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)]
         Type testClass, CancellationToken cancellationToken)
     {
+        var afterClassContext = _contextProvider.GetOrCreateClassContext(testClass);
         var hooks = await _hookCollectionService.CollectAfterClassHooksAsync(testClass).ConfigureAwait(false);
 
         if (hooks.Count == 0)
@@ -325,9 +324,8 @@ public async ValueTask<List<Exception>> ExecuteAfterClassHooksAsync(
         {
             try
             {
-                var context = _contextProvider.GetOrCreateClassContext(testClass);
-                context.RestoreExecutionContext();
-                await hook(context, cancellationToken).ConfigureAwait(false);
+                afterClassContext.RestoreExecutionContext();
+                await ExecuteHookWithActivityAsync(hook, afterClassContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -384,7 +382,7 @@ public async ValueTask ExecuteBeforeTestHooksAsync(AbstractExecutableTest test,
                 try
                 {
                     test.Context.RestoreExecutionContext();
-                    await hook(test.Context, cancellationToken).ConfigureAwait(false);
+                    await ExecuteHookWithActivityAsync(hook, test.Context, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -413,7 +411,7 @@ public async ValueTask ExecuteBeforeTestHooksAsync(AbstractExecutableTest test,
                 try
                 {
                     test.Context.RestoreExecutionContext();
-                    await hook(test.Context, cancellationToken).ConfigureAwait(false);
+                    await ExecuteHookWithActivityAsync(hook, test.Context, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -449,7 +447,7 @@ public async ValueTask<IReadOnlyList<Exception>> ExecuteAfterTestHooksAsync(Abst
                 try
                 {
                     test.Context.RestoreExecutionContext();
-                    await hook(test.Context, cancellationToken).ConfigureAwait(false);
+                    await ExecuteHookWithActivityAsync(hook, test.Context, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -469,7 +467,7 @@ public async ValueTask<IReadOnlyList<Exception>> ExecuteAfterTestHooksAsync(Abst
                 try
                 {
                     test.Context.RestoreExecutionContext();
-                    await hook(test.Context, cancellationToken).ConfigureAwait(false);
+                    await ExecuteHookWithActivityAsync(hook, test.Context, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -479,7 +477,7 @@ public async ValueTask<IReadOnlyList<Exception>> ExecuteAfterTestHooksAsync(Abst
             }
         }
 
-        return exceptions == null ? Array.Empty<Exception>() : exceptions;
+        return exceptions ?? [];
     }
 
     public async ValueTask ExecuteBeforeTestDiscoveryHooksAsync(CancellationToken cancellationToken)
@@ -496,7 +494,7 @@ public async ValueTask ExecuteBeforeTestDiscoveryHooksAsync(CancellationToken ca
             try
             {
                 _contextProvider.BeforeTestDiscoveryContext.RestoreExecutionContext();
-                await hook(_contextProvider.BeforeTestDiscoveryContext, cancellationToken).ConfigureAwait(false);
+                await ExecuteHookWithActivityAsync(hook, _contextProvider.BeforeTestDiscoveryContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -519,7 +517,7 @@ public async ValueTask ExecuteAfterTestDiscoveryHooksAsync(CancellationToken can
             try
             {
                 _contextProvider.TestDiscoveryContext.RestoreExecutionContext();
-                await hook(_contextProvider.TestDiscoveryContext, cancellationToken).ConfigureAwait(false);
+                await ExecuteHookWithActivityAsync(hook, _contextProvider.TestDiscoveryContext, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -527,4 +525,40 @@ public async ValueTask ExecuteAfterTestDiscoveryHooksAsync(CancellationToken can
             }
         }
     }
+
+#if NET
+    private static async ValueTask ExecuteHookWithActivityAsync<TContext>(NamedHookDelegate<TContext> hook, TContext context, CancellationToken cancellationToken)
+        where TContext : Context
+    {
+        System.Diagnostics.Activity? hookActivity = null;
+
+        if (TUnitActivitySource.Source.HasListeners())
+        {
+            hookActivity = TUnitActivitySource.StartActivity(
+                hook.ActivityName,
+                System.Diagnostics.ActivityKind.Internal,
+                context.Activity?.Context ?? default);
+        }
+
+        try
+        {
+            await hook.Invoke(context, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            TUnitActivitySource.RecordException(hookActivity, ex);
+            throw;
+        }
+        finally
+        {
+            TUnitActivitySource.StopActivity(hookActivity);
+        }
+    }
+#else
+    private static async ValueTask ExecuteHookWithActivityAsync<TContext>(NamedHookDelegate<TContext> hook, TContext context, CancellationToken cancellationToken)
+        where TContext : Context
+    {
+        await hook.Invoke(context, cancellationToken).ConfigureAwait(false);
+    }
+#endif
 }
diff --git a/TUnit.Engine/TestExecutor.cs b/TUnit.Engine/TestExecutor.cs
index ddd7139fd6..125ad8e676 100644
--- a/TUnit.Engine/TestExecutor.cs
+++ b/TUnit.Engine/TestExecutor.cs
@@ -147,36 +147,7 @@ await _eventReceiverOrchestrator.InvokeFirstTestInClassEventReceiversAsync(
 
             executableTest.Context.RestoreExecutionContext();
 
-#if NET
-            Activity? beforeTestActivity = null;
-            if (TUnitActivitySource.Source.HasListeners())
-            {
-                beforeTestActivity = TUnitActivitySource.StartActivity(
-                    "hook: BeforeTest",
-                    ActivityKind.Internal,
-                    executableTest.Context.Activity?.Context ?? default);
-            }
-#endif
-            try
-            {
-                await _hookExecutor.ExecuteBeforeTestHooksAsync(executableTest, cancellationToken).ConfigureAwait(false);
-            }
-            catch
-#if NET
-            (Exception ex)
-#endif
-            {
-#if NET
-                TUnitActivitySource.RecordException(beforeTestActivity, ex);
-#endif
-                throw;
-            }
-            finally
-            {
-#if NET
-                TUnitActivitySource.StopActivity(beforeTestActivity);
-#endif
-            }
+            await _hookExecutor.ExecuteBeforeTestHooksAsync(executableTest, cancellationToken).ConfigureAwait(false);
 
             // Late stage test start receivers run after instance-level hooks (default behavior)
             await _eventReceiverOrchestrator.InvokeTestStartEventReceiversAsync(executableTest.Context, cancellationToken, EventReceiverStage.Late).ConfigureAwait(false);
@@ -245,31 +216,7 @@ await TimeoutHelper.ExecuteWithTimeoutAsync(
             // Early stage test end receivers run before instance-level hooks
             var earlyStageExceptions = await _eventReceiverOrchestrator.InvokeTestEndEventReceiversAsync(executableTest.Context, CancellationToken.None, EventReceiverStage.Early).ConfigureAwait(false);
 
-            IReadOnlyList<Exception> hookExceptions = [];
-#if NET
-            Activity? afterTestActivity = null;
-            if (TUnitActivitySource.Source.HasListeners())
-            {
-                afterTestActivity = TUnitActivitySource.StartActivity(
-                    "hook: AfterTest",
-                    ActivityKind.Internal,
-                    executableTest.Context.Activity?.Context ?? default);
-            }
-#endif
-            try
-            {
-                hookExceptions = await _hookExecutor.ExecuteAfterTestHooksAsync(executableTest, CancellationToken.None).ConfigureAwait(false);
-            }
-            finally
-            {
-#if NET
-                if (hookExceptions.Count > 0 && afterTestActivity is not null)
-                {
-                    afterTestActivity.SetStatus(ActivityStatusCode.Error);
-                }
-                TUnitActivitySource.StopActivity(afterTestActivity);
-#endif
-            }
+            var hookExceptions = await _hookExecutor.ExecuteAfterTestHooksAsync(executableTest, CancellationToken.None).ConfigureAwait(false);
 
             // Late stage test end receivers run after instance-level hooks (default behavior)
             var lateStageExceptions = await _eventReceiverOrchestrator.InvokeTestEndEventReceiversAsync(executableTest.Context, CancellationToken.None, EventReceiverStage.Late).ConfigureAwait(false);