@beforeyoubid/logger-adapter 1.0.12 → 2.0.1

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sb2dnZXIvX190ZXN0c19fL2xvZ2RuYUNsaWVudC5zcGVjLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBMb2dETkFMb2dnZXIsIHsgY3JlYXRlTG9nZ2VyIH0gZnJvbSAnQGxvZ2RuYS9sb2dnZXInO1xuamVzdC5tb2NrKCdAbG9nZG5hL2xvZ2dlcicsICgpID0+ICh7XG4gIC4uLmplc3QucmVxdWlyZUFjdHVhbCgnQGxvZ2RuYS9sb2dnZXInKSxcbiAgY3JlYXRlTG9nZ2VyOiBqZXN0LmZuKCksIC8vIG1vY2sgb25lIHNwZWNpZmljIGZ1bmN0aW9uIHRvIG9ic2VydmUgYmVoYXZpb3Jcbn0pKTtcbmltcG9ydCB7IGNyZWF0ZUxvZ0ROQUNsaWVudCB9IGZyb20gJy4uL2xvZ2RuYUNsaWVudCc7XG5pbXBvcnQgdHlwZSB7IElMb2dETkFQYXJhbXMgfSBmcm9tICcuLi8uLi90eXBlcyc7XG5cbmRlc2NyaWJlKCdjcmVhdGVMb2dETkFDbGllbnQoKScsICgpID0+IHtcbiAgY29uc3QgcGFyYW1zID0ge1xuICAgIGxvZ0ROQUtleTogJ2tleScsXG4gICAgbG9nRE5BT3B0aW9uczoge30sXG4gIH0gYXMgSUxvZ0ROQVBhcmFtcztcbiAgY29uc3Qgc29tZUNsaWVudCA9IHt9IGFzIExvZ0ROQUxvZ2dlci5Mb2dnZXI7XG5cbiAgYmVmb3JlRWFjaCgoKSA9PiB7XG4gICAgamVzdC5jbGVhckFsbE1vY2tzKCk7XG4gICAgamVzdC5yZXN0b3JlQWxsTW9ja3MoKTtcbiAgfSk7XG5cbiAgaXQoJ3Nob3VsZCBiZSBhYmxlIHRvIGxvYWQgbW9kdWxlJywgKCkgPT4ge1xuICAgIC8vIFdhdGNoIG91dCAtIHRoaXMgbW9kdWxlIG9ubHkgcGVyZm9ybSB0aGUgY3JlYXRlTG9nZ2VyIG9uY2UsIHRlc3QgbW9kdWxlIG11bHRpcGxlIHRpbWVzIHlvdSBuZWVkIHRvIG1hbmFnZVxuICAgIC8vIGxvZ2RuYUNsaWVudCBzaW5nbGV0b24gb2JqZWN0XG4gICAgKGNyZWF0ZUxvZ2dlciBhcyBqZXN0Lk1vY2spLm1vY2tSZXR1cm5WYWx1ZSgnJyBhcyB1bmtub3duIGFzIExvZ0ROQUxvZ2dlci5Mb2dnZXIpO1xuICAgIGNyZWF0ZUxvZ0ROQUNsaWVudChwYXJhbXMpO1xuICAgIGV4cGVjdChjcmVhdGVMb2dnZXIpLnRvSGF2ZUJlZW5DYWxsZWRUaW1lcygxKTtcbiAgfSk7XG5cbiAgaXQoJ3Nob3VsZCByZXR1cm4gdGhlIHNhbWUgb2JqZWN0IGlmIGdldCBjYWxsZWQgbXVsdGlwbGUgdGltZXMnLCAoKSA9PiB7XG4gICAgKGNyZWF0ZUxvZ2dlciBhcyBqZXN0Lk1vY2spLm1vY2tSZXR1cm5WYWx1ZShzb21lQ2xpZW50KTtcbiAgICBjcmVhdGVMb2dETkFDbGllbnQocGFyYW1zKTtcblxuICAgIC8vIENhbGwgYWdhaW4sIGl0IHNob3VsZCBub3QgY2FsbCBjcmVhdGVMb2dnZXIoKSBhZ2FpblxuICAgIGNyZWF0ZUxvZ0ROQUNsaWVudChwYXJhbXMpO1xuICAgIGV4cGVjdChjcmVhdGVMb2dnZXIpLnRvSGF2ZUJlZW5DYWxsZWRUaW1lcygxKTtcbiAgfSk7XG59KTtcbiJdLCJuYW1lcyI6WyJqZXN0IiwibW9jayIsInJlcXVpcmVBY3R1YWwiLCJjcmVhdGVMb2dnZXIiLCJmbiIsImRlc2NyaWJlIiwicGFyYW1zIiwibG9nRE5BS2V5IiwibG9nRE5BT3B0aW9ucyIsInNvbWVDbGllbnQiLCJiZWZvcmVFYWNoIiwiY2xlYXJBbGxNb2NrcyIsInJlc3RvcmVBbGxNb2NrcyIsIml0IiwibW9ja1JldHVyblZhbHVlIiwiY3JlYXRlTG9nRE5BQ2xpZW50IiwiZXhwZWN0IiwidG9IYXZlQmVlbkNhbGxlZFRpbWVzIl0sIm1hcHBpbmdzIjoiOzs7O3NCQUEyQzs0QkFLUjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFKbkNBLEtBQUtDLElBQUksQ0FBQyxrQkFBa0I7V0FBTyxxQ0FDOUJELEtBQUtFLGFBQWEsQ0FBQztRQUN0QkMsY0FBY0gsS0FBS0ksRUFBRTs7O0FBS3ZCQyxTQUFTLHdCQUF3QixXQUFNO0lBQ3JDLElBQU1DLFNBQVM7UUFDYkMsV0FBVztRQUNYQyxlQUFlLENBQUM7SUFDbEI7SUFDQSxJQUFNQyxhQUFhLENBQUM7SUFFcEJDLFdBQVcsV0FBTTtRQUNmVixLQUFLVyxhQUFhO1FBQ2xCWCxLQUFLWSxlQUFlO0lBQ3RCO0lBRUFDLEdBQUcsaUNBQWlDLFdBQU07UUFDeEMsNEdBQTRHO1FBQzVHLGdDQUFnQztRQUMvQlYsb0JBQVksQ0FBZVcsZUFBZSxDQUFDO1FBQzVDQyxJQUFBQSxnQ0FBa0IsRUFBQ1Q7UUFDbkJVLE9BQU9iLG9CQUFZLEVBQUVjLHFCQUFxQixDQUFDO0lBQzdDO0lBRUFKLEdBQUcsOERBQThELFdBQU07UUFDcEVWLG9CQUFZLENBQWVXLGVBQWUsQ0FBQ0w7UUFDNUNNLElBQUFBLGdDQUFrQixFQUFDVDtRQUVuQixzREFBc0Q7UUFDdERTLElBQUFBLGdDQUFrQixFQUFDVDtRQUNuQlUsT0FBT2Isb0JBQVksRUFBRWMscUJBQXFCLENBQUM7SUFDN0M7QUFDRiJ9

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.d.ts

@@ -1,2 +1,2 @@
-declare const logger: any;
+declare const logger: import("winston").Logger;
 export { logger };

package/dist/logger/index.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "logger", {
 var _params = require("../params");
 var _logger = require("./logger");
 var logParams = (0, _params.getLogParams)();
-var logger = (0, _logger.getLogger)(logParams);
+// Create a singleton logger object during module initialisation
+var logger = (0, _logger.setupWinstonLogger)(logParams);
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dnZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi4vcGFyYW1zJztcbmltcG9ydCB7IGdldExvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcblxuY29uc3QgbG9nUGFyYW1zID0gZ2V0TG9nUGFyYW1zKCk7XG5jb25zdCBsb2dnZXIgPSBnZXRMb2dnZXIobG9nUGFyYW1zKTtcblxuZXhwb3J0IHsgbG9nZ2VyIH07XG4iXSwibmFtZXMiOlsibG9nZ2VyIiwibG9nUGFyYW1zIiwiZ2V0TG9nUGFyYW1zIiwiZ2V0TG9nZ2VyIl0sIm1hcHBpbmdzIjoiOzs7OytCQU1TQTs7O2VBQUFBOzs7c0JBTm9CO3NCQUNIO0FBRTFCLElBQU1DLFlBQVlDLElBQUFBLG9CQUFZO0FBQzlCLElBQU1GLFNBQVNHLElBQUFBLGlCQUFTLEVBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dnZXIvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi4vcGFyYW1zJztcbmltcG9ydCB7IHNldHVwV2luc3RvbkxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcblxuY29uc3QgbG9nUGFyYW1zID0gZ2V0TG9nUGFyYW1zKCk7XG5cbi8vIENyZWF0ZSBhIHNpbmdsZXRvbiBsb2dnZXIgb2JqZWN0IGR1cmluZyBtb2R1bGUgaW5pdGlhbGlzYXRpb25cbmNvbnN0IGxvZ2dlciA9IHNldHVwV2luc3RvbkxvZ2dlcihsb2dQYXJhbXMpO1xuXG5leHBvcnQgeyBsb2dnZXIgfTtcbiJdLCJuYW1lcyI6WyJsb2dnZXIiLCJsb2dQYXJhbXMiLCJnZXRMb2dQYXJhbXMiLCJzZXR1cFdpbnN0b25Mb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUVNBOzs7ZUFBQUE7OztzQkFSb0I7c0JBQ007QUFFbkMsSUFBTUMsWUFBWUMsSUFBQUEsb0JBQVk7QUFFOUIsZ0VBQWdFO0FBQ2hFLElBQU1GLFNBQVNHLElBQUFBLDBCQUFrQixFQUFDRiJ9

package/dist/logger/logdnaClient.d.ts

@@ -0,0 +1,19 @@
+import LogDNALogger from '@logdna/logger';
+import { type ILogDNAParams } from '../types';
+/**
+ * Create one single instance of LogDNA (Mezmo) client so it can be shared/used in two cases
+ * 1) Use it with the console wrapper. We send anything from console.log(), console.info(), console.error()
+ *    to LogDNA for backward compatibility. Consumer can use this by calling consoleLogger.init()
+ * 2) Use it with a Winston logger as part of the transports to send logs to LogDNA
+ *
+ * Before calling this function, make sure we check if LogDNA is enabled before creating it
+ *
+ * @param params
+ * @returns
+ */
+export declare const createLogDNAClient: (params: ILogDNAParams) => LogDNALogger.Logger;
+/**
+ * Return the singleton instance of LogDNA client created by createLogDNAClient()
+ * @returns
+ */
+export declare const getLogDNAClient: () => LogDNALogger.Logger;

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.d.ts

@@ -1,3 +1,13 @@
 import { ILogDNAParams } from '../types';
-declare const getLogger: (params: ILogDNAParams) => any;
-export { getLogger };
+import winston from 'winston';
+/**
+ * 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
+ */
+declare const setupWinstonLogger: (params: ILogDNAParams) => winston.Logger;
+export { setupWinstonLogger };

package/dist/logger/logger.js

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getLogger", {
+Object.defineProperty(exports, "setupWinstonLogger", {
     enumerable: true,
     get: function() {
-        return getLogger;
+        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 logdnaWinston = require("logdna-winston");
 var format = _winston.default.format, transports = _winston.default.transports;
 var createWinstonLogger = function(logLevel) {
     var logger = _winston.default.createLogger({
@@ -35,17 +36,26 @@ var createWinstonLogger = function(logLevel) {
     });
     return logger;
 };
-var getLogger = function(params) {
+/**
+ * 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) {
-        logger.add(new logdnaWinston(logDNAOptions));
+        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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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A utility command to return a logger with a prefix on log line.
+ * @param prefix string
+ */
+declare const getLoggerObject: (prefix?: string) => {
+    debug: (...args: unknown[]) => import("winston").Logger;
+    info: (...args: unknown[]) => import("winston").Logger;
+    warn: (...args: unknown[]) => import("winston").Logger;
+    error: (...args: unknown[]) => import("winston").Logger;
+};
+export { getLoggerObject };

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,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

package/dist/params.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ILogDNAParams } from './types';
+import { type ILogDNAParams } from './types';
 declare const sendToRemote: (logDNAKey: string, logDNAEnabled: string) => boolean;
 declare const getLogParams: (env?: NodeJS.ProcessEnv) => ILogDNAParams;
 export { getLogParams, sendToRemote };

package/dist/params.js

@@ -39,7 +39,7 @@ var getLogParams = function() {
         env: STAGE,
         app: AWS_LAMBDA_FUNCTION_NAME,
         hostname: STAGE,
-        index_meta: true,
+        indexMeta: true,
         tags: [
             AWS_LAMBDA_FUNCTION_NAME,
             STAGE
@@ -57,4 +57,4 @@ var getLogParams = function() {
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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