MassTransit store Message retry attempts in memory? - masstransit

Question

MassTransit Retry policy allows us to set retry attempts. At the consumer front, We can get it by calling
context.GetRetryAttempt()
but when consumer application restarts it starts from 0.
and I need it should be started from where it left before the server stops.
As RabbitMQ dead letter exchange help me to achieve it. Code sample attached here. Can I do similar in MassTransit?
public class Consumer<T> : IConsumer<T>
{
private readonly ConsumerConfigOptions _consumerConfigOptions;
private readonly RabbitMqPoc.Interface.IConnectionFactory _connectionFactory;
public event ReceiveMessage<T> ReceiveMessageEvent;
private AckType AckType = AckType.Accept;
private bool IsRequeue = false;
private const string RetryExchange = "RetryExchange";
private const string RetryKeyName = "x-retries";
public Consumer(ConsumerConfigOptions consumerConfigOptions,
RabbitMqPoc.Interface.IConnectionFactory connectionFactory)
{
_connectionFactory = connectionFactory;
_consumerConfigOptions = consumerConfigOptions;
}
public void Consume(string queue)
{
IModel channel = _connectionFactory.GetConnection().CreateModel();
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var header = ea.BasicProperties.Headers;
byte[] body = ea.Body;
try
{
//throw exception here
CheckForAcknowledge(channel,ea);
}
catch (Exception exception)
{
Requeue(channel, ea, body);
}
};
channel.BasicConsume(queue: queue,
autoAck: false,
consumer: consumer);
}
private void Requeue(IModel channel, BasicDeliverEventArgs ea, byte[] body)
{
var header = ea.BasicProperties.Headers;
if (header.ContainsKey(RetryKeyName))
{
SetRetryCount(header, channel, ea, body);
}
else
{
RePublishOnDlx(channel, ea, body, 0);
}
}
private void SetRetryCount(IDictionary<string, object> header, IModel channel, BasicDeliverEventArgs ea, byte[] body)
{
int currentRetryAttempt = (int)header[RetryKeyName] + 1;
if (currentRetryAttempt >= _consumerConfigOptions.RetryAttempts)
{
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
}
else
{
RePublishOnDlx(channel, ea, body, currentRetryAttempt);
}
}
private void RePublishOnDlx(IModel channel, BasicDeliverEventArgs eventArgs, byte[] body, int retryAttempt)
{
IBasicProperties basicProperties = channel.CreateBasicProperties();
basicProperties.Headers = new Dictionary<string, object>
{
{ RetryKeyName, retryAttempt }
};
channel.BasicNack(eventArgs.DeliveryTag, false, false);
channel.BasicPublish(RetryExchange, string.Empty, basicProperties, body);
}
public void Acknowledge(AckType ackType = AckType.Accept, bool isRequeue = false)
{
AckType = ackType;
IsRequeue = isRequeue;
}
private void CheckForAcknowledge(IModel channel, BasicDeliverEventArgs ea)
{
if (AckType == AckType.Accept)
{
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
}
else
{
channel.BasicReject(deliveryTag: ea.DeliveryTag, requeue: IsRequeue);
}
}

Answer 1

You are correct, UseMessageRetry in MassTransit is entirely in-memory. If the retry attempts are exhausted, the message will be moved to the _error queue. If the process exits while retries are pending, the message will be nack'd and stays on the queue. When this happens, and the process restarts, you are right, the retry policy starts from zero — because the original message is still in the queue and no headers can be modified.
If you want, you can redeliver messages with the delayed exchange RabbitMQ plug-in, to perform retries using the broker. The UseScheduledRedelivery filter will do this, once you've configured the delayed exchange plug-in and message scheduler on your bus.
cfg.UseDelayedExchangeMessageScheduler();