serverless-offline 8.0.0 → 8.3.1

package/dist/lambda/handler-runner/docker-runner/DockerContainer.js

@@ -49,34 +49,34 @@ const {
   keys
 } = Object;
 
-var _containerId = _classPrivateFieldLooseKey("containerId");
+var _containerId = /*#__PURE__*/_classPrivateFieldLooseKey("containerId");
 
-var _dockerOptions = _classPrivateFieldLooseKey("dockerOptions");
+var _dockerOptions = /*#__PURE__*/_classPrivateFieldLooseKey("dockerOptions");
 
-var _env = _classPrivateFieldLooseKey("env");
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
 
-var _functionKey = _classPrivateFieldLooseKey("functionKey");
+var _functionKey = /*#__PURE__*/_classPrivateFieldLooseKey("functionKey");
 
-var _handler = _classPrivateFieldLooseKey("handler");
+var _handler = /*#__PURE__*/_classPrivateFieldLooseKey("handler");
 
-var _image = _classPrivateFieldLooseKey("image");
+var _image = /*#__PURE__*/_classPrivateFieldLooseKey("image");
 
-var _imageNameTag = _classPrivateFieldLooseKey("imageNameTag");
+var _imageNameTag = /*#__PURE__*/_classPrivateFieldLooseKey("imageNameTag");
 
-var _lambda = _classPrivateFieldLooseKey("lambda");
+var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
-var _layers = _classPrivateFieldLooseKey("layers");
+var _layers = /*#__PURE__*/_classPrivateFieldLooseKey("layers");
 
-var _port = _classPrivateFieldLooseKey("port");
+var _port = /*#__PURE__*/_classPrivateFieldLooseKey("port");
 
-var _provider = _classPrivateFieldLooseKey("provider");
+var _provider = /*#__PURE__*/_classPrivateFieldLooseKey("provider");
 
-var _runtime = _classPrivateFieldLooseKey("runtime");
+var _runtime = /*#__PURE__*/_classPrivateFieldLooseKey("runtime");
 
-var _servicePath = _classPrivateFieldLooseKey("servicePath");
+var _servicePath = /*#__PURE__*/_classPrivateFieldLooseKey("servicePath");
 
 class DockerContainer {
-  constructor(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions) {
+  constructor(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions, v3Utils) {
     Object.defineProperty(this, _containerId, {
       writable: true,
       value: null
@@ -133,12 +133,19 @@ class DockerContainer {
     _classPrivateFieldLooseBase(this, _functionKey)[_functionKey] = functionKey;
     _classPrivateFieldLooseBase(this, _handler)[_handler] = handler;
     _classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag] = this._baseImage(runtime);
-    _classPrivateFieldLooseBase(this, _image)[_image] = new _DockerImage.default(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag]);
+    _classPrivateFieldLooseBase(this, _image)[_image] = new _DockerImage.default(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag], v3Utils);
     _classPrivateFieldLooseBase(this, _runtime)[_runtime] = runtime;
     _classPrivateFieldLooseBase(this, _layers)[_layers] = layers;
     _classPrivateFieldLooseBase(this, _provider)[_provider] = provider;
     _classPrivateFieldLooseBase(this, _servicePath)[_servicePath] = servicePath;
     _classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions] = dockerOptions;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   _baseImage(runtime) {
@@ -147,7 +154,13 @@ class DockerContainer {
 
   async start(codeDir) {
     await _classPrivateFieldLooseBase(this, _image)[_image].pull();
-    (0, _debugLog.default)('Run Docker container...');
+
+    if (this.log) {
+      this.log.debug('Run Docker container...');
+    } else {
+      (0, _debugLog.default)('Run Docker container...');
+    }
+
     let permissions = 'ro';
 
     if (!_classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions].readOnly) {
@@ -160,10 +173,18 @@ class DockerContainer {
     ];
 
     if (_classPrivateFieldLooseBase(this, _layers)[_layers].length > 0) {
-      (0, _serverlessLog.logLayers)(`Found layers, checking provider type`);
+      if (this.log) {
+        this.log.verbose(`Found layers, checking provider type`);
+      } else {
+        (0, _serverlessLog.logLayers)(`Found layers, checking provider type`);
+      }
 
       if (_classPrivateFieldLooseBase(this, _provider)[_provider].name.toLowerCase() !== 'aws') {
-        (0, _serverlessLog.logLayers)(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        if (this.log) {
+          this.log.warning(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        } else {
+          (0, _serverlessLog.logLayers)(`Provider ${_classPrivateFieldLooseBase(this, _provider)[_provider].name} is Unsupported. Layers are only supported on aws.`);
+        }
       } else {
         let layerDir = _classPrivateFieldLooseBase(this, _dockerOptions)[_dockerOptions].layersDir;
 
@@ -174,16 +195,31 @@ class DockerContainer {
         layerDir = (0, _path.join)(layerDir, this._getLayersSha256());
 
         if (await (0, _fsExtra.pathExists)(layerDir)) {
-          (0, _serverlessLog.logLayers)(`Layers already exist for this function. Skipping download.`);
+          if (this.log) {
+            this.log.verbose(`Layers already exist for this function. Skipping download.`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Layers already exist for this function. Skipping download.`);
+          }
         } else {
           const layers = [];
-          (0, _serverlessLog.logLayers)(`Storing layers at ${layerDir}`); // Only initialise if we have layers, we're using AWS, and they don't already exist
+
+          if (this.log) {
+            this.log.verbose(`Storing layers at ${layerDir}`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Storing layers at ${layerDir}`);
+          } // Only initialise if we have layers, we're using AWS, and they don't already exist
+
 
           _classPrivateFieldLooseBase(this, _lambda)[_lambda] = new _awsSdk.Lambda({
             apiVersion: '2015-03-31',
             region: _classPrivateFieldLooseBase(this, _provider)[_provider].region
           });
-          (0, _serverlessLog.logLayers)(`Getting layers`);
+
+          if (this.log) {
+            this.log.verbose(`Getting layers`);
+          } else {
+            (0, _serverlessLog.logLayers)(`Getting layers`);
+          }
 
           for (const layerArn of _classPrivateFieldLooseBase(this, _layers)[_layers]) {
             layers.push(this._downloadLayer(layerArn, layerDir));
@@ -275,66 +311,119 @@ class DockerContainer {
   async _downloadLayer(layerArn, layerDir) {
     const layerName = layerArn.split(':layer:')[1];
     const layerZipFile = `${layerDir}/${layerName}.zip`;
-    (0, _serverlessLog.logLayers)(`[${layerName}] ARN: ${layerArn}`);
+    const layerProgress = this.log && this.progress.get(`layer-${layerName}`);
+
+    if (this.log) {
+      this.log.verbose(`[${layerName}] ARN: ${layerArn}`);
+    } else {
+      (0, _serverlessLog.logLayers)(`[${layerName}] ARN: ${layerArn}`);
+    }
+
     const params = {
       Arn: layerArn
     };
-    (0, _serverlessLog.logLayers)(`[${layerName}] Getting Info`);
-    let layer = null;
 
-    try {
-      layer = await _classPrivateFieldLooseBase(this, _lambda)[_lambda].getLayerVersionByArn(params).promise();
-    } catch (e) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] ${e.code}: ${e.message}`);
-      return;
+    if (this.log) {
+      this.log.verbose(`[${layerName}] Getting Info`);
+      layerProgress.notice(`Retrieving "${layerName}": Getting info`);
+    } else {
+      (0, _serverlessLog.logLayers)(`[${layerName}] Getting Info`);
     }
 
-    if (Object.prototype.hasOwnProperty.call(layer, 'CompatibleRuntimes') && !layer.CompatibleRuntimes.includes(_classPrivateFieldLooseBase(this, _runtime)[_runtime])) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
-      return;
-    }
+    try {
+      let layer = null;
 
-    const layerUrl = layer.Content.Location; // const layerSha = layer.Content.CodeSha256
+      try {
+        layer = await _classPrivateFieldLooseBase(this, _lambda)[_lambda].getLayerVersionByArn(params).promise();
+      } catch (e) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] ${e.code}: ${e.message}`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] ${e.code}: ${e.message}`);
+        }
 
-    const layerSize = layer.Content.CodeSize;
-    await (0, _fsExtra.ensureDir)(layerDir);
-    (0, _serverlessLog.logLayers)(`[${layerName}] Downloading ${this._formatBytes(layerSize)}...`);
-    const res = await (0, _nodeFetch.default)(layerUrl, {
-      method: 'get'
-    });
+        return;
+      }
 
-    if (!res.ok) {
-      (0, _serverlessLog.logWarning)(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
-      return;
-    }
+      if (Object.prototype.hasOwnProperty.call(layer, 'CompatibleRuntimes') && !layer.CompatibleRuntimes.includes(_classPrivateFieldLooseBase(this, _runtime)[_runtime])) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] Layer is not compatible with ${_classPrivateFieldLooseBase(this, _runtime)[_runtime]} runtime`);
+        }
 
-    const fileStream = (0, _fs.createWriteStream)(`${layerZipFile}`);
-    await new Promise((resolve, reject) => {
-      res.body.pipe(fileStream);
-      res.body.on('error', err => {
-        reject(err);
-      });
-      fileStream.on('finish', () => {
-        resolve();
+        return;
+      }
+
+      const layerUrl = layer.Content.Location; // const layerSha = layer.Content.CodeSha256
+
+      const layerSize = layer.Content.CodeSize;
+      await (0, _fsExtra.ensureDir)(layerDir);
+
+      if (this.log) {
+        this.log.verbose(`Retrieving "${layerName}": Downloading ${this._formatBytes(layerSize)}...`);
+        layerProgress.notice(`Retrieving "${layerName}": Downloading ${this._formatBytes(layerSize)}`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Downloading ${this._formatBytes(layerSize)}...`);
+      }
+
+      const res = await (0, _nodeFetch.default)(layerUrl, {
+        method: 'get'
       });
-    });
-    (0, _serverlessLog.logLayers)(`[${layerName}] Unzipping to .layers directory`);
-    const data = await (0, _fsExtra.readFile)(`${layerZipFile}`);
-    const zip = await _jszip.default.loadAsync(data);
-    await Promise.all(keys(zip.files).map(async filename => {
-      const fileData = await zip.files[filename].async('nodebuffer');
-
-      if (filename.endsWith(_path.sep)) {
-        return Promise.resolve();
+
+      if (!res.ok) {
+        if (this.log) {
+          this.log.warning(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
+        } else {
+          (0, _serverlessLog.logWarning)(`[${layerName}] Failed to fetch from ${layerUrl} with ${res.statusText}`);
+        }
+
+        return;
       }
 
-      await (0, _fsExtra.ensureDir)((0, _path.join)(layerDir, (0, _path.dirname)(filename)));
-      return (0, _fsExtra.writeFile)((0, _path.join)(layerDir, filename), fileData, {
-        mode: zip.files[filename].unixPermissions
+      const fileStream = (0, _fs.createWriteStream)(`${layerZipFile}`);
+      await new Promise((resolve, reject) => {
+        res.body.pipe(fileStream);
+        res.body.on('error', err => {
+          reject(err);
+        });
+        fileStream.on('finish', () => {
+          resolve();
+        });
       });
-    }));
-    (0, _serverlessLog.logLayers)(`[${layerName}] Removing zip file`);
-    (0, _fs.unlinkSync)(`${layerZipFile}`);
+
+      if (this.log) {
+        this.log.verbose(`Retrieving "${layerName}": Unzipping to .layers directory`);
+        layerProgress.notice(`Retrieving "${layerName}": Unzipping to .layers directory`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Unzipping to .layers directory`);
+      }
+
+      const data = await (0, _fsExtra.readFile)(`${layerZipFile}`);
+      const zip = await _jszip.default.loadAsync(data);
+      await Promise.all(keys(zip.files).map(async filename => {
+        const fileData = await zip.files[filename].async('nodebuffer');
+
+        if (filename.endsWith(_path.sep)) {
+          return Promise.resolve();
+        }
+
+        await (0, _fsExtra.ensureDir)((0, _path.join)(layerDir, (0, _path.dirname)(filename)));
+        return (0, _fsExtra.writeFile)((0, _path.join)(layerDir, filename), fileData, {
+          mode: zip.files[filename].unixPermissions
+        });
+      }));
+
+      if (this.log) {
+        this.log.verbose(`[${layerName}] Removing zip file`);
+      } else {
+        (0, _serverlessLog.logLayers)(`[${layerName}] Removing zip file`);
+      }
+
+      (0, _fs.unlinkSync)(`${layerZipFile}`);
+    } finally {
+      if (this.log) layerProgress.remove();
+    }
   }
 
   async _getBridgeGatewayIp() {
@@ -346,7 +435,12 @@ class DockerContainer {
         stdout: gateway
       } = await (0, _execa.default)('docker', ['network', 'inspect', 'bridge', '--format', '{{(index .IPAM.Config 0).Gateway}}']));
     } catch (err) {
-      console.error(err.stderr);
+      if (this.log) {
+        this.log.error(err.stderr);
+      } else {
+        console.error(err.stderr);
+      }
+
       throw err;
     }
 
@@ -387,7 +481,12 @@ class DockerContainer {
         await (0, _execa.default)('docker', ['stop', _classPrivateFieldLooseBase(this, _containerId)[_containerId]]);
         await (0, _execa.default)('docker', ['rm', _classPrivateFieldLooseBase(this, _containerId)[_containerId]]);
       } catch (err) {
-        console.error(err.stderr);
+        if (this.log) {
+          this.log.error(err.stderr);
+        } else {
+          console.error(err.stderr);
+        }
+
         throw err;
       }
     }

package/dist/lambda/handler-runner/docker-runner/DockerImage.js

@@ -19,30 +19,46 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _imageNameTag = _classPrivateFieldLooseKey("imageNameTag");
+var _imageNameTag = /*#__PURE__*/_classPrivateFieldLooseKey("imageNameTag");
 
 class DockerImage {
-  constructor(imageNameTag) {
+  constructor(imageNameTag, v3Utils) {
     Object.defineProperty(this, _imageNameTag, {
       writable: true,
       value: null
     });
     _classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag] = imageNameTag;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   }
 
   static async _pullImage(imageNameTag) {
-    (0, _debugLog.default)(`Downloading base Docker image... (${imageNameTag})`);
+    if (this.log) {
+      this.log.debug(`Downloading base Docker image... (${imageNameTag})`);
+    } else {
+      (0, _debugLog.default)(`Downloading base Docker image... (${imageNameTag})`);
+    }
 
     try {
       await (0, _execa.default)('docker', ['pull', '--disable-content-trust=false', imageNameTag]);
     } catch (err) {
-      console.error(err.stderr);
+      if (this.log) {
+        this.log.error(err.stderr);
+      } else {
+        console.error(err.stderr);
+      }
+
       throw err;
     }
   }
 
   async pull() {
-    return DockerImage._memoizedPull(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag]);
+    return DockerImage._memoizedPull(_classPrivateFieldLooseBase(this, _imageNameTag)[_imageNameTag], this.v3Utils);
   }
 
 }

package/dist/lambda/handler-runner/docker-runner/DockerRunner.js

@@ -17,12 +17,12 @@ var id = 0;
 
 function _classPrivateFieldLooseKey(name) { return "__private_" + id++ + "_" + name; }
 
-var _codeDir = _classPrivateFieldLooseKey("codeDir");
+var _codeDir = /*#__PURE__*/_classPrivateFieldLooseKey("codeDir");
 
-var _container = _classPrivateFieldLooseKey("container");
+var _container = /*#__PURE__*/_classPrivateFieldLooseKey("container");
 
 class DockerRunner {
-  constructor(funOptions, env, dockerOptions) {
+  constructor(funOptions, env, dockerOptions, v3Utils) {
     Object.defineProperty(this, _codeDir, {
       writable: true,
       value: null
@@ -46,7 +46,7 @@ class DockerRunner {
       _classPrivateFieldLooseBase(this, _codeDir)[_codeDir] = _classPrivateFieldLooseBase(this, _codeDir)[_codeDir].replace(servicePath, dockerOptions.hostServicePath);
     }
 
-    _classPrivateFieldLooseBase(this, _container)[_container] = new _DockerContainer.default(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions);
+    _classPrivateFieldLooseBase(this, _container)[_container] = new _DockerContainer.default(env, functionKey, handler, runtime, layers, provider, servicePath, dockerOptions, v3Utils);
   }
 
   cleanup() {

package/dist/lambda/handler-runner/in-process-runner/InProcessRunner.js

@@ -11,9 +11,9 @@ var path = _interopRequireWildcard(require("path"));
 
 var fs = _interopRequireWildcard(require("fs"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; }
 
@@ -84,17 +84,17 @@ const clearModule = (fP, opts) => {
   }
 };
 
-var _env = _classPrivateFieldLooseKey("env");
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
 
-var _functionKey = _classPrivateFieldLooseKey("functionKey");
+var _functionKey = /*#__PURE__*/_classPrivateFieldLooseKey("functionKey");
 
-var _handlerName = _classPrivateFieldLooseKey("handlerName");
+var _handlerName = /*#__PURE__*/_classPrivateFieldLooseKey("handlerName");
 
-var _handlerPath = _classPrivateFieldLooseKey("handlerPath");
+var _handlerPath = /*#__PURE__*/_classPrivateFieldLooseKey("handlerPath");
 
-var _timeout = _classPrivateFieldLooseKey("timeout");
+var _timeout = /*#__PURE__*/_classPrivateFieldLooseKey("timeout");
 
-var _allowCache = _classPrivateFieldLooseKey("allowCache");
+var _allowCache = /*#__PURE__*/_classPrivateFieldLooseKey("allowCache");
 
 class InProcessRunner {
   constructor(functionKey, handlerPath, handlerName, env, timeout, allowCache) {
@@ -191,9 +191,6 @@ class InProcessRunner {
     try {
       result = handler(event, lambdaContext, callback);
     } catch (err) {
-      // this only executes when we have an exception caused by synchronous code
-      // TODO logging
-      console.log(err);
       throw new Error(`Uncaught error in '${_classPrivateFieldLooseBase(this, _functionKey)[_functionKey]}' handler.`);
     } // // not a Promise, which is not supported by aws
     // if (result == null || typeof result.then !== 'function') {
@@ -207,16 +204,7 @@ class InProcessRunner {
       callbacks.push(result);
     }
 
-    let callbackResult;
-
-    try {
-      callbackResult = await Promise.race(callbacks);
-    } catch (err) {
-      // TODO logging
-      console.log(err);
-      throw err;
-    }
-
+    const callbackResult = await Promise.race(callbacks);
     return callbackResult;
   }
 

package/dist/lambda/handler-runner/java-runner/JavaRunner.js

@@ -27,18 +27,18 @@ const {
   has
 } = Reflect;
 
-var _env = _classPrivateFieldLooseKey("env");
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
 
-var _functionName = _classPrivateFieldLooseKey("functionName");
+var _functionName = /*#__PURE__*/_classPrivateFieldLooseKey("functionName");
 
-var _handler = _classPrivateFieldLooseKey("handler");
+var _handler = /*#__PURE__*/_classPrivateFieldLooseKey("handler");
 
-var _deployPackage = _classPrivateFieldLooseKey("deployPackage");
+var _deployPackage = /*#__PURE__*/_classPrivateFieldLooseKey("deployPackage");
 
-var _allowCache = _classPrivateFieldLooseKey("allowCache");
+var _allowCache = /*#__PURE__*/_classPrivateFieldLooseKey("allowCache");
 
 class JavaRunner {
-  constructor(funOptions, env, allowCache) {
+  constructor(funOptions, env, allowCache, v3Utils) {
     Object.defineProperty(this, _env, {
       writable: true,
       value: null
@@ -70,6 +70,13 @@ class JavaRunner {
     _classPrivateFieldLooseBase(this, _handler)[_handler] = handler;
     _classPrivateFieldLooseBase(this, _deployPackage)[_deployPackage] = functionPackage || servicePackage;
     _classPrivateFieldLooseBase(this, _allowCache)[_allowCache] = allowCache;
+
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
   } // no-op
   // () => void
 
@@ -120,19 +127,24 @@ class JavaRunner {
       const response = await (0, _nodeFetch.default)(`http://localhost:${port}/invoke`, httpOptions);
       result = await response.text();
     } catch (e) {
-      console.log('Local java server not running. For faster local invocations, run "java-invoke-local --server" in your project directory'); // Fallback invocation
+      if (this.log) {
+        this.log.notice('Local java server not running. For faster local invocations, run "java-invoke-local --server" in your project directory');
+      } else {
+        console.log('Local java server not running. For faster local invocations, run "java-invoke-local --server" in your project directory');
+      } // Fallback invocation
+
 
       const args = ['-c', _classPrivateFieldLooseBase(this, _handler)[_handler], '-a', _classPrivateFieldLooseBase(this, _deployPackage)[_deployPackage], '-f', _classPrivateFieldLooseBase(this, _functionName)[_functionName], '-d', input, '--json-output', '--serverless-offline'];
       result = (0, _javaInvokeLocal.invokeJavaLocal)(args, _classPrivateFieldLooseBase(this, _env)[_env]);
-      console.log(result);
-    }
 
-    try {
-      return this._parsePayload(result);
-    } catch (err) {
-      console.log(result);
-      return err;
+      if (this.log) {
+        this.log.notice(result);
+      } else {
+        console.log(result);
+      }
     }
+
+    return this._parsePayload(result);
   }
 
 }

package/dist/lambda/handler-runner/python-runner/PythonRunner.js

@@ -34,18 +34,18 @@ const {
   has
 } = Reflect;
 
-var _env = _classPrivateFieldLooseKey("env");
+var _env = /*#__PURE__*/_classPrivateFieldLooseKey("env");
 
-var _handlerName = _classPrivateFieldLooseKey("handlerName");
+var _handlerName = /*#__PURE__*/_classPrivateFieldLooseKey("handlerName");
 
-var _handlerPath = _classPrivateFieldLooseKey("handlerPath");
+var _handlerPath = /*#__PURE__*/_classPrivateFieldLooseKey("handlerPath");
 
-var _runtime = _classPrivateFieldLooseKey("runtime");
+var _runtime = /*#__PURE__*/_classPrivateFieldLooseKey("runtime");
 
-var _allowCache = _classPrivateFieldLooseKey("allowCache");
+var _allowCache = /*#__PURE__*/_classPrivateFieldLooseKey("allowCache");
 
 class PythonRunner {
-  constructor(funOptions, env, allowCache) {
+  constructor(funOptions, env, allowCache, v3Utils) {
     Object.defineProperty(this, _env, {
       writable: true,
       value: null
@@ -77,6 +77,13 @@ class PythonRunner {
     _classPrivateFieldLooseBase(this, _runtime)[_runtime] = (0, _os.platform)() === 'win32' ? 'python.exe' : runtime;
     _classPrivateFieldLooseBase(this, _allowCache)[_allowCache] = allowCache;
 
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
+
     if (process.env.VIRTUAL_ENV) {
       const runtimeDir = (0, _os.platform)() === 'win32' ? 'Scripts' : 'bin';
       process.env.PATH = [(0, _path.join)(process.env.VIRTUAL_ENV, runtimeDir), _path.delimiter, process.env.PATH].join('');
@@ -112,6 +119,8 @@ class PythonRunner {
 
       if (json && typeof json === 'object' && has(json, '__offline_payload__')) {
         payload = json.__offline_payload__; // everything else is print(), logging, ...
+      } else if (this.log) {
+        this.log.notice(item);
       } else {
         console.log(item);
       }
@@ -134,7 +143,11 @@ class PythonRunner {
 
       const onErr = data => {
         // TODO
-        console.log(data.toString());
+        if (this.log) {
+          this.log.notice(data.toString());
+        } else {
+          console.log(data.toString());
+        }
       };
 
       const onLine = line => {