suitest-js-api 4.2.0 → 4.2.2

package/lib/api/request.js

@@ -8,7 +8,7 @@ const {apiUrl} = require('../../config');
 const SuitestError = require('../utils/SuitestError');
 const makeUrlFromArray = require('../utils/makeUrlFromArray');
 const {suitestServerError} = require('../texts');
-const {captureException} = require('../utils/sentry/Raven');
+const {captureException} = require('../utils/sentry/Sentry');
 
 /**
  * Make http request
@@ -38,7 +38,7 @@ async function request(url, requestObject, onFail) {
 	} catch (e) {
 		// Caught low-level network error, i.e. not HTTP error
 		// Report it to Sentry
-		await captureException(e, {extra:{networkingError: true}});
+		await captureException(e, {extra: {networkingError: true}});
 
 		throw e;
 	}

package/lib/api/webSockets.js

@@ -6,7 +6,7 @@
 const WS = require('ws');
 const {v1: uuid} = require('uuid');
 const {path} = require('ramda');
-const Raven = require('raven');
+const {captureException} = require('../utils/sentry/Sentry');
 const {fetch, setUserAgent} = require('../utils/fetch');
 
 const SuitestError = require('../utils/SuitestError');
@@ -89,6 +89,10 @@ const webSocketsFactory = (self) => {
 				throw new SuitestError(texts.testingMinutesExceededMessage());
 			}
 
+			if (content.type === 'releasingDevice') {
+				throw new SuitestError(texts.releasingDeviceMessage());
+			}
+
 			if (content.type === 'executorStopped') {
 				// Notify user about executor being stopped
 				throw new SuitestError(texts.executorStopped());
@@ -276,7 +280,7 @@ const webSocketsFactory = (self) => {
 			try {
 				logger.log(translateNotStartedReason(res.reason));
 			} catch (error) {
-				Raven.captureException(error);
+				captureException(error);
 			}
 		}
 		if (res.type === 'progress') {

package/lib/commands/startREPL.js

@@ -10,7 +10,7 @@ const texts = require('../texts');
 const {stackTraceParser} = require('../utils/stackTraceParser');
 const suitest = require('../../index');
 const {logger} = suitest;
-const {captureMessage} = require('../utils/sentry/Raven');
+const {captureMessage} = require('../utils/sentry/Sentry');
 
 let isReplActive = false;
 let replModeWasActivated = false;

package/lib/composers/thenComposer.js

@@ -5,7 +5,7 @@ const chainPromise = require('../utils/chainPromise');
 const {fetchTestDefinitions} = require('../utils/chainUtils');
 const {processServerResponse} = require('../utils/socketChainHelper');
 const {translateLine} = require('../utils/chainUtils');
-const {captureException} = require('../utils/sentry/Raven');
+const {captureException} = require('../utils/sentry/Sentry');
 const {connectionNotEstablished} = require('../texts');
 
 // A map to find promise by chain data object

package/lib/testLauncher/SuitestLauncher.js

@@ -13,7 +13,7 @@ const {TEST_COMMAND, TOKEN} = require('../constants/modes');
 const sessionConstants = require('../constants/session');
 const {getDevicesDetails} = require('../utils/getDeviceInfo');
 const {closeSessionUnchained} = require('../commands/closeSession');
-const {captureException} = require('../utils/sentry/Raven');
+const {captureException} = require('../utils/sentry/Sentry');
 const t = require('../texts');
 const {version} = require('../../package.json');
 const ipcServer = require('./ipc/server');

package/lib/texts.js

@@ -164,6 +164,8 @@ ${leaves}`,
 
 	testingMinutesExceededMessage: () => 'You reached the limit of testing minutes specified by your subscription plan. If you need more minutes, contact us at sales@suite.st or upgrade your subscription.',
 
+	releasingDeviceMessage: () => 'The device has been disconnected.',
+
 	// ipc
 	ipcFailedToCreateServer: template`Failed to create IPC server. Port ${0} is busy.`,
 

package/lib/utils/chainPromise.js

@@ -1,5 +1,5 @@
 const {stackTraceWrapper} = require('./stackTraceParser');
-const {captureException} = require('../utils/sentry/Raven');
+const {captureException} = require('./sentry/Sentry');
 
 let currentPromise = Promise.resolve();
 

package/lib/utils/logger.js

@@ -6,7 +6,7 @@ const timestamp = require('./timestamp');
 const {truncate} = require('./stringUtils');
 const {Transform} = require('stream');
 const semver = require('semver');
-const Raven = require('raven');
+const {captureException} = require('./sentry/Sentry');
 
 /**
  * Define custom colors
@@ -257,7 +257,7 @@ const createLogger = (config, pairedDeviceContext) => {
 			} else if (appLogger[lowercasedMethod]) {
 				appLogger[lowercasedMethod](...args);
 			} else {
-				Raven.captureException(new Error(`Received log method "${method}" does not exists`));
+				captureException(new Error(`Received log method "${method}" does not exists`));
 				appLogger.log(...args);
 			}
 		};

package/lib/utils/makeChain.js

@@ -1,5 +1,5 @@
 const {mergeAll} = require('ramda');
-const {wrapThrow} = require('./sentry/Raven');
+const {wrapThrow} = require('./sentry/Sentry');
 
 const makeChain = (instance, getComposers, data) => {
 	const makeNewChain = wrapThrow(updatedData => {

package/lib/utils/progressHandler.js

@@ -6,7 +6,7 @@
  */
 
 const translate = require('../utils/translateResults');
-const Raven = require('raven');
+const sentry = require('./sentry/Sentry');
 
 /**
  * Print progress description to stdout
@@ -21,7 +21,7 @@ function handleProgress(logger, res) {
 			logger.log(`  - ${msg}`);
 		}
 	} catch (error) {
-		Raven.captureException(error);
+		sentry.captureException(error);
 	}
 }
 

package/lib/utils/sentry/Sentry.js

@@ -0,0 +1,120 @@
+/* istanbul ignore file */
+
+/**
+ * Configure sentry reporting
+ */
+
+const Sentry = require('@sentry/node');
+const isSuitestUncaughtError = require('./isSuitestUncaughtError');
+const {version} = require('../../../package.json');
+
+let isSetup = false;
+
+const setUpSentry = (config, authContext) => {
+	if (!isSetup && !config.disallowCrashReports) {
+		Sentry.init({
+			dsn: config.sentryDsn,
+			release: version,
+			integrations(defaultIntegrations) {
+				// Keep behavior compatible with old Raven setup:
+				// - autoBreadcrumbs.console = false
+				// - autoBreadcrumbs.http = false
+				// - captureUnhandledRejections = false
+				return defaultIntegrations.filter(integration => {
+					return !['Console', 'Http', 'OnUnhandledRejection'].includes(integration.name);
+				});
+			},
+			beforeSend(data) {
+				// Populate error report with type of user session
+				data.user = {authType: authContext.context.toString()};
+
+				// send report if enabled in config and only uncaught suitest api errors
+				// and if message was sent
+				if (
+					!config.disallowCrashReports
+					&& (
+						(data.extra && data.extra.networkingError)
+						|| !data.exception
+						|| (
+							data.exception
+							&& data.exception.values
+							&& data.exception.values[0]
+							&& isSuitestUncaughtError(data.exception.values[0])
+						)
+					)
+				) {
+					return data;
+				}
+
+				return null;
+			},
+		});
+		isSetup = true;
+	}
+};
+
+/**
+ * Best-effort delivery for telemetry events.
+ * We intentionally do not fail the main execution flow if Sentry is unavailable.
+ */
+function flush() {
+	return Sentry.flush(2000)
+		.catch(() => undefined);
+}
+
+/**
+ * Explicitly capture provided exception
+ * @param {Error} error
+ * @param {Object} [extra]
+ * @returns {Promise<unknown>}
+ */
+function captureException(error, extra) {
+	Sentry.captureException(error, extra);
+
+	// Keep async contract
+	return flush();
+}
+
+/**
+ * @description Send log message to sentry
+ * @param {string} message
+ * @param {object} kwargs
+ * @returns {Promise<unknown>}
+ */
+function captureMessage(message, kwargs) {
+	Sentry.captureMessage(message, kwargs);
+
+	// Keep async contract
+	return flush();
+}
+
+/**
+ * Sentry's implementation of wrap does not trow an exception
+ * after it's reported. We need an error to be thrown to user.
+ * @param {Function} callback
+ * @returns {Function}
+ */
+const wrapThrow = callback => (...args) => {
+	try {
+		return callback.apply(undefined, args);
+	} catch (e) {
+		/*
+		 * Capturing Sentry exception is asynchronous.
+		 * While this function has to be synchronous.
+		 * If client's application does not catch this exception and node
+		 * crashes - we'll not get the report.
+		 * If client's application does catch an error an process it somehow
+		 * (e.g. mocha), we'll receive an exception in Sentry
+		 */
+		Sentry.captureException(e);
+
+		throw e;
+	}
+};
+
+module.exports = {
+	captureException,
+	captureMessage,
+	wrapThrow,
+	setUpSentry,
+};

package/lib/utils/sentry/isSuitestUncaughtError.js

@@ -1,5 +1,5 @@
 /**
- * Investigate raven error data.
+ * Investigate sentry error data.
  * Error should not be reported if its not from suitest api code and not of defined SuitestError type
  */
 
@@ -8,13 +8,13 @@ const SuitestError = require('../SuitestError');
 const isSuitestMethod = require('../isSuitestMethod');
 
 /**
- * @param {*} ravenException
+ * @param {*} sentryError
  * @returns boolean
  */
-function isSuitestUncaughtError(ravenException) {
-	return ravenException.type !== SuitestError.type // error is not SuitestError
-		&& ravenException.type !== ASSERTION_ERROR_TYPE // error is not node native AssertionError
-		&& ravenException.stacktrace.frames.some(fr => isSuitestMethod(fr.filename)); // but error occurred within suitest api code
+function isSuitestUncaughtError(sentryError) {
+	return sentryError.type !== SuitestError.type // error is not SuitestError
+		&& sentryError.type !== ASSERTION_ERROR_TYPE // error is not node native AssertionError
+		&& sentryError.stacktrace.frames.some(fr => isSuitestMethod(fr.filename)); // but error occurred within suitest api code
 }
 
 module.exports = isSuitestUncaughtError;

package/lib/utils/sessionStarter.js

@@ -1,7 +1,7 @@
 const {TOKEN} = require('../constants/modes');
 const chainPromise = require('./chainPromise');
 const {validate, validators} = require('../validation');
-const {captureException} = require('./sentry/Raven');
+const {captureException} = require('./sentry/Sentry');
 const envVars = require('../constants/environment');
 const messageId = require('../constants/ipcMessageId');
 const ipcClient = require('../testLauncher/ipc/client');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suitest-js-api",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "main": "index.js",
   "repository": "github:SuitestAutomation/suitest-js-api",
   "author": "Suitest <hello@suite.st>",
@@ -98,10 +98,11 @@
     "typescript": "5.8.3"
   },
   "dependencies": {
+    "@sentry/node": "^7.120.3",
     "@suitest/smst-to-text": "^4.28.5",
     "@suitest/translate": "^4.31.0",
     "@types/node": "^14.0.10",
-    "ajv": "^6.12.2",
+    "ajv": "^6.14.0",
     "ansi-regex": "^5.0.0",
     "chokidar": "^3.4.0",
     "colors": "^1.4.0",
@@ -116,7 +117,6 @@
     "package-json": "^7.0.0",
     "prettyjson": "^1.2.1",
     "ramda": "^0.27.0",
-    "raven": "^2.6.2",
     "semver": "^7.3.2",
     "stack-trace": "^0.0.10",
     "uuid": "8.1.0",

package/suitest.js

@@ -1,4 +1,4 @@
-require('./lib/utils/sentry/Raven');
+require('./lib/utils/sentry/Sentry');
 const {clone} = require('ramda');
 
 // Commands
@@ -77,7 +77,7 @@ const ipcServer = require('./lib/testLauncher/ipc/server');
 const Context = require('./lib/utils/Context');
 const AuthContext = require('./lib/utils/AuthContext');
 const {configFactory} = require('./config');
-const {setUpRaven} = require('./lib/utils/sentry/Raven');
+const {setUpSentry} = require('./lib/utils/sentry/Sentry');
 const {warnLauncherAndLibHasDiffVersions} = require('./lib/utils/packageMetadataHelper');
 const {createLogger} = require('./lib/utils/logger');
 
@@ -106,7 +106,7 @@ class SUITEST_API extends EventEmitter {
 		this.logger = createLogger(this.configuration.config, this.pairedDeviceContext);
 		this.unusedExpressionWatchers = unusedExpressionWatchersFactory(this);
 		this.webSockets = webSocketsFactory(this);
-		setUpRaven(this.configuration.config, this.authContext);
+		setUpSentry(this.configuration.config, this.authContext);
 
 		this.openSession = (...args) => openSession(this, ...args);
 		this.pairDevice = (...args) => pairDevice(this, ...args);

package/lib/utils/sentry/Raven.js

@@ -1,95 +0,0 @@
-/* istanbul ignore file */
-
-/**
- * Configure raven sentry reporting
- */
-
-const Raven = require('raven');
-const isSuitestUncaughtError = require('./isSuitestUncaughtError');
-const {version} = require('../../../package.json');
-
-let isSetup = false;
-
-const setUpRaven = (config, authContext) => {
-	if (!isSetup && !config.disallowCrashReports) {
-		Raven
-			.config(config.sentryDsn, {
-				release: version,
-				dataCallback: data => {
-					// Populate error report with type of user session
-					data.user = {authType: authContext.context.toString()};
-
-					return data;
-				},
-				autoBreadcrumbs: {
-					'console': false, // console logging
-					'http': false, // rest requests (during unit testing, nock disables some requests)
-				},
-				captureUnhandledRejections: false,
-				shouldSendCallback(data) {
-					// send report if enabled in config and only uncaught suitest api errors
-					// and if message was sent
-
-					return !config.disallowCrashReports && (
-						data.extra.networkingError
-						|| !data.exception
-						|| isSuitestUncaughtError(data.exception[0])
-					);
-				},
-			})
-			.install(err => {
-				isSetup = !!err;
-			});
-	}
-};
-
-/**
- * Explicitly capture provided exception
- * @param {Error} error
- * @param {Object} [extra]
- * @returns {Promise<*>}
- */
-function captureException(error, extra) {
-	return new Promise(res => Raven.captureException(error, extra, res));
-}
-
-/**
- * @description Send log message to sentry
- * @param {string} message
- * @param {object} kwargs
- * @returns {Promise<unknown>}
- */
-function captureMessage(message, kwargs) {
-	return new Promise(res => Raven.captureMessage(message, kwargs, res));
-}
-
-/**
- * Sentry's implementation of wrap does not trow an exception
- * after it's reported. We need an error to be thrown to user.
- * @param {Function} callback
- * @returns {Function}
- */
-const wrapThrow = callback => (...args) => {
-	try {
-		return callback.apply(undefined, args);
-	} catch (e) {
-		/*
-		 * Capturing Raven exception is asynchronous.
-		 * While this function has to be synchronous.
-		 * If client's application does not catch this exception and node
-		 * crashes - we'll not get the report.
-		 * If client's application does catch an error an process it somehow
-		 * (e.g. mocha), we'll receive an exception in Sentry
-		 */
-		Raven.captureException(e);
-
-		throw e;
-	}
-};
-
-module.exports = {
-	captureException,
-	captureMessage,
-	wrapThrow,
-	setUpRaven,
-};

package/lib/utils/testHelpers/mockRaven.js

@@ -1,4 +0,0 @@
-const sinon = require('sinon');
-const raven = require('../sentry/Raven');
-
-sinon.stub(raven, 'captureException').resolves();