Add Client Metadata Update Support.

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,53 +33,64 @@
 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.
+ *
+ * Metadata is used to identify the client in the server logs and metrics.
+ *
  * <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;
-
-    @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";
-        }
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    private final String applicationName;
+    private BsonDocument clientMetadataBsonDocument;
+    private DriverInformation driverInformation;
+
+    public ClientMetadata(@Nullable final String applicationName, final MongoDriverInformation mongoDriverInformation) {
+        this.applicationName = applicationName;
+        withLock(readWriteLock.writeLock(), () -> {
+            this.driverInformation = DriverInformation.from(
+                    mongoDriverInformation.getDriverNames(),
+                    mongoDriverInformation.getDriverVersions(),
+                    mongoDriverInformation.getDriverPlatforms());
+            this.clientMetadataBsonDocument = createClientMetadataDocument(applicationName, driverInformation);
+        });
     }
 
-    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 mongoDriverInformationToAppend) {
+        withLock(readWriteLock.writeLock(), () -> {
+            this.driverInformation.append(
+                    mongoDriverInformationToAppend.getDriverNames(),
+                    mongoDriverInformationToAppend.getDriverVersions(),
+                    mongoDriverInformationToAppend.getDriverPlatforms());
+            this.clientMetadataBsonDocument = createClientMetadataDocument(applicationName, driverInformation);
+        });
     }
 
-    public static BsonDocument createClientMetadataDocument(@Nullable final String applicationName,
-                                                            @Nullable final MongoDriverInformation mongoDriverInformation) {
+    private static BsonDocument createClientMetadataDocument(@Nullable final String applicationName,
+                                                             final DriverInformation driverInformation) {
         if (applicationName != null) {
             isTrueArgument("applicationName UTF-8 encoding length <= 128",
                     applicationName.getBytes(StandardCharsets.UTF_8).length <= 128);
@@ -87,27 +99,26 @@ public static BsonDocument createClientMetadataDocument(@Nullable final String a
         // client fields are added in "preservation" order:
         BsonDocument client = new BsonDocument();
         tryWithLimit(client, d -> putAtPath(d, "application.name", applicationName));
-        MongoDriverInformation baseDriverInfor = getDriverInformation(null);
+
         // required fields:
         tryWithLimit(client, d -> {
-            putAtPath(d, "driver.name", listToString(baseDriverInfor.getDriverNames()));
-            putAtPath(d, "driver.version", listToString(baseDriverInfor.getDriverVersions()));
+            putAtPath(d, "driver.name", driverInformation.getInitialDriverName());
+            putAtPath(d, "driver.version", driverInformation.getInitialDriverVersion());
         });
         tryWithLimit(client, d -> putAtPath(d, "os.type", getOperatingSystemType(getOperatingSystemName())));
         // full driver information:
-        MongoDriverInformation fullDriverInfo = getDriverInformation(mongoDriverInformation);
         tryWithLimit(client, d -> {
-            putAtPath(d, "driver.name", listToString(fullDriverInfo.getDriverNames()));
-            putAtPath(d, "driver.version", listToString(fullDriverInfo.getDriverVersions()));
+            putAtPath(d, "driver.name", listToString(driverInformation.getAllDriverNames()));
+            putAtPath(d, "driver.version", listToString(driverInformation.getAllDriverVersions()));
         });
 
         // 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())));
+        tryWithLimit(client, d -> putAtPath(d, "platform", driverInformation.getInitialDriverPlatform()));
+        tryWithLimit(client, d -> putAtPath(d, "platform", listToString(driverInformation.getAllDriverPlatforms())));
         tryWithLimit(client, d -> putAtPath(d, "os.name", getOperatingSystemName()));
         tryWithLimit(client, d -> putAtPath(d, "os.architecture", getProperty("os.arch", "unknown")));
         tryWithLimit(client, d -> putAtPath(d, "os.version", getProperty("os.version", "unknown")));
@@ -123,7 +134,6 @@ public static BsonDocument createClientMetadataDocument(@Nullable final String a
         return client;
     }
 
-
     private static void putAtPath(final BsonDocument d, final String path, @Nullable final String value) {
         if (value == null) {
             return;
@@ -180,7 +190,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 +220,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 +255,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;
                 }
@@ -255,17 +265,6 @@ static Orchestrator determineExecutionOrchestrator() {
         }
     }
 
-    static MongoDriverInformation getDriverInformation(@Nullable final MongoDriverInformation mongoDriverInformation) {
-        MongoDriverInformation.Builder builder = mongoDriverInformation != null ? MongoDriverInformation.builder(mongoDriverInformation)
-                : MongoDriverInformation.builder();
-        return builder
-                .driverName(MongoDriverVersion.NAME)
-                .driverVersion(MongoDriverVersion.VERSION)
-                .driverPlatform(format("Java/%s/%s", getProperty("java.vendor", "unknown-vendor"),
-                        getProperty("java.runtime.version", "unknown-version")))
-                .build();
-    }
-
     private static String listToString(final List<String> listOfStrings) {
         StringBuilder stringBuilder = new StringBuilder();
         int i = 0;
@@ -279,6 +278,95 @@ 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;
+    }
+
+    /**
+     * Holds driver information of client.driver field
+     * in {@link ClientMetadata#clientMetadataBsonDocument}.
+     */
+    private static class DriverInformation {
+        private final List<String> driverNames;
+        private final List<String> driverVersions;
+        private final List<String> driverPlatforms;
+        private final String initialPlatform;
+
+        DriverInformation() {
+            this.driverNames = new ArrayList<>();
+            driverNames.add(MongoDriverVersion.NAME);
+
+            this.driverVersions = new ArrayList<>();
+            driverVersions.add(MongoDriverVersion.VERSION);
+
+            this.initialPlatform = format("Java/%s/%s", getProperty("java.vendor", "unknown-vendor"),
+                    getProperty("java.runtime.version", "unknown-version"));
+            this.driverPlatforms = new ArrayList<>();
+            driverPlatforms.add(initialPlatform);
+        }
+
+        static DriverInformation from(final List<String> driverNames,
+                                      final List<String> driverVersions,
+                                      final List<String> driverPlatforms) {
+            DriverInformation driverInformation = new DriverInformation();
+            return driverInformation.append(driverNames, driverVersions, driverPlatforms);
+        }
+
+        DriverInformation append(final List<String> driverNames,
+                                 final List<String> driverVersions,
+                                 final List<String> driverPlatforms) {
+            this.driverNames.addAll(driverNames);
+            this.driverVersions.addAll(driverVersions);
+            this.driverPlatforms.addAll(driverPlatforms);
+            return this;
+        }
+
+        public String getInitialDriverPlatform() {
+            return initialPlatform;
+        }
+
+        public String getInitialDriverName() {
+            return MongoDriverVersion.NAME;
+        }
+
+        public String getInitialDriverVersion() {
+            return MongoDriverVersion.VERSION;
+        }
+
+        public List<String> getAllDriverNames() {
+            return driverNames;
+        }
+
+        public List<String> getAllDriverVersions() {
+            return driverVersions;
+        }
+
+        public List<String> getAllDriverPlatforms() {
+            return driverPlatforms;
+        }
     }
 }

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,