@beforeyoubid/logger-adapter 2.0.0 → 2.0.2

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,116 @@
+"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 logger object - debug", 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 prefix my logger object - info", function() {
+        var spy = jest.spyOn(_index.logger, "info");
+        var testLoggerObject = (0, _util.getLoggerObject)("[MY-PREFIX]");
+        testLoggerObject.info("my log message");
+        expect(spy).toHaveBeenCalledWith('[MY-PREFIX]: "my log message"');
+    });
+    it("should prefix my logger object - warn", function() {
+        var spy = jest.spyOn(_index.logger, "warn");
+        var testLoggerObject = (0, _util.getLoggerObject)("[MY-PREFIX]");
+        testLoggerObject.warn("my log message");
+        expect(spy).toHaveBeenCalledWith('[MY-PREFIX]: "my log message"');
+    });
+    it("should prefix my logger object - error", function() {
+        var spy = jest.spyOn(_index.logger, "error");
+        var testLoggerObject = (0, _util.getLoggerObject)("[MY-PREFIX]");
+        testLoggerObject.error("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"');
+    });
+    describe("Handle multiple loggers", function() {
+        it("should be able to handle multiple loggers with correct prefix", function() {
+            var spy = jest.spyOn(_index.logger, "debug");
+            var testLoggerObject1 = (0, _util.getLoggerObject)("[MY-PREFIX-1]");
+            testLoggerObject1.debug("my log message");
+            expect(spy).toHaveBeenCalledWith('[MY-PREFIX-1]: "my log message"');
+            spy.mockReset();
+            var spy2 = jest.spyOn(_index.logger, "info");
+            var testLoggerObject2 = (0, _util.getLoggerObject)("[MY-PREFIX-2]");
+            testLoggerObject2.info("my log message");
+            expect(spy2).toHaveBeenCalledWith('[MY-PREFIX-2]: "my log message"');
+            // try again on debug
+            var spy3 = jest.spyOn(_index.logger, "debug");
+            testLoggerObject1.debug("another log on the original logger");
+            expect(spy3).toHaveBeenCalledWith('[MY-PREFIX-1]: "another log on the original logger"');
+        });
+    });
+});
+
+//# 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.d.ts

@@ -1,5 +1,10 @@
 import LogDNALogger from '@logdna/logger';
 import { type ILogDNAParams } from '../types';
+/**
+ * Handy utility to check if LogDNA client is available, also support unit test
+ * @returns
+ */
+export declare const isClientAvailable: () => boolean;
 /**
  * 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()

package/dist/logger/logdnaClient.js

@@ -0,0 +1,57 @@
+"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, {
+    isClientAvailable: function() {
+        return isClientAvailable;
+    },
+    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
+    };
+}
+var debug = require("util").debuglog("logger-adapter");
+// A singleton object in this module
+var logdnaClient;
+var isClientAvailable = function() {
+    return !!logdnaClient;
+};
+var createLogDNAClient = function(params) {
+    if (isClientAvailable()) 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() {
+    if (!isClientAvailable()) {
+        debug("LogDNA client is not created yet. Please call createLogDNAClient() first");
+    }
+    return logdnaClient;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/logger.js

@@ -0,0 +1,60 @@
+"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 formatFunction = function(info) {
+    return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
+};
+var createWinstonLogger = function(logLevel) {
+    var logger = _winston.default.createLogger({
+        level: logLevel || "info",
+        format: format.combine(format.timestamp(), format.simple(), format.printf(formatFunction)),
+        transports: [
+            new transports.Console({
+                format: format.combine(format.timestamp(), format.simple(), format.printf(formatFunction), 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.d.ts

@@ -1,11 +1,7 @@
+import { WrappedLogger } from '../types';
 /**
  * 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;
-};
+declare const getLoggerObject: (prefix?: string) => WrappedLogger;
 export { getLoggerObject };

package/dist/logger/util.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getLoggerObject", {
+    enumerable: true,
+    get: function() {
+        return getLoggerObject;
+    }
+});
+var _index = require("./index");
+var logFunctionsToWrap = [
+    "debug",
+    "info",
+    "warn",
+    "error"
+];
+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 wrappedLogger = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var functionName = _step.value;
+            wrappedLogger[functionName] = function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return _index.logger[functionName]("".concat(getPrefix(prefix)).concat(toString(args)));
+            };
+        };
+        for(var _iterator = logFunctionsToWrap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return wrappedLogger;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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