How AckReplyConsumer.ack() works in Pub/Sub by using a client library

Question

I have small query regarding internal working of Pub/Sub's client library.

Here is sample subscriber code I copied from google documentation

import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SubscribeAsyncExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String subscriptionId = "your-subscription-id";

    subscribeAsyncExample(projectId, subscriptionId);
  }

  public static void subscribeAsyncExample(String projectId, String subscriptionId) {
    ProjectSubscriptionName subscriptionName =
        ProjectSubscriptionName.of(projectId, subscriptionId);

    // Instantiate an asynchronous message receiver.
    MessageReceiver receiver =
        new MessageReceiver() {
          @Override
          public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
            // Handle incoming message, then ack the received message.
            System.out.println("Id: " + message.getMessageId());
            System.out.println("Data: " + message.getData().toStringUtf8());
            consumer.ack();
          }
        };

    Subscriber subscriber = null;
    try {
      subscriber = Subscriber.newBuilder(subscriptionName, receiver).build();
      // Start the subscriber.
      subscriber.startAsync().awaitRunning();
      System.out.printf("Listening for messages on %s:\n", subscriptionName.toString());
      // Allow the subscriber to run for 30s unless an unrecoverable error occurs.
      subscriber.awaitTerminated(30, TimeUnit.SECONDS);
    } catch (TimeoutException timeoutException) {
      // Shut down the subscriber after 30s. Stop receiving messages.
      subscriber.stopAsync();
    }
  }
}

Now lets assume I change my MessageReceiver receiver

MessageReceiver receiver =
    new MessageReceiver() {
      @Override
      public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
         consumer.ack();
         // Some lengthy processing like calling Download file from GCS bucket,Calling Web service etc
      }
};

Based on my change I have below question

1. When does client library informs Pub Sub service that message is acknowledged ? Does it waits for completion of entire code inside receiveMessage or it informs immediately it see consumer.ack() step ?
2. What should be best practice for handling such scenarios (i.e. Where we have to perform lots of message processing before acknowledgment) ?

I searched on google documentation pubsub but could not find correct answer for this acknowledgment confusion.

Answer 1

You should not acknowledge a message until you have finished processing it. There is no guarantee that all of the code in receiveMessage will run before the ack is sent back to the server once you have called consumer.ack(). When you make that call, the acknowledgement is immediately a candidate to be sent back to the server asynchronously.