feat: Add option to change the log level of the logs emitted by triggers

spec/CloudCodeLogger.spec.js

@@ -182,6 +182,60 @@ describe('Cloud Code Logger', () => {
     });
   });
 
+  it('should log cloud function triggers using the custom log level', async done => {
+    Parse.Cloud.beforeSave('TestClass', () => {});
+    Parse.Cloud.afterSave('TestClass', () => {});
+
+    {
+      await reconfigureServer({
+        silent: true,
+        logLevel: 'silly',
+        logLevelUses: {
+          triggerAfterHook: 'debug',
+          triggerSuccessBeforeHook: 'silly',
+        },
+      });
+
+      spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
+
+      const obj = new Parse.Object('TestClass');
+      await obj.save();
+
+      let log = spy.calls.argsFor(1);
+      expect(log[0]).toEqual('silly');
+      expect(log[1]).toMatch(/beforeSave triggered for TestClass for user .*/);
+
+      log = spy.calls.argsFor(2);
+      expect(log[0]).toEqual('debug');
+      expect(log[1]).toMatch(/afterSave triggered for TestClass for user .*/);
+    }
+
+    {
+      await reconfigureServer({
+        silent: true,
+        logLevel: 'info',
+        logLevelUses: {
+          triggerSuccessBeforeHook: 'none',
+          triggerErrorBeforeHook: 'warn',
+        },
+      });
+
+      spy = spyOn(Config.get('test').loggerController.adapter, 'log').and.callThrough();
+
+      const obj = new Parse.Object('TestClass');
+      await obj.save();
+
+      let log = spy.calls.argsFor(1);
+      expect(log[0]).toEqual('warn');
+      expect(log[1]).toMatch('afterSave caught an error');
+
+      log = spy.calls.argsFor(2);
+      expect(log).toEqual([]);
+    }
+
+    done();
+  });
+
   it('should log cloud function failure', done => {
     Parse.Cloud.define('aFunction', () => {
       throw 'it failed!';

src/Config.js

@@ -15,6 +15,7 @@ import {
   ParseServerOptions,
 } from './Options/Definitions';
 import { isBoolean, isString } from 'lodash';
+import { logLevels } from './Controllers/LoggerController';
 
 function removeTrailingSlash(str) {
   if (!str) {
@@ -82,6 +83,7 @@ export class Config {
     schema,
     requestKeywordDenylist,
     allowExpiredAuthDataToken,
+    logLevelUses,
   }) {
     if (masterKey === readOnlyMasterKey) {
       throw new Error('masterKey and readOnlyMasterKey should be different');
@@ -123,6 +125,7 @@ export class Config {
     this.validateEnforcePrivateUsers(enforcePrivateUsers);
     this.validateAllowExpiredAuthDataToken(allowExpiredAuthDataToken);
     this.validateRequestKeywordDenylist(requestKeywordDenylist);
+    this.validateLogLevelUses(logLevelUses);
   }
 
   static validateRequestKeywordDenylist(requestKeywordDenylist) {
@@ -501,6 +504,15 @@ export class Config {
     }
   }
 
+  static validateLogLevelUses(logLevelUses) {
+    const possibleValues = ['none', ...logLevels];
+    for (const entry of Object.entries(logLevelUses)) {
+      if (possibleValues.indexOf(entry[1]) === -1) {
+        throw entry[0] + ' must be one of theses ' + possibleValues;
+      }
+    }
+  }
+
   generateEmailVerifyTokenExpiresAt() {
     if (!this.verifyUserEmails || !this.emailVerifyTokenValidityDuration) {
       return undefined;

src/Controllers/LoggerController.js

@@ -16,7 +16,7 @@ export const LogOrder = {
   ASCENDING: 'asc',
 };
 
-const logLevels = ['error', 'warn', 'info', 'debug', 'verbose', 'silly'];
+export const logLevels = ['error', 'warn', 'info', 'debug', 'verbose', 'silly'];
 
 export class LoggerController extends AdaptableController {
   constructor(adapter, appId, options = { logLevel: 'info' }) {

src/Options/Definitions.js

@@ -290,6 +290,16 @@ module.exports.ParseServerOptions = {
     env: 'PARSE_SERVER_LOG_LEVEL',
     help: 'Sets the level for logs',
   },
+  logLevelUses: {
+    env: 'PARSE_SERVER_LOG_LEVEL_USES',
+    help: 'Set the level used internally by Parse Server features',
+    action: parsers.objectParser,
+    default: {
+      triggerAfterHook: 'info',
+      triggerSuccessBeforeHook: 'info',
+      triggerErrorBeforeHook: 'error',
+    },
+  },
   logsFolder: {
     env: 'PARSE_SERVER_LOGS_FOLDER',
     help: "Folder for the logs (defaults to './logs'); set to null to disable file based logging",

src/Options/docs.js

@@ -56,6 +56,7 @@
  * @property {LiveQueryServerOptions} liveQueryServerOptions Live query server configuration options (will start the liveQuery server)
  * @property {Adapter<LoggerAdapter>} loggerAdapter Adapter module for the logging sub-system
  * @property {String} logLevel Sets the level for logs
+ * @property {LogLevelUses} logLevelUses Set the level used internally by Parse Server features
  * @property {String} logsFolder Folder for the logs (defaults to './logs'); set to null to disable file based logging
  * @property {String} masterKey Your Parse Master Key
  * @property {String[]} masterKeyIps (Optional) Restricts the use of master key permissions to a list of IP addresses.<br><br>This option accepts a list of single IP addresses, for example:<br>`['10.0.0.1', '10.0.0.2']`<br><br>You can also use CIDR notation to specify an IP address range, for example:<br>`['10.0.1.0/24']`<br><br>Special cases:<br>- Setting an empty array `[]` means that `masterKey`` cannot be used even in Parse Server Cloud Code.<br>- Setting `['0.0.0.0/0']` means disabling the filter and the master key can be used from any IP address.<br><br>To connect Parse Dashboard from a different server requires to add the IP address of the server that hosts Parse Dashboard because Parse Dashboard uses the master key.<br><br>Defaults to `['127.0.0.1']` which means that only `localhost`, the server itself, is allowed to use the master key.
@@ -215,3 +216,10 @@
  * @interface AuthAdapter
  * @property {Boolean} enabled Is `true` if the auth adapter is enabled, `false` otherwise.
  */
+
+/**
+ * @interface LogLevelUses
+ * @property {Boolean} triggerAfterHook Log level used by the after hook trigger, default is 'info'.
+ * @property {Boolean} triggerSuccessBeforeHook Log level used by the success before hook trigger, default is 'info.
+ * @property {Boolean} triggerErrorBeforeHook Log level used by the error before hook trigger, default is 'error.
+ */

src/Options/index.js

@@ -81,6 +81,9 @@ export interface ParseServerOptions {
   verbose: ?boolean;
   /* Sets the level for logs */
   logLevel: ?string;
+  /* Set the level used internally by Parse Server features
+  :ENV: PARSE_SERVER_LOG_LEVEL_USES */
+  logLevelUses: ?LogLevelUses;
   /* Maximum number of logs to keep. If not set, no logs will be removed. This can be a number of files or number of days. If using days, add 'd' as the suffix. (default: null) */
   maxLogFiles: ?NumberOrString;
   /* Disables console output
@@ -520,3 +523,18 @@ export interface AuthAdapter {
   */
   enabled: ?boolean;
 }
+
+export interface LogLevelUses {
+  /* Log level used by the after hook trigger, default is 'info'.
+  :DEFAULT: 'info'
+  */
+  triggerAfterHook: ?string;
+  /* Log level used by the success before hook trigger, default is 'info.
+  :DEFAULT: 'info'
+  */
+  triggerSuccessBeforeHook: ?string;
+  /* Log level used by the error before hook trigger, default is 'error.
+  :DEFAULT: 'error'
+  */
+  triggerErrorBeforeHook: ?string;
+}

src/triggers.js

@@ -373,48 +373,54 @@ function userIdForLog(auth) {
   return auth && auth.user ? auth.user.id : undefined;
 }
 
-function logTriggerAfterHook(triggerType, className, input, auth) {
+function logTriggerAfterHook(triggerType, className, input, auth, logLevel) {
   const cleanInput = logger.truncateLogMessage(JSON.stringify(input));
-  logger.info(
-    `${triggerType} triggered for ${className} for user ${userIdForLog(
-      auth
-    )}:\n  Input: ${cleanInput}`,
-    {
-      className,
-      triggerType,
-      user: userIdForLog(auth),
-    }
-  );
+  if (logLevel !== 'none') {
+    logger[logLevel](
+      `${triggerType} triggered for ${className} for user ${userIdForLog(
+        auth
+      )}:\n  Input: ${cleanInput}`,
+      {
+        className,
+        triggerType,
+        user: userIdForLog(auth),
+      }
+    );
+  }
 }
 
-function logTriggerSuccessBeforeHook(triggerType, className, input, result, auth) {
+function logTriggerSuccessBeforeHook(triggerType, className, input, result, auth, logLevel) {
   const cleanInput = logger.truncateLogMessage(JSON.stringify(input));
   const cleanResult = logger.truncateLogMessage(JSON.stringify(result));
-  logger.info(
-    `${triggerType} triggered for ${className} for user ${userIdForLog(
-      auth
-    )}:\n  Input: ${cleanInput}\n  Result: ${cleanResult}`,
-    {
-      className,
-      triggerType,
-      user: userIdForLog(auth),
-    }
-  );
+  if (logLevel !== 'none') {
+    logger[logLevel](
+      `${triggerType} triggered for ${className} for user ${userIdForLog(
+        auth
+      )}:\n  Input: ${cleanInput}\n  Result: ${cleanResult}`,
+      {
+        className,
+        triggerType,
+        user: userIdForLog(auth),
+      }
+    );
+  }
 }
 
-function logTriggerErrorBeforeHook(triggerType, className, input, auth, error) {
+function logTriggerErrorBeforeHook(triggerType, className, input, auth, error, logLevel) {
   const cleanInput = logger.truncateLogMessage(JSON.stringify(input));
-  logger.error(
-    `${triggerType} failed for ${className} for user ${userIdForLog(
-      auth
-    )}:\n  Input: ${cleanInput}\n  Error: ${JSON.stringify(error)}`,
-    {
-      className,
-      triggerType,
-      error,
-      user: userIdForLog(auth),
-    }
-  );
+  if (logLevel !== 'none') {
+    logger[logLevel](
+      `${triggerType} failed for ${className} for user ${userIdForLog(
+        auth
+      )}:\n  Input: ${cleanInput}\n  Error: ${JSON.stringify(error)}`,
+      {
+        className,
+        triggerType,
+        error,
+        user: userIdForLog(auth),
+      }
+    );
+  }
 }
 
 export function maybeRunAfterFindTrigger(
@@ -444,7 +450,14 @@ export function maybeRunAfterFindTrigger(
         reject(error);
       }
     );
-    logTriggerSuccessBeforeHook(triggerType, className, 'AfterFind', JSON.stringify(objects), auth);
+    logTriggerSuccessBeforeHook(
+      triggerType,
+      className,
+      'AfterFind',
+      JSON.stringify(objects),
+      auth,
+      config.logLevelUses.triggerSuccessBeforeHook
+    );
     request.objects = objects.map(object => {
       //setting the class name to transform into parse object
       object.className = className;
@@ -468,7 +481,13 @@ export function maybeRunAfterFindTrigger(
       })
       .then(success, error);
   }).then(results => {
-    logTriggerAfterHook(triggerType, className, JSON.stringify(results), auth);
+    logTriggerAfterHook(
+      triggerType,
+      className,
+      JSON.stringify(results),
+      auth,
+      config.logLevelUses.triggerAfterHook
+    );
     return results;
   });
 }
@@ -842,7 +861,8 @@ export function maybeRunTrigger(
           parseObject.className,
           parseObject.toJSON(),
           object,
-          auth
+          auth,
+          config.logLevelUses.triggerSuccessBeforeHook
         );
         if (
           triggerType === Types.beforeSave ||
@@ -860,7 +880,8 @@ export function maybeRunTrigger(
           parseObject.className,
           parseObject.toJSON(),
           auth,
-          error
+          error,
+          config.logLevelUses.triggerErrorBeforeHook
         );
         reject(error);
       }
@@ -885,7 +906,13 @@ export function maybeRunTrigger(
           triggerType === Types.afterDelete ||
           triggerType === Types.afterLogin
         ) {
-          logTriggerAfterHook(triggerType, parseObject.className, parseObject.toJSON(), auth);
+          logTriggerAfterHook(
+            triggerType,
+            parseObject.className,
+            parseObject.toJSON(),
+            auth,
+            config.logLevelUses.triggerAfterHook
+          );
         }
         // beforeSave is expected to return null (nothing)
         if (triggerType === Types.beforeSave) {
@@ -965,7 +992,8 @@ export async function maybeRunFileTrigger(triggerType, fileObject, config, auth)
         'Parse.File',
         { ...fileObject.file.toJSON(), fileSize: fileObject.fileSize },
         result,
-        auth
+        auth,
+        config.logLevelUses.triggerSuccessBeforeHook
       );
       return result || fileObject;
     } catch (error) {
@@ -974,7 +1002,8 @@ export async function maybeRunFileTrigger(triggerType, fileObject, config, auth)
         'Parse.File',
         { ...fileObject.file.toJSON(), fileSize: fileObject.fileSize },
         auth,
-        error
+        error,
+        config.logLevelUses.triggerErrorBeforeHook
       );
       throw error;
     }