azify-logger 1.0.26 → 1.0.29

package/middleware-express.js

@@ -1,413 +1,314 @@
-const axios = require('axios')
-const { als, runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+const { startRequestContext } = require('./store')
+const { createHttpLoggerTransport } = require('./streams/httpQueue')
+const { Worker } = require('worker_threads')
+const path = require('path')
+const os = require('os')
 
-/**
- * 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'
-  }
+function fastUUID() {
+  const timestamp = Date.now().toString(36)
+  const randomPart = Math.random().toString(36).substring(2, 15)
+  const randomPart2 = Math.random().toString(36).substring(2, 15)
+  return `${timestamp}-${randomPart}-${randomPart2}`.substring(0, 36)
+}
 
-  /**
-   * 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,
-        service: {
-          name: config.serviceName,
-          version: '1.0.0'
-        },
-        environment: config.environment,
-        timestamp: new Date().toISOString(),
-        hostname: require('os').hostname()
-      }
-    }
+function sanitizeTraceHex(value) {
+  if (!value || typeof value !== 'string') return null
+  const hex = value.replace(/[^0-9a-fA-F]/g, '').toLowerCase()
+  if (!hex) return null
+  return hex.padEnd(32, '0').slice(0, 32)
+}
 
+function safeSerializeBody(payload) {
+  if (payload == null) return ''
+  if (typeof payload === 'string') return payload
+  if (Buffer.isBuffer(payload)) return payload.toString('utf8')
+  try {
+    return JSON.stringify(payload)
+  } catch (err) {
     try {
-      await axios.post(`${config.loggerUrl}`, logData, {
-        timeout: 5000
-      })
-    } catch (error) {
-      console.error('Erro ao enviar log:', error.message)
+      return String(payload)
+    } catch {
+      return ''
     }
   }
+}
 
-  /**
-   * 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
-    }
+function normalizeChunkToBuffer(chunk) {
+  if (chunk == null) return null
+  if (Buffer.isBuffer(chunk)) return chunk
+  if (typeof chunk === 'string') return Buffer.from(chunk)
+  if (chunk && chunk.type === 'Buffer' && Array.isArray(chunk.data)) {
+    return Buffer.from(chunk.data)
+  }
+  try {
+    return Buffer.from(String(chunk))
+  } catch {
+    return null
+  }
+}
+
+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
     
-    let reqCtx
-    if (existingTraceId) {
-      reqCtx = {
-        traceId: existingTraceId,
-        spanId: existingSpanId || require('uuid').v4().substring(0, 16),
-        parentSpanId: existingParentSpanId,
-        requestId: requestId
-      }
-    } else {
-      reqCtx = startRequestContext({ requestId })
-    }
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue
     
-    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
+    const value = source[key]
+    if (Array.isArray(value)) {
+      result[key] = value.map(String)
+    } else if (value != null) {
+      result[key] = String(value)
     }
+  }
+  return result
+}
 
-    console.log = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('info', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
+function createExpressLoggingMiddleware(options = {}) {
+  const config = {
+    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'
+  }
 
-    console.info = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('info', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
-    }
+  const transport = createHttpLoggerTransport(config.loggerUrl, {})
 
-    console.warn = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('warn', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
+  const hostname = os.hostname()
+  
+  const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
+  
+  const workerPool = []
+  const cpuCount = Math.max(1, (os.cpus() || []).length || 1)
+  const WORKER_POOL_SIZE = Math.min(8, Math.max(2, cpuCount))
+  const maxWorkers = Math.min(WORKER_POOL_SIZE, cpuCount)
+  let workerIndex = 0
+  let poolInitialized = false
+  
+  function initWorkerPool() {
+    try {
+      const workerPath = path.join(__dirname, 'utils', 'bodyWorker.js')
+      for (let i = 0; i < maxWorkers; i++) {
+        try {
+          const worker = new Worker(workerPath)
+          workerPool.push(worker)
+        } catch (err) {
+          break
+        }
+      }
+    } catch (err) {
     }
-
-    console.error = (...args) => {
-      const message = args.map(String).join(' ')
-      sendLog('error', message, {
-        traceId: requestTraceId,
-        spanId: requestSpanId,
-        parentSpanId: requestParentSpanId,
-        requestId: requestId
-      })
+  }
+  
+  function ensureWorkerPool() {
+    if (!poolInitialized && (config.captureResponseBody || config.captureRequestBody)) {
+      poolInitialized = true
+      initWorkerPool()
     }
+  }
+  
+  function getWorker() {
+    if (workerPool.length === 0) return null
+    const worker = workerPool[workerIndex % workerPool.length]
+    workerIndex++
+    return worker
+  }
+  
+  function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') return
     
-    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}')
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
+  }
 
-    function sanitizeHeaders(headers) {
-      const sanitized = { ...headers }
-      const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key', 'x-auth-token', 'x-access-token']
-      
-      for (const key of Object.keys(sanitized)) {
-        if (sensitiveHeaders.includes(key.toLowerCase())) {
-          sanitized[key] = '***'
-        }
+  return function azifyExpressLoggingMiddleware(req, res, next) {
+    const startTime = Date.now()
+    const method = req.method
+    const url = req.url
+    const path = req.path || url
+    
+    let responseChunk = null
+    let responseChunkCaptured = false
+    let logSent = false
+    
+    let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
+    let idsCreated = false
+    let headersCached = false
+    let reqCtx = null
+    
+    next()
+    
+    const logWithContext = (level, message, meta) => {
+      if (!reqCtx) {
+        const traceHex = sanitizeTraceHex(req.headers['x-trace-id'])
+        reqCtx = startRequestContext({
+          requestId: requestId || req.requestId || fastUUID(),
+          traceHex,
+          parentSpanId: req.headers['x-parent-span-id'] || null
+        })
       }
-      
-      return sanitized
+      meta.traceId = meta.traceId || reqCtx.traceId
+      meta.spanId = meta.spanId || reqCtx.spanId
+      meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+      sendLog(level, message, meta)
     }
-
-    function sanitizeBody(body) {
-      if (!body || typeof body !== 'object') return body
+    
+    function ensureIds() {
+      if (idsCreated) return
+      idsCreated = true
       
-      const sanitized = Array.isArray(body) ? [...body] : { ...body }
-      const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'api_key', 'accessToken', 'access_token', 'refreshToken', 'refresh_token', 'clientSecret', 'client_secret']
+      query = req.query || null
       
-      for (const key of Object.keys(sanitized)) {
-        if (sensitiveFields.includes(key) || key.toLowerCase().includes('password') || key.toLowerCase().includes('secret')) {
-          sanitized[key] = '***'
-        }
+      if (!reqCtx) {
+        const traceHex = sanitizeTraceHex(req.headers['x-trace-id'])
+        reqCtx = startRequestContext({
+          requestId: req.requestId || fastUUID(),
+          traceHex,
+          parentSpanId: req.headers['x-parent-span-id'] || null
+        })
       }
       
-      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
+      requestId = reqCtx.requestId || req.requestId || fastUUID()
+      traceId = reqCtx.traceId
+      spanId = reqCtx.spanId
+      parentSpanId = reqCtx.parentSpanId || req.headers['x-parent-span-id'] || null
+      
+      clientIp = req.ip || req.connection?.remoteAddress || req.socket?.remoteAddress || 'unknown'
+      req.requestId = requestId
     }
-
-    if (req.method === 'GET') {
-      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
-    } else {
-      if (req.body !== undefined) {
-        req._azifyRequestData.requestBody = sanitizeBody(req.body)
+    
+    function ensureHeaders() {
+      if (headersCached) return
+      headersCached = true
+      if (config.captureHeaders) {
+        cachedHeaders = pickHeaders(req.headers || {})
+      } else {
+        cachedHeaders = {}
       }
-      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
     }
-
-    res.on('finish', () => {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
+    
+    function emitResponseLog(meta, chunk) {
+      if (!config.captureResponseBody || chunk == null) {
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+        return
       }
-      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
-    })
+      if (!meta.response) meta.response = {}
+      meta.response.body = safeSerializeBody(chunk)
+      logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+    }
 
-    let sentBody
-    let responseLogged = false
-    
-    const originalSend = res.send && res.send.bind(res)
-    if (originalSend) {
-      res.send = function patchedSend() {
-        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 (config.logRequest) {
+      process.nextTick(() => {
+        ensureIds()
+        ensureHeaders()
         
-        if (!responseLogged) {
-          logResponse()
-          responseLogged = true
+        const request = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
         }
-        
-        return originalSend.apply(this, arguments)
-      }
-    }
-
-    const originalStatus = res.status
-    res.status = function(code) {
-      res._actualStatusCode = code
-      return originalStatus.call(this, code)
-    }
-    
-    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 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])
+        if (query) request.query = query
+        if (config.captureHeaders && cachedHeaders) request.headers = cachedHeaders
+        if (config.captureRequestBody && req.body !== undefined && req.body != null) {
+          request.body = safeSerializeBody(req.body)
         }
-      } catch (_) {}
-      
-      if (typeof code === 'number') {
-        res._actualStatusCode = code
-      } else {
-        const errorObj = arguments.length === 1 ? arguments[0] : (typeof arguments[0] === 'number' ? arguments[1] : arguments[0])
         
-        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
-          }
-        } else {
-          res._actualStatusCode = res.statusCode || 200
+        const meta = {
+          traceId: reqCtx.traceId,
+          spanId: reqCtx.spanId,
+          parentSpanId: reqCtx.parentSpanId || null,
+          requestId,
+          request,
+          timestamp: Date.now(),
+          hostname
         }
-      }
-      
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-      
-      return originalJsonMethod.apply(this, arguments)
+        if (serviceObj) meta.service = serviceObj
+        if (config.environment) meta.environment = config.environment
+        
+        logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
+      })
     }
+  
+    const originalEnd = res.end.bind(res)
     
-    res.on('finish', function() {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
+    res.end = (chunk, encoding) => {
+      if (logSent) {
+        return originalEnd(chunk, encoding)
       }
-    })
-
-    const originalEnd = res.end
-    res.end = function(chunk, encoding) {
-      const duration = Date.now() - startTime
+      logSent = true
       
-      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)
-          }
-        }
-      } catch (_) {}
+      const result = originalEnd(chunk, encoding)
 
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
+      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+        responseChunk = chunk
+        responseChunkCaptured = 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)
-          }
-        } else {
-          serializedResponseBody = responseBody != null ? String(responseBody) : ''
+      process.nextTick(() => {
+        ensureIds()
+        
+        const statusCode = res.statusCode || 200
+        const duration = Date.now() - startTime
+        const response = { statusCode, durationMs: duration }
+        
+        if (config.captureHeaders) {
+          ensureHeaders()
         }
-      } catch (error) {
-        try {
-          serializedResponseBody = JSON.stringify(responseBody, null, 2)
-        } catch (secondError) {
-          serializedResponseBody = '[Complex object - serialization failed]'
+        
+        const requestObj = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
         }
-      }
-      
-      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
-      }
-      
-      try { res._azifyResponseLogged = true } catch (_) {}
-      sendLog('info', responseMessage, responseData)
-    }
-
-    req._azifyContext = reqCtx
-    
-    try {
-      runWithRequestContext(reqCtx, () => {
-        next()
+        if (query) requestObj.query = query
+        if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
+        
+        const meta = {
+          traceId: reqCtx.traceId,
+          spanId: reqCtx.spanId,
+          parentSpanId: reqCtx.parentSpanId || null,
+          requestId,
+          request: requestObj,
+          response,
+          timestamp: Date.now(),
+          hostname
+        }
+        if (serviceObj) meta.service = serviceObj
+        if (config.environment) meta.environment = config.environment
+        
+        const chunkToProcess = (responseChunk !== null && responseChunkCaptured) ? responseChunk : null
+        emitResponseLog(meta, chunkToProcess)
       })
-    } catch (error) {
-      console.error('Error in azify middleware:', error)
-      next()
+      
+      return result
     }
   }
 }