private async Task SendMessageToDeadLetterQueueAsync(MessageExecutionContext messageExecutionContext, int retrycount) { IntegrationEvent <JObject> integrationEvent = null; if (!string.IsNullOrEmpty(messageExecutionContext.SerializedMessage)) { integrationEvent = JsonConvert.DeserializeObject <IntegrationEvent <JObject> >(messageExecutionContext.SerializedMessage); } var deadLetterEventDescriptor = new DeadLetterEventDescriptor <JObject> { CountOfAttempts = retrycount, LastAttemptError = messageExecutionContext.Exception.ToString(), Original = integrationEvent }; messageExecutionContext.DeadLetterIntegrationEvent = new IntegrationEvent <DeadLetterEventDescriptor <JObject> > { EventType = _modelNamingConventionController.GetDeadLetterQueueMessageEventType( integrationEvent?.EventType), Content = deadLetterEventDescriptor }; await _failedExecutionHandler(messageExecutionContext); }
private async Task TrySendToRetryQueue(MessageExecutionContext messageExecutionContext) { if (!messageExecutionContext.MessageProperties.HeadersPresent) { messageExecutionContext.MessageProperties.Headers = new Dictionary <string, object>(); } int retrycount; if (messageExecutionContext.MessageProperties.Headers.ContainsKey("retrycount")) { retrycount = int.Parse(messageExecutionContext.MessageProperties.Headers["retrycount"].ToString()); } else { retrycount = 0; } if (retrycount < _maxRetry) { _logger.Warning(messageExecutionContext.Exception, $"Failed to process the event({retrycount}/{_maxRetry}): {messageExecutionContext.SerializedMessage}"); messageExecutionContext.MessageProperties.Headers["retrycount"] = retrycount + 1; await _waitEasyNetQPublisher.PublishEventAsync(messageExecutionContext.BodyBytes, messageExecutionContext.MessageProperties, _modelNamingConventionController.GetRetryRoutingKey(_name, retrycount + 1)); } else { _logger.Error(messageExecutionContext.Exception, $"Failed to process the event({retrycount}/{_maxRetry}): {messageExecutionContext.SerializedMessage}"); await SendMessageToDeadLetterQueueAsync(messageExecutionContext, retrycount); } }
private async Task HandleDeadletterQueueAndTrackingAsync(MessageExecutionContext messageExecutionContext) { await HandleDeadletterQueueWithoutTrackingAsync(messageExecutionContext); await _publisher.PublishEventAsync( messageExecutionContext.DeadLetterIntegrationEvent, _modelNamingConventionController.GetDeadLetterQueueRoutingKey(_name)); }
private async Task HandleDeadletterQueueWithoutTrackingAsync(MessageExecutionContext messageExecutionContext) { if (_storedeadletter) { await _waitEasyNetQPublisher.PublishEventAsync( messageExecutionContext.DeadLetterIntegrationEvent, _modelNamingConventionController.GetDeadLetterQueueRoutingKey(_name), true); } await messageExecutionContext.Subscription.NotifyAboutDeadLetterAsync(messageExecutionContext.SerializedMessage, messageExecutionContext.Exception); }
public async Task HandleErrorAsync(MessageExecutionContext messageExecutionContext) { switch (messageExecutionContext.Exception) { case MalformedEventException ex: throw ex; case DiscardEventException ex: throw ex; default: await TrySendToRetryQueue(messageExecutionContext); break; } }
public void Subscribe(IDictionary <string, ISubscription> subscriptions) { lock (_threadguard) { if (_alreadyDisposed) { throw new ObjectDisposedException("EasyNetQSubscriber", "Called Subscribe Method on Disposed object"); } if (_subscribed == false) { _subscriptions = new ConcurrentDictionary <string, ISubscription>(subscriptions); _consumerDisposable = _bus.Consume(_queue, async(body, properties, info) => { MessageExecutionContext messageExecutionContext = new MessageExecutionContext(body, properties, info); try { messageExecutionContext.IntergrationEventParsingResult = DefaultIntergrationEventParser.Parse(body); if (messageExecutionContext.IntergrationEventParsingResult.Success) { using (LogContext.PushProperty("CorrelationId", messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.CorrelationId)) { messageExecutionContext.Subscription = _subscriptionSelector.Select(_subscriptions, messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.EventType); if (messageExecutionContext.Subscription != null) { messageExecutionContext.SerializedMessage = Encoding.UTF8.GetString(body); _logger.Debug("Subscriber received message: {@body}", messageExecutionContext.SerializedMessage); await messageExecutionContext.Subscription.InvokeAsync(messageExecutionContext.SerializedMessage); await _successHandlingStrategy.HandleSuccessAsync( messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent); } else { throw new DiscardEventException( $"The consumer for {messageExecutionContext.IntergrationEventParsingResult.IntegrationEvent.EventType} event type is not matched"); } } } else { throw new MalformedEventException(messageExecutionContext.IntergrationEventParsingResult.Errors); } } catch (Exception e) { messageExecutionContext.Exception = e; await _errorHandlingStrategy.HandleErrorAsync(messageExecutionContext); } }, configuration => configuration.WithPrefetchCount(_prefetchcount)); _subscribed = true; } else { foreach (var subscription in subscriptions) { _subscriptions.AddOrUpdate( subscription.Key, subscription.Value, (key, oldValue) => subscription.Value); } } } }