@autofleet/logger 3.0.0 → 4.0.0-beta-2

package/dist/example.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const logger = (0, index_1.default)('info');
+logger.info('it is working');
+logger.error('errors displayed in logs/error.log', new Error('test error'));
+logger.debug('debug with object', { a: 5 });
+const loggerMiddleware = () => ({ middleware: Math.random() });
+logger.addContextMiddleware(loggerMiddleware);
+logger.info('middleware added', { a: 5 });
+logger.error('middleware added', new Error('test error'));

package/dist/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+const pino_1 = __importDefault(require("pino"));
+const pino_cloud_logging_1 = require("pino-cloud-logging");
+const getLevel = (logLevel) => {
+    if (logLevel)
+        return logLevel;
+    if (process.env.LOG_LEVEL)
+        return process.env.LOG_LEVEL;
+    if (process.env.NODE_ENV && ['production', 'staging', 'test'].includes(process.env.NODE_ENV))
+        return 'info';
+    if (process.env.NODE_ENV === 'development')
+        return 'debug';
+    return 'debug';
+};
+const createLoggerInstance = (level, options) => {
+    let loggerInstance;
+    if (process.env.NODE_ENV === 'production') {
+        loggerInstance = (0, pino_1.default)((0, pino_cloud_logging_1.gcpLogOptions)(Object.assign({ level: process.env.PINO_LOG_LEVEL || 'info' }, options)));
+    }
+    else {
+        loggerInstance = (0, pino_1.default)(Object.assign({ level: process.env.PINO_LOG_LEVEL || 'info', transport: {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                },
+            } }, options));
+    }
+    loggerInstance.level = level;
+    return loggerInstance;
+};
+// eslint-disable-next-line no-shadow
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["trace"] = "trace";
+    LogLevel["debug"] = "debug";
+    LogLevel["info"] = "info";
+    LogLevel["warn"] = "warn";
+    LogLevel["error"] = "error";
+    LogLevel["fatal"] = "fatal";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class LoggerInstanceManager {
+    constructor(logLevel) {
+        this.contextMiddlewares = [];
+        this.logger = createLoggerInstance(getLevel(logLevel), {
+            mixin: () => this.addMetadata(),
+        });
+    }
+    // To support winston like logging in pino
+    winstonLikeLoggerCall(logLevel, message, meta) {
+        if (meta) {
+            this.logger[logLevel](meta, message);
+        }
+        else {
+            this.logger[logLevel](message);
+        }
+    }
+    addMetadata() {
+        const newMetadata = {};
+        this.contextMiddlewares.forEach((middleware) => {
+            const metadata = middleware();
+            Object.assign(newMetadata, metadata);
+        });
+        return newMetadata;
+    }
+    addContextMiddleware(middleware) {
+        this.contextMiddlewares.push(middleware);
+    }
+    trace(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.trace, message, meta);
+    }
+    debug(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.debug, message, meta);
+    }
+    info(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.info, message, meta);
+    }
+    warn(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.warn, message, meta);
+    }
+    error(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.error, message, meta);
+    }
+    fatal(message, meta) {
+        this.winstonLikeLoggerCall(LogLevel.fatal, message, meta);
+    }
+    child(metadata) {
+        return this.logger.child(metadata);
+    }
+    get level() {
+        return this.logger.level;
+    }
+}
+exports.default = (loglevel) => new LoggerInstanceManager(loglevel);

package/dist/index.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const { env } = process;
+describe('Logger', () => {
+    it('it`s default level is info', () => {
+        env.NODE_ENV = '';
+        const logger = (0, index_1.default)();
+        expect(logger).toBeDefined();
+        expect(logger.level).toBe('debug');
+        logger.info('test');
+    });
+    it('its default develpment level is debug', () => {
+        env.NODE_ENV = 'development';
+        const logger = (0, index_1.default)();
+        expect(logger.level).toBe('debug');
+    });
+    it('its default test level is info', () => {
+        env.NODE_ENV = 'test';
+        const logger = (0, index_1.default)();
+        expect(logger.level).toBe('info');
+    });
+    it('its default production level is info', () => {
+        env.NODE_ENV = 'production';
+        const logger = (0, index_1.default)();
+        expect(logger.level).toBe('info');
+    });
+    it('its level can be override by LOG_LEVEL env variable', () => {
+        env.NODE_ENV = 'development';
+        env.LOG_LEVEL = 'warn';
+        const logger = (0, index_1.default)();
+        expect(logger.level).toBe('warn');
+    });
+    it('its level can be override by function variable', () => {
+        env.NODE_ENV = 'production';
+        env.LOG_LEVEL = 'warn';
+        const logger = (0, index_1.default)('info');
+        expect(logger.level).toBe('info');
+    });
+    it('its has functions for each level', () => {
+        const logger = (0, index_1.default)();
+        expect(typeof logger.error).toBe('function');
+        expect(typeof logger.warn).toBe('function');
+        expect(typeof logger.info).toBe('function');
+        expect(typeof logger.debug).toBe('function');
+    });
+});

package/example.ts

@@ -0,0 +1,13 @@
+import Logger from './index';
+
+const logger = Logger('info');
+
+logger.info('it is working');
+logger.error('errors displayed in logs/error.log', new Error('test error'));
+logger.debug('debug with object', { a: 5 });
+
+const loggerMiddleware = () => ({ middleware: Math.random() });
+logger.addContextMiddleware(loggerMiddleware);
+
+logger.info('middleware added', { a: 5 });
+logger.error('middleware added', new Error('test error'));

package/{index.test.js → index.test.ts}

@@ -1,4 +1,4 @@
-const Logger = require('./index');
+import Logger from './index';
 
 const { env } = process;
 
@@ -39,17 +39,15 @@ describe('Logger', () => {
   it('its level can be override by function variable', () => {
     env.NODE_ENV = 'production';
     env.LOG_LEVEL = 'warn';
-    const logger = Logger('silly');
-    expect(logger.level).toBe('silly');
+    const logger = Logger('info');
+    expect(logger.level).toBe('info');
   });
 
   it('its has functions for each level', () => {
     const logger = Logger();
-    expect(logger.error).toBeFunction();
-    expect(logger.warn).toBeFunction();
-    expect(logger.info).toBeFunction();
-    expect(logger.verbose).toBeFunction();
-    expect(logger.debug).toBeFunction();
-    expect(logger.silly).toBeFunction();
+    expect(typeof logger.error).toBe('function');
+    expect(typeof logger.warn).toBe('function');
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.debug).toBe('function');
   });
 });

package/index.ts

@@ -0,0 +1,113 @@
+import Pino from 'pino';
+import { gcpLogOptions } from 'pino-cloud-logging';
+
+const getLevel = (logLevel: string | undefined) => {
+  if (logLevel) return logLevel;
+  if (process.env.LOG_LEVEL) return process.env.LOG_LEVEL;
+  if (process.env.NODE_ENV && ['production', 'staging', 'test'].includes(process.env.NODE_ENV)) return 'info';
+  if (process.env.NODE_ENV === 'development') return 'debug';
+  return 'debug';
+};
+
+const createLoggerInstance = (level: string, options: object) => {
+  let loggerInstance;
+  if (process.env.NODE_ENV === 'production') {
+    loggerInstance = Pino(gcpLogOptions({
+      level: process.env.PINO_LOG_LEVEL || 'info',
+      ...options,
+    }));
+  } else {
+    loggerInstance = Pino({
+      level: process.env.PINO_LOG_LEVEL || 'info',
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true,
+        },
+      },
+      ...options,
+    });
+  }
+  loggerInstance.level = level;
+  return loggerInstance;
+};
+
+// eslint-disable-next-line no-shadow
+export enum LogLevel {
+  trace = 'trace',
+  debug = 'debug',
+  info = 'info',
+  warn = 'warn',
+  error = 'error',
+  fatal = 'fatal',
+}
+
+type MiddlewareFunction = () => Record<string, unknown>;
+
+class LoggerInstanceManager {
+  contextMiddlewares: MiddlewareFunction[];
+
+  logger: Pino.Logger;
+
+  constructor(logLevel?: string) {
+    this.contextMiddlewares = [];
+    this.logger = createLoggerInstance(getLevel(logLevel), {
+      mixin: () => this.addMetadata(),
+    });
+  }
+
+  // To support winston like logging in pino
+  winstonLikeLoggerCall(logLevel: LogLevel, message: string, meta: unknown) {
+    if (meta) {
+      this.logger[logLevel](meta, message);
+    } else {
+      this.logger[logLevel](message);
+    }
+  }
+
+  addMetadata(): Record<string, unknown> {
+    const newMetadata = {};
+    this.contextMiddlewares.forEach((middleware) => {
+      const metadata = middleware();
+      Object.assign(newMetadata, metadata);
+    });
+    return newMetadata;
+  }
+
+  addContextMiddleware(middleware: MiddlewareFunction) {
+    this.contextMiddlewares.push(middleware);
+  }
+
+  trace(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.trace, message, meta);
+  }
+
+  debug(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.debug, message, meta);
+  }
+
+  info(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.info, message, meta);
+  }
+
+  warn(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.warn, message, meta);
+  }
+
+  error(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.error, message, meta);
+  }
+
+  fatal(message: string, meta?: unknown) {
+    this.winstonLikeLoggerCall(LogLevel.fatal, message, meta);
+  }
+
+  child(metadata: Record<string, unknown>) {
+    return this.logger.child(metadata);
+  }
+
+  get level() {
+    return this.logger.level;
+  }
+}
+export default (loglevel?: string) => new LoggerInstanceManager(loglevel);

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@autofleet/logger",
-  "version": "3.0.0",
+  "version": "4.0.0-beta-2",
   "description": "",
   "scripts": {
     "coverage": "jest --coverage --forceExit --runInBand",
     "test": "jest --runInBand",
     "test-auto": "jest --watch --runInBand",
-    "linter": "./node_modules/.bin/eslint ."
+    "linter": "./node_modules/.bin/eslint .",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "example": "ts-node example.ts"
   },
   "jest": {
     "setupTestFrameworkScriptFile": "jest-extended",
-    "testURL": "http://localhost:8085/"
+    "testURL": "http://localhost:8085/",
+    "preset": "ts-jest"
   },
   "repository": {
     "type": "git",
@@ -25,15 +29,25 @@
   "dependencies": {
     "@google-cloud/logging-winston": "^6.0.0",
     "dotenv": "^5.0.1",
-    "jest": "^22.4.4",
     "object-sizeof": "^1.6.1",
+    "pino": "^9.2.0",
+    "pino-cloud-logging": "^1.0.6",
+    "pino-pretty": "^11.2.1",
     "winston": "^3.11.0"
   },
   "devDependencies": {
-    "eslint": "^4.19.1",
-    "eslint-config-airbnb": "^16.1.0",
-    "eslint-plugin-import": "^2.11.0",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.14.7",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
     "jest-extended": "^0.7.1",
-    "nock": "^10.0.2"
+    "nock": "^10.0.2",
+    "ts-jest": "^29.1.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.2"
   }
 }

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "commonjs",                                /* Specify what module code is generated. */       /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    "outDir": "./dist"
+  }
+}

package/example.js

@@ -1,5 +0,0 @@
-const logger = require('./index')();
-
-logger.info('it is working');
-logger.error('errors displayed in logs/error.log', { e: new Error('test error') });
-logger.debug('debug with object', { a: 5 });

package/index.d.ts

@@ -1,7 +0,0 @@
-import { Logger } from 'winston';
-
-declare const logger: Logger;
-
-declare const _exported: (_logLevel: any) => Logger
-
-export default _exported;

package/index.js

@@ -1,143 +0,0 @@
-const winston = require('winston');
-const sizeof = require('object-sizeof');
-
-const { createLogger } = winston;
-require('dotenv').config();
-
-const { env } = process;
-
-const isProd = env.NODE_ENV === 'production';
-
-const infoEnvNmaes = [
-  'production',
-  'staging',
-  'test',
-];
-
-const serializeError = (error) => {
-  const fields = ['code', 'status', 'statusCode', 'message', 'messageData', 'name', 'stack', 'stackTrace'];
-  return fields.reduce((v, field) => ({ ...v, [field]: error[field] }), {});
-};
-
-const getLevel = (logLevel) => {
-  if (logLevel) return logLevel;
-  if (env.LOG_LEVEL) return env.LOG_LEVEL;
-  if (infoEnvNmaes.includes(env.NODE_ENV)) return 'info';
-  if (env.NODE_ENV === 'development') return 'debug';
-  return 'debug';
-};
-
-const addLogsSize = winston.format((info) => {
-  let logSize = 0;
-  try {
-    logSize = sizeof(JSON.stringify(info));
-    if (logSize > 256000) {
-      console.log(`[WARNING] Found Oversized log with message "${info.message}"`);
-      return {
-        message: info.message,
-        stack: info.stack,
-        level: info.level,
-        logSize,
-      };
-    }
-  } catch (e) {
-    console.log(`[WARNING] Failed to calculate log size with message "${info.message}"`);
-  }
-
-  return { ...info, logSize };
-});
-
-const enumerateErrorFormat = winston.format((info) => {
-  // fix for this crap: https://github.com/googleapis/nodejs-logging-winston/issues/285
-  // eslint-disable-next-line no-param-reassign
-  info.severity = info.level.toUpperCase();
-
-  if (info.message instanceof Error) {
-    info.message = Object.assign({ // eslint-disable-line
-      message: info.message.message,
-      stack: info.message.stack,
-    }, info.message);
-  }
-  if (info instanceof Error) {
-    return Object.assign({
-      message: info.message,
-      stack: info.stack,
-    }, info);
-  }
-
-  // eslint-disable-next-line array-callback-return
-  Object.keys(info).map((k) => {
-    if (info[k] instanceof Error) {
-      // eslint-disable-next-line no-param-reassign
-      info[k] = serializeError(info[k]);
-    }
-  });
-
-  return info;
-});
-
-const getFormat = () => {
-  if (isProd) {
-    return winston.format.combine(
-      addLogsSize(),
-      enumerateErrorFormat(),
-      winston.format.json(),
-    );
-  }
-
-  return winston.format.combine(
-    addLogsSize(),
-    enumerateErrorFormat(),
-    winston.format.splat(),
-    winston.format.simple(),
-  );
-};
-
-const createLoggerInstance = (level, exceptionHandlers) => {
-  const logger = createLogger({
-    level,
-    format: getFormat(),
-    transports: [
-      new winston.transports.Console(),
-    ],
-    exceptionHandlers,
-    exitOnError: false,
-  });
-
-  logger.httpMorganInfo = (options) => {
-    logger.info(options.url, {
-      httpRequest: {
-        status: options.status,
-        requestUrl: options.url,
-        requestMethod: options.method,
-        responseSize: options['content-length'],
-        latency: {
-          seconds: parseInt(options['response-time'], 10) / 1000,
-          nanos: parseInt(options['response-time'], 10) * 1000000,
-        },
-        userAgent: options['user-agent'],
-      },
-    });
-  };
-  if (env.NODE_ENV !== 'production') {
-    logger.httpMorganInfo = undefined;
-  }
-
-  return logger;
-};
-
-class LoggerInstanceManager {
-  static getLoggerInstance(logLevel) {
-    if (!LoggerInstanceManager.instances) {
-      LoggerInstanceManager.instances = {};
-    }
-    const level = getLevel(logLevel);
-    if (!LoggerInstanceManager.instances[level]) {
-      LoggerInstanceManager.instances[level] = createLoggerInstance(level);
-    }
-    return LoggerInstanceManager.instances[level];
-  }
-}
-
-
-module.exports = LoggerInstanceManager.getLoggerInstance;