feat: improved LiveQuery error logging with additional information (#7837)

spec/ParseLiveQuery.spec.js

@@ -319,6 +319,41 @@ describe('ParseLiveQuery', function () {
     await object.save();
   });
 
+  it('can log on afterLiveQueryEvent throw', async () => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+
+    const object = new TestObject();
+    await object.save();
+
+    const logger = require('../lib/logger').logger;
+    spyOn(logger, 'error').and.callFake(() => {});
+
+    let session = undefined;
+    Parse.Cloud.afterLiveQueryEvent('TestObject', ({ sessionToken }) => {
+      session = sessionToken;
+      /* eslint-disable no-undef */
+      foo.bar();
+      /* eslint-enable no-undef */
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', object.id);
+    const subscription = await query.subscribe();
+    object.set({ foo: 'bar' });
+    await object.save();
+    await new Promise(resolve => subscription.on('error', resolve));
+    expect(logger.error).toHaveBeenCalledWith(
+      `Failed running afterLiveQueryEvent on class TestObject for event update with session ${session} with:\n Error: {"message":"foo is not defined","code":141}`
+    );
+  });
+
   it('can handle afterEvent sendEvent to false', async done => {
     await reconfigureServer({
       liveQuery: {
@@ -566,6 +601,33 @@ describe('ParseLiveQuery', function () {
     await query.subscribe();
   });
 
+  it('can log on beforeConnect throw', async () => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+
+    const logger = require('../lib/logger').logger;
+    spyOn(logger, 'error').and.callFake(() => {});
+    let token = undefined;
+    Parse.Cloud.beforeConnect(({ sessionToken }) => {
+      token = sessionToken;
+      /* eslint-disable no-undef */
+      foo.bar();
+      /* eslint-enable no-undef */
+    });
+    new Parse.Query(TestObject).subscribe();
+    await new Promise(resolve => Parse.LiveQuery.on('error', resolve));
+    Parse.LiveQuery.removeAllListeners('error');
+    expect(logger.error).toHaveBeenCalledWith(
+      `Failed running beforeConnect for session ${token} with:\n Error: {"message":"foo is not defined","code":141}`
+    );
+  });
+
   it('can handle beforeSubscribe error', async done => {
     await reconfigureServer({
       liveQuery: {
@@ -594,6 +656,34 @@ describe('ParseLiveQuery', function () {
     });
   });
 
+  it('can log on beforeSubscribe error', async () => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+
+    const logger = require('../lib/logger').logger;
+    spyOn(logger, 'error').and.callFake(() => {});
+
+    Parse.Cloud.beforeSubscribe(TestObject, () => {
+      /* eslint-disable no-undef */
+      foo.bar();
+      /* eslint-enable no-undef */
+    });
+
+    const query = new Parse.Query(TestObject);
+    const subscription = await query.subscribe();
+    await new Promise(resolve => subscription.on('error', resolve));
+
+    expect(logger.error).toHaveBeenCalledWith(
+      `Failed running beforeSubscribe on TestObject for session undefined with:\n Error: {"message":"foo is not defined","code":141}`
+    );
+  });
+
   it('can handle mutate beforeSubscribe query', async done => {
     await reconfigureServer({
       liveQuery: {

src/LiveQuery/ParseLiveQueryServer.js

@@ -10,7 +10,7 @@ import { ParsePubSub } from './ParsePubSub';
 import SchemaController from '../Controllers/SchemaController';
 import _ from 'lodash';
 import { v4 as uuidv4 } from 'uuid';
-import { runLiveQueryEventHandlers, getTrigger, runTrigger, toJSONwithObjects } from '../triggers';
+import { runLiveQueryEventHandlers, getTrigger, runTrigger, resolveError, toJSONwithObjects } from '../triggers';
 import { getAuthForSessionToken, Auth } from '../Auth';
 import { getCacheController } from '../Controllers';
 import LRU from 'lru-cache';
@@ -194,14 +194,9 @@ class ParseLiveQueryServer {
               delete deletedParseObject.authData;
             }
             client.pushDelete(requestId, deletedParseObject);
-          } catch (error) {
+          } catch (e) {
-            Client.pushError(
+            const error = resolveError(e);
-              client.parseWebSocket,
+            Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);
-              error.code || Parse.Error.SCRIPT_FAILED,
-              error.message || error,
-              false,
-              requestId
-            );
             logger.error(
               `Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\n Error: ` +
                 JSON.stringify(error)
@@ -358,14 +353,9 @@ class ParseLiveQueryServer {
             if (client[functionName]) {
               client[functionName](requestId, currentParseObject, originalParseObject);
             }
-          } catch (error) {
+          } catch (e) {
-            Client.pushError(
+            const error = resolveError(e);
-              client.parseWebSocket,
+            Client.pushError(client.parseWebSocket, error.code, error.message, false, requestId);
-              error.code || Parse.Error.SCRIPT_FAILED,
-              error.message || error,
-              false,
-              requestId
-            );
             logger.error(
               `Failed running afterLiveQueryEvent on class ${className} for event ${res.event} with session ${res.sessionToken} with:\n Error: ` +
                 JSON.stringify(error)
@@ -681,13 +671,9 @@ class ParseLiveQueryServer {
       logger.info(`Create new client: ${parseWebsocket.clientId}`);
       client.pushConnect();
       runLiveQueryEventHandlers(req);
-    } catch (error) {
+    } catch (e) {
-      Client.pushError(
+      const error = resolveError(e);
-        parseWebsocket,
+      Client.pushError(parseWebsocket, error.code, error.message, false);
-        error.code || Parse.Error.SCRIPT_FAILED,
-        error.message || error,
-        false
-      );
       logger.error(
         `Failed running beforeConnect for session ${request.sessionToken} with:\n Error: ` +
           JSON.stringify(error)
@@ -827,16 +813,11 @@ class ParseLiveQueryServer {
         installationId: client.installationId,
       });
     } catch (e) {
-      Client.pushError(
+      const error = resolveError(e);
-        parseWebsocket,
+      Client.pushError(parseWebsocket, error.code, error.message, false, request.requestId);
-        e.code || Parse.Error.SCRIPT_FAILED,
-        e.message || e,
-        false,
-        request.requestId
-      );
       logger.error(
         `Failed running beforeSubscribe on ${className} for session ${request.sessionToken} with:\n Error: ` +
-          JSON.stringify(e)
+          JSON.stringify(error)
       );
     }
   }