@percy/core 1.28.8-beta.6 → 1.28.9-beta.0

package/dist/discovery.js

@@ -321,6 +321,9 @@ export function createDiscoveryQueue(percy) {
   // on start, launch the browser and run the queue
   .handle('start', async () => {
     cache = percy[RESOURCE_CACHE_KEY] = new Map();
+
+    // If browser.launch() fails it will get captured in
+    // *percy.start()
     await percy.browser.launch();
     queue.run();
   })
@@ -395,17 +398,34 @@ export function createDiscoveryQueue(percy) {
         throwOn: ['AbortError']
       });
     });
-  }).handle('error', ({
+  }).handle('error', async ({
     name,
     meta
   }, error) => {
     if (error.name === 'AbortError' && queue.readyState < 3) {
       // only error about aborted snapshots when not closed
-      percy.log.error('Received a duplicate snapshot, ' + `the previous snapshot was aborted: ${snapshotLogName(name, meta)}`, meta);
+      let errMsg = 'Received a duplicate snapshot, ' + `the previous snapshot was aborted: ${snapshotLogName(name, meta)}`;
+      percy.log.error(errMsg, {
+        snapshotLevel: true,
+        snapshotName: name
+      });
+      await percy.suggestionsForFix(errMsg, meta);
     } else {
       // log all other encountered errors
-      percy.log.error(`Encountered an error taking snapshot: ${name}`, meta);
+      let errMsg = `Encountered an error taking snapshot: ${name}`;
+      percy.log.error(errMsg, meta);
       percy.log.error(error, meta);
+      let assetDiscoveryErrors = [{
+        message: errMsg,
+        meta
+      }, {
+        message: error === null || error === void 0 ? void 0 : error.message,
+        meta
+      }];
+      await percy.suggestionsForFix(assetDiscoveryErrors, {
+        snapshotLevel: true,
+        snapshotName: name
+      });
     }
   });
 }

package/dist/percy.js

@@ -1,6 +1,20 @@
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateMethodGet(s, a, r) { return _assertClassBrand(a, s), r; }
+function _classPrivateFieldGet2(e, t) { var r = _classPrivateFieldGet(t, e); return _classApplyDescriptorGet(e, r); }
+function _classApplyDescriptorGet(e, t) { return t.get ? t.get.call(e) : t.value; }
+function _classPrivateFieldSet(e, t, r) { var s = _classPrivateFieldGet(t, e); return _classApplyDescriptorSet(e, s, r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+function _classApplyDescriptorSet(e, t, l) { if (t.set) t.set.call(e, l);else { if (!t.writable) throw new TypeError("attempted to set read only private field"); t.value = l; } }
 import PercyClient from '@percy/client';
 import PercyConfig from '@percy/config';
 import logger from '@percy/logger';
+import { getProxy } from '@percy/client/utils';
 import Browser from './browser.js';
 import Pako from 'pako';
 import { base64encode, generatePromise, yieldAll, yieldTo, redactSecrets } from './utils.js';
@@ -12,12 +26,11 @@ import { WaitForJob } from './wait-for-job.js';
 // A Percy instance will create a new build when started, handle snapshot creation, asset discovery,
 // and resource uploads, and will finalize the build when stopped. Snapshots are processed
 // concurrently and the build is not finalized until all snapshots have been handled.
+var _discovery = /*#__PURE__*/new WeakMap();
+var _snapshots = /*#__PURE__*/new WeakMap();
+var _displaySuggestionLogs = /*#__PURE__*/new WeakSet();
+var _proxyEnabled = /*#__PURE__*/new WeakSet();
 export class Percy {
-  log = logger('core');
-  readyState = null;
-  #discovery = null;
-  #snapshots = null;
-
   // Static shortcut to create and start an instance in one call
   static async start(options) {
     let instance = new this(options);
@@ -52,17 +65,31 @@ export class Percy {
     projectType = null,
     // options such as `snapshot` and `discovery` that are valid Percy config
     // options which will become accessible via the `.config` property
-    ...options
+    ..._options
   } = {}) {
-    var _config$percy;
+    var _config$percy, _config$percy2;
+    _classPrivateMethodInitSpec(this, _proxyEnabled);
+    _classPrivateMethodInitSpec(this, _displaySuggestionLogs);
+    _defineProperty(this, "log", logger('core'));
+    _defineProperty(this, "readyState", null);
+    _classPrivateFieldInitSpec(this, _discovery, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec(this, _snapshots, {
+      writable: true,
+      value: null
+    });
     let config = PercyConfig.load({
-      overrides: options,
+      overrides: _options,
       path: configFile
     });
-    deferUploads ?? (deferUploads = (_config$percy = config.percy) === null || _config$percy === void 0 ? void 0 : _config$percy.deferUploads);
+    labels ?? (labels = (_config$percy = config.percy) === null || _config$percy === void 0 ? void 0 : _config$percy.labels);
+    deferUploads ?? (deferUploads = (_config$percy2 = config.percy) === null || _config$percy2 === void 0 ? void 0 : _config$percy2.deferUploads);
     this.config = config;
     if (testing) loglevel = 'silent';
     if (loglevel) this.loglevel(loglevel);
+    this.port = port;
     this.projectType = projectType;
     this.testing = testing ? {} : null;
     this.dryRun = !!testing || !!dryRun;
@@ -80,8 +107,8 @@ export class Percy {
     });
     if (server) this.server = createPercyServer(this, port);
     this.browser = new Browser(this);
-    this.#discovery = createDiscoveryQueue(this);
-    this.#snapshots = createSnapshotsQueue(this);
+    _classPrivateFieldSet(this, _discovery, createDiscoveryQueue(this));
+    _classPrivateFieldSet(this, _snapshots, createSnapshotsQueue(this));
 
     // generator methods are wrapped to autorun and return promises
     for (let m of ['start', 'stop', 'flush', 'idle', 'snapshot', 'upload']) {
@@ -134,10 +161,10 @@ export class Percy {
     let {
       concurrency
     } = this.config.discovery;
-    this.#discovery.set({
+    _classPrivateFieldGet2(this, _discovery).set({
       concurrency
     });
-    this.#snapshots.set({
+    _classPrivateFieldGet2(this, _snapshots).set({
       concurrency
     });
     return this.config;
@@ -153,9 +180,9 @@ export class Percy {
         this.log.warn('Notice: Percy collects CI logs for service improvement, stored for 30 days. Opt-out anytime with export PERCY_CLIENT_ERROR_LOGS=false');
       }
       // start the snapshots queue immediately when not delayed or deferred
-      if (!this.delayUploads && !this.deferUploads) yield this.#snapshots.start();
+      if (!this.delayUploads && !this.deferUploads) yield _classPrivateFieldGet2(this, _snapshots).start();
       // do not start the discovery queue when not needed
-      if (!this.skipDiscovery) yield this.#discovery.start();
+      if (!this.skipDiscovery) yield _classPrivateFieldGet2(this, _discovery).start();
       // start a local API server for SDK communication
       if (this.server) yield this.server.listen();
       if (this.projectType === 'web') {
@@ -173,16 +200,19 @@ export class Percy {
       var _this$server2;
       // on error, close any running server and end queues
       await ((_this$server2 = this.server) === null || _this$server2 === void 0 ? void 0 : _this$server2.close());
-      await this.#discovery.end();
-      await this.#snapshots.end();
+      await _classPrivateFieldGet2(this, _discovery).end();
+      await _classPrivateFieldGet2(this, _snapshots).end();
 
       // mark this instance as closed unless aborting
       this.readyState = error.name !== 'AbortError' ? 3 : null;
 
       // throw an easier-to-understand error when the port is in use
       if (error.code === 'EADDRINUSE') {
-        throw new Error('Percy is already running or the port is in use');
+        let errMsg = `Percy is already running or the port ${this.port} is in use`;
+        await this.suggestionsForFix(errMsg);
+        throw new Error(errMsg);
       } else {
+        await this.suggestionsForFix(error.message);
         throw error;
       }
     }
@@ -190,8 +220,8 @@ export class Percy {
 
   // Resolves once snapshot and upload queues are idle
   async *idle() {
-    yield* this.#discovery.idle();
-    yield* this.#snapshots.idle();
+    yield* _classPrivateFieldGet2(this, _discovery).idle();
+    yield* _classPrivateFieldGet2(this, _snapshots).idle();
   }
 
   // Wait for currently queued snapshots then run and wait for resulting uploads
@@ -204,13 +234,13 @@ export class Percy {
     yield new Promise(r => setImmediate(r));
 
     // flush and log progress for discovery before snapshots
-    if (!this.skipDiscovery && this.#discovery.size) {
-      if (options) yield* yieldAll(options.map(o => this.#discovery.process(o)));else yield* this.#discovery.flush(size => callback === null || callback === void 0 ? void 0 : callback('Processing', size));
+    if (!this.skipDiscovery && _classPrivateFieldGet2(this, _discovery).size) {
+      if (options) yield* yieldAll(options.map(o => _classPrivateFieldGet2(this, _discovery).process(o)));else yield* _classPrivateFieldGet2(this, _discovery).flush(size => callback === null || callback === void 0 ? void 0 : callback('Processing', size));
     }
 
     // flush and log progress for snapshot uploads
-    if (!this.skipUploads && this.#snapshots.size) {
-      if (options) yield* yieldAll(options.map(o => this.#snapshots.process(o)));else yield* this.#snapshots.flush(size => callback === null || callback === void 0 ? void 0 : callback('Uploading', size));
+    if (!this.skipUploads && _classPrivateFieldGet2(this, _snapshots).size) {
+      if (options) yield* yieldAll(options.map(o => _classPrivateFieldGet2(this, _snapshots).process(o)));else yield* _classPrivateFieldGet2(this, _snapshots).flush(size => callback === null || callback === void 0 ? void 0 : callback('Uploading', size));
     }
   }
 
@@ -229,8 +259,8 @@ export class Percy {
 
       // close queues asap
       if (force) {
-        this.#discovery.close(true);
-        this.#snapshots.close(true);
+        _classPrivateFieldGet2(this, _discovery).close(true);
+        _classPrivateFieldGet2(this, _snapshots).close(true);
       }
 
       // already stopping
@@ -255,14 +285,14 @@ export class Percy {
       }
 
       // if dry-running, log the total number of snapshots
-      if (this.dryRun && this.#snapshots.size) {
-        this.log.info(info('Found', this.#snapshots.size));
+      if (this.dryRun && _classPrivateFieldGet2(this, _snapshots).size) {
+        this.log.info(info('Found', _classPrivateFieldGet2(this, _snapshots).size));
       }
 
       // close server and end queues
       await ((_this$server3 = this.server) === null || _this$server3 === void 0 ? void 0 : _this$server3.close());
-      await this.#discovery.end();
-      await this.#snapshots.end();
+      await _classPrivateFieldGet2(this, _discovery).end();
+      await _classPrivateFieldGet2(this, _snapshots).end();
 
       // mark instance as stopped
       this.readyState = 3;
@@ -270,6 +300,9 @@ export class Percy {
       this.log.error(err);
       throw err;
     } finally {
+      // This issue doesn't comes under regular error logs,
+      // it's detected if we just and stop percy server
+      await this.checkForNoSnapshotCommandError();
       await this.sendBuildLogs();
     }
   }
@@ -322,7 +355,7 @@ export class Percy {
         }
 
         // gather snapshots and discover snapshot resources
-        yield* discoverSnapshotResources(this.#discovery, {
+        yield* discoverSnapshotResources(_classPrivateFieldGet2(this, _discovery), {
           skipDiscovery: this.skipDiscovery,
           dryRun: this.dryRun,
           snapshots: yield* gatherSnapshots(options, {
@@ -342,7 +375,7 @@ export class Percy {
             });
           }
           // push each finished snapshot to the snapshots queue
-          this.#snapshots.push(snapshot);
+          _classPrivateFieldGet2(this, _snapshots).push(snapshot);
         });
       } finally {
         var _server;
@@ -402,9 +435,11 @@ export class Percy {
     // return an async generator to allow cancelation
     return async function* () {
       try {
-        return yield* yieldTo(this.#snapshots.push(options));
+        return yield* yieldTo(_classPrivateFieldGet2(this, _snapshots).push(options));
       } catch (error) {
-        this.#snapshots.cancel(options);
+        _classPrivateFieldGet2(this, _snapshots).cancel(options);
+        // Detecting and suggesting fix for errors;
+        await this.suggestionsForFix(error.message);
         throw error;
       }
     }.call(this);
@@ -436,6 +471,48 @@ export class Percy {
     if (syncMode) options.sync = syncMode;
     return syncMode;
   }
+
+  // This specific error will be hard coded
+  async checkForNoSnapshotCommandError() {
+    let isPercyStarted = false;
+    let containsSnapshotTaken = false;
+    logger.query(item => {
+      var _item$message, _item$message2, _item$message3;
+      isPercyStarted || (isPercyStarted = item === null || item === void 0 ? void 0 : (_item$message = item.message) === null || _item$message === void 0 ? void 0 : _item$message.includes('Percy has started'));
+      containsSnapshotTaken || (containsSnapshotTaken = item === null || item === void 0 ? void 0 : (_item$message2 = item.message) === null || _item$message2 === void 0 ? void 0 : _item$message2.includes('Snapshot taken'));
+
+      // This case happens when you directly upload it using cli-upload
+      containsSnapshotTaken || (containsSnapshotTaken = item === null || item === void 0 ? void 0 : (_item$message3 = item.message) === null || _item$message3 === void 0 ? void 0 : _item$message3.includes('Snapshot uploaded'));
+      return item;
+    });
+    if (isPercyStarted && !containsSnapshotTaken) {
+      // This is the case for No snapshot command called
+      _classPrivateMethodGet(this, _displaySuggestionLogs, _displaySuggestionLogs2).call(this, [{
+        failure_reason: 'Snapshot command was not called',
+        reason_message: 'Snapshot Command was not called. please check your CI for errors',
+        suggestion: 'Try using percy snapshot command to take snapshots',
+        reference_doc_link: ['https://www.browserstack.com/docs/percy/take-percy-snapshots/']
+      }]);
+    }
+  }
+  async suggestionsForFix(errors, options = {}) {
+    try {
+      const suggestionResponse = await this.client.getErrorAnalysis(errors);
+      _classPrivateMethodGet(this, _displaySuggestionLogs, _displaySuggestionLogs2).call(this, suggestionResponse, options);
+    } catch (e) {
+      // Common error code for Proxy issues
+      const PROXY_CODES = ['ECONNREFUSED', 'ECONNRESET', 'EHOSTUNREACH'];
+      if (!!e.code && PROXY_CODES.includes(e.code)) {
+        // This can be due to proxy issue
+        this.log.error('percy.io might not be reachable, check network connection, proxy and ensure that percy.io is whitelisted.');
+        if (!_classPrivateMethodGet(this, _proxyEnabled, _proxyEnabled2).call(this)) {
+          this.log.error('If inside a proxied envirnment, please configure the following environment variables: HTTP_PROXY, [ and optionally HTTPS_PROXY if you need it ]. Refer to our documentation for more details');
+        }
+      }
+      this.log.error('Unable to analyze error logs');
+      this.log.debug(e);
+    }
+  }
   async sendBuildLogs() {
     if (!process.env.PERCY_TOKEN) return;
     try {
@@ -443,6 +520,7 @@ export class Percy {
       const logsObject = {
         clilogs: logger.query(log => !['ci'].includes(log.debug))
       };
+
       // Only add CI logs if not disabled voluntarily.
       const sendCILogs = process.env.PERCY_CLIENT_ERROR_LOGS !== 'false';
       if (sendCILogs) {
@@ -466,4 +544,32 @@ export class Percy {
     }
   }
 }
+function _displaySuggestionLogs2(suggestions, options = {}) {
+  if (!(suggestions !== null && suggestions !== void 0 && suggestions.length)) return;
+  suggestions.forEach(item => {
+    const failure = item === null || item === void 0 ? void 0 : item.failure_reason;
+    const failureReason = item === null || item === void 0 ? void 0 : item.reason_message;
+    const suggestion = item === null || item === void 0 ? void 0 : item.suggestion;
+    const referenceDocLinks = item === null || item === void 0 ? void 0 : item.reference_doc_link;
+    if (options !== null && options !== void 0 && options.snapshotLevel) {
+      this.log.warn(`Detected erorr for Snapshot: ${options === null || options === void 0 ? void 0 : options.snapshotName}`);
+    } else {
+      this.log.warn('Detected error for percy build');
+    }
+    this.log.warn(`Failure: ${failure}`);
+    this.log.warn(`Failure Reason: ${failureReason}`);
+    this.log.warn(`Suggestion: ${suggestion}`);
+    if ((referenceDocLinks === null || referenceDocLinks === void 0 ? void 0 : referenceDocLinks.length) > 0) {
+      this.log.warn('Refer to the below Doc Links for the same');
+      referenceDocLinks === null || referenceDocLinks === void 0 ? void 0 : referenceDocLinks.forEach(_docLink => {
+        this.log.warn(`* ${_docLink}`);
+      });
+    }
+  });
+}
+function _proxyEnabled2() {
+  return !!(getProxy({
+    protocol: 'https:'
+  }) || getProxy({}));
+}
 export default Percy;

package/dist/snapshot.js

@@ -234,6 +234,7 @@ export async function handleSyncJob(jobPromise, percy, type) {
       data = await percy.client.getComparisonDetails(id);
     }
   } catch (e) {
+    await percy.suggestionsForFix(e.message);
     data = {
       error: e.message
     };
@@ -453,7 +454,7 @@ export function createSnapshotsQueue(percy) {
     };
   })
   // handle possible build errors returned by the API
-  .handle('error', (snapshot, error) => {
+  .handle('error', async (snapshot, error) => {
     var _error$response, _error$response2, _error$response2$body;
     let result = {
       ...snapshot,
@@ -478,12 +479,29 @@ export function createSnapshotsQueue(percy) {
     let duplicate = (errors === null || errors === void 0 ? void 0 : errors.length) > 1 && errors[1].detail.includes('must be unique');
     if (duplicate) {
       if (process.env.PERCY_IGNORE_DUPLICATES !== 'true') {
-        percy.log.warn(`Ignored duplicate snapshot. ${errors[1].detail}`);
+        let errMsg = `Ignored duplicate snapshot. ${errors[1].detail}`;
+        percy.log.warn(errMsg);
+        await percy.suggestionsForFix(errMsg, {
+          snapshotLevel: true,
+          snapshotName: name
+        });
       }
       return result;
     }
-    percy.log.error(`Encountered an error uploading snapshot: ${name}`, meta);
+    let errMsg = `Encountered an error uploading snapshot: ${name}`;
+    percy.log.error(errMsg, meta);
     percy.log.error(error, meta);
+    let snapshotErrors = [{
+      message: errMsg,
+      meta
+    }, {
+      message: error === null || error === void 0 ? void 0 : error.message,
+      meta
+    }];
+    await percy.suggestionsForFix(snapshotErrors, {
+      snapshotLevel: true,
+      snapshotName: name
+    });
     if (snapshot.sync) snapshot.reject(error);
     return result;
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.28.8-beta.6",
+  "version": "1.28.9-beta.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,11 +43,11 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.28.8-beta.6",
-    "@percy/config": "1.28.8-beta.6",
-    "@percy/dom": "1.28.8-beta.6",
-    "@percy/logger": "1.28.8-beta.6",
-    "@percy/webdriver-utils": "1.28.8-beta.6",
+    "@percy/client": "1.28.9-beta.0",
+    "@percy/config": "1.28.9-beta.0",
+    "@percy/dom": "1.28.9-beta.0",
+    "@percy/logger": "1.28.9-beta.0",
+    "@percy/webdriver-utils": "1.28.9-beta.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -60,5 +60,5 @@
     "ws": "^8.17.1",
     "yaml": "^2.4.1"
   },
-  "gitHead": "33ebd1aded619784a02e27cb26dbd344c7131ee9"
+  "gitHead": "a1114f1e18518012f48756c9558a8e7895d2b3a9"
 }