public static void AfterAction(
object diagnosticSource,
object actionDescriptor,
object httpContext,
object routeData,
int opCode)
{
AspNetCoreMvc2Integration integration = null;
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled
return;
}
try
{
if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems))
{
integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration;
}
}
catch (Exception ex)
{
Log.ErrorExceptionForFilter($"Error accessing {nameof(AspNetCoreMvc2Integration)}.", ex);
}
try
{
if (_afterAction == null)
{
var type = actionDescriptor.GetType().Assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions");
_afterAction = Emit.DynamicMethodBuilder <Action <object, object, object, object> > .CreateMethodCallDelegate(
type,
"AfterAction");
}
}
catch
{
// TODO: log this as an instrumentation error, we cannot call instrumented method,
// profiled app will continue working without DiagnosticSource
}
try
{
// call the original method, catching and rethrowing any unhandled exceptions
_afterAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData);
}
catch (Exception ex)
{
integration?.SetException(ex);
throw;
}
finally
{
integration?.Dispose();
}
}
/// <summary>
/// Wrapper method used to instrument Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions.AfterAction()
/// </summary>
/// <param name="diagnosticSource">The DiagnosticSource that this extension method was called on.</param>
/// <param name="actionDescriptor">An ActionDescriptor with information about the current action.</param>
/// <param name="httpContext">The HttpContext for the current request.</param>
/// <param name="routeData">A RouteData with information about the current route.</param>
public static void AfterAction(
object diagnosticSource,
object actionDescriptor,
dynamic httpContext,
object routeData)
{
AspNetCoreMvc2Integration integration = null;
try
{
IDictionary <object, object> contextItems = httpContext?.Items;
integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration;
}
catch
{
// TODO: log this as an instrumentation error, but continue calling instrumented method
}
try
{
if (_afterAction == null)
{
Type type = actionDescriptor.GetType().Assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions");
_afterAction = DynamicMethodBuilder.CreateMethodCallDelegate <Action <object, object, object, object> >(
type,
"AfterAction",
isStatic: true);
}
}
catch
{
// TODO: log this as an instrumentation error, we cannot call instrumented method,
// profiled app will continue working without DiagnosticSource
}
try
{
// call the original method, catching and rethrowing any unhandled exceptions
_afterAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData);
}
catch (Exception ex)
{
integration?.SetException(ex);
throw;
}
finally
{
integration?.Dispose();
}
}
public static void AfterAction(
object diagnosticSource,
object actionDescriptor,
object httpContext,
object routeData,
int opCode,
int mdToken,
long moduleVersionPtr)
{
AspNetCoreMvc2Integration integration = null;
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled
return;
}
try
{
if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems))
{
integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration;
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error accessing {nameof(AspNetCoreMvc2Integration)}.");
}
Action <object, object, object, object> instrumentedMethod = null;
try
{
instrumentedMethod =
MethodBuilder <Action <object, object, object, object> >
.Start(moduleVersionPtr, mdToken, opCode, nameof(AfterAction))
.WithConcreteType(DiagnosticSourceType)
.WithParameters(diagnosticSource, actionDescriptor, httpContext, routeData)
.WithNamespaceAndNameFilters(
ClrNames.Void,
ClrNames.Ignore,
"Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor",
"Microsoft.AspNetCore.Http.HttpContext",
"Microsoft.AspNetCore.Routing.RouteData")
.Build();
}
catch (Exception ex)
{
// profiled app will continue working as expected without this method
Log.ErrorRetrievingMethod(
exception: ex,
moduleVersionPointer: moduleVersionPtr,
mdToken: mdToken,
opCode: opCode,
instrumentedType: DiagnosticSourceTypeName,
methodName: nameof(AfterAction),
instanceType: null,
relevantArguments: new[] { diagnosticSource?.GetType().AssemblyQualifiedName });
}
try
{
// call the original method, catching and rethrowing any unhandled exceptions
instrumentedMethod?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData);
}
catch (Exception ex)
{
integration?.SetException(ex);
throw;
}
finally
{
integration?.Dispose();
}
}
public static void AfterAction(
object diagnosticSource,
object actionDescriptor,
object httpContext,
object routeData,
int opCode,
int mdToken)
{
AspNetCoreMvc2Integration integration = null;
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled
return;
}
try
{
if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems))
{
integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration;
}
}
catch (Exception ex)
{
Log.ErrorExceptionForFilter($"Error accessing {nameof(AspNetCoreMvc2Integration)}.", ex);
}
Action <object, object, object, object> instrumentedMethod = null;
string methodDef = $"{DiagnosticSource}.{nameof(AfterAction)}(...)";
try
{
instrumentedMethod =
MethodBuilder <Action <object, object, object, object> >
.Start(Assembly.GetCallingAssembly(), mdToken, opCode, nameof(AfterAction))
.WithConcreteTypeName(DiagnosticSource)
.WithParameters(diagnosticSource, actionDescriptor, httpContext, routeData)
.Build();
}
catch (Exception ex)
{
// profiled app will continue working as expected without this method
Log.ErrorException($"Error resolving {methodDef}", ex);
}
try
{
// call the original method, catching and rethrowing any unhandled exceptions
instrumentedMethod?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData);
}
catch (Exception ex)
{
integration?.SetException(ex);
throw;
}
finally
{
integration?.Dispose();
}
}
