@beforeyoubid/logger-adapter 2.0.1 → 2.0.3

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.sample.ts)
+- [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":";;;;qBAA6B;sBAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACvBA,KAAKC,IAAI,CAAC,gBAAgB;WAAO;QAC/BC,QAAQ;YACNC,MAAMH,KAAKI,EAAE;QACf;IACF;;AAoBAC,SAAS,gBAAgB,WAAM;IAC7B,IAAMC,gBAAgB;QACpBC,KAAK;YAAEC,MAAM;YAAUC,QAAQ;QAAa;QAC5CC,KAAK;YAAEC,cAAc,IAAI;YAAEC,WAAW;YAAIC,OAAO;QAAG;IACtD;IACAR,SAAS,sCAAsC,WAAM;QACnDS,GAAG,8BAA8B,WAAM;YACrC,IAAMC,eAAe,IAAIC,mBAAY,CAAWV,eAAe,IAAI,EAAEJ,cAAM;YAE3E,IAAMe,iBAAiB;YACvB,IAAMC,iBAAiB,qCAClBZ;gBACHC,KAAK,qCAAKD,cAAcC,GAAG;oBAAEE,QAAQQ;;;YAEvCF,aAAaI,SAAS,CAAC,cAAcF;YACrC,IAAMG,SAASL,aAAaM,SAAS;YACrCC,OAAOF,OAAOb,GAAG,CAACE,MAAM,EAAEc,OAAO,CAACN;YAClCK,OAAOF,QAAQG,OAAO,CAACL;QACzB;QAEAJ,GAAG,+BAA+B,WAAM;YACtC,IAAMC,eAAe,IAAIC,mBAAY,CAAWV,eAAe,IAAI,EAAEJ,cAAM;YAE3E,IAAMe,iBAAiB;YACvB,IAAMO,WAAW;YACjB,IAAMN,iBAAiB;gBACrBX,KAAK,qCAAKD,cAAcC,GAAG;oBAAEE,QAAQQ;;gBACrCP,KAAK,qCAAKJ,cAAcI,GAAG;oBAAEG,OAAOW;;YACtC;YACAT,aAAaI,SAAS,CAAC,cAAcF;YACrCF,aAAaI,SAAS,CAAC,aAAaK;YACpC,IAAMJ,SAASL,aAAaM,SAAS;YACrCC,OAAOF,OAAOb,GAAG,CAACE,MAAM,EAAEc,OAAO,CAACN;YAClCK,OAAOF,QAAQG,OAAO,CAACL;QACzB;QAEAJ,GAAG,kDAAkD,WAAM;YASzD,IAAMW,sBAAsB,qCACvBnB;gBACHI,KAAK,qCACAJ,cAAcI,GAAG;oBACpBgB,cAAc;wBACZC,SAAS;wBACTC,WAAW;oBACb;;;YAGJ,IAAMb,eAAe,IAAIC,mBAAY,CAAsBS,qBAAqB,IAAI,EAAEvB,cAAM;YAC5F,IAAM2B,kBAAkB;YACxB,IAAMC,oBAAoB;YAC1B,IAAMZ,iBAAiB,qCAClBO;gBACHf,KAAK,qCACAJ,cAAcI,GAAG;oBACpBgB,cAAc;wBACZC,SAASE;wBACTD,WAAWE;oBACb;;;YAGJf,aAAaI,SAAS,CAAC,4BAA4BU;YACnDd,aAAaI,SAAS,CAAC,8BAA8BW;YACrD,IAAMV,SAASL,aAAaM,SAAS;YACrCC,OAAOF,QAAQG,OAAO,CAACL;QACzB;IACF;IAEAb,SAAS,oCAAoC,WAAM;QACjDS,GAAG,0CAA0C,WAAM;YACjD,IAAMiB,kBAAkB;gBACtBC,aAAa;gBACbnB,OAAO;YACT;YACA,IAAME,eAAe,IAAIC,mBAAY,CAAiBe,iBAAiB,IAAI,EAAE7B,cAAM;YACnF,IAAM+B,sBAAsB;YAC5B,IAAMC,gBAAgB;YACtBnB,aAAaI,SAAS,CAAC,eAAec;YACtClB,aAAaI,SAAS,CAAC,SAASe;YAChC,IAAMd,SAASL,aAAaM,SAAS;YACrCC,OAAOF,OAAOY,WAAW,EAAET,OAAO,CAACU;YACnCX,OAAOF,OAAOP,KAAK,EAAEU,OAAO,CAACW;QAC/B;IACF;IAEA7B,SAAS,aAAa,WAAM;QAC1BS,GAAG,+BAA+B,WAAM;YACtC,IAAMC,eAAe,IAAIC,mBAAY,CAAWV,eAAe,IAAI,EAAEJ,cAAM;YAE3E,IAAMe,iBAAiB;YACvB,IAAMC,iBAAiB,qCAClBZ;gBACHC,KAAK,qCAAKD,cAAcC,GAAG;oBAAEE,QAAQQ;oBAAgBN,cAAc,IAAI;oBAAEC,WAAW;;;YAEtFG,aAAaI,SAAS,CAAC,cAAcF;YACrC,IAAMG,SAASL,aAAaM,SAAS;YACrCC,OAAOF,OAAOb,GAAG,CAACE,MAAM,EAAEc,OAAO,CAACN;YAClCK,OAAOF,OAAOV,GAAG,CAACC,YAAY,EAAEY,OAAO,CAACL,eAAeR,GAAG,CAACC,YAAY;YACvEW,OAAOF,OAAOV,GAAG,CAACE,SAAS,EAAEW,OAAO,CAACL,eAAeR,GAAG,CAACE,SAAS;QACnE;IACF;IAEAP,SAAS,WAAW,WAAM;QACxBS,GAAG,6BAA6B,WAAM;YACpC,IAAMC,eAAe,IAAIC,mBAAY,CAAWV,eAAe,IAAI,EAAEJ,cAAM;YAE3E,IAAMe,iBAAiB;YACvB,IAAMC,iBAAiB;gBACrBX,KAAK,qCAAKD,cAAcC,GAAG;oBAAEE,QAAQQ;;gBACrCP,KAAK,qCAAKJ,cAAcI,GAAG;oBAAEC,cAAc,KAAK;oBAAEC,WAAW;;YAC/D;YACAG,aAAaoB,KAAK,CAAC;YACnBpB,aAAaI,SAAS,CAAC,oBAAoB,KAAK;YAChD,IAAMC,SAASL,aAAaM,SAAS;YACrCC,OAAOF,OAAOb,GAAG,CAACE,MAAM,EAAEc,OAAO,CAACN;YAClCK,OAAOF,OAAOV,GAAG,CAACC,YAAY,EAAEY,OAAO,CAACL,eAAeR,GAAG,CAACC,YAAY;YACvEW,OAAOF,OAAOV,GAAG,CAACE,SAAS,EAAEW,OAAO,CAACL,eAAeR,GAAG,CAACE,SAAS;QACnE;IACF;AACF"}

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/logger/__tests__/logdnaClient.spec.js

@@ -61,6 +61,11 @@ jest.mock("@logdna/logger", function() {
         createLogger: jest.fn()
     });
 });
+jest.mock("../logdnaClient", function() {
+    return _objectSpreadProps(_objectSpread({}, jest.requireActual("../logdnaClient")), {
+        isClientAvailable: jest.fn()
+    });
+});
 describe("createLogDNAClient()", function() {
     var params = {
         logDNAKey: "key",
@@ -72,13 +77,12 @@ describe("createLogDNAClient()", function() {
         jest.restoreAllMocks();
     });
     it("should be able to load module", function() {
-        // Watch out - this module only perform the createLogger once, test module multiple times you need to manage
-        // logdnaClient singleton object
         _logger.createLogger.mockReturnValue("");
         (0, _logdnaClient.createLogDNAClient)(params);
         expect(_logger.createLogger).toHaveBeenCalledTimes(1);
     });
     it("should return the same object if get called multiple times", function() {
+        _logdnaClient.isClientAvailable.mockReturnValueOnce(false);
         _logger.createLogger.mockReturnValue(someClient);
         (0, _logdnaClient.createLogDNAClient)(params);
         // Call again, it should not call createLogger() again
@@ -87,4 +91,4 @@ describe("createLogDNAClient()", function() {
     });
 });
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/__tests__/util.spec.js

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

package/dist/logger/logdnaClient.d.ts

@@ -1,5 +1,10 @@
 import LogDNALogger from '@logdna/logger';
 import { type ILogDNAParams } from '../types';
+/**
+ * Handy utility to check if LogDNA client is available, also support unit test
+ * @returns
+ */
+export declare const isClientAvailable: () => boolean;
 /**
  * Create one single instance of LogDNA (Mezmo) client so it can be shared/used in two cases
  * 1) Use it with the console wrapper. We send anything from console.log(), console.info(), console.error()

package/dist/logger/logdnaClient.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    isClientAvailable: function() {
+        return isClientAvailable;
+    },
     createLogDNAClient: function() {
         return createLogDNAClient;
     },
@@ -22,10 +25,14 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
+var debug = require("util").debuglog("logger-adapter");
 // A singleton object in this module
 var logdnaClient;
+var isClientAvailable = function() {
+    return !!logdnaClient;
+};
 var createLogDNAClient = function(params) {
-    if (logdnaClient) return logdnaClient;
+    if (isClientAvailable()) return logdnaClient;
     var logDNAKey = params.logDNAKey, logDNAOptions = params.logDNAOptions;
     var env = logDNAOptions.env, app = logDNAOptions.app, tags = logDNAOptions.tags, level = logDNAOptions.level;
     var options = {
@@ -41,7 +48,10 @@ var createLogDNAClient = function(params) {
     return logdnaClient;
 };
 var getLogDNAClient = function() {
+    if (!isClientAvailable()) {
+        debug("LogDNA client is not created yet. Please call createLogDNAClient() first");
+    }
     return logdnaClient;
 };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sb2dnZXIvbG9nZG5hQ2xpZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBMb2dETkFMb2dnZXIsIHsgdHlwZSBDb25zdHJ1Y3Rvck9wdGlvbnMgfSBmcm9tICdAbG9nZG5hL2xvZ2dlcic7XG5pbXBvcnQgeyB0eXBlIElMb2dETkFQYXJhbXMgfSBmcm9tICcuLi90eXBlcyc7XG5cbi8vIEEgc2luZ2xldG9uIG9iamVjdCBpbiB0aGlzIG1vZHVsZVxubGV0IGxvZ2RuYUNsaWVudDogTG9nRE5BTG9nZ2VyLkxvZ2dlcjtcblxuLyoqXG4gKiBDcmVhdGUgb25lIHNpbmdsZSBpbnN0YW5jZSBvZiBMb2dETkEgKE1lem1vKSBjbGllbnQgc28gaXQgY2FuIGJlIHNoYXJlZC91c2VkIGluIHR3byBjYXNlc1xuICogMSkgVXNlIGl0IHdpdGggdGhlIGNvbnNvbGUgd3JhcHBlci4gV2Ugc2VuZCBhbnl0aGluZyBmcm9tIGNvbnNvbGUubG9nKCksIGNvbnNvbGUuaW5mbygpLCBjb25zb2xlLmVycm9yKClcbiAqICAgIHRvIExvZ0ROQSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eS4gQ29uc3VtZXIgY2FuIHVzZSB0aGlzIGJ5IGNhbGxpbmcgY29uc29sZUxvZ2dlci5pbml0KClcbiAqIDIpIFVzZSBpdCB3aXRoIGEgV2luc3RvbiBsb2dnZXIgYXMgcGFydCBvZiB0aGUgdHJhbnNwb3J0cyB0byBzZW5kIGxvZ3MgdG8gTG9nRE5BXG4gKlxuICogQmVmb3JlIGNhbGxpbmcgdGhpcyBmdW5jdGlvbiwgbWFrZSBzdXJlIHdlIGNoZWNrIGlmIExvZ0ROQSBpcyBlbmFibGVkIGJlZm9yZSBjcmVhdGluZyBpdFxuICpcbiAqIEBwYXJhbSBwYXJhbXNcbiAqIEByZXR1cm5zXG4gKi9cbmV4cG9ydCBjb25zdCBjcmVhdGVMb2dETkFDbGllbnQgPSAocGFyYW1zOiBJTG9nRE5BUGFyYW1zKTogTG9nRE5BTG9nZ2VyLkxvZ2dlciA9PiB7XG4gIGlmIChsb2dkbmFDbGllbnQpIHJldHVybiBsb2dkbmFDbGllbnQ7XG5cbiAgY29uc3QgeyBsb2dETkFLZXksIGxvZ0ROQU9wdGlvbnMgfSA9IHBhcmFtcztcbiAgY29uc3QgeyBlbnYsIGFwcCwgdGFncywgbGV2ZWwgfSA9IGxvZ0ROQU9wdGlvbnM7XG4gIGNvbnN0IG9wdGlvbnM6IENvbnN0cnVjdG9yT3B0aW9ucyA9IHtcbiAgICBlbnYsXG4gICAgYXBwLFxuICAgIGhvc3RuYW1lOiBlbnYsXG4gICAgaW5kZXhNZXRhOiB0cnVlLFxuICAgIHRhZ3MsXG4gICAgbGV2ZWwsXG4gIH07XG5cbiAgLy8gQ3JlYXRlIGEgbmV3IExvZ0ROQSBjbGllbnRcbiAgbG9nZG5hQ2xpZW50ID0gTG9nRE5BTG9nZ2VyLmNyZWF0ZUxvZ2dlcihsb2dETkFLZXksIG9wdGlvbnMpO1xuICByZXR1cm4gbG9nZG5hQ2xpZW50O1xufTtcblxuLyoqXG4gKiBSZXR1cm4gdGhlIHNpbmdsZXRvbiBpbnN0YW5jZSBvZiBMb2dETkEgY2xpZW50IGNyZWF0ZWQgYnkgY3JlYXRlTG9nRE5BQ2xpZW50KClcbiAqIEByZXR1cm5zXG4gKi9cbmV4cG9ydCBjb25zdCBnZXRMb2dETkFDbGllbnQgPSAoKTogTG9nRE5BTG9nZ2VyLkxvZ2dlciA9PiB7XG4gIHJldHVybiBsb2dkbmFDbGllbnQ7XG59O1xuIl0sIm5hbWVzIjpbImNyZWF0ZUxvZ0ROQUNsaWVudCIsImdldExvZ0ROQUNsaWVudCIsImxvZ2RuYUNsaWVudCIsInBhcmFtcyIsImxvZ0ROQUtleSIsImxvZ0ROQU9wdGlvbnMiLCJlbnYiLCJhcHAiLCJ0YWdzIiwibGV2ZWwiLCJvcHRpb25zIiwiaG9zdG5hbWUiLCJpbmRleE1ldGEiLCJMb2dETkFMb2dnZXIiLCJjcmVhdGVMb2dnZXIiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0lBaUJhQSxrQkFBa0I7ZUFBbEJBOztJQXVCQUMsZUFBZTtlQUFmQTs7OzJEQXhDeUM7Ozs7OztBQUd0RCxvQ0FBb0M7QUFDcEMsSUFBSUM7QUFhRyxJQUFNRixxQkFBcUIsU0FBQ0csUUFBK0M7SUFDaEYsSUFBSUQsY0FBYyxPQUFPQTtJQUV6QixJQUFRRSxZQUE2QkQsT0FBN0JDLFdBQVdDLGdCQUFrQkYsT0FBbEJFO0lBQ25CLElBQVFDLE1BQTBCRCxjQUExQkMsS0FBS0MsTUFBcUJGLGNBQXJCRSxLQUFLQyxPQUFnQkgsY0FBaEJHLE1BQU1DLFFBQVVKLGNBQVZJO0lBQ3hCLElBQU1DLFVBQThCO1FBQ2xDSixLQUFBQTtRQUNBQyxLQUFBQTtRQUNBSSxVQUFVTDtRQUNWTSxXQUFXLElBQUk7UUFDZkosTUFBQUE7UUFDQUMsT0FBQUE7SUFDRjtJQUVBLDZCQUE2QjtJQUM3QlAsZUFBZVcsZUFBWSxDQUFDQyxZQUFZLENBQUNWLFdBQVdNO0lBQ3BELE9BQU9SO0FBQ1Q7QUFNTyxJQUFNRCxrQkFBa0IsV0FBMkI7SUFDeEQsT0FBT0M7QUFDVCJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/logger.js

@@ -18,17 +18,16 @@ function _interopRequireDefault(obj) {
     };
 }
 var format = _winston.default.format, transports = _winston.default.transports;
+var formatFunction = function(info) {
+    return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
+};
 var createWinstonLogger = function(logLevel) {
     var logger = _winston.default.createLogger({
         level: logLevel || "info",
-        format: format.combine(format.timestamp(), format.simple(), format.printf(function(info) {
-            return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
-        })),
+        format: format.combine(format.timestamp(), format.simple(), format.printf(formatFunction)),
         transports: [
             new transports.Console({
-                format: format.combine(format.timestamp(), format.simple(), format.printf(function(info) {
-                    return "".concat(info.timestamp, " - ").concat(info.level, ": ").concat(info.message);
-                }), format.colorize({
+                format: format.combine(format.timestamp(), format.simple(), format.printf(formatFunction), format.colorize({
                     all: true
                 }))
             })
@@ -58,4 +57,4 @@ var createWinstonLogger = function(logLevel) {
     return logger;
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger/util.d.ts

@@ -1,11 +1,7 @@
+import { WrappedLogger } from '../types';
 /**
  * A utility command to return a logger with a prefix on log line.
  * @param prefix string
  */
-declare const getLoggerObject: (prefix?: string) => {
-    debug: (...args: unknown[]) => import("winston").Logger;
-    info: (...args: unknown[]) => import("winston").Logger;
-    warn: (...args: unknown[]) => import("winston").Logger;
-    error: (...args: unknown[]) => import("winston").Logger;
-};
+declare const getLoggerObject: (prefix?: string) => WrappedLogger;
 export { getLoggerObject };

package/dist/logger/util.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "getLoggerObject", {
     }
 });
 var _index = require("./index");
+var logFunctionsToWrap = [
+    "debug",
+    "info",
+    "warn",
+    "error"
+];
 var toString = function(args) {
     return args.map(function(arg) {
         return JSON.stringify(arg);
@@ -22,36 +28,34 @@ var getPrefix = function(prefix) {
  * @param prefix string
  */ var getLoggerObject = function() {
     var prefix = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
-    var debug = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
+    var wrappedLogger = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        var _loop = function() {
+            var functionName = _step.value;
+            wrappedLogger[functionName] = function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return _index.logger[functionName]("".concat(getPrefix(prefix)).concat(toString(args)));
+            };
+        };
+        for(var _iterator = logFunctionsToWrap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
-        return _index.logger.debug("".concat(getPrefix(prefix)).concat(toString(args)));
-    };
-    var info = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
-        }
-        return _index.logger.info("".concat(getPrefix(prefix)).concat(toString(args)));
-    };
-    var warn = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
-        }
-        return _index.logger.warn("".concat(getPrefix(prefix)).concat(toString(args)));
-    };
-    var error = function() {
-        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-            args[_key] = arguments[_key];
-        }
-        return _index.logger.error("".concat(getPrefix(prefix)).concat(toString(args)));
-    };
-    return {
-        debug: debug,
-        info: info,
-        warn: warn,
-        error: error
-    };
+    }
+    return wrappedLogger;
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -20,3 +20,4 @@ export interface ILogDNAParams {
     functionName: string;
     logDNAOptions: ILogDNALogOptions;
 }
+export type WrappedLogger = Record<string, (...args: unknown[]) => void>;

package/package.json

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