Add collectionName and databaseName attributes to MongoDbProvider

log4j-mongodb/pom.xml

@@ -76,6 +76,7 @@
     <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-api</artifactId>
+      <version>3.0.0-SNAPSHOT</version>
     </dependency>
 
     <dependency>
@@ -141,7 +142,11 @@
       <artifactId>junit-jupiter-api</artifactId>
       <scope>test</scope>
     </dependency>
-
+      <dependency>
+          <groupId>junit</groupId>
+          <artifactId>junit</artifactId>
+          <scope>test</scope>
+      </dependency>
   </dependencies>
 
   <build>
@@ -151,7 +156,7 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
         <configuration>
-          <skip>true</skip>
+          <skip>false</skip>
         </configuration>
         <dependencies>
 

log4j-mongodb/src/main/java/org/apache/logging/log4j/mongodb/MongoDbConnection.java

@@ -59,20 +59,19 @@ private static MongoCollection<Document> getOrCreateMongoCollection(
         }
     }
 
-    private final ConnectionString connectionString;
+
     private final MongoCollection<Document> collection;
     private final MongoClient mongoClient;
 
     public MongoDbConnection(
-            final ConnectionString connectionString,
             final MongoClient mongoClient,
             final MongoDatabase mongoDatabase,
+            final String collectionName,
             final boolean isCapped,
             final Long sizeInBytes) {
-        this.connectionString = connectionString;
         this.mongoClient = mongoClient;
         this.collection =
-                getOrCreateMongoCollection(mongoDatabase, connectionString.getCollection(), isCapped, sizeInBytes);
+                getOrCreateMongoCollection(mongoDatabase, collectionName, isCapped, sizeInBytes);
     }
 
     @Override
@@ -107,7 +106,15 @@ public void insertObject(final NoSqlObject<Document> object) {
     @Override
     public String toString() {
         return String.format(
-                "Mongo4Connection [connectionString=%s, collection=%s, mongoClient=%s]",
-                connectionString, collection, mongoClient);
+                "Mongo4Connection [collection=%s, mongoClient=%s]", collection, mongoClient);
+    }
+
+    /*
+     * This method is exposed to help support unit tests for the MongoDbProvider class.
+     *
+     */
+    public MongoCollection<Document> getCollection(){
+        return this.collection;
     }
+
 }

log4j-mongodb/src/main/java/org/apache/logging/log4j/mongodb/MongoDbProvider.java

@@ -18,6 +18,7 @@
 
 import com.mongodb.ConnectionString;
 import com.mongodb.MongoClientSettings;
+import com.mongodb.MongoNamespace;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoClients;
 import com.mongodb.client.MongoDatabase;
@@ -57,12 +58,40 @@ public static class Builder<B extends Builder<B>> extends AbstractFilterable.Bui
         @PluginAttribute("collectionName")
         private String collectionName = null;
 
-        @PluginAttribute("datbaseName")
+        @PluginAttribute("databaseName")
         private String databaseName = null;
 
         @Override
         public MongoDbProvider build() {
-            return new MongoDbProvider(connectionStringSource, capped, collectionSize, databaseName, collectionName);
+            LOGGER.debug("Creating ConnectionString {}...", connectionStringSource);
+            ConnectionString connectionString;
+            try {
+                connectionString = new ConnectionString(connectionStringSource);
+            } catch (final IllegalArgumentException e) {
+                LOGGER.error("Invalid MongoDB connection string `{}`.", connectionStringSource, e);
+                return null;
+            }
+
+            String effectiveDatabaseName = databaseName != null ? databaseName : connectionString.getDatabase();
+            String effectiveCollectionName = collectionName != null ? collectionName: connectionString.getCollection();
+            // Validate the provided databaseName property
+            try {
+                MongoNamespace.checkDatabaseNameValidity(effectiveDatabaseName);
+                databaseName = effectiveDatabaseName;
+            } catch (final IllegalArgumentException e) {
+                LOGGER.error("Invalid MongoDB database name `{}`.", effectiveDatabaseName, e);
+                return null;
+            }
+            // Validate the provided collectionName property
+            try {
+                MongoNamespace.checkCollectionNameValidity(effectiveCollectionName);
+                collectionName = effectiveCollectionName;
+            } catch (final IllegalArgumentException e) {
+                LOGGER.error("Invalid MongoDB collection name `{}`.", effectiveCollectionName, e);
+                return null;
+            }
+
+            return new MongoDbProvider(connectionString, capped, collectionSize, databaseName, collectionName);
         }
 
         public B setConnectionStringSource(final String connectionStringSource) {
@@ -111,62 +140,48 @@ public static <B extends Builder<B>> B newBuilder() {
     private final Long collectionSize;
     private final boolean isCapped;
     private final String collectionName;
-    private final String databaseName;
     private final MongoClient mongoClient;
     private final MongoDatabase mongoDatabase;
     private final ConnectionString connectionString;
 
-    private MongoDbProvider(
-            final String connectionStringSource,
-            final boolean isCapped,
-            final Long collectionSize,
-            final String databaseName,
-            final String collectionName) {
-        LOGGER.debug("Creating ConnectionString {}...", connectionStringSource);
-        this.connectionString = new ConnectionString(connectionStringSource);
+    private MongoDbProvider(final ConnectionString connectionString, final boolean isCapped, final Long collectionSize, final String databaseName, final String collectionName) {
+
         LOGGER.debug("Created ConnectionString {}", connectionString);
+        this.connectionString = connectionString;
         LOGGER.debug("Creating MongoClientSettings...");
         // @formatter:off
         final MongoClientSettings settings = MongoClientSettings.builder()
-                .applyConnectionString(this.connectionString)
+                .applyConnectionString(connectionString)
                 .codecRegistry(CODEC_REGISTRIES)
                 .build();
         // @formatter:on
         LOGGER.debug("Created MongoClientSettings {}", settings);
         LOGGER.debug("Creating MongoClient {}...", settings);
         this.mongoClient = MongoClients.create(settings);
         LOGGER.debug("Created MongoClient {}", mongoClient);
-        if (databaseName == null || databaseName.isEmpty()) {
-            this.databaseName = this.connectionString.getDatabase();
-        } else {
-            this.databaseName = databaseName;
-        }
-        LOGGER.debug("Getting MongoDatabase {}...", this.databaseName);
-        this.mongoDatabase = this.mongoClient.getDatabase(this.databaseName);
+        LOGGER.debug("Getting MongoDatabase {}...", databaseName);
+        this.mongoDatabase = this.mongoClient.getDatabase(databaseName);
         LOGGER.debug("Got MongoDatabase {}", mongoDatabase);
-        if (collectionName == null || collectionName.isEmpty()) {
-            this.collectionName = this.connectionString.getCollection();
-        } else {
-            this.collectionName = collectionName;
-        }
+        this.collectionName = collectionName;
         this.isCapped = isCapped;
         this.collectionSize = collectionSize;
     }
 
     @Override
     public MongoDbConnection getConnection() {
-        return new MongoDbConnection(connectionString, mongoClient, mongoDatabase, isCapped, collectionSize);
+        return new MongoDbConnection(mongoClient, mongoDatabase, collectionName, isCapped, collectionSize);
     }
 
     @Override
     public String toString() {
         return String.format(
-                "%s [connectionString=%s, collectionSize=%s, isCapped=%s, mongoClient=%s, mongoDatabase=%s]",
+                "%s [connectionString=%s, collectionSize=%s, isCapped=%s, mongoClient=%s, mongoDatabase=%s, collectionName=%s]",
                 MongoDbProvider.class.getSimpleName(),
                 connectionString,
                 collectionSize,
                 isCapped,
                 mongoClient,
-                mongoDatabase);
+                mongoDatabase,
+                collectionName);
     }
 }

log4j-mongodb/src/test/java/org/apache/logging/log4j/mongodb/MongoDbProviderTest.java

@@ -0,0 +1,108 @@
+package org.apache.logging.log4j.mongodb;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+
+class MongoDbProviderTest {
+
+    private String validConnectionStringWithoutDatabase = "mongodb://localhost:27017";
+    private String invalidConnectionString = "test:test";
+    private String validConnectionStringWithDatabase = "mongodb://localhost:27017/logging";
+    private String validConnectionStringWithDatabaseAndCollection = "mongodb://localhost:27017/logging.logs";
+
+    private String collectionName = "logsTest";
+    private String databaseName = "loggingTest";
+
+
+
+
+    @Test
+    void createProviderWithDatabaseAndCollectionProvidedViaConfig() {
+
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithoutDatabase)
+                .setDatabaseName(this.databaseName)
+                .setCollectionName(this.collectionName)
+                .build();
+
+        assertNotNull("Returned provider is null", provider);
+        assertEquals("Collection names do not match", this.collectionName, provider.getConnection().getCollection().getNamespace().getCollectionName());
+        assertEquals("Database names do not match", this.databaseName, provider.getConnection().getCollection().getNamespace().getDatabaseName());
+
+    }
+
+    @Test
+    void createProviderWithoutDatabaseName() {
+
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithoutDatabase)
+                .build();
+
+        assertNull("Provider should be null but was not", provider);
+
+
+    }
+
+    @Test
+    void createProviderWithoutDatabaseNameWithCollectionName(){
+
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithoutDatabase)
+                .setCollectionName(this.collectionName)
+                .build();
+
+        assertNull("Provider should be null but was not", provider);
+
+
+
+    }
+
+    @Test
+    void createProviderWithoutCollectionName(){
+
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithoutDatabase)
+                .setDatabaseName(this.databaseName)
+                .build();
+
+        assertNull("Provider should be null but was not", provider);
+
+
+    }
+
+    @Test
+    void createProviderWithDatabaseOnConnectionString(){
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithDatabase)
+                .setCollectionName(this.collectionName)
+                .build();
+
+        assertNotNull("Provider should be null but was not", provider);
+        assertEquals("Collection names do not match", this.collectionName, provider.getConnection().getCollection().getNamespace().getCollectionName());
+        assertEquals("Database names do not match", "logging", provider.getConnection().getCollection().getNamespace().getDatabaseName());
+
+    }
+
+    @Test
+    void createProviderConfigOverridesConnectionString() {
+
+        MongoDbProvider provider = MongoDbProvider.newBuilder()
+                .setConnectionStringSource(this.validConnectionStringWithDatabaseAndCollection)
+                .setCollectionName(this.collectionName)
+                .setDatabaseName(this.databaseName)
+                .build();
+
+        assertNotNull("Provider should not be null", provider);
+        assertEquals("Collection name does not match provided configuration", this.collectionName, provider.getConnection().getCollection().getNamespace().getCollectionName());
+        assertEquals("Database name does not match provided configuration", this.databaseName, provider.getConnection().getCollection().getNamespace().getDatabaseName());
+
+    }
+
+
+
+
+}

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo-keys.json

@@ -5,7 +5,9 @@
       "NoSql": {
         "name": "MONGO",
         "MongoDb": {
-          "connection": "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"
+          "connection": "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017",
+          "databaseName": "logging",
+          "collectionName": "logs"
         },
         "KeyValuePair": [
           {

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo-keys.properties

@@ -19,7 +19,10 @@
 Appenders.0.type = NoSql
 Appenders.0.name = MONGO
 Appenders.0.provider.type = MongoDB
-Appenders.0.provider.connection = mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs
+Appenders.0.provider.connection = mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017
+Appenders.0.provider.databaseName = logging
+Appenders.0.provider.collectionName = logs
+
 
 Appenders.0.kv[0].type = KeyValuePair
 Appenders.0.kv[0].key = startTime

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo-keys.xml

@@ -23,7 +23,7 @@
   <Appenders>
     <!-- tag::appender[] -->
     <NoSql name="MONGO">
-      <MongoDb connection="mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"/>
+      <MongoDb connection="mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017" databaseName="logging" collectionName="logs"/>
       <KeyValuePair key="startTime" value="${date:yyyy-MM-dd hh:mm:ss.SSS}"/> <!--1-->
       <KeyValuePair key="currentTime" value="$${date:yyyy-MM-dd hh:mm:ss.SSS}"/> <!--2-->
     </NoSql>

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo-keys.yaml

@@ -20,7 +20,9 @@ Configuration:
     NoSql:
       name: "MONGO"
       MongoDb:
-        connection: "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"
+        connection: "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017"
+        databaseName: "logging"
+        collectionName: "logs"
       KeyValuePair:
         - key: "startTime"
           value: "${date:yyyy-MM-dd hh:mm:ss.SSS}" # <1>

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo.json

@@ -10,7 +10,9 @@
       "NoSql": {
         "name": "MONGO",
         "MongoDb": {
-          "connection": "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"
+          "connection": "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017",
+          "databaseName" : "logging",
+          "collectionName": "logs"
         }
       }
       // end::appender[]

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo.properties

@@ -22,7 +22,9 @@ Appenders.0.layout.type = JsonTemplateLayout
 Appenders.1.type = NoSql
 Appenders.1.name = MONGO
 Appenders.1.provider.type = MongoDB
-Appenders.1.provider.connection = mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs
+Appenders.1.provider.connection = mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017
+Appenders.1.provider.databaseName = logging
+Appenders.1.provider.collectionName = logs
 # end::appender[]
 # tag::loggers[]
 

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo.xml

@@ -27,7 +27,7 @@
     </File>
     <!-- tag::appender[] -->
     <NoSql name="MONGO">
-      <MongoDb connection="mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"/>
+      <MongoDb connection="mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017" databaseName="logging" collectionName="logs"/>
     </NoSql>
     <!-- end::appender[] -->
   </Appenders>

src/site/antora/modules/ROOT/examples/manual/appenders/database/nosql-mongo.yaml

@@ -24,7 +24,9 @@ Configuration:
     NoSql:
       name: "MONGO"
       MongoDb:
-        connection: "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017/logging.logs"
+        connection: "mongodb://${env:DB_USER}:${env:DB_PASS}@localhost:27017"
+        databaseName: "logging"
+        collectionName: "logs"
     # end::appender[]
   Loggers:
     # tag::loggers[]