@beforeyoubid/logger-adapter 1.0.11 → 2.0.0

package/README.md

@@ -1,9 +1,18 @@
-# LogDNA Logger Adapter
+# Mezmo (Formerly LogDNA) Logger Adapter
 
-This is a platform logger module that is able to support multiple logging scenarios.
+Notes - LogDNA made a decision not to rename the library to Mezmo just yet. To avoid having two names, we decided to
+keep the variable, class and etc as LogDNA for now.
 
-- A `console` log wrapper so it can send all logs from the native `console` object to LogDNA.
-- A Winston log wrapper logger which output better colour and we can send log messages to LogNDA.
+---
+
+This is our BYB logger module that is designed to support multiple two logging scenarios.
+
+- Some repos may heavily rely on console.log() or similar to output log on the console. We can utilise this module to
+  wrap around the original `console` so all logs can be sent to Mezmo as well. The service need to add
+  `consoleLogger.init()` in the handler.
+- A Winston logger - Winston creates a generic logger objec that allows us to perform various operations on the log e.g.
+  change the colour of the log line, format message, can customise/add a custom code (using a transport mechanism) to
+  send log messages to Mezmo or store in the database if we want.
 
 This module is designed to work on a native node runtime and in a Lambda environment. For Lambda, please see the
 [Flush All Messages](#Flush-All-Messages) section below.
@@ -25,6 +34,24 @@ This module is designed to work on a native node runtime and in a Lambda environ
 If you are using `console.log` on the existing code base and not ready to switch to Winston logger just yet, this module
 can also helps you out as well.
 
+### Versions
+
+- **v1.x.x (first version)**
+  - Originally created in 2020 but the `logdna` module is no longer maintained (https://www.npmjs.com/package/logdna).
+    We need to move away from it.
+- **v2.x.x**
+  - Utilise the latest module actively maintained by Mezmo team (https://www.npmjs.com/package/@logdna/logger)
+  - Fix a missing some log line issue occured due to the the fact that `logdna-winston` module creates a separate logdna
+    client instance and it doesn't get a chance to fully flush messages before Lambda terminates. We decided to
+    customise this module in this project and allow us to utilise a single instance of a LogDNA logger object so that
+    `ensureFlushAll()` can flush those messages before we terminate Lambda function. This single LogDNA is shared and
+    used by both console log wrapper and LogDNA transport as part of Winston log system.
+  - Although it is not a major change, users of this module would like an explicably upgraded version. Just update to
+    the most recent v2 version; no API modifications are necessary on the consumer side.
+  - Also moved `createLoggerObject()` into this shared module so it's easier to use and prefix message before returning
+    the actual logger object. e.g. `createLoggerObject(`[LOG-PREFIX]`);`
+  - ![V2 Diagram](./docs/v2-diagram.png)
+
 ## 1) Use Console Logger
 
 ```
@@ -55,66 +82,10 @@ by setting `LOGDNA_ENABLED=false` in your env variables.
     // Don't need to call consoleLogger.flushAll(), logdna object has default flush interval interval at 250ms
 ```
 
-### Lambda: Use with an Aync Handler
-
-```
-  import { consoleLogger, flushAll } from '@beforeyoubid/logger-adapter';
-  consoleLogger.init();
-
-  // Ensure the we flush all messages before Lambda function gets terminated
-  const yourLambdaHandler = async (event, context) => {
-    try {
-      console.debug('Sample debug log - this message only show up when LOG_LEVEL is set to "debug"')
-
-      const result = await yourNormalProcess();
-
-      await flushAll(); // Trigger to flush all messages
-
-      return result;
-    } catch (e) {
-      // handle error
-      await flushAll(); // Trigger to flush all messages
-
-      // Throw or send result as usual
-      throw e;
-
-      // Or handle it nicely
-      // return unsuccessfulResponse;
-    }
-  }
-
-```
-
-### Lambda: Use with a Callback Handler
-
-```
-  import { consoleLogger, flushAll } from '@beforeyoubid/logger-adapter';
-  consoleLogger.init();
-
-  const yourLambdaHandler = (event, context, callback) => {
-    try {
-      console.debug('Sample debug log - this message only show up when LOG_LEVEL is set to "debug"')
-
-      const result = yourNormalProcess();
-
-      callback(null, yourNormalResponseObject);
-
-      flushAll(); // Trigger to flush all messages
-    } catch (e) {
-
-      // Ensure the we flush all messages before Lambda function gets terminated
-      flushAll(); // Trigger to flush all messages
-
-      // Call a callback with error
-      callback(yourErrorObject);
-
-      // Or return unsuccessful response
-      // https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
-      // callback(null, unsuccessfulResponse);
-    }
-  }
+## Flush All Messages
 
-```
+LogDNA puts messages in the buffer and push out every 250ms. If Lambda is terminated before some of these intervals,
+it's likely that some of message logs are not sent to LogDNA. Use `ensureFlushAll()` to flush messages automatically.
 
 ### Lambda: Use a handler wrapper for Serverless Express
 
@@ -122,26 +93,17 @@ by setting `LOGDNA_ENABLED=false` in your env variables.
   import { consoleLogger, ensureFlushAll } from '@beforeyoubid/logger-adapter';
   consoleLogger.init();
 
-  export default ensureFlushAll(graphqlHandler);
+  export default ensureFlushAll(yourLambdaHandler);
 
 ```
 
-### Lambda: Use with a Callback Handler (Apollo GraphQL Handler)
+### Lambda: Use with a Callback Handler
 
 ```
   import { consoleLogger, ensureFlushAllCallback } from '@beforeyoubid/logger-adapter';
   consoleLogger.init();
 
-  // Existing graphql hander - it uses callback signature
-  const graphqlHandler = server.createHandler({
-    cors: {
-      origin: '*',
-      allowedHeaders: ['x-api-token', 'Authorization'],
-      methods: ['GET', 'POST'],
-    },
-  });
-
-  export default ensureFlushAllCallback(graphqlHandler);
+  export default ensureFlushAllCallback(yourLambdaHandlerCallback);
 
 ```
 
@@ -172,76 +134,42 @@ of the environment variable.
     logger.info('This message only show up when LOG_LEVEL is set to "info"')
 ```
 
-### Lambda: Use with an Aync Handler
+### Lambda: Use a handler wrapper for Serverless Express
 
 ```
-  import { logger, flushAll } from '@beforeyoubid/logger-adapter';
+  import { logger, ensureFlushAll } from '@beforeyoubid/logger-adapter';
 
-  const yourLambdaHandler = async (event, context) => {
-    try {
-      logger.debug('Sample debug log - this message only show up when LOG_LEVEL is set to "debug"')
+  // you can use logger.debug('log text in a string format');
 
-      const result = await yourNormalProcess();
-
-      // Ensure the we flush all messages before Lambda function gets terminated
-      await flushAll();
-
-      return result;
-    } catch (e) {
-      // Ensure the we flush all messages before Lambda function gets terminated
-      await flushAll(); // Trigger to flush all messages
-
-      // Throw or send result as usual
-      throw e;
-
-      // Or handle it nicely
-      // return unsuccessfulResponse;
-    }
-  }
+  export default ensureFlushAll(yourLambdaHandler);
 
 ```
 
 ### Lambda: Use with a Callback Handler
 
 ```
-  import { logger, flushAll } from '@beforeyoubid/logger-adapter';
+  import { logger, ensureFlushAllCallback } from '@beforeyoubid/logger-adapter';
 
-  const yourLambdaHandler = (event, context, callback) => {
-    try {
-      logger.debug('Sample debug log - this message only show up when LOG_LEVEL is set to "debug"')
+  // you can use logger.debug('log text in a string format');
 
-      const result = yourNormalProcess();
+  export default ensureFlushAllCallback(yourLambdaHandlerCallback);
 
-      callback(null, yourNormalResponseObject);
 
-      // Ensure the we flush all messages before Lambda function gets terminated
-      flushAll(); // Trigger to flush all messages
-    } catch (e) {
-      // Ensure the we flush all messages before Lambda function gets terminated
-      flushAll(); // Trigger to flush all messages
+```
 
-      // Call a callback with error
-      callback(yourErrorObject);
+### Prefixing your log message
 
-      // Or return unsuccessful response
-      // https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
-      // callback(null, unsuccessfulResponse);
-    }
-  }
+In some cases, you may want to have a clearer log message by prefixing them with a predefined string e.g. name of your
+module so they look like this. ![Log prefix](./docs/log-prefix.png)
 
 ```
+  import { getLoggerObject } from '@beforeyoubid/logger-adapter';
 
-## Flush All Messages
-
-LogDNA puts messages in the buffer and push out every 250ms. If Lambda is terminated before some of these intervals,
-it's likely that some of message logs are not sent to LogDNA.
+  const logger = getLoggerObject('[CoreLogicListingProvider]');
 
-We just need to ensure that after we've completed the business logic and before the Lambda function is terminated, we
-flush all messages. We can just call a LogDNA `flushAll()` function and this module export this logic for us to use.
-Depending on how your Lambda handler is set up, but there are three variances we have observed.
-
-1. Async handler
-2. Async handler but use Serverless Express framework
-3. Apollo non-async handler which is created by a `createHandler()` function
+  logger.info('the usual log string...')
+```
 
-Please see usage examples from the above sections
+**Notes that** this function just wraps the original Winston logger instance your normally access from this line.
+`import { logger } from '@beforeyoubid/logger-adapter';`. It only wraps and add the prefix the log line for you and
+returns with debug, info, warn, error functions.

package/dist/console/logWrapper.d.ts

@@ -0,0 +1,4 @@
+import { type Logger } from '@logdna/logger';
+declare const wrapAndSendToLogDNA: (logDNAClient: Logger, logLevel: string) => void;
+declare const getDefaultConsoleLog: () => any;
+export { wrapAndSendToLogDNA, getDefaultConsoleLog };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { consoleLogger } from './console';
 import { logger } from './logger';
+import { getLoggerObject } from './logger/util';
 import { getLogParams } from './params';
 import { flushAll, ensureFlushAll, ensureFlushAllCallback } from './util';
-export { consoleLogger, logger, getLogParams, flushAll, ensureFlushAll, ensureFlushAllCallback };
+export { consoleLogger, logger, getLoggerObject, getLogParams, flushAll, ensureFlushAll, ensureFlushAllCallback };

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/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/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/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/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/src/__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/src/console/__tests__/consoleLogger.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+function _type_of(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" : _type_of(_index.consoleLogger);
+        expect(objType).toEqual('object');
+        expect(_type_of(_index.consoleLogger.init)).toEqual('function');
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb25zb2xlL19fdGVzdHNfXy9jb25zb2xlTG9nZ2VyLnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29uc29sZUxvZ2dlciB9IGZyb20gJy4uL2luZGV4JztcblxuZGVzY3JpYmUoJ0NvbnNvbGUgTG9nZ2VyJywgKCkgPT4ge1xuICBpdCgnc2hvdWxkIGJlIGFibGUgdG8gbG9hZCBtb2R1bGUnLCAoKSA9PiB7XG4gICAgY29uc3Qgb2JqVHlwZSA9IHR5cGVvZiBjb25zb2xlTG9nZ2VyO1xuICAgIGV4cGVjdChvYmpUeXBlKS50b0VxdWFsKCdvYmplY3QnKTtcbiAgICBleHBlY3QodHlwZW9mIGNvbnNvbGVMb2dnZXIuaW5pdCkudG9FcXVhbCgnZnVuY3Rpb24nKTtcbiAgfSk7XG59KTtcbiJdLCJuYW1lcyI6WyJkZXNjcmliZSIsIml0Iiwib2JqVHlwZSIsImNvbnNvbGVMb2dnZXIiLCJleHBlY3QiLCJ0b0VxdWFsIiwiaW5pdCJdLCJtYXBwaW5ncyI6Ijs7OztxQkFBOEI7Ozs7O0FBRTlCQSxTQUFTLGtCQUFrQjtJQUN6QkMsR0FBRyxpQ0FBaUM7UUFDbEMsSUFBTUMsVUFBVSxPQUFPQyxvQkFBYSxpQ0FBcEIsU0FBT0Esb0JBQWE7UUFDcENDLE9BQU9GLFNBQVNHLE9BQU8sQ0FBQztRQUN4QkQsT0FBTyxTQUFPRCxvQkFBYSxDQUFDRyxJQUFJLEdBQUVELE9BQU8sQ0FBQztJQUM1QztBQUNGIn0=

package/dist/src/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/src/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, {
+    getDefaultConsoleLog: function() {
+        return getDefaultConsoleLog;
+    },
+    wrapAndSendToLogDNA: function() {
+        return wrapAndSendToLogDNA;
+    }
+});
+function _array_like_to_array(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 _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(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 _array_like_to_array(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(_to_consumable_array(args).join(' ')));
+        }
+        _log.apply(void 0, _to_consumable_array(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(_to_consumable_array(args).join(' ')));
+        }
+        _info.apply(void 0, _to_consumable_array(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(_to_consumable_array(args).join(' '));
+        _warn.apply(void 0, _to_consumable_array(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(_to_consumable_array(args).join(' '));
+        _error.apply(void 0, _to_consumable_array(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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FALLBACK_TIMEOUT_AFTER_FLUSHING", {
+    enumerable: true,
+    get: function() {
+        return FALLBACK_TIMEOUT_AFTER_FLUSHING;
+    }
+});
+var FALLBACK_TIMEOUT_AFTER_FLUSHING = 5000;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25zdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgRkFMTEJBQ0tfVElNRU9VVF9BRlRFUl9GTFVTSElORyA9IDUwMDA7XG5cbmV4cG9ydCB7IEZBTExCQUNLX1RJTUVPVVRfQUZURVJfRkxVU0hJTkcgfTtcbiJdLCJuYW1lcyI6WyJGQUxMQkFDS19USU1FT1VUX0FGVEVSX0ZMVVNISU5HIl0sIm1hcHBpbmdzIjoiOzs7OytCQUVTQTs7O2VBQUFBOzs7QUFGVCxJQUFNQSxrQ0FBa0MifQ==

package/dist/src/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;
+    },
+    ensureFlushAll: function() {
+        return _util1.ensureFlushAll;
+    },
+    ensureFlushAllCallback: function() {
+        return _util1.ensureFlushAllCallback;
+    },
+    flushAll: function() {
+        return _util1.flushAll;
+    },
+    getLogParams: function() {
+        return _params.getLogParams;
+    },
+    getLoggerObject: function() {
+        return _util.getLoggerObject;
+    },
+    logger: function() {
+        return _logger.logger;
+    }
+});
+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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb25zb2xlTG9nZ2VyIH0gZnJvbSAnLi9jb25zb2xlJztcbmltcG9ydCB7IGxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcbmltcG9ydCB7IGdldExvZ2dlck9iamVjdCB9IGZyb20gJy4vbG9nZ2VyL3V0aWwnO1xuaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi9wYXJhbXMnO1xuaW1wb3J0IHsgZmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsLCBlbnN1cmVGbHVzaEFsbENhbGxiYWNrIH0gZnJvbSAnLi91dGlsJztcblxuLy8gRXhwb3J0IGFsbCB0aGUgZnVuY3Rpb25zXG5leHBvcnQgeyBjb25zb2xlTG9nZ2VyLCBsb2dnZXIsIGdldExvZ2dlck9iamVjdCwgZ2V0TG9nUGFyYW1zLCBmbHVzaEFsbCwgZW5zdXJlRmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsQ2FsbGJhY2sgfTtcbiJdLCJuYW1lcyI6WyJjb25zb2xlTG9nZ2VyIiwiZW5zdXJlRmx1c2hBbGwiLCJlbnN1cmVGbHVzaEFsbENhbGxiYWNrIiwiZmx1c2hBbGwiLCJnZXRMb2dQYXJhbXMiLCJnZXRMb2dnZXJPYmplY3QiLCJsb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0lBT1NBLGFBQWE7ZUFBYkEsc0JBQWE7O0lBQW1EQyxjQUFjO2VBQWRBLHFCQUFjOztJQUFFQyxzQkFBc0I7ZUFBdEJBLDZCQUFzQjs7SUFBaERDLFFBQVE7ZUFBUkEsZUFBUTs7SUFBdEJDLFlBQVk7ZUFBWkEsb0JBQVk7O0lBQTdCQyxlQUFlO2VBQWZBLHFCQUFlOztJQUF2QkMsTUFBTTtlQUFOQSxjQUFNOzs7dUJBUEE7c0JBQ1A7b0JBQ1M7c0JBQ0g7cUJBQ29DIn0=