@beforeyoubid/logger-adapter 1.0.12 → 2.0.1

package/dist/transports/logdnaWinston.d.ts

@@ -0,0 +1,28 @@
+import Transport from 'winston-transport';
+import { Logger } from '@logdna/logger';
+/**
+ * Support for Winston Transport
+ * Functionality:
+ *  This code is to extend Winston object and transport logs to LogDNA automatically.
+ *  We need to build a custom transport because the original code doesn't support Lambda environment. See below
+ *
+ * Note:
+ *  This code is cloned from the official LogDNA Winston transport (https://github.com/logdna/logdna-winston)
+ *  This module has limited and doesn't fully support Lambda environment due to the fact that the logger object is
+ *  created inside of the transport. This means that our ensureFlushAll() doesn't have a chance to clear its buffer
+ *
+ *  Someone reported the issue here - https://github.com/logdna/logdna-winston/issues/38
+ *
+ * Example of transport (https://github.com/winstonjs/winston-transport)
+ */
+export declare class LogDNATransport extends Transport {
+    logger: Logger;
+    constructor(options: any, suppliedLogdnaClient?: Logger);
+    /**
+     * Winston Transport will call this log function
+     * @param info
+     * @param callback
+     * @returns
+     */
+    log(info: any, callback: (a: any, b: any) => void): void;
+}

package/dist/transports/logdnaWinston.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LogDNATransport", {
+    enumerable: true,
+    get: function() {
+        return LogDNATransport;
+    }
+});
+var _winstonTransport = /*#__PURE__*/ _interopRequireDefault(require("winston-transport"));
+var _logger = require("@logdna/logger");
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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 _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var LogDNATransport = /*#__PURE__*/ function(Transport) {
+    "use strict";
+    _inherits(LogDNATransport, Transport);
+    var _super = _createSuper(LogDNATransport);
+    function LogDNATransport(options, suppliedLogdnaClient) {
+        _classCallCheck(this, LogDNATransport);
+        var _this;
+        var levels = options.levels, maxLevel = options.maxLevel, key = options.key, opts = _objectWithoutProperties(options, [
+            "levels",
+            "maxLevel",
+            "key"
+        ]);
+        _this = _super.call(this, _objectSpreadProps(_objectSpread({}, opts), {
+            levels: levels,
+            level: maxLevel
+        }));
+        var custom_levels = levels;
+        if (!custom_levels) {
+            // Per the winston docs, their 'npm' levels will be used, and those must be
+            // set up as custom levels in LogDNA.
+            // @see https://github.com/winstonjs/winston#logging-levels
+            custom_levels = {
+                error: 0,
+                warn: 1,
+                info: 2,
+                http: 3,
+                verbose: 4,
+                debug: 5,
+                silly: 6
+            };
+        }
+        // Using the supplied logger or create an instance of @logdna/logger
+        _this.logger = suppliedLogdnaClient !== null && suppliedLogdnaClient !== void 0 ? suppliedLogdnaClient : (0, _logger.createLogger)(key, _objectSpreadProps(_objectSpread({}, opts), {
+            levels: Object.keys(custom_levels),
+            UserAgent: "byb-logger-adapter"
+        }));
+        return _this;
+    }
+    var _proto = LogDNATransport.prototype;
+    /**
+   * Winston Transport will call this log function
+   * @param info
+   * @param callback
+   * @returns
+   */ _proto.log = function log(info, callback) {
+        var level = info.level;
+        if (_instanceof(info.error, Error)) {
+            info.error = info.error.stack || info.error.toString();
+        }
+        if (!info.message) {
+            // Send the incoming object payload as the message
+            this.logger.log(info, level);
+            callback(null, true);
+            return;
+        }
+        // eslint-disable-next-line no-unused-vars
+        var message = info.message, indexMeta = info.indexMeta, timestamp = info.timestamp, meta = _objectWithoutProperties(info, [
+            "message",
+            "indexMeta",
+            "timestamp"
+        ]);
+        var opts = {
+            level: level,
+            indexMeta: indexMeta,
+            timestamp: timestamp,
+            meta: meta
+        };
+        this.logger.log(message, opts);
+        callback(null, true);
+    };
+    return LogDNATransport;
+}(_winstonTransport.default);
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -7,7 +7,7 @@ export interface ILogDNALogOptions {
     env: string;
     app: string;
     hostname: string;
-    index_meta: boolean;
+    indexMeta: boolean;
     tags: Array<string>;
     level: string;
     handleExceptions: boolean;

package/dist/util.d.ts

@@ -7,6 +7,7 @@ import { LambdaHandlerWithAsyncFunction, LambdaHandlerWithCallbackFunction } fro
 declare const isLogDNAEnabled: (logDNAKey: string, sendToRemote: boolean) => boolean;
 /**
  * Send all log messages to LogDNA before lambda is terminated
+ * Support an async function
  */
 declare const flushAll: () => Promise<void>;
 /**

package/dist/util.js

@@ -22,6 +22,8 @@ _export(exports, {
         return ensureFlushAllCallback;
     }
 });
+var _logdnaClient = require("./logger/logdnaClient");
+var _events = require("events");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -146,12 +148,11 @@ var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
         };
     }
 };
-var LogDNALogger = require("logdna");
 var debug = require("util").debuglog("logger-adapter");
 var FALLBACK_TIMEOUT_AFTER_FLUSHING = require("./consts").FALLBACK_TIMEOUT_AFTER_FLUSHING;
 var getLogParams = require("./params").getLogParams;
 // timeout
-var timeout;
+var timeout = null;
 /**
  * Handy function to check if we are sending to LogDNA
  * @param logDNAKey
@@ -167,21 +168,45 @@ var timeout;
 };
 /**
  * Send all log messages to LogDNA before lambda is terminated
+ * Support an async function
  */ var flushAll = function() {
     var _ref = _asyncToGenerator(function() {
         return __generator(this, function(_state) {
             return [
                 2,
-                new Promise(function(resolve) {
-                    debug("Flushing all logs...");
-                    LogDNALogger.flushAll(function() {
-                        debug("Completed flushing all log messages");
-                        if (timeout) {
-                            clearTimeout(timeout);
-                        }
-                        resolve();
+                new Promise(function() {
+                    var _ref = _asyncToGenerator(function(resolve) {
+                        var logger, before;
+                        return __generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    debug("Flushing all logs...");
+                                    logger = (0, _logdnaClient.getLogDNAClient)();
+                                    if (!logger) return [
+                                        2
+                                    ];
+                                    before = Date.now();
+                                    // Wait until LogDNA emitter flushes all logs, then resolve
+                                    // The default flushing interval is 250ms
+                                    return [
+                                        4,
+                                        (0, _events.once)(logger, "cleared")
+                                    ];
+                                case 1:
+                                    _state.sent();
+                                    debug("Flushing all logs done in ".concat(Date.now() - before, "ms"));
+                                    timeout && clearTimeout(timeout);
+                                    resolve();
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
                     });
-                })
+                    return function(resolve) {
+                        return _ref.apply(this, arguments);
+                    };
+                }())
             ];
         });
     });
@@ -189,6 +214,18 @@ var timeout;
         return _ref.apply(this, arguments);
     };
 }();
+/**
+ * Try to clear all logs before the Lambda function is terminated (support callback pattern)
+ *
+ * @returns
+ */ var flushAllCallback = function() {
+    debug("Flushing all logs...");
+    var logger = (0, _logdnaClient.getLogDNAClient)();
+    if (!logger) return;
+    // Calling flush() manually here to avoid relying on the async event
+    // https://www.npmjs.com/package/@logdna/logger#loggerflush
+    logger.flush();
+};
 /**
  * Fallback promise just in
  */ var timeoutPromise = function() {
@@ -282,10 +319,10 @@ var timeout;
     return function(event, context, callback) {
         var thisCallback = function(error, result) {
             callback(error, result);
-            if (!suppressFlushAll()) flushAll();
+            if (!suppressFlushAll()) flushAllCallback();
         };
         lambdaHandler(event, context, thisCallback);
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/util.ts"],"sourcesContent":["import { LambdaHandlerWithAsyncFunction, LambdaHandlerWithCallbackFunction, CallbackFunction } from './types';\n\n//const LogDNALogger = require('@logdna/logger');\nimport { getLogDNAClient } from './logger/logdnaClient';\nconst debug = require('util').debuglog('logger-adapter');\nconst { FALLBACK_TIMEOUT_AFTER_FLUSHING } = require('./consts');\nconst { getLogParams } = require('./params');\nimport { once } from 'events';\n\n// timeout\nlet timeout: NodeJS.Timeout | null = null;\n\n/**\n * Handy function to check if we are sending to LogDNA\n * @param logDNAKey\n * @param sendToRemote\n */\nconst isLogDNAEnabled = (logDNAKey: string, sendToRemote: boolean): boolean => !!logDNAKey && sendToRemote;\n\n/**\n * REturn if we need to suppress flushAll on a local machine\n */\nconst suppressFlushAll = (): boolean => getLogParams()?.logDNASuppressFlushAll || false;\n\n/**\n * Send all log messages to LogDNA before lambda is terminated\n * Support an async function\n */\nconst flushAll = async (): Promise<void> => {\n  return new Promise(async resolve => {\n    debug('Flushing all logs...');\n    const logger = getLogDNAClient();\n    if (!logger) return;\n\n    const before = Date.now();\n    // Wait until LogDNA emitter flushes all logs, then resolve\n    // The default flushing interval is 250ms\n    await once(logger, 'cleared');\n    debug(`Flushing all logs done in ${Date.now() - before}ms`);\n    timeout && clearTimeout(timeout);\n    resolve();\n  });\n};\n\n/**\n * Try to clear all logs before the Lambda function is terminated (support callback pattern)\n *\n * @returns\n */\nconst flushAllCallback = (): void => {\n  debug('Flushing all logs...');\n  const logger = getLogDNAClient();\n  if (!logger) return;\n\n  // Calling flush() manually here to avoid relying on the async event\n  // https://www.npmjs.com/package/@logdna/logger#loggerflush\n  logger.flush();\n};\n\n/**\n * Fallback promise just in\n */\nconst timeoutPromise = (): Promise<void> => {\n  return new Promise(resolve => {\n    timeout = setTimeout(() => {\n      debug('Flushing timeout has reached. Ignore flushing messages...');\n      resolve();\n    }, FALLBACK_TIMEOUT_AFTER_FLUSHING);\n  });\n};\n\n/**\n * Lambda wrapper to ensure we flush messages before returning the response\n * @param lambdaHandler\n */\nconst ensureFlushAll = (lambdaHandler: LambdaHandlerWithAsyncFunction): LambdaHandlerWithAsyncFunction => {\n  return async (event: any, context: any): Promise<any> => {\n    try {\n      const result = await lambdaHandler(event, context);\n      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);\n      return result;\n    } catch (e) {\n      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);\n      throw e;\n    }\n  };\n};\n\n/**\n * A Lambda wrapper to ensure we flush messages before a Lambda function get terminated\n * NOTE: For non-async handlers, AWS Lambda will wait until the event loop is completed.\n * This means after a callback function is called, a Lambda function still run\n * and we can catch the final clean up.\n * REF: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html\n *\n * @param lambdaHandler\n */\nconst ensureFlushAllCallback = (\n  lambdaHandler: LambdaHandlerWithCallbackFunction\n): LambdaHandlerWithCallbackFunction => {\n  return (event: any, context: any, callback: CallbackFunction): void => {\n    const thisCallback = (error: any, result: any): void => {\n      callback(error, result);\n      if (!suppressFlushAll()) flushAllCallback();\n    };\n    lambdaHandler(event, context, thisCallback);\n  };\n};\n\nexport { isLogDNAEnabled, flushAll, ensureFlushAll, ensureFlushAllCallback };\n"],"names":["isLogDNAEnabled","flushAll","ensureFlushAll","ensureFlushAllCallback","debug","require","debuglog","FALLBACK_TIMEOUT_AFTER_FLUSHING","getLogParams","timeout","logDNAKey","sendToRemote","suppressFlushAll","logDNASuppressFlushAll","Promise","resolve","logger","before","getLogDNAClient","Date","now","once","clearTimeout","flushAllCallback","flush","timeoutPromise","setTimeout","lambdaHandler","event","context","result","e","race","callback","thisCallback","error"],"mappings":";;;;;;;;;;;IA6GSA,eAAe;eAAfA;;IAAiBC,QAAQ;eAARA;;IAAUC,cAAc;eAAdA;;IAAgBC,sBAAsB;eAAtBA;;;4BA1GpB;sBAIX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAHrB,IAAMC,QAAQC,QAAQ,QAAQC,QAAQ,CAAC;AACvC,IAAM,AAAEC,kCAAoCF,QAAQ,YAA5CE;AACR,IAAM,AAAEC,eAAiBH,QAAQ,YAAzBG;AAGR,UAAU;AACV,IAAIC,UAAiC,IAAI;AAEzC;;;;CAIC,GACD,IAAMT,kBAAkB,SAACU,WAAmBC;WAAmC,CAAC,CAACD,aAAaC;;AAE9F;;CAEC,GACD,IAAMC,mBAAmB;QAAeJ;IAAAA,OAAAA,CAAAA,CAAAA,gBAAAA,4BAAAA,2BAAAA,KAAAA,IAAAA,cAAgBK,sBAAsB,AAAD,KAAK,KAAK;;AAEvF;;;CAGC,GACD,IAAMZ;eAAW,kBAAA,WAA2B;;YAC1C;;gBAAO,IAAIa;+BAAQ,kBAAA,SAAMC,SAAW;4BAE5BC,QAGAC;;;;oCAJNb,MAAM;oCACAY,SAASE,IAAAA,6BAAe;oCAC9B,IAAI,CAACF,QAAQ;;;oCAEPC,SAASE,KAAKC,GAAG;oCACvB,2DAA2D;oCAC3D,yCAAyC;oCACzC;;wCAAMC,IAAAA,YAAI,EAACL,QAAQ;;;oCAAnB;oCACAZ,MAAM,AAAC,6BAAgD,OAApBe,KAAKC,GAAG,KAAKH,QAAO;oCACvDR,WAAWa,aAAab;oCACxBM;;;;;;oBACF;oCAZyBA;;;;;;IAa3B;oBAdMd;;;;AAgBN;;;;CAIC,GACD,IAAMsB,mBAAmB,WAAY;IACnCnB,MAAM;IACN,IAAMY,SAASE,IAAAA,6BAAe;IAC9B,IAAI,CAACF,QAAQ;IAEb,oEAAoE;IACpE,2DAA2D;IAC3DA,OAAOQ,KAAK;AACd;AAEA;;CAEC,GACD,IAAMC,iBAAiB,WAAqB;IAC1C,OAAO,IAAIX,QAAQC,SAAAA,SAAW;QAC5BN,UAAUiB,WAAW,WAAM;YACzBtB,MAAM;YACNW;QACF,GAAGR;IACL;AACF;AAEA;;;CAGC,GACD,IAAML,iBAAiB,SAACyB,eAAkF;IACxG;mBAAO,kBAAA,SAAOC,OAAYC,SAA+B;gBAE/CC,QAGCC;;;;;;;;;;wBAHQ;;4BAAMJ,cAAcC,OAAOC;;;wBAApCC,SAAS;6BACX,CAAClB,oBAAD;;;;wBAAqB;;4BAAME,QAAQkB,IAAI;gCAAE/B;gCAAYwB;;;;wBAAhC;;;wBACzB;;4BAAOK;;;wBACAC;6BACH,CAACnB,oBAAD;;;;wBAAqB;;4BAAME,QAAQkB,IAAI;gCAAE/B;gCAAYwB;;;;wBAAhC;;;wBACzB,MAAMM,EAAE;;;;;;;QAEZ;wBATcH,OAAYC;;;;AAU5B;AAEA;;;;;;;;CAQC,GACD,IAAM1B,yBAAyB,SAC7BwB,eACsC;IACtC,OAAO,SAACC,OAAYC,SAAcI,UAAqC;QACrE,IAAMC,eAAe,SAACC,OAAYL,QAAsB;YACtDG,SAASE,OAAOL;YAChB,IAAI,CAAClB,oBAAoBW;QAC3B;QACAI,cAAcC,OAAOC,SAASK;IAChC;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@beforeyoubid/logger-adapter",
-  "version": "1.0.12",
-  "description": "A platform logger module to send the log messages to LogDNA.",
+  "version": "2.0.1",
+  "description": "A platform logger module to send the log messages to Mezmo (formerly LogDNA).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -34,9 +34,9 @@
   },
   "homepage": "https://github.com/beforeyoubid/npm-logger-adapter#readme",
   "dependencies": {
-    "logdna": "3.5.3",
-    "logdna-winston": "^2.3.2",
-    "winston": "3.8.2"
+    "@logdna/logger": "^2.6.9",
+    "winston": "^3.13.0",
+    "winston-transport": "^4.7.0"
   },
   "devDependencies": {
     "@swc/cli": "0.1.61",
@@ -51,7 +51,7 @@
     "eslint": "8.34.0",
     "eslint-config-prettier": "8.6.0",
     "eslint-plugin-prettier": "4.2.1",
-    "jest": "29.4.2",
+    "jest": "^29.7.0",
     "jest-junit": "15.0.0",
     "prettier": "2.8.4",
     "rimraf": "^4.1.2",

package/dist/console/logger.d.ts

@@ -1,4 +0,0 @@
-import { ILogDNAParams } from '../types';
-declare const getLogger: (params: ILogDNAParams) => any;
-declare const getDefaultConsoleLog: () => any;
-export { getLogger, getDefaultConsoleLog };

package/dist/console/logger.js

@@ -1,108 +0,0 @@
-"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, {
-    getLogger: function() {
-        return getLogger;
-    },
-    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);
-}
-var LogDNALogger = require("logdna");
-var flushAll = require("../util").flushAll;
-var logger;
-// Default console
-var _log = console.log;
-var _info = console.info;
-var _warn = console.warn;
-var _error = console.error;
-var wrapConsole = function(logger, logLevel) {
-    _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") {
-            logger.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) {
-            logger.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];
-        }
-        logger.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];
-        }
-        logger.error(_toConsumableArray(args).join(" "));
-        _error.apply(void 0, _toConsumableArray(args));
-    };
-    console.log = log;
-    console.debug = log;
-    console.info = info;
-    console.warn = warn;
-    console.error = error;
-};
-var getLogger = function(params) {
-    var logDNAKey = params.logDNAKey, logLevel = params.logLevel, logDNAOptions = params.logDNAOptions;
-    logger = LogDNALogger.setupDefaultLogger(logDNAKey, logDNAOptions);
-    // Wrap default
-    wrapConsole(logger, logLevel);
-    // Attach flushAll
-    logger.flushAll = flushAll;
-    return logger;
-};
-var getDefaultConsoleLog = function() {
-    return _log;
-};
-
-//# sourceMappingURL=data:application/json;base64,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