private async Task ProcessErrorAsync(ProcessErrorEventArgs args)
{
if (args?.Exception is null)
{
Logger.LogWarning("Thrown exception on Azure Service Bus message pump '{JobId}' was null, skipping", JobId);
return;
}
try
{
await HandleReceiveExceptionAsync(args.Exception);
}
finally
{
if (args.Exception is UnauthorizedAccessException)
{
if (Interlocked.Increment(ref _unauthorizedExceptionCount) >= Settings.Options.MaximumUnauthorizedExceptionsBeforeRestart)
{
Logger.LogTrace("Unable to connect anymore to Azure Service Bus, trying to re-authenticate...");
await RestartAsync();
}
else
{
Logger.LogWarning("Unable to connect anymore to Azure Service Bus ({CurrentCount}/{MaxCount})",
_unauthorizedExceptionCount, Settings.Options.MaximumUnauthorizedExceptionsBeforeRestart);
}
}
}
}
static Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
{
// Write details about the error to the console window
Console.WriteLine($"\tPartition '{ eventArgs.PartitionId}': an unhandled exception was encountered. This was not expected to happen.");
Console.WriteLine(eventArgs.Exception.Message);
return(Task.CompletedTask);
}
private Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
{
_logger.LogError($"\n\nERROR: Partition: '{eventArgs.PartitionId}': an unhandled exception was encountered.\n\n");
_logger.LogError(eventArgs.Exception.Message);
return(Task.CompletedTask);
}
private static Task Error_Handler(ProcessErrorEventArgs eventArgs)
{
Console.WriteLine("An Error has occurred");
Console.WriteLine(eventArgs.Exception.Message);
return(Task.CompletedTask);
}
private Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
{
// Write details about the error to the console window
logger.LogError(eventArgs.Exception, $"Partition '{ eventArgs.PartitionId}': an unhandled exception was encountered. This was not expected to happen.");
return(Task.CompletedTask);
}
/// <summary>
/// Event handler that logs errors from EventProcessorClient
/// </summary>
/// <param name="arg">Error event args</param>
/// <returns>Completed Task, no async work needed</returns>
private Task Client_ProcessErrorAsync(ProcessErrorEventArgs arg)
{
_logger.LogError(arg.Exception, "Issue reported by EventProcessorClient, partition {PartitionId}, operation {Operation}",
arg.PartitionId,
arg.Operation);
return(Task.CompletedTask);
}
private static Task ProcessErrorHandler(ProcessErrorEventArgs arg)
{
Console.WriteLine($"\tPartition '{ arg.PartitionId}': an unhandled exception was encountered.");
Console.WriteLine(arg.Exception.Message);
return(Task.CompletedTask);
}
async Task OnError(ProcessErrorEventArgs arg)
{
if (ProcessError != null)
{
await ProcessError.Invoke(arg).ConfigureAwait(false);
}
}
private Task ProcessErrorHandler(ProcessErrorEventArgs args)
{
try
{
var eventHubsException = (args.Exception as EventHubsException);
eventHubsException?.TrackMetrics(Metrics);
if (eventHubsException == null)
{
Interlocked.Increment(ref Metrics.GeneralExceptions);
}
Interlocked.Increment(ref Metrics.TotalExceptions);
Interlocked.Increment(ref Metrics.ProcessingExceptions);
ErrorsObserved.Add(args.Exception);
}
catch (EventHubsException ex)
{
Interlocked.Increment(ref Metrics.TotalExceptions);
ex.TrackMetrics(Metrics);
ErrorsObserved.Add(ex);
}
catch (Exception ex)
{
Interlocked.Increment(ref Metrics.TotalExceptions);
Interlocked.Increment(ref Metrics.GeneralExceptions);
ErrorsObserved.Add(ex);
}
return(Task.CompletedTask);
}
private static Task EventProcessorClient_ProcessErrorAsync(ProcessErrorEventArgs arg)
{
// WRITE TO LOG
Console.WriteLine($"\tPartition {arg.PartitionId} : Error");
Console.WriteLine($"{arg.Exception.Message}");
return(Task.CompletedTask);
}
static Task ActionErreurReception(ProcessErrorEventArgs args)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Une erreur est survenue lors de la reception du message : " + args.Exception.ToString());
Console.ForegroundColor = ConsoleColor.White;
return(Task.CompletedTask);
}
private async Task _processor_ProcessErrorAsync(ProcessErrorEventArgs arg)
{
EndedHow = Ended.Error;
_wait.Set();
await Task.CompletedTask;
}
private Task ClientOnProcessErrorAsync(ProcessErrorEventArgs arg)
{
if (!(arg.Exception is OperationCanceledException))
{
_log.Error(arg.Exception, $"{typeof(ServiceBusTopicChannelReceiver<TTopic>).Name}");
}
return(Task.CompletedTask);
}
/// <summary>
/// The method to pass to the <see cref="EventProcessorClient" /> instance as the <see cref="EventProcessorClient.ProcessErrorAsync" />
/// event handler.
/// </summary>
///
/// <param name="args">The <see cref="ProcessErrorEventArgs" /> used to pass information to the errpr handler.</param>
///
private Task ProcessErrorHandler(ProcessErrorEventArgs args)
{
var exceptionProperties = new Dictionary <string, string>();
exceptionProperties.Add(Metrics.TestName, _testName);
_metrics.Client.TrackException(args.Exception, exceptionProperties);
return(Task.CompletedTask);
}
private Task OnMessageFaultedAsync(ProcessErrorEventArgs args)
{
Logger.LogError(args.Exception,
"Message receiving faulted. Namespace:{FullyQualifiedNamespace}, Entity Path: {EntityPath}, Source: {ErrorSource}",
args.FullyQualifiedNamespace,
args.EntityPath,
args.ErrorSource);
return(Task.CompletedTask);
}
private Task ProcessErrorHandler(ProcessErrorEventArgs e)
{
var partitionId = e.PartitionId;
var operation = e.Operation;
Logger.LogError(e.Exception, $"Encountered an error during operation {operation} on partition {partitionId}.");
return(Task.CompletedTask);
}
private static Task ErrorHandler(ProcessErrorEventArgs args, string subscription)
{
Console.WriteLine($"Received error on subscription {subscription}");
Console.WriteLine(args.ErrorSource);
Console.WriteLine(args.FullyQualifiedNamespace);
Console.WriteLine(args.EntityPath);
Console.WriteLine(args.Exception.ToString());
return(Task.CompletedTask);
}
static Task ExceptionReceivedHandler(ProcessErrorEventArgs ex)
{
Console.WriteLine($"Message handler encountered an exception {ex.Exception}.");
Console.WriteLine("Exception context for troubleshooting:");
Console.WriteLine($"- ErrorSource: {ex.ErrorSource}");
Console.WriteLine($"- Entity Path: {ex.EntityPath}");
Console.WriteLine($"- Fully Qualified Namespace: {ex.FullyQualifiedNamespace}");
return(Task.CompletedTask);
}
private async Task _processor_ProcessErrorAsync(ProcessErrorEventArgs arg)
{
_logger.Error(arg.Exception, $"Error ocurred at ServiceBusProcessor for queue {_queueName}. ErrorSource: {arg.ErrorSource}");
if (arg.ErrorSource == ServiceBusErrorSource.AcceptSession || arg.ErrorSource == ServiceBusErrorSource.CloseSession)
{
_logger.Error(arg.Exception, $"Stopping ServiceBusProcessor for queue {_queueName}");
await Stop(true);
}
}
static Task ErrorHandler(ProcessErrorEventArgs args)
{
Console.WriteLine($"Message handler encountered an exception {args.Exception}.");
Console.WriteLine("Exception context for troubleshooting:");
Console.WriteLine($"- Endpoint: {args.FullyQualifiedNamespace}");
Console.WriteLine($"- Entity Path: {args.EntityPath}");
Console.WriteLine($"- Executing Action: {args.ErrorSource}");
return(Task.CompletedTask);
}
private Task ErrorHandler(ProcessErrorEventArgs args)
{
var ex = args.Exception;
var context = args.ErrorSource;
_logger.LogError(ex, "ERROR handling message: {ExceptionMessage} - Context: {@ExceptionContext}", ex.Message, context);
return(Task.CompletedTask);
}
Task ExceptionReceivedHandler(ProcessErrorEventArgs args)
{
Log.Error(args.Exception,
$@"Message handler encountered an exception.
ErrorSource: {Enum.GetName(typeof(ServiceBusErrorSource), args.ErrorSource)}
Entity Path: {args.EntityPath}
Namespace: {args.FullyQualifiedNamespace}");
return(Task.CompletedTask);
}
private Task ErrorHandlerAsync(ProcessErrorEventArgs arg)
{
_logger.LogError(arg.Exception, "Message handler encountered an exception");
_logger.LogDebug($"- Error Source: {arg.ErrorSource}");
_logger.LogDebug($"- Fully Qualified Namespace: {arg.FullyQualifiedNamespace}");
_logger.LogDebug($"- Entity Path: {arg.EntityPath}");
_logger.LogDebug($"- Exception: {arg.Exception.ToString()}");
return(_serviceBusProcessor.CloseAsync());
}
private Task Processor_ProcessErrorAsync(ProcessErrorEventArgs arg)
{
return(eventBus.HandleError(
new EventBusError(
Guid.NewGuid(),
arg.EntityPath,
DateTime.Now,
new AggregateException(arg.Exception)
)
));
}
private static Task processErrorHandler(ProcessErrorEventArgs eventArgs)
{
try
{
Console.WriteLine($"\n[ERROR] processErrorHandler -> Operation '{eventArgs.Operation}' from Partition {eventArgs.PartitionId} - {eventArgs.Exception.Message} ");
}
catch
{
}
return(Task.CompletedTask);
}
private static Task ErrorHandler(ProcessErrorEventArgs args)
{
// the error source tells me at what point in the processing an error occurred
Console.WriteLine(args.ErrorSource);
// the fully qualified namespace is available
Console.WriteLine(args.FullyQualifiedNamespace);
// as well as the entity path
Console.WriteLine(args.EntityPath);
Console.WriteLine(args.Exception.ToString());
return(Task.CompletedTask);
}
// Use this handler to examine the exceptions received on the message pump.
private Task ExceptionReceivedHandler(ProcessErrorEventArgs e)
{
OnException?.Invoke(new Models.ServiceBusException
{
Exception = e.Exception,
// Action = e.ExceptionReceivedContext.Action,
// ClientId = e.ExceptionReceivedContext.ClientId,
// Endpoint = e.FullyQualifiedNamespace,
EntityPath = e.EntityPath,
});
return(Task.CompletedTask);
}
private Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
{
try
{
// Write details about the error to the console window
log.LogError($"\tPartition '{ eventArgs.PartitionId}': an unhandled exception was encountered. This was not expected to happen.");
log.LogError(eventArgs.Exception.Message);
}
catch (Exception exe)
{
log.LogError($"Failure to process event error args: {exe.Message}");
}
return(Task.CompletedTask);
}
/// <summary>
/// Formats message.
/// </summary>
/// <param name="processErrorEventArgs">Message.</param>
/// <returns>Formatted message.</returns>
/// <exception cref="ArgumentNullException">processErrorEventArgs is null.</exception>
public string Format(ProcessErrorEventArgs processErrorEventArgs)
{
if (processErrorEventArgs == null)
{
throw new ArgumentNullException("processErrorEventArgs",
Resources.ArgumentNullException);
}
return(String.Format(CultureInfo.CurrentCulture,
@Resources.MessageProcessError,
@DateTime.Now,
@Resources.MessageTypeError,
@processErrorEventArgs.DaemonName,
@processErrorEventArgs.Exception.Message));
}
public void LogExceptionReceivedEvent_NonMessagingException_LoggedAsError()
{
var ex = new MissingMethodException("What method??");
ProcessErrorEventArgs e = new ProcessErrorEventArgs(ex, ServiceBusErrorSource.Complete, "TestEndpoint", "TestEntity", CancellationToken.None);
ServiceBusExtensionConfigProvider.LogExceptionReceivedEvent(e, _loggerFactory);
var expectedMessage = $"Message processing error (Action=Complete, EntityPath=TestEntity, Endpoint=TestEndpoint)";
var logMessage = _loggerProvider.GetAllLogMessages().Single();
Assert.AreEqual(LogLevel.Error, logMessage.Level);
Assert.AreSame(ex, logMessage.Exception);
Assert.AreEqual(expectedMessage, logMessage.FormattedMessage);
}
