RPC vs direct API calls in RabbitMQ - Performance Comparison

Time Complexity: RPC vs direct API calls

O(n)

Understanding Time Complexity

We want to understand how the time it takes to get a response changes when using RPC with RabbitMQ compared to direct API calls.

How does the number of steps grow as more requests are made?

Scenario Under Consideration

Analyze the time complexity of the following RabbitMQ RPC client code snippet.

// RPC client sends request and waits for reply
channel.assertQueue('', { exclusive: true }, (err, q) => {
  const correlationId = generateUuid();
  channel.consume(q.queue, (msg) => {
    if (msg.properties.correlationId === correlationId) {
      // process reply
    }
  }, { noAck: true });
  channel.sendToQueue('rpc_queue', Buffer.from('request'), {
    correlationId: correlationId,
    replyTo: q.queue
  });
});

This code sends a request message to a queue and waits for a matching reply using a correlation ID.

Identify Repeating Operations

Look for repeated actions that affect time.

• Primary operation: Sending a request and waiting for a reply message.
• How many times: Once per request; each request involves sending and receiving one message.

How Execution Grows With Input

Each request requires one send and one receive operation.

Input Size (n)	Approx. Operations
10	20 (10 sends + 10 receives)
100	200 (100 sends + 100 receives)
1000	2000 (1000 sends + 1000 receives)

Pattern observation: The total operations grow linearly with the number of requests.

Final Time Complexity

Time Complexity: O(n)

This means the time to handle requests grows directly in proportion to how many requests you make.

Common Mistake

[X] Wrong: "RPC calls are instant and do not add extra time compared to direct API calls."

[OK] Correct: RPC involves sending and receiving messages through a broker, which adds communication steps and time for each request.

Interview Connect

Understanding how RPC scales helps you explain system behavior and choose the right communication method in real projects.

Self-Check

What if we batch multiple requests into one RPC call? How would the time complexity change?