@beforeyoubid/logger-adapter 2.0.2 → 2.0.4

package/README.md

@@ -51,6 +51,8 @@ can also helps you out as well.
   - 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)
+- **v2.0.3 onwards**
+  - Adding generic `MetricLogger`
 
 ## 1) Use Console Logger
 
@@ -165,7 +167,7 @@ module so they look like this. ![Log prefix](./docs/log-prefix.png)
 ```
   import { getLoggerObject } from '@beforeyoubid/logger-adapter';
 
-  const logger = getLoggerObject('[CoreLogicListingProvider]');
+  const logger = getLoggerObject('[Your Custom Prefix]');
 
   logger.info('the usual log string...')
 ```
@@ -173,3 +175,26 @@ module so they look like this. ![Log prefix](./docs/log-prefix.png)
 **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.
+
+## MetricLogger
+
+**Motivation:**
+
+- Mezmo is one of the leading telemetry tools for logging and debugging
+- We can also utilise Mezmo to collect, process and display business metrics based on log messages without extra fee on
+  the existing plan
+- The setup is very simple and Mezmo does this out of the box
+
+**How does it work?**
+
+- When a JSON string (e.g. `JSON.stringify(jsonObject)`) is sent to Mezmo, Mezmo is smart enough to parse this into a
+  json object and index them automatically
+- With this process, we can search for any value in the object and/or create a dashboard on any specific metric we see
+  fit
+- The only drawback, the data retention is usually limited to 30 days as per the data retention policy on the account
+
+**How to use:**
+
+- [Sample Metric](./samples/metricLogger.md)
+- [Sample 1](./samples/metricLogger1.sample.ts)
+- [Sample 2](./samples/metricLogger2.sample.ts)

package/dist/MetricLogger/__tests__/index.spec.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var _index = require("../index");
+var _logger = require("../../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 _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("../../logger", function() {
+    return {
+        logger: {
+            info: jest.fn()
+        }
+    };
+});
+describe("MetricLogger", function() {
+    var defaultMetric = {
+        req: {
+            type: "myType",
+            userId: "my-user-id"
+        },
+        res: {
+            isSuccessful: true,
+            errorCode: "",
+            count: 10
+        }
+    };
+    describe("setMetric() - extended metric type", function() {
+        it("should set metric property", function() {
+            var metricLogger = new _index.MetricLogger(defaultMetric, true, _logger.logger);
+            var expectedUserId = "another-user-id";
+            var expectedResult = _objectSpreadProps(_objectSpread({}, defaultMetric), {
+                req: _objectSpreadProps(_objectSpread({}, defaultMetric.req), {
+                    userId: expectedUserId
+                })
+            });
+            metricLogger.setMetric("req.userId", expectedUserId);
+            var result = metricLogger.getMetric();
+            expect(result.req.userId).toEqual(expectedUserId);
+            expect(result).toEqual(expectedResult);
+        });
+        it("should allow to set metrics", function() {
+            var metricLogger = new _index.MetricLogger(defaultMetric, true, _logger.logger);
+            var expectedUserId = "another-user-id";
+            var newCount = 20;
+            var expectedResult = {
+                req: _objectSpreadProps(_objectSpread({}, defaultMetric.req), {
+                    userId: expectedUserId
+                }),
+                res: _objectSpreadProps(_objectSpread({}, defaultMetric.res), {
+                    count: newCount
+                })
+            };
+            metricLogger.setMetric("req.userId", expectedUserId);
+            metricLogger.setMetric("res.count", newCount);
+            var result = metricLogger.getMetric();
+            expect(result.req.userId).toEqual(expectedUserId);
+            expect(result).toEqual(expectedResult);
+        });
+        it("should allow to set custom multi-layer metrics", function() {
+            var nestedDefaultMetric = _objectSpreadProps(_objectSpread({}, defaultMetric), {
+                res: _objectSpreadProps(_objectSpread({}, defaultMetric.res), {
+                    customObject: {
+                        someKey: "some-key",
+                        someValue: "some-value"
+                    }
+                })
+            });
+            var metricLogger = new _index.MetricLogger(nestedDefaultMetric, true, _logger.logger);
+            var expectedSomeKey = "new-key";
+            var expectedSomeValue = "new-value";
+            var expectedResult = _objectSpreadProps(_objectSpread({}, nestedDefaultMetric), {
+                res: _objectSpreadProps(_objectSpread({}, defaultMetric.res), {
+                    customObject: {
+                        someKey: expectedSomeKey,
+                        someValue: expectedSomeValue
+                    }
+                })
+            });
+            metricLogger.setMetric("res.customObject.someKey", expectedSomeKey);
+            metricLogger.setMetric("res.customObject.someValue", expectedSomeValue);
+            var result = metricLogger.getMetric();
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe("setMetric() - custom metric type", function() {
+        it("should be able to handle custom metric", function() {
+            var myDefaultMetric = {
+                productType: "myType",
+                count: 10
+            };
+            var metricLogger = new _index.MetricLogger(myDefaultMetric, true, _logger.logger);
+            var expectedProductType = "anotherType";
+            var expectedCount = 100;
+            metricLogger.setMetric("productType", expectedProductType);
+            metricLogger.setMetric("count", expectedCount);
+            var result = metricLogger.getMetric();
+            expect(result.productType).toEqual(expectedProductType);
+            expect(result.count).toEqual(expectedCount);
+        });
+    });
+    describe("success()", function() {
+        it("should set success response", function() {
+            var metricLogger = new _index.MetricLogger(defaultMetric, true, _logger.logger);
+            var expectedUserId = "another-user-id";
+            var expectedResult = _objectSpreadProps(_objectSpread({}, defaultMetric), {
+                req: _objectSpreadProps(_objectSpread({}, defaultMetric.req), {
+                    userId: expectedUserId,
+                    isSuccessful: true,
+                    errorCode: ""
+                })
+            });
+            metricLogger.setMetric("req.userId", expectedUserId);
+            var result = metricLogger.getMetric();
+            expect(result.req.userId).toEqual(expectedUserId);
+            expect(result.res.isSuccessful).toEqual(expectedResult.res.isSuccessful);
+            expect(result.res.errorCode).toEqual(expectedResult.res.errorCode);
+        });
+    });
+    describe("error()", function() {
+        it("should set error response", function() {
+            var metricLogger = new _index.MetricLogger(defaultMetric, true, _logger.logger);
+            var expectedUserId = "another-user-id";
+            var expectedResult = {
+                req: _objectSpreadProps(_objectSpread({}, defaultMetric.req), {
+                    userId: expectedUserId
+                }),
+                res: _objectSpreadProps(_objectSpread({}, defaultMetric.res), {
+                    isSuccessful: false,
+                    errorCode: "some-error-code"
+                })
+            };
+            metricLogger.error("some-error-code");
+            metricLogger.setMetric("res.isSuccessful", false);
+            var result = metricLogger.getMetric();
+            expect(result.req.userId).toEqual(expectedUserId);
+            expect(result.res.isSuccessful).toEqual(expectedResult.res.isSuccessful);
+            expect(result.res.errorCode).toEqual(expectedResult.res.errorCode);
+        });
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/MetricLogger/__tests__/index.spec.ts"],"sourcesContent":["import { MetricLogger } from '../index';\nimport type { BasicMetric, BasicMetricReq, BasicMetricRes } from '../types';\nimport { logger } from '../../logger';\njest.mock('../../logger', () => ({\n  logger: {\n    info: jest.fn(),\n  },\n}));\n\ntype MyReqMetric = BasicMetricReq & {\n  userId: string;\n};\n\ntype MyResMetric = BasicMetricRes & {\n  count: number;\n};\n\ntype MyMetric = BasicMetric & {\n  req: MyReqMetric;\n  res: MyResMetric;\n};\n\ntype MyCustomMetric = {\n  productType: string;\n  count: number;\n};\n\ndescribe('MetricLogger', () => {\n  const defaultMetric = {\n    req: { type: 'myType', userId: 'my-user-id' },\n    res: { isSuccessful: true, errorCode: '', count: 10 },\n  };\n  describe('setMetric() - extended metric type', () => {\n    it('should set metric property', () => {\n      const metricLogger = new MetricLogger<MyMetric>(defaultMetric, true, logger);\n\n      const expectedUserId = 'another-user-id';\n      const expectedResult = {\n        ...defaultMetric,\n        req: { ...defaultMetric.req, userId: expectedUserId },\n      };\n      metricLogger.setMetric('req.userId', expectedUserId);\n      const result = metricLogger.getMetric();\n      expect(result.req.userId).toEqual(expectedUserId);\n      expect(result).toEqual(expectedResult);\n    });\n\n    it('should allow to set metrics', () => {\n      const metricLogger = new MetricLogger<MyMetric>(defaultMetric, true, logger);\n\n      const expectedUserId = 'another-user-id';\n      const newCount = 20;\n      const expectedResult = {\n        req: { ...defaultMetric.req, userId: expectedUserId },\n        res: { ...defaultMetric.res, count: newCount },\n      };\n      metricLogger.setMetric('req.userId', expectedUserId);\n      metricLogger.setMetric('res.count', newCount);\n      const result = metricLogger.getMetric();\n      expect(result.req.userId).toEqual(expectedUserId);\n      expect(result).toEqual(expectedResult);\n    });\n\n    it('should allow to set custom multi-layer metrics', () => {\n      type MyMetricNestedLayer = MyMetric & {\n        res: MyResMetric & {\n          customObject: {\n            someKey: string;\n            someValue: string;\n          };\n        };\n      };\n      const nestedDefaultMetric = {\n        ...defaultMetric,\n        res: {\n          ...defaultMetric.res,\n          customObject: {\n            someKey: 'some-key',\n            someValue: 'some-value',\n          },\n        },\n      };\n      const metricLogger = new MetricLogger<MyMetricNestedLayer>(nestedDefaultMetric, true, logger);\n      const expectedSomeKey = 'new-key';\n      const expectedSomeValue = 'new-value';\n      const expectedResult = {\n        ...nestedDefaultMetric,\n        res: {\n          ...defaultMetric.res,\n          customObject: {\n            someKey: expectedSomeKey,\n            someValue: expectedSomeValue,\n          },\n        },\n      };\n      metricLogger.setMetric('res.customObject.someKey', expectedSomeKey);\n      metricLogger.setMetric('res.customObject.someValue', expectedSomeValue);\n      const result = metricLogger.getMetric();\n      expect(result).toEqual(expectedResult);\n    });\n  });\n\n  describe('setMetric() - custom metric type', () => {\n    it('should be able to handle custom metric', () => {\n      const myDefaultMetric = {\n        productType: 'myType',\n        count: 10,\n      };\n      const metricLogger = new MetricLogger<MyCustomMetric>(myDefaultMetric, true, logger);\n      const expectedProductType = 'anotherType';\n      const expectedCount = 100;\n      metricLogger.setMetric('productType', expectedProductType);\n      metricLogger.setMetric('count', expectedCount);\n      const result = metricLogger.getMetric();\n      expect(result.productType).toEqual(expectedProductType);\n      expect(result.count).toEqual(expectedCount);\n    });\n  });\n\n  describe('success()', () => {\n    it('should set success response', () => {\n      const metricLogger = new MetricLogger<MyMetric>(defaultMetric, true, logger);\n\n      const expectedUserId = 'another-user-id';\n      const expectedResult = {\n        ...defaultMetric,\n        req: { ...defaultMetric.req, userId: expectedUserId, isSuccessful: true, errorCode: '' },\n      };\n      metricLogger.setMetric('req.userId', expectedUserId);\n      const result = metricLogger.getMetric();\n      expect(result.req.userId).toEqual(expectedUserId);\n      expect(result.res.isSuccessful).toEqual(expectedResult.res.isSuccessful);\n      expect(result.res.errorCode).toEqual(expectedResult.res.errorCode);\n    });\n  });\n\n  describe('error()', () => {\n    it('should set error response', () => {\n      const metricLogger = new MetricLogger<MyMetric>(defaultMetric, true, logger);\n\n      const expectedUserId = 'another-user-id';\n      const expectedResult = {\n        req: { ...defaultMetric.req, userId: expectedUserId },\n        res: { ...defaultMetric.res, isSuccessful: false, errorCode: 'some-error-code' },\n      };\n      metricLogger.error('some-error-code');\n      metricLogger.setMetric('res.isSuccessful', false);\n      const result = metricLogger.getMetric();\n      expect(result.req.userId).toEqual(expectedUserId);\n      expect(result.res.isSuccessful).toEqual(expectedResult.res.isSuccessful);\n      expect(result.res.errorCode).toEqual(expectedResult.res.errorCode);\n    });\n  });\n});\n"],"names":["jest","mock","logger","info","fn","describe","defaultMetric","req","type","userId","res","isSuccessful","errorCode","count","it","metricLogger","MetricLogger","expectedUserId","expectedResult","setMetric","result","getMetric","expect","toEqual","newCount","nestedDefaultMetric","customObject","someKey","someValue","expectedSomeKey","expectedSomeValue","myDefaultMetric","productType","expectedProductType","expectedCount","error"],"mappings":"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"}

package/dist/MetricLogger/index.d.ts

@@ -0,0 +1,34 @@
+import winston from 'winston';
+export declare class MetricLogger<T> {
+    private readonly defaultMetric;
+    private _logger;
+    private _metric;
+    private _isTest;
+    constructor(defaultMetric?: T, _isTest?: boolean, suppliedLogger?: winston.Logger);
+    getMetric(): T;
+    /**
+     * Trigger to send log message over the supplied logger object
+     * @param metric
+     * @param stringifyMetric
+     */
+    sendMetric(metric: T, stringifyMetric?: boolean): void;
+    /**
+     * Dynamically set the metric, support the dot notation e.g. `setMetric('res.isSuccess', true)`
+     * @param key
+     * @param value
+     */
+    setMetric(key: string, value: unknown): void;
+    /**
+     * Capture the success
+     * @param cachedResponse
+     * @returns
+     */
+    success(): void;
+    /**
+     * A handy function to capture the error
+     * @param errorCode
+     * @param errorField
+     * @returns
+     */
+    error(errorCode?: string, errorField?: string): void;
+}

package/dist/MetricLogger/index.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MetricLogger", {
+    enumerable: true,
+    get: function() {
+        return MetricLogger;
+    }
+});
+var _logger = require("../logger");
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+var MetricLogger = /*#__PURE__*/ function() {
+    "use strict";
+    function MetricLogger() {
+        var defaultMetric = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _isTest = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, suppliedLogger = arguments.length > 2 ? arguments[2] : void 0;
+        _classCallCheck(this, MetricLogger);
+        this.defaultMetric = defaultMetric;
+        this._metric = defaultMetric;
+        this._isTest = _isTest;
+        this._logger = suppliedLogger || _logger.logger;
+    }
+    var _proto = MetricLogger.prototype;
+    _proto.getMetric = function getMetric() {
+        return this._metric;
+    };
+    /**
+   * Trigger to send log message over the supplied logger object
+   * @param metric
+   * @param stringifyMetric
+   */ _proto.sendMetric = function sendMetric(metric) {
+        var stringifyMetric = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+        if (!this._isTest) {
+            var metricToSend = stringifyMetric ? JSON.stringify(metric) : metric;
+            this._logger.info(metricToSend);
+        }
+    };
+    /**
+   * Dynamically set the metric, support the dot notation e.g. `setMetric('res.isSuccess', true)`
+   * @param key
+   * @param value
+   */ _proto.setMetric = function setMetric(key, value) {
+        var keys = key.split(".");
+        var parentObject = this._metric;
+        for(var i = 0; i < keys.length; i++){
+            var leafNode = i === keys.length - 1;
+            var objectExists = _typeof(parentObject[keys[i]]) !== undefined;
+            // If not a leaf node and the object does not exist, set parent object so we can keep traversing through themn
+            if (objectExists && !leafNode) {
+                parentObject = parentObject[keys[i]];
+            }
+            if (leafNode) {
+                parentObject[keys[i]] = value;
+                break;
+            }
+        }
+    };
+    /**
+   * Capture the success
+   * @param cachedResponse
+   * @returns
+   */ _proto.success = function success() {
+        return this.sendMetric(this.getMetric());
+    };
+    /**
+   * A handy function to capture the error
+   * @param errorCode
+   * @param errorField
+   * @returns
+   */ _proto.error = function error() {
+        var errorCode = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", errorField = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "res.errorCode";
+        if (errorField) {
+            this.setMetric(errorField, errorCode);
+        }
+        return this.sendMetric(this.getMetric());
+    };
+    return MetricLogger;
+}();
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/MetricLogger/types.d.ts

@@ -0,0 +1,12 @@
+export type BasicRecord = Record<string, unknown>;
+export type BasicMetricReq = BasicRecord & {
+    type: string;
+};
+export type BasicMetricRes = BasicRecord & {
+    isSuccessful: boolean;
+    errorCode: string;
+};
+export type BasicMetric = {
+    req: BasicMetricReq;
+    res: BasicMetricRes;
+};

package/dist/MetricLogger/types.js

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

package/dist/index.d.ts

@@ -3,4 +3,5 @@ import { logger } from './logger';
 import { getLoggerObject } from './logger/util';
 import { getLogParams } from './params';
 import { flushAll, ensureFlushAll, ensureFlushAllCallback } from './util';
-export { consoleLogger, logger, getLoggerObject, getLogParams, flushAll, ensureFlushAll, ensureFlushAllCallback };
+import { MetricLogger } from './MetricLogger';
+export { consoleLogger, logger, getLoggerObject, getLogParams, flushAll, ensureFlushAll, ensureFlushAllCallback, MetricLogger, };

package/dist/index.js

@@ -29,6 +29,9 @@ _export(exports, {
     },
     ensureFlushAllCallback: function() {
         return _util1.ensureFlushAllCallback;
+    },
+    MetricLogger: function() {
+        return _metricLogger.MetricLogger;
     }
 });
 var _console = require("./console");
@@ -36,5 +39,6 @@ var _logger = require("./logger");
 var _util = require("./logger/util");
 var _params = require("./params");
 var _util1 = require("./util");
+var _metricLogger = require("./MetricLogger");
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb25zb2xlTG9nZ2VyIH0gZnJvbSAnLi9jb25zb2xlJztcbmltcG9ydCB7IGxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcbmltcG9ydCB7IGdldExvZ2dlck9iamVjdCB9IGZyb20gJy4vbG9nZ2VyL3V0aWwnO1xuaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi9wYXJhbXMnO1xuaW1wb3J0IHsgZmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsLCBlbnN1cmVGbHVzaEFsbENhbGxiYWNrIH0gZnJvbSAnLi91dGlsJztcblxuLy8gRXhwb3J0IGFsbCB0aGUgZnVuY3Rpb25zXG5leHBvcnQgeyBjb25zb2xlTG9nZ2VyLCBsb2dnZXIsIGdldExvZ2dlck9iamVjdCwgZ2V0TG9nUGFyYW1zLCBmbHVzaEFsbCwgZW5zdXJlRmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsQ2FsbGJhY2sgfTtcbiJdLCJuYW1lcyI6WyJjb25zb2xlTG9nZ2VyIiwibG9nZ2VyIiwiZ2V0TG9nZ2VyT2JqZWN0IiwiZ2V0TG9nUGFyYW1zIiwiZmx1c2hBbGwiLCJlbnN1cmVGbHVzaEFsbCIsImVuc3VyZUZsdXNoQWxsQ2FsbGJhY2siXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0lBT1NBLGFBQWE7ZUFBYkEsc0JBQWE7O0lBQUVDLE1BQU07ZUFBTkEsY0FBTTs7SUFBRUMsZUFBZTtlQUFmQSxxQkFBZTs7SUFBRUMsWUFBWTtlQUFaQSxvQkFBWTs7SUFBRUMsUUFBUTtlQUFSQSxlQUFROztJQUFFQyxjQUFjO2VBQWRBLHFCQUFjOztJQUFFQyxzQkFBc0I7ZUFBdEJBLDZCQUFzQjs7O3VCQVBqRjtzQkFDUDtvQkFDUztzQkFDSDtxQkFDb0MifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb25zb2xlTG9nZ2VyIH0gZnJvbSAnLi9jb25zb2xlJztcbmltcG9ydCB7IGxvZ2dlciB9IGZyb20gJy4vbG9nZ2VyJztcbmltcG9ydCB7IGdldExvZ2dlck9iamVjdCB9IGZyb20gJy4vbG9nZ2VyL3V0aWwnO1xuaW1wb3J0IHsgZ2V0TG9nUGFyYW1zIH0gZnJvbSAnLi9wYXJhbXMnO1xuaW1wb3J0IHsgZmx1c2hBbGwsIGVuc3VyZUZsdXNoQWxsLCBlbnN1cmVGbHVzaEFsbENhbGxiYWNrIH0gZnJvbSAnLi91dGlsJztcbmltcG9ydCB7IE1ldHJpY0xvZ2dlciB9IGZyb20gJy4vTWV0cmljTG9nZ2VyJztcblxuLy8gRXhwb3J0IGFsbCB0aGUgZnVuY3Rpb25zXG5leHBvcnQge1xuICBjb25zb2xlTG9nZ2VyLFxuICBsb2dnZXIsXG4gIGdldExvZ2dlck9iamVjdCxcbiAgZ2V0TG9nUGFyYW1zLFxuICBmbHVzaEFsbCxcbiAgZW5zdXJlRmx1c2hBbGwsXG4gIGVuc3VyZUZsdXNoQWxsQ2FsbGJhY2ssXG4gIE1ldHJpY0xvZ2dlcixcbn07XG4iXSwibmFtZXMiOlsiY29uc29sZUxvZ2dlciIsImxvZ2dlciIsImdldExvZ2dlck9iamVjdCIsImdldExvZ1BhcmFtcyIsImZsdXNoQWxsIiwiZW5zdXJlRmx1c2hBbGwiLCJlbnN1cmVGbHVzaEFsbENhbGxiYWNrIiwiTWV0cmljTG9nZ2VyIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQVNFQSxhQUFhO2VBQWJBLHNCQUFhOztJQUNiQyxNQUFNO2VBQU5BLGNBQU07O0lBQ05DLGVBQWU7ZUFBZkEscUJBQWU7O0lBQ2ZDLFlBQVk7ZUFBWkEsb0JBQVk7O0lBQ1pDLFFBQVE7ZUFBUkEsZUFBUTs7SUFDUkMsY0FBYztlQUFkQSxxQkFBYzs7SUFDZEMsc0JBQXNCO2VBQXRCQSw2QkFBc0I7O0lBQ3RCQyxZQUFZO2VBQVpBLDBCQUFZOzs7dUJBaEJnQjtzQkFDUDtvQkFDUztzQkFDSDtxQkFDb0M7NEJBQ3BDIn0=

package/dist/transports/logdnaWinston.js

@@ -245,4 +245,4 @@ var LogDNATransport = /*#__PURE__*/ function(Transport) {
     return LogDNATransport;
 }(_winstonTransport.default);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beforeyoubid/logger-adapter",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "A platform logger module to send the log messages to Mezmo (formerly LogDNA).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",