private bool CallMessageHandlers(Message message) { var handlerFuncs = _handlerMap.Get(message.GetType()); if (handlerFuncs == null) { return true; } var allHandlersSucceeded = true; foreach (var handlerFunc in handlerFuncs) { var watch = new System.Diagnostics.Stopwatch(); watch.Start(); var thisHandlerSucceeded = handlerFunc(message); allHandlersSucceeded = allHandlersSucceeded && thisHandlerSucceeded; watch.Stop(); Log.Trace("Handled message - MessageType: {0}", message.GetType().Name); _messagingMonitor.HandleTime(watch.ElapsedMilliseconds); } return allHandlersSucceeded; }
public void Publish(Message message) { _client.SendMessage(new SendMessageRequest { MessageBody = GetMessageInContext(message), QueueUrl = Url }); }
private async Task <bool> CallMessageHandler(string queueName, Message message, CancellationToken cancellationToken) { var messageType = message.GetType(); var middleware = _middlewareMap.Get(queueName, messageType); if (middleware == null) { _logger.LogError( "Failed to dispatch. Middleware for message of type '{MessageTypeName}' not found in middleware map.", message.GetType().FullName); return(false); } var watch = System.Diagnostics.Stopwatch.StartNew(); using (_messagingMonitor.MeasureDispatch()) { bool dispatchSuccessful = false; try { var context = new HandleMessageContext(message, messageType, queueName); dispatchSuccessful = await middleware.RunAsync(context, null, cancellationToken) .ConfigureAwait(false); } finally { watch.Stop(); var logMessage = "{Status} handling message with Id '{MessageId}' of type {MessageType} in {TimeToHandle}ms."; if (dispatchSuccessful) { _logger.LogInformation(logMessage, "Succeeded", message.Id, messageType, watch.ElapsedMilliseconds); } else { _logger.LogWarning(logMessage, "Failed", message.Id, messageType, watch.ElapsedMilliseconds); } } return(dispatchSuccessful); } }
private PublishRequest BuildPublishRequest(Message message, PublishMetadata metadata) { var messageToSend = _serializationRegister.Serialize(message, serializeForSnsPublishing: true); var messageType = _messageSubjectProvider.GetSubjectForType(message.GetType()); return(new PublishRequest { TopicArn = Arn, Subject = messageType, Message = messageToSend, MessageAttributes = BuildMessageAttributes(metadata) }); }
private protected override Task <SqsMessagePublisher> CreateSystemUnderTestAsync() { var sqs = new SqsMessagePublisher(new Uri(Url), Sqs, _serializationRegister, Substitute.For <ILoggerFactory>()) { MessageResponseLogger = (r, m) => { _response = r; _message = m; } }; return(Task.FromResult(sqs)); }
private SendMessageRequest BuildSendMessageRequest(Message message) { var request = new SendMessageRequest { MessageBody = GetMessageInContext(message), QueueUrl = Uri?.AbsoluteUri }; if (message.DelaySeconds.HasValue) { request.DelaySeconds = message.DelaySeconds.Value; } return(request); }
private SendMessageRequest BuildSendMessageRequest(Message message, PublishMetadata metadata) { var request = new SendMessageRequest { MessageBody = GetMessageInContext(message), QueueUrl = Uri?.AbsoluteUri, }; if (metadata?.Delay != null) { request.DelaySeconds = (int)metadata.Delay.Value.TotalSeconds; } return(request); }
public void Publish(Message message) { var messageToSend = _serialisationRegister.Serialise(message, serializeForSnsPublishing:true); var messageType = message.GetType().Name; Client.Publish(new PublishRequest { Subject = messageType, Message = messageToSend, TopicArn = Arn }); EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend); }
protected override SqsPublisher CreateSystemUnderTest() { var sqs = new SqsPublisher(RegionEndpoint.EUWest1, QueueName, _sqs, 0, _serialisationRegister, Substitute.For <ILoggerFactory>()) { MessageResponseLogger = (r, m) => { _response = r; _message = m; } }; sqs.ExistsAsync().GetAwaiter().GetResult(); return(sqs); }
protected virtual void Given() { _typedMessage = new OrderAccepted(); _sqsMessage = new SQSMessage { Body = JsonConvert.SerializeObject(_typedMessage), ReceiptHandle = "i_am_receipt_handle" }; _loggerFactory.CreateLogger(Arg.Any <string>()).Returns(_logger); _queue = new DummySqsQueue(new Uri(ExpectedQueueUrl), _amazonSqsClient); _serializationRegister.DeserializeMessage(Arg.Any <string>()).Returns(_typedMessage); }
public void Publish(Message message) { var messageToSend = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message); var messageType = message.GetType().Name; Client.Publish(new PublishRequest { Subject = messageType, Message = messageToSend, TopicArn = Arn }); EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend); }
public void Publish(Message message) { var messageToSend = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message); var messageType = message.GetType().ToKey(); Client.Publish(new PublishRequest { Subject = messageType, Message = messageToSend, TopicArn = Arn }); EventLog.Info("Published message: '{0}' with content {1}", messageType, messageToSend); }
private protected override async Task <SqsPublisher> CreateSystemUnderTestAsync() { var sqs = new SqsPublisher(RegionEndpoint.EUWest1, QueueName, Sqs, 0, _serializationRegister, Substitute.For <ILoggerFactory>()) { MessageResponseLogger = (r, m) => { _response = r; _message = m; } }; await sqs.ExistsAsync(); return(sqs); }
private async Task <bool> CallMessageHandler(string queueName, Message message) { var messageType = message.GetType(); var handler = _handlerMap.Get(queueName, messageType); if (handler == null) { _logger.LogError( "Failed to dispatch. Handler for message of type '{MessageTypeName}' not found in handler map.", message.GetType().FullName); return(false); } var watch = System.Diagnostics.Stopwatch.StartNew(); using (_messagingMonitor.MeasureHandler()) { bool handlerSucceeded = false; try { handlerSucceeded = await handler(message).ConfigureAwait(false); } finally { watch.Stop(); var logMessage = "{Status} handling message with Id '{MessageId}' of type {MessageType} in {TimeToHandle}ms."; if (handlerSucceeded) { _logger.LogInformation(logMessage, "Succeeded", message.Id, messageType, watch.ElapsedMilliseconds); } else { _logger.LogWarning(logMessage, "Failed", message.Id, messageType, watch.ElapsedMilliseconds); } } return(handlerSucceeded); } }
public async Task PublishAsync(Message message) { var request = BuildSendMessageRequest(message); try { await _client.SendMessageAsync(request).ConfigureAwait(false); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}", ex); } }
public void Publish(Message message) { var request = BuildSendMessageRequest(message); try { _client.SendMessage(request); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}", ex); } }
public void Publish(Message message) { var request = BuildPublishRequest(message); try { Client.Publish(request); _eventLog.LogInformation($"Published message: '{request.Subject}' with content {request.Message}"); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}", ex); } }
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken) { if (QueueUrl is null) { throw new PublishException("Queue URL was null, perhaps you need to call `StartAsync` on the `IMessagePublisher` before publishing."); } var request = BuildSendMessageRequest(message, metadata); SendMessageResponse response; try { response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false); } catch (AmazonServiceException ex) { throw new PublishException( $"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}", ex); } using (_logger.BeginScope(new Dictionary <string, object> { ["AwsRequestId"] = response?.MessageId })) { _logger.LogInformation( "Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.", message.Id, message.GetType().FullName, "Queue", request.QueueUrl); } if (MessageResponseLogger != null) { var responseData = new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId, ResponseMetadata = response?.ResponseMetadata }; MessageResponseLogger.Invoke(responseData, message); } }
private async Task <bool> CallMessageHandler(Message message) { var handler = _handlerMap.Get(message.GetType()); if (handler == null) { return(true); } var watch = System.Diagnostics.Stopwatch.StartNew(); var handlerSucceeded = await handler(message).ConfigureAwait(false); watch.Stop(); _log.LogTrace($"Handled message - MessageType: {message.GetType().Name}"); _messagingMonitor.HandleTime(watch.ElapsedMilliseconds); return(handlerSucceeded); }
public async Task PublishAsync(Message message) { var request = new SendMessageRequest { MessageBody = GetMessageInContext(message), QueueUrl = Url }; try { await _client.SendMessageAsync(request); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}", ex); } }
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken) { var request = BuildPublishRequest(message, metadata); PublishResponse response = null; try { response = await Client.PublishAsync(request, cancellationToken).ConfigureAwait(false); } catch (AmazonServiceException ex) { if (!ClientExceptionHandler(ex, message)) { throw new PublishException( $"Failed to publish message to SNS. Topic ARN: '{request.TopicArn}', Subject: '{request.Subject}', Message: '{request.Message}'.", ex); } } using (_logger.BeginScope(new[] { new KeyValuePair <string, object>("AwsRequestId", response?.MessageId) })) { _logger.LogInformation( "Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.", message.Id, message.GetType().Name, "Topic", request.TopicArn); } if (MessageResponseLogger != null) { var responseData = new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId, ResponseMetadata = response?.ResponseMetadata }; MessageResponseLogger.Invoke(responseData, message); } }
public async Task PublishAsync(Message message) { var request = BuildPublishRequest(message); try { await Client.PublishAsync(request).ConfigureAwait(false); _eventLog.LogInformation($"Published message: '{request.Subject}' with content {request.Message}"); } catch (Exception ex) { if (!ClientExceptionHandler(ex)) { throw new PublishException( $"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}", ex); } } }
private async Task <bool> CallMessageHandler(Message message) { var handler = _handlerMap.Get(message.GetType()); if (handler == null) { return(true); } var watch = System.Diagnostics.Stopwatch.StartNew(); var handlerSucceeded = await handler(message).ConfigureAwait(false); watch.Stop(); _logger.LogTrace("Handled message of type {MessageType} in {TimeToHandle}.", message.GetType(), watch.Elapsed); _messagingMonitor.HandleTime(watch.Elapsed); return(handlerSucceeded); }
public void Publish(Message message) { var request = BuildSendMessageRequest(message); try { var response = _client.SendMessage(request); MessageResponseLogger?.Invoke(new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId }, message); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SQS. QueueUrl: {request.QueueUrl} MessageBody: {request.MessageBody}", ex); } }
public async Task PublishAsync(Message message, CancellationToken cancellationToken) { var request = BuildSendMessageRequest(message); try { var response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false); MessageResponseLogger?.Invoke(new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId }, message); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}", ex); } }
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken) { var request = BuildSendMessageRequest(message, metadata); SendMessageResponse response; try { response = await _client.SendMessageAsync(request, cancellationToken).ConfigureAwait(false); } catch (AmazonServiceException ex) { throw new PublishException( $"Failed to publish message to SQS. {nameof(request.QueueUrl)}: {request.QueueUrl},{nameof(request.MessageBody)}: {request.MessageBody}", ex); } using (Logger.BeginScope(new[] { new KeyValuePair <string, object>("AwsRequestId", response?.MessageId) })) { Logger.LogInformation( "Published message {MessageId} of type {MessageType} to {DestinationType} '{MessageDestination}'.", message.Id, message.GetType().Name, "Queue", request.QueueUrl); } if (MessageResponseLogger != null) { var responseData = new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId, ResponseMetadata = response?.ResponseMetadata }; MessageResponseLogger.Invoke(responseData, message); } }
protected virtual void Given() { _typedMessage = new OrderAccepted(); _sqsMessage = new SQSMessage { Body = JsonConvert.SerializeObject(_typedMessage), ReceiptHandle = "i_am_receipt_handle" }; IEnumerable <SQSMessage> GetMessages() { yield return(_sqsMessage); } _queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages())) { Uri = new Uri(ExpectedQueueUrl) }; _serializationRegister.DeserializeMessage(Arg.Any <string>()) .Returns(new MessageWithAttributes(_typedMessage, new MessageAttributes())); }
public async Task PublishAsync(Message message) { var messageToSend = _serialisationRegister.Serialise(message, serializeForSnsPublishing: true); var messageType = message.GetType().Name; var request = new PublishRequest { TopicArn = Arn, Subject = messageType, Message = messageToSend }; try { await Client.PublishAsync(request); _eventLog.LogInformation($"Published message: '{messageType}' with content {messageToSend}"); } catch (Exception ex) { throw new PublishException( $"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}", ex); } }
public async Task PublishAsync(Message message, PublishMetadata metadata, CancellationToken cancellationToken) { var request = BuildPublishRequest(message, metadata); PublishResponse response = null; try { response = await Client.PublishAsync(request, cancellationToken).ConfigureAwait(false); } catch (AmazonServiceException ex) { if (!ClientExceptionHandler(ex, message)) { throw new PublishException( $"Failed to publish message to SNS. Topic ARN: '{request.TopicArn}', Subject: '{request.Subject}', Message: '{request.Message}'.", ex); } } _logger.LogInformation( "Published message: '{SnsSubject}' with content {SnsMessage} and request Id '{SnsRequestId}'", request.Subject, request.Message, response?.ResponseMetadata?.RequestId); if (MessageResponseLogger != null) { var responseData = new MessageResponse { HttpStatusCode = response?.HttpStatusCode, MessageId = response?.MessageId, ResponseMetadata = response?.ResponseMetadata }; MessageResponseLogger.Invoke(responseData, message); } }
private bool ClientExceptionHandler(Exception ex, Message message) => _snsWriteConfiguration?.HandleException?.Invoke(ex, message) ?? false;
private async Task<bool> CallMessageHandlers(Message message) { var handlerFuncs = _handlerMap.Get(message.GetType()); if ((handlerFuncs == null) || (handlerFuncs.Count == 0)) { return true; } bool allHandlersSucceeded; var watch = System.Diagnostics.Stopwatch.StartNew(); if (handlerFuncs.Count == 1) { // a shortcut for the usual case allHandlersSucceeded = await handlerFuncs[0](message).ConfigureAwait(false); } else { var handlerTasks = handlerFuncs.Select(func => func(message)); var handlerResults = await Task.WhenAll(handlerTasks).ConfigureAwait(false); allHandlersSucceeded = handlerResults.All(x => x); } watch.Stop(); Log.Trace("Handled message - MessageType: {0}", message.GetType().Name); _messagingMonitor.HandleTime(watch.ElapsedMilliseconds); return allHandlersSucceeded; }
public Task PublishAsync(Message message, CancellationToken cancellationToken) => PublishAsync(message, null, cancellationToken);
public string GetMessageInContext(Message message) { return _serialisationRegister.Serialise(message, serializeForSnsPublishing: false); }
private string GetMessageInContext(Message message) { var serializedMessage = _serialisationRegister.GeTypeSerialiser(message.GetType()).Serialiser.Serialise(message); var context = new { Subject = message.GetType().ToKey(), Message = serializedMessage }; return JsonConvert.SerializeObject(context); }
private async Task UpdateMessageVisibilityTimeout(SQSMessage message, string receiptHandle, Message typedMessage, Exception lastException) { if (TryGetApproxReceiveCount(message.Attributes, out int approxReceiveCount)) { var visibilityTimeout = _messageBackoffStrategy.GetBackoffDuration(typedMessage, approxReceiveCount, lastException); var visibilityTimeoutSeconds = (int)visibilityTimeout.TotalSeconds; var visibilityRequest = new ChangeMessageVisibilityRequest { QueueUrl = _queue.Uri.AbsoluteUri, ReceiptHandle = receiptHandle, VisibilityTimeout = visibilityTimeoutSeconds }; try { await _queue.Client.ChangeMessageVisibilityAsync(visibilityRequest).ConfigureAwait(false); } catch (AmazonServiceException ex) { _logger.LogError(0, ex, "Failed to update message visibility timeout by {VisibilityTimeout} seconds.", visibilityTimeoutSeconds); _onError(ex, message); } } }
public string GetMessageInContext(Message message) => _serialisationRegister.Serialise(message, serializeForSnsPublishing: false);
public Task PublishAsync(Message message) => PublishAsync(message, CancellationToken.None);