diff --git a/src/Microsoft.AspNet.Mvc.Core/Controllers/FilterActionInvoker.cs b/src/Microsoft.AspNet.Mvc.Core/Controllers/FilterActionInvoker.cs
index 8dacc14059..42eee82e73 100644
--- a/src/Microsoft.AspNet.Mvc.Core/Controllers/FilterActionInvoker.cs
+++ b/src/Microsoft.AspNet.Mvc.Core/Controllers/FilterActionInvoker.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.AspNet.Mvc.Abstractions;
 using Microsoft.AspNet.Mvc.Core;
+using Microsoft.AspNet.Mvc.Diagnostics;
 using Microsoft.AspNet.Mvc.Filters;
 using Microsoft.AspNet.Mvc.Formatters;
 using Microsoft.AspNet.Mvc.Infrastructure;
@@ -288,31 +289,17 @@ private async Task InvokeAuthorizationFilterAsync()
             var current = _cursor.GetNextFilter<IAuthorizationFilter, IAsyncAuthorizationFilter>();
             if (current.FilterAsync != null)
             {
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnAuthorization"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.BeforeOnAuthorization",
-                        new
-                        {
-                            actionDescriptor = _authorizationContext.ActionDescriptor,
-                            authorizationContext = _authorizationContext,
-                            filter = current.FilterAsync
-                        });
-                }
+                _diagnosticSource.BeforeOnAuthorizationAsync(
+                    _authorizationContext.ActionDescriptor,
+                    _authorizationContext,
+                    current.FilterAsync);
 
                 await current.FilterAsync.OnAuthorizationAsync(_authorizationContext);
 
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnAuthorization"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.AfterOnAuthorization",
-                        new
-                        {
-                            actionDescriptor = _authorizationContext.ActionDescriptor,
-                            authorizationContext = _authorizationContext,
-                            filter = current.FilterAsync
-                        });
-                }
+                _diagnosticSource.AfterOnAuthorizationAsync(
+                    _authorizationContext.ActionDescriptor,
+                    _authorizationContext,
+                    current.FilterAsync);
 
                 if (_authorizationContext.Result == null)
                 {
@@ -326,31 +313,17 @@ private async Task InvokeAuthorizationFilterAsync()
             }
             else if (current.Filter != null)
             {
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnAuthorization"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.BeforeOnAuthorization",
-                        new
-                        {
-                            actionDescriptor = _authorizationContext.ActionDescriptor,
-                            authorizationContext = _authorizationContext,
-                            filter = current.Filter
-                        });
-                }
+                _diagnosticSource.BeforeOnAuthorization(
+                    _authorizationContext.ActionDescriptor,
+                    _authorizationContext,
+                    current.Filter);
 
                 current.Filter.OnAuthorization(_authorizationContext);
 
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnAuthorization"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.AfterOnAuthorization",
-                        new
-                        {
-                            actionDescriptor = _authorizationContext.ActionDescriptor,
-                            authorizationContext = _authorizationContext,
-                            filter = current.Filter
-                        });
-                }
+                _diagnosticSource.AfterOnAuthorization(
+                    _authorizationContext.ActionDescriptor,
+                    _authorizationContext,
+                    current.Filter);
 
                 if (_authorizationContext.Result == null)
                 {
@@ -406,33 +379,19 @@ private async Task<ResourceExecutedContext> InvokeResourceFilterAsync()
             {
                 if (item.FilterAsync != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnResourceExecution",
-                            new
-                            {
-                                actionDescriptor = _resourceExecutingContext.ActionDescriptor,
-                                resourceExecutingContext = _resourceExecutingContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.BeforeOnResourceExecution(
+                        _resourceExecutingContext.ActionDescriptor,
+                        _resourceExecutingContext,
+                        item.FilterAsync);
 
                     await item.FilterAsync.OnResourceExecutionAsync(
                         _resourceExecutingContext,
                         InvokeResourceFilterAsync);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnResourceExecution",
-                            new
-                            {
-                                actionDescriptor = _resourceExecutingContext.ActionDescriptor,
-                                resourceExecutedContext = _resourceExecutedContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.AfterOnResourceExecution(
+                        _resourceExecutingContext.ActionDescriptor,
+                        _resourceExecutedContext,
+                        item.FilterAsync);
 
                     if (_resourceExecutedContext == null)
                     {
@@ -455,31 +414,17 @@ await item.FilterAsync.OnResourceExecutionAsync(
                 }
                 else if (item.Filter != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnResourceExecuting",
-                            new
-                            {
-                                actionDescriptor = _resourceExecutingContext.ActionDescriptor,
-                                resourceExecutingContext = _resourceExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.BeforeOnResourceExecuting(
+                        _resourceExecutingContext.ActionDescriptor,
+                        _resourceExecutingContext,
+                        item.Filter);
 
                     item.Filter.OnResourceExecuting(_resourceExecutingContext);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnResourceExecuting",
-                            new
-                            {
-                                actionDescriptor = _resourceExecutingContext.ActionDescriptor,
-                                resourceExecutingContext = _resourceExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.AfterOnResourceExecuting(
+                        _resourceExecutingContext.ActionDescriptor,
+                        _resourceExecutingContext,
+                        item.Filter);
 
                     if (_resourceExecutingContext.Result != null)
                     {
@@ -496,31 +441,17 @@ await item.FilterAsync.OnResourceExecutionAsync(
                     }
                     else
                     {
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.BeforeOnResourceExecuted",
-                                new
-                                {
-                                    actionDescriptor = _resourceExecutedContext.ActionDescriptor,
-                                    resourceExecutedContext = _resourceExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.BeforeOnResourceExecuted(
+                            _resourceExecutingContext.ActionDescriptor,
+                            _resourceExecutedContext,
+                            item.Filter);
 
                         item.Filter.OnResourceExecuted(await InvokeResourceFilterAsync());
 
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.AfterOnResourceExecuted",
-                                new
-                                {
-                                    actionDescriptor = _resourceExecutedContext.ActionDescriptor,
-                                    resourceExecutedContext = _resourceExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.AfterOnResourceExecuted(
+                            _resourceExecutingContext.ActionDescriptor,
+                            _resourceExecutedContext,
+                            item.Filter);
                     }
                 }
                 else
@@ -620,33 +551,19 @@ private async Task InvokeExceptionFilterAsync()
                 Debug.Assert(_exceptionContext != null);
                 if (_exceptionContext.Exception != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnException"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnException",
-                            new
-                            {
-                                actionDescriptor = _exceptionContext.ActionDescriptor,
-                                exceptionContext = _exceptionContext,
-                                filter = current.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.BeforeOnExceptionAsync(
+                        _exceptionContext.ActionDescriptor,
+                        _exceptionContext,
+                        current.FilterAsync);
 
                     // Exception filters only run when there's an exception - unsetting it will short-circuit
                     // other exception filters.
                     await current.FilterAsync.OnExceptionAsync(_exceptionContext);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnException"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnException",
-                            new
-                            {
-                                actionDescriptor = _exceptionContext.ActionDescriptor,
-                                exceptionContext = _exceptionContext,
-                                filter = current.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.AfterOnExceptionAsync(
+                        _exceptionContext.ActionDescriptor,
+                        _exceptionContext,
+                        current.FilterAsync);
 
                     if (_exceptionContext.Exception == null)
                     {
@@ -665,33 +582,19 @@ private async Task InvokeExceptionFilterAsync()
                 Debug.Assert(_exceptionContext != null);
                 if (_exceptionContext.Exception != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnException"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnException",
-                            new
-                            {
-                                actionDescriptor = _exceptionContext.ActionDescriptor,
-                                exceptionContext = _exceptionContext,
-                                filter = current.Filter
-                            });
-                    }
+                    _diagnosticSource.BeforeOnException(
+                        _exceptionContext.ActionDescriptor,
+                        _exceptionContext,
+                        current.Filter);
 
                     // Exception filters only run when there's an exception - unsetting it will short-circuit
                     // other exception filters.
                     current.Filter.OnException(_exceptionContext);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnException"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnException",
-                            new
-                            {
-                                actionDescriptor = _exceptionContext.ActionDescriptor,
-                                exceptionContext = _exceptionContext,
-                                filter = current.Filter
-                            });
-                    }
+                    _diagnosticSource.AfterOnException(
+                        _exceptionContext.ActionDescriptor,
+                        _exceptionContext,
+                        current.Filter);
 
                     if (_exceptionContext.Exception == null)
                     {
@@ -770,31 +673,17 @@ private async Task<ActionExecutedContext> InvokeActionFilterAsync()
             {
                 if (item.FilterAsync != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnActionExecution",
-                            new
-                            {
-                                actionDescriptor = _actionExecutingContext.ActionDescriptor,
-                                actionExecutingContext = _actionExecutingContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.BeforeOnActionExecution(
+                        _actionExecutingContext.ActionDescriptor,
+                        _actionExecutingContext,
+                        item.FilterAsync);
 
                     await item.FilterAsync.OnActionExecutionAsync(_actionExecutingContext, InvokeActionFilterAsync);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnActionExecution",
-                            new
-                            {
-                                actionDescriptor = _actionExecutingContext.ActionDescriptor,
-                                actionExecutedContext = _actionExecutedContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.AfterOnActionExecution(
+                        _actionExecutingContext.ActionDescriptor,
+                        _actionExecutedContext,
+                        item.FilterAsync);
 
                     if (_actionExecutedContext == null)
                     {
@@ -814,31 +703,17 @@ private async Task<ActionExecutedContext> InvokeActionFilterAsync()
                 }
                 else if (item.Filter != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnActionExecuting",
-                            new
-                            {
-                                actionDescriptor = _actionExecutingContext.ActionDescriptor,
-                                actionExecutingContext = _actionExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.BeforeOnActionExecuting(
+                        _actionExecutingContext.ActionDescriptor,
+                        _actionExecutingContext,
+                        item.Filter);
 
                     item.Filter.OnActionExecuting(_actionExecutingContext);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnActionExecuting",
-                            new
-                            {
-                                actionDescriptor = _actionExecutingContext.ActionDescriptor,
-                                actionExecutingContext = _actionExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.AfterOnActionExecuting(
+                        _actionExecutingContext.ActionDescriptor,
+                        _actionExecutingContext,
+                        item.Filter);
 
                     if (_actionExecutingContext.Result != null)
                     {
@@ -857,31 +732,17 @@ private async Task<ActionExecutedContext> InvokeActionFilterAsync()
                     }
                     else
                     {
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.BeforeOnActionExecuted",
-                                new
-                                {
-                                    actionDescriptor = _actionExecutedContext.ActionDescriptor,
-                                    actionExecutedContext = _actionExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.BeforeOnActionExecuted(
+                            _actionExecutingContext.ActionDescriptor,
+                            _actionExecutedContext,
+                            item.Filter);
 
                         item.Filter.OnActionExecuted(await InvokeActionFilterAsync());
 
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.AfterOnActionExecuted",
-                                new
-                                {
-                                    actionDescriptor = _actionExecutedContext.ActionDescriptor,
-                                    actionExecutedContext = _actionExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.BeforeOnActionExecuted(
+                            _actionExecutingContext.ActionDescriptor,
+                            _actionExecutedContext,
+                            item.Filter);
                     }
                 }
                 else
@@ -891,34 +752,20 @@ private async Task<ActionExecutedContext> InvokeActionFilterAsync()
 
                     try
                     {
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeActionMethod"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.BeforeActionMethod",
-                                new
-                                {
-                                    actionContext = ActionContext,
-                                    arguments = _actionExecutingContext.ActionArguments,
-                                    controller = _actionExecutingContext.Controller
-                                });
-                        }
+                        _diagnosticSource.BeforeActionMethod(
+                            ActionContext,
+                            _actionExecutingContext.ActionArguments,
+                            _actionExecutingContext.Controller);
 
                         result = await InvokeActionAsync(_actionExecutingContext);
                     }
                     finally
                     {
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterActionMethod"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.AfterActionMethod",
-                                new
-                                {
-                                    actionContext = ActionContext,
-                                    arguments = _actionExecutingContext.ActionArguments,
-                                    controller = _actionExecutingContext.Controller,
-                                    result = result
-                                });
-                        }
+                        _diagnosticSource.AfterActionMethod(
+                            ActionContext,
+                            _actionExecutingContext.ActionArguments,
+                            _actionExecutingContext.Controller,
+                            result);
                     }
 
                     _actionExecutedContext = new ActionExecutedContext(
@@ -987,31 +834,17 @@ private async Task<ResultExecutedContext> InvokeResultFilterAsync()
                 var item = _cursor.GetNextFilter<IResultFilter, IAsyncResultFilter>();
                 if (item.FilterAsync != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnResultExecution",
-                            new
-                            {
-                                actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                resultExecutingContext = _resultExecutingContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.BeforeOnResultExecution(
+                        _resultExecutingContext.ActionDescriptor,
+                        _resultExecutingContext,
+                        item.FilterAsync);
 
                     await item.FilterAsync.OnResultExecutionAsync(_resultExecutingContext, InvokeResultFilterAsync);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecution"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnResultExecution",
-                            new
-                            {
-                                actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                resultExecutedContext = _resultExecutedContext,
-                                filter = item.FilterAsync
-                            });
-                    }
+                    _diagnosticSource.AfterOnResultExecution(
+                        _resultExecutingContext.ActionDescriptor,
+                        _resultExecutedContext,
+                        item.FilterAsync);
 
                     if (_resultExecutedContext == null || _resultExecutingContext.Cancel == true)
                     {
@@ -1030,31 +863,17 @@ private async Task<ResultExecutedContext> InvokeResultFilterAsync()
                 }
                 else if (item.Filter != null)
                 {
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.BeforeOnResultExecuting",
-                            new
-                            {
-                                actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                resultExecutingContext = _resultExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.BeforeOnResultExecuting(
+                        _resultExecutingContext.ActionDescriptor,
+                        _resultExecutingContext,
+                        item.Filter);
 
                     item.Filter.OnResultExecuting(_resultExecutingContext);
 
-                    if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecuting"))
-                    {
-                        _diagnosticSource.Write(
-                            "Microsoft.AspNet.Mvc.AfterOnResultExecuting",
-                            new
-                            {
-                                actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                resultExecutingContext = _resultExecutingContext,
-                                filter = item.Filter
-                            });
-                    }
+                    _diagnosticSource.AfterOnResultExecuting(
+                        _resultExecutingContext.ActionDescriptor,
+                        _resultExecutingContext,
+                        item.Filter);
 
                     if (_resultExecutingContext.Cancel == true)
                     {
@@ -1072,31 +891,17 @@ private async Task<ResultExecutedContext> InvokeResultFilterAsync()
                     }
                     else
                     {
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.BeforeOnResultExecuted",
-                                new
-                                {
-                                    actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                    resultExecutedContext = _resultExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.BeforeOnResultExecuted(
+                            _resultExecutingContext.ActionDescriptor,
+                            _resultExecutedContext,
+                            item.Filter);
 
                         item.Filter.OnResultExecuted(await InvokeResultFilterAsync());
 
-                        if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecuted"))
-                        {
-                            _diagnosticSource.Write(
-                                "Microsoft.AspNet.Mvc.AfterOnResultExecuted",
-                                new
-                                {
-                                    actionDescriptor = _resultExecutingContext.ActionDescriptor,
-                                    resultExecutedContext = _resultExecutedContext,
-                                    filter = item.Filter
-                                });
-                        }
+                        _diagnosticSource.AfterOnResultExecuted(
+                            _resultExecutingContext.ActionDescriptor,
+                            _resultExecutedContext,
+                            item.Filter);
                     }
                 }
                 else
@@ -1136,12 +941,7 @@ private async Task<ResultExecutedContext> InvokeResultFilterAsync()
 
         private async Task InvokeResultAsync(IActionResult result)
         {
-            if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeActionResult"))
-            {
-                _diagnosticSource.Write(
-                    "Microsoft.AspNet.Mvc.BeforeActionResult",
-                    new { actionContext = ActionContext, result = result });
-            }
+            _diagnosticSource.BeforeActionResult(ActionContext, result);
 
             try
             {
@@ -1149,12 +949,7 @@ private async Task InvokeResultAsync(IActionResult result)
             }
             finally
             {
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterActionResult"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.AfterActionResult",
-                        new { actionContext = ActionContext, result = result });
-                }
+                _diagnosticSource.AfterActionResult(ActionContext, result);
             }
         }
 
diff --git a/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/FilterActionInvokerDiagnosticSourceExtensions.cs b/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/FilterActionInvokerDiagnosticSourceExtensions.cs
new file mode 100644
index 0000000000..c9e42ca7e4
--- /dev/null
+++ b/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/FilterActionInvokerDiagnosticSourceExtensions.cs
@@ -0,0 +1,573 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.AspNet.Mvc.Abstractions;
+using Microsoft.AspNet.Mvc.Filters;
+
+namespace Microsoft.AspNet.Mvc.Diagnostics
+{
+    public static class FilterActionInvokerDiagnosticSourceExtensions
+    {
+        public static void BeforeOnAuthorizationAsync(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            AuthorizationContext authorizationContext,
+            IAsyncAuthorizationFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnAuthorization"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnAuthorization",
+                    new
+                    {
+                        actionDescriptor = authorizationContext.ActionDescriptor,
+                        authorizationContext = authorizationContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnAuthorizationAsync(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            AuthorizationContext authorizationContext,
+            IAsyncAuthorizationFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnAuthorization"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnAuthorization",
+                    new
+                    {
+                        actionDescriptor = authorizationContext.ActionDescriptor,
+                        authorizationContext = authorizationContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnAuthorization(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            AuthorizationContext authorizationContext,
+            IAuthorizationFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnAuthorization"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnAuthorization",
+                    new
+                    {
+                        actionDescriptor = authorizationContext.ActionDescriptor,
+                        authorizationContext = authorizationContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnAuthorization(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            AuthorizationContext authorizationContext,
+            IAuthorizationFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnAuthorization"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnAuthorization",
+                    new
+                    {
+                        actionDescriptor = authorizationContext.ActionDescriptor,
+                        authorizationContext = authorizationContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnResourceExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutingContext resourceExecutingContext,
+            IAsyncResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResourceExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutingContext = resourceExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResourceExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutedContext resourceExecutedContext,
+            IAsyncResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResourceExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutedContext = resourceExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnResourceExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutingContext resourceExecutingContext,
+            IResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResourceExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutingContext = resourceExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResourceExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutingContext resourceExecutingContext,
+            IResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResourceExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutingContext = resourceExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnResourceExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutedContext resourceExecutedContext,
+            IResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResourceExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResourceExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutedContext = resourceExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResourceExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResourceExecutedContext resourceExecutedContext,
+            IResourceFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResourceExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResourceExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resourceExecutedContext = resourceExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnExceptionAsync(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ExceptionContext exceptionContext,
+            IAsyncExceptionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnException"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnException",
+                    new
+                    {
+                        actionDescriptor = exceptionContext.ActionDescriptor,
+                        exceptionContext = exceptionContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnExceptionAsync(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ExceptionContext exceptionContext,
+            IAsyncExceptionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnException"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnException",
+                    new
+                    {
+                        actionDescriptor = exceptionContext.ActionDescriptor,
+                        exceptionContext = exceptionContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnException(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ExceptionContext exceptionContext,
+            IExceptionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnException"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnException",
+                    new
+                    {
+                        actionDescriptor = exceptionContext.ActionDescriptor,
+                        exceptionContext = exceptionContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnException(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ExceptionContext exceptionContext,
+            IExceptionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnException"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnException",
+                    new
+                    {
+                        actionDescriptor = exceptionContext.ActionDescriptor,
+                        exceptionContext = exceptionContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnActionExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutingContext actionExecutingContext,
+            IAsyncActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnActionExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutingContext = actionExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnActionExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutedContext actionExecutedContext,
+            IAsyncActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnActionExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutedContext = actionExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnActionExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutingContext actionExecutingContext,
+            IActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnActionExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutingContext = actionExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnActionExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutingContext actionExecutingContext,
+            IActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnActionExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutingContext = actionExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnActionExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutedContext actionExecutedContext,
+            IActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnActionExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnActionExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutedContext = actionExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnActionExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ActionExecutedContext actionExecutedContext,
+            IActionFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnActionExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnActionExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        actionExecutedContext = actionExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeActionMethod(
+            this DiagnosticSource diagnosticSource,
+            ActionContext actionContext,
+            IDictionary<string, object> actionArguments,
+            object controller)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeActionMethod"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeActionMethod",
+                    new
+                    {
+                        actionContext = actionContext,
+                        arguments = actionArguments,
+                        controller = controller
+                    });
+            }
+        }
+
+        public static void AfterActionMethod(
+            this DiagnosticSource diagnosticSource,
+            ActionContext actionContext,
+            IDictionary<string, object> actionArguments,
+            object controller,
+            IActionResult result)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterActionMethod"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterActionMethod",
+                    new
+                    {
+                        actionContext = actionContext,
+                        arguments = actionArguments,
+                        controller = controller,
+                        result = result
+                    });
+            }
+        }
+
+        public static void BeforeOnResultExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutingContext resultExecutingContext,
+            IAsyncResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResultExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutingContext = resultExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResultExecution(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutedContext resultExecutedContext,
+            IAsyncResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecution"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResultExecution",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutedContext = resultExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnResultExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutingContext resultExecutingContext,
+            IResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResultExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutingContext = resultExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResultExecuting(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutingContext resultExecutingContext,
+            IResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecuting"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResultExecuting",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutingContext = resultExecutingContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeOnResultExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutedContext resultExecutedContext,
+            IResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeOnResultExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeOnResultExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutedContext = resultExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void AfterOnResultExecuted(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            ResultExecutedContext resultExecutedContext,
+            IResultFilter filter)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterOnResultExecuted"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterOnResultExecuted",
+                    new
+                    {
+                        actionDescriptor = actionDescriptor,
+                        resultExecutedContext = resultExecutedContext,
+                        filter = filter
+                    });
+            }
+        }
+
+        public static void BeforeActionResult(
+            this DiagnosticSource diagnosticSource,
+            ActionContext actionContext,
+            IActionResult result)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeActionResult"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeActionResult",
+                    new { actionContext = actionContext, result = result });
+            }
+        }
+
+        public static void AfterActionResult(
+            this DiagnosticSource diagnosticSource,
+            ActionContext actionContext,
+            IActionResult result)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterActionResult"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterActionResult",
+                    new { actionContext = actionContext, result = result });
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/MvcRouteHandlerDiagnosticSourceExtensions.cs b/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/MvcRouteHandlerDiagnosticSourceExtensions.cs
new file mode 100644
index 0000000000..0528a61740
--- /dev/null
+++ b/src/Microsoft.AspNet.Mvc.Core/DiagnosticSource/MvcRouteHandlerDiagnosticSourceExtensions.cs
@@ -0,0 +1,41 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Diagnostics;
+using Microsoft.AspNet.Http;
+using Microsoft.AspNet.Mvc.Abstractions;
+using Microsoft.AspNet.Routing;
+
+namespace Microsoft.AspNet.Mvc.Diagnostics
+{
+    public static class MvcRouteHandlerDiagnosticSourceExtensions
+    {
+        public static void BeforeAction(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            HttpContext httpContext,
+            RouteData routeData)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeAction"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.BeforeAction",
+                    new { actionDescriptor, httpContext = httpContext, routeData = routeData });
+            }
+        }
+
+        public static void AfterAction(
+            this DiagnosticSource diagnosticSource,
+            ActionDescriptor actionDescriptor,
+            HttpContext httpContext,
+            RouteData routeData)
+        {
+            if (diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterAction"))
+            {
+                diagnosticSource.Write(
+                    "Microsoft.AspNet.Mvc.AfterAction",
+                    new { actionDescriptor, httpContext = httpContext, routeData = routeData });
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.AspNet.Mvc.Core/Infrastructure/MvcRouteHandler.cs b/src/Microsoft.AspNet.Mvc.Core/Infrastructure/MvcRouteHandler.cs
index ef4dd0dd8e..f668bdcb82 100644
--- a/src/Microsoft.AspNet.Mvc.Core/Infrastructure/MvcRouteHandler.cs
+++ b/src/Microsoft.AspNet.Mvc.Core/Infrastructure/MvcRouteHandler.cs
@@ -7,6 +7,7 @@
 using Microsoft.AspNet.Http;
 using Microsoft.AspNet.Mvc.Abstractions;
 using Microsoft.AspNet.Mvc.Core;
+using Microsoft.AspNet.Mvc.Diagnostics;
 using Microsoft.AspNet.Mvc.Internal;
 using Microsoft.AspNet.Mvc.Routing;
 using Microsoft.AspNet.Routing;
@@ -84,12 +85,7 @@ public async Task RouteAsync(RouteContext context)
             {
                 context.RouteData = newRouteData;
 
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.BeforeAction"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.BeforeAction",
-                        new { actionDescriptor, httpContext = context.HttpContext, routeData = context.RouteData });
-                }
+                _diagnosticSource.BeforeAction(actionDescriptor, context.HttpContext, context.RouteData);
 
                 using (_logger.BeginScope("ActionId: {ActionId}", actionDescriptor.Id))
                 {
@@ -101,12 +97,7 @@ public async Task RouteAsync(RouteContext context)
             }
             finally
             {
-                if (_diagnosticSource.IsEnabled("Microsoft.AspNet.Mvc.AfterAction"))
-                {
-                    _diagnosticSource.Write(
-                        "Microsoft.AspNet.Mvc.AfterAction",
-                        new { actionDescriptor, httpContext = context.HttpContext, routeData = context.RouteData });
-                }
+                _diagnosticSource.AfterAction(actionDescriptor, context.HttpContext, context.RouteData);
 
                 if (!context.IsHandled)
                 {