@appium/base-driver 8.5.3 → 8.5.4

package/lib/basedriver/helpers.js

@@ -2,18 +2,14 @@ import _ from 'lodash';
 import path from 'path';
 import url from 'url';
 import logger from './logger';
-import { tempDir, fs, util, zip, net, timing, node } from '@appium/support';
+import {tempDir, fs, util, zip, net, timing, node} from '@appium/support';
 import LRU from 'lru-cache';
 import AsyncLock from 'async-lock';
 import axios from 'axios';
 
 const IPA_EXT = '.ipa';
 const ZIP_EXTS = ['.zip', IPA_EXT];
-const ZIP_MIME_TYPES = [
-  'application/zip',
-  'application/x-zip-compressed',
-  'multipart/x-zip',
-];
+const ZIP_MIME_TYPES = ['application/zip', 'application/x-zip-compressed', 'multipart/x-zip'];
 const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
 const MAX_CACHED_APPS = 1024;
 const APPLICATIONS_CACHE = new LRU({
@@ -21,8 +17,10 @@ const APPLICATIONS_CACHE = new LRU({
   ttl: CACHED_APPS_MAX_AGE, // expire after 24 hours
   updateAgeOnGet: true,
   dispose: (app, {fullPath}) => {
-    logger.info(`The application '${app}' cached at '${fullPath}' has ` +
-      `expired after ${CACHED_APPS_MAX_AGE}ms`);
+    logger.info(
+      `The application '${app}' cached at '${fullPath}' has ` +
+        `expired after ${CACHED_APPS_MAX_AGE}ms`
+    );
     if (fullPath) {
       fs.rimraf(fullPath);
     }
@@ -39,10 +37,11 @@ process.on('exit', () => {
     return;
   }
 
-  const appPaths = [...APPLICATIONS_CACHE.values()]
-    .map(({fullPath}) => fullPath);
-  logger.debug(`Performing cleanup of ${appPaths.length} cached ` +
-    util.pluralize('application', appPaths.length));
+  const appPaths = [...APPLICATIONS_CACHE.values()].map(({fullPath}) => fullPath);
+  logger.debug(
+    `Performing cleanup of ${appPaths.length} cached ` +
+      util.pluralize('application', appPaths.length)
+  );
   for (const appPath of appPaths) {
     try {
       // Asynchronous calls are not supported in onExit handler
@@ -53,21 +52,22 @@ process.on('exit', () => {
   }
 });
 
-
-async function retrieveHeaders (link) {
+async function retrieveHeaders(link) {
   try {
-    return (await axios({
-      url: link,
-      method: 'HEAD',
-      timeout: 5000,
-    })).headers;
+    return (
+      await axios({
+        url: link,
+        method: 'HEAD',
+        timeout: 5000,
+      })
+    ).headers;
   } catch (e) {
     logger.info(`Cannot send HEAD request to '${link}'. Original error: ${e.message}`);
   }
   return {};
 }
 
-function getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {}) {
+function getCachedApplicationPath(link, currentAppProps = {}, cachedAppInfo = {}) {
   const refresh = () => {
     logger.debug(`A fresh copy of the application is going to be downloaded from ${link}`);
     return null;
@@ -108,7 +108,9 @@ function getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {
   if (currentMaxAge && timestamp) {
     const msLeft = timestamp + currentMaxAge * 1000 - Date.now();
     if (msLeft > 0) {
-      logger.debug(`The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`);
+      logger.debug(
+        `The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`
+      );
       return fullPath;
     }
     logger.debug(`The cached application '${path.basename(fullPath)}' has expired`);
@@ -116,25 +118,27 @@ function getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {
   return refresh();
 }
 
-function verifyAppExtension (app, supportedAppExtensions) {
+function verifyAppExtension(app, supportedAppExtensions) {
   if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {
     return app;
   }
-  throw new Error(`New app path '${app}' did not have ` +
-    `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +
-    supportedAppExtensions);
+  throw new Error(
+    `New app path '${app}' did not have ` +
+      `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +
+      supportedAppExtensions
+  );
 }
 
-async function calculateFolderIntegrity (folderPath) {
+async function calculateFolderIntegrity(folderPath) {
   return (await fs.glob('**/*', {cwd: folderPath, strict: false, nosort: true})).length;
 }
 
-async function calculateFileIntegrity (filePath) {
+async function calculateFileIntegrity(filePath) {
   return await fs.hash(filePath);
 }
 
-async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
-  if (!await fs.exists(currentPath)) {
+async function isAppIntegrityOk(currentPath, expectedIntegrity = {}) {
+  if (!(await fs.exists(currentPath))) {
     return false;
   }
 
@@ -146,8 +150,8 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
   // more precise, but we don't need to be very precise here and also don't want to
   // overuse RAM and have a performance drop.
   return (await fs.stat(currentPath)).isDirectory()
-    ? await calculateFolderIntegrity(currentPath) >= expectedIntegrity?.folder
-    : await calculateFileIntegrity(currentPath) === expectedIntegrity?.file;
+    ? (await calculateFolderIntegrity(currentPath)) >= expectedIntegrity?.folder
+    : (await calculateFileIntegrity(currentPath)) === expectedIntegrity?.file;
 }
 
 /**
@@ -178,7 +182,7 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
 
 /**
  * @typedef ConfigureAppOptions
- * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} onPostProcess
+ * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} [onPostProcess]
  * Optional function, which should be applied
  * to the application after it is downloaded/preprocessed. This function may be async
  * and is expected to accept single object parameter.
@@ -200,16 +204,16 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
  * @param {string|string[]|ConfigureAppOptions} options
  * @returns The full path to the resulting application bundle
  */
-async function configureApp (app, options = {}) {
+async function configureApp(app, options = /** @type {ConfigureAppOptions} */ ({})) {
   if (!_.isString(app)) {
     // immediately shortcircuit if not given an app
     return;
   }
 
   let supportedAppExtensions;
-  const {
-    onPostProcess,
-  } = _.isPlainObject(options) ? options : {};
+  const onPostProcess =
+    !_.isString(options) && !_.isArray(options) ? options.onPostProcess : undefined;
+
   if (_.isString(options)) {
     supportedAppExtensions = [options];
   } else if (_.isArray(options)) {
@@ -225,13 +229,14 @@ async function configureApp (app, options = {}) {
   let shouldUnzipApp = false;
   let packageHash = null;
   let headers = null;
+  /** @type {RemoteAppProps} */
   const remoteAppProps = {
     lastModified: null,
     immutable: false,
     maxAge: null,
   };
   const {protocol, pathname} = url.parse(newApp);
-  const isUrl = ['http:', 'https:'].includes(protocol);
+  const isUrl = protocol === null ? false : ['http:', 'https:'].includes(protocol);
 
   const cachedAppInfo = APPLICATIONS_CACHE.get(app);
 
@@ -260,14 +265,16 @@ async function configureApp (app, options = {}) {
           logger.info(`Reusing previously downloaded application at '${cachedPath}'`);
           return verifyAppExtension(cachedPath, supportedAppExtensions);
         }
-        logger.info(`The application at '${cachedPath}' does not exist anymore ` +
-          `or its integrity has been damaged. Deleting it from the internal cache`);
+        logger.info(
+          `The application at '${cachedPath}' does not exist anymore ` +
+            `or its integrity has been damaged. Deleting it from the internal cache`
+        );
         APPLICATIONS_CACHE.delete(app);
       }
 
       let fileName = null;
-      const basename = fs.sanitizeName(path.basename(decodeURIComponent(pathname)), {
-        replacement: SANITIZE_REPLACEMENT
+      const basename = fs.sanitizeName(path.basename(decodeURIComponent(pathname ?? '')), {
+        replacement: SANITIZE_REPLACEMENT,
       });
       const extname = path.extname(basename);
       // to determine if we need to unzip the app, we have a number of places
@@ -280,7 +287,11 @@ async function configureApp (app, options = {}) {
         const ct = headers['content-type'];
         logger.debug(`Content-Type: ${ct}`);
         // the filetype may not be obvious for certain urls, so check the mime type too
-        if (ZIP_MIME_TYPES.some((mimeType) => new RegExp(`\\b${_.escapeRegExp(mimeType)}\\b`).test(ct))) {
+        if (
+          ZIP_MIME_TYPES.some((mimeType) =>
+            new RegExp(`\\b${_.escapeRegExp(mimeType)}\\b`).test(ct)
+          )
+        ) {
           if (!fileName) {
             fileName = `${DEFAULT_BASENAME}.zip`;
           }
@@ -292,7 +303,7 @@ async function configureApp (app, options = {}) {
         const match = /filename="([^"]+)/i.exec(headers['content-disposition']);
         if (match) {
           fileName = fs.sanitizeName(match[1], {
-            replacement: SANITIZE_REPLACEMENT
+            replacement: SANITIZE_REPLACEMENT,
           });
           shouldUnzipApp = shouldUnzipApp || ZIP_EXTS.includes(path.extname(fileName));
         }
@@ -304,9 +315,11 @@ async function configureApp (app, options = {}) {
           : DEFAULT_BASENAME;
         let resultingExt = extname;
         if (!supportedAppExtensions.includes(resultingExt)) {
-          logger.info(`The current file extension '${resultingExt}' is not supported. ` +
-            `Defaulting to '${_.first(supportedAppExtensions)}'`);
-          resultingExt = _.first(supportedAppExtensions);
+          logger.info(
+            `The current file extension '${resultingExt}' is not supported. ` +
+              `Defaulting to '${_.first(supportedAppExtensions)}'`
+          );
+          resultingExt = /** @type {string} */ (_.first(supportedAppExtensions));
         }
         fileName = `${resultingName}${resultingExt}`;
       }
@@ -323,7 +336,8 @@ async function configureApp (app, options = {}) {
       let errorMessage = `The application at '${newApp}' does not exist or is not accessible`;
       // protocol value for 'C:\\temp' is 'c:', so we check the length as well
       if (_.isString(protocol) && protocol.length > 2) {
-        errorMessage = `The protocol '${protocol}' used in '${newApp}' is not supported. ` +
+        errorMessage =
+          `The protocol '${protocol}' used in '${newApp}' is not supported. ` +
           `Only http: and https: protocols are supported`;
       }
       throw new Error(errorMessage);
@@ -345,8 +359,10 @@ async function configureApp (app, options = {}) {
           logger.info(`Will reuse previously cached application at '${fullPath}'`);
           return verifyAppExtension(fullPath, supportedAppExtensions);
         }
-        logger.info(`The application at '${fullPath}' does not exist anymore ` +
-          `or its integrity has been damaged. Deleting it from the cache`);
+        logger.info(
+          `The application at '${fullPath}' does not exist anymore ` +
+            `or its integrity has been damaged. Deleting it from the cache`
+        );
         APPLICATIONS_CACHE.delete(app);
       }
       const tmpRoot = await tempDir.openDir();
@@ -360,8 +376,10 @@ async function configureApp (app, options = {}) {
       logger.info(`Unzipped local app to '${newApp}'`);
     } else if (!path.isAbsolute(newApp)) {
       newApp = path.resolve(process.cwd(), newApp);
-      logger.warn(`The current application path '${app}' is not absolute ` +
-        `and has been rewritten to '${newApp}'. Consider using absolute paths rather than relative`);
+      logger.warn(
+        `The current application path '${app}' is not absolute ` +
+          `and has been rewritten to '${newApp}'. Consider using absolute paths rather than relative`
+      );
       app = newApp;
     }
 
@@ -393,19 +411,19 @@ async function configureApp (app, options = {}) {
         headers: _.clone(headers),
         appPath: newApp,
       });
-      return (!result?.appPath || app === result?.appPath || !await fs.exists(result?.appPath))
+      return !result?.appPath || app === result?.appPath || !(await fs.exists(result?.appPath))
         ? newApp
         : await storeAppInCache(result.appPath);
     }
 
     verifyAppExtension(newApp, supportedAppExtensions);
-    return (app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean)))
+    return app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean))
       ? await storeAppInCache(newApp)
       : newApp;
   });
 }
 
-async function downloadApp (app, targetPath) {
+async function downloadApp(app, targetPath) {
   const {href} = url.parse(app);
   try {
     await net.downloadFile(href, targetPath, {
@@ -426,11 +444,11 @@ async function downloadApp (app, targetPath) {
  * @param {Array<string>|string} supportedAppExtensions The list of extensions
  * the target application bundle supports, for example ['.apk', '.apks'] for
  * Android packages
- * @returns {string} Full path to the bundle in the destination folder
+ * @returns {Promise<string>} Full path to the bundle in the destination folder
  * @throws {Error} If the given archive is invalid or no application bundles
  * have been found inside
  */
-async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {
+async function unzipApp(zipPath, dstRoot, supportedAppExtensions) {
   await zip.assertValidZip(zipPath);
 
   if (!_.isArray(supportedAppExtensions)) {
@@ -442,8 +460,8 @@ async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {
     logger.debug(`Unzipping '${zipPath}'`);
     const timer = new timing.Timer().start();
     const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;
-    const useSystemUnzip = _.isEmpty(useSystemUnzipEnv)
-      || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));
+    const useSystemUnzip =
+      _.isEmpty(useSystemUnzipEnv) || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));
     /**
      * Attempt to use use the system `unzip` (e.g., `/usr/bin/unzip`) due
      * to the significant performance improvement it provides over the native
@@ -453,25 +471,41 @@ async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {
     const extractionOpts = {useSystemUnzip};
     // https://github.com/appium/appium/issues/14100
     if (path.extname(zipPath) === IPA_EXT) {
-      logger.debug(`Enforcing UTF-8 encoding on the extracted file names for '${path.basename(zipPath)}'`);
+      logger.debug(
+        `Enforcing UTF-8 encoding on the extracted file names for '${path.basename(zipPath)}'`
+      );
       extractionOpts.fileNamesEncoding = 'utf8';
     }
     await zip.extractAllTo(zipPath, tmpRoot, extractionOpts);
-    const globPattern = `**/*.+(${supportedAppExtensions.map((ext) => ext.replace(/^\./, '')).join('|')})`;
-    const sortedBundleItems = (await fs.glob(globPattern, {
-      cwd: tmpRoot,
-      strict: false,
-    // Get the top level match
-    })).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
+    const globPattern = `**/*.+(${supportedAppExtensions
+      .map((ext) => ext.replace(/^\./, ''))
+      .join('|')})`;
+    const sortedBundleItems = (
+      await fs.glob(globPattern, {
+        cwd: tmpRoot,
+        strict: false,
+        // Get the top level match
+      })
+    ).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
     if (_.isEmpty(sortedBundleItems)) {
-      logger.errorAndThrow(`App unzipped OK, but we could not find any '${supportedAppExtensions}' ` +
-        util.pluralize('bundle', supportedAppExtensions.length, false) +
-        ` in it. Make sure your archive contains at least one package having ` +
-        `'${supportedAppExtensions}' ${util.pluralize('extension', supportedAppExtensions.length, false)}`);
+      logger.errorAndThrow(
+        `App unzipped OK, but we could not find any '${supportedAppExtensions}' ` +
+          util.pluralize('bundle', supportedAppExtensions.length, false) +
+          ` in it. Make sure your archive contains at least one package having ` +
+          `'${supportedAppExtensions}' ${util.pluralize(
+            'extension',
+            supportedAppExtensions.length,
+            false
+          )}`
+      );
     }
-    logger.debug(`Extracted ${util.pluralize('bundle item', sortedBundleItems.length, true)} ` +
-      `from '${zipPath}' in ${Math.round(timer.getDuration().asMilliSeconds)}ms: ${sortedBundleItems}`);
-    const matchedBundle = _.first(sortedBundleItems);
+    logger.debug(
+      `Extracted ${util.pluralize('bundle item', sortedBundleItems.length, true)} ` +
+        `from '${zipPath}' in ${Math.round(
+          timer.getDuration().asMilliSeconds
+        )}ms: ${sortedBundleItems}`
+    );
+    const matchedBundle = /** @type {string} */ (_.first(sortedBundleItems));
     logger.info(`Assuming '${matchedBundle}' is the correct bundle`);
     const dstPath = path.resolve(dstRoot, path.basename(matchedBundle));
     await fs.mv(path.resolve(tmpRoot, matchedBundle), dstPath, {mkdirp: true});
@@ -481,8 +515,8 @@ async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {
   }
 }
 
-function isPackageOrBundle (app) {
-  return (/^([a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+)+$/).test(app);
+function isPackageOrBundle(app) {
+  return /^([a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+)+$/.test(app);
 }
 
 /**
@@ -495,7 +529,7 @@ function isPackageOrBundle (app) {
  * @param {String} firstKey The first key to duplicate
  * @param {String} secondKey The second key to duplicate
  */
-function duplicateKeys (input, firstKey, secondKey) {
+function duplicateKeys(input, firstKey, secondKey) {
   // If array provided, recursively call on all elements
   if (_.isArray(input)) {
     return input.map((item) => duplicateKeys(item, firstKey, secondKey));
@@ -526,7 +560,7 @@ function duplicateKeys (input, firstKey, secondKey) {
  *
  * @param {string|Array<String>} cap A desired capability
  */
-function parseCapsArray (cap) {
+function parseCapsArray(cap) {
   if (_.isArray(cap)) {
     return cap;
   }
@@ -553,15 +587,24 @@ function parseCapsArray (cap) {
  * @param {string?} sessionId session identifier (if exists)
  * @returns {string}
  */
-function generateDriverLogPrefix (obj, sessionId = null) {
+function generateDriverLogPrefix(obj, sessionId = null) {
   const instanceName = `${obj.constructor.name}@${node.getObjectId(obj).substring(0, 4)}`;
   return sessionId ? `${instanceName} (${sessionId.substring(0, 8)})` : instanceName;
 }
 
 /** @type {import('@appium/types').DriverHelpers} */
 export default {
-  configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray, generateDriverLogPrefix
-};
-export {
-  configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray, generateDriverLogPrefix
+  configureApp,
+  isPackageOrBundle,
+  duplicateKeys,
+  parseCapsArray,
+  generateDriverLogPrefix,
 };
+export {configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray, generateDriverLogPrefix};
+
+/**
+ * @typedef RemoteAppProps
+ * @property {Date?} lastModified
+ * @property {boolean} immutable
+ * @property {number?} maxAge
+ */

package/lib/basedriver/logger.js

@@ -1,4 +1,4 @@
-import { logger } from '@appium/support';
+import {logger} from '@appium/support';
 
 const log = logger.getLogger('BaseDriver');
 export default log;

package/lib/constants.js

@@ -1,4 +1,4 @@
-import { util } from '@appium/support';
+import {util} from '@appium/support';
 
 // The default maximum length of a single log record
 // containing http request/response body
@@ -17,8 +17,4 @@ const PROTOCOLS = {
 // Before Appium 2.0, this default value was '/wd/hub' by historical reasons.
 const DEFAULT_BASE_PATH = '';
 
-
-export {
-  MAX_LOG_BODY_LENGTH, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY,
-  PROTOCOLS, DEFAULT_BASE_PATH
-};
+export {MAX_LOG_BODY_LENGTH, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS, DEFAULT_BASE_PATH};

package/lib/express/crash.js

@@ -1,13 +1,11 @@
-import { errors } from '../protocol';
+import {errors} from '../protocol';
 
-
-function produceError () {
+function produceError() {
   throw new errors.UnknownCommandError('Produced generic error for testing');
 }
 
-function produceCrash () {
+function produceCrash() {
   throw new Error('We just tried to crash Appium!');
 }
 
-
-export { produceError, produceCrash };
+export {produceError, produceCrash};

package/lib/express/express-logging.js

@@ -2,23 +2,21 @@ import _ from 'lodash';
 import '@colors/colors';
 import morgan from 'morgan';
 import log from './logger';
-import { MAX_LOG_BODY_LENGTH } from '../constants';
-
+import {MAX_LOG_BODY_LENGTH} from '../constants';
 
 // Copied the morgan compile function over so that cooler formats
 // may be configured
-function compile (fmt) {
+function compile(fmt) {
   // escape quotes
   fmt = fmt.replace(/"/g, '\\"');
-  fmt = fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g,
-    function replace (_, name, arg) {
-      return `"\n    + (tokens["${name}"](req, res, "${arg}") || "-") + "`;
-    });
+  fmt = fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g, function replace(_, name, arg) {
+    return `"\n    + (tokens["${name}"](req, res, "${arg}") || "-") + "`;
+  });
   let js = `  return "${fmt}";`;
   return new Function('tokens, req, res', js);
 }
 
-function requestEndLoggingFormat (tokens, req, res) {
+function requestEndLoggingFormat(tokens, req, res) {
   let status = res.statusCode;
   let statusStr = ':status';
   if (status >= 500) {
@@ -30,28 +28,32 @@ function requestEndLoggingFormat (tokens, req, res) {
   } else {
     statusStr = statusStr.green;
   }
-  let fn = compile(`${'<-- :method :url '.white}${statusStr} ${':response-time ms - :res[content-length]'.grey}`);
+  let fn = compile(
+    `${'<-- :method :url '.white}${statusStr} ${':response-time ms - :res[content-length]'.grey}`
+  );
   return fn(tokens, req, res);
 }
 
 const endLogFormatter = morgan((tokens, req, res) => {
-  log.info(requestEndLoggingFormat(tokens, req, res),
-    (res.jsonResp || '').grey);
+  log.info(requestEndLoggingFormat(tokens, req, res), (res.jsonResp || '').grey);
 });
 
 const requestStartLoggingFormat = compile(`${'-->'.white} ${':method'.white} ${':url'.white}`);
 
-const startLogFormatter = morgan((tokens, req, res) => {
-  // morgan output is redirected straight to winston
-  let reqBody = '';
-  if (req.body) {
-    try {
-      reqBody = _.truncate(_.isString(req.body) ? req.body : JSON.stringify(req.body), {
-        length: MAX_LOG_BODY_LENGTH,
-      });
-    } catch (ign) {}
-  }
-  log.info(requestStartLoggingFormat(tokens, req, res), reqBody.grey);
-}, {immediate: true});
+const startLogFormatter = morgan(
+  (tokens, req, res) => {
+    // morgan output is redirected straight to winston
+    let reqBody = '';
+    if (req.body) {
+      try {
+        reqBody = _.truncate(_.isString(req.body) ? req.body : JSON.stringify(req.body), {
+          length: MAX_LOG_BODY_LENGTH,
+        });
+      } catch (ign) {}
+    }
+    log.info(requestStartLoggingFormat(tokens, req, res), reqBody.grey);
+  },
+  {immediate: true}
+);
 
-export { endLogFormatter, startLogFormatter };
+export {endLogFormatter, startLogFormatter};

package/lib/express/idempotency.js

@@ -1,16 +1,15 @@
 import log from './logger';
 import LRU from 'lru-cache';
-import { fs, util } from '@appium/support';
+import {fs, util} from '@appium/support';
 import os from 'os';
 import path from 'path';
-import { EventEmitter } from 'events';
-
+import {EventEmitter} from 'events';
 
 const CACHE_SIZE = 1024;
 const IDEMPOTENT_RESPONSES = new LRU({
   max: CACHE_SIZE,
   updateAgeOnGet: true,
-  dispose (key, {response}) {
+  dispose(key, {response}) {
     if (response) {
       fs.rimrafSync(response);
     }
@@ -20,9 +19,7 @@ const MONITORED_METHODS = ['POST', 'PATCH'];
 const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 
 process.on('exit', () => {
-  const resPaths = [...IDEMPOTENT_RESPONSES.values()]
-    .map(({response}) => response)
-    .filter(Boolean);
+  const resPaths = [...IDEMPOTENT_RESPONSES.values()].map(({response}) => response).filter(Boolean);
   for (const resPath of resPaths) {
     try {
       // Asynchronous calls are not supported in onExit handler
@@ -31,8 +28,7 @@ process.on('exit', () => {
   }
 });
 
-
-function cacheResponse (key, req, res) {
+function cacheResponse(key, req, res) {
   const responseStateListener = new EventEmitter();
   IDEMPOTENT_RESPONSES.set(key, {
     method: req.method,
@@ -72,8 +68,10 @@ function cacheResponse (key, req, res) {
     }
 
     if (!IDEMPOTENT_RESPONSES.has(key)) {
-      log.info(`Could not cache the response identified by '${key}'. ` +
-        `Cache consistency has been damaged`);
+      log.info(
+        `Could not cache the response identified by '${key}'. ` +
+          `Cache consistency has been damaged`
+      );
       return responseStateListener.emit('ready', null);
     }
     if (writeError) {
@@ -82,8 +80,10 @@ function cacheResponse (key, req, res) {
       return responseStateListener.emit('ready', null);
     }
     if (!isResponseFullySent) {
-      log.info(`Could not cache the response identified by '${key}', ` +
-        `because it has not been completed`);
+      log.info(
+        `Could not cache the response identified by '${key}', ` +
+          `because it has not been completed`
+      );
       log.info('Does the client terminate connections too early?');
       IDEMPOTENT_RESPONSES.delete(key);
       return responseStateListener.emit('ready', null);
@@ -94,7 +94,7 @@ function cacheResponse (key, req, res) {
   });
 }
 
-async function handleIdempotency (req, res, next) {
+async function handleIdempotency(req, res, next) {
   const key = req.headers[IDEMPOTENCY_KEY_HEADER];
   if (!key) {
     return next();
@@ -124,7 +124,7 @@ async function handleIdempotency (req, res, next) {
   }
 
   const rerouteCachedResponse = async (cachedResPath) => {
-    if (!await fs.exists(cachedResPath)) {
+    if (!(await fs.exists(cachedResPath))) {
       IDEMPOTENT_RESPONSES.delete(key);
       log.warn(`Could not read the cached response identified by key '${key}'`);
       log.warn('The temporary storage is not accessible anymore');
@@ -149,4 +149,4 @@ async function handleIdempotency (req, res, next) {
   }
 }
 
-export { handleIdempotency };
+export {handleIdempotency};

package/lib/express/logger.js

@@ -1,4 +1,4 @@
-import { logger } from '@appium/support';
+import {logger} from '@appium/support';
 
 const log = logger.getLogger('HTTP');
 export default log;