@autofleet/logger 1.2.3 → 1.2.4

package/dist/debug-console-log.d.ts

@@ -0,0 +1,16 @@
+interface EntityObject {
+    entityId: string;
+    entityType: string;
+    businessModelId?: string;
+    fleetId?: string;
+    demandSourceId?: string;
+}
+export default class DebugConsoleLog {
+    entites: EntityObject;
+    constructor(entites: EntityObject);
+    private generateLevelLog;
+    info(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+    warn(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+    error(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+}
+export {};

package/dist/debug-console-log.js

@@ -0,0 +1,44 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Events = require('@autofleet/events');
+const logger_1 = __importDefault(require("./logger"));
+const events = new Events({ logger: logger_1.default });
+class DebugConsoleLog {
+    constructor(entites) {
+        this.entites = entites;
+    }
+    generateLevelLog(level) {
+        return (msg, payload, additonalEntityies) => __awaiter(this, void 0, void 0, function* () {
+            logger_1.default[level](msg, payload);
+            events.send('log_events', 1, Object.assign(Object.assign({ action: 'logEvent', level }, this.entites), { payload: JSON.stringify(payload) }));
+        });
+    }
+    info(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('info')(msg, payload, additonalEntityies);
+        });
+    }
+    warn(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('warn')(msg, payload, additonalEntityies);
+        });
+    }
+    error(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('error')(msg, payload, additonalEntityies);
+        });
+    }
+}
+exports.default = DebugConsoleLog;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import logger from './logger';
+import DebugConsoleLog from './debug-console-log';
+export { DebugConsoleLog };
+export default logger;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugConsoleLog = void 0;
+const logger_1 = __importDefault(require("./logger"));
+const debug_console_log_1 = __importDefault(require("./debug-console-log"));
+exports.DebugConsoleLog = debug_console_log_1.default;
+exports.default = logger_1.default;

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import winston from 'winston';
+declare const logger: winston.Logger;
+export declare const httpMorganInfo: (options: any) => void;
+export default logger;

package/dist/logger.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpMorganInfo = void 0;
+const winston_1 = __importDefault(require("winston"));
+const { createLogger } = winston_1.default;
+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) => (Object.assign(Object.assign({}, v), { [field]: error[field] })), {});
+};
+const getLevel = () => {
+    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 enumerateErrorFormat = winston_1.default.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 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_1.default.format.combine(enumerateErrorFormat(), winston_1.default.format.json());
+    }
+    return winston_1.default.format.combine(enumerateErrorFormat(), winston_1.default.format.splat(), winston_1.default.format.colorize(), winston_1.default.format.simple());
+};
+const logger = createLogger({
+    level: getLevel(),
+    format: getFormat(),
+    transports: [
+        new winston_1.default.transports.Console(),
+    ],
+    exitOnError: false,
+});
+const 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'],
+        },
+    });
+};
+exports.httpMorganInfo = httpMorganInfo;
+exports.default = logger;

package/dist/src/debug-console-log.d.ts

@@ -0,0 +1,16 @@
+interface EntityObject {
+    entityId: string;
+    entityType: string;
+    businessModelId?: string;
+    fleetId?: string;
+    demandSourceId?: string;
+}
+export default class DebugConsoleLog {
+    entites: EntityObject;
+    constructor(entites: EntityObject);
+    private generateLevelLog;
+    info(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+    warn(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+    error(msg: string, payload?: any, additonalEntityies?: any): Promise<void>;
+}
+export {};

package/dist/src/debug-console-log.js

@@ -0,0 +1,44 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("@autofleet/events"));
+const logger_1 = __importDefault(require("./logger"));
+const events = new events_1.default();
+class DebugConsoleLog {
+    constructor(entites) {
+        this.entites = entites;
+    }
+    generateLevelLog(level) {
+        return (msg, payload, additonalEntityies) => __awaiter(this, void 0, void 0, function* () {
+            logger_1.default[level](msg, payload);
+            events.send('log_events', 1, Object.assign(Object.assign({ action: 'logEvent', level }, this.entites), { payload: JSON.stringify(payload) }));
+        });
+    }
+    info(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('info')(msg, payload, additonalEntityies);
+        });
+    }
+    warn(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('warn')(msg, payload, additonalEntityies);
+        });
+    }
+    error(msg, payload, additonalEntityies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.generateLevelLog('error')(msg, payload, additonalEntityies);
+        });
+    }
+}
+exports.default = DebugConsoleLog;

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import logger from './logger';
+import DebugConsoleLog from './debug-console-log';
+export { DebugConsoleLog };
+export default logger;

package/dist/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugConsoleLog = void 0;
+const logger_1 = __importDefault(require("./logger"));
+const debug_console_log_1 = __importDefault(require("./debug-console-log"));
+exports.DebugConsoleLog = debug_console_log_1.default;
+exports.default = logger_1.default;

package/dist/src/logger.d.ts

@@ -0,0 +1,4 @@
+import winston from 'winston';
+declare const logger: winston.Logger;
+export declare const httpMorganInfo: (options: any) => void;
+export default logger;

package/dist/src/logger.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpMorganInfo = void 0;
+const winston_1 = __importDefault(require("winston"));
+const { createLogger } = winston_1.default;
+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) => (Object.assign(Object.assign({}, v), { [field]: error[field] })), {});
+};
+const getLevel = () => {
+    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 enumerateErrorFormat = winston_1.default.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 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_1.default.format.combine(enumerateErrorFormat(), winston_1.default.format.json());
+    }
+    return winston_1.default.format.combine(enumerateErrorFormat(), winston_1.default.format.splat(), winston_1.default.format.colorize(), winston_1.default.format.simple());
+};
+const logger = createLogger({
+    level: getLevel(),
+    format: getFormat(),
+    transports: [
+        new winston_1.default.transports.Console(),
+    ],
+    exitOnError: false,
+});
+const 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'],
+        },
+    });
+};
+exports.httpMorganInfo = httpMorganInfo;
+exports.default = logger;

package/index.js

@@ -1,6 +1,5 @@
 const winston = require('winston');
 const sizeof = require('object-sizeof');
-const Events = require('@autofleet/events');
 
 const { createLogger } = winston;
 require('dotenv').config();
@@ -83,23 +82,6 @@ const getFormat = () => {
   );
 };
 
-const clientFacingLogLevel = [
-  'error',
-  'warn',
-  'info',
-];
-
-
-const createClientFacingLog = (logger, level, events) => async (msg, entities, payload) => {
-  logger[level](msg, payload);
-  events.send('log_events', 1, {
-    action: 'logEvent',
-    level,
-    ...entities,
-    payload: JSON.stringify(payload),
-  });
-};
-
 const createLoggerInstance = (level, exceptionHandlers) => {
   const logger = createLogger({
     level,
@@ -130,13 +112,6 @@ const createLoggerInstance = (level, exceptionHandlers) => {
     logger.httpMorganInfo = undefined;
   }
 
-
-  const events = new Events({ logger });
-  logger.events = events;
-  clientFacingLogLevel.forEach((currentLevel) => {
-    logger[`clientFacing${currentLevel.charAt(0).toUpperCase()}${currentLevel.substring(1)}`] = createClientFacingLog(logger, currentLevel, events);
-  });
-
   return logger;
 };
 

package/index.test.js

@@ -1,4 +1,3 @@
-const EventsMock = require('@autofleet/events/mocks');
 const Logger = require('./index');
 
 const { env } = process;
@@ -51,28 +50,5 @@ describe('Logger', () => {
     expect(logger.verbose).toBeFunction();
     expect(logger.debug).toBeFunction();
     expect(logger.silly).toBeFunction();
-    expect(logger.clientFacingInfo).toBeFunction();
-    expect(logger.clientFacingWarn).toBeFunction();
-    expect(logger.clientFacingError).toBeFunction();
-  });
-
-  it('Sends event with client facing methods', () => {
-    const logger = Logger();
-    const eventsMock = EventsMock.mockSendEvent(logger.events);
-    logger.clientFacingInfo('Message', { businessModelId: 'uuid' }, { attr1: 'Value' });
-    eventsMock.calledWithAndTimes([
-      [
-        'log_events',
-        1,
-        {
-          action: 'logEvent',
-          businessModelId: 'uuid',
-          level: 'info',
-          payload: JSON.stringify({
-            attr1: 'Value',
-          }),
-        },
-      ],
-    ]);
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/logger",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "",
   "scripts": {
     "coverage": "jest --coverage --forceExit --runInBand",
@@ -23,9 +23,7 @@
   },
   "homepage": "https://github.com/Autofleet/logger",
   "dependencies": {
-    "@autofleet/events": "^1.3.1",
     "@google-cloud/logging-winston": "^0.10.2",
-    "@google-cloud/pubsub": "^0.20.1",
     "dotenv": "^5.0.1",
     "jest": "^22.4.4",
     "object-sizeof": "^1.6.1",

package/src/debug-console-log.ts

@@ -0,0 +1,44 @@
+const Events = require('@autofleet/events');
+import logger from './logger';
+
+
+interface EntityObject {
+    entityId: string;
+    entityType: string;
+    businessModelId?: string;
+    fleetId?: string;
+    demandSourceId?: string;
+}
+
+const events = new Events({ logger });
+
+export default class DebugConsoleLog {
+    entites: EntityObject;
+    constructor(entites: EntityObject) {
+        this.entites = entites;
+    }
+
+    private generateLevelLog(level: 'info' | 'warn'| 'error') {
+        return async (msg: string, payload: any, additonalEntityies?: any) => {
+            logger[level](msg, payload);
+            events.send('log_events', 1, {
+                action: 'logEvent',
+                level,
+                ...this.entites,
+                payload: JSON.stringify(payload),
+              });
+        }
+    }
+
+    async info(msg: string, payload?: any, additonalEntityies?: any) {
+        return this.generateLevelLog('info')(msg, payload, additonalEntityies);
+    }
+
+    async warn(msg: string, payload?: any, additonalEntityies?: any) {
+        return this.generateLevelLog('warn')(msg, payload, additonalEntityies);
+    }
+
+    async error(msg: string, payload?: any, additonalEntityies?: any) {
+        return this.generateLevelLog('error')(msg, payload, additonalEntityies);
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import logger from './logger';
+import DebugConsoleLog from './debug-console-log';
+
+export {
+    DebugConsoleLog
+};
+
+export default logger;

package/src/logger.ts

@@ -0,0 +1,91 @@
+import winston from 'winston';
+
+const { createLogger } = winston;
+require('dotenv').config();
+
+const { env } = process;
+
+const isProd = env.NODE_ENV === 'production';
+
+const infoEnvNmaes = [
+  'production',
+  'staging',
+  'test',
+];
+
+const serializeError = (error: any) => {
+  const fields = ['code', 'status', 'statusCode', 'message', 'messageData', 'name', 'stack', 'stackTrace'];
+  return fields.reduce((v, field) => ({ ...v, [field]: error[field] }), {});
+};
+
+const getLevel = () => {
+  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 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 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(
+      enumerateErrorFormat(),
+      winston.format.json(),
+    );
+  }
+
+  return winston.format.combine(
+    enumerateErrorFormat(),
+    winston.format.splat(),
+    winston.format.colorize(),
+    winston.format.simple(),
+  );
+};
+
+const logger = createLogger({
+  level: getLevel(),
+  format: getFormat(),
+  transports: [
+    new winston.transports.Console(),
+  ],
+  exitOnError: false,
+});
+
+export const httpMorganInfo = (options: any) => {
+  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'],
+    },
+  });
+};
+
+export default logger;

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true
+  }
+}