JAVA-2266: Add support for server handshake to send client metadata, including driver, os, platform, and application name

Author: jyemin

build.gradle

@@ -111,6 +111,31 @@ configure(subprojects.findAll { it.name != 'util' }) {
     }
 }
 
+def getGitVersion() {
+    def outputAsString
+    new ByteArrayOutputStream().withStream { os ->
+        def result = exec {
+            executable 'git'
+            args 'describe', '--tags'
+            standardOutput = os
+        }
+        outputAsString = os.toString().substring(1)
+    }
+    return outputAsString
+}
+
+configure(subprojects.findAll { it.name != 'util' }) {
+
+    project.ext.generatedResources = "$buildDir/generated-resources/main"
+
+    task generateVersionPropertiesFile << {
+        def directory = new File(project.ext.generatedResources)
+        directory.mkdirs()
+        def propertiesFile = new File(directory, "version.properties")
+        propertiesFile.text = "version=${getGitVersion()}"
+    }
+}
+
 configure(subprojects.findAll { it.name != 'util' && it.name != 'mongo-java-driver' }) {
     apply plugin: 'checkstyle'
     apply plugin: 'findbugs'
@@ -131,6 +156,7 @@ configure(subprojects.findAll { it.name != 'util' && it.name != 'mongo-java-driv
     sourceSets {
         main {
             java.srcDirs = ['src/main']
+            output.dir(project.ext.generatedResources, builtBy: 'generateVersionPropertiesFile')
         }
         test {
             groovy.srcDirs = ['src/test/functional', 'src/test/unit']

driver-async/src/main/com/mongodb/async/client/MongoClientSettings.java

@@ -33,10 +33,12 @@
 import com.mongodb.event.CommandListener;
 import org.bson.codecs.configuration.CodecRegistry;
 
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static com.mongodb.assertions.Assertions.isTrueArgument;
 import static com.mongodb.assertions.Assertions.notNull;
 
 
@@ -62,6 +64,7 @@ public final class MongoClientSettings {
     private final ConnectionPoolSettings connectionPoolSettings;
     private final ServerSettings serverSettings;
     private final SslSettings sslSettings;
+    private final String applicationName;
 
     /**
      * Convenience method to create a Builder.
@@ -105,6 +108,7 @@ public static final class Builder {
         private ServerSettings serverSettings = ServerSettings.builder().build();
         private SslSettings sslSettings = SslSettings.builder().build();
         private List<MongoCredential> credentialList = Collections.emptyList();
+        private String applicationName;
 
         private Builder() {
         }
@@ -129,6 +133,7 @@ private Builder(final MongoClientSettings settings) {
             heartbeatSocketSettings = settings.getHeartbeatSocketSettings();
             connectionPoolSettings = settings.getConnectionPoolSettings();
             sslSettings = settings.getSslSettings();
+            applicationName = settings.getApplicationName();
         }
 
         /**
@@ -292,6 +297,27 @@ public Builder addCommandListener(final CommandListener commandListener) {
             return this;
         }
 
+
+        /**
+         * Sets the logical name of the application using this MongoClient.  The application name may be used by the client to identify
+         * the application to the server, for use in server logs, slow query logs, and profile collection.
+         *
+         * @param applicationName the logical name of the application using this MongoClient.  It may be null.
+         *                        The UTF-8 encoding may not exceed 128 bytes.
+         * @return {@code this}
+         * @see #getApplicationName()
+         * @since 3.4
+         * @mongodb.server.release 3.4
+         */
+        public Builder applicationName(final String applicationName) {
+            if (applicationName != null) {
+                isTrueArgument("applicationName UTF-8 encoding length <= 128",
+                        applicationName.getBytes(Charset.forName("UTF-8")).length <= 128);
+            }
+            this.applicationName = applicationName;
+            return this;
+        }
+
         /**
          * Build an instance of {@code MongoClientSettings}.
          *
@@ -391,6 +417,21 @@ public List<CommandListener> getCommandListeners() {
         return Collections.unmodifiableList(commandListeners);
     }
 
+    /**
+     * Gets the logical name of the application using this MongoClient.  The application name may be used by the client to identify
+     * the application to the server, for use in server logs, slow query logs, and profile collection.
+     *
+     * <p>Default is null.</p>
+     *
+     * @return the application name, which may be null
+     * @since 3.4
+     * @mongodb.server.release 3.4
+     */
+    public String getApplicationName() {
+        return applicationName;
+    }
+
+
     /**
      * Gets the cluster settings.
      *
@@ -463,6 +504,7 @@ private MongoClientSettings(final Builder builder) {
         streamFactoryFactory = builder.streamFactoryFactory;
         codecRegistry = builder.codecRegistry;
         commandListeners = builder.commandListeners;
+        applicationName = builder.applicationName;
         clusterSettings = builder.clusterSettings;
         serverSettings = builder.serverSettings;
         socketSettings = builder.socketSettings;

driver-async/src/main/com/mongodb/async/client/MongoClients.java

@@ -138,6 +138,9 @@ public static MongoClient create(final ConnectionString connectionString) {
         if (connectionString.getWriteConcern() != null) {
             builder.writeConcern(connectionString.getWriteConcern());
         }
+        if (connectionString.getApplicationName() != null) {
+            builder.applicationName(connectionString.getApplicationName());
+        }
         return create(builder.build());
     }
 
@@ -173,7 +176,8 @@ private static Cluster createCluster(final MongoClientSettings settings, final S
                                                   settings.getConnectionPoolSettings(), streamFactory,
                                                   heartbeatStreamFactory,
                                                   settings.getCredentialList(), null, new JMXConnectionPoolListener(), null,
-                                                  createCommandListener(settings.getCommandListeners()));
+                                                  createCommandListener(settings.getCommandListeners()),
+                                                  settings.getApplicationName());
     }
 
     private static StreamFactory getHeartbeatStreamFactory(final MongoClientSettings settings) {

driver-async/src/test/functional/com/mongodb/async/client/MongoClientsSpecification.groovy

@@ -23,12 +23,17 @@ import com.mongodb.ServerAddress
 import com.mongodb.WriteConcern
 import com.mongodb.connection.AsynchronousSocketChannelStreamFactoryFactory
 import com.mongodb.connection.netty.NettyStreamFactoryFactory
+import org.bson.Document
 import spock.lang.IgnoreIf
 import spock.lang.Unroll
 
 import static com.mongodb.ClusterFixture.getSslSettings
+import static com.mongodb.ClusterFixture.isStandalone
+import static com.mongodb.ClusterFixture.serverVersionAtLeast
 import static com.mongodb.ReadPreference.primary
 import static com.mongodb.ReadPreference.secondaryPreferred
+import static com.mongodb.async.client.Fixture.getMongoClientBuilderFromConnectionString
+import static com.mongodb.async.client.TestHelper.run
 import static java.util.concurrent.TimeUnit.MILLISECONDS
 
 class MongoClientsSpecification extends FunctionalSpecification {
@@ -174,4 +179,44 @@ class MongoClientsSpecification extends FunctionalSpecification {
         'mongodb://localhost'             | WriteConcern.ACKNOWLEDGED
         'mongodb://localhost/?w=majority' | WriteConcern.MAJORITY
     }
+
+    @Unroll
+    def 'should apply application name from connection string to settings'() {
+        when:
+        def client = MongoClients.create(uri)
+
+        then:
+        client.settings.getApplicationName() == applicationName
+
+        cleanup:
+        client?.close()
+
+        where:
+        uri                                 | applicationName
+        'mongodb://localhost'               | null
+        'mongodb://localhost/?appname=app1' | 'app1'
+    }
+
+    @IgnoreIf({ !serverVersionAtLeast([3, 3, 9]) || !isStandalone() })
+    def 'application name should appear in the system.profile collection'() {
+        given:
+        def appName = 'appName1'
+        def client = MongoClients.create(getMongoClientBuilderFromConnectionString().applicationName(appName).build())
+        def database = client.getDatabase(getDatabaseName())
+        def collection = database.getCollection(getCollectionName())
+        run(database.&runCommand, new Document('profile', 2))
+
+        when:
+        run(collection.&count)
+
+        then:
+        Document profileDocument = run(database.getCollection('system.profile').find().&first)
+        profileDocument.get('appName') == appName
+
+        cleanup:
+        if (database != null) {
+            run(database.&runCommand, new Document('profile', 0))
+        }
+        client?.close()
+    }
 }

driver-async/src/test/unit/com/mongodb/async/client/MongoClientSettingsSpecification.groovy

@@ -46,6 +46,7 @@ class MongoClientSettingsSpecification extends Specification {
         options.getReadConcern() == ReadConcern.DEFAULT
         options.getReadPreference() == ReadPreference.primary()
         options.getCommandListeners().isEmpty()
+        options.getApplicationName() == null
         options.connectionPoolSettings == ConnectionPoolSettings.builder().build()
         options.socketSettings == SocketSettings.builder().build()
         options.heartbeatSocketSettings == SocketSettings.builder().build()
@@ -139,6 +140,7 @@ class MongoClientSettingsSpecification extends Specification {
                 .readPreference(ReadPreference.secondary())
                 .writeConcern(WriteConcern.JOURNALED)
                 .readConcern(ReadConcern.LOCAL)
+                .applicationName('app1')
                 .addCommandListener(commandListener)
                 .sslSettings(sslSettings)
                 .socketSettings(socketSettings)
@@ -155,6 +157,7 @@ class MongoClientSettingsSpecification extends Specification {
         options.getReadPreference() == ReadPreference.secondary()
         options.getWriteConcern() == WriteConcern.JOURNALED
         options.getReadConcern() == ReadConcern.LOCAL
+        options.getApplicationName() == 'app1'
         options.commandListeners.get(0) == commandListener
         options.connectionPoolSettings == connectionPoolSettings
         options.socketSettings == socketSettings
@@ -183,6 +186,7 @@ class MongoClientSettingsSpecification extends Specification {
                 .readPreference(ReadPreference.secondary())
                 .writeConcern(WriteConcern.JOURNALED)
                 .readConcern(ReadConcern.LOCAL)
+                .applicationName('app1')
                 .addCommandListener(commandListener)
                 .sslSettings(sslSettings)
                 .socketSettings(socketSettings)
@@ -198,6 +202,29 @@ class MongoClientSettingsSpecification extends Specification {
         expect options, isTheSameAs(MongoClientSettings.builder(options).build())
     }
 
+    def 'applicationName can be 128 bytes when encoded as UTF-8'() {
+        given:
+        def applicationName = 'a' * 126 + '\u00A0'
+
+        when:
+        def options = MongoClientSettings.builder().applicationName(applicationName).build()
+
+        then:
+        options.applicationName == applicationName
+    }
+
+    def 'should throw IllegalArgumentException if applicationName exceeds 128 bytes when encoded as UTF-8'() {
+        given:
+        def applicationName = 'a' * 127 + '\u00A0'
+
+        when:
+        MongoClientSettings.builder().applicationName(applicationName)
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+
     def 'should add command listeners'() {
         given:
         CommandListener commandListenerOne = Mock(CommandListener)
@@ -249,9 +276,9 @@ class MongoClientSettingsSpecification extends Specification {
         when:
         // A regression test so that if anymore methods are added then the builder(final MongoClientSettings settings) should be updated
         def actual = MongoClientSettings.Builder.declaredFields.grep {  !it.synthetic } *.name.sort()
-        def expected = ['clusterSettings', 'codecRegistry', 'commandListeners', 'connectionPoolSettings', 'credentialList',
-                        'heartbeatSocketSettings', 'readConcern', 'readPreference', 'serverSettings', 'socketSettings', 'sslSettings',
-                        'streamFactoryFactory', 'writeConcern']
+        def expected = ['applicationName', 'clusterSettings', 'codecRegistry', 'commandListeners', 'connectionPoolSettings',
+                        'credentialList', 'heartbeatSocketSettings', 'readConcern', 'readPreference', 'serverSettings', 'socketSettings',
+                        'sslSettings', 'streamFactoryFactory', 'writeConcern']
 
         then:
         actual == expected

driver-core/src/main/com/mongodb/ConnectionString.java

@@ -178,6 +178,11 @@
  *   Deprecated, please use {@code authMechanismProperties=SERVICE_NAME:string} instead.
  * </li>
  * </ul>
+ * <p>Server Handshake configuration:</p>
+ * <ul>
+ * <li>{@code appName=string}: Sets the logical name of the application.  The application name may be used by the client to identify
+ * the application to the server, for use in server logs, slow query logs, and profile collection.</li>
+ * </ul>
  *
  * @mongodb.driver.manual reference/connection-string Connection String Format
  * @since 3.0.0
@@ -214,6 +219,7 @@ public class ConnectionString {
     private Integer serverSelectionTimeout;
     private Integer localThreshold;
     private Integer heartbeatFrequency;
+    private String applicationName;
 
     /**
      * Creates a ConnectionString from the given string.
@@ -329,6 +335,8 @@ public ConnectionString(final String connectionString) {
         GENERAL_OPTIONS_KEYS.add("localthresholdms");
         GENERAL_OPTIONS_KEYS.add("heartbeatfrequencyms");
 
+        GENERAL_OPTIONS_KEYS.add("appname");
+
         READ_PREFERENCE_KEYS.add("readpreference");
         READ_PREFERENCE_KEYS.add("readpreferencetags");
         READ_PREFERENCE_KEYS.add("maxstalenessms");
@@ -399,6 +407,8 @@ private void translateOptions(final Map<String, List<String>> optionsMap) {
                 localThreshold = parseInteger(value, "localthresholdms");
             } else if (key.equals("heartbeatfrequencyms")) {
                 heartbeatFrequency = parseInteger(value, "heartbeatfrequencyms");
+            } else if (key.equals("appname")) {
+                applicationName = value;
             }
         }
 
@@ -975,6 +985,19 @@ public Integer getHeartbeatFrequency() {
         return heartbeatFrequency;
     }
 
+    /**
+     * Gets the logical name of the application.  The application name may be used by the client to identify the application to the server,
+     * for use in server logs, slow query logs, and profile collection.
+     *
+     * <p>Default is null.</p>
+     *
+     * @return the application name, which may be null
+     * @since 3.4
+     * @mongodb.server.release 3.4
+     */
+    public String getApplicationName() {
+        return applicationName;
+    }
 
     @Override
     public String toString() {
@@ -1047,6 +1070,9 @@ public boolean equals(final Object o) {
         if (writeConcern != null ? !writeConcern.equals(that.writeConcern) : that.writeConcern != null) {
             return false;
         }
+        if (applicationName != null ? !applicationName.equals(that.applicationName) : that.applicationName != null) {
+            return false;
+        }
 
         return true;
     }
@@ -1071,6 +1097,7 @@ public int hashCode() {
         result = 31 * result + (socketTimeout != null ? socketTimeout.hashCode() : 0);
         result = 31 * result + (sslEnabled != null ? sslEnabled.hashCode() : 0);
         result = 31 * result + (requiredReplicaSetName != null ? requiredReplicaSetName.hashCode() : 0);
+        result = 31 * result + (applicationName != null ? applicationName.hashCode() : 0);
         return result;
     }
 }