perf: cache BlobServiceClient per connection instead of BlobContainerClient per container

Refactors BaseBlobHydrator to cache BlobServiceClient (which holds the HTTP
pipeline) keyed by connection env var name, instead of caching individual
BlobContainerClient objects keyed by connection+container. This means all
containers under the same storage account share a single HTTP pipeline.

Before: Each unique container built its own pipeline (~100-200ms each)
After: One pipeline per connection, container/blob clients derived for free

Cache reduced from LRU-32 (BlobContainerClient) to LRU-8 (BlobServiceClient).

Author: ahmedmuhsin

azure-functions-java-sdktypes/src/main/java/com/microsoft/azure/functions/sdktype/blob/BaseBlobHydrator.java

@@ -10,6 +10,9 @@
 import com.microsoft.azure.functions.sdktype.exceptions.SdkHydrationException;
 
 import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.logging.Logger;
 
 /**
@@ -20,10 +23,33 @@
  * This class implements the Template Method pattern, where the overall algorithm
  * structure is defined in createInstance(), but specific steps are delegated to
  * subclass implementations.
+ * 
+ * Maintains an internal cache of BlobServiceClient objects keyed by the connection
+ * environment variable name. Since BlobServiceClient holds the HttpPipeline (HTTP
+ * client, retry policies, auth), caching at this level means all containers and
+ * blobs under the same storage account share a single pipeline. Deriving
+ * BlobContainerClient and BlobClient from a BlobServiceClient is free — just URL
+ * construction, no new HTTP connections.
  */
 public abstract class BaseBlobHydrator<T extends BlobMetaData> implements SdkTypeHydrator<T> {
     protected static final Logger LOGGER = Logger.getLogger(BaseBlobHydrator.class.getName());
 
+    /** Max number of cached BlobServiceClient instances (keyed by connection env var). */
+    private static final int MAX_SERVICE_CLIENTS = 8;
+
+    /**
+     * LRU cache of BlobServiceClient objects, keyed by the connection environment
+     * variable name (e.g. "AzureWebJobsStorage"). Typically a function app has 1-3
+     * storage connections, so a small cache suffices.
+     */
+    private static final Map<String, Object> SERVICE_CLIENT_CACHE =
+            Collections.synchronizedMap(new LinkedHashMap<String, Object>(4, 0.75f, true) {
+                @Override
+                protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
+                    return size() > MAX_SERVICE_CLIENTS;
+                }
+            });
+
     /**
      * Implements the SdkTypeHydrator interface method. Extracts the connection environment variable
      * from metadata and delegates to the template method.
@@ -70,6 +96,109 @@ private Object createInstance(T metaData, String envVar) throws Exception {
         }
     }
 
+    /**
+     * Gets or creates a cached BlobServiceClient for the given connection.
+     * The BlobServiceClient holds the HttpPipeline and is the most expensive object
+     * to create. All container and blob clients derived from it share the pipeline.
+     *
+     * @param metaData the metadata containing connection info
+     * @return a BlobServiceClient instance (cached per connection env var)
+     * @throws Exception if service client creation fails
+     */
+    protected Object getOrCreateServiceClient(BlobMetaData metaData) throws Exception {
+        final String cacheKey = metaData.getConnectionEnvVar();
+        Object cached = SERVICE_CLIENT_CACHE.get(cacheKey);
+        if (cached != null) {
+            LOGGER.fine("Service client cache hit for: " + cacheKey);
+            return cached;
+        }
+
+        LOGGER.info("Service client cache miss for: " + cacheKey + ". Building new BlobServiceClient.");
+        final Object serviceClient = buildServiceClient(metaData.getConnectionEnvVar());
+        SERVICE_CLIENT_CACHE.put(cacheKey, serviceClient);
+        return serviceClient;
+    }
+
+    /**
+     * Gets or creates a BlobContainerClient by deriving it from the cached BlobServiceClient.
+     * This is a cheap operation — no new HTTP pipeline, just URL construction.
+     *
+     * @param metaData the metadata containing connection and container info
+     * @return a BlobContainerClient instance
+     * @throws Exception if creation fails
+     */
+    protected Object getOrCreateContainerClient(BlobMetaData metaData) throws Exception {
+        final Object serviceClient = getOrCreateServiceClient(metaData);
+        return serviceClient.getClass()
+                .getMethod("getBlobContainerClient", String.class)
+                .invoke(serviceClient, metaData.getContainerName());
+    }
+
+    /**
+     * Builds a BlobServiceClient using reflection, handling both connection string
+     * and managed identity scenarios.
+     *
+     * @param envVar the environment variable name for the connection
+     * @return a new BlobServiceClient instance
+     * @throws Exception if client creation fails
+     */
+    private Object buildServiceClient(String envVar) throws Exception {
+        final String maybeConnString = System.getenv(envVar);
+        final ClassLoader cl = Thread.currentThread().getContextClassLoader();
+
+        if (maybeConnString != null && isConnectionString(maybeConnString)) {
+            return buildServiceClientWithConnectionString(cl, maybeConnString);
+        } else {
+            final String accountName = System.getenv(envVar + "__accountName");
+            final String serviceUri = System.getenv(envVar + "__serviceUri");
+            final String blobServiceUri = System.getenv(envVar + "__blobServiceUri");
+            final String clientId = System.getenv(envVar + "__clientId");
+
+            final String endpoint = resolveEndpoint(accountName, serviceUri, blobServiceUri);
+            final Object credential = buildManagedIdentityCredential(clientId);
+            return buildServiceClientWithManagedIdentity(cl, endpoint, credential);
+        }
+    }
+
+    private Object buildServiceClientWithConnectionString(ClassLoader cl, String connStr) throws Exception {
+        final Class<?> builderClass = cl.loadClass("com.azure.storage.blob.BlobServiceClientBuilder");
+        final Object builder = builderClass.getDeclaredConstructor().newInstance();
+
+        builderClass.getMethod("connectionString", String.class).invoke(builder, connStr);
+
+        final Object serviceClient = builderClass.getMethod("buildClient").invoke(builder);
+        LOGGER.info("Built BlobServiceClient using connection string.");
+        return serviceClient;
+    }
+
+    private Object buildServiceClientWithManagedIdentity(ClassLoader cl, String endpoint, Object credential) throws Exception {
+        final Class<?> builderClass = cl.loadClass("com.azure.storage.blob.BlobServiceClientBuilder");
+        final Object builder = builderClass.getDeclaredConstructor().newInstance();
+
+        final Class<?> tokenCredClass = cl.loadClass("com.azure.core.credential.TokenCredential");
+        builderClass.getMethod("credential", tokenCredClass).invoke(builder, credential);
+        builderClass.getMethod("endpoint", String.class).invoke(builder, endpoint);
+
+        final Object serviceClient = builderClass.getMethod("buildClient").invoke(builder);
+        LOGGER.info("Built BlobServiceClient using managed identity.");
+        return serviceClient;
+    }
+
+    /**
+     * Derives a BlobClient from a cached BlobContainerClient via getBlobClient(blobName).
+     * This is essentially free — no HTTP pipeline build, just URL construction.
+     *
+     * @param containerClient a BlobContainerClient instance
+     * @param blobName the blob name
+     * @return a BlobClient pointing at the specific blob
+     * @throws Exception if reflection fails
+     */
+    protected Object deriveBlobClient(Object containerClient, String blobName) throws Exception {
+        return containerClient.getClass()
+                .getMethod("getBlobClient", String.class)
+                .invoke(containerClient, blobName);
+    }
+
     /**
      * Subclasses override to build their specific client using connection string authentication.
      *