@beforeyoubid/logger-adapter 2.0.0 → 2.0.1

package/dist/__tests__/params.spec.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _params = require("../params");
+describe("Log Params", function() {
+    it("return correct sendToRemote status", function() {
+        var status;
+        // LOGDNA_ENABLED is from env which is string
+        status = (0, _params.sendToRemote)("", "true");
+        expect(status).toEqual(false);
+        status = (0, _params.sendToRemote)("something", "true");
+        expect(status).toEqual(true);
+        status = (0, _params.sendToRemote)("something", "false");
+        expect(status).toEqual(false);
+    });
+    it("is able to set default logdna setting", function() {
+        var simulatedEnv = {
+            STAGE: "sample",
+            LOGDNA_KEY: "",
+            LOGDNA_SUPPRESS_FLUSH_ALL: "true"
+        };
+        var params = (0, _params.getLogParams)(simulatedEnv);
+        expect(params.logLevel).toEqual("info");
+        expect(params.logDNASuppressFlushAll).toEqual(true);
+        expect(params.functionName).toEqual("n/a");
+        expect(params.logDNAOptions.env).toEqual("sample");
+    });
+    describe("sendToRemote", function() {
+        it("should set sendToRemote to false when logdna_key is empty", function() {
+            var simulatedEnv = {
+                LOGDNA_KEY: ""
+            };
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.sendToRemote).toEqual(false);
+        });
+        it("should set sendToRemote to true when logdna_key presents & logdna is enabled", function() {
+            var simulatedEnv = {
+                LOGDNA_KEY: "some-random-key",
+                LOGDNA_ENABLED: "true"
+            };
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.sendToRemote).toEqual(true);
+        });
+    });
+    describe("sendToRemote", function() {
+        it("should set sendToRemote to false when logdna_key is not set", function() {
+            var simulatedEnv = {};
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.sendToRemote).toEqual(false);
+        });
+        it("should set sendToRemote to false when logdna_key is empty", function() {
+            var simulatedEnv = {
+                LOGDNA_KEY: ""
+            };
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.sendToRemote).toEqual(false);
+        });
+        it("should set sendToRemote to true when logdna_key presents & logdna is enabled", function() {
+            var simulatedEnv = {
+                LOGDNA_KEY: "some-random-key",
+                LOGDNA_ENABLED: "true"
+            };
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.sendToRemote).toEqual(true);
+        });
+    });
+    describe("Validate logDNASuppressFlushAll", function() {
+        it("should set logDNASuppressFlushAll to false by default", function() {
+            var simulatedEnv = {};
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.logDNASuppressFlushAll).toEqual(false);
+        });
+        it("should set logDNASuppressFlushAll to true when we supply env variable", function() {
+            var simulatedEnv = {
+                LOGDNA_SUPPRESS_FLUSH_ALL: "true"
+            };
+            var params = (0, _params.getLogParams)(simulatedEnv);
+            expect(params.logDNASuppressFlushAll).toEqual(true);
+        });
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/console/__tests__/consoleLogger.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+describe("Console Logger", function() {
+    it("should be able to load module", function() {
+        var objType = typeof _index.consoleLogger === "undefined" ? "undefined" : _typeof(_index.consoleLogger);
+        expect(objType).toEqual("object");
+        expect(_typeof(_index.consoleLogger.init)).toEqual("function");
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25zb2xlL19fdGVzdHNfXy9jb25zb2xlTG9nZ2VyLnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29uc29sZUxvZ2dlciB9IGZyb20gJy4uL2luZGV4JztcblxuZGVzY3JpYmUoJ0NvbnNvbGUgTG9nZ2VyJywgKCkgPT4ge1xuICBpdCgnc2hvdWxkIGJlIGFibGUgdG8gbG9hZCBtb2R1bGUnLCAoKSA9PiB7XG4gICAgY29uc3Qgb2JqVHlwZSA9IHR5cGVvZiBjb25zb2xlTG9nZ2VyO1xuICAgIGV4cGVjdChvYmpUeXBlKS50b0VxdWFsKCdvYmplY3QnKTtcbiAgICBleHBlY3QodHlwZW9mIGNvbnNvbGVMb2dnZXIuaW5pdCkudG9FcXVhbCgnZnVuY3Rpb24nKTtcbiAgfSk7XG59KTtcbiJdLCJuYW1lcyI6WyJkZXNjcmliZSIsIml0Iiwib2JqVHlwZSIsImNvbnNvbGVMb2dnZXIiLCJleHBlY3QiLCJ0b0VxdWFsIiwiaW5pdCJdLCJtYXBwaW5ncyI6Ijs7OztxQkFBOEI7Ozs7O0FBRTlCQSxTQUFTLGtCQUFrQixXQUFNO0lBQy9CQyxHQUFHLGlDQUFpQyxXQUFNO1FBQ3hDLElBQU1DLFVBQVUsT0FBT0Msb0JBQWEsaUNBQXBCLFFBQU9BLG9CQUFhLENBQUE7UUFDcENDLE9BQU9GLFNBQVNHLE9BQU8sQ0FBQztRQUN4QkQsT0FBTyxRQUFPRCxvQkFBYSxDQUFDRyxJQUFJLEdBQUVELE9BQU8sQ0FBQztJQUM1QztBQUNGIn0=

package/dist/console/__tests__/index.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+var _logWrapper = /*#__PURE__*/ _interopRequireWildcard(require("../logWrapper"));
+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, 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;
+}
+jest.mock("../logWrapper.ts");
+jest.mock("../../logger/logdnaClient.ts");
+jest.mock("../../util", function() {
+    return {
+        isLogDNAEnabled: function() {
+            return true;
+        }
+    };
+});
+describe("consoleLogger.init()", function() {
+    beforeEach(function() {
+        jest.resetAllMocks();
+    });
+    it("should not wrap the console logger if we do not call init", function() {
+        var spy = jest.spyOn(_logWrapper, "wrapAndSendToLogDNA");
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it("should wrap console log if we enable it", function() {
+        var spy = jest.spyOn(_logWrapper, "wrapAndSendToLogDNA");
+        _index.consoleLogger.init();
+        expect(spy).toHaveBeenCalled();
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25zb2xlL19fdGVzdHNfXy9pbmRleC5zcGVjLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImplc3QubW9jaygnLi4vbG9nV3JhcHBlci50cycpO1xuamVzdC5tb2NrKCcuLi8uLi9sb2dnZXIvbG9nZG5hQ2xpZW50LnRzJyk7XG5pbXBvcnQgeyBjb25zb2xlTG9nZ2VyIH0gZnJvbSAnLi4vaW5kZXgnO1xuaW1wb3J0ICogYXMgbG9nV3JhcHBlciBmcm9tICcuLi9sb2dXcmFwcGVyJztcbmplc3QubW9jaygnLi4vLi4vdXRpbCcsICgpID0+ICh7XG4gIGlzTG9nRE5BRW5hYmxlZDogKCkgPT4gdHJ1ZSxcbn0pKTtcblxuZGVzY3JpYmUoJ2NvbnNvbGVMb2dnZXIuaW5pdCgpJywgKCkgPT4ge1xuICBiZWZvcmVFYWNoKCgpID0+IHtcbiAgICBqZXN0LnJlc2V0QWxsTW9ja3MoKTtcbiAgfSk7XG5cbiAgaXQoJ3Nob3VsZCBub3Qgd3JhcCB0aGUgY29uc29sZSBsb2dnZXIgaWYgd2UgZG8gbm90IGNhbGwgaW5pdCcsICgpID0+IHtcbiAgICBjb25zdCBzcHkgPSBqZXN0LnNweU9uKGxvZ1dyYXBwZXIsICd3cmFwQW5kU2VuZFRvTG9nRE5BJyk7XG4gICAgZXhwZWN0KHNweSkubm90LnRvSGF2ZUJlZW5DYWxsZWQoKTtcbiAgfSk7XG5cbiAgaXQoJ3Nob3VsZCB3cmFwIGNvbnNvbGUgbG9nIGlmIHdlIGVuYWJsZSBpdCcsICgpID0+IHtcbiAgICBjb25zdCBzcHkgPSBqZXN0LnNweU9uKGxvZ1dyYXBwZXIsICd3cmFwQW5kU2VuZFRvTG9nRE5BJyk7XG4gICAgY29uc29sZUxvZ2dlci5pbml0KCk7XG4gICAgZXhwZWN0KHNweSkudG9IYXZlQmVlbkNhbGxlZCgpO1xuICB9KTtcbn0pO1xuIl0sIm5hbWVzIjpbImplc3QiLCJtb2NrIiwiaXNMb2dETkFFbmFibGVkIiwiZGVzY3JpYmUiLCJiZWZvcmVFYWNoIiwicmVzZXRBbGxNb2NrcyIsIml0Iiwic3B5Iiwic3B5T24iLCJsb2dXcmFwcGVyIiwiZXhwZWN0Iiwibm90IiwidG9IYXZlQmVlbkNhbGxlZCIsImNvbnNvbGVMb2dnZXIiLCJpbml0Il0sIm1hcHBpbmdzIjoiOzs7O3FCQUU4QjtnRUFDRjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUg1QkEsS0FBS0MsSUFBSSxDQUFDO0FBQ1ZELEtBQUtDLElBQUksQ0FBQztBQUdWRCxLQUFLQyxJQUFJLENBQUMsY0FBYztXQUFPO1FBQzdCQyxpQkFBaUI7bUJBQU0sSUFBSTs7SUFDN0I7O0FBRUFDLFNBQVMsd0JBQXdCLFdBQU07SUFDckNDLFdBQVcsV0FBTTtRQUNmSixLQUFLSyxhQUFhO0lBQ3BCO0lBRUFDLEdBQUcsNkRBQTZELFdBQU07UUFDcEUsSUFBTUMsTUFBTVAsS0FBS1EsS0FBSyxDQUFDQyxhQUFZO1FBQ25DQyxPQUFPSCxLQUFLSSxHQUFHLENBQUNDLGdCQUFnQjtJQUNsQztJQUVBTixHQUFHLDJDQUEyQyxXQUFNO1FBQ2xELElBQU1DLE1BQU1QLEtBQUtRLEtBQUssQ0FBQ0MsYUFBWTtRQUNuQ0ksb0JBQWEsQ0FBQ0MsSUFBSTtRQUNsQkosT0FBT0gsS0FBS0ssZ0JBQWdCO0lBQzlCO0FBQ0YifQ==

package/dist/console/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "consoleLogger", {
+    enumerable: true,
+    get: function() {
+        return consoleLogger;
+    }
+});
+var _params = require("../params");
+var _logWrapper = require("./logWrapper");
+var _util = require("../util");
+var _logdnaClient = require("../logger/logdnaClient");
+var hasWrapped = false;
+var logParams = (0, _params.getLogParams)();
+/**
+ * Initialise and wrap the native console log object
+ * @param params
+ */ var init = function() {
+    var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : logParams;
+    if (hasWrapped) return;
+    var AWS_LAMBDA_FUNCTION_NAME = process.env.AWS_LAMBDA_FUNCTION_NAME;
+    var logDNAKey = params.logDNAKey, sendToRemote = params.sendToRemote, logLevel = params.logLevel;
+    var isEnabled = (0, _util.isLogDNAEnabled)(logDNAKey, sendToRemote);
+    if (isEnabled) {
+        // Create/reuse this logdna client instance so that we can use it in the console wrapper
+        var logDNAClient = (0, _logdnaClient.createLogDNAClient)(params);
+        // Wrap console object and keep the status
+        (0, _logWrapper.wrapAndSendToLogDNA)(logDNAClient, logLevel);
+        hasWrapped = true;
+    }
+    // What case is this?
+    var isFunctionNameAvailable = AWS_LAMBDA_FUNCTION_NAME !== undefined;
+    if (!isEnabled && isFunctionNameAvailable) {
+        console.info("LOGDNA is disabled");
+    }
+};
+var consoleLogger = {
+    init: init,
+    flushAll: _util.flushAll
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/console/logWrapper.js

@@ -0,0 +1,99 @@
+"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, {
+    wrapAndSendToLogDNA: function() {
+        return wrapAndSendToLogDNA;
+    },
+    getDefaultConsoleLog: function() {
+        return getDefaultConsoleLog;
+    }
+});
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+// Original console functions
+var _log = console.log;
+var _info = console.info;
+var _warn = console.warn;
+var _error = console.error;
+var wrapAndSendToLogDNA = function(logDNAClient, logLevel) {
+    if (logLevel === "debug") {
+        _log("--------------------- Wrapping Console -----------------------");
+    }
+    var log = function log() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        if (logLevel === "debug") {
+            (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.debug) && (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.debug(_toConsumableArray(args).join(" ")));
+        }
+        _log.apply(void 0, _toConsumableArray(args));
+    };
+    var info = function info() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        if ([
+            "debug",
+            "info"
+        ].indexOf(logLevel) !== -1) {
+            (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.info) && (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.info(_toConsumableArray(args).join(" ")));
+        }
+        _info.apply(void 0, _toConsumableArray(args));
+    };
+    var warn = function warn() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.warn) && logDNAClient.warn(_toConsumableArray(args).join(" "));
+        _warn.apply(void 0, _toConsumableArray(args));
+    };
+    var error = function error() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        (logDNAClient === null || logDNAClient === void 0 ? void 0 : logDNAClient.error) && logDNAClient.error(_toConsumableArray(args).join(" "));
+        _error.apply(void 0, _toConsumableArray(args));
+    };
+    // Override default functions with our wrapped functions
+    console.log = log;
+    console.debug = log;
+    console.info = info;
+    console.warn = warn;
+    console.error = error;
+};
+var getDefaultConsoleLog = function() {
+    return _log;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{src/consts.js → consts.js}

@@ -10,4 +10,4 @@ Object.defineProperty(exports, "FALLBACK_TIMEOUT_AFTER_FLUSHING", {
 });
 var FALLBACK_TIMEOUT_AFTER_FLUSHING = 5000;
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25zdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgRkFMTEJBQ0tfVElNRU9VVF9BRlRFUl9GTFVTSElORyA9IDUwMDA7XG5cbmV4cG9ydCB7IEZBTExCQUNLX1RJTUVPVVRfQUZURVJfRkxVU0hJTkcgfTtcbiJdLCJuYW1lcyI6WyJGQUxMQkFDS19USU1FT1VUX0FGVEVSX0ZMVVNISU5HIl0sIm1hcHBpbmdzIjoiOzs7OytCQUVTQTs7O2VBQUFBOzs7QUFGVCxJQUFNQSxrQ0FBa0MifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jb25zdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgRkFMTEJBQ0tfVElNRU9VVF9BRlRFUl9GTFVTSElORyA9IDUwMDA7XG5cbmV4cG9ydCB7IEZBTExCQUNLX1RJTUVPVVRfQUZURVJfRkxVU0hJTkcgfTtcbiJdLCJuYW1lcyI6WyJGQUxMQkFDS19USU1FT1VUX0FGVEVSX0ZMVVNISU5HIl0sIm1hcHBpbmdzIjoiOzs7OytCQUVTQTs7O2VBQUFBOzs7QUFGVCxJQUFNQSxrQ0FBa0MifQ==

package/dist/index.js

@@ -0,0 +1,40 @@
+"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, {
+    consoleLogger: function() {
+        return _console.consoleLogger;
+    },
+    logger: function() {
+        return _logger.logger;
+    },
+    getLoggerObject: function() {
+        return _util.getLoggerObject;
+    },
+    getLogParams: function() {
+        return _params.getLogParams;
+    },
+    flushAll: function() {
+        return _util1.flushAll;
+    },
+    ensureFlushAll: function() {
+        return _util1.ensureFlushAll;
+    },
+    ensureFlushAllCallback: function() {
+        return _util1.ensureFlushAllCallback;
+    }
+});
+var _console = require("./console");
+var _logger = require("./logger");
+var _util = require("./logger/util");
+var _params = require("./params");
+var _util1 = require("./util");
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb25zb2xlTG9nZ2VyIH0gZnJvbSAnLi9jb25zb2xlJztcbmltcG9ydCB7IGxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcbmltcG9ydCB7IGdldExvZ2dlck9iamVjdCB9IGZyb20gJy4vbG9nZ2VyL3V0aWwnO1xuaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi9wYXJhbXMnO1xuaW1wb3J0IHsgZmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsLCBlbnN1cmVGbHVzaEFsbENhbGxiYWNrIH0gZnJvbSAnLi91dGlsJztcblxuLy8gRXhwb3J0IGFsbCB0aGUgZnVuY3Rpb25zXG5leHBvcnQgeyBjb25zb2xlTG9nZ2VyLCBsb2dnZXIsIGdldExvZ2dlck9iamVjdCwgZ2V0TG9nUGFyYW1zLCBmbHVzaEFsbCwgZW5zdXJlRmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsQ2FsbGJhY2sgfTtcbiJdLCJuYW1lcyI6WyJjb25zb2xlTG9nZ2VyIiwibG9nZ2VyIiwiZ2V0TG9nZ2VyT2JqZWN0IiwiZ2V0TG9nUGFyYW1zIiwiZmx1c2hBbGwiLCJlbnN1cmVGbHVzaEFsbCIsImVuc3VyZUZsdXNoQWxsQ2FsbGJhY2siXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0lBT1NBLGFBQWE7ZUFBYkEsc0JBQWE7O0lBQUVDLE1BQU07ZUFBTkEsY0FBTTs7SUFBRUMsZUFBZTtlQUFmQSxxQkFBZTs7SUFBRUMsWUFBWTtlQUFaQSxvQkFBWTs7SUFBRUMsUUFBUTtlQUFSQSxlQUFROztJQUFFQyxjQUFjO2VBQWRBLHFCQUFjOztJQUFFQyxzQkFBc0I7ZUFBdEJBLDZCQUFzQjs7O3VCQVBqRjtzQkFDUDtvQkFDUztzQkFDSDtxQkFDb0MifQ==

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+describe("Logger", function() {
+    it("should be able to load module", function() {
+        var objType = typeof _index.logger === "undefined" ? "undefined" : _typeof(_index.logger);
+        expect(objType).toEqual("object");
+        expect(_typeof(_index.logger.info)).toEqual("function");
+        expect(_typeof(_index.logger.debug)).toEqual("function");
+    });
+    it("should not prefix my Winston logger", function() {
+        var spy = jest.spyOn(_index.logger, "debug");
+        _index.logger.debug("my log message");
+        expect(spy).toHaveBeenCalledWith("my log message");
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sb2dnZXIvX190ZXN0c19fL2luZGV4LnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbG9nZ2VyIH0gZnJvbSAnLi4vaW5kZXgnO1xuXG5kZXNjcmliZSgnTG9nZ2VyJywgKCkgPT4ge1xuICBpdCgnc2hvdWxkIGJlIGFibGUgdG8gbG9hZCBtb2R1bGUnLCAoKSA9PiB7XG4gICAgY29uc3Qgb2JqVHlwZSA9IHR5cGVvZiBsb2dnZXI7XG4gICAgZXhwZWN0KG9ialR5cGUpLnRvRXF1YWwoJ29iamVjdCcpO1xuICAgIGV4cGVjdCh0eXBlb2YgbG9nZ2VyLmluZm8pLnRvRXF1YWwoJ2Z1bmN0aW9uJyk7XG4gICAgZXhwZWN0KHR5cGVvZiBsb2dnZXIuZGVidWcpLnRvRXF1YWwoJ2Z1bmN0aW9uJyk7XG4gIH0pO1xuXG4gIGl0KCdzaG91bGQgbm90IHByZWZpeCBteSBXaW5zdG9uIGxvZ2dlcicsICgpID0+IHtcbiAgICBjb25zdCBzcHkgPSBqZXN0LnNweU9uKGxvZ2dlciwgJ2RlYnVnJyk7XG4gICAgbG9nZ2VyLmRlYnVnKCdteSBsb2cgbWVzc2FnZScpO1xuICAgIGV4cGVjdChzcHkpLnRvSGF2ZUJlZW5DYWxsZWRXaXRoKCdteSBsb2cgbWVzc2FnZScpO1xuICB9KTtcbn0pO1xuIl0sIm5hbWVzIjpbImRlc2NyaWJlIiwiaXQiLCJvYmpUeXBlIiwibG9nZ2VyIiwiZXhwZWN0IiwidG9FcXVhbCIsImluZm8iLCJkZWJ1ZyIsInNweSIsImplc3QiLCJzcHlPbiIsInRvSGF2ZUJlZW5DYWxsZWRXaXRoIl0sIm1hcHBpbmdzIjoiOzs7O3FCQUF1Qjs7Ozs7QUFFdkJBLFNBQVMsVUFBVSxXQUFNO0lBQ3ZCQyxHQUFHLGlDQUFpQyxXQUFNO1FBQ3hDLElBQU1DLFVBQVUsT0FBT0MsYUFBTSxpQ0FBYixRQUFPQSxhQUFNLENBQUE7UUFDN0JDLE9BQU9GLFNBQVNHLE9BQU8sQ0FBQztRQUN4QkQsT0FBTyxRQUFPRCxhQUFNLENBQUNHLElBQUksR0FBRUQsT0FBTyxDQUFDO1FBQ25DRCxPQUFPLFFBQU9ELGFBQU0sQ0FBQ0ksS0FBSyxHQUFFRixPQUFPLENBQUM7SUFDdEM7SUFFQUosR0FBRyx1Q0FBdUMsV0FBTTtRQUM5QyxJQUFNTyxNQUFNQyxLQUFLQyxLQUFLLENBQUNQLGFBQU0sRUFBRTtRQUMvQkEsYUFBTSxDQUFDSSxLQUFLLENBQUM7UUFDYkgsT0FBT0ksS0FBS0csb0JBQW9CLENBQUM7SUFDbkM7QUFDRiJ9

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _logger = require("@logdna/logger");
+var _logdnaClient = require("../logdnaClient");
+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("@logdna/logger", function() {
+    return _objectSpreadProps(_objectSpread({}, jest.requireActual("@logdna/logger")), {
+        createLogger: jest.fn()
+    });
+});
+describe("createLogDNAClient()", function() {
+    var params = {
+        logDNAKey: "key",
+        logDNAOptions: {}
+    };
+    var someClient = {};
+    beforeEach(function() {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    it("should be able to load module", function() {
+        // Watch out - this module only perform the createLogger once, test module multiple times you need to manage
+        // logdnaClient singleton object
+        _logger.createLogger.mockReturnValue("");
+        (0, _logdnaClient.createLogDNAClient)(params);
+        expect(_logger.createLogger).toHaveBeenCalledTimes(1);
+    });
+    it("should return the same object if get called multiple times", function() {
+        _logger.createLogger.mockReturnValue(someClient);
+        (0, _logdnaClient.createLogDNAClient)(params);
+        // Call again, it should not call createLogger() again
+        (0, _logdnaClient.createLogDNAClient)(params);
+        expect(_logger.createLogger).toHaveBeenCalledTimes(1);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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