Add Client Metadata Update Support.

buildSrc/src/main/kotlin/conventions/testing-base.gradle.kts

@@ -105,3 +105,7 @@ testlogger {
     showFailedStandardStreams = true
     logLevel = LogLevel.LIFECYCLE
 }
+
+dependencies {
+    testImplementation(libs.assertj)
+}

driver-core/src/main/com/mongodb/internal/connection/AbstractMultiServerCluster.java

@@ -78,8 +78,11 @@ private ServerTuple(final ClusterableServer server, final ServerDescription desc
         }
     }
 
-    AbstractMultiServerCluster(final ClusterId clusterId, final ClusterSettings settings, final ClusterableServerFactory serverFactory) {
-        super(clusterId, settings, serverFactory);
+    AbstractMultiServerCluster(final ClusterId clusterId,
+                               final ClusterSettings settings,
+                               final ClusterableServerFactory serverFactory,
+                               final ClientMetadata clientMetadata) {
+        super(clusterId, settings, serverFactory, clientMetadata);
         isTrue("connection mode is multiple", settings.getMode() == MULTIPLE);
         clusterType = settings.getRequiredClusterType();
         replicaSetName = settings.getRequiredReplicaSetName();

driver-core/src/main/com/mongodb/internal/connection/BaseCluster.java

@@ -53,11 +53,11 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
-import java.util.stream.Stream;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Stream;
 
 import static com.mongodb.assertions.Assertions.assertNotNull;
 import static com.mongodb.assertions.Assertions.isTrue;
@@ -106,28 +106,38 @@ abstract class BaseCluster implements Cluster {
     private final ClusterListener clusterListener;
     private final Deque<ServerSelectionRequest> waitQueue = new ConcurrentLinkedDeque<>();
     private final ClusterClock clusterClock = new ClusterClock();
+    private final ClientMetadata clientMetadata;
     private Thread waitQueueHandler;
 
     private volatile boolean isClosed;
     private volatile ClusterDescription description;
 
-    BaseCluster(final ClusterId clusterId, final ClusterSettings settings, final ClusterableServerFactory serverFactory) {
+    BaseCluster(final ClusterId clusterId,
+                final ClusterSettings settings,
+                final ClusterableServerFactory serverFactory,
+                final ClientMetadata clientMetadata) {
         this.clusterId = notNull("clusterId", clusterId);
         this.settings = notNull("settings", settings);
         this.serverFactory = notNull("serverFactory", serverFactory);
         this.clusterListener = singleClusterListener(settings);
         ClusterOpeningEvent clusterOpeningEvent = new ClusterOpeningEvent(clusterId);
-        clusterListener.clusterOpening(clusterOpeningEvent);
+        this.clusterListener.clusterOpening(clusterOpeningEvent);
         logTopologyOpening(clusterId, clusterOpeningEvent);
-        description = new ClusterDescription(settings.getMode(), UNKNOWN, emptyList(),
+        this.description = new ClusterDescription(settings.getMode(), UNKNOWN, emptyList(),
                 settings, serverFactory.getSettings());
+        this.clientMetadata = clientMetadata;
     }
 
     @Override
     public ClusterClock getClock() {
         return clusterClock;
     }
 
+    @Override
+    public ClientMetadata getClientMetadata() {
+        return clientMetadata;
+    }
+
     @Override
     public ServerTuple selectServer(final ServerSelector serverSelector, final OperationContext operationContext) {
         isTrue("open", !isClosed());

driver-core/src/main/com/mongodb/internal/connection/ClientMetadataHelper.java → driver-core/src/main/com/mongodb/internal/connection/ClientMetadata.java

@@ -17,6 +17,7 @@
 package com.mongodb.internal.connection;
 
 import com.mongodb.MongoDriverInformation;
+import com.mongodb.annotations.ThreadSafe;
 import com.mongodb.internal.VisibleForTesting;
 import com.mongodb.internal.build.MongoDriverVersion;
 import com.mongodb.lang.Nullable;
@@ -32,52 +33,50 @@
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Consumer;
 
 import static com.mongodb.assertions.Assertions.isTrueArgument;
+import static com.mongodb.internal.Locks.withLock;
 import static com.mongodb.internal.connection.FaasEnvironment.getFaasEnvironment;
 import static java.lang.String.format;
 import static java.lang.System.getProperty;
 import static java.nio.file.Paths.get;
 
 /**
+ * Represents metadata of the current MongoClient.
+ *
  * <p>This class is not part of the public API and may be removed or changed at any time</p>
  */
-public final class ClientMetadataHelper {
+@ThreadSafe
+public class ClientMetadata {
     private static final String SEPARATOR = "|";
-
     private static final int MAXIMUM_CLIENT_METADATA_ENCODED_SIZE = 512;
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    private BsonDocument clientMetadataBsonDocument;
 
-    @VisibleForTesting(otherwise = VisibleForTesting.AccessModifier.PRIVATE)
-    static String getOperatingSystemType(final String operatingSystemName) {
-        if (nameStartsWith(operatingSystemName, "linux")) {
-            return "Linux";
-        } else if (nameStartsWith(operatingSystemName, "mac")) {
-            return "Darwin";
-        } else if (nameStartsWith(operatingSystemName, "windows")) {
-            return  "Windows";
-        } else if (nameStartsWith(operatingSystemName, "hp-ux", "aix", "irix", "solaris", "sunos")) {
-            return "Unix";
-        } else {
-            return "unknown";
-        }
+    public ClientMetadata(@Nullable final String applicationName, final MongoDriverInformation mongoDriverInformation) {
+        withLock(readWriteLock.writeLock(), () -> {
+            this.clientMetadataBsonDocument = createClientMetadataDocument(applicationName, mongoDriverInformation);
+        });
     }
 
-    private static String getOperatingSystemName() {
-        return getProperty("os.name", "unknown");
+    /**
+     * Returns mutable BsonDocument that represents the client metadata.
+     */
+    public BsonDocument getBsonDocument() {
+        return withLock(readWriteLock.readLock(), () -> clientMetadataBsonDocument);
     }
 
-    private static boolean nameStartsWith(final String name, final String... prefixes) {
-        for (String prefix : prefixes) {
-            if (name.toLowerCase().startsWith(prefix.toLowerCase())) {
-                return true;
-            }
-        }
-        return false;
+    public void append(final MongoDriverInformation mongoDriverInformation) {
+        withLock(readWriteLock.writeLock(), () ->
+                this.clientMetadataBsonDocument = updateClientMetadataDocument(clientMetadataBsonDocument.clone(), mongoDriverInformation)
+        );
     }
 
-    public static BsonDocument createClientMetadataDocument(@Nullable final String applicationName,
+    private static BsonDocument createClientMetadataDocument(@Nullable final String applicationName,
                                                             @Nullable final MongoDriverInformation mongoDriverInformation) {
         if (applicationName != null) {
             isTrueArgument("applicationName UTF-8 encoding length <= 128",
@@ -103,8 +102,8 @@ public static BsonDocument createClientMetadataDocument(@Nullable final String a
 
         // optional fields:
         FaasEnvironment faasEnvironment =  getFaasEnvironment();
-        ContainerRuntime containerRuntime = ContainerRuntime.determineExecutionContainer();
-        Orchestrator orchestrator = Orchestrator.determineExecutionOrchestrator();
+        ClientMetadata.ContainerRuntime containerRuntime = ClientMetadata.ContainerRuntime.determineExecutionContainer();
+        ClientMetadata.Orchestrator orchestrator = ClientMetadata.Orchestrator.determineExecutionOrchestrator();
 
         tryWithLimit(client, d -> putAtPath(d, "platform", listToString(baseDriverInfor.getDriverPlatforms())));
         tryWithLimit(client, d -> putAtPath(d, "platform", listToString(fullDriverInfo.getDriverPlatforms())));
@@ -123,6 +122,44 @@ public static BsonDocument createClientMetadataDocument(@Nullable final String a
         return client;
     }
 
+    /**
+     * Modifies the given client metadata document by appending the driver information.
+     * Driver name and version are appended atomically to the existing driver name and version if they do not exceed
+     * {@value MAXIMUM_CLIENT_METADATA_ENCODED_SIZE} bytes.
+     * <p>
+     * Platform is appended separately to the existing platform if it does not exceed {@value MAXIMUM_CLIENT_METADATA_ENCODED_SIZE} bytes.
+     */
+    private static BsonDocument updateClientMetadataDocument(final BsonDocument clientMetadataDocument,
+                                                            final MongoDriverInformation driverInformationToAppend) {
+        BsonDocument currentDriverInformation = clientMetadataDocument.getDocument("driver");
+
+        List<String> driverNamesToAppend = driverInformationToAppend.getDriverNames();
+        List<String> driverVersionsToAppend = driverInformationToAppend.getDriverVersions();
+        List<String> driverPlatformsToAppend = driverInformationToAppend.getDriverPlatforms();
+
+        List<String> updatedDriverNames = new ArrayList<>(driverNamesToAppend.size() + 1);
+        List<String> updatedDriverVersions = new ArrayList<>(driverVersionsToAppend.size() + 1);
+        List<String> updateDriverPlatforms = new ArrayList<>(driverPlatformsToAppend.size() + 1);
+
+        updatedDriverNames.add(currentDriverInformation.getString("name").getValue());
+        updatedDriverNames.addAll(driverNamesToAppend);
+
+        updatedDriverVersions.add(currentDriverInformation.getString("version").getValue());
+        updatedDriverVersions.addAll(driverVersionsToAppend);
+
+        updateDriverPlatforms.add(clientMetadataDocument.getString("platform").getValue());
+        updateDriverPlatforms.addAll(driverPlatformsToAppend);
+
+        tryWithLimit(clientMetadataDocument, d -> {
+            putAtPath(d, "driver.name", listToString(updatedDriverNames));
+            putAtPath(d, "driver.version", listToString(updatedDriverVersions));
+        });
+        tryWithLimit(clientMetadataDocument, d -> {
+            putAtPath(d, "platform", listToString(updateDriverPlatforms));
+        });
+        return clientMetadataDocument;
+    }
+
 
     private static void putAtPath(final BsonDocument d, final String path, @Nullable final String value) {
         if (value == null) {
@@ -180,7 +217,7 @@ static boolean clientMetadataDocumentTooLarge(final BsonDocument document) {
         return buffer.getPosition() > MAXIMUM_CLIENT_METADATA_ENCODED_SIZE;
     }
 
-    public enum ContainerRuntime {
+    private enum ContainerRuntime {
         DOCKER("docker") {
             @Override
             boolean isCurrentRuntimeContainer() {
@@ -210,8 +247,8 @@ boolean isCurrentRuntimeContainer() {
             return false;
         }
 
-        static ContainerRuntime determineExecutionContainer() {
-            for (ContainerRuntime allegedContainer : ContainerRuntime.values()) {
+        static ClientMetadata.ContainerRuntime determineExecutionContainer() {
+            for (ClientMetadata.ContainerRuntime allegedContainer : ClientMetadata.ContainerRuntime.values()) {
                 if (allegedContainer.isCurrentRuntimeContainer()) {
                     return allegedContainer;
                 }
@@ -245,8 +282,8 @@ boolean isCurrentOrchestrator() {
             return false;
         }
 
-        static Orchestrator determineExecutionOrchestrator() {
-            for (Orchestrator alledgedOrchestrator : Orchestrator.values()) {
+        static ClientMetadata.Orchestrator determineExecutionOrchestrator() {
+            for (ClientMetadata.Orchestrator alledgedOrchestrator : ClientMetadata.Orchestrator.values()) {
                 if (alledgedOrchestrator.isCurrentOrchestrator()) {
                     return alledgedOrchestrator;
                 }
@@ -279,6 +316,31 @@ private static String listToString(final List<String> listOfStrings) {
         return stringBuilder.toString();
     }
 
-    private ClientMetadataHelper() {
+    @VisibleForTesting(otherwise = VisibleForTesting.AccessModifier.PRIVATE)
+    public static String getOperatingSystemType(final String operatingSystemName) {
+        if (nameStartsWith(operatingSystemName, "linux")) {
+            return "Linux";
+        } else if (nameStartsWith(operatingSystemName, "mac")) {
+            return "Darwin";
+        } else if (nameStartsWith(operatingSystemName, "windows")) {
+            return  "Windows";
+        } else if (nameStartsWith(operatingSystemName, "hp-ux", "aix", "irix", "solaris", "sunos")) {
+            return "Unix";
+        } else {
+            return "unknown";
+        }
+    }
+
+    private static String getOperatingSystemName() {
+        return getProperty("os.name", "unknown");
+    }
+
+    private static boolean nameStartsWith(final String name, final String... prefixes) {
+        for (String prefix : prefixes) {
+            if (name.toLowerCase().startsWith(prefix.toLowerCase())) {
+                return true;
+            }
+        }
+        return false;
     }
 }

driver-core/src/main/com/mongodb/internal/connection/Cluster.java

@@ -57,6 +57,8 @@ public interface Cluster extends Closeable {
      */
     ClusterClock getClock();
 
+    ClientMetadata getClientMetadata();
+
     ServerTuple selectServer(ServerSelector serverSelector, OperationContext operationContext);
 
     void selectServerAsync(ServerSelector serverSelector, OperationContext operationContext,

driver-core/src/main/com/mongodb/internal/connection/DefaultClusterFactory.java

@@ -107,27 +107,29 @@ public Cluster createCluster(final ClusterSettings originalClusterSettings, fina
         InternalOperationContextFactory heartBeatOperationContextFactory =
                 new InternalOperationContextFactory(heartbeatTimeoutSettings, serverApi);
 
+        ClientMetadata clientMetadata = new ClientMetadata(
+                applicationName,
+                mongoDriverInformation != null ? mongoDriverInformation : MongoDriverInformation.builder().build());
+
         if (clusterSettings.getMode() == ClusterConnectionMode.LOAD_BALANCED) {
             ClusterableServerFactory serverFactory = new LoadBalancedClusterableServerFactory(serverSettings,
                     connectionPoolSettings, internalConnectionPoolSettings, streamFactory, credential, loggerSettings, commandListener,
-                    applicationName, mongoDriverInformation != null ? mongoDriverInformation : MongoDriverInformation.builder().build(),
                     compressorList, serverApi, clusterOperationContextFactory);
-            return new LoadBalancedCluster(clusterId, clusterSettings, serverFactory, dnsSrvRecordMonitorFactory);
+            return new LoadBalancedCluster(clusterId, clusterSettings, serverFactory, clientMetadata, dnsSrvRecordMonitorFactory);
         } else {
             ClusterableServerFactory serverFactory = new DefaultClusterableServerFactory(serverSettings,
                     connectionPoolSettings, internalConnectionPoolSettings,
                     clusterOperationContextFactory, streamFactory, heartBeatOperationContextFactory, heartbeatStreamFactory, credential,
-                    loggerSettings, commandListener, applicationName,
-                    mongoDriverInformation != null ? mongoDriverInformation : MongoDriverInformation.builder().build(), compressorList,
+                    loggerSettings, commandListener, compressorList,
                     serverApi, FaasEnvironment.getFaasEnvironment() != FaasEnvironment.UNKNOWN);
 
             if (clusterSettings.getMode() == ClusterConnectionMode.SINGLE) {
-                return new SingleServerCluster(clusterId, clusterSettings, serverFactory);
+                return new SingleServerCluster(clusterId, clusterSettings, serverFactory, clientMetadata);
             } else if (clusterSettings.getMode() == ClusterConnectionMode.MULTIPLE) {
                 if (clusterSettings.getSrvHost() == null) {
-                    return new MultiServerCluster(clusterId, clusterSettings, serverFactory);
+                    return new MultiServerCluster(clusterId, clusterSettings, serverFactory, clientMetadata);
                 } else {
-                    return new DnsMultiServerCluster(clusterId, clusterSettings, serverFactory, dnsSrvRecordMonitorFactory);
+                    return new DnsMultiServerCluster(clusterId, clusterSettings, serverFactory, clientMetadata, dnsSrvRecordMonitorFactory);
                 }
             } else {
                 throw new UnsupportedOperationException("Unsupported cluster mode: " + clusterSettings.getMode());