Journalisation des requêtes MongoDB avec Spring Boot

1. Présentation

Lors de l'utilisation de Spring Data MongoDB, nous devrons peut-être nous connecter à un niveau supérieur à celui par défaut. En règle générale, nous pouvons avoir besoin de voir, par exemple, des informations supplémentaires telles que les exécutions d'instructions ou les paramètres de requête.

Dans ce court tutoriel, nous verrons comment modifier le niveau de journalisation MongoDB pour les requêtes.

2. Configurer la journalisation des requêtes MongoDB

Le support MongoDB propose les MongoOperations interface ou son MongoTemplate principal implémentation pour accéder aux données, donc tout ce dont nous avons besoin est de configurer un niveau de débogage pour le MongoTemplate classe.

Comme toute application Spring ou Java, nous pouvons utiliser une bibliothèque de journalisation et définir un niveau de journalisation pour MongoTemplate .

Typiquement, nous pouvons écrire dans notre fichier de configuration quelque chose comme :

<logger name="org.springframework.data.mongodb.core.MongoTemplate" level="DEBUG" />

Cependant, si nous exécutons une application Spring Boot , nous pouvons le configurer dans notre application.properties fichier :

logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG

De même, nous pouvons utiliser le YAML syntaxe :

logging:
  level:
    org:
      springframework:
        data:
          mongodb:
            core:
              MongoTemplate: DEBUG

3. Classe de test pour la journalisation

Commençons par créer un livre classe :

@Document(collection = "book")
public class Book {

    @MongoId
    private ObjectId id;
    private String bookName;
    private String authorName;

    // getters and setters
}

Nous voulons créer une classe de test simple et vérifier les journaux.

Pour le démontrer, nous utilisons Embedded MongoDB. Pour être sûr, vérifions d'abord nos dépendances :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>de.flapdoodle.embed</groupId>
    <artifactId>de.flapdoodle.embed.mongo</artifactId>
    <version>${embed.mongo.version}</version>
    <scope>test</scope>
</dependency>

Enfin, définissons notre classe de test à l'aide de Spring Boot Test :

@SpringBootTest
@TestPropertySource(properties = { "logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG" })
public class LoggingUnitTest {

    private static final String CONNECTION_STRING = "mongodb://%s:%d";

    private MongodExecutable mongodExecutable;
    private MongoTemplate mongoTemplate;

    @AfterEach
    void clean() {
        mongodExecutable.stop();
    }

    @BeforeEach
    void setup() throws Exception {
        String ip = "localhost";
        int port = 27017;

        ImmutableMongodConfig mongodbConfig = MongodConfig.builder()
          .version(Version.Main.PRODUCTION)
          .net(new Net(ip, port, Network.localhostIsIPv6()))
          .build();

        MongodStarter starter = MongodStarter.getDefaultInstance();
        mongodExecutable = starter.prepare(mongodbConfig);
        mongodExecutable.start();
        mongoTemplate = new MongoTemplate(MongoClients.create(String.format(CONNECTION_STRING, ip, port)), "test");
    }
    // tests
}

4. Échantillons de journaux

Dans cette section, nous allons définir quelques cas de test simples et afficher les journaux relatifs pour tester les scénarios les plus courants, tels que la recherche, l'insertion, la mise à jour ou l'agrégation de Document s.

4.1. Insérer

Tout d'abord, commençons par insérer un seul Document :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

Les journaux montrent dans quelle collection nous insérons. Lors de la recherche d'un Document , l'identifiant est également enregistré :

[2022-03-20 17:42:47,093]-[main] DEBUG MongoTemplate - Inserting Document containing fields: [bookName, authorName, _class] in collection: book
...
[2022-03-20 17:42:47,144]-[main] DEBUG MongoTemplate - findOne using query: { "id" : { "$oid" : "623759871ff6275fe96a5ecb"}} fields: Document{{}} for class: class com.baeldung.mongodb.models.Book in collection: book
[2022-03-20 17:42:47,149]-[main] DEBUG MongoTemplate - findOne using query: { "_id" : { "$oid" : "623759871ff6275fe96a5ecb"}} fields: {} in db.collection: test.book

4.2. Mettre à jour

De même, lors de la mise à jour d'un Document :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

String authorNameUpdate = "AuthorNameUpdate";

book.setAuthorName(authorNameUpdate);
mongoTemplate.updateFirst(query(where("bookName").is("Book")), update("authorName", authorNameUpdate), Book.class);

Nous pouvons voir le document mis à jour champ dans les logs :

[2022-03-20 17:48:31,759]-[main] DEBUG MongoTemplate - Calling update using query: { "bookName" : "Book"} and update: { "$set" : { "authorName" : "AuthorNameUpdate"}} in collection: book

4.3. Insertion par lots

Ajoutons un exemple pour une insertion par lot :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

Book book1 = new Book();
book1.setBookName("Book1");
book1.setAuthorName("Author1");

mongoTemplate.insert(Arrays.asList(book, book1), Book.class);

Nous pouvons voir le nombre de Documents insérés s dans les journaux :

[2022-03-20 17:52:00,564]-[main] DEBUG MongoTemplate - Inserting list of Documents containing 2 items

4.4. Supprimer

Ajoutons également un exemple de suppression :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

mongoTemplate.remove(book);

On peut voir dans les logs, dans ce cas, l'id du Document supprimé :

[2022-03-20 17:56:42,151]-[main] DEBUG MongoTemplate - Remove using query: { "_id" : { "$oid" : "62375cca2a2cba4db774d8c1"}} in collection: book.

4.5. Agrégation

Voyons un exemple pour Agrégation . Dans ce cas, nous devons définir une classe de résultats. Par exemple, nous allons agréger par nom d'auteur :

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Ensuite, définissons un cas de test pour le regroupement :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

Book book1 = new Book();
book1.setBookName("Book1");
book1.setAuthorName("Author");

Book book2 = new Book();
book2.setBookName("Book2");
book2.setAuthorName("Author");

mongoTemplate.insert(Arrays.asList(book, book1, book2), Book.class);

GroupOperation groupByAuthor = group("authorName")
  .count()
  .as("authCount");

Aggregation aggregation = newAggregation(groupByAuthor);

AggregationResults<GroupByAuthor> aggregationResults = mongoTemplate.aggregate(aggregation, "book", GroupByAuthor.class);

Nous pouvons voir dans les journaux par quel champ nous avons agrégé et quel type de pipeline d'agrégation :

[2022-03-20 17:58:51,237]-[main] DEBUG MongoTemplate - Executing aggregation: [{ "$group" : { "_id" : "$authorName", "authCount" : { "$sum" : 1}}}] in collection book