Merge branch 'main' into ta/SDK-2225/drop-persistent-cache

Author: tanderson-ld

lib/sdk/server/contract-tests/service/src/main/java/sdktest/TestService.java

@@ -42,7 +42,8 @@ public class TestService {
     "strongly-typed",
     "tags",
     "server-side-polling",
-    "fdv1-fallback"
+    "fdv1-fallback",
+    "instance-id"
   };
 
   static final Gson gson = new GsonBuilder().serializeNulls().create();

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/ClientContextImpl.java

@@ -8,6 +8,7 @@
 import com.launchdarkly.sdk.server.subsystems.HttpConfiguration;
 import com.launchdarkly.sdk.server.subsystems.LoggingConfiguration;
 
+import java.util.UUID;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 
@@ -37,7 +38,7 @@ private ClientContextImpl(
   ) {
     super(baseContext.getSdkKey(), baseContext.getApplicationInfo(), baseContext.getHttp(),
         baseContext.getLogging(), baseContext.isOffline(), baseContext.getServiceEndpoints(),
-        baseContext.getThreadPriority(), baseContext.getWrapperInfo());
+        baseContext.getThreadPriority(), baseContext.getWrapperInfo(), baseContext.getInstanceId());
     this.sharedExecutor = sharedExecutor;
     this.diagnosticStore = diagnosticStore;
     this.dataSourceUpdateSink = null;
@@ -79,22 +80,29 @@ static ClientContextImpl fromConfig(
       LDConfig config,
       ScheduledExecutorService sharedExecutor
       ) {
+    // Generate the instance ID once and thread it through every ClientContext we build for this
+    // LDClient. Subsystems built from any of these contexts will all observe the same value.
+    String instanceId = UUID.randomUUID().toString();
+
     ClientContext minimalContext = new ClientContext(sdkKey, config.applicationInfo, null,
-        null, config.offline, config.serviceEndpoints, config.threadPriority, config.wrapperInfo);
+        null, config.offline, config.serviceEndpoints, config.threadPriority, config.wrapperInfo,
+        instanceId);
     LoggingConfiguration loggingConfig = config.logging.build(minimalContext);
-    
+
     ClientContext contextWithLogging = new ClientContext(sdkKey, config.applicationInfo, null,
-        loggingConfig, config.offline, config.serviceEndpoints, config.threadPriority, config.wrapperInfo);
+        loggingConfig, config.offline, config.serviceEndpoints, config.threadPriority,
+        config.wrapperInfo, instanceId);
     HttpConfiguration httpConfig = config.http.build(contextWithLogging);
-    
+
     if (httpConfig.getProxy() != null) {
       contextWithLogging.getBaseLogger().info("Using proxy: {} {} authentication.",
           httpConfig.getProxy(),
           httpConfig.getProxyAuthentication() == null ? "without" : "with");
     }
-    
-    ClientContext contextWithHttpAndLogging = new ClientContext(sdkKey, config.applicationInfo, httpConfig,
-        loggingConfig, config.offline, config.serviceEndpoints, config.threadPriority, config.wrapperInfo);
+
+    ClientContext contextWithHttpAndLogging = new ClientContext(sdkKey, config.applicationInfo,
+        httpConfig, loggingConfig, config.offline, config.serviceEndpoints, config.threadPriority,
+        config.wrapperInfo, instanceId);
 
     // Create a diagnostic store only if diagnostics are enabled. Diagnostics are enabled as long as 1. the
     // opt-out property was not set in the config, and 2. we are using the standard event processor.

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/ComponentsImpl.java

@@ -304,6 +304,15 @@ private Result transformResult(com.launchdarkly.sdk.server.subsystems.EventSende
   }
 
   static final class HttpConfigurationBuilderImpl extends HttpConfigurationBuilder {
+    /**
+     * HTTP header used to identify this SDK instance for the purpose of estimating
+     * server-connection-minutes when polling. It contains a v4 UUID that is generated once per SDK
+     * instance and remains constant for the lifetime of the client.
+     *
+     * <p>See: sdk-specs / SCMP-server-connection-minutes-polling.
+     */
+    static final String INSTANCE_ID_HEADER = "X-LaunchDarkly-Instance-Id";
+
     @Override
     public HttpConfiguration build(ClientContext clientContext) {
       LDLogger logger = clientContext.getBaseLogger();
@@ -340,6 +349,16 @@ else if (wrapperName != null) {
         headers.put("X-LaunchDarkly-Wrapper", wrapperId);
       }
 
+      // The instance ID originates on ClientContext (generated once when LDClient is constructed)
+      // so every subsystem built from the same context observes a consistent value for the
+      // lifetime of the SDK instance.
+      String instanceId = clientContext.getInstanceId();
+      if (instanceId != null && !instanceId.isEmpty()) {
+        headers.put(INSTANCE_ID_HEADER, instanceId);
+      }
+
+      // For consistency with other SDKs, custom headers are allowed to overwrite headers such as
+      // User-Agent and Authorization.
       if (!customHeaders.isEmpty()) {
           headers.putAll(customHeaders);
       }

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/FDv2DataSource.java

@@ -15,6 +15,8 @@
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
@@ -591,21 +593,102 @@ private void maybeReportUnexpectedExhaustion(String message) {
 
     /**
      * Helper class to manage the lifecycle of conditions with automatic cleanup.
+     *
+     * <p>Before the aggregate completes, {@link #getFuture()} returns a
+     * <em>fresh</em> {@link CompletableFuture} per call. This matters because
+     * the run loop calls {@code CompletableFuture.anyOf(getFuture(),
+     * synchronizerNext)} on every iteration: if {@code getFuture()} returned
+     * the shared underlying aggregate while it was still pending, each
+     * {@code anyOf} call would permanently attach an {@code OrRelay}
+     * {@code Completion} to its {@code stack}. On a healthy primary
+     * synchronizer that streams ChangeSets without ever arming the fallback
+     * timer, the aggregate never completes, so those Completion nodes would
+     * accumulate monotonically for the synchronizer's full tenure -- a real
+     * memory leak proportional to event rate.
+     *
+     * <p>After the aggregate completes, {@link #getFuture()} returns the
+     * aggregate directly: any continuation registered on an already-completed
+     * CompletableFuture fires synchronously at registration time and is
+     * removed from the stack immediately by {@code cleanStack}, so the same
+     * accumulation cannot happen.
+     *
+     * <p>Fresh pre-completion futures are tracked in a {@link WeakHashMap}-backed
+     * set, so a fresh future whose only strong references were in the caller's
+     * loop iteration becomes garbage-collectable -- and automatically removed
+     * from {@code pending} -- once that iteration ends.
+     *
+     * <p>Package-private (rather than private) so that direct unit tests can
+     * exercise the API surface and assert per-call distinctness.
      */
-    private static class Conditions implements AutoCloseable {
+    static class Conditions implements AutoCloseable {
         private final List<Condition> conditions;
-        private final CompletableFuture<Object> conditionsFuture;
+        private final CompletableFuture<Object> aggregate;
+        private final Object lock = new Object();
+
+        /**
+         * Tracks futures previously returned by {@link #getFuture()} that have
+         * not yet been completed. Held weakly via {@link WeakHashMap} so that
+         * fresh futures abandoned by the caller (the typical end-of-iteration
+         * case) become GC-collectable. Set to {@code null} once the aggregate
+         * has fired and the entries have been drained. Mutated only under
+         * {@code lock}.
+         */
+        private Set<CompletableFuture<Object>> pending =
+            Collections.newSetFromMap(new WeakHashMap<>());
 
         public Conditions(List<Condition> conditions) {
             this.conditions = conditions;
-            this.conditionsFuture = conditions.isEmpty()
+            this.aggregate = conditions.isEmpty()
                 ? new CompletableFuture<>() // Never completes if no conditions
                 : CompletableFuture.anyOf(
-                conditions.stream().map(Condition::execute).toArray(CompletableFuture[]::new));
+                    conditions.stream().map(Condition::execute).toArray(CompletableFuture[]::new));
+
+            // Single permanent listener. This is the only Completion node ever
+            // attached to aggregate.stack while the aggregate is still pending
+            // -- subsequent pre-completion getFuture() calls do not touch the
+            // aggregate at all.
+            this.aggregate.whenComplete((result, throwable) -> {
+                List<CompletableFuture<Object>> snapshot;
+                synchronized (lock) {
+                    if (pending == null) {
+                        return;
+                    }
+                    // Copy under the lock: the ArrayList holds strong
+                    // references so entries that survived GC to this point
+                    // stay alive until we complete them below.
+                    snapshot = new ArrayList<>(pending);
+                    pending = null;
+                }
+                for (CompletableFuture<Object> cf : snapshot) {
+                    if (throwable != null) {
+                        cf.completeExceptionally(throwable);
+                    } else {
+                        cf.complete(result);
+                    }
+                }
+            });
         }
 
+        /**
+         * Returns a future that will complete when the underlying aggregate
+         * condition fires. Pre-completion, this is a fresh future per call;
+         * post-completion, this is the aggregate itself (already done).
+         */
         public CompletableFuture<Object> getFuture() {
-            return conditionsFuture;
+            if (aggregate.isDone()) {
+                return aggregate;
+            }
+
+            CompletableFuture<Object> fresh = new CompletableFuture<>();
+            synchronized (lock) {
+                if (pending == null) {
+                    // Raced with aggregate completion between isDone() and
+                    // the lock acquisition; aggregate is now done.
+                    return aggregate;
+                }
+                pending.add(fresh);
+            }
+            return fresh;
         }
 
         public void inform(FDv2SourceResult result) {
@@ -615,6 +698,11 @@ public void inform(FDv2SourceResult result) {
         @Override
         public void close() {
             conditions.forEach(Condition::close);
+            synchronized (lock) {
+                if (pending != null) {
+                    pending.clear();
+                }
+            }
         }
     }
 }

lib/sdk/server/src/main/java/com/launchdarkly/sdk/server/subsystems/ClientContext.java

@@ -8,6 +8,8 @@
 import com.launchdarkly.sdk.server.interfaces.ServiceEndpoints;
 import com.launchdarkly.sdk.server.interfaces.WrapperInfo;
 
+import java.util.UUID;
+
 /**
  * Context information provided by the {@link com.launchdarkly.sdk.server.LDClient} when creating components.
  * <p>
@@ -31,11 +33,18 @@ public class ClientContext {
   private final boolean offline;
   private final ServiceEndpoints serviceEndpoints;
   private final int threadPriority;
+  private final String instanceId;
   private WrapperInfo wrapperInfo;
 
   /**
-   * Constructor that sets all properties. All should be non-null.
-   * 
+   * Constructor that sets all properties including an explicit instance ID. All should be
+   * non-null.
+   *
+   * <p>The instance ID is sent on every outbound request in the {@code X-LaunchDarkly-Instance-Id}
+   * header. It must be generated once per LDClient and remain stable for the client's lifetime.
+   * The eight-argument constructor auto-generates a v4 UUID for callers that do not need to
+   * supply their own value.
+   *
    * @param sdkKey the SDK key
    * @param applicationInfo application metadata properties from
    *   {@link Builder#applicationInfo(com.launchdarkly.sdk.server.integrations.ApplicationInfoBuilder)}
@@ -46,6 +55,7 @@ public class ClientContext {
    *   {@link Builder#serviceEndpoints(com.launchdarkly.sdk.server.integrations.ServiceEndpointsBuilder)}
    * @param threadPriority worker thread priority from {@link Builder#threadPriority(int)}
    * @param wrapperInfo wrapper configuration from {@link Builder#wrapper(com.launchdarkly.sdk.server.integrations.WrapperInfoBuilder)}
+   * @param instanceId per-LDClient identifier for the {@code X-LaunchDarkly-Instance-Id} header
    */
   public ClientContext(
       String sdkKey,
@@ -55,7 +65,8 @@ public ClientContext(
       boolean offline,
       ServiceEndpoints serviceEndpoints,
       int threadPriority,
-      WrapperInfo wrapperInfo
+      WrapperInfo wrapperInfo,
+      String instanceId
       ) {
     this.sdkKey = sdkKey;
     this.applicationInfo = applicationInfo;
@@ -65,19 +76,51 @@ public ClientContext(
     this.serviceEndpoints = serviceEndpoints;
     this.threadPriority = threadPriority;
     this.wrapperInfo = wrapperInfo;
-    
+    this.instanceId = instanceId;
+
     this.baseLogger = logging == null ? LDLogger.none() :
       LDLogger.withAdapter(logging.getLogAdapter(), logging.getBaseLoggerName());
   }
-  
+
+  /**
+   * Constructor that sets all properties. All should be non-null. Auto-generates a v4 UUID for
+   * the instance ID; use the nine-argument constructor if you need to thread an existing value
+   * through (for example, when copying a context for an in-flight LDClient).
+   *
+   * @param sdkKey the SDK key
+   * @param applicationInfo application metadata properties from
+   *   {@link Builder#applicationInfo(com.launchdarkly.sdk.server.integrations.ApplicationInfoBuilder)}
+   * @param http HTTP configuration properties from {@link Builder#http(ComponentConfigurer)}
+   * @param logging logging configuration properties from {@link Builder#logging(ComponentConfigurer)}
+   * @param offline true if the SDK should be entirely offline
+   * @param serviceEndpoints service endpoint URI properties from
+   *   {@link Builder#serviceEndpoints(com.launchdarkly.sdk.server.integrations.ServiceEndpointsBuilder)}
+   * @param threadPriority worker thread priority from {@link Builder#threadPriority(int)}
+   * @param wrapperInfo wrapper configuration from {@link Builder#wrapper(com.launchdarkly.sdk.server.integrations.WrapperInfoBuilder)}
+   */
+  public ClientContext(
+      String sdkKey,
+      ApplicationInfo applicationInfo,
+      HttpConfiguration http,
+      LoggingConfiguration logging,
+      boolean offline,
+      ServiceEndpoints serviceEndpoints,
+      int threadPriority,
+      WrapperInfo wrapperInfo
+      ) {
+    this(sdkKey, applicationInfo, http, logging, offline, serviceEndpoints, threadPriority,
+        wrapperInfo, UUID.randomUUID().toString());
+  }
+
   /**
    * Copy constructor.
-   * 
+   *
    * @param copyFrom the instance to copy from
    */
   protected ClientContext(ClientContext copyFrom) {
     this(copyFrom.sdkKey, copyFrom.applicationInfo, copyFrom.http, copyFrom.logging,
-        copyFrom.offline, copyFrom.serviceEndpoints, copyFrom.threadPriority, copyFrom.wrapperInfo);
+        copyFrom.offline, copyFrom.serviceEndpoints, copyFrom.threadPriority, copyFrom.wrapperInfo,
+        copyFrom.instanceId);
   }
 
   /**
@@ -86,20 +129,32 @@ protected ClientContext(ClientContext copyFrom) {
    * @param sdkKey the SDK key
    */
   public ClientContext(String sdkKey) {
+    this(sdkKey, UUID.randomUUID().toString());
+  }
+
+  // Private delegating constructor: generates a single instance id up front and threads it
+  // both into the default HttpConfiguration (so the X-LaunchDarkly-Instance-Id default
+  // header carries it) and into this.instanceId (so getInstanceId() returns the same value).
+  // The earlier shape, where the public single-arg ctor called defaultHttp(sdkKey) and then
+  // let the eight-arg ctor auto-generate a fresh UUID, produced two different ids -- one in
+  // the headers and one returned by getInstanceId().
+  private ClientContext(String sdkKey, String instanceId) {
     this(
         sdkKey,
         new ApplicationInfo(null, null),
-        defaultHttp(sdkKey),
+        defaultHttp(sdkKey, instanceId),
         defaultLogging(),
         false,
         Components.serviceEndpoints().createServiceEndpoints(),
         Thread.MIN_PRIORITY,
-      null
+        null,
+        instanceId
         );
   }
-  
-  private static HttpConfiguration defaultHttp(String sdkKey) {
-    ClientContext minimalContext = new ClientContext(sdkKey, null, null, null, false, null, 0, null);
+
+  private static HttpConfiguration defaultHttp(String sdkKey, String instanceId) {
+    ClientContext minimalContext = new ClientContext(sdkKey, null, null, null, false, null, 0, null,
+        instanceId);
     return Components.httpConfiguration().build(minimalContext);
   }
 
@@ -199,13 +254,24 @@ public ServiceEndpoints getServiceEndpoints() {
   /**
    * Returns the worker thread priority that is set by
    * {@link Builder#threadPriority(int)}.
-   * 
+   *
    * @return the thread priority
    */
   public int getThreadPriority() {
     return threadPriority;
   }
 
+  /**
+   * Returns the per-LDClient instance identifier sent in the {@code X-LaunchDarkly-Instance-Id}
+   * header on outbound requests. The value is generated once when the {@link ClientContext} is
+   * constructed and is stable for the client's lifetime.
+   *
+   * @return the instance ID
+   */
+  public String getInstanceId() {
+    return instanceId;
+  }
+
   /**
    * Returns the wrapper information.
    *