@appium/base-driver 8.2.4 → 8.3.0

package/lib/basedriver/commands/session.js

@@ -1,45 +1,44 @@
 /* eslint-disable require-await */
 import _ from 'lodash';
-import log from '../logger';
 import { errors } from '../../protocol';
 import { util } from '@appium/support';
-import { processCapabilities, promoteAppiumOptions, APPIUM_OPTS_CAP, PREFIXED_APPIUM_OPTS_CAP } from '../capabilities';
+import {
+  processCapabilities, promoteAppiumOptions, APPIUM_OPTS_CAP, PREFIXED_APPIUM_OPTS_CAP,
+} from '../capabilities';
+import { isW3cCaps } from '../../helpers/capabilities';
 
-let commands = {};
+const commands = {};
 
-// TODO: Remove jsonwpDesiredCapabilities and jsonwpRequiredCaps completely
-//       since Appium 2.0 no longer supports them.
-commands.createSession = async function createSession (jsonwpDesiredCapabilities, jsonwpRequiredCaps, w3cCapabilities) {
+commands.createSession = async function createSession (w3cCapabilities1, w3cCapabilities2, w3cCapabilities) {
   if (this.sessionId !== null) {
-    throw new errors.SessionNotCreatedError('Cannot create a new session ' +
-                                            'while one is in progress');
+    throw new errors.SessionNotCreatedError('Cannot create a new session while one is in progress');
   }
 
-  log.debug();
+  this.log.debug();
 
-  if (!w3cCapabilities) {
+  // Historically the first two arguments were reserved for JSONWP capabilities.
+  // Appium 2 has dropped the support of these, so now we only accept capability
+  // objects in W3C format and thus allow any of the three arguments to represent
+  // the latter.
+  const originalCaps = [w3cCapabilities, w3cCapabilities1, w3cCapabilities2].find(isW3cCaps);
+  if (!originalCaps) {
     throw new errors.SessionNotCreatedError('Appium only supports W3C-style capability objects. ' +
       'Your client is sending an older capabilities format. Please update your client library.');
   }
 
-  if (jsonwpDesiredCapabilities) {
-    log.warn('Appium received (M)JSONWP desired capabilities in alongside the W3C capabilities; they will be ignored');
-  }
-
   this.setProtocolW3C();
 
-  this.originalCaps = _.cloneDeep(w3cCapabilities);
-  log.debug(`Creating session with W3C capabilities: ${JSON.stringify(w3cCapabilities, null, 2)}`);
-
+  this.originalCaps = _.cloneDeep(originalCaps);
+  this.log.debug(`Creating session with W3C capabilities: ${JSON.stringify(originalCaps, null, 2)}`);
 
   let caps;
   try {
-    caps = processCapabilities(w3cCapabilities, this.desiredCapConstraints, this.shouldValidateCaps);
+    caps = processCapabilities(originalCaps, this.desiredCapConstraints, this.shouldValidateCaps);
     if (caps[APPIUM_OPTS_CAP]) {
-      log.debug(`Found ${PREFIXED_APPIUM_OPTS_CAP} capability present; will promote items inside to caps`);
+      this.log.debug(`Found ${PREFIXED_APPIUM_OPTS_CAP} capability present; will promote items inside to caps`);
       caps = promoteAppiumOptions(caps);
     }
-    caps = fixCaps(caps, this.desiredCapConstraints);
+    caps = fixCaps(caps, this.desiredCapConstraints, this.log);
   } catch (e) {
     throw new errors.SessionNotCreatedError(e.message);
   }
@@ -79,7 +78,7 @@ commands.createSession = async function createSession (jsonwpDesiredCapabilities
     this.newCommandTimeoutMs = (this.caps.newCommandTimeout * 1000);
   }
 
-  log.info(`Session created with session id: ${this.sessionId}`);
+  this.log.info(`Session created with session id: ${this.sessionId}`);
 
   return [this.sessionId, caps];
 };
@@ -115,7 +114,7 @@ commands.deleteSession = async function deleteSession (/* sessionId */) {
   this.sessionId = null;
 };
 
-function fixCaps (originalCaps, desiredCapConstraints = {}) {
+function fixCaps (originalCaps, desiredCapConstraints = {}, log) {
   let caps = _.clone(originalCaps);
 
   // boolean capabilities can be passed in as strings 'false' and 'true'

package/lib/basedriver/commands/settings.js

@@ -1,17 +1,15 @@
-import log from '../logger';
-
-let commands = {};
+const commands = {};
 
 commands.updateSettings = async function updateSettings (newSettings) {
   if (!this.settings) {
-    log.errorAndThrow('Cannot update settings; settings object not found');
+    this.log.errorAndThrow('Cannot update settings; settings object not found');
   }
   return await this.settings.update(newSettings);
 };
 
 commands.getSettings = async function getSettings () {
   if (!this.settings) {
-    log.errorAndThrow('Cannot get settings; settings object not found');
+    this.log.errorAndThrow('Cannot get settings; settings object not found');
   }
   return await this.settings.getSettings();
 };

package/lib/basedriver/commands/timeout.js

@@ -1,4 +1,3 @@
-import log from '../logger';
 import { waitForCondition } from 'asyncbox';
 import _ from 'lodash';
 import { util } from '@appium/support';
@@ -11,7 +10,7 @@ const MIN_TIMEOUT = 0;
 
 commands.timeouts = async function timeouts (type, ms, script, pageLoad, implicit) {
   if (util.hasValue(type) && util.hasValue(ms)) {
-    log.debug(`MJSONWP timeout arguments: ${JSON.stringify({type, ms})}}`);
+    this.log.debug(`MJSONWP timeout arguments: ${JSON.stringify({type, ms})}}`);
 
     switch (type) {
       case 'command':
@@ -32,7 +31,7 @@ commands.timeouts = async function timeouts (type, ms, script, pageLoad, implici
   }
 
   // Otherwise assume it is W3C protocol
-  log.debug(`W3C timeout argument: ${JSON.stringify({script, pageLoad, implicit})}}`);
+  this.log.debug(`W3C timeout argument: ${JSON.stringify({script, pageLoad, implicit})}}`);
   if (util.hasValue(script)) {
     await this.scriptTimeoutW3C(script);
   }
@@ -66,9 +65,9 @@ commands.implicitWait = async function implicitWait (ms) {
 
 helpers.setImplicitWait = function setImplicitWait (ms) { // eslint-disable-line require-await
   this.implicitWaitMs = ms;
-  log.debug(`Set implicit wait to ${ms}ms`);
+  this.log.debug(`Set implicit wait to ${ms}ms`);
   if (this.managedDrivers && this.managedDrivers.length) {
-    log.debug('Setting implicit wait on managed drivers');
+    this.log.debug('Setting implicit wait on managed drivers');
     for (let driver of this.managedDrivers) {
       if (_.isFunction(driver.setImplicitWait)) {
         driver.setImplicitWait(ms);
@@ -106,9 +105,9 @@ commands.newCommandTimeout = async function newCommandTimeout (ms) { // eslint-d
 
 helpers.setNewCommandTimeout = function setNewCommandTimeout (ms) {
   this.newCommandTimeoutMs = ms;
-  log.debug(`Set new command timeout to ${ms}ms`);
+  this.log.debug(`Set new command timeout to ${ms}ms`);
   if (this.managedDrivers && this.managedDrivers.length) {
-    log.debug('Setting new command timeout on managed drivers');
+    this.log.debug('Setting new command timeout on managed drivers');
     for (let driver of this.managedDrivers) {
       if (_.isFunction(driver.setNewCommandTimeout)) {
         driver.setNewCommandTimeout(ms);
@@ -132,7 +131,7 @@ helpers.startNewCommandTimeout = function startNewCommandTimeout () {
   if (!this.newCommandTimeoutMs) return; // eslint-disable-line curly
 
   this.noCommandTimer = setTimeout(async () => {
-    log.warn(`Shutting down because we waited ` +
+    this.log.warn(`Shutting down because we waited ` +
               `${this.newCommandTimeoutMs / 1000.0} seconds for a command`);
     const errorMessage = `New Command Timeout of ` +
               `${this.newCommandTimeoutMs / 1000.0} seconds ` +
@@ -143,7 +142,7 @@ helpers.startNewCommandTimeout = function startNewCommandTimeout () {
 };
 
 helpers.implicitWaitForCondition = async function implicitWaitForCondition (condFn) {
-  log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
+  this.log.debug(`Waiting up to ${this.implicitWaitMs} ms for condition`);
   let wrappedCondFn = async (...args) => {
     // reset command timeout
     this.clearNewCommandTimeout();
@@ -151,7 +150,7 @@ helpers.implicitWaitForCondition = async function implicitWaitForCondition (cond
     return await condFn(...args);
   };
   return await waitForCondition(wrappedCondFn, {
-    waitMs: this.implicitWaitMs, intervalMs: 500, logger: log
+    waitMs: this.implicitWaitMs, intervalMs: 500, logger: this.log
   });
 };
 

package/lib/basedriver/device-settings.js

@@ -1,5 +1,9 @@
 import _ from 'lodash';
 import log from './logger';
+import { node, util } from '@appium/support';
+import { errors } from '../protocol/errors';
+
+const MAX_SETTINGS_SIZE = 20 * 1024 * 1024; // 20 MB
 
 class DeviceSettings {
 
@@ -11,9 +15,14 @@ class DeviceSettings {
   // calls updateSettings from implementing driver every time a setting is changed.
   async update (newSettings) {
     if (!_.isPlainObject(newSettings)) {
-      throw new Error(`Settings update should be called with valid JSON. Got ` +
+      throw new errors.InvalidArgumentError(`Settings update should be called with valid JSON. Got ` +
         `${JSON.stringify(newSettings)} instead`);
     }
+    if (node.getObjectSize({...this._settings, ...newSettings}) >= MAX_SETTINGS_SIZE) {
+      throw new errors.InvalidArgumentError(`New settings cannot be applied, because the overall ` +
+        `object size exceeds the allowed limit of ${util.toReadableSizeString(MAX_SETTINGS_SIZE)}`);
+    }
+
     for (const prop of _.keys(newSettings)) {
       if (!_.isUndefined(this._settings[prop])) {
         if (this._settings[prop] === newSettings[prop]) {

package/lib/basedriver/driver.js

@@ -1,12 +1,11 @@
 import {
   Protocol, errors, determineProtocol, DELETE_SESSION_COMMAND,
 } from '../protocol';
-import { fs } from '@appium/support';
+import { fs, logger, node } from '@appium/support';
 import { PROTOCOLS, DEFAULT_BASE_PATH } from '../constants';
 import os from 'os';
 import commands from './commands';
 import * as helpers from './helpers';
-import log from './logger';
 import DeviceSettings from './device-settings';
 import { desiredCapabilityConstraints } from './desired-caps';
 import { validateCaps } from './capabilities';
@@ -30,6 +29,7 @@ const EVENT_SESSION_QUIT_START = 'quitSessionRequested';
 const EVENT_SESSION_QUIT_DONE = 'quitSessionFinished';
 const ON_UNEXPECTED_SHUTDOWN_EVENT = 'onUnexpectedShutdown';
 
+
 class BaseDriver extends Protocol {
 
   /**
@@ -48,6 +48,8 @@ class BaseDriver extends Protocol {
     this.originalCaps = null; // To give the original capabilities to reset
     this.helpers = helpers;
 
+    this._log = null;
+
     // basePath is used for several purposes, for example in setting up
     // proxying to other drivers, since we need to know what the base path
     // of any incoming request might look like. We set it to the default
@@ -104,6 +106,17 @@ class BaseDriver extends Protocol {
     this.protocol = null;
   }
 
+  get log () {
+    if (!this._log) {
+      const instanceName = `${this.constructor.name}@${node.getObjectId(this).substring(0, 8)}`;
+      this._log = logger.getLogger(() =>
+        this.sessionId ? `${instanceName} (${this.sessionId.substring(0, 8)})` : instanceName
+      );
+    }
+
+    return this._log;
+  }
+
   /**
    * Set a callback handler if needed to execute a custom piece of code
    * when the driver is shut down unexpectedly. Multiple calls to this method
@@ -168,7 +181,7 @@ class BaseDriver extends Protocol {
     const ts = Date.now();
     const logTime = (new Date(ts)).toTimeString();
     this._eventHistory[eventName].push(ts);
-    log.debug(`Event '${eventName}' logged at ${ts} (${logTime})`);
+    this.log.debug(`Event '${eventName}' logged at ${ts} (${logTime})`);
   }
 
   /*
@@ -214,10 +227,10 @@ class BaseDriver extends Protocol {
     let extraCaps = _.difference(_.keys(caps),
                                  _.keys(this._constraints));
     if (extraCaps.length) {
-      log.warn(`The following capabilities were provided, but are not ` +
+      this.log.warn(`The following capabilities were provided, but are not ` +
                `recognized by Appium:`);
       for (const cap of extraCaps) {
-        log.warn(`  ${cap}`);
+        this.log.warn(`  ${cap}`);
       }
     }
   }
@@ -230,8 +243,8 @@ class BaseDriver extends Protocol {
     try {
       validateCaps(caps, this._constraints);
     } catch (e) {
-      log.errorAndThrow(new errors.SessionNotCreatedError(`The desiredCapabilities object was not valid for the ` +
-                    `following reason(s): ${e.message}`));
+      this.log.errorAndThrow(new errors.SessionNotCreatedError(`The desiredCapabilities object was not valid for the ` +
+        `following reason(s): ${e.message}`));
     }
 
     this.logExtraCaps(caps);
@@ -309,7 +322,7 @@ class BaseDriver extends Protocol {
 
     if (cmd === 'createSession') {
       // If creating a session determine if W3C or MJSONWP protocol was requested and remember the choice
-      this.protocol = determineProtocol(...args);
+      this.protocol = determineProtocol(args);
       this.logEvent(EVENT_SESSION_INIT);
     } else if (cmd === DELETE_SESSION_COMMAND) {
       this.logEvent(EVENT_SESSION_QUIT_START);
@@ -381,7 +394,7 @@ class BaseDriver extends Protocol {
 
   validateLocatorStrategy (strategy, webContext = false) {
     let validStrategies = this.locatorStrategies;
-    log.debug(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);
+    this.log.debug(`Valid locator strategies for this request: ${validStrategies.join(', ')}`);
 
     if (webContext) {
       validStrategies = validStrategies.concat(this.webLocatorStrategies);
@@ -397,8 +410,8 @@ class BaseDriver extends Protocol {
    * preserving the timeout config.
    */
   async reset () {
-    log.debug('Resetting app mid-session');
-    log.debug('Running generic full reset');
+    this.log.debug('Resetting app mid-session');
+    this.log.debug('Running generic full reset');
 
     // preserving state
     let currentConfig = {};
@@ -411,7 +424,7 @@ class BaseDriver extends Protocol {
 
     try {
       await this.deleteSession(this.sessionId);
-      log.debug('Restarting app');
+      this.log.debug('Restarting app');
       await this.createSession(undefined, undefined, this.originalCaps);
     } finally {
       // always restore state.

package/lib/basedriver/helpers.js

@@ -15,17 +15,17 @@ const ZIP_MIME_TYPES = [
   'multipart/x-zip',
 ];
 const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
+const MAX_CACHED_APPS = 1024;
 const APPLICATIONS_CACHE = new LRU({
-  maxAge: CACHED_APPS_MAX_AGE, // expire after 24 hours
+  max: MAX_CACHED_APPS,
+  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`);
-    setTimeout(async () => {
-      if (fullPath) {
-        await fs.rimraf(fullPath);
-      }
-    });
+    if (fullPath) {
+      fs.rimraf(fullPath);
+    }
   },
   noDisposeOnSet: true,
 });
@@ -35,11 +35,11 @@ const DEFAULT_BASENAME = 'appium-app';
 const APP_DOWNLOAD_TIMEOUT_MS = 120 * 1000;
 
 process.on('exit', () => {
-  if (APPLICATIONS_CACHE.itemCount === 0) {
+  if (APPLICATIONS_CACHE.size === 0) {
     return;
   }
 
-  const appPaths = APPLICATIONS_CACHE.values()
+  const appPaths = [...APPLICATIONS_CACHE.values()]
     .map(({fullPath}) => fullPath);
   logger.debug(`Performing cleanup of ${appPaths.length} cached ` +
     util.pluralize('application', appPaths.length));
@@ -151,7 +151,7 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
 }
 
 /**
- * @typedef {Object} PostProcessOptions
+ * @typedef PostProcessOptions
  * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):
  *    - packageHash: SHA1 hash of the package if it is a file and not a folder
  *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header
@@ -171,13 +171,13 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
  */
 
 /**
- * @typedef {Object} PostProcessResult
+ * @typedef PostProcessResult
  * @property {string} appPath The full past to the post-processed application package on the
  * local file system (might be a file or a folder path)
  */
 
 /**
- * @typedef {Object} ConfigureAppOptions
+ * @typedef ConfigureAppOptions
  * @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
@@ -193,6 +193,8 @@ async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
 /**
  * Prepares an app to be used in an automated test. The app gets cached automatically
  * if it is an archive or if it is downloaded from an URL.
+ * If the downloaded app has `.zip` extension, this method will unzip it.
+ * The unzip does not work when `onPostProcess` is provided.
  *
  * @param {string} app Either a full path to the app or a remote URL
  * @param {string|string[]|ConfigureAppOptions} options

package/lib/express/express-logging.js

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import '@dabh/colors';
+import '@colors/colors';
 import morgan from 'morgan';
 import log from './logger';
 import { MAX_LOG_BODY_LENGTH } from '../constants';

package/lib/express/idempotency.js

@@ -20,7 +20,7 @@ const MONITORED_METHODS = ['POST', 'PATCH'];
 const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 
 process.on('exit', () => {
-  const resPaths = IDEMPOTENT_RESPONSES.values()
+  const resPaths = [...IDEMPOTENT_RESPONSES.values()]
     .map(({response}) => response)
     .filter(Boolean);
   for (const resPath of resPaths) {

package/lib/helpers/capabilities.js

@@ -0,0 +1,25 @@
+import _ from 'lodash';
+
+function isW3cCaps (caps) {
+  if (!_.isPlainObject(caps)) {
+    return false;
+  }
+
+  const isFirstMatchValid = () => _.isArray(caps.firstMatch)
+    && !_.isEmpty(caps.firstMatch) && _.every(caps.firstMatch, _.isPlainObject);
+  const isAlwaysMatchValid = () => _.isPlainObject(caps.alwaysMatch);
+  if (_.has(caps, 'firstMatch') && _.has(caps, 'alwaysMatch')) {
+    return isFirstMatchValid() && isAlwaysMatchValid();
+  }
+  if (_.has(caps, 'firstMatch')) {
+    return isFirstMatchValid();
+  }
+  if (_.has(caps, 'alwaysMatch')) {
+    return isAlwaysMatchValid();
+  }
+  return false;
+}
+
+export {
+  isW3cCaps,
+};

package/lib/index.js

@@ -5,9 +5,9 @@ import * as driver from './basedriver/driver';
 import * as deviceSettings from './basedriver/device-settings';
 
 const { BaseDriver } = driver;
-const { DeviceSettings, BASEDRIVER_HANDLED_SETTINGS } = deviceSettings;
+const { DeviceSettings } = deviceSettings;
 
-export { BaseDriver, DeviceSettings, BASEDRIVER_HANDLED_SETTINGS };
+export { BaseDriver, DeviceSettings };
 export default BaseDriver;
 
 

package/lib/jsonwp-proxy/protocol-converter.js

@@ -5,9 +5,6 @@ import {
   MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS
 } from '../constants';
 
-const log = logger.getLogger('Protocol Converter');
-
-
 export const COMMAND_URLS_CONFLICTS = [
   {
     commandNames: ['execute', 'executeAsync'],
@@ -41,20 +38,24 @@ export const COMMAND_URLS_CONFLICTS = [
     jsonwpConverter: (w3cUrl) => {
       const w3cPropertyRegex = /\/element\/([^/]+)\/property\/([^/]+)/;
       const jsonwpUrl = w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');
-      log.info(`Converting W3C '${w3cUrl}' to '${jsonwpUrl}'`);
       return jsonwpUrl;
     },
     w3cConverter: (jsonwpUrl) => jsonwpUrl // Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property
   }
 ];
-
 const {MJSONWP, W3C} = PROTOCOLS;
+const DEFAULT_LOG = logger.getLogger('Protocol Converter');
 
 
 class ProtocolConverter {
-  constructor (proxyFunc) {
+  constructor (proxyFunc, log = null) {
     this.proxyFunc = proxyFunc;
     this._downstreamProtocol = null;
+    this._log = log;
+  }
+
+  get log () {
+    return this._log ?? DEFAULT_LOG;
   }
 
   set downstreamProtocol (value) {
@@ -107,7 +108,7 @@ class ProtocolConverter {
     let response, resBody;
 
     const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
-    log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
+    this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
     for (const timeoutObj of timeoutRequestObjects) {
       [response, resBody] = await this.proxyFunc(url, method, timeoutObj);
 
@@ -130,14 +131,14 @@ class ProtocolConverter {
     const bodyObj = util.safeJsonParse(body);
     if (_.isPlainObject(bodyObj)) {
       if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {
-        log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
+        this.log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, {
           ...bodyObj,
           handle: bodyObj.name,
         });
       }
       if (this.downstreamProtocol === MJSONWP && _.has(bodyObj, 'handle') && !_.has(bodyObj, 'name')) {
-        log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
+        this.log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, {
           ...bodyObj,
           name: bodyObj.handle,
@@ -156,12 +157,12 @@ class ProtocolConverter {
         value = _.isString(text)
           ? [...text]
           : (_.isArray(text) ? text : []);
-        log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
+        this.log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
       } else if (!util.hasValue(text) && util.hasValue(value)) {
         text = _.isArray(value)
           ? value.join('')
           : (_.isString(value) ? value : '');
-        log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
+        this.log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
       }
       return await this.proxyFunc(url, method, Object.assign({}, bodyObj, {
         text,
@@ -236,11 +237,11 @@ class ProtocolConverter {
         ? jsonwpConverter(url)
         : w3cConverter(url);
       if (rewrittenUrl === url) {
-        log.debug(`Did not know how to rewrite the original URL '${url}' ` +
+        this.log.debug(`Did not know how to rewrite the original URL '${url}' ` +
           `for ${this.downstreamProtocol} protocol`);
         break;
       }
-      log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +
+      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +
         `for ${this.downstreamProtocol} protocol`);
       return await this.proxyFunc(rewrittenUrl, method, body);
     }

package/lib/jsonwp-proxy/proxy.js

@@ -12,8 +12,7 @@ import { formatResponseValue, formatStatus } from '../protocol/helpers';
 import http from 'http';
 import https from 'https';
 
-
-const log = logger.getLogger('WD Proxy');
+const DEFAULT_LOG = logger.getLogger('WD Proxy');
 const DEFAULT_REQUEST_TIMEOUT = 240000;
 const COMPACT_ERROR_PATTERNS = [
   /\bECONNREFUSED\b/,
@@ -43,7 +42,12 @@ class JWProxy {
     };
     this.httpAgent = new http.Agent(agentOpts);
     this.httpsAgent = new https.Agent(agentOpts);
-    this.protocolConverter = new ProtocolConverter(this.proxy.bind(this));
+    this.protocolConverter = new ProtocolConverter(this.proxy.bind(this), opts.log);
+    this._log = opts.log;
+  }
+
+  get log () {
+    return this._log ?? DEFAULT_LOG;
   }
 
   /**
@@ -166,7 +170,7 @@ class JWProxy {
       }
     }
 
-    log.debug(`Proxying [${method} ${url || '/'}] to [${method} ${newUrl}] ` +
+    this.log.debug(`Proxying [${method} ${url || '/'}] to [${method} ${newUrl}] ` +
       (reqOpts.data ? `with body: ${truncateBody(reqOpts.data)}` : 'with no body'));
 
     const throwProxyError = (error) => {
@@ -187,7 +191,7 @@ class JWProxy {
         // If it cannot be coerced to an object then the response is wrong
         throwProxyError(data);
       }
-      log.debug(`Got response with status ${status}: ${truncateBody(data)}`);
+      this.log.debug(`Got response with status ${status}: ${truncateBody(data)}`);
       isResponseLogged = true;
       const isSessionCreationRequest = /\/session$/.test(url) && method === 'POST';
       if (isSessionCreationRequest) {
@@ -195,7 +199,7 @@ class JWProxy {
           this.sessionId = data.sessionId || (data.value || {}).sessionId;
         }
         this.downstreamProtocol = this.getProtocolFromResBody(data);
-        log.info(`Determined the downstream protocol as '${this.downstreamProtocol}'`);
+        this.log.info(`Determined the downstream protocol as '${this.downstreamProtocol}'`);
       }
       if (_.has(data, 'status') && parseInt(data.status, 10) !== 0) {
         // Some servers, like chromedriver may return response code 200 for non-zero JSONWP statuses
@@ -211,16 +215,16 @@ class JWProxy {
       if (util.hasValue(e.response)) {
         if (!isResponseLogged) {
           const error = truncateBody(e.response.data);
-          log.info(util.hasValue(e.response.status)
+          this.log.info(util.hasValue(e.response.status)
             ? `Got response with status ${e.response.status}: ${error}`
             : `Got response with unknown status: ${error}`);
         }
       } else {
         proxyErrorMsg = `Could not proxy command to the remote server. Original error: ${e.message}`;
         if (COMPACT_ERROR_PATTERNS.some((p) => p.test(e.message))) {
-          log.info(e.message);
+          this.log.info(e.message);
         } else {
-          log.info(e.stack);
+          this.log.info(e.stack);
         }
       }
       throw new errors.ProxyRequestError(proxyErrorMsg, e.response?.data, e.response?.status);
@@ -256,7 +260,7 @@ class JWProxy {
     if (!commandName) {
       return await this.proxy(url, method, body);
     }
-    log.debug(`Matched '${url}' to command name '${commandName}'`);
+    this.log.debug(`Matched '${url}' to command name '${commandName}'`);
 
     return await this.protocolConverter.convertAndProxy(commandName, url, method, body);
   }
@@ -318,10 +322,10 @@ class JWProxy {
     const reqSessionId = this.getSessionIdFromUrl(req.originalUrl);
     if (_.has(resBodyObj, 'sessionId')) {
       if (reqSessionId) {
-        log.info(`Replacing sessionId ${resBodyObj.sessionId} with ${reqSessionId}`);
+        this.log.info(`Replacing sessionId ${resBodyObj.sessionId} with ${reqSessionId}`);
         resBodyObj.sessionId = reqSessionId;
       } else if (this.sessionId) {
-        log.info(`Replacing sessionId ${resBodyObj.sessionId} with ${this.sessionId}`);
+        this.log.info(`Replacing sessionId ${resBodyObj.sessionId} with ${this.sessionId}`);
         resBodyObj.sessionId = this.sessionId;
       }
     }