@hvedinich/utils 0.0.62 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hvedinich/utils",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "description": "utils module",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,8 @@
     "axios": "^0.27.2",
     "express": "4.17.1",
     "graphql-playground-middleware-express": "1.7.20",
-    "jsonwebtoken": "8.5.1"
+    "jsonwebtoken": "8.5.1",
+    "pino": "^9.5.0"
   },
   "devDependencies": {
     "eslint": "^7.2.0",

package/src/log/index.js

@@ -1,25 +1,60 @@
-const ctxToString = (ctx) => {
-  if (!ctx) return 'unknown';
-  let str = '';
-  if (ctx.uid) {
-    str += `uid: ${ctx.uid}; `;
-  }
-  return str;
+const pino = require('pino');
+
+const ctxParser = ctx => {
+  if (!ctx) return { uid: 'unknown' };
+  return ctx.uid ? { uid: ctx.uid, permission: ctx.permission } : { uid: 'unknown' };
+};
+
+const errorParser = error => {
+  if (!error) return null;
+  return {
+    stack: error.stack,
+    code: error.code,
+    message: error.message,
+    status: error.status,
+    sanitized: error.sanitized,
+  };
+};
+
+const PinoLevelToSeverityLookup = {
+  debug: 'DEBUG',
+  info: 'INFO',
+  error: 'ERROR',
 };
 module.exports = class Logger {
-  constructor(name) {
-    this.name = name;
+  constructor(name, environment) {
+    this.logger = pino({
+      name,
+      mixin() {
+        return { environment };
+      },
+      level: 'debug',
+      timestamp: pino.stdTimeFunctions.isoTime,
+      formatters: {
+        level(label, number) {
+          return {
+            severity: PinoLevelToSeverityLookup[label] || PinoLevelToSeverityLookup.info,
+            level: number,
+          };
+        },
+        log: object => {
+          const ctx = ctxParser(object?.ctx);
+          return { ...object, ctx };
+        },
+      },
+    });
   }
 
-  error(str, ctx) {
-    console.error(`[${this.name}] [ERROR] ${new Date().toISOString().replace(/[T]|(\..*Z$)+/gi, ' ')}: ${str}`, ctxToString(ctx));
+  error(str, ctx, params) {
+    const { error, ...fields } = params || {};
+    this.logger.error({ ctx, error: errorParser(error), fields }, str);
   }
 
-  info(str, ctx) {
-    console.log(`[${this.name}] [INFO] ${new Date().toISOString().replace(/[T]|(\..*Z$)+/gi, ' ')}: ${str}`, ctxToString(ctx));
+  info(str, ctx, fields) {
+    this.logger.info({ ctx, fields }, str);
   }
 
-  debug(str, ctx) {
-    console.debug(`[${this.name}] [DEBUG] ${new Date().toISOString().replace(/[T]|(\..*Z$)+/gi, ' ')}: ${str}`, ctxToString(ctx));
+  debug(str, ctx, fields) {
+    this.logger.debug({ ctx, fields }, str);
   }
 };

package/src/server/index.js

@@ -2,7 +2,10 @@ const express = require('express');
 const expressPlayground = require('graphql-playground-middleware-express').default;
 const axios = require('axios');
 const { ApolloServer, ApolloError } = require('apollo-server-express');
-const { guestCtx, token: { EXPIRED, UNAUTHORIZED } } = require('../constants');
+const {
+  guestCtx,
+  token: { EXPIRED, UNAUTHORIZED },
+} = require('../constants');
 const { addContext } = require('../utils/contextUtils');
 
 const logError = (err, logger = console) => {
@@ -11,15 +14,23 @@ const logError = (err, logger = console) => {
     description.path = err.path && err.path[0] ? err.path[0] : 'unknown';
     description.message = err.message;
     description.serviceName = err.extensions.serviceName;
-    description.stack = err.extensions && err.extensions.exception
-      && err.extensions.exception.stacktrace
-      ? JSON.stringify(err.extensions.exception.stacktrace)
-      : 'unknown';
+    description.stack =
+      err.extensions && err.extensions.exception && err.extensions.exception.stacktrace
+        ? JSON.stringify(err.extensions.exception.stacktrace)
+        : 'unknown';
   } finally {
-    logger.error(`path: ${description.path}
-          message: ${description.message}
-          serviceName: ${description.serviceName}
-          stack: ${description.stack}`);
+    logger.error(
+      `Server error`,
+      {},
+      {
+        error: {
+          path: description.path,
+          message: description.message,
+          serviceName: description.serviceName,
+          stack: description.stack,
+        },
+      },
+    );
   }
 };
 
@@ -44,9 +55,7 @@ class Server {
     this.app.get('/_status', healthCheck || defaultCHealthCheck);
   }
 
-  initGQL({
-    gateway, schema, context, options, logger, errorHandler,
-  }) {
+  initGQL({ gateway, schema, context, options, logger, errorHandler }) {
     if (!gateway && !schema) {
       console.error('Schema not found');
       return;
@@ -54,7 +63,7 @@ class Server {
 
     const serverOptions = {
       context: context || defaultContext,
-      formatError: (err) => {
+      formatError: err => {
         logError(err, logger);
         if (errorHandler) return errorHandler(err);
         if (err.name === 'TokenExpiredError') {
@@ -67,8 +76,11 @@ class Server {
           return new ApolloError(err.extensions.sanitized, err.extensions.code, err.extensions);
         }
         if (err.extensions && err.extensions.exception && err.extensions.exception.sanitized) {
-          return new ApolloError(err.extensions.exception.sanitized,
-            err.extensions.exception.code, err.extensions.exception);
+          return new ApolloError(
+            err.extensions.exception.sanitized,
+            err.extensions.exception.code,
+            err.extensions.exception,
+          );
         }
         if (err.name === 'GraphQLError' || err.name === 'ValidationError') {
           return new ApolloError(err.message, err.name);
@@ -94,9 +106,7 @@ class Server {
   }
 
   addEndpoints(endpoints) {
-    endpoints.forEach(({
-      path, method, handler, proxy,
-    }) => {
+    endpoints.forEach(({ path, method, handler, proxy }) => {
       if (proxy) {
         this.app.use(path, proxy);
       } else {
@@ -115,8 +125,8 @@ const waitServices = async (services = {}, logger = console) => {
   while (shouldWait) {
     try {
       // eslint-disable-next-line no-await-in-loop
-      const statuses = await Promise.all(Object.values(services)
-        .map(async ({ wait, name, url }) => {
+      const statuses = await Promise.all(
+        Object.values(services).map(async ({ wait, name, url }) => {
           if (!wait) {
             logger.info(`${name}: ready "true"`);
             return true;
@@ -128,15 +138,22 @@ const waitServices = async (services = {}, logger = console) => {
           }
           logger.info(`${name}: ready "false"`);
           return false;
-        }));
+        }),
+      );
       if (statuses.every(Boolean)) {
         shouldWait = false;
       }
-      // eslint-disable-next-line no-await-in-loop
+      // eslint-disable-next-line no-await-in-loop, no-promise-executor-return
       await new Promise(res => setTimeout(res, 5000));
-    } catch (err) {
-      logger.debug(err);
-      // eslint-disable-next-line no-await-in-loop
+    } catch (error) {
+      logger.error(
+        `waitServices error`,
+        {},
+        {
+          error,
+        },
+      );
+      // eslint-disable-next-line no-await-in-loop, no-promise-executor-return
       await new Promise(res => setTimeout(res, 5000));
     }
   }
@@ -149,10 +166,14 @@ let isHealthyQueue = true;
  */
 const checkIsAlive = () => isHealthyQueue;
 
-const setQueueHealthCheck = (value) => {
+const setQueueHealthCheck = value => {
   isHealthyQueue = value;
 };
 
 module.exports = {
-  Server, waitServices, express, checkIsAlive, setQueueHealthCheck,
+  Server,
+  waitServices,
+  express,
+  checkIsAlive,
+  setQueueHealthCheck,
 };