fix

Author: mtrezza

spec/MongoStorageAdapter.spec.js

@@ -931,5 +931,136 @@ describe_only_db('mongo')('MongoStorageAdapter', () => {
 
       await adapter.handleShutdown();
     });
+
+    it('should handle invalid log level gracefully', async () => {
+      const logger = require('../lib/logger').logger;
+      const infoSpy = spyOn(logger, 'info');
+
+      const clientLogEvents = [
+        {
+          name: 'connectionPoolReady',
+          keys: ['address'],
+          logLevel: 'invalidLogLevel', // Invalid log level
+        },
+      ];
+
+      const adapter = new MongoStorageAdapter({
+        uri: databaseURI,
+        mongoOptions: { clientLogEvents },
+      });
+
+      await adapter.connect();
+
+      const mockEvent = {
+        address: 'localhost:27017',
+      };
+
+      adapter.client.emit('connectionPoolReady', mockEvent);
+
+      // Should fallback to 'info' level
+      expect(infoSpy).toHaveBeenCalledWith(
+        jasmine.stringMatching(/MongoDB client event connectionPoolReady:.*"address":"localhost:27017"/)
+      );
+
+      await adapter.handleShutdown();
+    });
+
+    it('should handle Map and Set instances in events', async () => {
+      const logger = require('../lib/logger').logger;
+      const warnSpy = spyOn(logger, 'warn');
+
+      const clientLogEvents = [
+        {
+          name: 'customEvent',
+          logLevel: 'warn',
+        },
+      ];
+
+      const adapter = new MongoStorageAdapter({
+        uri: databaseURI,
+        mongoOptions: { clientLogEvents },
+      });
+
+      await adapter.connect();
+
+      const mockEvent = {
+        mapData: new Map([['key1', 'value1'], ['key2', 'value2']]),
+        setData: new Set([1, 2, 3]),
+      };
+
+      adapter.client.emit('customEvent', mockEvent);
+
+      // Should serialize Map and Set properly
+      expect(warnSpy).toHaveBeenCalledWith(
+        jasmine.stringMatching(/MongoDB client event customEvent:.*"mapData":\{"key1":"value1","key2":"value2"\}.*"setData":\[1,2,3\]/)
+      );
+
+      await adapter.handleShutdown();
+    });
+
+    it('should handle missing keys in event object', async () => {
+      const logger = require('../lib/logger').logger;
+      const infoSpy = spyOn(logger, 'info');
+
+      const clientLogEvents = [
+        {
+          name: 'testEvent',
+          keys: ['nonexistent.nested.key', 'another.missing'],
+          logLevel: 'info',
+        },
+      ];
+
+      const adapter = new MongoStorageAdapter({
+        uri: databaseURI,
+        mongoOptions: { clientLogEvents },
+      });
+
+      await adapter.connect();
+
+      const mockEvent = {
+        actualField: 'value',
+      };
+
+      adapter.client.emit('testEvent', mockEvent);
+
+      // Should handle missing keys gracefully with undefined values
+      expect(infoSpy).toHaveBeenCalledWith(
+        jasmine.stringMatching(/MongoDB client event testEvent:/)
+      );
+
+      await adapter.handleShutdown();
+    });
+
+    it('should handle circular references with fallback warning', async () => {
+      const logger = require('../lib/logger').logger;
+      const warnSpy = spyOn(logger, 'warn');
+
+      const clientLogEvents = [
+        {
+          name: 'circularEvent',
+          logLevel: 'info',
+        },
+      ];
+
+      const adapter = new MongoStorageAdapter({
+        uri: databaseURI,
+        mongoOptions: { clientLogEvents },
+      });
+
+      await adapter.connect();
+
+      // Create circular reference
+      const mockEvent = { name: 'test' };
+      mockEvent.self = mockEvent;
+
+      adapter.client.emit('circularEvent', mockEvent);
+
+      // Should fallback to warning when JSON.stringify fails
+      expect(warnSpy).toHaveBeenCalledWith(
+        jasmine.stringMatching(/MongoDB client event circularEvent logged with error:/)
+      );
+
+      await adapter.handleShutdown();
+    });
   });
 });

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -211,22 +211,35 @@ export class MongoStorageAdapter implements StorageAdapter {
         if (this._clientLogEvents && Array.isArray(this._clientLogEvents)) {
           this._clientLogEvents.forEach(eventConfig => {
             client.on(eventConfig.name, event => {
-              let logData = {};
-              if (!eventConfig.keys || eventConfig.keys.length === 0) {
-                logData = event;
-              } else {
-                eventConfig.keys.forEach(keyPath => {
-                  const keyParts = keyPath.split('.');
-                  let value = event;
-                  keyParts.forEach(part => {
-                    value = value ? value[part] : undefined;
+              try {
+                let logData = {};
+                if (!eventConfig.keys || eventConfig.keys.length === 0) {
+                  logData = event;
+                } else {
+                  eventConfig.keys.forEach(keyPath => {
+                    logData[keyPath] = _.get(event, keyPath);
                   });
-                  logData[keyPath] = value;
-                });
+                }
+
+                // Validate log level exists, fallback to 'info'
+                const logLevel = typeof logger[eventConfig.logLevel] === 'function' ? eventConfig.logLevel : 'info';
+
+                // Safe JSON serialization with Map/Set support
+                const logMessage = `MongoDB client event ${eventConfig.name}: ${JSON.stringify(logData, (key, value) => {
+                  if (value instanceof Map) {
+                    return Object.fromEntries(value);
+                  }
+                  if (value instanceof Set) {
+                    return Array.from(value);
+                  }
+                  return value;
+                })}`;
+
+                logger[logLevel](logMessage);
+              } catch (error) {
+                // Fallback if serialization completely fails
+                logger.warn(`MongoDB client event ${eventConfig.name} logged with error: ${error.message}`);
               }
-
-              const logMessage = `MongoDB client event ${eventConfig.name}: ${JSON.stringify(logData)}`;
-              logger[eventConfig.logLevel](logMessage);
             });
           });
         }

src/Options/docs.js

@@ -608,6 +608,15 @@ export interface FileUploadOptions {
   enableForPublic: ?boolean;
 }
 
+export type ClientLogEvent = {
+  /* The MongoDB driver event name to listen for. */
+  name: string,
+  /* Optional array of dot-notation paths to extract specific data from the event object. If not provided or empty, the entire event object will be logged. */
+  keys?: string[],
+  /* The log level to use for this event. */
+  logLevel: string,
+};
+
 export interface DatabaseOptions {
   /* Enables database real-time hooks to update single schema cache. Set to `true` if using multiple Parse Servers instances connected to the same database. Failing to do so will cause a schema change to not propagate to all instances and re-syncing will only happen when the instances restart. To use this feature with MongoDB, a replica set cluster with [change stream](https://docs.mongodb.com/manual/changeStreams/#availability) support is required.
   :DEFAULT: false */
@@ -726,7 +735,7 @@ export interface DatabaseOptions {
   /* Set to `true` to disable validation of index fields. When disabled, indexes can be created even if the fields do not exist in the schema. This can be useful when creating indexes on fields that will be added later. */
   disableIndexFieldValidation: ?boolean;
   /* An array of MongoDB client event configurations to enable logging of specific events. Each configuration object should contain:<br><ul><li>`name` (the event name, e.g., 'topologyDescriptionChanged', 'serverDescriptionChanged', 'connectionPoolCleared', 'connectionPoolReady')</li><li>`keys` (optional array of dot-notation paths to extract specific data from the event object; if not provided or empty, the entire event object will be logged)</li><li>`logLevel` (the log level to use for this event: 'error', 'warn', 'info', 'debug', etc.).</li></ul> */
-  clientLogEvents: ?(any[]);
+  clientLogEvents: ?(ClientLogEvent[]);
 }
 
 export interface AuthAdapter {