appium-uiautomator2-driver 2.0.5 → 2.0.8

package/lib/driver.js

@@ -6,7 +6,6 @@ import {
 import { fs, util, mjpeg } from '@appium/support';
 import { retryInterval } from 'asyncbox';
 import B from 'bluebird';
-import logger from './logger';
 import commands from './commands/index';
 import { DEFAULT_ADB_PORT } from 'appium-adb';
 import uiautomator2Helpers from './helpers';
@@ -212,11 +211,11 @@ class AndroidUiautomator2Driver extends BaseDriver {
       _.defaults(this.opts, defaultOpts);
 
       if (this.isChromeSession) {
-        logger.info("We're going to run a Chrome-based session");
+        this.log.info("We're going to run a Chrome-based session");
         let {pkg, activity} = helpers.getChromePkg(this.opts.browserName);
         this.opts.appPackage = this.caps.appPackage = pkg;
         this.opts.appActivity = this.caps.appActivity = activity;
-        logger.info(`Chrome-type package and activity are ${pkg} and ${activity}`);
+        this.log.info(`Chrome-type package and activity are ${pkg} and ${activity}`);
       }
 
       if (this.opts.reboot) {
@@ -230,9 +229,9 @@ class AndroidUiautomator2Driver extends BaseDriver {
       } else if (this.opts.appPackage) {
         // the app isn't an actual app file but rather something we want to
         // assume is on the device and just launch via the appPackage
-        logger.info(`Starting '${this.opts.appPackage}' directly on the device`);
+        this.log.info(`Starting '${this.opts.appPackage}' directly on the device`);
       } else {
-        logger.info(`Neither 'app' nor 'appPackage' was set. Starting UiAutomator2 ` +
+        this.log.info(`Neither 'app' nor 'appPackage' was set. Starting UiAutomator2 ` +
           'without the target application');
       }
       this.opts.adbPort = this.opts.adbPort || DEFAULT_ADB_PORT;
@@ -240,7 +239,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
       await this.startUiAutomator2Session();
       await this.fillDeviceDetails();
       if (this.opts.mjpegScreenshotUrl) {
-        logger.info(`Starting MJPEG stream reading URL: '${this.opts.mjpegScreenshotUrl}'`);
+        this.log.info(`Starting MJPEG stream reading URL: '${this.opts.mjpegScreenshotUrl}'`);
         this.mjpegStream = new mjpeg.MJpegStream(this.opts.mjpegScreenshotUrl);
         await this.mjpegStream.start();
       }
@@ -264,7 +263,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
 
   async getSession () {
     let sessionData = await super.getSession();
-    logger.debug('Getting session details from server to mix in');
+    this.log.debug('Getting session details from server to mix in');
     let uia2Data = await this.uiautomator2.jwproxy.command('/', 'GET', {});
     return Object.assign({}, sessionData, uia2Data);
   }
@@ -275,13 +274,13 @@ class AndroidUiautomator2Driver extends BaseDriver {
 
   setAvdFromCapabilities (caps) {
     if (this.opts.avd) {
-      logger.info('avd name defined, ignoring device name and platform version');
+      this.log.info('avd name defined, ignoring device name and platform version');
     } else {
       if (!caps.deviceName) {
-        logger.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
+        this.log.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
       }
       if (!caps.platformVersion) {
-        logger.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
+        this.log.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
       }
       let avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');
       this.opts.avd = `${avdDevice}__${caps.platformVersion}`;
@@ -290,9 +289,9 @@ class AndroidUiautomator2Driver extends BaseDriver {
 
   async allocateSystemPort () {
     const forwardPort = async (localPort) => {
-      logger.debug(`Forwarding UiAutomator2 Server port ${DEVICE_PORT} to local port ${localPort}`);
+      this.log.debug(`Forwarding UiAutomator2 Server port ${DEVICE_PORT} to local port ${localPort}`);
       if ((await checkPortStatus(localPort, LOCALHOST_IP4)) === 'open') {
-        logger.errorAndThrow(`UiAutomator2 Server cannot start because the local port #${localPort} is busy. ` +
+        this.log.errorAndThrow(`UiAutomator2 Server cannot start because the local port #${localPort} is busy. ` +
           `Make sure the port you provide via 'systemPort' capability is not occupied. ` +
           `This situation might often be a result of an inaccurate sessions management, e.g. ` +
           `old automation sessions on the same device must always be closed before starting new ones.`);
@@ -310,7 +309,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
       try {
         this.opts.systemPort = await findAPortNotInUse(startPort, endPort);
       } catch (e) {
-        logger.errorAndThrow(
+        this.log.errorAndThrow(
           `Cannot find any free port in range ${startPort}..${endPort}}. ` +
           `Please set the available port number by providing the systemPort capability or ` +
           `double check the processes that are locking ports within this range and terminate ` +
@@ -357,22 +356,22 @@ class AndroidUiautomator2Driver extends BaseDriver {
     const apiLevel = await this.adb.getApiLevel();
 
     if (apiLevel < 21) {
-      logger.errorAndThrow('UIAutomator2 is only supported since Android 5.0 (Lollipop). ' +
+      this.log.errorAndThrow('UIAutomator2 is only supported since Android 5.0 (Lollipop). ' +
         'You could still use other supported backends in order to automate older Android versions.');
     }
 
     if (apiLevel >= 28) { // Android P
-      logger.info('Relaxing hidden api policy');
+      this.log.info('Relaxing hidden api policy');
       await this.adb.setHiddenApiPolicy('1', !!this.opts.ignoreHiddenApiPolicyError);
     }
 
     // check if we have to enable/disable gps before running the application
     if (util.hasValue(this.opts.gpsEnabled)) {
       if (this.isEmulator()) {
-        logger.info(`Trying to ${this.opts.gpsEnabled ? 'enable' : 'disable'} gps location provider`);
+        this.log.info(`Trying to ${this.opts.gpsEnabled ? 'enable' : 'disable'} gps location provider`);
         await this.adb.toggleGPSLocationProvider(this.opts.gpsEnabled);
       } else {
-        logger.warn(`Sorry! 'gpsEnabled' capability is only available for emulators`);
+        this.log.warn(`Sorry! 'gpsEnabled' capability is only available for emulators`);
       }
     }
 
@@ -406,11 +405,11 @@ class AndroidUiautomator2Driver extends BaseDriver {
       // Read https://github.com/appium/appium/pull/11640#issuecomment-438260477
       // `--no-window-animation` works over Android 8 to disable all of animations
       if (await this.adb.isAnimationOn()) {
-        logger.info('Disabling animation via io.appium.settings');
+        this.log.info('Disabling animation via io.appium.settings');
         await this.adb.setAnimationState(false);
         this._wasWindowAnimationDisabled = true;
       } else {
-        logger.info('Window animation is already disabled');
+        this.log.info('Window animation is already disabled');
       }
     }
 
@@ -433,7 +432,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
       // unlock the device to prepare it for testing
       await helpers.unlock(this, this.adb, this.caps);
     } else {
-      logger.debug(`'skipUnlock' capability set, so skipping device unlock`);
+      this.log.debug(`'skipUnlock' capability set, so skipping device unlock`);
     }
 
     if (this.isChromeSession) { // start a chromedriver session
@@ -444,7 +443,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
 
     // if the initial orientation is requested, set it
     if (util.hasValue(this.opts.orientation)) {
-      logger.debug(`Setting initial orientation to '${this.opts.orientation}'`);
+      this.log.debug(`Setting initial orientation to '${this.opts.orientation}'`);
       await this.setOrientation(this.opts.orientation);
     }
 
@@ -453,7 +452,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
     if (this.opts.autoWebview) {
       const viewName = this.defaultWebviewName();
       const timeout = this.opts.autoWebviewTimeout || 2000;
-      logger.info(`Setting auto webview to context '${viewName}' with timeout ${timeout}ms`);
+      this.log.info(`Setting auto webview to context '${viewName}' with timeout ${timeout}ms`);
       await retryInterval(timeout / 500, 500, this.setContext.bind(this), viewName);
     }
 
@@ -496,12 +495,12 @@ class AndroidUiautomator2Driver extends BaseDriver {
     };
     // now that we have package and activity, we can create an instance of
     // uiautomator2 with the appropriate options
-    this.uiautomator2 = new UiAutomator2Server(uiautomator2Opts);
+    this.uiautomator2 = new UiAutomator2Server(this.log, uiautomator2Opts);
     this.proxyReqRes = this.uiautomator2.proxyReqRes.bind(this.uiautomator2);
     this.proxyCommand = this.uiautomator2.proxyCommand.bind(this.uiautomator2);
 
     if (this.opts.skipServerInstallation) {
-      logger.info(`'skipServerInstallation' is set. Skipping UIAutomator2 server installation.`);
+      this.log.info(`'skipServerInstallation' is set. Skipping UIAutomator2 server installation.`);
     } else {
       await this.uiautomator2.installServerApk(this.opts.uiautomator2ServerInstallTimeout);
       try {
@@ -509,7 +508,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
           SETTINGS_HELPER_PKG_ID, SERVER_PACKAGE_ID, SERVER_TEST_PACKAGE_ID,
         );
       } catch (e) {
-        logger.warn(`Cannot add server packages to the Doze whitelist. Original error: ` +
+        this.log.warn(`Cannot add server packages to the Doze whitelist. Original error: ` +
           (e.stderr || e.message));
       }
     }
@@ -531,7 +530,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
       try {
         otherApps = helpers.parseArray(this.opts.otherApps);
       } catch (e) {
-        logger.errorAndThrow(`Could not parse "otherApps" capability: ${e.message}`);
+        this.log.errorAndThrow(`Could not parse "otherApps" capability: ${e.message}`);
       }
       otherApps = await B.all(otherApps
         .map((app) => this.helpers.configureApp(app, [APK_EXTENSION, APKS_EXTENSION])));
@@ -551,13 +550,13 @@ class AndroidUiautomator2Driver extends BaseDriver {
         }
         await helpers.installApk(this.adb, this.opts);
       } else {
-        logger.debug('noReset has been requested and the app is already installed. Doing nothing');
+        this.log.debug('noReset has been requested and the app is already installed. Doing nothing');
       }
     } else {
       if (this.opts.fullReset) {
-        logger.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');
+        this.log.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');
       }
-      logger.debug('No app capability. Assuming it is already on the device');
+      this.log.debug('No app capability. Assuming it is already on the device');
       if (this.opts.fastReset && this.opts.appPackage) {
         await helpers.resetApp(this.adb, this.opts);
       }
@@ -569,11 +568,11 @@ class AndroidUiautomator2Driver extends BaseDriver {
     const appWaitPackage = this.opts.appWaitPackage || this.opts.appPackage;
     const appWaitActivity = this.opts.appWaitActivity || this.opts.appActivity;
 
-    logger.info(`Starting '${this.opts.appPackage}/${this.opts.appActivity} ` +
+    this.log.info(`Starting '${this.opts.appPackage}/${this.opts.appActivity} ` +
       `and waiting for '${appWaitPackage}/${appWaitActivity}'`);
 
     if (this.caps.androidCoverage) {
-      logger.info(`androidCoverage is configured. ` +
+      this.log.info(`androidCoverage is configured. ` +
         ` Starting instrumentation of '${this.caps.androidCoverage}'...`);
       await this.adb.androidCoverage(this.caps.androidCoverage, appWaitPackage, appWaitActivity);
     } else {
@@ -597,7 +596,7 @@ class AndroidUiautomator2Driver extends BaseDriver {
   }
 
   async deleteSession () {
-    logger.debug('Deleting UiAutomator2 session');
+    this.log.debug('Deleting UiAutomator2 session');
 
     try {
       if (!_.isEmpty(this._screenRecordingProperties)) {
@@ -613,13 +612,13 @@ class AndroidUiautomator2Driver extends BaseDriver {
       try {
         await this.stopChromedriverProxies();
       } catch (err) {
-        logger.warn(`Unable to stop ChromeDriver proxies: ${err.message}`);
+        this.log.warn(`Unable to stop ChromeDriver proxies: ${err.message}`);
       }
       if (this.jwpProxyActive) {
         try {
           await this.uiautomator2.deleteSession();
         } catch (err) {
-          logger.warn(`Unable to proxy deleteSession to UiAutomator2: ${err.message}`);
+          this.log.warn(`Unable to proxy deleteSession to UiAutomator2: ${err.message}`);
         }
       }
       this.uiautomator2 = null;
@@ -628,22 +627,22 @@ class AndroidUiautomator2Driver extends BaseDriver {
 
     if (this.adb) {
       if (this.opts.unicodeKeyboard && this.opts.resetKeyboard && this.defaultIME) {
-        logger.debug(`Resetting IME to '${this.defaultIME}'`);
+        this.log.debug(`Resetting IME to '${this.defaultIME}'`);
         try {
           await this.adb.setIME(this.defaultIME);
         } catch (err) {
-          logger.warn(`Unable to reset IME: ${err.message}`);
+          this.log.warn(`Unable to reset IME: ${err.message}`);
         }
       }
       if (this.caps.androidCoverage) {
-        logger.info('Shutting down the adb process of instrumentation...');
+        this.log.info('Shutting down the adb process of instrumentation...');
         await this.adb.endAndroidCoverage();
         // Use this broadcast intent to notify it's time to dump coverage to file
         if (this.caps.androidCoverageEndIntent) {
-          logger.info(`Sending intent broadcast '${this.caps.androidCoverageEndIntent}' at the end of instrumenting.`);
+          this.log.info(`Sending intent broadcast '${this.caps.androidCoverageEndIntent}' at the end of instrumenting.`);
           await this.adb.broadcast(this.caps.androidCoverageEndIntent);
         } else {
-          logger.warn('No androidCoverageEndIntent is configured in caps. Possibly you cannot get coverage file.');
+          this.log.warn('No androidCoverageEndIntent is configured in caps. Possibly you cannot get coverage file.');
         }
       }
       if (this.opts.appPackage) {
@@ -653,65 +652,65 @@ class AndroidUiautomator2Driver extends BaseDriver {
           try {
             await this.adb.forceStop(this.opts.appPackage);
           } catch (err) {
-            logger.warn(`Unable to force stop app: ${err.message}`);
+            this.log.warn(`Unable to force stop app: ${err.message}`);
           }
         }
         if (this.opts.fullReset && !this.opts.skipUninstall) {
-          logger.debug(`Capability 'fullReset' set to 'true', Uninstalling '${this.opts.appPackage}'`);
+          this.log.debug(`Capability 'fullReset' set to 'true', Uninstalling '${this.opts.appPackage}'`);
           try {
             await this.adb.uninstallApk(this.opts.appPackage);
           } catch (err) {
-            logger.warn(`Unable to uninstall app: ${err.message}`);
+            this.log.warn(`Unable to uninstall app: ${err.message}`);
           }
         }
       }
       // This value can be true if test target device is <= 26
       if (this._wasWindowAnimationDisabled) {
-        logger.info('Restoring window animation state');
+        this.log.info('Restoring window animation state');
         await this.adb.setAnimationState(true);
       }
       await this.adb.stopLogcat();
       try {
         await this.releaseSystemPort();
       } catch (error) {
-        logger.warn(`Unable to remove system port forward: ${error.message}`);
+        this.log.warn(`Unable to remove system port forward: ${error.message}`);
         // Ignore, this block will also be called when we fall in catch block
         // and before even port forward.
       }
       try {
         await this.releaseMjpegServerPort();
       } catch (error) {
-        logger.warn(`Unable to remove MJPEG server port forward: ${error.message}`);
+        this.log.warn(`Unable to remove MJPEG server port forward: ${error.message}`);
         // Ignore, this block will also be called when we fall in catch block
         // and before even port forward.
       }
 
       if (await this.adb.getApiLevel() >= 28) { // Android P
-        logger.info('Restoring hidden api policy to the device default configuration');
+        this.log.info('Restoring hidden api policy to the device default configuration');
         await this.adb.setDefaultHiddenApiPolicy(!!this.opts.ignoreHiddenApiPolicyError);
       }
 
       if (this.opts.reboot) {
         let avdName = this.opts.avd.replace('@', '');
-        logger.debug(`Closing emulator '${avdName}'`);
+        this.log.debug(`Closing emulator '${avdName}'`);
         try {
           await this.adb.killEmulator(avdName);
         } catch (err) {
-          logger.warn(`Unable to close emulator: ${err.message}`);
+          this.log.warn(`Unable to close emulator: ${err.message}`);
         }
       }
     }
     if (this.mjpegStream) {
-      logger.info('Closing MJPEG stream');
+      this.log.info('Closing MJPEG stream');
       this.mjpegStream.stop();
     }
     await super.deleteSession();
   }
 
   async checkAppPresent () {
-    logger.debug('Checking whether app is actually present');
+    this.log.debug('Checking whether app is actually present');
     if (!(await fs.exists(this.opts.app))) {
-      logger.errorAndThrow(`Could not find app apk at '${this.opts.app}'`);
+      this.log.errorAndThrow(`Could not find app apk at '${this.opts.app}'`);
     }
   }
 

package/lib/uiautomator2.js

@@ -1,7 +1,6 @@
 import _ from 'lodash';
 import { JWProxy, errors } from '@appium/base-driver';
 import { waitForCondition } from 'asyncbox';
-import log from './logger';
 import {
   SERVER_APK_PATH as apkPath,
   TEST_APK_PATH as testApkPath,
@@ -37,15 +36,17 @@ class UIA2Proxy extends JWProxy {
 }
 
 class UiAutomator2Server {
-  constructor (opts = {}) {
+  constructor (log, opts = {}) {
     for (let req of REQD_PARAMS) {
       if (!opts || !util.hasValue(opts[req])) {
         throw new Error(`Option '${req}' is required!`);
       }
       this[req] = opts[req];
     }
+    this.log = log;
     this.disableSuppressAccessibilityService = opts.disableSuppressAccessibilityService;
     const proxyOpts = {
+      log,
       server: this.host,
       port: this.systemPort,
       keepAlive: true,
@@ -71,7 +72,7 @@ class UiAutomator2Server {
         return { appPath, appId };
       }
 
-      log.info(`Server package at '${appPath}' is not writeable. ` +
+      this.log.info(`Server package at '${appPath}' is not writeable. ` +
         `Will copy it into the temporary location at '${tmpRoot}' as a workaround. ` +
         `Consider making this file writeable manually in order to improve the performance of session startup.`);
       const dstPath = path.resolve(tmpRoot, path.basename(appPath));
@@ -114,7 +115,7 @@ class UiAutomator2Server {
         }
 
         const appState = await this.adb.getApplicationInstallState(appPath, appId);
-        log.debug(`${appId} installation state: ${appState}`);
+        this.log.debug(`${appId} installation state: ${appState}`);
         if (await this.adb.checkApkCert(appPath, appId)) {
           shouldUninstallServerPackages = shouldUninstallServerPackages || [
             this.adb.APP_INSTALL_STATE.OLDER_VERSION_INSTALLED,
@@ -130,16 +131,16 @@ class UiAutomator2Server {
           this.adb.APP_INSTALL_STATE.NOT_INSTALLED,
         ].includes(appState);
       }
-      log.info(`Server packages are ${shouldInstallServerPackages ? '' : 'not '}going to be (re)installed`);
+      this.log.info(`Server packages are ${shouldInstallServerPackages ? '' : 'not '}going to be (re)installed`);
       if (shouldInstallServerPackages && shouldUninstallServerPackages) {
-        log.info('Full packages reinstall is going to be performed');
+        this.log.info('Full packages reinstall is going to be performed');
       }
       for (const {appId, appPath} of packagesInfo) {
         if (shouldUninstallServerPackages) {
           try {
             await this.adb.uninstallApk(appId);
           } catch (err) {
-            log.warn(`Error uninstalling '${appId}': ${err.message}`);
+            this.log.warn(`Error uninstalling '${appId}': ${err.message}`);
           }
         }
         if (shouldInstallServerPackages) {
@@ -159,7 +160,7 @@ class UiAutomator2Server {
   }
 
   async verifyServicesAvailability () {
-    log.debug(`Waiting up to ${SERVICES_LAUNCH_TIMEOUT}ms for services to be available`);
+    this.log.debug(`Waiting up to ${SERVICES_LAUNCH_TIMEOUT}ms for services to be available`);
     let isPmServiceAvailable = false;
     let pmOutput = '';
     let pmError = null;
@@ -178,7 +179,7 @@ class UiAutomator2Server {
             pmOutput = ''; // remove output, so it is not printed below
           } else if (pmOutput.includes(INSTRUMENTATION_TARGET)) {
             pmOutput = ''; // remove output, so it is not printed below
-            log.debug(`Instrumentation target '${INSTRUMENTATION_TARGET}' is available`);
+            this.log.debug(`Instrumentation target '${INSTRUMENTATION_TARGET}' is available`);
             // eslint-disable-next-line require-atomic-updates
             isPmServiceAvailable = true;
           } else if (!pmError) {
@@ -191,11 +192,11 @@ class UiAutomator2Server {
         intervalMs: 1000,
       });
     } catch (err) {
-      log.error(`Unable to find instrumentation target '${INSTRUMENTATION_TARGET}': ${(pmError || {}).message}`);
+      this.log.error(`Unable to find instrumentation target '${INSTRUMENTATION_TARGET}': ${(pmError || {}).message}`);
       if (pmOutput) {
-        log.debug('Available targets:');
+        this.log.debug('Available targets:');
         for (const line of pmOutput.split('\n')) {
-          log.debug(`    ${line.replace('instrumentation:', '')}`);
+          this.log.debug(`    ${line.replace('instrumentation:', '')}`);
         }
       }
     }
@@ -204,10 +205,10 @@ class UiAutomator2Server {
   async startSession (caps) {
     await this.cleanupAutomationLeftovers();
     if (caps.skipServerInstallation) {
-      log.info(`'skipServerInstallation' is set. Attempting to use UIAutomator2 server from the device`);
+      this.log.info(`'skipServerInstallation' is set. Attempting to use UIAutomator2 server from the device`);
     } else {
-      log.info(`Starting UIAutomator2 server ${serverVersion}`);
-      log.info(`Using UIAutomator2 server from '${apkPath}' and test from '${testApkPath}'`);
+      this.log.info(`Starting UIAutomator2 server ${serverVersion}`);
+      this.log.info(`Using UIAutomator2 server from '${apkPath}' and test from '${testApkPath}'`);
     }
 
     const timeout = caps.uiautomator2ServerLaunchTimeout || SERVER_LAUNCH_TIMEOUT;
@@ -216,7 +217,7 @@ class UiAutomator2Server {
     const maxRetries = 2;
     const delayBetweenRetries = 3000;
     while (retries < maxRetries) {
-      log.info(`Waiting up to ${timeout}ms for UiAutomator2 to be online...`);
+      this.log.info(`Waiting up to ${timeout}ms for UiAutomator2 to be online...`);
       this.jwproxy.didInstrumentationExit = false;
       await this.startInstrumentationProcess();
       if (!this.jwproxy.didInstrumentationExit) {
@@ -234,7 +235,7 @@ class UiAutomator2Server {
             intervalMs: 1000,
           });
         } catch (err) {
-          log.errorAndThrow(`The instrumentation process cannot be initialized within ${timeout}ms timeout. `
+          this.log.errorAndThrow(`The instrumentation process cannot be initialized within ${timeout}ms timeout. `
             + 'Make sure the application under test does not crash and investigate the logcat output. '
             + `You could also try to increase the value of 'uiautomator2ServerLaunchTimeout' capability`);
         }
@@ -245,16 +246,16 @@ class UiAutomator2Server {
 
       retries++;
       if (retries >= maxRetries) {
-        log.errorAndThrow('The instrumentation process cannot be initialized. '
+        this.log.errorAndThrow('The instrumentation process cannot be initialized. '
           + 'Make sure the application under test does not crash and investigate the logcat output.');
       }
-      log.warn(`The instrumentation process has been unexpectedly terminated. `
+      this.log.warn(`The instrumentation process has been unexpectedly terminated. `
         + `Retrying UiAutomator2 startup (#${retries} of ${maxRetries - 1})`);
       await this.cleanupAutomationLeftovers(true);
       await B.delay(delayBetweenRetries);
     }
 
-    log.debug(`The initialization of the instrumentation process took `
+    this.log.debug(`The initialization of the instrumentation process took `
       + `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
     await this.jwproxy.command('/session', 'POST', {
       capabilities: {
@@ -290,19 +291,19 @@ class UiAutomator2Server {
   }
 
   async deleteSession () {
-    log.debug('Deleting UiAutomator2 server session');
+    this.log.debug('Deleting UiAutomator2 server session');
     // rely on jwproxy's intelligence to know what we're talking about and
     // delete the current session
     try {
       await this.jwproxy.command('/', 'DELETE');
     } catch (err) {
-      log.warn(`Did not get confirmation UiAutomator2 deleteSession worked; ` +
+      this.log.warn(`Did not get confirmation UiAutomator2 deleteSession worked; ` +
           `Error was: ${err}`);
     }
   }
 
   async cleanupAutomationLeftovers (strictCleanup = false) {
-    log.debug(`Performing ${strictCleanup ? 'strict' : 'shallow'} cleanup of automation leftovers`);
+    this.log.debug(`Performing ${strictCleanup ? 'strict' : 'shallow'} cleanup of automation leftovers`);
 
     try {
       const {value} = (await axios({
@@ -311,18 +312,18 @@ class UiAutomator2Server {
       })).data;
       const activeSessionIds = value.map(({id}) => id).filter(Boolean);
       if (activeSessionIds.length) {
-        log.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);
-        log.debug(`Cleaning up ${util.pluralize('obsolete session', activeSessionIds.length, true)}`);
+        this.log.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);
+        this.log.debug(`Cleaning up ${util.pluralize('obsolete session', activeSessionIds.length, true)}`);
         await B.all(activeSessionIds
           .map((id) => axios.delete(`http://${this.host}:${this.systemPort}/session/${id}`))
         );
         // Let all sessions to be properly terminated before continuing
         await B.delay(1000);
       } else {
-        log.debug('No obsolete sessions have been detected');
+        this.log.debug('No obsolete sessions have been detected');
       }
     } catch (e) {
-      log.debug(`No obsolete sessions have been detected (${e.message})`);
+      this.log.debug(`No obsolete sessions have been detected (${e.message})`);
     }
 
     try {