/// <inheritdoc /> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { var spanContext = message.Extract(_tracer, _headers); if (spanContext != null) { using (IScope scope = _tracer.BuildSpan("Error").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true)) { scope.Span.Log(exception.ToString()); Tags.Error.Set(scope.Span, true); var result = _handler.MessageFailedProcessing(message, context, exception); scope.Span.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry); return(result); } } else { using (IScope scope = _tracer.BuildSpan("Error").StartActive(finishSpanOnDispose: true)) { scope.Span.AddMessageIdTag(message); scope.Span.Log(exception.ToString()); Tags.Error.Set(scope.Span, true); var result = _handler.MessageFailedProcessing(message, context, exception); scope.Span.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry); return(result); } } }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> /// <returns> /// an awaitable task /// </returns> public async Task Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification) { using (_runCodeTimer.NewContext()) { await _handler.Handle(message, workerNotification).ConfigureAwait(false); } }
/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public bool Handle(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { _methodToRun.Handle(transportMessage, context.WorkerNotification); _commitMessage.Commit(context); return(true); } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception); } } return(false); }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception> /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception> public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception) { ReceiveMessagesErrorResult result; try { result = _transportErrorHandler.MessageFailedProcessing(message, context, exception); } catch (Exception errorHandlingError) { _log.ErrorException( "An error has occurred while trying to move message {0} to the error queue", exception, message.MessageId); throw new DotNetWorkQueueException("An error has occurred in the error handling code", errorHandlingError); } switch (result) { case ReceiveMessagesErrorResult.Retry: case ReceiveMessagesErrorResult.NotSpecified: case ReceiveMessagesErrorResult.NoActionPossible: throw new MessageException("An unhanded exception has occurred while processing a message", exception, message.MessageId, message.CorrelationId); case ReceiveMessagesErrorResult.Error: //don't throw exception, as the message has been moved break; } }
/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public async Task Handle(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { await _methodToRun.HandleAsync(transportMessage, context.WorkerNotification).ConfigureAwait(false); _commitMessage.Commit(context); } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception.InnerException ?? exception); } } }
/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public async Task HandleAsync(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { await _methodToRun.HandleAsync(transportMessage, context.WorkerNotification).ConfigureAwait(false); _commitMessage.Commit(context); } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception.InnerException ?? exception); } } }
/// <summary> /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" /> /// </summary> /// <param name="messageType">Type of the output message.</param> /// <param name="message">The message.</param> /// <returns></returns> public dynamic GenerateMessage(Type messageType, IReceivedMessageInternal message) { var getHandlerGenericMethod = GetType().GetMethod("GetMessage", new[] { message.GetType() }); var generic = getHandlerGenericMethod.MakeGenericMethod(messageType); return(generic.Invoke(this, new object[] { message })); }
public MessageProcessingRpcReceive <FakeMessage> Create() { var fixture = new Fixture().Customize(new AutoNSubstituteCustomization()); var receiveMessages = fixture.Create <IReceiveMessagesFactory>(); fixture.Inject(receiveMessages); var fakeMessage = fixture.Create <IMessage>(); fakeMessage.Body.Returns(new FakeMessage()); fixture.Inject(fakeMessage); ICommitMessage commitMessage = fixture.Create <CommitMessage>(); fixture.Inject(commitMessage); IReceivedMessageInternal message = fixture.Create <ReceivedMessageInternal>(); var messageHandlerRegistration = fixture.Create <IMessageHandlerRegistration>(); messageHandlerRegistration.GenerateMessage(message) .Returns(new ReceivedMessage <FakeMessage>(message)); fixture.Inject(messageHandlerRegistration); receiveMessages.Create().ReceiveMessage(null).ReturnsForAnyArgs(message); return(fixture.Create <MessageProcessingRpcReceive <FakeMessage> >()); }
/// <summary> /// Handles processing the specified message with the context /// </summary> /// <param name="context">The context.</param> /// <param name="transportMessage">The transport message.</param> /// <returns></returns> public bool Handle(IMessageContext context, IReceivedMessageInternal transportMessage) { using (var heartBeat = _heartBeatWorkerFactory.Create(context)) { try { _methodToRun.Handle(transportMessage, context.WorkerNotification); _commitMessage.Commit(context); return true; } // ReSharper disable once UncatchableException catch (ThreadAbortException) { heartBeat.Stop(); throw; } catch (OperationCanceledException) { heartBeat.Stop(); throw; } catch (Exception exception) { heartBeat.Stop(); _messageExceptionHandler.Handle(transportMessage, context, exception); } } return false; }
/// <summary> /// Adds the message identifier tag. /// </summary> /// <param name="span">The span.</param> /// <param name="message">The message.</param> public static void AddMessageIdTag(this ISpan span, IReceivedMessageInternal message) { if (message.MessageId.HasValue) { span.SetTag("MessageId", message.MessageId.Id.Value.ToString()); } }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification) { using (_runCodeTimer.NewContext()) { _handler.Handle(message, workerNotification); } }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification) { using (_runCodeTimer.NewContext()) { await _handler.HandleAsync(message, workerNotification).ConfigureAwait(false); } }
/// <inheritdoc /> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { //message failed to process if (context.MessageId == null || !context.MessageId.HasValue) { return(ReceiveMessagesErrorResult.NoActionPossible); } var info = _configuration.TransportConfiguration.RetryDelayBehavior.GetRetryAmount(exception); string exceptionType = null; if (info.ExceptionType != null) { exceptionType = info.ExceptionType.ToString(); } var bSendErrorQueue = false; if (string.IsNullOrEmpty(exceptionType) || info.MaxRetries <= 0) { bSendErrorQueue = true; } else { //determine how many times this exception has been seen for this message var retries = _queryErrorRetryCount.Handle( new GetErrorRetryCountQuery(exceptionType, (long)context.MessageId.Id.Value)); if (retries >= info.MaxRetries) { bSendErrorQueue = true; } else { context.Set(_headers.QueueDelay, new QueueDelay(info.Times[retries])); //note zero based index - use the current count not count +1 _commandSetErrorCount.Handle( new SetErrorCountCommand( exceptionType, (long)context.MessageId.Id.Value)); } } if (!bSendErrorQueue) { return(ReceiveMessagesErrorResult.Retry); } _commandMoveRecord.Handle( new MoveRecordToErrorQueueCommand(exception, (long)context.MessageId.Id.Value, context)); //we are done doing any processing - remove the messageID to block other actions context.SetMessageAndHeaders(null, context.Headers); _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception, message.MessageId); return(ReceiveMessagesErrorResult.Error); }
/// <inheritdoc /> public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification) { var ActivityContext = message.Extract(_tracer, _headers); using (var scope = _tracer.StartActivity("MessageHandler", ActivityKind.Internal, parentContext: ActivityContext)) { _handler.Handle(message, workerNotification); } }
/// <summary> /// Initializes a new instance of the <see cref="IReceivedMessage{T}" /> class. /// </summary> /// <param name="message">The internal message.</param> public ReceivedMessage(IReceivedMessageInternal message) { Guard.NotNull(() => message, message); Body = (T)message.Body; Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key, entry => entry.Value)); MessageId = message.MessageId; CorrelationId = message.CorrelationId; }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> /// <returns></returns> public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification) { var activityContext = message.Extract(_tracer, _headers.StandardHeaders); using (var scope = _tracer.StartActivity("MessageHandlerAsync", ActivityKind.Internal, activityContext)) { scope?.AddMessageIdTag(message); await _handler.HandleAsync(message, workerNotification); } }
/// <summary> /// Extracts the specified tracer. /// </summary> /// <param name="message">The message.</param> /// <param name="tracer">The tracer.</param> /// <param name="headers">The headers.</param> /// <returns></returns> public static ISpanContext Extract(this IReceivedMessageInternal message, ITracer tracer, IStandardHeaders headers) { if (message.Headers.ContainsKey(headers.TraceSpan.Name)) { var mapping = (DataMappingTextMap)message.Headers[headers.TraceSpan.Name]; return(tracer.Extract(BuiltinFormats.TextMap, mapping)); } return(null); }
/// <summary> /// Handles a message that has failed processing /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { //message failed to process if (context.MessageId == null || !context.MessageId.HasValue) { return(ReceiveMessagesErrorResult.NoActionPossible); } var info = _configuration.TransportConfiguration.RetryDelayBehavior.GetRetryAmount(exception); string exceptionType = null; if (info.ExceptionType != null) { exceptionType = info.ExceptionType.ToString(); } var bSendErrorQueue = false; if (string.IsNullOrEmpty(exceptionType) || info.MaxRetries <= 0) { bSendErrorQueue = true; } else { //determine how many times this exception has been seen for this message var metadata = _queryGetMetaData.Handle(new GetMetaDataQuery((RedisQueueId)context.MessageId)); var retries = metadata.ErrorTracking.GetExceptionCount(exceptionType); if (retries >= info.MaxRetries) { bSendErrorQueue = true; } else { context.Set(_headers.IncreaseQueueDelay, new RedisQueueDelay(info.Times[retries])); metadata.ErrorTracking.IncrementExceptionCount(exceptionType); _saveMetaData.Handle(new SaveMetaDataCommand((RedisQueueId)context.MessageId, metadata)); } } if (!bSendErrorQueue) { return(ReceiveMessagesErrorResult.Retry); } _commandMoveRecord.Handle( new MoveRecordToErrorQueueCommand((RedisQueueId)context.MessageId)); //we are done doing any processing - remove the messageID to block other actions context.MessageId = null; _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception, message.MessageId); return(ReceiveMessagesErrorResult.Error); }
/// <summary> /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" /> /// </summary> /// <param name="messageType">Type of the output message.</param> /// <param name="message">The message.</param> /// <returns></returns> public dynamic GenerateMessage(Type messageType, IReceivedMessageInternal message) { var getHandlerGenericMethod = GetType().GetMethod("GetMessage", new[] { message.GetType() }); if (getHandlerGenericMethod == null) { throw new NullReferenceException("getHandlerGenericMethod is null"); } var generic = getHandlerGenericMethod.MakeGenericMethod(messageType); return(generic.Invoke(this, new object[] { message })); }
/// <summary> /// Generates a <see cref="IReceivedMessage{T}" /> from a <see cref="IReceivedMessageInternal" /> /// </summary> /// <typeparam name="T">The type of the output message</typeparam> /// <param name="internalMessage">The internal message.</param> /// <returns></returns> public IReceivedMessage <T> GetMessage <T>(IReceivedMessageInternal internalMessage) where T : class { var d1 = Type.GetType("DotNetWorkQueue.Messages.ReceivedMessage`1"); Type[] typeArgs = { typeof(T) }; //if d1 is null, just let it throw an exception; this would indicate that something strange has happened // ReSharper disable once PossibleNullReferenceException var make = d1.MakeGenericType(typeArgs); return((IReceivedMessage <T>)Activator.CreateInstance(make, internalMessage, _getErrors)); }
/// <summary>Initializes a new instance of the <see cref="IReceivedMessage{T}"/> class.</summary> /// <param name="message">The internal message.</param> /// <param name="getErrors">Gets any previous errors that have occured for this specific message</param> public ReceivedMessage(IReceivedMessageInternal message, IGetPreviousMessageErrors getErrors) { Guard.NotNull(() => message, message); Guard.NotNull(() => getErrors, getErrors); _getErrors = getErrors; Body = (T)message.Body; Headers = new ReadOnlyDictionary <string, object>(message.Headers.ToDictionary(entry => entry.Key, entry => entry.Value)); MessageId = message.MessageId; CorrelationId = message.CorrelationId; }
/// <inheritdoc /> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { var activityContext = message.Extract(_tracer, _headers); using (var scope = _tracer.StartActivity("Error", ActivityKind.Internal, parentContext: activityContext)) { scope?.AddMessageIdTag(message); scope?.RecordException(exception); scope?.SetStatus(Status.Error);; var result = _handler.MessageFailedProcessing(message, context, exception); scope?.SetTag("WillRetry", result == ReceiveMessagesErrorResult.Retry); return(result); } }
private void ProcessResult(IReceivedMessageInternal message) { if (message.Headers.ContainsKey(_headers.StandardHeaders.FirstPossibleDeliveryDate.Name)) { var waitTime = (ValueTypeWrapper <DateTime>)message.Headers[_headers.StandardHeaders.FirstPossibleDeliveryDate.Name]; if (waitTime != null) { var difference = _getTime.Create().GetCurrentUtcDate() - waitTime.Value; _waitTimer.Record((long)difference.TotalMilliseconds, TimeUnits.Milliseconds); } } _meter.Mark(); }
/// <summary> /// Invoked when a message has failed to process. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { //message failed to process if (context.MessageId == null || !context.MessageId.HasValue) return ReceiveMessagesErrorResult.NoActionPossible; var info = _configuration.TransportConfiguration.RetryDelayBehavior.GetRetryAmount(exception); string exceptionType = null; if (info.ExceptionType != null) { exceptionType = info.ExceptionType.ToString(); } var bSendErrorQueue = false; if (string.IsNullOrEmpty(exceptionType) || info.MaxRetries <= 0) { bSendErrorQueue = true; } else { //determine how many times this exception has been seen for this message var retries = _queryErrorRetryCount.Handle( new GetErrorRetryCountQuery(exceptionType, (long) context.MessageId.Id.Value)); if (retries >= info.MaxRetries) { bSendErrorQueue = true; } else { context.Set(_headers.IncreaseQueueDelay, new SqlQueueDelay(info.Times[retries])); //note zero based index - use the current count not count +1 _commandSetErrorCount.Handle( new SetErrorCountCommand( exceptionType, (long) context.MessageId.Id.Value)); } } if (!bSendErrorQueue) return ReceiveMessagesErrorResult.Retry; _commandMoveRecord.Handle( new MoveRecordToErrorQueueCommand(exception, (long)context.MessageId.Id.Value, context)); //we are done doing any processing - remove the messageID to block other actions context.MessageId = null; _log.ErrorException("Message with ID {0} has failed and has been moved to the error queue", exception, message.MesssageId); return ReceiveMessagesErrorResult.Error; }
/// <summary> /// Invoked when a message has failed to process. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { //message failed to process if (context.MessageId == null || !context.MessageId.HasValue) { return(ReceiveMessagesErrorResult.NoActionPossible); } _dataDataStorage.MoveToErrorQueue(exception, (Guid)context.MessageId.Id.Value, context); //we are done doing any processing - remove the messageID to block other actions context.SetMessageAndHeaders(null, context.Headers); _log.LogError($"Message with ID {message.MessageId} has failed and has been moved to the error queue", exception); return(ReceiveMessagesErrorResult.Error); }
/// <summary> /// Invoked when a message has failed to process. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> /// <returns> /// Result of error processing /// </returns> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { var result = _handler.MessageFailedProcessing(message, context, exception); switch (result) { case ReceiveMessagesErrorResult.Error: _meterError.Mark(); break; case ReceiveMessagesErrorResult.Retry: _meterRetry.Mark(); break; } return result; }
/// <summary> /// Invoked when a message has failed to process. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> /// <returns> /// Result of error processing /// </returns> public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { var result = _handler.MessageFailedProcessing(message, context, exception); switch (result) { case ReceiveMessagesErrorResult.Error: _meterError.Mark(); break; case ReceiveMessagesErrorResult.Retry: _meterRetry.Mark(); break; } return(result); }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception> /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception> public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception) { try { _transportErrorHandler.MessageFailedProcessing(message, context, exception); } catch (Exception errorHandlingError) { _log.ErrorException( "An error has occurred while trying to move message {0} to the error queue", exception, message.MesssageId); throw new DotNetWorkQueueException("An error has occurred in the error handling code", errorHandlingError); } throw new MessageException("An unhanded exception has occurred while processing a message", exception, message.MesssageId, message.CorrelationId); }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="context">The context.</param> /// <param name="exception">The exception.</param> /// <exception cref="DotNetWorkQueueException">An error has occurred in the error handling code</exception> /// <exception cref="MessageException">An unhanded exception has occurred while processing a message</exception> public void Handle(IReceivedMessageInternal message, IMessageContext context, Exception exception) { try { _transportErrorHandler.MessageFailedProcessing(message, context, exception); } catch (Exception errorHandlingError) { _log.ErrorException( "An error has occurred while trying to move message {0} to the error queue", exception, message.MessageId); throw new DotNetWorkQueueException("An error has occurred in the error handling code", errorHandlingError); } throw new MessageException("An unhanded exception has occurred while processing a message", exception, message.MessageId, message.CorrelationId); }
/// <inheritdoc /> public async Task <IReceivedMessageInternal> ReceiveMessageAsync(IMessageContext context) { IReceivedMessageInternal result = null; if (_policyAsync == null) { _policies.Registry.TryGet(_policies.Definition.ReceiveMessageFromTransportAsync, out _policyAsync); } if (_policyAsync != null) { await _policyAsync.ExecuteAsync(async() => result = await _handler.ReceiveMessageAsync(context).ConfigureAwait(false)).ConfigureAwait(false); } else //no policy found { result = await _handler.ReceiveMessageAsync(context).ConfigureAwait(false); } return(result); }
/// <inheritdoc /> public IReceivedMessageInternal ReceiveMessage(IMessageContext context) { IReceivedMessageInternal result = null; if (_policy == null) { _policies.Registry.TryGet(_policies.Definition.ReceiveMessageFromTransport, out _policy); } if (_policy != null) { _policy.Execute(() => result = _handler.ReceiveMessage(context)); } else //no policy found { result = _handler.ReceiveMessage(context); } return(result); }
/// <inheritdoc /> public void Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification) { var spanContext = message.Extract(_tracer, _headers); if (spanContext != null) { using (IScope scope = _tracer.BuildSpan("MessageHandler").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true)) { _handler.Handle(message, workerNotification); } } else { using (IScope scope = _tracer.BuildSpan("MessageHandler").StartActive(finishSpanOnDispose: true)) { _handler.Handle(message, workerNotification); } } }
public void TestCreation() { var fixture = new Fixture().Customize(new AutoNSubstituteCustomization()); IGenerateReceivedMessage gen = fixture.Create <GenerateReceivedMessage>(); var inputMessage = fixture.Create <IMessage>(); inputMessage.Body.Returns(new FakeMessage()); fixture.Inject(inputMessage); IReceivedMessageInternal rec = fixture.Create <ReceivedMessageInternal>(); var message = gen.GenerateMessage(typeof(FakeMessage), rec); IReceivedMessage <FakeMessage> translatedMessage = message; Assert.Equal(translatedMessage.Body, rec.Body); Assert.Equal(translatedMessage.CorrelationId, rec.CorrelationId); Assert.Equal(translatedMessage.Headers, rec.Headers); Assert.Equal(translatedMessage.MessageId, rec.MessageId); }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> /// <returns></returns> public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification) { var spanContext = message.Extract(_tracer, _headers.StandardHeaders); if (spanContext != null) { using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true)) { scope.Span.AddMessageIdTag(message); await _handler.HandleAsync(message, workerNotification); } } else { using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").StartActive(finishSpanOnDispose: true)) { scope.Span.AddMessageIdTag(message); await _handler.HandleAsync(message, workerNotification); } } }
public void GenerateMessage() { var fixture = new Fixture().Customize(new AutoNSubstituteCustomization()); IGenerateReceivedMessage gen = fixture.Create <GenerateReceivedMessage>(); var inputMessage = fixture.Create <IMessage>(); inputMessage.Body.Returns(new FakeMessage()); fixture.Inject(gen); fixture.Inject(inputMessage); var test = fixture.Create <MessageHandlerRegistrationAsync>(); Task Func(IReceivedMessage <FakeMessage> recMessage, IWorkerNotification worker) => null; test.Set((Func <IReceivedMessage <FakeMessage>, IWorkerNotification, Task>)Func); IReceivedMessageInternal rec = fixture.Create <ReceivedMessageInternal>(); var message = test.GenerateMessage(rec); Assert.IsAssignableFrom <FakeMessage>(message.Body); }
private IReceivedMessageInternal ProcessMessage(IReceivedMessageInternal receivedTransportMessage, IConnectionHolder <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> connectionHolder, IMessageContext context, Action <IConnectionHolder <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> > noMessageFoundActon) { //if no message (null) run the no message action and return if (receivedTransportMessage == null) { noMessageFoundActon(connectionHolder); return(null); } //set the message ID on the context for later usage context.SetMessageAndHeaders(receivedTransportMessage.MessageId, receivedTransportMessage.Headers); //we need to update the status table here, as we don't do it as part of the de-queue if (_configuration.Options().EnableStatusTable) { _setStatusCommandHandler.Handle( new SetStatusTableStatusCommand <long>( (long)receivedTransportMessage.MessageId.Id.Value, QueueStatuses.Processing)); } return(receivedTransportMessage); }
/// <summary> /// Handles the specified message. /// </summary> /// <param name="message">The message.</param> /// <param name="workerNotification">The worker notification.</param> /// <returns></returns> public Task Handle(IReceivedMessageInternal message, IWorkerNotification workerNotification) { Guard.NotNull(() => message, message); Guard.NotNull(() => workerNotification, workerNotification); return _messageHandlerRegistration.GetHandler().Invoke(_messageHandlerRegistration.GenerateMessage(message), workerNotification); }
/// <summary> /// Initializes a new instance of the <see cref="RedisMessage" /> class. /// </summary> /// <param name="messageId">The message identifier.</param> /// <param name="message">The message.</param> /// <param name="expired">if set to <c>true</c> [expired].</param> public RedisMessage(string messageId, IReceivedMessageInternal message, bool expired) { MessageId = messageId; Message = message; Expired = expired; }
public ReceiveMessagesErrorResult MessageFailedProcessing(IReceivedMessageInternal message, IMessageContext context, Exception exception) { throw new NotImplementedException(); }