serverless-offline 8.2.0 → 8.5.0

package/dist/events/http/HttpServer.js

@@ -9,12 +9,14 @@ var _buffer = require("buffer");
 
 var _fs = require("fs");
 
-var _path = require("path");
+var pathUtils = _interopRequireWildcard(require("path"));
 
 var _h2o = _interopRequireDefault(require("@hapi/h2o2"));
 
 var _hapi = require("@hapi/hapi");
 
+var _module = require("module");
+
 var _authFunctionNameExtractor = _interopRequireDefault(require("./authFunctionNameExtractor.js"));
 
 var _authJWTSettingsExtractor = _interopRequireDefault(require("./authJWTSettingsExtractor.js"));
@@ -39,11 +41,11 @@ var _index2 = require("../../utils/index.js");
 
 var _LambdaProxyIntegrationEventV = _interopRequireDefault(require("./lambda-events/LambdaProxyIntegrationEventV2.js"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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 _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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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; }
 
@@ -56,20 +58,20 @@ const {
   stringify
 } = JSON;
 
-var _lambda = _classPrivateFieldLooseKey("lambda");
+var _lambda = /*#__PURE__*/_classPrivateFieldLooseKey("lambda");
 
-var _lastRequestOptions = _classPrivateFieldLooseKey("lastRequestOptions");
+var _lastRequestOptions = /*#__PURE__*/_classPrivateFieldLooseKey("lastRequestOptions");
 
-var _options = _classPrivateFieldLooseKey("options");
+var _options = /*#__PURE__*/_classPrivateFieldLooseKey("options");
 
-var _serverless = _classPrivateFieldLooseKey("serverless");
+var _serverless = /*#__PURE__*/_classPrivateFieldLooseKey("serverless");
 
-var _server = _classPrivateFieldLooseKey("server");
+var _server = /*#__PURE__*/_classPrivateFieldLooseKey("server");
 
-var _terminalInfo = _classPrivateFieldLooseKey("terminalInfo");
+var _terminalInfo = /*#__PURE__*/_classPrivateFieldLooseKey("terminalInfo");
 
 class HttpServer {
-  constructor(serverless, options, lambda) {
+  constructor(serverless, options, lambda, v3Utils) {
     Object.defineProperty(this, _lambda, {
       writable: true,
       value: null
@@ -98,6 +100,13 @@ class HttpServer {
     _classPrivateFieldLooseBase(this, _options)[_options] = options;
     _classPrivateFieldLooseBase(this, _serverless)[_serverless] = serverless;
 
+    if (v3Utils) {
+      this.log = v3Utils.log;
+      this.progress = v3Utils.progress;
+      this.writeText = v3Utils.writeText;
+      this.v3Utils = v3Utils;
+    }
+
     const {
       enforceSecureCookies,
       host,
@@ -127,8 +136,8 @@ class HttpServer {
 
     if (typeof httpsProtocol === 'string' && httpsProtocol.length > 0) {
       serverOptions.tls = {
-        cert: (0, _fs.readFileSync)((0, _path.resolve)(httpsProtocol, 'cert.pem'), 'ascii'),
-        key: (0, _fs.readFileSync)((0, _path.resolve)(httpsProtocol, 'key.pem'), 'ascii')
+        cert: (0, _fs.readFileSync)((0, pathUtils.resolve)(httpsProtocol, 'cert.pem'), 'ascii'),
+        key: (0, _fs.readFileSync)((0, pathUtils.resolve)(httpsProtocol, 'key.pem'), 'ascii')
       };
     } // Hapijs server creation
 
@@ -142,7 +151,7 @@ class HttpServer {
         };
 
         if (_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi && _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors) {
-          const httpApiCors = (0, _index2.getHttpApiCorsConfig)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors);
+          const httpApiCors = (0, _index2.getHttpApiCorsConfig)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors, this);
 
           if (request.method === 'options') {
             response.statusCode = 204;
@@ -223,18 +232,30 @@ class HttpServer {
     try {
       await _classPrivateFieldLooseBase(this, _server)[_server].start();
     } catch (err) {
-      console.error(`Unexpected error while starting serverless-offline server on port ${httpPort}:`, err);
+      if (this.log) {
+        this.log.error(`Unexpected error while starting serverless-offline server on port ${httpPort}:`, err);
+      } else {
+        console.error(`Unexpected error while starting serverless-offline server on port ${httpPort}:`, err);
+      }
+
       process.exit(1);
     } // TODO move the following block
 
 
     const server = `${httpsProtocol ? 'https' : 'http'}://${host}:${httpPort}`;
-    (0, _serverlessLog.default)(`[HTTP] server ready: ${server} 🚀`);
-    (0, _serverlessLog.default)(''); // serverlessLog('OpenAPI/Swagger documentation:')
-    // logRoute('GET', server, '/documentation')
-    // serverlessLog('')
 
-    (0, _serverlessLog.default)('Enter "rp" to replay the last request');
+    if (this.log) {
+      this.log.notice(`Server ready: ${server} 🚀`);
+      this.log.notice();
+      this.log.notice('Enter "rp" to replay the last request');
+    } else {
+      (0, _serverlessLog.default)(`[HTTP] server ready: ${server} 🚀`);
+      (0, _serverlessLog.default)(''); // serverlessLog('OpenAPI/Swagger documentation:')
+      // logRoute('GET', server, '/documentation')
+      // serverlessLog('')
+
+      (0, _serverlessLog.default)('Enter "rp" to replay the last request');
+    }
 
     if (process.env.NODE_ENV !== 'test') {
       process.openStdin().addListener('data', data => {
@@ -259,7 +280,11 @@ class HttpServer {
     try {
       await _classPrivateFieldLooseBase(this, _server)[_server].register([_h2o.default]);
     } catch (err) {
-      (0, _serverlessLog.default)(err);
+      if (this.log) {
+        this.log.error(err);
+      } else {
+        (0, _serverlessLog.default)(err);
+      }
     }
   } // // TODO unused:
   // get server() {
@@ -269,17 +294,26 @@ class HttpServer {
 
   _printBlankLine() {
     if (process.env.NODE_ENV !== 'test') {
-      console.log();
+      if (this.log) {
+        this.log.notice();
+      } else {
+        console.log();
+      }
     }
   }
 
   _logPluginIssue() {
-    (0, _serverlessLog.default)('If you think this is an issue with the plugin please submit it, thanks!');
-    (0, _serverlessLog.default)('https://github.com/dherault/serverless-offline/issues');
+    if (this.log) {
+      this.log.notice('If you think this is an issue with the plugin please submit it, thanks!\nhttps://github.com/dherault/serverless-offline/issues');
+      this.log.notice();
+    } else {
+      (0, _serverlessLog.default)('If you think this is an issue with the plugin please submit it, thanks!');
+      (0, _serverlessLog.default)('https://github.com/dherault/serverless-offline/issues');
+    }
   }
 
   _extractJWTAuthSettings(endpoint) {
-    const result = (0, _authJWTSettingsExtractor.default)(endpoint, _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider, _classPrivateFieldLooseBase(this, _options)[_options].ignoreJWTSignature);
+    const result = (0, _authJWTSettingsExtractor.default)(endpoint, _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider, _classPrivateFieldLooseBase(this, _options)[_options].ignoreJWTSignature, this);
     return result.unsupportedAuth ? null : result;
   }
 
@@ -300,16 +334,26 @@ class HttpServer {
       return null;
     }
 
-    (0, _serverlessLog.default)(`Configuring JWT Authorization: ${method} ${path}`); // Create a unique scheme per endpoint
+    if (this.log) {
+      this.log.notice(`Configuring JWT Authorization: ${method} ${path}`);
+    } else {
+      (0, _serverlessLog.default)(`Configuring JWT Authorization: ${method} ${path}`);
+    } // Create a unique scheme per endpoint
     // This allows the methodArn on the event property to be set appropriately
 
+
     const authKey = `${functionKey}-${jwtSettings.authorizerName}-${method}-${path}`;
     const authSchemeName = `scheme-${authKey}`;
     const authStrategyName = `strategy-${authKey}`; // set strategy name for the route config
 
-    (0, _debugLog.default)(`Creating Authorization scheme for ${authKey}`); // Create the Auth Scheme for the endpoint
+    if (this.log) {
+      this.log.debug(`Creating Authorization scheme for ${authKey}`);
+    } else {
+      (0, _debugLog.default)(`Creating Authorization scheme for ${authKey}`);
+    } // Create the Auth Scheme for the endpoint
 
-    const scheme = (0, _createJWTAuthScheme.default)(jwtSettings); // Set the auth scheme and strategy on the server
+
+    const scheme = (0, _createJWTAuthScheme.default)(jwtSettings, this); // Set the auth scheme and strategy on the server
 
     _classPrivateFieldLooseBase(this, _server)[_server].auth.scheme(authSchemeName, scheme);
 
@@ -319,7 +363,7 @@ class HttpServer {
   }
 
   _extractAuthFunctionName(endpoint) {
-    const result = (0, _authFunctionNameExtractor.default)(endpoint);
+    const result = (0, _authFunctionNameExtractor.default)(endpoint, null, this);
     return result.unsupportedAuth ? null : result.authorizerName;
   }
 
@@ -334,11 +378,24 @@ class HttpServer {
       return null;
     }
 
-    (0, _serverlessLog.default)(`Configuring Authorization: ${path} ${authFunctionName}`);
+    if (this.log) {
+      this.log.notice(`Configuring Authorization: ${path} ${authFunctionName}`);
+    } else {
+      (0, _serverlessLog.default)(`Configuring Authorization: ${path} ${authFunctionName}`);
+    }
 
     const authFunction = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.getFunction(authFunctionName);
 
-    if (!authFunction) return (0, _serverlessLog.default)(`WARNING: Authorization function ${authFunctionName} does not exist`);
+    if (!authFunction) {
+      if (this.log) {
+        this.log.error(`Authorization function ${authFunctionName} does not exist`);
+      } else {
+        (0, _serverlessLog.default)(`WARNING: Authorization function ${authFunctionName} does not exist`);
+      }
+
+      return null;
+    }
+
     const authorizerOptions = {
       identitySource: 'method.request.header.Authorization',
       identityValidationExpression: '(.*)',
@@ -357,9 +414,14 @@ class HttpServer {
     const authSchemeName = `scheme-${authKey}`;
     const authStrategyName = `strategy-${authKey}`; // set strategy name for the route config
 
-    (0, _debugLog.default)(`Creating Authorization scheme for ${authKey}`); // Create the Auth Scheme for the endpoint
+    if (this.log) {
+      this.log.debug(`Creating Authorization scheme for ${authKey}`);
+    } else {
+      (0, _debugLog.default)(`Creating Authorization scheme for ${authKey}`);
+    } // Create the Auth Scheme for the endpoint
+
 
-    const scheme = (0, _createAuthScheme.default)(authorizerOptions, _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider, _classPrivateFieldLooseBase(this, _lambda)[_lambda]); // Set the auth scheme and strategy on the server
+    const scheme = (0, _createAuthScheme.default)(authorizerOptions, _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider, _classPrivateFieldLooseBase(this, _lambda)[_lambda], this); // Set the auth scheme and strategy on the server
 
     _classPrivateFieldLooseBase(this, _server)[_server].auth.scheme(authSchemeName, scheme);
 
@@ -368,6 +430,36 @@ class HttpServer {
     return authStrategyName;
   }
 
+  _setAuthorizationStrategy(endpoint, functionKey, method, path) {
+    var _customizations$offli;
+
+    /*
+     *  The authentication strategy can be provided outside of this project
+     *  by injecting the provider through a custom variable in the serverless.yml.
+     *
+     *  see the example in the tests for more details
+     *    /tests/integration/custom-authentication
+     */
+    const customizations = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom;
+
+    if (customizations && (_customizations$offli = customizations.offline) !== null && _customizations$offli !== void 0 && _customizations$offli.customAuthenticationProvider) {
+      const root = pathUtils.resolve(_classPrivateFieldLooseBase(this, _serverless)[_serverless].serviceDir, 'require-resolver');
+      const customRequire = (0, _module.createRequire)(root);
+      const provider = customRequire(customizations.offline.customAuthenticationProvider);
+      const strategy = provider(endpoint, functionKey, method, path);
+
+      _classPrivateFieldLooseBase(this, _server)[_server].auth.scheme(strategy.scheme, strategy.getAuthenticateFunction);
+
+      _classPrivateFieldLooseBase(this, _server)[_server].auth.strategy(strategy.name, strategy.scheme);
+
+      return strategy.name;
+    } // If the endpoint has an authorization function, create an authStrategy for the route
+
+
+    const authStrategyName = _classPrivateFieldLooseBase(this, _options)[_options].noAuth ? null : this._configureJWTAuthorization(endpoint, functionKey, method, path) || this._configureAuthorization(endpoint, functionKey, method, path);
+    return authStrategyName;
+  }
+
   createRoutes(functionKey, httpEvent, handler) {
     const [handlerPath] = (0, _index2.splitHandlerPathAndName)(handler);
     let method;
@@ -395,7 +487,7 @@ class HttpServer {
       hapiPath = (0, _index2.generateHapiPath)(path, _classPrivateFieldLooseBase(this, _options)[_options], _classPrivateFieldLooseBase(this, _serverless)[_serverless]);
     }
 
-    const endpoint = new _Endpoint.default((0, _path.join)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].config.servicePath, handlerPath), httpEvent);
+    const endpoint = new _Endpoint.default((0, pathUtils.join)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].config.servicePath, handlerPath), httpEvent, this.v3Utils);
     const stage = endpoint.isHttpApi ? '$default' : _classPrivateFieldLooseBase(this, _options)[_options].stage || _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.stage;
     const protectedRoutes = [];
 
@@ -417,10 +509,10 @@ class HttpServer {
       server,
       stage: endpoint.isHttpApi || _classPrivateFieldLooseBase(this, _options)[_options].noPrependStageInUrl ? null : stage,
       invokePath: `/2015-03-31/functions/${functionKey}/invocations`
-    }); // If the endpoint has an authorization function, create an authStrategy for the route
+    });
 
+    const authStrategyName = this._setAuthorizationStrategy(endpoint, functionKey, method, path);
 
-    const authStrategyName = _classPrivateFieldLooseBase(this, _options)[_options].noAuth ? null : this._configureJWTAuthorization(endpoint, functionKey, method, path) || this._configureAuthorization(endpoint, functionKey, method, path);
     let cors = null;
 
     if (endpoint.cors) {
@@ -431,7 +523,7 @@ class HttpServer {
         origin: endpoint.cors.origins || _classPrivateFieldLooseBase(this, _options)[_options].corsConfig.origin
       };
     } else if (_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi && _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors) {
-      const httpApiCors = (0, _index2.getHttpApiCorsConfig)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors);
+      const httpApiCors = (0, _index2.getHttpApiCorsConfig)(_classPrivateFieldLooseBase(this, _serverless)[_serverless].service.provider.httpApi.cors, this);
       cors = {
         origin: httpApiCors.allowedOrigins || [],
         credentials: httpApiCors.allowCredentials,
@@ -460,7 +552,12 @@ class HttpServer {
     // for more details, check https://github.com/dherault/serverless-offline/issues/204
 
     if (hapiMethod === 'HEAD') {
-      (0, _serverlessLog.default)('HEAD method event detected. Skipping HAPI server route mapping ...');
+      if (this.log) {
+        this.log.notice('HEAD method event detected. Skipping HAPI server route mapping');
+      } else {
+        (0, _serverlessLog.default)('HEAD method event detected. Skipping HAPI server route mapping ...');
+      }
+
       return;
     }
 
@@ -473,6 +570,12 @@ class HttpServer {
       };
     }
 
+    const additionalRequestContext = {};
+
+    if (httpEvent.operationId) {
+      additionalRequestContext.operationName = httpEvent.operationId;
+    }
+
     hapiOptions.tags = ['api'];
 
     const hapiHandler = async (request, h) => {
@@ -499,7 +602,13 @@ class HttpServer {
 
       this._printBlankLine();
 
-      (0, _serverlessLog.default)(`${method} ${request.path} (λ: ${functionKey})`); // Check for APIKey
+      if (this.log) {
+        this.log.notice();
+        this.log.notice(`${method} ${request.path} (λ: ${functionKey})`);
+      } else {
+        (0, _serverlessLog.default)(`${method} ${request.path} (λ: ${functionKey})`);
+      } // Check for APIKey
+
 
       if ((protectedRoutes.includes(`${hapiMethod}#${hapiPath}`) || protectedRoutes.includes(`ANY#${hapiPath}`)) && !_classPrivateFieldLooseBase(this, _options)[_options].noAuth) {
         const errorResponse = () => h.response({
@@ -523,7 +632,12 @@ class HttpServer {
             return errorResponse();
           }
         } else {
-          (0, _debugLog.default)(`Missing x-api-key on private function ${functionKey}`);
+          if (this.log) {
+            this.log.debug(`Missing x-api-key on private function ${functionKey}`);
+          } else {
+            (0, _debugLog.default)(`Missing x-api-key on private function ${functionKey}`);
+          }
+
           return errorResponse();
         }
       }
@@ -550,17 +664,32 @@ class HttpServer {
 
           request.payload = parse(request.payload);
         } catch (err) {
-          (0, _debugLog.default)('error in converting request.payload to JSON:', err);
+          if (this.log) {
+            this.log.debug('error in converting request.payload to JSON:', err);
+          } else {
+            (0, _debugLog.default)('error in converting request.payload to JSON:', err);
+          }
         }
       }
 
-      (0, _debugLog.default)('contentType:', contentType);
-      (0, _debugLog.default)('requestTemplate:', requestTemplate);
-      (0, _debugLog.default)('payload:', request.payload);
+      if (this.log) {
+        this.log.debug('contentType:', contentType);
+        this.log.debug('requestTemplate:', requestTemplate);
+        this.log.debug('payload:', request.payload);
+      } else {
+        (0, _debugLog.default)('contentType:', contentType);
+        (0, _debugLog.default)('requestTemplate:', requestTemplate);
+        (0, _debugLog.default)('payload:', request.payload);
+      }
       /* REQUEST PAYLOAD SCHEMA VALIDATION */
 
+
       if (schema) {
-        (0, _debugLog.default)('schema:', schema);
+        if (this.log) {
+          this.log.debug('schema:', schema);
+        } else {
+          (0, _debugLog.default)('schema:', schema);
+        }
 
         try {
           _payloadSchemaValidator.default.validate(schema, request.payload);
@@ -576,8 +705,13 @@ class HttpServer {
       if (integration === 'AWS') {
         if (requestTemplate) {
           try {
-            (0, _debugLog.default)('_____ REQUEST TEMPLATE PROCESSING _____');
-            event = new _index.LambdaIntegrationEvent(request, stage, requestTemplate, requestPath).create();
+            if (this.log) {
+              this.log.debug('_____ REQUEST TEMPLATE PROCESSING _____');
+            } else {
+              (0, _debugLog.default)('_____ REQUEST TEMPLATE PROCESSING _____');
+            }
+
+            event = new _index.LambdaIntegrationEvent(request, stage, requestTemplate, requestPath, this.v3Utils).create();
           } catch (err) {
             return this._reply502(response, `Error while parsing template "${contentType}" for ${functionKey}`, err);
           }
@@ -586,11 +720,15 @@ class HttpServer {
         }
       } else if (integration === 'AWS_PROXY') {
         const stageVariables = _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom ? _classPrivateFieldLooseBase(this, _serverless)[_serverless].service.custom.stageVariables : null;
-        const lambdaProxyIntegrationEvent = endpoint.isHttpApi && endpoint.payload === '2.0' ? new _LambdaProxyIntegrationEventV.default(request, stage, endpoint.routeKey, stageVariables) : new _index.LambdaProxyIntegrationEvent(request, stage, requestPath, stageVariables, endpoint.isHttpApi ? endpoint.routeKey : null);
+        const lambdaProxyIntegrationEvent = endpoint.isHttpApi && endpoint.payload === '2.0' ? new _LambdaProxyIntegrationEventV.default(request, stage, endpoint.routeKey, stageVariables, additionalRequestContext, this.v3Utils) : new _index.LambdaProxyIntegrationEvent(request, stage, requestPath, stageVariables, endpoint.isHttpApi ? endpoint.routeKey : null, additionalRequestContext, this.v3Utils);
         event = lambdaProxyIntegrationEvent.create();
       }
 
-      (0, _debugLog.default)('event:', event);
+      if (this.log) {
+        this.log.debug('event:', event);
+      } else {
+        (0, _debugLog.default)('event:', event);
+      }
 
       const lambdaFunction = _classPrivateFieldLooseBase(this, _lambda)[_lambda].get(functionKey);
 
@@ -606,7 +744,12 @@ class HttpServer {
       // Everything in this block happens once the lambda function has resolved
 
 
-      (0, _debugLog.default)('_____ HANDLER RESOLVED _____');
+      if (this.log) {
+        this.log.debug('_____ HANDLER RESOLVED _____');
+      } else {
+        (0, _debugLog.default)('_____ HANDLER RESOLVED _____');
+      }
+
       let responseName = 'default';
       const {
         contentHandling,
@@ -645,10 +788,19 @@ class HttpServer {
           errorType: err.constructor.name,
           stackTrace: this._getArrayStackTrace(err.stack)
         };
-        (0, _serverlessLog.default)(`Failure: ${errorMessage}`);
+
+        if (this.log) {
+          this.log.error(errorMessage);
+        } else {
+          (0, _serverlessLog.default)(`Failure: ${errorMessage}`);
+        }
 
         if (!_classPrivateFieldLooseBase(this, _options)[_options].hideStackTraces) {
-          console.error(err.stack);
+          if (this.log) {
+            this.log.error(err.stack);
+          } else {
+            console.error(err.stack);
+          }
         }
 
         for (const [key, value] of Object.entries(endpoint.responses)) {
@@ -659,7 +811,12 @@ class HttpServer {
         }
       }
 
-      (0, _debugLog.default)(`Using response '${responseName}'`);
+      if (this.log) {
+        this.log.debug(`Using response '${responseName}'`);
+      } else {
+        (0, _debugLog.default)(`Using response '${responseName}'`);
+      }
+
       const chosenResponse = endpoint.responses[responseName];
       /* RESPONSE PARAMETERS PROCCESSING */
 
@@ -669,24 +826,46 @@ class HttpServer {
 
       if (responseParameters) {
         const responseParametersKeys = Object.keys(responseParameters);
-        (0, _debugLog.default)('_____ RESPONSE PARAMETERS PROCCESSING _____');
-        (0, _debugLog.default)(`Found ${responseParametersKeys.length} responseParameters for '${responseName}' response`); // responseParameters use the following shape: "key": "value"
+
+        if (this.log) {
+          this.log.debug('_____ RESPONSE PARAMETERS PROCCESSING _____');
+          this.log.debug(`Found ${responseParametersKeys.length} responseParameters for '${responseName}' response`);
+        } else {
+          (0, _debugLog.default)('_____ RESPONSE PARAMETERS PROCCESSING _____');
+          (0, _debugLog.default)();
+        } // responseParameters use the following shape: "key": "value"
+
 
         Object.entries(responseParameters).forEach(([key, value]) => {
           const keyArray = key.split('.'); // eg: "method.response.header.location"
 
           const valueArray = value.split('.'); // eg: "integration.response.body.redirect.url"
 
-          (0, _debugLog.default)(`Processing responseParameter "${key}": "${value}"`); // For now the plugin only supports modifying headers
+          if (this.log) {
+            this.log.debug(`Processing responseParameter "${key}": "${value}"`);
+          } else {
+            (0, _debugLog.default)(`Processing responseParameter "${key}": "${value}"`);
+          } // For now the plugin only supports modifying headers
+
 
           if (key.startsWith('method.response.header') && keyArray[3]) {
             const headerName = keyArray.slice(3).join('.');
             let headerValue;
-            (0, _debugLog.default)('Found header in left-hand:', headerName);
+
+            if (this.log) {
+              this.log.debug('Found header in left-hand:', headerName);
+            } else {
+              (0, _debugLog.default)('Found header in left-hand:', headerName);
+            }
 
             if (value.startsWith('integration.response')) {
               if (valueArray[2] === 'body') {
-                (0, _debugLog.default)('Found body in right-hand');
+                if (this.log) {
+                  this.log.debug('Found body in right-hand');
+                } else {
+                  (0, _debugLog.default)('Found body in right-hand');
+                }
+
                 headerValue = valueArray[3] ? (0, _index2.jsonPath)(result, valueArray.slice(3).join('.')) : result;
 
                 if (typeof headerValue === 'undefined' || headerValue === null) {
@@ -697,8 +876,13 @@ class HttpServer {
               } else {
                 this._printBlankLine();
 
-                (0, _serverlessLog.default)(`Warning: while processing responseParameter "${key}": "${value}"`);
-                (0, _serverlessLog.default)(`Offline plugin only supports "integration.response.body[.JSON_path]" right-hand responseParameter. Found "${value}" instead. Skipping.`);
+                if (this.log) {
+                  this.log.warning();
+                  this.log.warning(`Offline plugin only supports "integration.response.body[.JSON_path]" right-hand responseParameter. Found "${value}" (for "${key}"") instead. Skipping.`);
+                } else {
+                  (0, _serverlessLog.default)(`Warning: while processing responseParameter "${key}": "${value}"`);
+                  (0, _serverlessLog.default)(`Offline plugin only supports "integration.response.body[.JSON_path]" right-hand responseParameter. Found "${value}" instead. Skipping.`);
+                }
 
                 this._logPluginIssue();
 
@@ -710,16 +894,30 @@ class HttpServer {
 
 
             if (headerValue === '') {
-              (0, _serverlessLog.default)(`Warning: empty value for responseParameter "${key}": "${value}", it won't be set`);
+              if (this.log) {
+                this.log.warning(`Empty value for responseParameter "${key}": "${value}", it won't be set`);
+              } else {
+                (0, _serverlessLog.default)(`Warning: empty value for responseParameter "${key}": "${value}", it won't be set`);
+              }
             } else {
-              (0, _debugLog.default)(`Will assign "${headerValue}" to header "${headerName}"`);
+              if (this.log) {
+                this.log.debug(`Will assign "${headerValue}" to header "${headerName}"`);
+              } else {
+                (0, _debugLog.default)(`Will assign "${headerValue}" to header "${headerName}"`);
+              }
+
               response.header(headerName, headerValue);
             }
           } else {
             this._printBlankLine();
 
-            (0, _serverlessLog.default)(`Warning: while processing responseParameter "${key}": "${value}"`);
-            (0, _serverlessLog.default)(`Offline plugin only supports "method.response.header.PARAM_NAME" left-hand responseParameter. Found "${key}" instead. Skipping.`);
+            if (this.log) {
+              this.log.warning();
+              this.log.warning(`Offline plugin only supports "method.response.header.PARAM_NAME" left-hand responseParameter. Found "${key}" instead. Skipping.`);
+            } else {
+              (0, _serverlessLog.default)(`Warning: while processing responseParameter "${key}": "${value}"`);
+              (0, _serverlessLog.default)(`Offline plugin only supports "method.response.header.PARAM_NAME" left-hand responseParameter. Found "${key}" instead. Skipping.`);
+            }
 
             this._logPluginIssue();
 
@@ -748,17 +946,26 @@ class HttpServer {
             const responseTemplate = responseTemplates[responseContentType];
 
             if (responseTemplate && responseTemplate !== '\n') {
-              (0, _debugLog.default)('_____ RESPONSE TEMPLATE PROCCESSING _____');
-              (0, _debugLog.default)(`Using responseTemplate '${responseContentType}'`);
+              if (this.log) {
+                this.log.debug('_____ RESPONSE TEMPLATE PROCCESSING _____');
+                this.log.debug(`Using responseTemplate '${responseContentType}'`);
+              } else {
+                (0, _debugLog.default)('_____ RESPONSE TEMPLATE PROCCESSING _____');
+                (0, _debugLog.default)(`Using responseTemplate '${responseContentType}'`);
+              }
 
               try {
                 const reponseContext = new _index.VelocityContext(request, stage, result).getContext();
                 result = (0, _index.renderVelocityTemplateObject)({
                   root: responseTemplate
-                }, reponseContext).root;
+                }, reponseContext, this.v3Utils).root;
               } catch (error) {
-                (0, _serverlessLog.default)(`Error while parsing responseTemplate '${responseContentType}' for lambda ${functionKey}:`);
-                console.log(error.stack);
+                if (this.log) {
+                  this.log.error(`Error while parsing responseTemplate '${responseContentType}' for lambda ${functionKey}:\n${error.stack}`);
+                } else {
+                  (0, _serverlessLog.default)(`Error while parsing responseTemplate '${responseContentType}' for lambda ${functionKey}:`);
+                  console.log(error.stack);
+                }
               }
             }
           }
@@ -775,7 +982,12 @@ class HttpServer {
         if (!chosenResponse.statusCode) {
           this._printBlankLine();
 
-          (0, _serverlessLog.default)(`Warning: No statusCode found for response "${responseName}".`);
+          if (this.log) {
+            this.log.warning();
+            this.log.warning(`No statusCode found for response "${responseName}".`);
+          } else {
+            (0, _serverlessLog.default)(`Warning: No statusCode found for response "${responseName}".`);
+          }
         }
 
         response.header('Content-Type', responseContentType, {
@@ -830,7 +1042,11 @@ class HttpServer {
           });
         }
 
-        (0, _debugLog.default)('headers', headers);
+        if (this.log) {
+          this.log.debug('headers', headers);
+        } else {
+          (0, _debugLog.default)('headers', headers);
+        }
 
         const parseCookies = headerValue => {
           const cookieName = headerValue.slice(0, headerValue.indexOf('='));
@@ -888,7 +1104,13 @@ class HttpServer {
         whatToLog = stringify(result);
       } catch (error) {// nothing
       } finally {
-        if (_classPrivateFieldLooseBase(this, _options)[_options].printOutput) (0, _serverlessLog.default)(err ? `Replying ${statusCode}` : `[${statusCode}] ${whatToLog}`);
+        if (_classPrivateFieldLooseBase(this, _options)[_options].printOutput) {
+          if (this.log) {
+            this.log.notice(err ? `Replying ${statusCode}` : `[${statusCode}] ${whatToLog}`);
+          } else {
+            (0, _serverlessLog.default)(err ? `Replying ${statusCode}` : `[${statusCode}] ${whatToLog}`);
+          }
+        }
       } // Bon voyage!
 
 
@@ -905,7 +1127,13 @@ class HttpServer {
 
   _replyError(statusCode, response, message, error) {
     (0, _serverlessLog.default)(message);
-    console.error(error);
+
+    if (this.log) {
+      this.log.error(error);
+    } else {
+      console.error(error);
+    }
+
     response.header('Content-Type', 'application/json');
     response.statusCode = statusCode;
     response.source = {
@@ -942,7 +1170,13 @@ class HttpServer {
 
     this._printBlankLine();
 
-    (0, _serverlessLog.default)('Routes defined in resources:');
+    if (this.log) {
+      this.log.notice();
+      this.log.notice('Routes defined in resources:');
+    } else {
+      (0, _serverlessLog.default)('Routes defined in resources:');
+    }
+
     Object.entries(resourceRoutes).forEach(([methodId, resourceRoutesObj]) => {
       const {
         isProxy,
@@ -952,12 +1186,22 @@ class HttpServer {
       } = resourceRoutesObj;
 
       if (!isProxy) {
-        (0, _serverlessLog.default)(`WARNING: Only HTTP_PROXY is supported. Path '${pathResource}' is ignored.`);
+        if (this.log) {
+          this.log.warning(`Only HTTP_PROXY is supported. Path '${pathResource}' is ignored.`);
+        } else {
+          (0, _serverlessLog.default)(`WARNING: Only HTTP_PROXY is supported. Path '${pathResource}' is ignored.`);
+        }
+
         return;
       }
 
       if (!pathResource) {
-        (0, _serverlessLog.default)(`WARNING: Could not resolve path for '${methodId}'.`);
+        if (this.log) {
+          this.log.warning(`Could not resolve path for '${methodId}'.`);
+        } else {
+          (0, _serverlessLog.default)(`WARNING: Could not resolve path for '${methodId}'.`);
+        }
+
         return;
       }
 
@@ -966,7 +1210,12 @@ class HttpServer {
       const proxyUriInUse = proxyUriOverwrite.Uri || proxyUri;
 
       if (!proxyUriInUse) {
-        (0, _serverlessLog.default)(`WARNING: Could not load Proxy Uri for '${methodId}'`);
+        if (this.log) {
+          this.log.warning(`Could not load Proxy Uri for '${methodId}'`);
+        } else {
+          (0, _serverlessLog.default)(`WARNING: Could not load Proxy Uri for '${methodId}'`);
+        }
+
         return;
       }
 
@@ -985,7 +1234,12 @@ class HttpServer {
       // for more details, check https://github.com/dherault/serverless-offline/issues/204
 
       if (hapiMethod === 'HEAD') {
-        (0, _serverlessLog.default)('HEAD method event detected. Skipping HAPI server route mapping ...');
+        if (this.log) {
+          this.log.notice('HEAD method event detected. Skipping HAPI server route mapping');
+        } else {
+          (0, _serverlessLog.default)('HEAD method event detected. Skipping HAPI server route mapping ...');
+        }
+
         return;
       }
 
@@ -995,8 +1249,16 @@ class HttpServer {
         };
       }
 
-      (0, _serverlessLog.default)(`${method} ${hapiPath} -> ${proxyUriInUse}`); // hapiOptions.tags = ['api']
+      if (this.log) {
+        this.log.notice(`${method} ${hapiPath} -> ${proxyUriInUse}`);
+      } else {
+        (0, _serverlessLog.default)(`${method} ${hapiPath} -> ${proxyUriInUse}`);
+      } // hapiOptions.tags = ['api']
+
 
+      const {
+        log
+      } = this;
       const route = {
         handler(request, h) {
           const {
@@ -1011,7 +1273,12 @@ class HttpServer {
             resultUri += request.url.search; // search is empty string by default
           }
 
-          (0, _serverlessLog.default)(`PROXY ${request.method} ${request.url.pathname} -> ${resultUri}`);
+          if (log) {
+            log.notice(`PROXY ${request.method} ${request.url.pathname} -> ${resultUri}`);
+          } else {
+            (0, _serverlessLog.default)(`PROXY ${request.method} ${request.url.pathname} -> ${resultUri}`);
+          }
+
           return h.proxy({
             passThrough: true,
             uri: resultUri
@@ -1068,9 +1335,15 @@ class HttpServer {
 
   _injectLastRequest() {
     if (_classPrivateFieldLooseBase(this, _lastRequestOptions)[_lastRequestOptions]) {
-      (0, _serverlessLog.default)('Replaying HTTP last request');
+      if (this.log) {
+        this.log.notice('Replaying HTTP last request');
 
-      _classPrivateFieldLooseBase(this, _server)[_server].inject(_classPrivateFieldLooseBase(this, _lastRequestOptions)[_lastRequestOptions]);
+        _classPrivateFieldLooseBase(this, _server)[_server].inject(_classPrivateFieldLooseBase(this, _lastRequestOptions)[_lastRequestOptions]);
+      } else {
+        (0, _serverlessLog.default)('Replaying HTTP last request');
+      }
+    } else if (this.log) {
+      this.log.notice('No last HTTP request to replay!');
     } else {
       (0, _serverlessLog.default)('No last HTTP request to replay!');
     }