private Task OnActionExecutedAsyncCore(
HttpActionExecutedContext actionExecutedContext,
CancellationToken cancellationToken,
[CallerMemberName] string methodName = null
)
{
return(_traceWriter.TraceBeginEndAsync(
actionExecutedContext.Request,
TraceCategories.FiltersCategory,
TraceLevel.Info,
_innerFilter.GetType().Name,
methodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceActionFilterMessage,
FormattingUtilities.ActionDescriptorToString(
actionExecutedContext.ActionContext.ActionDescriptor
)
);
tr.Exception = actionExecutedContext.Exception;
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
},
execute: async() =>
{
await _innerFilter.OnActionExecutedAsync(
actionExecutedContext,
cancellationToken
);
},
endTrace: (tr) =>
{
tr.Exception = actionExecutedContext.Exception;
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: (tr) =>
{
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
}
));
}
public Task <CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request)
{
return(_traceWriter.TraceBeginEndAsync <CorsPolicy>(
request,
TraceCategories.CorsCategory,
TraceLevel.Info,
_innerPolicyProvider.GetType().Name,
MethodName,
beginTrace: (tr) =>
{
tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceCorsRequestContext, request.GetCorsRequestContext());
},
execute: () => _innerPolicyProvider.GetCorsPolicyAsync(request),
endTrace: (tr, policy) =>
{
if (policy != null)
{
tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceEndPolicyReturned, policy);
}
else
{
tr.Message = SRResources.TraceEndNoPolicyReturned;
}
},
errorTrace: null));
}
public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync(
actionContext.Request,
TraceCategories.ModelBindingCategory,
TraceLevel.Info,
_innerBinding.GetType().Name,
ExecuteBindingAsyncMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(SRResources.TraceBeginParameterBind,
_innerBinding.Descriptor.ParameterName);
},
execute: () => _innerBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken),
endTrace: (tr) =>
{
string parameterName = _innerBinding.Descriptor.ParameterName;
tr.Message = actionContext.ActionArguments.ContainsKey(parameterName)
? Error.Format(SRResources.TraceEndParameterBind, parameterName,
FormattingUtilities.ValueToString(actionContext.ActionArguments[parameterName], CultureInfo.CurrentCulture))
: Error.Format(SRResources.TraceEndParameterBindNoBind,
parameterName);
},
errorTrace: null));
}
Task <HttpResponseMessage> IHttpActionInvoker.InvokeActionAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
if (actionContext == null)
{
throw new ArgumentNullException("actionContext");
}
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
actionContext.ControllerContext.Request,
TraceCategories.ActionCategory,
TraceLevel.Info,
_innerInvoker.GetType().Name,
InvokeActionAsyncMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceActionInvokeMessage,
FormattingUtilities.ActionInvokeToString(actionContext));
},
execute: () => (Task <HttpResponseMessage>)_innerInvoker.InvokeActionAsync(actionContext, cancellationToken),
endTrace: (tr, result) =>
{
HttpResponseMessage response = result;
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null));
}
public override Task ExecuteBindingAsync(Controllers.HttpActionContext actionContext, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync(
actionContext.ControllerContext.Request,
TraceCategories.ModelBindingCategory,
TraceLevel.Info,
_innerBinding.GetType().Name,
ExecuteBindingAsyncMethodName,
beginTrace: null,
execute: () => _innerBinding.ExecuteBindingAsync(actionContext, cancellationToken),
endTrace: (tr) =>
{
if (!actionContext.ModelState.IsValid)
{
tr.Message = Error.Format(SRResources.TraceModelStateInvalidMessage,
FormattingUtilities.ModelStateToString(
actionContext.ModelState));
}
else
{
if (actionContext.ActionDescriptor.GetParameters().Count > 0)
{
tr.Message = Error.Format(SRResources.TraceValidModelState,
FormattingUtilities.ActionArgumentsToString(
actionContext.ActionArguments));
}
}
},
errorTrace: null));
}
Task <HttpResponseMessage> IHttpController.ExecuteAsync(
HttpControllerContext controllerContext,
CancellationToken cancellationToken
)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerController.GetType().Name,
ExecuteAsyncMethodName,
beginTrace: null,
execute: () =>
{
// Critical to allow wrapped controller to have itself in ControllerContext
controllerContext.Controller = ActualController(controllerContext.Controller);
return ExecuteAsyncCore(controllerContext, cancellationToken);
},
endTrace: (tr, response) =>
{
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null
));
}
protected override Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken
)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
request,
TraceCategories.RequestCategory,
TraceLevel.Info,
String.Empty,
String.Empty,
beginTrace: (tr) =>
{
tr.Message =
request.RequestUri == null
? SRResources.TraceNoneObjectMessage
: request.RequestUri.ToString();
},
execute: () => base.SendAsync(request, cancellationToken),
endTrace: (tr, response) =>
{
MediaTypeHeaderValue contentType =
response == null
? null
: response.Content == null
? null
: response.Content.Headers.ContentType;
long?contentLength =
response == null
? null
: response.Content == null
? null
: response.Content.Headers.ContentLength;
if (response != null)
{
tr.Status = response.StatusCode;
}
tr.Message = Error.Format(
SRResources.TraceRequestCompleteMessage,
contentType == null
? SRResources.TraceNoneObjectMessage
: contentType.ToString(),
contentLength.HasValue
? contentLength.Value.ToString(CultureInfo.CurrentCulture)
: SRResources.TraceUnknownMessage
);
},
errorTrace: null
));
}
private Task OnExceptionAsyncCore(
HttpActionExecutedContext actionExecutedContext,
CancellationToken cancellationToken,
[CallerMemberName] string methodName = null
)
{
return(_traceStore.TraceBeginEndAsync(
actionExecutedContext.Request,
TraceCategories.FiltersCategory,
TraceLevel.Info,
_innerFilter.GetType().Name,
methodName,
beginTrace: (tr) =>
{
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
},
execute: async() =>
{
await _innerFilter.OnExceptionAsync(actionExecutedContext, cancellationToken);
},
endTrace: (tr) =>
{
Exception returnedException = actionExecutedContext.Exception;
tr.Level = returnedException == null ? TraceLevel.Info : TraceLevel.Error;
tr.Exception = returnedException;
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: (tr) =>
{
HttpResponseMessage response = actionExecutedContext.Response;
if (response != null)
{
tr.Status = response.StatusCode;
}
}
));
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
request,
TraceCategories.MessageHandlersCategory,
TraceLevel.Info,
_innerHandler.GetType().Name,
SendAsyncMethodName,
beginTrace: null,
execute: () => base.SendAsync(request, cancellationToken),
endTrace: (tr, response) =>
{
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null));
}
Task <HttpResponseMessage> IHttpController.ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerController.GetType().Name,
ExecuteAsyncMethodName,
beginTrace: null,
execute: () =>
{
// Critical to allow wrapped controller to have itself in ControllerContext
controllerContext.Controller = ActualController(controllerContext.Controller);
return _innerController.ExecuteAsync(controllerContext, cancellationToken)
.Finally(() =>
{
IDisposable disposable = _innerController as IDisposable;
if (disposable != null)
{
// Need to remove the original controller from the disposables list, if it's
// there, and put ourselves in there instead, so we can trace the dispose.
// This currently knows a little too much about how RegisterForDispose works,
// but that's unavoidable unless we want to offer UnregisterForDispose.
IList <IDisposable> disposables;
if (_request.Properties.TryGetValue(HttpPropertyKeys.DisposableRequestResourcesKey, out disposables))
{
disposables.Remove(disposable);
disposables.Add(this);
}
}
});
},
endTrace: (tr, response) =>
{
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null));
}
public override Task <object> ExecuteAsync(
HttpControllerContext controllerContext,
IDictionary <string, object> arguments,
CancellationToken cancellationToken
)
{
return(_traceWriter.TraceBeginEndAsync <object>(
controllerContext.Request,
TraceCategories.ActionCategory,
TraceLevel.Info,
_innerDescriptor.GetType().Name,
ExecuteMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceInvokingAction,
FormattingUtilities.ActionInvokeToString(ActionName, arguments)
);
},
execute: () =>
{
return _innerDescriptor.ExecuteAsync(
controllerContext,
arguments,
cancellationToken
);
},
endTrace: (tr, value) =>
{
tr.Message = Error.Format(
SRResources.TraceActionReturnValue,
FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture)
);
},
errorTrace: null
));
}
