private void HandleFaultException(FaultException ex, SoapContext <TService> context)
{
_logger.LogWarning(ex, $"Fault exception: {ex.Message}");
var messageFault = ex.CreateMessageFault();
context.Response = FaultMessage.CreateFaultMessage(context.MessageVersion, messageFault, context.Request.Headers.Action);
}
/// <summary>
/// Create the custom error message format
/// </summary>
/// <returns></returns>
protected virtual string GetCombinedExceptionMessage()
{
if (string.IsNullOrEmpty(base.Message))
{
return(FaultMessage);
}
string _message;
if (FaultMessage.Contains(Environment.NewLine))
{
_message = string.Format("{0}Base:{1}{2}Stack:{3}",
FaultMessage,
base.Message,
Environment.NewLine,
StackTrace);
}
else
{
_message = string.Format("{0}{2}Base:{1}{2}Stack:{3}",
FaultMessage,
base.Message,
Environment.NewLine,
StackTrace);
}
return(_message);
}
/// <summary>
/// Submits an exception as a fault to the ESB Exception database
/// </summary>
/// <remarks>
/// The majority of the properties populated in the fault are needed for the WCF-generated
/// fault to look the same as an ESB-generated fault, as null values are allowed in the
/// database, but will prevent records showing in the ESB management portal.
/// </remarks>
/// <param name="serviceProviderName">Name of the service provider</param>
/// <param name="serviceName">Name of the service submitting the fault</param>
/// <param name="faultDescription">Description or fault/error message</param>
/// <param name="severity">Severity of fault</param>
/// <param name="ex">Exception that was caught</param>
public static void SubmitFault(string serviceProviderName, string serviceName,
string faultDescription, FaultSeverity severity, Exception ex)
{
DateTime now = DateTime.Now;
//populate the header:
FaultMessageHeader header = new FaultMessageHeader();
header.DateTime = now.ToString();
header.MachineName = Environment.MachineName;
header.Application = ServiceProviderErrorHandlerConfiguration.Current.BizTalkApplication;
header.ServiceName = string.Format("{0}.{1}", serviceProviderName, serviceName);
header.ErrorType = ServiceProviderErrorHandlerConfiguration.Current.ErrorType;
header.FailureCategory = ServiceProviderErrorHandlerConfiguration.Current.FailureCategory;
header.FaultCode = ServiceProviderErrorHandlerConfiguration.Current.FaultCode;
header.FaultSeverity = (int)severity;
header.FaultDescription = faultDescription;
header.FaultGenerator = ServiceProviderErrorHandlerConfiguration.Current.FaultGeneratorName;
header.Description = string.Format("Fault occurred in provider: {0}, processing service: {1}", serviceProviderName, serviceName);
header.MessageID = GetDeterministicGuid("{0}_{1}_{2}", serviceProviderName, serviceName, now.Ticks).ToString();
header.ActivityIdentity = GetDeterministicGuid("{0}_{1}", serviceProviderName, serviceName).ToString();
header.ServiceInstanceID = GetDeterministicGuid(serviceProviderName).ToString();
//OperationContext is thread static, no may be null if call from child threads:
if (OperationContext.Current == null)
{
header.Scope = "Worker thread";
}
else
{
header.Scope = OperationContext.Current.EndpointDispatcher.EndpointAddress.Uri.AbsoluteUri;
}
//populate exception details:
FaultMessageExceptionObject faultException = new FaultMessageExceptionObject();
faultException.Source = ex.Source;
faultException.StackTrace = ex.StackTrace;
faultException.Message = ex.Message;
faultException.Type = ex.GetType().FullName;
if (ex.TargetSite != null)
{
faultException.TargetSite = ex.TargetSite.ToString();
}
if (ex.InnerException != null)
{
faultException.InnerExceptionMessage = ex.InnerException.Message;
}
else
{
//ESB uses the fault code here:
faultException.InnerExceptionMessage = ServiceProviderErrorHandlerConfiguration.Current.FaultCode;
}
FaultMessage message = new FaultMessage();
message.Header = header;
message.ExceptionObject = faultException;
SubmitFault(message);
}
/// <summary>
/// Submits the fault message to the configured ESB service
/// </summary>
/// <param name="faultMessage">Fault message to submit</param>
private static void SubmitFault(FaultMessage faultMessage)
{
using (ExceptionHandling proxy = new ExceptionHandling())
{
proxy.Url = ServiceProviderErrorHandlerConfiguration.Current.ExceptionHandlingUrl;
proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
proxy.SubmitFault(faultMessage);
}
}
/// <remarks/>
public void SubmitFaultAsync(FaultMessage FaultMessage, object userState)
{
if ((this.SubmitFaultOperationCompleted == null))
{
this.SubmitFaultOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSubmitFaultOperationCompleted);
}
this.InvokeAsync("SubmitFault", new object[] {
FaultMessage
}, this.SubmitFaultOperationCompleted, userState);
}
public void It_sets_fault_action()
{
var message = FaultMessage.Create("someAction", "no reason", FaultCode.Sender, Enumerable.Empty <XmlQualifiedName>());
var envelope = XElementExtensions.ParseGeneratedXml(message.Write);
var headerSectionElement = envelope.Element(Constants.Header);
var actionHeader = headerSectionElement.Element(Addressing.Constants.Namespace + "Action");
var actionValue = ((XText)actionHeader.FirstNode).Value;
Assert.AreEqual("someAction", actionValue);
}
public void It_reads_first_reason()
{
var outgoingMessage = FaultMessage.Create(
"someAction",
"no reason",
FaultCode.Sender,
new[] { FaultCode.Receiver });
var reader = XElementExtensions.ParseGeneratedXml(outgoingMessage.Write).ToReader();
var incomingMessage = new IncomingMessage(reader);
var exception = incomingMessage.CreateFaultException();
Assert.AreEqual("no reason", exception.Reason);
}
public void It_reads_fault_code_with_nested_subcodes()
{
var outgoingMessage = FaultMessage.Create(
"someAction",
"no reason",
FaultCode.Sender,
new [] { FaultCode.Receiver, FaultCode.VersionMismatch });
var reader = XElementExtensions.ParseGeneratedXml(outgoingMessage.Write).ToReader();
var incomingMessage = new IncomingMessage(reader);
var exception = incomingMessage.CreateFaultException();
Assert.AreEqual(FaultCode.Sender, exception.Code);
Assert.IsTrue(new [] { FaultCode.Receiver, FaultCode.VersionMismatch }.SequenceEqual(exception.Subcodes));
}
public void OnException(ExceptionContext context)
{
logger.LogError(new EventId(context.Exception.HResult),
context.Exception,
context.Exception.Message);
var faultMessage = new FaultMessage()
{
Message = context.Exception.Message,
Path = context.HttpContext.Request.Path,
CreatedDate = DateTime.UtcNow
};
context.Result = new ErrorObjectResult(faultMessage);
context.HttpContext.Response.StatusCode = (int)BuildHttpCode(context.Exception);
context.ExceptionHandled = true;
}
public void It_sets_fault_code_with_nested_subcodes()
{
var message = FaultMessage.Create("someAction", "no reason", FaultCode.Sender, new [] { FaultCode.Receiver, FaultCode.VersionMismatch });
var envelope = XElementExtensions.ParseGeneratedXml(message.Write);
var bodyElement = envelope.Element(Constants.Body);
var codeElement = bodyElement
.Element(Constants.Namespace + "Fault")
.Element(Constants.Namespace + "Code");
var rootSubcodeElement = codeElement.Element(Constants.Namespace + "Subcode");
var childSubcodeElement = rootSubcodeElement.Element(Constants.Namespace + "Subcode");
Assert.AreEqual("Sender", ExtractCodeValue(codeElement));
Assert.AreEqual("Receiver", ExtractCodeValue(rootSubcodeElement));
Assert.AreEqual("VersionMismatch", ExtractCodeValue(childSubcodeElement));
}
/// <summary>
/// Create the custom error message format
/// </summary>
/// <returns></returns>
private string GetCombinedExceptionMessage()
{
string _message;
if (FaultMessage.Contains(Environment.NewLine))
{
_message = string.Format("{0} at {1}{2} data {3}",
FaultMessage,
StackTrace,
Environment.NewLine,
ValidatedDataJson);
}
else
{
_message = string.Format("{0}{2} at {1}{2} data {3}",
FaultMessage,
StackTrace,
Environment.NewLine,
ValidatedDataJson);
}
return(_message);
}
/// <summary>
/// Submits an exception as a fault to the ESB Exception database
/// </summary>
/// <remarks>
/// The majority of the properties populated in the fault are needed for the WCF-generated
/// fault to look the same as an ESB-generated fault, as null values are allowed in the
/// database, but will prevent records showing in the ESB management portal.
/// </remarks>
/// <param name="serviceProviderName">Name of the service provider</param>
/// <param name="serviceName">Name of the service submitting the fault</param>
/// <param name="faultDescription">Description or fault/error message</param>
/// <param name="severity">Severity of fault</param>
/// <param name="ex">Exception that was caught</param>
public static void SubmitFault(string serviceProviderName, string serviceName,
string faultDescription, FaultSeverity severity, Exception ex)
{
DateTime now = DateTime.Now;
//populate the header:
FaultMessageHeader header = new FaultMessageHeader();
header.DateTime = now.ToString();
header.MachineName = Environment.MachineName;
header.Application = ServiceProviderErrorHandlerConfiguration.Current.BizTalkApplication;
header.ServiceName = string.Format("{0}.{1}", serviceProviderName, serviceName);
header.ErrorType = ServiceProviderErrorHandlerConfiguration.Current.ErrorType;
header.FailureCategory = ServiceProviderErrorHandlerConfiguration.Current.FailureCategory;
header.FaultCode = ServiceProviderErrorHandlerConfiguration.Current.FaultCode;
header.FaultSeverity = (int)severity;
header.FaultDescription = faultDescription;
header.FaultGenerator = ServiceProviderErrorHandlerConfiguration.Current.FaultGeneratorName;
header.Description = string.Format("Fault occurred in provider: {0}, processing service: {1}", serviceProviderName, serviceName);
header.MessageID = GetDeterministicGuid("{0}_{1}_{2}", serviceProviderName, serviceName, now.Ticks).ToString();
header.ActivityIdentity = GetDeterministicGuid("{0}_{1}", serviceProviderName, serviceName).ToString();
header.ServiceInstanceID = GetDeterministicGuid(serviceProviderName).ToString();
//OperationContext is thread static, no may be null if call from child threads:
if (OperationContext.Current == null)
{
header.Scope = "Worker thread";
}
else
{
header.Scope = OperationContext.Current.EndpointDispatcher.EndpointAddress.Uri.AbsoluteUri;
}
//populate exception details:
FaultMessageExceptionObject faultException = new FaultMessageExceptionObject();
faultException.Source = ex.Source;
faultException.StackTrace = ex.StackTrace;
faultException.Message = ex.Message;
faultException.Type = ex.GetType().FullName;
if (ex.TargetSite != null)
{
faultException.TargetSite = ex.TargetSite.ToString();
}
if (ex.InnerException != null)
{
faultException.InnerExceptionMessage = ex.InnerException.Message;
}
else
{
//ESB uses the fault code here:
faultException.InnerExceptionMessage = ServiceProviderErrorHandlerConfiguration.Current.FaultCode;
}
FaultMessage message = new FaultMessage();
message.Header = header;
message.ExceptionObject = faultException;
SubmitFault(message);
}
/// <summary>
/// Submits the fault message to the configured ESB service
/// </summary>
/// <param name="faultMessage">Fault message to submit</param>
private static void SubmitFault(FaultMessage faultMessage)
{
using (ExceptionHandling proxy = new ExceptionHandling())
{
proxy.Url = ServiceProviderErrorHandlerConfiguration.Current.ExceptionHandlingUrl;
proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
proxy.SubmitFault(faultMessage);
}
}
/// <remarks/>
public void SubmitFaultAsync(FaultMessage FaultMessage, object userState)
{
if ((this.SubmitFaultOperationCompleted == null))
{
this.SubmitFaultOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSubmitFaultOperationCompleted);
}
this.InvokeAsync("SubmitFault", new object[] {
FaultMessage}, this.SubmitFaultOperationCompleted, userState);
}
/// <remarks/>
public void SubmitFaultAsync(FaultMessage FaultMessage)
{
this.SubmitFaultAsync(FaultMessage, null);
}
public void SubmitFault([System.Xml.Serialization.XmlElementAttribute(Namespace = "http://schemas.microsoft.biztalk.practices.esb.com/exceptionhandling")] FaultMessage FaultMessage)
{
this.Invoke("SubmitFault", new object[] {
FaultMessage
});
}
/// <remarks/>
public void SubmitFaultAsync(FaultMessage FaultMessage)
{
this.SubmitFaultAsync(FaultMessage, null);
}
