Message acknowledgment in RabbitMQ - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output when a message is acknowledged in RabbitMQ?

You have a consumer that receives a message from a queue and sends a manual acknowledgment using channel.basicAck(deliveryTag, false). What happens to the message in the queue?

A The message is moved to a dead-letter queue automatically.

B The message remains in the queue but is marked as acknowledged.

C The message is removed from the queue and will not be delivered again.

D The message is duplicated and sent to all consumers.

💡 Hint

Think about what acknowledgment means in message queues.

When a message is acknowledged, RabbitMQ removes it from the queue so it won't be delivered again.

🧠 Conceptual

intermediate

Which RabbitMQ setting controls automatic message acknowledgment?

In RabbitMQ, which consumer setting determines if messages are acknowledged automatically upon delivery?

A prefetchCount set to 1

B autoAck (or noAck) flag set to true

C durable flag set to true

D exclusive flag set to true

💡 Hint

Look for the flag that controls acknowledgment behavior.

The autoAck (or noAck) flag controls whether messages are acknowledged automatically when delivered.

❓ Troubleshoot

advanced

Why are messages re-delivered repeatedly despite manual acknowledgment?

A consumer uses manual acknowledgment but messages keep reappearing in the queue after processing. What is the most likely cause?

A The consumer never calls <code>basicAck</code> after processing messages.

B The queue is set to durable, causing message duplication.

C The prefetch count is set too high, causing message overflow.

D The consumer uses <code>autoAck=true</code> instead of manual acknowledgment.

💡 Hint

Think about what happens if acknowledgment is not sent.

If the consumer does not send basicAck, RabbitMQ assumes the message was not processed and re-delivers it.

🔀 Workflow

advanced

Order the steps for manual message acknowledgment in RabbitMQ

Arrange the following steps in the correct order for a consumer to manually acknowledge a message:

A 3,1,2,4

B 1,3,2,4

C 2,1,3,4

D 1,2,3,4

💡 Hint

Think about receiving, processing, then acknowledging.

The consumer must first receive the message, then process it, then acknowledge it, and finally wait for the next message.

✅ Best Practice

expert

What is the best practice for handling message acknowledgment to avoid message loss?

Which approach best prevents message loss in RabbitMQ when processing messages?

A Use manual acknowledgment and only call basicAck after successful processing

B Use automatic acknowledgment to speed up processing

C Acknowledge messages before processing to avoid duplicates

D Disable acknowledgments and rely on queue durability

💡 Hint

Consider when to acknowledge messages to ensure they are processed safely.

Manual acknowledgment after successful processing ensures messages are not lost or prematurely removed.

Practice

1. What is the main purpose of message acknowledgment in RabbitMQ?

easy

A. To confirm that a message was received and processed successfully

B. To delete the message queue permanently

C. To create a new message exchange

D. To encrypt messages before sending

Solution

1. Step 1: Understand message acknowledgment role

   Message acknowledgment tells RabbitMQ that the consumer has processed the message successfully.

2. Step 2: Identify the purpose from options

   Only To confirm that a message was received and processed successfully describes confirming message processing, which prevents message loss.

3. Final Answer:

   To confirm that a message was received and processed successfully -> Option A

4. Quick Check:

   Message acknowledgment = Confirm processing [OK]

Hint: Acknowledgment means confirming message processed [OK]

Common Mistakes:

• Confusing acknowledgment with queue deletion
• Thinking acknowledgment creates exchanges
• Assuming acknowledgment encrypts messages

2. Which RabbitMQ client method is used to acknowledge a message after processing?

easy

A. basic_reject

B. basic_publish

C. basic_consume

D. basic_ack

Solution

1. Step 1: Recall RabbitMQ acknowledgment method

   The method to acknowledge a message is basic_ack, which confirms message processing.

2. Step 2: Match method to options

   Only basic_ack matches the acknowledgment method; others are for publishing, consuming, or rejecting.

3. Final Answer:

   basic_ack -> Option D

4. Quick Check:

   basic_ack = acknowledge message [OK]

Hint: Use basic_ack to confirm message processed [OK]

Common Mistakes:

• Using basic_publish to acknowledge
• Confusing basic_consume with acknowledgment
• Mistaking basic_reject as acknowledgment

3. Given this Python snippet using pika:

channel.basic_consume(queue='task_queue', on_message_callback=callback, auto_ack=False)

def callback(ch, method, properties, body):
    print(f"Received {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

What will happen if basic_ack is not called inside callback?

medium

A. Messages will be lost after delivery

B. Messages will be automatically acknowledged

C. Messages will be requeued and redelivered

D. The queue will be deleted

Solution

1. Step 1: Understand auto_ack=False effect

   With auto_ack=False, messages must be manually acknowledged or they stay unacknowledged.

2. Step 2: Consequence of missing basic_ack

   If basic_ack is not called, RabbitMQ will requeue the message and redeliver it to consumers.

3. Final Answer:

   Messages will be requeued and redelivered -> Option C

4. Quick Check:

   No ack + auto_ack=False = redelivery [OK]

Hint: No ack with auto_ack false causes redelivery [OK]

Common Mistakes:

• Assuming messages are lost without ack
• Thinking messages auto-acknowledge without basic_ack
• Believing queue deletes on missing ack

4. You wrote this callback in Python with pika:

def callback(ch, method, properties, body):
    print(f"Processing {body}")
    ch.basic_ack(delivery_tag=method.delivery_tag + 1)

What is the problem with this acknowledgment call?

medium

A. The delivery tag is incorrect, causing ack failure

B. basic_ack does not accept delivery_tag parameter

C. The callback function is missing required parameters

D. basic_ack should be called before processing the message

Solution

1. Step 1: Check delivery_tag usage

   The delivery tag must match the exact tag from method.delivery_tag to acknowledge the correct message.

2. Step 2: Identify error in delivery_tag calculation

   Adding 1 to the delivery tag sends an invalid tag, so RabbitMQ will not acknowledge the message properly.

3. Final Answer:

   The delivery tag is incorrect, causing ack failure -> Option A

4. Quick Check:

   delivery_tag must match exactly [OK]

Hint: Use exact delivery_tag value for ack [OK]

Common Mistakes:

• Modifying delivery_tag before ack
• Thinking basic_ack lacks delivery_tag parameter
• Calling ack before processing message

5. You want to ensure that if your consumer crashes before acknowledging, the message is redelivered. Which combination of settings and code achieves this safely?

hard

A. Set auto_ack=True and call basic_ack in callback

B. Set auto_ack=False and call basic_ack with correct delivery_tag after processing

C. Set auto_ack=False and never call basic_ack

D. Set auto_ack=True and never call basic_ack

Solution

1. Step 1: Understand auto_ack impact on message safety

   Setting auto_ack=True acknowledges messages immediately, risking message loss if consumer crashes.

2. Step 2: Use manual acknowledgment for safe processing

   Setting auto_ack=False and calling basic_ack after processing ensures messages are only removed after success.

3. Step 3: Confirm correct delivery_tag usage

   Calling basic_ack with the exact delivery tag confirms the message was processed and prevents redelivery.

4. Final Answer:

   Set auto_ack=False and call basic_ack with correct delivery_tag after processing -> Option B

5. Quick Check:

   Manual ack + correct tag = safe redelivery [OK]

Hint: Use manual ack with correct tag for safe redelivery [OK]

Common Mistakes:

• Using auto_ack=True for critical messages
• Not calling basic_ack at all
• Calling basic_ack with wrong delivery_tag