Example #1
0
        private void LogPostHandleMessage(CorrelationContext context, string messageName, ISpan span, string retryMessage)
        {
            var postLogMessage = $"Handled a message: '{messageName}'" +
                                 $"with correlationId: {context.Id}. {retryMessage}";

            _logger.LogInformation(postLogMessage);
            span.Log(postLogMessage);
        }
Example #2
0
        private void LogPreHandleMessage(CorrelationContext context, string messageName, ISpan span, string retryMessage)
        {
            var logMessage = $"Handling a message: '{messageName}'" +
                             $"with correlationId: '{context.Id}'. {retryMessage}";

            _logger.LogInformation(logMessage);
            span.Log(logMessage);
        }
Example #3
0
        private async Task PublishRejectedEventAndLog(CorrelationContext context, string messageName, ISpan span, IRejectedEvent rejectedEvent)
        {
            await _busClient.PublishAsync(rejectedEvent, ctx => ctx.UseMessageContext(context));

            _logger.LogInformation($"Published rejected event: '{rejectedEvent.GetType().Name}' for message: '{messageName}' " +
                                   $"with correlationId: '{context.Id}'");

            span.SetTag("error-type", "domain");
        }
Example #4
0
        private async Task <Acknowledgement> TryHandleAsync <TMessage>(TMessage message, CorrelationContext context,
                                                                       Func <Task> handle, Func <TMessage, CRouteException, IRejectedEvent> onError)

        {
            var currentRetry = 0;
            var policy       = Policy.Handle <Exception>()
                               .WaitAndRetryAsync(_retries, i => TimeSpan.FromSeconds(_retryInterval));

            var messageName = message.GetType().Name;

            return(await policy.ExecuteAsync <Acknowledgement>(async() =>
            {
                using (var scope = GetScope())
                {
                    var span = scope.Span;

                    try
                    {
                        var retryMessage = currentRetry == 0 ? string.Empty : $"Retry: {currentRetry}.";
                        LogPreHandleMessage(context, messageName, span, retryMessage);
                        await handle();
                        LogPostHandleMessage(context, messageName, span, retryMessage);
                        return new Ack();
                    }
                    catch (Exception exception)
                    {
                        currentRetry++;
                        LogErrorMessage(span, exception);

                        if (ShouldProcessError(onError, exception, out var cRouteException))
                        {
                            var rejectedEvent = onError(message, cRouteException);

                            await PublishRejectedEventAndLog(context, messageName, span, rejectedEvent);

                            return new Ack();
                        }

                        span.SetTag("error-type", "infrastructure");
                        throw new Exception($"Unable to handle message: '{messageName}' " +
                                            $"with correlationId: '{context.Id}'. " +
                                            $"Retry {currentRetry}/{_retries}.");
                    }
                }
            }));
        }