@beforeyoubid/logger-adapter 2.0.0 → 2.0.1

package/dist/logger/__tests__/logger.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _winston = /*#__PURE__*/ _interopRequireDefault(require("winston"));
+var _logger = require("../../../src/logger/logger");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+jest.mock("winston", function() {
+    return _objectSpreadProps(_objectSpread({}, jest.requireActual("winston")), {
+        createLogger: jest.fn()
+    });
+});
+describe("setupWinstonLogger", function() {
+    var debugMock;
+    var addMock;
+    beforeAll(function() {
+        debugMock = jest.fn();
+        addMock = jest.fn();
+        _winston.default.createLogger.mockReturnValue({
+            add: addMock,
+            debug: debugMock
+        });
+    });
+    beforeEach(function() {
+        debugMock.mockClear();
+        addMock.mockClear();
+    });
+    it("should return logger", function() {
+        var logger = (0, _logger.setupWinstonLogger)({});
+        expect(logger).toEqual({
+            add: addMock,
+            debug: debugMock
+        });
+    });
+    describe("logdna transport", function() {
+        describe("when keys provided", function() {
+            it("should add the transport", function() {
+                (0, _logger.setupWinstonLogger)({
+                    logDNAOptions: {
+                        key: Math.random().toString()
+                    },
+                    logDNAKey: Math.random().toString(),
+                    sendToRemote: true
+                });
+                expect(addMock).toHaveBeenCalled();
+            });
+        });
+        describe("when keys not provided", function() {
+            it("shouldnt add the transport", function() {
+                (0, _logger.setupWinstonLogger)({
+                    logDNAOptions: {}
+                });
+                expect(addMock).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe("debug statement", function() {
+        describe("when lambda function name in env variables", function() {
+            beforeEach(function() {
+                process.env.AWS_LAMBDA_FUNCTION_NAME = Math.random().toString();
+            });
+            it("should print disabled msg", function() {
+                (0, _logger.setupWinstonLogger)({
+                    logDNAOptions: {}
+                });
+                expect(debugMock).toHaveBeenCalledWith("LOGDNA is disabled");
+            });
+        });
+        describe("when lambda function name not in env variables", function() {
+            beforeEach(function() {
+                delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+            });
+            it("should not print disabled msg", function() {
+                (0, _logger.setupWinstonLogger)({
+                    logDNAOptions: {}
+                });
+                expect(debugMock).not.toHaveBeenCalledWith("LOGDNA is disabled");
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/__tests__/util.spec.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+var _util = require("../util");
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+jest.mock("../../util", function() {
+    return _objectSpreadProps(_objectSpread({}, jest.requireActual("../../util")), {
+        isLogDNAEnabled: function() {
+            return false;
+        }
+    });
+});
+describe("getLoggerObject", function() {
+    it("should prefix my log object", function() {
+        var spy = jest.spyOn(_index.logger, "debug");
+        var testLoggerObject = (0, _util.getLoggerObject)("[MY-PREFIX]");
+        testLoggerObject.debug("my log message");
+        expect(spy).toHaveBeenCalledWith('[MY-PREFIX]: "my log message"');
+    });
+    it("should not prefix my log object if I leave it empty", function() {
+        var spy = jest.spyOn(_index.logger, "debug");
+        var testLoggerObject = (0, _util.getLoggerObject)();
+        testLoggerObject.debug("my log message");
+        expect(spy).toHaveBeenCalledWith('"my log message"');
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "logger", {
+    enumerable: true,
+    get: function() {
+        return logger;
+    }
+});
+var _params = require("../params");
+var _logger = require("./logger");
+var logParams = (0, _params.getLogParams)();
+// Create a singleton logger object during module initialisation
+var logger = (0, _logger.setupWinstonLogger)(logParams);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dnZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi4vcGFyYW1zJztcbmltcG9ydCB7IHNldHVwV2luc3RvbkxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcblxuY29uc3QgbG9nUGFyYW1zID0gZ2V0TG9nUGFyYW1zKCk7XG5cbi8vIENyZWF0ZSBhIHNpbmdsZXRvbiBsb2dnZXIgb2JqZWN0IGR1cmluZyBtb2R1bGUgaW5pdGlhbGlzYXRpb25cbmNvbnN0IGxvZ2dlciA9IHNldHVwV2luc3RvbkxvZ2dlcihsb2dQYXJhbXMpO1xuXG5leHBvcnQgeyBsb2dnZXIgfTtcbiJdLCJuYW1lcyI6WyJsb2dnZXIiLCJsb2dQYXJhbXMiLCJnZXRMb2dQYXJhbXMiLCJzZXR1cFdpbnN0b25Mb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUVNBOzs7ZUFBQUE7OztzQkFSb0I7c0JBQ007QUFFbkMsSUFBTUMsWUFBWUMsSUFBQUEsb0JBQVk7QUFFOUIsZ0VBQWdFO0FBQ2hFLElBQU1GLFNBQVNHLElBQUFBLDBCQUFrQixFQUFDRiJ9

package/dist/logger/logdnaClient.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLogDNAClient: function() {
+        return createLogDNAClient;
+    },
+    getLogDNAClient: function() {
+        return getLogDNAClient;
+    }
+});
+var _logger = /*#__PURE__*/ _interopRequireDefault(require("@logdna/logger"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// A singleton object in this module
+var logdnaClient;
+var createLogDNAClient = function(params) {
+    if (logdnaClient) return logdnaClient;
+    var logDNAKey = params.logDNAKey, logDNAOptions = params.logDNAOptions;
+    var env = logDNAOptions.env, app = logDNAOptions.app, tags = logDNAOptions.tags, level = logDNAOptions.level;
+    var options = {
+        env: env,
+        app: app,
+        hostname: env,
+        indexMeta: true,
+        tags: tags,
+        level: level
+    };
+    // Create a new LogDNA client
+    logdnaClient = _logger.default.createLogger(logDNAKey, options);
+    return logdnaClient;
+};
+var getLogDNAClient = function() {
+    return logdnaClient;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/logger.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "setupWinstonLogger", {
+    enumerable: true,
+    get: function() {
+        return setupWinstonLogger;
+    }
+});
+var _winston = /*#__PURE__*/ _interopRequireDefault(require("winston"));
+var _logdnaClient = require("./logdnaClient");
+var _logdnaWinston = require("../transports/logdnaWinston");
+var _util = require("../util");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var format = _winston.default.format, transports = _winston.default.transports;
+var createWinstonLogger = function(logLevel) {
+    var logger = _winston.default.createLogger({
+        level: logLevel || "info",
+        format: format.combine(format.timestamp(), format.simple(), format.printf(function(info) {
+            return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
+        })),
+        transports: [
+            new transports.Console({
+                format: format.combine(format.timestamp(), format.simple(), format.printf(function(info) {
+                    return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
+                }), format.colorize({
+                    all: true
+                }))
+            })
+        ]
+    });
+    return logger;
+};
+/**
+ * Create a Winston logger object so that we can get a few benefits
+ * 1. We can use the same logger to output logs to console. If we use logger from @logdna/logger, it won't show up locally
+ * 2. We can also format the colour of the log lines so that it's easier to read in the local docker container
+ * 3. We can use the same logger object and send logs to logDNA using transports mechanism
+ *
+ * @param params
+ * @returns
+ */ var setupWinstonLogger = function(params) {
+    var AWS_LAMBDA_FUNCTION_NAME = process.env.AWS_LAMBDA_FUNCTION_NAME;
+    var logLevel = params.logLevel, logDNAOptions = params.logDNAOptions, logDNAKey = params.logDNAKey, sendToRemote = params.sendToRemote;
+    var isEnabled = (0, _util.isLogDNAEnabled)(logDNAKey, sendToRemote);
+    var logger = createWinstonLogger(logLevel);
+    if (isEnabled) {
+        var logdnaClient = (0, _logdnaClient.createLogDNAClient)(params);
+        logger.add(new _logdnaWinston.LogDNATransport(logDNAOptions, logdnaClient));
+    } else if (AWS_LAMBDA_FUNCTION_NAME !== undefined) {
+        logger.debug("LOGDNA is disabled");
+    }
+    return logger;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/util.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLoggerObject", {
+    enumerable: true,
+    get: function() {
+        return getLoggerObject;
+    }
+});
+var _index = require("./index");
+var toString = function(args) {
+    return args.map(function(arg) {
+        return JSON.stringify(arg);
+    }).join(" ");
+};
+var getPrefix = function(prefix) {
+    return prefix && "".concat(prefix, ": ") || "";
+};
+/**
+ * A utility command to return a logger with a prefix on log line.
+ * @param prefix string
+ */ var getLoggerObject = function() {
+    var prefix = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+    var debug = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _index.logger.debug("".concat(getPrefix(prefix)).concat(toString(args)));
+    };
+    var info = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _index.logger.info("".concat(getPrefix(prefix)).concat(toString(args)));
+    };
+    var warn = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _index.logger.warn("".concat(getPrefix(prefix)).concat(toString(args)));
+    };
+    var error = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _index.logger.error("".concat(getPrefix(prefix)).concat(toString(args)));
+    };
+    return {
+        debug: debug,
+        info: info,
+        warn: warn,
+        error: error
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dnZXIvdXRpbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBsb2dnZXIgfSBmcm9tICcuL2luZGV4JztcblxuY29uc3QgdG9TdHJpbmcgPSAoYXJnczogdW5rbm93bltdKSA9PiB7XG4gIHJldHVybiBhcmdzLm1hcChhcmcgPT4gSlNPTi5zdHJpbmdpZnkoYXJnKSkuam9pbignICcpO1xufTtcblxuY29uc3QgZ2V0UHJlZml4ID0gKHByZWZpeDogc3RyaW5nKSA9PiAocHJlZml4ICYmIGAke3ByZWZpeH06IGApIHx8ICcnO1xuXG4vKipcbiAqIEEgdXRpbGl0eSBjb21tYW5kIHRvIHJldHVybiBhIGxvZ2dlciB3aXRoIGEgcHJlZml4IG9uIGxvZyBsaW5lLlxuICogQHBhcmFtIHByZWZpeCBzdHJpbmdcbiAqL1xuY29uc3QgZ2V0TG9nZ2VyT2JqZWN0ID0gKHByZWZpeCA9ICcnKSA9PiB7XG4gIGNvbnN0IGRlYnVnID0gKC4uLmFyZ3M6IHVua25vd25bXSkgPT4gbG9nZ2VyLmRlYnVnKGAke2dldFByZWZpeChwcmVmaXgpfSR7dG9TdHJpbmcoYXJncyl9YCk7XG4gIGNvbnN0IGluZm8gPSAoLi4uYXJnczogdW5rbm93bltdKSA9PiBsb2dnZXIuaW5mbyhgJHtnZXRQcmVmaXgocHJlZml4KX0ke3RvU3RyaW5nKGFyZ3MpfWApO1xuICBjb25zdCB3YXJuID0gKC4uLmFyZ3M6IHVua25vd25bXSkgPT4gbG9nZ2VyLndhcm4oYCR7Z2V0UHJlZml4KHByZWZpeCl9JHt0b1N0cmluZyhhcmdzKX1gKTtcbiAgY29uc3QgZXJyb3IgPSAoLi4uYXJnczogdW5rbm93bltdKSA9PiBsb2dnZXIuZXJyb3IoYCR7Z2V0UHJlZml4KHByZWZpeCl9JHt0b1N0cmluZyhhcmdzKX1gKTtcbiAgcmV0dXJuIHsgZGVidWcsIGluZm8sIHdhcm4sIGVycm9yIH07XG59O1xuXG5leHBvcnQgeyBnZXRMb2dnZXJPYmplY3QgfTtcbiJdLCJuYW1lcyI6WyJnZXRMb2dnZXJPYmplY3QiLCJ0b1N0cmluZyIsImFyZ3MiLCJtYXAiLCJhcmciLCJKU09OIiwic3RyaW5naWZ5Iiwiam9pbiIsImdldFByZWZpeCIsInByZWZpeCIsImRlYnVnIiwibG9nZ2VyIiwiaW5mbyIsIndhcm4iLCJlcnJvciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFvQlNBOzs7ZUFBQUE7OztxQkFwQmM7QUFFdkIsSUFBTUMsV0FBVyxTQUFDQyxNQUFvQjtJQUNwQyxPQUFPQSxLQUFLQyxHQUFHLENBQUNDLFNBQUFBO2VBQU9DLEtBQUtDLFNBQVMsQ0FBQ0Y7T0FBTUcsSUFBSSxDQUFDO0FBQ25EO0FBRUEsSUFBTUMsWUFBWSxTQUFDQztXQUFtQixBQUFDQSxVQUFVLEFBQUMsR0FBUyxPQUFQQSxRQUFPLFNBQVE7O0FBRW5FOzs7Q0FHQyxHQUNELElBQU1ULGtCQUFrQixXQUFpQjtRQUFoQlMsMEVBQVM7SUFDaEMsSUFBTUMsUUFBUTt5Q0FBSVI7WUFBQUE7O2VBQW9CUyxhQUFNLENBQUNELEtBQUssQ0FBQyxBQUFDLEdBQXNCVCxPQUFwQk8sVUFBVUMsU0FBeUIsT0FBZlIsU0FBU0M7O0lBQ25GLElBQU1VLE9BQU87eUNBQUlWO1lBQUFBOztlQUFvQlMsYUFBTSxDQUFDQyxJQUFJLENBQUMsQUFBQyxHQUFzQlgsT0FBcEJPLFVBQVVDLFNBQXlCLE9BQWZSLFNBQVNDOztJQUNqRixJQUFNVyxPQUFPO3lDQUFJWDtZQUFBQTs7ZUFBb0JTLGFBQU0sQ0FBQ0UsSUFBSSxDQUFDLEFBQUMsR0FBc0JaLE9BQXBCTyxVQUFVQyxTQUF5QixPQUFmUixTQUFTQzs7SUFDakYsSUFBTVksUUFBUTt5Q0FBSVo7WUFBQUE7O2VBQW9CUyxhQUFNLENBQUNHLEtBQUssQ0FBQyxBQUFDLEdBQXNCYixPQUFwQk8sVUFBVUMsU0FBeUIsT0FBZlIsU0FBU0M7O0lBQ25GLE9BQU87UUFBRVEsT0FBQUE7UUFBT0UsTUFBQUE7UUFBTUMsTUFBQUE7UUFBTUMsT0FBQUE7SUFBTTtBQUNwQyJ9

package/dist/params.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getLogParams: function() {
+        return getLogParams;
+    },
+    sendToRemote: function() {
+        return sendToRemote;
+    }
+});
+var getEnvs = function() {
+    var env = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : (process === null || process === void 0 ? void 0 : process.env) || {};
+    var _env_LOG_LEVEL = env.LOG_LEVEL, LOG_LEVEL = _env_LOG_LEVEL === void 0 ? "info" : _env_LOG_LEVEL, _env_LOGDNA_KEY = env.LOGDNA_KEY, LOGDNA_KEY = _env_LOGDNA_KEY === void 0 ? "" : _env_LOGDNA_KEY, _env_STAGE = env.STAGE, STAGE = _env_STAGE === void 0 ? "n/a" : _env_STAGE, _env_AWS_LAMBDA_FUNCTION_NAME = env.AWS_LAMBDA_FUNCTION_NAME, AWS_LAMBDA_FUNCTION_NAME = _env_AWS_LAMBDA_FUNCTION_NAME === void 0 ? "n/a" : _env_AWS_LAMBDA_FUNCTION_NAME, _env_LOGDNA_ENABLED = env.LOGDNA_ENABLED, LOGDNA_ENABLED = _env_LOGDNA_ENABLED === void 0 ? "true" : _env_LOGDNA_ENABLED, _env_LOGDNA_SUPPRESS_FLUSH_ALL = env.LOGDNA_SUPPRESS_FLUSH_ALL, LOGDNA_SUPPRESS_FLUSH_ALL = _env_LOGDNA_SUPPRESS_FLUSH_ALL === void 0 ? "false" : _env_LOGDNA_SUPPRESS_FLUSH_ALL;
+    return {
+        LOG_LEVEL: LOG_LEVEL,
+        LOGDNA_KEY: LOGDNA_KEY,
+        STAGE: STAGE,
+        AWS_LAMBDA_FUNCTION_NAME: AWS_LAMBDA_FUNCTION_NAME,
+        LOGDNA_ENABLED: LOGDNA_ENABLED,
+        LOGDNA_SUPPRESS_FLUSH_ALL: LOGDNA_SUPPRESS_FLUSH_ALL
+    };
+};
+var sendToRemote = function(logDNAKey, logDNAEnabled) {
+    return !!logDNAKey && logDNAEnabled === "true";
+};
+var getLogParams = function() {
+    var env = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : (process === null || process === void 0 ? void 0 : process.env) || {};
+    var _getEnvs = getEnvs(env), LOG_LEVEL = _getEnvs.LOG_LEVEL, LOGDNA_KEY = _getEnvs.LOGDNA_KEY, STAGE = _getEnvs.STAGE, AWS_LAMBDA_FUNCTION_NAME = _getEnvs.AWS_LAMBDA_FUNCTION_NAME, LOGDNA_ENABLED = _getEnvs.LOGDNA_ENABLED, LOGDNA_SUPPRESS_FLUSH_ALL = _getEnvs.LOGDNA_SUPPRESS_FLUSH_ALL;
+    var logDNAOptions = {
+        key: LOGDNA_KEY,
+        env: STAGE,
+        app: AWS_LAMBDA_FUNCTION_NAME,
+        hostname: STAGE,
+        indexMeta: true,
+        tags: [
+            AWS_LAMBDA_FUNCTION_NAME,
+            STAGE
+        ],
+        level: LOG_LEVEL,
+        handleExceptions: true
+    };
+    return {
+        logLevel: LOG_LEVEL,
+        logDNAKey: LOGDNA_KEY,
+        sendToRemote: sendToRemote(LOGDNA_KEY, LOGDNA_ENABLED),
+        logDNASuppressFlushAll: LOGDNA_SUPPRESS_FLUSH_ALL === "true",
+        functionName: AWS_LAMBDA_FUNCTION_NAME,
+        logDNAOptions: logDNAOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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