LEGLINK-186: Fail fast on Validation blob calls so the retry-topic ladder owns retrying

Mirrors the MeasureEval resource-cache change: the Validation blob client
(bundle download and pre-qual append, both on the consumer path) used the
Azure SDK's default retry policy, hiding minutes of silent retrying inside
every consumer attempt during an ABS outage while blocking the single-
threaded consumer executor.

The client now uses a fail-fast policy: FIXED, maxTries=2, tryTimeout=10s,
1s delay, configurable via internal-blob-storage.max-tries /
.try-timeout-seconds. Measured live with azurite stopped: attempt latency
dropped to 5.1s, and the first retry rung after azurite's restart
completed validation and produced ValidationComplete (33s outage-to-
recovery total).

Claude-Session: https://claude.ai/code/session_01KN565tFAuJUAEkK2DdRF1e

Author: arianamihailescu

Java/validation/src/main/java/com/lantanagroup/link/validation/configs/BlobStorageConfig.java

@@ -1,5 +1,7 @@
 package com.lantanagroup.link.validation.configs;
 
+import com.azure.storage.common.policy.RequestRetryOptions;
+import com.azure.storage.common.policy.RetryPolicyType;
 import com.lantanagroup.link.validation.services.BlobStorageService;
 import lombok.Getter;
 import lombok.Setter;
@@ -8,6 +10,8 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
+import java.time.Duration;
+
 @Getter
 @Setter
 @Configuration
@@ -16,11 +20,38 @@ public class BlobStorageConfig {
     private String connectionString;
     private String blobContainerName;
 
+    /**
+     * Azure SDK in-process tries per blob call (initial call + quick retries). This client is used
+     * entirely on the consumer path — the bundle download and the pre-qual append both run inside
+     * process() — where the Kafka retry-topic ladder owns real retrying. The SDK default of 4
+     * exponential tries hid minutes of silent retrying inside every consumer attempt while blocking
+     * the single-threaded consumer executor.
+     */
+    private int maxTries = 2;
+
+    /** Cap on a single network attempt; the SDK default is effectively unbounded. */
+    private int tryTimeoutSeconds = 10;
+
     @Bean
     public BlobStorageService blobStorageService() {
         if (StringUtils.isAnyEmpty(connectionString, blobContainerName)) {
             return null;
         }
-        return new BlobStorageService(connectionString, blobContainerName);
+        return new BlobStorageService(connectionString, blobContainerName, buildRetryOptions());
+    }
+
+    /**
+     * Fail-fast policy: an ABS outage should surface as a quick failure the retry-topic ladder
+     * handles visibly (log lines, attempt headers, dead-lettering), not as silent in-SDK retrying.
+     * Package-private so the test pins the exact values.
+     */
+    RequestRetryOptions buildRetryOptions() {
+        return new RequestRetryOptions(
+                RetryPolicyType.FIXED,
+                maxTries,
+                Duration.ofSeconds(tryTimeoutSeconds),
+                Duration.ofSeconds(1),
+                Duration.ofSeconds(1),
+                null);
     }
 }

Java/validation/src/main/java/com/lantanagroup/link/validation/services/BlobStorageService.java

@@ -6,16 +6,18 @@
 import com.azure.storage.blob.BlobServiceClient;
 import com.azure.storage.blob.BlobServiceClientBuilder;
 import com.azure.storage.blob.specialized.AppendBlobClient;
+import com.azure.storage.common.policy.RequestRetryOptions;
 
 import java.io.ByteArrayInputStream;
 import java.nio.charset.StandardCharsets;
 
 public class BlobStorageService {
     private final BlobContainerClient containerClient;
 
-    public BlobStorageService(String connectionString, String blobContainerName) {
+    public BlobStorageService(String connectionString, String blobContainerName, RequestRetryOptions retryOptions) {
         BlobServiceClient serviceClient = new BlobServiceClientBuilder()
                 .connectionString(connectionString)
+                .retryOptions(retryOptions)
                 .buildClient();
         containerClient = serviceClient.getBlobContainerClient(blobContainerName);
     }

Java/validation/src/test/java/com/lantanagroup/link/validation/configs/BlobStorageConfigTest.java

@@ -0,0 +1,40 @@
+package com.lantanagroup.link.validation.configs;
+
+import com.azure.storage.common.policy.RequestRetryOptions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * The validation blob client is used entirely on the consumer path (the bundle download and the
+ * pre-qual append both run inside process()), where the Kafka retry-topic ladder owns retrying.
+ * The Azure SDK's default policy (4 exponential tries, effectively unbounded per-try timeout) hides
+ * minutes of silent retrying inside every consumer attempt during an ABS outage while blocking the
+ * single-threaded consumer executor. These tests pin the fail-fast policy handed to the builder.
+ */
+class BlobStorageConfigTest {
+
+    @Test
+    void retryOptions_failFast_defaults() {
+        BlobStorageConfig config = new BlobStorageConfig();
+
+        RequestRetryOptions options = config.buildRetryOptions();
+
+        assertEquals(2, options.getMaxTries(),
+                "one quick in-process retry absorbs a dropped connection; anything more belongs to the ladder");
+        assertEquals(10, options.getTryTimeoutDuration().toSeconds(),
+                "each network attempt must be capped, not left to the SDK's effectively unbounded default");
+    }
+
+    @Test
+    void retryOptions_areConfigurable() {
+        BlobStorageConfig config = new BlobStorageConfig();
+        config.setMaxTries(1);
+        config.setTryTimeoutSeconds(5);
+
+        RequestRetryOptions options = config.buildRetryOptions();
+
+        assertEquals(1, options.getMaxTries());
+        assertEquals(5, options.getTryTimeoutDuration().toSeconds());
+    }
+}