@beforeyoubid/logger-adapter 1.0.7 → 1.0.11

package/dist/console/index.js

@@ -4,7 +4,6 @@ exports.consoleLogger = void 0;
 const params_1 = require("../params");
 const logger_1 = require("./logger");
 const util_1 = require("../util");
-const flush_1 = require("../flush");
 let loggerObject;
 const logParams = params_1.getLogParams();
 /**
@@ -25,6 +24,6 @@ const init = (params = logParams) => {
 };
 const consoleLogger = {
     init,
-    flushAll: flush_1.flushAll,
+    flushAll: util_1.flushAll,
 };
 exports.consoleLogger = consoleLogger;

package/dist/console/logger.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultConsoleLog = exports.getLogger = void 0;
-const LogDNALogger = require('@logdna/logger');
+const LogDNALogger = require('logdna');
 const { flushAll } = require('../util');
 let logger;
 // Default console

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureFlushAllCallback = exports.ensureFlushAll = exports.flushAll = exports.getLogParams = exports.logger = exports.consoleLogger = exports.logdnaTransport = void 0;
+exports.ensureFlushAllCallback = exports.ensureFlushAll = exports.flushAll = exports.getLogParams = exports.logger = exports.consoleLogger = void 0;
 const console_1 = require("./console");
 Object.defineProperty(exports, "consoleLogger", { enumerable: true, get: function () { return console_1.consoleLogger; } });
 const logger_1 = require("./logger");
 Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
-Object.defineProperty(exports, "logdnaTransport", { enumerable: true, get: function () { return logger_1.logdnaTransport; } });
 const params_1 = require("./params");
 Object.defineProperty(exports, "getLogParams", { enumerable: true, get: function () { return params_1.getLogParams; } });
-const flush_1 = require("./flush");
-Object.defineProperty(exports, "flushAll", { enumerable: true, get: function () { return flush_1.flushAll; } });
-Object.defineProperty(exports, "ensureFlushAll", { enumerable: true, get: function () { return flush_1.ensureFlushAll; } });
-Object.defineProperty(exports, "ensureFlushAllCallback", { enumerable: true, get: function () { return flush_1.ensureFlushAllCallback; } });
+const util_1 = require("./util");
+Object.defineProperty(exports, "flushAll", { enumerable: true, get: function () { return util_1.flushAll; } });
+Object.defineProperty(exports, "ensureFlushAll", { enumerable: true, get: function () { return util_1.ensureFlushAll; } });
+Object.defineProperty(exports, "ensureFlushAllCallback", { enumerable: true, get: function () { return util_1.ensureFlushAllCallback; } });

package/dist/logger/index.d.ts

@@ -1,3 +1,2 @@
 declare const logger: any;
-declare const logdnaTransport: any;
-export { logger, logdnaTransport };
+export { logger };

package/dist/logger/index.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logdnaTransport = exports.logger = void 0;
+exports.logger = void 0;
 const params_1 = require("../params");
 const logger_1 = require("./logger");
 const logParams = params_1.getLogParams();
 const logger = logger_1.getLogger(logParams);
 exports.logger = logger;
-const logdnaTransport = logger_1.getLogdnaTransport();
-exports.logdnaTransport = logdnaTransport;

package/dist/logger/logger.d.ts

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

package/dist/logger/logger.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogdnaTransport = exports.getLogger = void 0;
+exports.getLogger = void 0;
 const logdnaWinston = require('logdna-winston');
 const winston = require('winston');
 const { isLogDNAEnabled } = require('../util');
@@ -17,14 +17,12 @@ const createWinstonLogger = (logLevel) => {
     });
     return logger;
 };
-let logdnaTransport;
 const getLogger = (params) => {
     const { logLevel, logDNAOptions, logDNAKey, sendToRemote } = params;
     const isEnabled = isLogDNAEnabled(logDNAKey, sendToRemote);
     const logger = createWinstonLogger(logLevel);
-    logdnaTransport = new logdnaWinston(logDNAOptions);
     if (isEnabled) {
-        logger.add(logdnaTransport);
+        logger.add(new logdnaWinston(logDNAOptions));
     }
     else {
         logger.info(`LOGDNA is disabled`);
@@ -32,5 +30,3 @@ const getLogger = (params) => {
     return logger;
 };
 exports.getLogger = getLogger;
-const getLogdnaTransport = () => logdnaTransport;
-exports.getLogdnaTransport = getLogdnaTransport;

package/dist/params.js

@@ -25,6 +25,7 @@ const getLogParams = (env = (process === null || process === void 0 ? void 0 : p
         hostname: STAGE,
         index_meta: true,
         tags: [AWS_LAMBDA_FUNCTION_NAME, STAGE],
+        level: LOG_LEVEL,
         handleExceptions: true,
     };
     return {

package/dist/types.d.ts

@@ -9,6 +9,7 @@ export interface ILogDNALogOptions {
     hostname: string;
     index_meta: boolean;
     tags: Array<string>;
+    level: string;
     handleExceptions: boolean;
 }
 export interface ILogDNAParams {

package/dist/util.d.ts

@@ -1,6 +1,27 @@
+import { LambdaHandlerWithAsyncFunction, LambdaHandlerWithCallbackFunction } from './types';
 /**
  * Handy function to check if we are sending to LogDNA
  * @param logDNAKey
  * @param sendToRemote
  */
-export declare const isLogDNAEnabled: (logDNAKey: string, sendToRemote: boolean) => boolean;
+declare const isLogDNAEnabled: (logDNAKey: string, sendToRemote: boolean) => boolean;
+/**
+ * Send all log messages to LogDNA before lambda is terminated
+ */
+declare const flushAll: () => Promise<void>;
+/**
+ * Lambda wrapper to ensure we flush messages before returning the response
+ * @param lambdaHandler
+ */
+declare const ensureFlushAll: (lambdaHandler: LambdaHandlerWithAsyncFunction) => LambdaHandlerWithAsyncFunction;
+/**
+ * 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
+ */
+declare const ensureFlushAllCallback: (lambdaHandler: LambdaHandlerWithCallbackFunction) => LambdaHandlerWithCallbackFunction;
+export { isLogDNAEnabled, flushAll, ensureFlushAll, ensureFlushAllCallback };

package/dist/util.js

@@ -1,9 +1,96 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLogDNAEnabled = void 0;
+exports.ensureFlushAllCallback = exports.ensureFlushAll = exports.flushAll = exports.isLogDNAEnabled = void 0;
+const LogDNALogger = require('logdna');
+const debug = require('util').debuglog('logger-adapter');
+const { FALLBACK_TIMEOUT_AFTER_FLUSHING } = require('./consts');
+const { getLogParams } = require('./params');
+// timeout
+let timeout;
 /**
  * Handy function to check if we are sending to LogDNA
  * @param logDNAKey
  * @param sendToRemote
  */
-exports.isLogDNAEnabled = (logDNAKey, sendToRemote) => !!logDNAKey && sendToRemote;
+const isLogDNAEnabled = (logDNAKey, sendToRemote) => !!logDNAKey && sendToRemote;
+exports.isLogDNAEnabled = isLogDNAEnabled;
+/**
+ * REturn if we need to suppress flushAll on a local machine
+ */
+const suppressFlushAll = () => { var _a; return ((_a = getLogParams()) === null || _a === void 0 ? void 0 : _a.logDNASuppressFlushAll) || false; };
+/**
+ * Send all log messages to LogDNA before lambda is terminated
+ */
+const flushAll = () => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise(resolve => {
+        debug('Flushing all logs...');
+        LogDNALogger.flushAll(() => {
+            debug('Completed flushing all log messages');
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            resolve();
+        });
+    });
+});
+exports.flushAll = flushAll;
+/**
+ * Fallback promise just in
+ */
+const timeoutPromise = () => {
+    return new Promise(resolve => {
+        timeout = setTimeout(() => {
+            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
+ */
+const ensureFlushAll = (lambdaHandler) => {
+    return (event, context) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const result = yield lambdaHandler(event, context);
+            if (!suppressFlushAll())
+                yield Promise.race([flushAll(), timeoutPromise()]);
+            return result;
+        }
+        catch (e) {
+            if (!suppressFlushAll())
+                yield Promise.race([flushAll(), timeoutPromise()]);
+            throw e;
+        }
+    });
+};
+exports.ensureFlushAll = ensureFlushAll;
+/**
+ * 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
+ */
+const ensureFlushAllCallback = (lambdaHandler) => {
+    return (event, context, callback) => {
+        const thisCallback = (error, result) => {
+            callback(error, result);
+            if (!suppressFlushAll())
+                flushAll();
+        };
+        lambdaHandler(event, context, thisCallback);
+    };
+};
+exports.ensureFlushAllCallback = ensureFlushAllCallback;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beforeyoubid/logger-adapter",
-  "version": "1.0.7",
+  "version": "1.0.11",
   "description": "A platform logger module to send the log messages to LogDNA.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/beforeyoubid/npm-logger-adapter#readme",
   "dependencies": {
-    "@logdna/logger": "^1.2.0",
+    "logdna": "^3.5.2",
     "logdna-winston": "^2.3.2",
     "winston": "^3.3.3"
   },
@@ -46,5 +46,8 @@
     "prettier": "^2.0.5",
     "ts-jest": "^26.2.0",
     "typescript": "^3.9.7"
+  },
+  "resolutions": {
+    "colors": "1.4.0"
   }
 }

package/src/console/index.ts

@@ -2,8 +2,7 @@ import { ILogDNAParams } from '../types';
 
 import { getLogParams } from '../params';
 import { getLogger } from './logger';
-import { isLogDNAEnabled } from '../util';
-import { flushAll } from '../flush';
+import { isLogDNAEnabled, flushAll } from '../util';
 
 let loggerObject: any;
 const logParams = getLogParams();

package/src/console/logger.ts

@@ -1,5 +1,5 @@
 import { ILogDNAParams } from '../types';
-const LogDNALogger = require('@logdna/logger');
+const LogDNALogger = require('logdna');
 const { flushAll } = require('../util');
 let logger: any;
 

package/src/index.ts

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

package/src/logger/index.ts

@@ -1,8 +1,7 @@
 import { getLogParams } from '../params';
-import { getLogger, getLogdnaTransport } from './logger';
+import { getLogger } from './logger';
 
 const logParams = getLogParams();
 const logger = getLogger(logParams);
-const logdnaTransport = getLogdnaTransport();
 
-export { logger, logdnaTransport };
+export { logger };

package/src/logger/logger.ts

@@ -26,21 +26,16 @@ const createWinstonLogger = (logLevel: string) => {
   return logger;
 };
 
-let logdnaTransport: any;
-
 const getLogger = (params: ILogDNAParams): any => {
   const { logLevel, logDNAOptions, logDNAKey, sendToRemote } = params;
   const isEnabled = isLogDNAEnabled(logDNAKey, sendToRemote);
   const logger = createWinstonLogger(logLevel);
-  logdnaTransport = new logdnaWinston(logDNAOptions);
   if (isEnabled) {
-    logger.add(logdnaTransport);
+    logger.add(new logdnaWinston(logDNAOptions));
   } else {
     logger.info(`LOGDNA is disabled`);
   }
   return logger;
 };
 
-const getLogdnaTransport = () => logdnaTransport;
-
-export { getLogger, getLogdnaTransport };
+export { getLogger };

package/src/params.ts

@@ -36,6 +36,7 @@ const getLogParams = (env = process?.env || {}): ILogDNAParams => {
     hostname: STAGE,
     index_meta: true,
     tags: [AWS_LAMBDA_FUNCTION_NAME, STAGE],
+    level: LOG_LEVEL,
     handleExceptions: true,
   };
 

package/src/types.ts

@@ -9,6 +9,7 @@ export interface ILogDNALogOptions {
   hostname: string;
   index_meta: boolean;
   tags: Array<string>;
+  level: string;
   handleExceptions: boolean;
 }
 

package/src/util.ts

@@ -1,6 +1,89 @@
+import { LambdaHandlerWithAsyncFunction, LambdaHandlerWithCallbackFunction, CallbackFunction } from './types';
+
+const LogDNALogger = require('logdna');
+const debug = require('util').debuglog('logger-adapter');
+const { FALLBACK_TIMEOUT_AFTER_FLUSHING } = require('./consts');
+const { getLogParams } = require('./params');
+
+// timeout
+let timeout: NodeJS.Timeout;
+
 /**
  * Handy function to check if we are sending to LogDNA
  * @param logDNAKey
  * @param sendToRemote
  */
-export const isLogDNAEnabled = (logDNAKey: string, sendToRemote: boolean): boolean => !!logDNAKey && sendToRemote;
+const isLogDNAEnabled = (logDNAKey: string, sendToRemote: boolean): boolean => !!logDNAKey && sendToRemote;
+
+/**
+ * REturn if we need to suppress flushAll on a local machine
+ */
+const suppressFlushAll = (): boolean => getLogParams()?.logDNASuppressFlushAll || false;
+
+/**
+ * Send all log messages to LogDNA before lambda is terminated
+ */
+const flushAll = async (): Promise<void> => {
+  return new Promise(resolve => {
+    debug('Flushing all logs...');
+    LogDNALogger.flushAll(() => {
+      debug('Completed flushing all log messages');
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      resolve();
+    });
+  });
+};
+
+/**
+ * Fallback promise just in
+ */
+const timeoutPromise = () => {
+  return new Promise(resolve => {
+    timeout = setTimeout(() => {
+      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
+ */
+const ensureFlushAll = (lambdaHandler: LambdaHandlerWithAsyncFunction): LambdaHandlerWithAsyncFunction => {
+  return async (event: any, context: any): Promise<any> => {
+    try {
+      const result = await lambdaHandler(event, context);
+      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);
+      return result;
+    } catch (e) {
+      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);
+      throw e;
+    }
+  };
+};
+
+/**
+ * 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
+ */
+const ensureFlushAllCallback = (
+  lambdaHandler: LambdaHandlerWithCallbackFunction
+): LambdaHandlerWithCallbackFunction => {
+  return (event: any, context: any, callback: CallbackFunction): void => {
+    const thisCallback = (error: any, result: any): void => {
+      callback(error, result);
+      if (!suppressFlushAll()) flushAll();
+    };
+    lambdaHandler(event, context, thisCallback);
+  };
+};
+
+export { isLogDNAEnabled, flushAll, ensureFlushAll, ensureFlushAllCallback };

package/src/flush.ts

@@ -1,77 +0,0 @@
-import { LambdaHandlerWithAsyncFunction, LambdaHandlerWithCallbackFunction, CallbackFunction } from './types';
-import { logdnaTransport } from './logger';
-
-const debug = require('util').debuglog('logger-adapter');
-const { once } = require('events')
-const { FALLBACK_TIMEOUT_AFTER_FLUSHING } = require('./consts');
-const { getLogParams } = require('./params');
-
-// timeout
-let timeout: NodeJS.Timeout;
-
-/**
- * REturn if we need to suppress flushAll on a local machine
- */
-export const suppressFlushAll = (): boolean => getLogParams()?.logDNASuppressFlushAll || false;
-
-export const sleep = (time: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, time));
-
-/**
- * Send all log messages to LogDNA before lambda is terminated
- */
-export const flushAll = (): Promise<void> => {
-  debug('Flushing all logs...');
-  return new Promise(resolve => 
-    logdnaTransport.Logger.flushAll(resolve)
-  );
-};
-
-/**
- * Fallback promise just in
- */
-export const timeoutPromise = () => {
-  return new Promise(resolve => {
-    timeout = setTimeout(() => {
-      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
- */
-export const ensureFlushAll = (lambdaHandler: LambdaHandlerWithAsyncFunction): LambdaHandlerWithAsyncFunction => {
-  return async (event: any, context: any): Promise<any> => {
-    try {
-      const result = await lambdaHandler(event, context);
-      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);
-      return result;
-    } catch (e) {
-      if (!suppressFlushAll()) await Promise.race([flushAll(), timeoutPromise()]);
-      throw e;
-    }
-  };
-};
-
-/**
- * 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
- */
-export const ensureFlushAllCallback = (
-  lambdaHandler: LambdaHandlerWithCallbackFunction
-): LambdaHandlerWithCallbackFunction => {
-  return (event: any, context: any, callback: CallbackFunction): void => {
-    const thisCallback = (error: any, result: any): void => {
-      callback(error, result);
-      if (!suppressFlushAll()) flushAll();
-    };
-    lambdaHandler(event, context, thisCallback);
-  };
-};