azify-logger 1.0.26 → 1.0.28

package/middleware-express.js

@@ -1,413 +1,264 @@
-const axios = require('axios')
-const { als, runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+const { runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+const { createHttpLoggerTransport } = require('./streams/httpQueue')
+const { randomUUID } = require('crypto')
+const os = require('os')
+
+const HEADER_WHITELIST = new Set([
+  'content-type',
+  'content-length',
+  'accept',
+  'accept-encoding',
+  'user-agent',
+  'host',
+  'x-request-id',
+  'x-trace-id',
+  'x-span-id',
+  'x-parent-span-id'
+])
+
+function pickHeaders(source) {
+  if (!source || typeof source !== 'object') {
+    return {}
+  }
+  const result = {}
+  for (const key in source) {
+    const lower = key.toLowerCase()
+    if (!HEADER_WHITELIST.has(lower)) continue
+    
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue
+    
+    const value = source[key]
+    if (Array.isArray(value)) {
+      result[key] = value.map(String)
+    } else if (value != null) {
+      result[key] = String(value)
+    }
+  }
+  return result
+}
 
-/**
- * Creates an Express middleware for automatic request/response logging with azify-logger
- * @param {Object} options - Configuration options
- * @param {string} [options.serviceName] - Name of the service (defaults to APP_NAME env var or 'assemble')
- * @param {string} [options.loggerUrl] - URL of the azify-logger service (defaults to AZIFY_LOGGER_URL env var or 'http://localhost:3001')
- * @param {string} [options.environment] - Environment name (defaults to NODE_ENV env var or 'development')
- * @returns {Function} Express middleware function
- * @example
- * const azifyMiddleware = require('azify-logger/middleware-express');
- * app.use(azifyMiddleware({ serviceName: 'my-app' }));
- */
 function createExpressLoggingMiddleware(options = {}) {
   const config = {
-    serviceName: options.serviceName || process.env.APP_NAME || 'assemble',
-    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001',
-    environment: options.environment || process.env.NODE_ENV || 'development'
+    serviceName: options.serviceName || process.env.APP_NAME,
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log',
+    environment: options.environment || process.env.NODE_ENV,
+    captureResponseBody: options.captureResponseBody !== false && process.env.AZIFY_LOGGER_CAPTURE_RESPONSE_BODY !== 'false',
+    captureRequestBody: options.captureRequestBody !== false && process.env.AZIFY_LOGGER_CAPTURE_REQUEST_BODY !== 'false',
+    logRequest: options.logRequest !== false && process.env.AZIFY_LOGGER_LOG_REQUEST !== 'false',
+    captureHeaders: options.captureHeaders !== undefined ? options.captureHeaders : process.env.AZIFY_LOGGER_CAPTURE_HEADERS === 'true'
   }
 
-  /**
-   * Sends a log entry to the azify-logger service
-   * @param {string} level - Log level (info, error, warn, debug)
-   * @param {string} message - Log message
-   * @param {Object} [meta={}] - Additional metadata to include in the log
-   * @private
-   */
-  async function sendLog(level, message, meta = {}) {
-    const logData = {
-      level,
-      message,
-      meta: {
-        ...meta,
+  const transport = createHttpLoggerTransport(config.loggerUrl, {})
+
+  const hostname = os.hostname()
+  
+  function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') return
+    
+    try {
+      const metaObj = {
         service: {
           name: config.serviceName,
           version: '1.0.0'
         },
         environment: config.environment,
         timestamp: new Date().toISOString(),
-        hostname: require('os').hostname()
+        hostname: hostname,
+        ...meta
       }
-    }
-
-    try {
-      await axios.post(`${config.loggerUrl}`, logData, {
-        timeout: 5000
-      })
-    } catch (error) {
-      console.error('Erro ao enviar log:', error.message)
-    }
+      
+      transport.enqueue({
+        level,
+        message,
+        meta: metaObj
+      }, { 'content-type': 'application/json' })
+    } catch (err) { }
   }
 
-  /**
-   * Express middleware function that logs requests and responses
-   * @param {Object} req - Express request object
-   * @param {Object} res - Express response object  
-   * @param {Function} next - Express next function
-   * @returns {void}
-   */
   return function azifyExpressLoggingMiddleware(req, res, next) {
     const startTime = Date.now()
-    const requestId = req.requestId || require('uuid').v4()
-    const middlewareId = require('uuid').v4().substring(0, 8)
-    
-    let existingTraceId = null
-    let existingSpanId = null
-    let existingParentSpanId = null
-    
-    if (req.headers['x-trace-id']) {
-      existingTraceId = req.headers['x-trace-id']
-      existingSpanId = req.headers['x-span-id']
-      existingParentSpanId = req.headers['x-parent-span-id']
-    }
-    
-    const currentCtx = getRequestContext()
-    if (currentCtx && currentCtx.traceId) {
-      existingTraceId = currentCtx.traceId
-      existingSpanId = currentCtx.spanId
-      existingParentSpanId = currentCtx.parentSpanId
-    }
+    const method = req.method
+    const url = req.url
+    const path = req.path || url
     
-    let reqCtx
-    if (existingTraceId) {
-      reqCtx = {
-        traceId: existingTraceId,
-        spanId: existingSpanId || require('uuid').v4().substring(0, 16),
-        parentSpanId: existingParentSpanId,
-        requestId: requestId
-      }
-    } else {
-      reqCtx = startRequestContext({ requestId })
-    }
+    let responseChunk = null
+    let responseChunkCaptured = false
+    let logSent = false
     
-    const requestTraceId = reqCtx.traceId
-    const requestSpanId = reqCtx.spanId
-    const requestParentSpanId = reqCtx.parentSpanId
-
-    const originalConsole = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error
-    }
-
-    console.log = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('info', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
-
-    console.info = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('info', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
-
-    console.warn = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('warn', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
-
-    console.error = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('error', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
+    let requestId, traceId, spanId, parentSpanId, reqCtx, clientIp, query, cachedHeaders
+    let idsCreated = false
+    let headersCached = false
     
-    let baseUrl = req.url
-    if (baseUrl.includes('?')) {
-      baseUrl = baseUrl.substring(0, baseUrl.indexOf('?'))
-    }
-    baseUrl = baseUrl.replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '/{id}')
-    baseUrl = baseUrl.replace(/\/[0-9]+/g, '/{id}')
-
-    function sanitizeHeaders(headers) {
-      const sanitized = { ...headers }
-      const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key', 'x-auth-token', 'x-access-token']
+    function ensureIds() {
+      if (idsCreated) return
+      idsCreated = true
       
-      for (const key of Object.keys(sanitized)) {
-        if (sensitiveHeaders.includes(key.toLowerCase())) {
-          sanitized[key] = '***'
-        }
-      }
+      query = req.query
       
-      return sanitized
-    }
-
-    function sanitizeBody(body) {
-      if (!body || typeof body !== 'object') return body
+      const currentCtx = getRequestContext()
+      const headerTraceId = req.headers['x-trace-id']
+      const headerParentSpanId = req.headers['x-parent-span-id']
       
-      const sanitized = Array.isArray(body) ? [...body] : { ...body }
-      const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'api_key', 'accessToken', 'access_token', 'refreshToken', 'refresh_token', 'clientSecret', 'client_secret']
+      if (currentCtx?.traceId) {
+        traceId = currentCtx.traceId
+      } else if (headerTraceId) {
+        traceId = headerTraceId
+      } else {
+        traceId = randomUUID()
+      }
       
-      for (const key of Object.keys(sanitized)) {
-        if (sensitiveFields.includes(key) || key.toLowerCase().includes('password') || key.toLowerCase().includes('secret')) {
-          sanitized[key] = '***'
+      parentSpanId = currentCtx?.spanId || headerParentSpanId || null
+      
+      if (!req.requestId) {
+        const singleUUID = randomUUID()
+        requestId = singleUUID
+        spanId = singleUUID.replace(/-/g, '').substring(0, 16)
+      } else {
+        requestId = req.requestId
+        if (requestId.length >= 16) {
+          spanId = requestId.replace(/-/g, '').substring(0, 16)
+        } else if (traceId.length >= 16) {
+          spanId = traceId.replace(/-/g, '').substring(0, 16)
+        } else {
+          spanId = randomUUID().replace(/-/g, '').substring(0, 16)
         }
       }
       
-      return sanitized
-    }
-
-    req._azifyRequestData = {
-      requestId,
-      method: req.method,
-      url: req.url,
-      baseUrl: baseUrl,
-      path: req.url,
-      headers: sanitizeHeaders(req.headers || {}),
-      query: req.query || {},
-      userAgent: (req.headers && req.headers['user-agent']) || 'unknown',
-      ip: (req.connection && req.connection.remoteAddress) || (req.socket && req.socket.remoteAddress) || req.ip || 'unknown',
-      traceId: requestTraceId,
-      spanId: requestSpanId,
-      parentSpanId: requestParentSpanId
+      clientIp = req.ip || req.connection?.remoteAddress || req.socket?.remoteAddress || 'unknown'
+      
+      reqCtx = startRequestContext({ requestId, traceId, spanId, parentSpanId })
     }
-
-    if (req.method === 'GET') {
-      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
-    } else {
-      if (req.body !== undefined) {
-        req._azifyRequestData.requestBody = sanitizeBody(req.body)
-      }
-      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
+    
+    function ensureHeaders() {
+      if (headersCached) return
+      headersCached = true
+      cachedHeaders = config.captureHeaders ? pickHeaders(req.headers || {}) : {}
     }
-
-    res.on('finish', () => {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-      console.log = originalConsole.log
-      console.info = originalConsole.info
-      console.warn = originalConsole.warn
-      console.error = originalConsole.error
-    })
-
-    res.on('close', () => {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-      console.log = originalConsole.log
-      console.info = originalConsole.info
-      console.warn = originalConsole.warn
-      console.error = originalConsole.error
-    })
-
-    let sentBody
-    let responseLogged = false
     
-    const originalSend = res.send && res.send.bind(res)
-    if (originalSend) {
-      res.send = function patchedSend() {
+    if (config.logRequest) {
+      setImmediate(() => {
         try {
-          if (arguments.length === 1) {
-            sentBody = arguments[0]
-          } else if (arguments.length >= 2) {
-            sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
+          ensureIds()
+          ensureHeaders()
+          const request = {
+            id: requestId,
+            method,
+            url,
+            path,
+            query: query || {},
+            headers: cachedHeaders,
+            ip: clientIp
           }
-        } catch (_) {}
-        
-        if (!responseLogged) {
-          logResponse()
-          responseLogged = true
-        }
-        
-        return originalSend.apply(this, arguments)
-      }
-    }
-
-    const originalStatus = res.status
-    res.status = function(code) {
-      res._actualStatusCode = code
-      return originalStatus.call(this, code)
+          if (req.body && config.captureRequestBody) {
+            request.body = req.body
+          }
+          sendLog('info', `[REQUEST] ${method} ${url}`, {
+            traceId: reqCtx.traceId,
+            spanId: reqCtx.spanId,
+            parentSpanId: reqCtx.parentSpanId,
+            requestId: requestId,
+            request: request
+          })
+        } catch (err) { }
+      })
     }
     
-    const originalWriteHead = res.writeHead
-    res.writeHead = function(statusCode, statusMessage, headers) {
-      res._actualStatusCode = statusCode
-      if (typeof statusMessage === 'object') {
-        headers = statusMessage
-        statusMessage = undefined
-      }
-      return originalWriteHead.call(this, statusCode, statusMessage, headers)
-    }
+    const originalEnd = res.end.bind(res)
     
-    const originalJsonMethod = res.json
-    res.json = function(code, body) {
-      try {
-        if (arguments.length === 1) {
-          sentBody = arguments[0]
-        } else if (arguments.length >= 2) {
-          sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
-        }
-      } catch (_) {}
-      
-      if (typeof code === 'number') {
-        res._actualStatusCode = code
-      } else {
-        const errorObj = arguments.length === 1 ? arguments[0] : (typeof arguments[0] === 'number' ? arguments[1] : arguments[0])
+    res.end = (chunk, encoding) => {
+      const result = originalEnd(chunk, encoding)
+
+      setImmediate(() => {
+        if (logSent) return
+        logSent = true
         
-        if (errorObj && errorObj.constructor && errorObj.constructor.name === 'ErrCtor') {
-          const errorName = errorObj.toString()
-          if (errorName.includes('InternalServerError') || errorName.includes('InternalError')) {
-            res._actualStatusCode = 500
-          } else if (errorName.includes('BadRequest') || errorName.includes('BadDigest')) {
-            res._actualStatusCode = 400
-          } else if (errorName.includes('NotFound')) {
-            res._actualStatusCode = 404
-          } else if (errorName.includes('Unauthorized')) {
-            res._actualStatusCode = 401
-          } else if (errorName.includes('Forbidden')) {
-            res._actualStatusCode = 403
-          } else {
-            res._actualStatusCode = 500
+        try {
+          if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+            responseChunk = chunk
+            responseChunkCaptured = true
           }
-        } else {
-          res._actualStatusCode = res.statusCode || 200
-        }
-      }
-      
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-      
-      return originalJsonMethod.apply(this, arguments)
-    }
-    
-    res.on('finish', function() {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-    })
-
-    const originalEnd = res.end
-    res.end = function(chunk, encoding) {
-      const duration = Date.now() - startTime
-      
-      let responseBody = sentBody
-      try {
-        if (responseBody == null && chunk) {
-          if (Buffer.isBuffer(chunk)) {
-            responseBody = chunk.toString('utf8')
-          } else if (typeof chunk === 'string') {
-            responseBody = chunk
-          } else {
-            responseBody = JSON.stringify(chunk)
+          
+          ensureIds()
+          
+          const statusCode = res.statusCode || 200
+          const duration = Date.now() - startTime
+          
+          const response = { statusCode, durationMs: duration }
+          if (responseChunk !== null && responseChunkCaptured && config.captureResponseBody) {
+            response.body = responseChunk
           }
-        }
-      } catch (_) {}
-
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-
-      originalEnd.call(this, chunk, encoding)
-    }
-    
-    /**
-     * Logs the response data to azify-logger
-     * @private
-     */
-    function logResponse() {
-      const duration = Date.now() - startTime
-      
-      let responseBody = sentBody
-      
-      let serializedResponseBody
-      try {
-        if (typeof responseBody === 'string') {
-          serializedResponseBody = responseBody
-        } else if (Array.isArray(responseBody)) {
-          serializedResponseBody = JSON.stringify(responseBody)
-        } else if (responseBody && typeof responseBody === 'object') {
-          if (responseBody.toJSON && typeof responseBody.toJSON === 'function') {
-            serializedResponseBody = JSON.stringify(responseBody.toJSON())
-          } else if (responseBody.toString && typeof responseBody.toString === 'function' && responseBody.toString() !== '[object Object]') {
-            serializedResponseBody = responseBody.toString()
-          } else {
-            serializedResponseBody = JSON.stringify(responseBody, (key, value) => {
-              if (typeof value === 'function') {
-                return '[Function]'
-              }
-              if (value instanceof Error) {
-                return { name: value.name, message: value.message, stack: value.stack }
-              }
-              return value
-            }, null, 0)
+          
+          if (config.captureHeaders) {
+            ensureHeaders()
           }
-        } else {
-          serializedResponseBody = responseBody != null ? String(responseBody) : ''
-        }
-      } catch (error) {
-        try {
-          serializedResponseBody = JSON.stringify(responseBody, null, 2)
-        } catch (secondError) {
-          serializedResponseBody = '[Complex object - serialization failed]'
-        }
-      }
-      
-      const statusCode = res._actualStatusCode || res._statusCode || res.statusCode || 200
-      
-      const responseMessage = serializedResponseBody && serializedResponseBody.length > 0
-        ? `[RESPONSE] ${serializedResponseBody}`
-        : `[RESPONSE] ${req.method} ${req.url} ${statusCode} ${duration}ms`
-      
-      const responseData = {
-        ...req._azifyRequestData,
-        requestBody: req.body,
-        statusCode: statusCode,
-        responseTime: duration,
-        responseHeaders: res.getHeaders ? res.getHeaders() : {},
-        responseBody: serializedResponseBody
-      }
+          
+          const meta = {
+            traceId: reqCtx.traceId,
+            spanId: reqCtx.spanId,
+            parentSpanId: reqCtx.parentSpanId,
+            requestId: requestId,
+            request: {
+              id: requestId,
+              method,
+              url,
+              path,
+              query: query || {},
+              headers: config.captureHeaders ? (cachedHeaders || {}) : {},
+              ip: clientIp
+            },
+            response: response
+          }
+          
+          sendLog('info', `[RESPONSE] ${method} ${url}`, meta)
+        } catch (err) { }
+      })
       
-      try { res._azifyResponseLogged = true } catch (_) {}
-      sendLog('info', responseMessage, responseData)
+      return result
     }
 
-    req._azifyContext = reqCtx
-    
     try {
-      runWithRequestContext(reqCtx, () => {
-        next()
-      })
-    } catch (error) {
-      console.error('Error in azify middleware:', error)
       next()
+    } catch (err) {
+      if (!logSent) {
+        logSent = true
+        ensureIds()
+        runWithRequestContext(reqCtx, () => {
+          process.stderr.write(`[azify-logger][middleware] Erro no next(): ${err?.message || String(err)}\n`)
+          setImmediate(() => {
+            try {
+              const statusCode = res.statusCode || 500
+              const duration = Date.now() - startTime
+              
+              ensureHeaders()
+              
+              const response = { statusCode, durationMs: duration }
+              const meta = {
+                traceId: reqCtx.traceId,
+                spanId: reqCtx.spanId,
+                parentSpanId: reqCtx.parentSpanId,
+                requestId: requestId,
+                request: {
+                  id: requestId,
+                  method,
+                  url,
+                  path,
+                  query: query || {},
+                  headers: cachedHeaders,
+                  ip: clientIp
+                },
+                response: response,
+                error: {
+                  message: err?.message || String(err),
+                  name: err?.name || 'Error',
+                  stack: err?.stack
+                }
+              }
+              sendLog('error', `[RESPONSE] ${method} ${url}`, meta)
+            } catch (logErr) { }
+          })
+        })
+      }
+      throw err
     }
   }
 }