@felloh-org/lambda-wrapper 1.0.0 → 1.0.1

package/dist/wrapper/index.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleSuccess = exports.handleError = exports.default = void 0;
+
+var _epsagon = _interopRequireDefault(require("epsagon"));
+
+var _dependencies = require("../config/dependencies");
+
+var _dependencyInjection = _interopRequireDefault(require("../dependency-injection/dependency-injection"));
+
+var _response = _interopRequireDefault(require("../model/response"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable sonarjs/cognitive-complexity */
+
+/**
+ * Processes the outcome once we have one
+ *
+ * @param di
+ * @param outcome
+ */
+const handleSuccess = (di, outcome) => {
+  const logger = di.get(_dependencies.DEFINITIONS.LOGGER); // Outcome may be undefined as not all lambdas have a return value.
+
+  logger.metric('lambda.statusCode', outcome && outcome.statusCode || 200);
+  return outcome;
+};
+/**
+ * Gracefully handles an error
+ * logging in Epsagon and generating
+ * a response reflecting the `code`
+ * of the error, if defined.
+ *
+ * Note about Epsagon:
+ * Epsagon generates alerts for logs on level ERROR.
+ * This means that logger.error will produce an alert.
+ * To avoid not meaningful notifications, most likely
+ * coming from tests, we log INFO unless either:
+ *
+ * 1. `error.raiseOnEpsagon` is defined & truthy
+ * 2. `error.code` is defined and `error.code >= 500`.
+ *
+ * @param {DependencyInjection} di
+ * @param {Error} error
+ * @param {boolean} [throwError=false]
+ */
+
+
+exports.handleSuccess = handleSuccess;
+
+const handleError = (di, error, throwError = false) => {
+  const logger = di.get(_dependencies.DEFINITIONS.LOGGER);
+  logger.metric('lambda.statusCode', error.code || 500);
+
+  if (error.raiseOnEpsagon || !error.code || error.code >= 500) {
+    logger.error(error);
+  } else {
+    logger.info(error);
+  }
+
+  if (throwError) {
+    if (error instanceof Error) {
+      return error;
+    } // We want to be absolutely sure
+    // that we are returning an error
+    // as Lambda sync handlers will only fail
+    // if the object is instanceof Error
+
+
+    return new Error(error);
+  }
+
+  const responseDetails = {
+    body: error.body || {},
+    code: error.code || 500,
+    details: error.details || 'unknown error'
+  };
+  return _response.default.generate(responseDetails.body, responseDetails.code, responseDetails.details);
+};
+/**
+ * Lambda Wrapper.
+ *
+ * Wraps a lambda handler, generating a new function
+ * that has access to the dependency injection
+ * for the service and handles logging and exceptions.
+ *
+ * @param configuration
+ * @param handler
+ * @param throwError
+ */
+
+
+exports.handleError = handleError;
+
+const wrapper = (configuration, handler, throwError = false) => {
+  let instance = (event, context, callback) => {
+    const di = new _dependencyInjection.default(configuration, event, context);
+    const request = di.get(_dependencies.DEFINITIONS.REQUEST);
+    const logger = di.get(_dependencies.DEFINITIONS.LOGGER);
+    context.callbackWaitsForEmptyEventLoop = false; // If the event is to trigger a warm up, then don't bother returning the function.
+
+    if (di.getEvent().source === 'serverless-plugin-warmup') {
+      return callback(null, 'Lambda is warm!');
+    } // Log the users ip address silently for use in error tracing
+
+
+    if (request.getIp() !== null) {
+      logger.metric('ipAddress', request.getIp(), true);
+    } // Add metrics with user browser information for rapid debugging
+
+
+    const userBrowserAndDevice = request.getUserBrowserAndDevice();
+
+    if (userBrowserAndDevice !== null && typeof userBrowserAndDevice === 'object') {
+      Object.keys(userBrowserAndDevice).forEach(metricKey => {
+        logger.metric(metricKey, userBrowserAndDevice[metricKey], true);
+      });
+    }
+
+    let outcome;
+
+    try {
+      outcome = handler.call(instance, di, request, callback);
+
+      if (outcome instanceof Promise) {
+        outcome = outcome.then(value => handleSuccess(di, value)).catch(error => {
+          const handled = handleError(di, error, throwError);
+
+          if (throwError) {
+            // AWS Lambda with async handler is looking for a rejection
+            // and not an error object directly
+            // and will treat resolved errors as successful
+            // as it will cast the error to JSON, i.e. `{}`
+            return Promise.reject(handled);
+          }
+
+          return handled;
+        });
+      }
+    } catch (error) {
+      outcome = handleError(di, error, throwError);
+    }
+
+    return outcome;
+  }; // If the Epsagon token is enabled, then wrap the instance in the Epsagon wrapper
+
+
+  if (typeof process.env.EPSAGON_TOKEN === 'string' && process.env.EPSAGON_TOKEN !== 'undefined' && typeof process.env.EPSAGON_SERVICE_NAME === 'string' && process.env.EPSAGON_SERVICE_NAME !== 'undefined') {
+    _epsagon.default.init({
+      token: process.env.EPSAGON_TOKEN,
+      appName: process.env.EPSAGON_SERVICE_NAME
+    });
+
+    instance = _epsagon.default.lambdaWrapper(instance);
+  }
+
+  return instance;
+};
+
+var _default = wrapper;
+exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felloh-org/lambda-wrapper",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Lambda wrapper for all Felloh Serverless Projects",
   "main": "dist/index.js",
   "scripts": {