@beforeyoubid/logger-adapter 1.0.11 → 2.0.0

package/dist/src/transports/logdnaWinston.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LogDNATransport", {
+    enumerable: true,
+    get: function() {
+        return LogDNATransport;
+    }
+});
+var _winstontransport = /*#__PURE__*/ _interop_require_default(require("winston-transport"));
+var _logger = require("@logdna/logger");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(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) _set_prototype_of(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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(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) {
+            _define_property(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 _object_spread_props(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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(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 _object_without_properties_loose(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 _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    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 _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var LogDNATransport = /*#__PURE__*/ function(Transport) {
+    "use strict";
+    _inherits(LogDNATransport, Transport);
+    var _super = _create_super(LogDNATransport);
+    function LogDNATransport(options, suppliedLogdnaClient) {
+        _class_call_check(this, LogDNATransport);
+        var _this;
+        var levels = options.levels, maxLevel = options.maxLevel, key = options.key, opts = _object_without_properties(options, [
+            "levels",
+            "maxLevel",
+            "key"
+        ]);
+        _this = _super.call(this, _object_spread_props(_object_spread({}, opts), {
+            levels: levels,
+            level: maxLevel
+        }));
+        _define_property(_assert_this_initialized(_this), "logger", void 0);
+        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, _object_spread_props(_object_spread({}, opts), {
+            levels: Object.keys(custom_levels),
+            UserAgent: 'byb-logger-adapter'
+        }));
+        return _this;
+    }
+    _create_class(LogDNATransport, [
+        {
+            /**
+   * Winston Transport will call this log function
+   * @param info
+   * @param callback
+   * @returns
+   */ key: "log",
+            value: 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 = _object_without_properties(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/src/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/src/util.js

@@ -0,0 +1,328 @@
+"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, {
+    ensureFlushAll: function() {
+        return ensureFlushAll;
+    },
+    ensureFlushAllCallback: function() {
+        return ensureFlushAllCallback;
+    },
+    flushAll: function() {
+        return flushAll;
+    },
+    isLogDNAEnabled: function() {
+        return isLogDNAEnabled;
+    }
+});
+var _logdnaClient = require("./logger/logdnaClient");
+var _events = require("events");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+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 = null;
+/**
+ * Handy function to check if we are sending to LogDNA
+ * @param logDNAKey
+ * @param sendToRemote
+ */ var isLogDNAEnabled = function(logDNAKey, sendToRemote) {
+    return !!logDNAKey && sendToRemote;
+};
+/**
+ * REturn if we need to suppress flushAll on a local machine
+ */ var suppressFlushAll = function() {
+    var _getLogParams;
+    return ((_getLogParams = getLogParams()) === null || _getLogParams === void 0 ? void 0 : _getLogParams.logDNASuppressFlushAll) || false;
+};
+/**
+ * Send all log messages to LogDNA before lambda is terminated
+ * Support an async function
+ */ var flushAll = function() {
+    var _ref = _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            return [
+                2,
+                new Promise(function() {
+                    var _ref = _async_to_generator(function(resolve) {
+                        var logger, before;
+                        return _ts_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);
+                    };
+                }())
+            ];
+        });
+    });
+    return function flushAll() {
+        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() {
+    return new Promise(function(resolve) {
+        timeout = setTimeout(function() {
+            debug('Flushing timeout has reached. Ignore flushing messages...');
+            resolve();
+        }, FALLBACK_TIMEOUT_AFTER_FLUSHING);
+    });
+};
+/**
+ * Lambda wrapper to ensure we flush messages before returning the response
+ * @param lambdaHandler
+ */ var ensureFlushAll = function(lambdaHandler) {
+    return function() {
+        var _ref = _async_to_generator(function(event, context) {
+            var result, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            4,
+                            ,
+                            7
+                        ]);
+                        return [
+                            4,
+                            lambdaHandler(event, context)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        if (!!suppressFlushAll()) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            Promise.race([
+                                flushAll(),
+                                timeoutPromise()
+                            ])
+                        ];
+                    case 2:
+                        _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            2,
+                            result
+                        ];
+                    case 4:
+                        e = _state.sent();
+                        if (!!suppressFlushAll()) return [
+                            3,
+                            6
+                        ];
+                        return [
+                            4,
+                            Promise.race([
+                                flushAll(),
+                                timeoutPromise()
+                            ])
+                        ];
+                    case 5:
+                        _state.sent();
+                        _state.label = 6;
+                    case 6:
+                        throw e;
+                    case 7:
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function(event, context) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};
+/**
+ * A Lambda wrapper to ensure we flush messages before a Lambda function get terminated
+ * NOTE: For non-async handlers, AWS Lambda will wait until the event loop is completed.
+ * This means after a callback function is called, a Lambda function still run
+ * and we can catch the final clean up.
+ * REF: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html
+ *
+ * @param lambdaHandler
+ */ var ensureFlushAllCallback = function(lambdaHandler) {
+    return function(event, context, callback) {
+        var thisCallback = function(error, result) {
+            callback(error, result);
+            if (!suppressFlushAll()) flushAllCallback();
+        };
+        lambdaHandler(event, context, thisCallback);
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,13 +1,13 @@
-export declare type EmptyCBFunction = () => void;
-export declare type CallbackFunction = (err: any, data: any) => void;
-export declare type LambdaHandlerWithAsyncFunction = (event: any, context: any) => Promise<any>;
-export declare type LambdaHandlerWithCallbackFunction = (event: any, context: any, fn: CallbackFunction) => void;
+export type EmptyCBFunction = () => void;
+export type CallbackFunction = (err: any, data: any) => void;
+export type LambdaHandlerWithAsyncFunction = (event: any, context: any) => Promise<any>;
+export type LambdaHandlerWithCallbackFunction = (event: any, context: any, fn: CallbackFunction) => void;
 export interface ILogDNALogOptions {
     key: string;
     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>;
 /**