Spring rabbitmq retry message delivery not working - spring

Question

I am setting PubSub using RabbitMQ, so whenever there is some failure in message processing a negative acknowledgement is sent in Listener, ideally retry should be done after some preconfigured time interval but retries are done continuously for each second till time of message-ttl value. For retry added created Advice chain in SimpleMessageListenerContainer. Queues and consumers are created dynamically depending on subscription. Below is code for rabbitmq service
#Service
public class RabbitMQQueueServiceImpl {
private final String JAVA_OBJECT_SERIALIZER_HEADER_NAME = "Content-Type";
private final String JAVA_OBJECT_SERIALIZER_HEADER_VALUE = "application/x-java-serialized-object";
private final String TIME_TO_LIVE_HEADER_NAME = "x-message-ttl";
#Value("${rabbitmq.message.timetolive}")
private Long messageTimeToLive;
#Value("${rabbitmq.host}")
private String host;
#Value("${rabbitmq.username}")
private String userName;
#Value("${rabbitmq.password}")
private String password;
#Value("${rabbitmq.port}")
private Integer port;
private RabbitTemplate rabbitTemplate;
#PostConstruct
public void init() {
createRabitTemplate();
}
public void subscribe(WebHookSubscription webHookSubscription,String queueName) throws Exception {
createProducer(webHookSubscription,queueName);
createConsumer(webHookSubscription,queueName);
}
public void publish(PublishEvent publishEvent,String queueName) {
//Append eventId for queueName and exchange name as accountId_accountTypeId
String exchange = queueName;
queueName = queueName+"_"+publishEvent.getEventId();
BroadcastMessageBean broadcastMessageBean = new BroadcastMessageBean();
/*
* Set properties for message - message persistence, JAVA object serializer
*/
MessageProperties messageProperties = new MessageProperties();
messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
messageProperties.setHeader(JAVA_OBJECT_SERIALIZER_HEADER_NAME, JAVA_OBJECT_SERIALIZER_HEADER_VALUE);
BeanUtils.copyProperties(publishEvent, broadcastMessageBean);
Gson gson = new Gson();
Message messageBean = new Message(gson.toJson(broadcastMessageBean).getBytes(), messageProperties);
rabbitTemplate.send(exchange, publishEvent.getEventId().toString(), messageBean);
}
public void createQueue(String queueName) {
RabbitTemplate rabbitTemplate = getRabbitTemplate(queueName);
RabbitAdmin rabbitAdmin = new RabbitAdmin(rabbitTemplate.getConnectionFactory());
Queue queue = new Queue(queueName, true,false,false);
rabbitAdmin.declareQueue(queue);
}
private void createProducer(WebHookSubscription webHookSubscription, String queueName) {
queueName = queueName+"_"+webHookSubscription.getEventId();
RabbitAdmin rabbitAdmin = new RabbitAdmin(rabbitTemplate.getConnectionFactory());
String exchangeName = webHookSubscription.getAccountId()+"_"+webHookSubscription.getAccountTypeId();
String routingKey = webHookSubscription.getEventId().toString();
Map<String, Object> arguments = new HashMap<String, Object>();
arguments.put(TIME_TO_LIVE_HEADER_NAME, messageTimeToLive);
Queue queue = new Queue(queueName, true,false,false, arguments );
rabbitAdmin.declareQueue(queue);
Exchange exchange = new TopicExchange(exchangeName, true, false) ;
rabbitAdmin.declareExchange(exchange );
Binding binding = new Binding(queueName, DestinationType.QUEUE, exchangeName, routingKey, arguments);
rabbitAdmin.declareBinding(binding );
}
private void createConsumer(WebHookSubscription webHookSubscription,String queueName) throws Exception {
Map<String, String> headers = new HashMap<String, String>();
//Create exchange name same as queue name and append eventId to queueName for each event subscription for account
queueName = queueName+"_"+webHookSubscription.getEventId();
for(WebHookSubscriptionHeaders header : webHookSubscription.getWebHookHeaders()) {
headers.put(header.getName(), header.getValue());
}
/*
* Register consumer through SimpleMessageListenerContainer
* add consumer handler with eventId
*/
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
container.setPrefetchCount(10);
container.setRecoveryInterval(1000);
ConsumerHandler consumerHandler = new ConsumerHandler(webHookSubscription.getEventId(),
webHookSubscription.getWebHookURL(),headers, webHookSubscription.getNotificationEmail());
container.setConnectionFactory(connectionFactory());
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
container.setAdviceChain(new Advice[]{retryAdvice()});
/*
* Register consumer to queue and all messages will be broadcasted to subscriber specific queue
*/
container.setQueues(new Queue(queueName,true,false,false));
container.setMessageListener(consumerHandler);
container.start();
}
private MethodInterceptor retryAdvice() {
ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(15000);
backOffPolicy.setMultiplier(100);
backOffPolicy.setMaxInterval(604800);
return RetryInterceptorBuilder.stateless().backOffPolicy(backOffPolicy).maxAttempts(5).recoverer(new RejectAndDontRequeueRecoverer()).build();
}
/**
* Create Connection factory for RabbitMQ template
* #return
*/
private CachingConnectionFactory connectionFactory() {
CachingConnectionFactory connectionFactory = new CachingConnectionFactory(getHost());
connectionFactory.setUsername(getUserName());
connectionFactory.setPassword(getPassword());
connectionFactory.setPort(getPort());
return connectionFactory;
}
private RabbitTemplate createRabitTemplate() {
rabbitTemplate = new RabbitTemplate(connectionFactory());
rabbitTemplate.setMessageConverter(new JsonMessageConverter());
//Create retries configuration for message delivery
/*RetryTemplate retryTemplate = new RetryTemplate();
ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(messageRetriesInitialInterval);
backOffPolicy.setMaxInterval(messageRetriesMaxInterval);
backOffPolicy.setMultiplier(messageRetriesMultiplier);
retryTemplate.setBackOffPolicy(backOffPolicy);
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
retryPolicy.setMaxAttempts(retries);
retryTemplate.setRetryPolicy(retryPolicy);
//Retries configuration ends here
rabbitTemplate.setRetryTemplate(retryTemplate);*/
return rabbitTemplate;
}
}
This is for consumer handler
public class ConsumerHandler implements ChannelAwareMessageListener {
public ConsumerHandler(Long eventId, String url, Map<String, String> headers, String email) {
this.eventId = eventId;
this.url = url;
this.headers = headers;
this.email = email;
}
#Override
public void onMessage(Message message, Channel channel) throws IOException, NoSuchAlgorithmException {
//process message body
if(error){
channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
return;
}
//for success
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}
}
What is missing in above code to make retry work?
logs:
2016-02-23 16:34:09 DEBUG [org.springframework.amqp.rabbit.listener.BlockingQueueConsumer] - <Storing delivery for Consumer: tags=[{amq.ctag-a1IonIIN7mf8uhIGXE4eIw=14947_0_4}], channel=Cached Rabbit Channel: AMQChannel(amqp://guest#127.0.0.1:5672/,1), acknowledgeMode=MANUAL local queue size=0>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.interceptor.StatefulRetryOperationsInterceptor] - <Exiting proxied method in stateful retry with result: (null)>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.interceptor.StatefulRetryOperationsInterceptor] - <Exiting proxied method in stateful retry with result: (null)>
2016-02-23 16:34:09 DEBUG [org.springframework.amqp.rabbit.listener.BlockingQueueConsumer] - <Retrieving delivery for Consumer: tags=[{amq.ctag-a1IonIIN7mf8uhIGXE4eIw=14947_0_4}], channel=Cached Rabbit Channel: AMQChannel(amqp://guest#127.0.0.1:5672/,1), acknowledgeMode=MANUAL local queue size=1>
2016-02-23 16:34:09 DEBUG [org.springframework.amqp.rabbit.listener.BlockingQueueConsumer] - <Received message: (Body:'[B#4109b410(byte[199])'MessageProperties [headers={eventId=4, retry=1, Content-Type=application/x-java-serialized-object}, timestamp=null, messageId=31b93494-d6ef-4d63-b90b-c7a7e73acb70, userId=null, appId=null, clusterId=null, type=null, correlationId=null, replyTo=null, contentType=application/octet-stream, contentEncoding=null, contentLength=0, deliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=true, receivedExchange=14947_0, receivedRoutingKey=4, deliveryTag=10234, messageCount=0])>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.interceptor.StatefulRetryOperationsInterceptor] - <Executing proxied method in stateful retry: public abstract void org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$ContainerDelegate.invokeListener(com.rabbitmq.client.Channel,org.springframework.amqp.core.Message) throws java.lang.Exception(27f49de4)>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.support.RetryTemplate] - <Retry: count=0>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.interceptor.StatefulRetryOperationsInterceptor] - <Executing proxied method in stateful retry: public abstract void org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer$ContainerDelegate.invokeListener(com.rabbitmq.client.Channel,org.springframework.amqp.core.Message) throws java.lang.Exception(27f49de4)>
2016-02-23 16:34:09 DEBUG [org.springframework.retry.support.RetryTemplate] - <Retry: count=0>

Answer 1

There is no direct way to ensure delayed retry.
You may have to create a Dead letter exchange and create a retryQueue on that exchange with the message ttl set to the the delay interval you want.
Your main queue should look something like this
#Bean
public Queue mainQueue() {
Map<String, Object> args = new HashMap<>();
args.put("x-dead-letter-exchange", "retryExchangeName");
return new Queue("mainQueue", true, false, false, args);
}
and retry Queue
#Bean
public Queue retryQueue() {
Map<String, Object> args = new HashMap<>();
args.put("x-dead-letter-exchange", "mainExchangeName");
args.put("x-message-ttl", RETRY_MESSAGE_TTL);
return new Queue("retryQueue", true, false, false, args);
}
now for the messages you want a delayed retry Nack them with requeue=false
channel().basicNack(10, false, false);
now this message will be sent to retryQueue and after the specified ttl it will be put back to the mainQueue for reprocessing.