@ecdt/logger 1.0.1 → 1.0.3

package/README.dev.md

@@ -1,4 +1,12 @@
-# Fiz uma atualização e agora?
+### Fiz uma atualização no código e agora?
+1. Verificar as mudanças que subirão
+``npm pack``
 
-## Atualize a versão
-npm version patch
+2. Atualize a versão
+``npm version patch``
+
+3. Publique na organização da econodata
+``npm publish --access=public``
+
+4. Atualize o cliente (Ms que importa a lib)
+``npm install @ecdt/logger@latest``

package/README.md

@@ -0,0 +1,83 @@
+### @ecdt/logger
+
+Middleware de logging para **Express** (baseado em **morgan**) com saída em **JSON** ou **string**, com suporte a campos extras (`extraFields`) e captura opcional de **stack trace** em respostas **5xx**.
+
+### Instalação
+
+```bash
+npm i @ecdt/logger
+```
+### Uso (Express)
+
+#### Logger padrão (JSON)
+
+```js
+const express = require('express');
+const { createLogger, createErrorCapture } = require('@ecdt/logger');
+
+const app = express();
+app.use(express.json());
+
+// 1) Logger (no começo)
+app.use(createLogger());
+
+app.get('/', (_req, res) => res.status(200).send('ok'));
+
+// 2) Error handler (sempre por último)
+app.use(createErrorCapture());
+```
+
+#### Logger com opções
+
+```js
+app.use(
+  createLogger({
+    format: 'json', // 'json' | 'string'
+    extraFields: {
+      service: 'minha-api',
+      env: process.env.NODE_ENV,
+    },
+    includeStackErrors5xx: true, // default: true
+  })
+);
+```
+
+### Captura de stack em 5xx
+
+- Para o logger incluir `error.stack`, é necessário que **`res.error` esteja preenchido**.
+- A forma recomendada é usar o middleware `createErrorCapture()` **por último**, pois ele seta `res.error` e responde `500`.
+
+Exemplo:
+
+```js
+app.get('/throw-error', (_req, _res) => {
+  // erro síncrono: o Express encaminha para o error handler
+  throw new Error('boom');
+});
+
+app.use(createErrorCapture());
+```
+
+Se você apenas fizer `res.status(500).send(...)` em uma rota, o status será 500, mas **não haverá stack** (porque não existe erro capturado em `res.error`).
+
+### Formatos de saída
+
+- **`format: 'json'` (default)**: log em JSON com `method`, `url`, `status`, `responseTime`, `payload` e `extraFields`.
+- **`format: 'string'`**: log em texto (campos extras são concatenados).
+
+### Opções (`createLogger(options)`)
+
+- **`format?: 'json' | 'string' | string`**: formato do log (default: `'json'`).
+- **`extraFields?: Record<string, unknown>`**: campos extras para serem adicionados ao log.
+- **`includeStackErrors5xx?: boolean`**: inclui stack de erro quando `status >= 500` e `res.error.stack` existir (default: `true`).
+
+### TypeScript
+
+O pacote expõe definições em `index.d.ts`. Exemplo:
+
+```ts
+import { createLogger, createErrorCapture } from '@ecdt/logger';
+
+app.use(createLogger({ format: 'json' }));
+app.use(createErrorCapture());
+```

package/examples/express.js

@@ -1,8 +1,8 @@
 const express = require("express");
-const { createLogger } = require("../src");
+const { createLogger, createErrorCapture } = require("../src");
 
 const app = express();
-
+app.use(express.json());
 app.use(
   createLogger({
     format: 'json',
@@ -12,16 +12,56 @@ app.use(
   })
 );
 
+
+
 app.get("/health", (_req, res) => {
   res.status(200).json({ ok: true });
 });
 
+
+// Examples status 200
 app.get("/", (_req, res) => {
   res.status(200).send("hello");
 });
+app.post("/post", (_req, res) => {
+  res.status(200).send("posted");
+})
+
+app.patch("/patch", (_req, res) => {
+  res.status(200).send("patched");
+})
+
+
+app.put("/put", (_req, res) => {
+  res.status(200).send("putted");
+})
+
+// Examples status 500
+app.get("/get-error", (_req, res) => {
+  res.status(500).send("get error example");
+})
+
+app.post("/post-error", (_req, res) => {
+  res.status(500).send("post error example");
+})
+
+app.patch("/patch-error", (_req, res) => {
+  res.status(500).send("error patch example");
+})
+
+app.put("/put-error", (_req, res) => {
+  res.status(500).send("error put example");
+})
+
+// Stack log
+app.get("/throw-error", (_req, res) => {
+  throw new Error('throw error example');
+})
+
+// Error handler (sempre por último, após as rotas)
+app.use(createErrorCapture());
 
 const port = Number(process.env.PORT || 7878);
 app.listen(port, () => {
   console.log(`Example server listening on http://localhost:${port}`);
-});
-
+});

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@ecdt/logger",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Logger padronização de microsserviços da Econodata",
+  "type": "commonjs",
   "main": "src/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/src/constants.cjs

@@ -0,0 +1,5 @@
+const formatsSupported = ['json', 'string']
+const loggersSupported = ['morgan']
+
+module.exports = { formatsSupported, loggersSupported }
+

package/src/index.d.ts

@@ -2,9 +2,17 @@ declare module '@ecdt/logger' {
     export type LoggerOptions = {
       format?: string;
       extraFields?: Record<string, unknown>;
+      includeStackErrors5xx?: boolean;
     };
   
     export function createLogger(
       options?: LoggerOptions
     ): (req: unknown, res: unknown, next: unknown) => void;
+
+    export function createErrorCapture(): (
+      err: unknown,
+      req: unknown,
+      res: { locals?: Record<string, unknown> } & Record<string, unknown>,
+      next: (err: unknown) => void
+    ) => void;
   }

package/src/index.js

@@ -1,41 +1,33 @@
-var { formatsSupported } = require('./constants')
-var morgan = require('morgan')
+const morgan = require('morgan')
+const logFormatter = require('./services/logFormatter');
+const { loggersSupported } = require('./constants.cjs');
 
 function createLogger(options = {}) {
-    return morgan((tokens, req, res) => {
-        return format(tokens, req, res, options);
+  const logger = options.logger ?? 'morgan'
 
-    });
-  }
-
-function format(tokens, req, res, options = {}){
-  if(!options || !options.format)options.format = 'json'
-  
-  const format = (options.format).toLowerCase()
-  if(!formatsSupported.includes(format)){
-    return `*!* Formato informado "[${format}]" não é suportado.\n*!*Formatos suportados: ${formatsSupported.join(' , ')} `
-  }
-
-  const payload = addPayload(tokens.method(req,res), req)
-  
-  switch (format) {
-    case 'json':
-      return JSON.stringify({
-        method: tokens.method(req, res),
-        url: tokens.url(req, res),
-        status: tokens.status(req, res),
-        responseTime: tokens['response-time'](req, res) + ' ms',
-        payload: payload,
-        ...options.extraFields
+  switch (logger) {
+    case 'morgan': {
+      return morgan((tokens, req, res) => {
+        const log = logFormatter.formatLog(tokens, req, res, options);
+        return log;
       });
+    }
+    default: {
+      console.warn(`Logger não suportado. Escolha uma das opções: ${loggersSupported}`);
+      // Evita quebrar o app com `app.use(null)`
+      return (_req, _res, next) => next();
+    }
   }
 }
 
-function addPayload(log, method, req) {
-    switch (method) {
-      case "POST":
-        return req.body || {};
+function createErrorCapture() {
+  return function errorCapture(err, req, res, next) {
+    res.error = {
+      message: err?.message,
+      stack: err?.stack
     }
+    res.status(500).json({ error: 'Erro interno' });
   }
+}
   
-  module.exports = { createLogger };
+  module.exports = { createLogger, createErrorCapture };

package/src/services/logFormatter.js

@@ -0,0 +1,73 @@
+const { formatsSupported } = require('../constants.cjs');
+const  payload = require('./payload');
+function formatLog(tokens, req, res, options = {}){
+    // Normaliza options sem mutar o objeto original (evita "vazar" error stack entre requests)
+    const normalized = normalizeOptions(options)
+
+    const format = (normalized.format).toLowerCase()
+    if(!formatsSupported.includes(format)){
+      return `*!* Formato informado "[${format}]" não é suportado.\n*!*Formatos suportados: ${formatsSupported.join(' , ')} `
+    }
+      
+    const _method = tokens.method(req, res);
+    const _url = tokens.url(req, res);
+    const _status = tokens.status(req, res);
+    const _responseTime = tokens['response-time'](req, res) + ' ms'
+    const _payload = payload.addPayload(req);
+    
+    // `extraFields` é clonado por request, então podemos anexar info do erro com segurança
+    if(_status >= 500 && res.error && res.error.stack && normalized.includeStackErrors5xx) {
+      normalized.extraFields.error = {
+        message: res.error.message ?? '',
+        stack: res.error.stack
+      }
+    }
+
+    switch (format) {
+      case 'json':
+        return JSON.stringify({
+          method: _method,
+          url: _url,
+          status: _status,
+          responseTime: _responseTime,
+          payload: _payload,
+          ...normalized.extraFields
+        });
+      case 'string':
+        const extraFieldsToString = formatExtraFields(normalized.extraFields)
+        return `${_method} - ${_status} - ${_responseTime} - ${_payload} - ${extraFieldsToString}`;;
+    }
+  }
+
+function formatExtraFields(extraFields = {}){
+  
+  const formatValues = (val) => {
+    switch(typeof(val)){
+      case 'object':
+          return Array.isArray(val) ? `[${val}]` : JSON.stringify(val);
+      default:
+          return val;
+    }
+  }
+
+  let string = ''
+  for(let val of Object.values(extraFields)){
+    val = formatValues(val);
+    string += `${val} - `
+  }
+
+  string = string.trim();
+   
+  return string.slice(0, string.length-1);
+}
+
+function normalizeOptions(options) {
+    const input = options ?? {};
+    return {
+      extraFields: { ...(input.extraFields ?? {}) },
+      format: input.format ?? 'json',
+      includeStackErrors5xx: input.includeStackErrors5xx ?? true
+    }
+}
+  
+module.exports = { formatLog }

package/src/services/payload.js

@@ -0,0 +1,16 @@
+function addPayload(req){
+    switch(req.method){
+      case 'GET':
+        return '';
+      case 'POST':
+      case 'PUT':
+      case 'PATCH':
+      case 'DELETE':
+        if(req.body) return JSON.stringify(req.body);
+        return null;
+      default:
+        return `Request payload for ${req.method} method not implemented`;
+    }
+};
+   
+module.exports = { addPayload }

package/src/constants.js

@@ -1,3 +0,0 @@
-const formatsSupported = ['json', 'string']
-
-module.exports = { formatsSupported }