How can I isolate local and Cloud Run Pub/Sub subscriptions for debugging in Spring Boot 3?

I'm developing a Spring Boot 3 application that interacts with several GCP Pub/Sub subscriptions (P1, P2, P3, etc.) to perform distinct tasks. I have a single instance of each subscription, and both my Cloud Run deployment and my local instance are configured to subscribe to the same topics.

When I debug locally (publishing messages from my local instance), the Cloud Run instance picks up the messages instead of the local one, making debugging challenging. I considered creating an endpoint to programmatically disable or enable the subscription on Cloud Run during local debugging but couldn’t find support for that.

My main question is: Is there any way to ensure that, if my local instance publishes a message, it will also be the one to subscribe to the response, rather than having Cloud Run process it? Alternatively, what are the best options to separate local debugging from production processing?

Below is my existing code setup:

JAVACopied
@Configuration
public class PubSubSubscriberConfig {
    @Value("${metadata.response.pubsub.subscriber.name}")
    private String metadataResponseSubscription;

    @Value("${prep.response.pubsub.subscriber.name}")
    private String downloadPrepResponseSubscription;

    @Value("${download.response.pubsub.subscriber.name}")
    private String downloadResponseSubscription;

    @Value("${conversion.response.pubsub.subscriber.name}")
    private String conversionResponseSubscription;

    @Value("${operation.id.response.pubsub.subscriber.name}")
    private String operationIdResponseSubscription;

    @Value("${response.pubsub.subscriber.name}")
    private String responseSubscription;

  
    @Bean("metadataResponseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber metadataResponseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(metadataResponseSubscription, pubSubTemplate);
    }

    @Bean("downloadPrepResponseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber DownloadPrepResponseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(downloadPrepResponseSubscription, pubSubTemplate);
    }

    @Bean("downloadResponseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber DownloadResponseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(downloadResponseSubscription, pubSubTemplate);
    }

    @Bean("conversionResponseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber flacConversionResponseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(conversionResponseSubscription, pubSubTemplate);
    }

    @Bean("operationIdResponseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber operationIdResponseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(operationIdResponseSubscription, pubSubTemplate);
    }

    @Bean("responseSubscriber")
    @Profile("!h2 & !test")
    public MessageSubscriber responseSubscriber(PubSubTemplate pubSubTemplate) {
        return new GcpSubscriber(responseSubscription, pubSubTemplate);
    }


public interface MessageSubscriber {

    void subscribe(Consumer<String> messageProcessor);

}


@Slf4j
public class GcpSubscriber implements MessageSubscriber {

    private final PubSubTemplate pubSubTemplate;
    private final String subscriptionName;

    public GcpSubscriber(String subscriptionName, PubSubTemplate pubSubTemplate) {
        this.subscriptionName = subscriptionName;
        this.pubSubTemplate = pubSubTemplate;
    }

    @Override
    public void subscribe(Consumer<String> messageProcessor) {
        pubSubTemplate.subscribe(subscriptionName, message -> {
            String payload = message.getPubsubMessage().getData().toStringUtf8();
            try {
                messageProcessor.accept(payload);
                message.ack();
                log.info("Message acknowledged with payload {}", payload);
            } catch (Exception e) {
                log.error("Error {} while processing message with payload {}", e, payload);
                message.nack();
            }
        });
    }
}

Additionally, I have several handler classes that process specific subscription messages. For example:

JAVACopied
@Component
@Slf4j
public class ConversionResponseHandler {

    // fields and constructor

    @PostConstruct
    public void startListening() {
        conversionResponseSubscriber.subscribe(this::handleMessage);
    }
    
    public void handleMessage(String payload) {
        try {
            ConversionResponse conversionResponse = objectMapper.readValue(payload, ConversionResponse.class);
            log.info("Received flac conversion response: {}", conversionResponse);

           // business logic

        } catch (JsonProcessingException e) {
            log.error("Failed to process response payload", e);
        }
    }
}

Below is my pom configuration:

XMLCopied
<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.google.cloud</groupId>
                <artifactId>spring-cloud-gcp-dependencies</artifactId>
                <version>5.5.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
</dependencyManagement>


<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>spring-cloud-gcp-starter-pubsub</artifactId>
</dependency>

I’m looking for alternative strategies or recommended approaches to ensure that the local instance exclusively handles the debug messages without interference from the Cloud Run instance. Thanks!