azify-logger 1.0.28 → 1.0.29

package/README.md

@@ -49,7 +49,21 @@ APP_NAME=nome-app
 require('azify-logger')
 const express = require('express')
 const app = express()
-// Logs automáticos via OpenTelemetry
+const azifyMiddleware = require('azify-logger/middleware-express')
+app.use(azifyMiddleware())
+```
+
+### Para aplicações Fastify:
+
+```javascript
+const fastify = require('fastify')()
+const azifyPlugin = require('azify-logger/middleware-fastify')
+
+await fastify.register(azifyPlugin, {
+  serviceName: 'minha-app'
+})
+
+await fastify.listen({ port: 3000 })
 ```
 
 ## ⚙️ Variáveis de Ambiente
@@ -192,11 +206,11 @@ O deploy é feito automaticamente via GitHub Actions.
 
 **Comandos seguros** (preservam dados):
 ```bash
-docker-compose stop
-docker-compose restart
+docker compose stop
+docker compose restart
 ```
 
 **Comandos destrutivos** (APAGAM logs):
 ```bash
-docker-compose down -v  # ⚠️ APAGA VOLUMES!
+docker compose down -v  # ⚠️ APAGA VOLUMES!
 ```

package/index.js

@@ -341,7 +341,8 @@ module.exports.streams = {
 }
 module.exports.middleware = {
   restify: require('./middleware-restify'),
-  express: require('./middleware-express')
+  express: require('./middleware-express'),
+  fastify: require('./middleware-fastify')
 }
 module.exports.startLoggerWorker = require('./queue/workerManager').startLoggerWorker
 module.exports.stopLoggerWorker = require('./queue/workerManager').stopLoggerWorker

package/middleware-express.js

@@ -1,8 +1,52 @@
-const { runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+const { startRequestContext } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
-const { randomUUID } = require('crypto')
+const { Worker } = require('worker_threads')
+const path = require('path')
 const os = require('os')
 
+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)
+}
+
+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 {
+      return String(payload)
+    } catch {
+      return ''
+    }
+  }
+}
+
+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',
@@ -52,27 +96,52 @@ function createExpressLoggingMiddleware(options = {}) {
 
   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) {
+    }
+  }
+  
+  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
     
-    try {
-      const metaObj = {
-        service: {
-          name: config.serviceName,
-          version: '1.0.0'
-        },
-        environment: config.environment,
-        timestamp: new Date().toISOString(),
-        hostname: hostname,
-        ...meta
-      }
-      
-      transport.enqueue({
-        level,
-        message,
-        meta: metaObj
-      }, { 'content-type': 'application/json' })
-    } catch (err) { }
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
   }
 
   return function azifyExpressLoggingMiddleware(req, res, next) {
@@ -85,181 +154,162 @@ function createExpressLoggingMiddleware(options = {}) {
     let responseChunkCaptured = false
     let logSent = false
     
-    let requestId, traceId, spanId, parentSpanId, reqCtx, clientIp, query, cachedHeaders
+    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
+        })
+      }
+      meta.traceId = meta.traceId || reqCtx.traceId
+      meta.spanId = meta.spanId || reqCtx.spanId
+      meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+      sendLog(level, message, meta)
+    }
     
     function ensureIds() {
       if (idsCreated) return
       idsCreated = true
       
-      query = req.query
+      query = req.query || null
       
-      const currentCtx = getRequestContext()
-      const headerTraceId = req.headers['x-trace-id']
-      const headerParentSpanId = req.headers['x-parent-span-id']
-      
-      if (currentCtx?.traceId) {
-        traceId = currentCtx.traceId
-      } else if (headerTraceId) {
-        traceId = headerTraceId
-      } else {
-        traceId = randomUUID()
+      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
+        })
       }
       
-      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)
-        }
-      }
+      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'
-      
-      reqCtx = startRequestContext({ requestId, traceId, spanId, parentSpanId })
+      req.requestId = requestId
     }
     
     function ensureHeaders() {
       if (headersCached) return
       headersCached = true
-      cachedHeaders = config.captureHeaders ? pickHeaders(req.headers || {}) : {}
+      if (config.captureHeaders) {
+        cachedHeaders = pickHeaders(req.headers || {})
+      } else {
+        cachedHeaders = {}
+      }
     }
     
+    function emitResponseLog(meta, chunk) {
+      if (!config.captureResponseBody || chunk == null) {
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+        return
+      }
+
+      if (!meta.response) meta.response = {}
+      meta.response.body = safeSerializeBody(chunk)
+      logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+    }
+
     if (config.logRequest) {
-      setImmediate(() => {
-        try {
-          ensureIds()
-          ensureHeaders()
-          const request = {
-            id: requestId,
-            method,
-            url,
-            path,
-            query: query || {},
-            headers: cachedHeaders,
-            ip: clientIp
-          }
-          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) { }
+      process.nextTick(() => {
+        ensureIds()
+        ensureHeaders()
+        
+        const request = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
+        }
+        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)
+        }
+        
+        const meta = {
+          traceId: reqCtx.traceId,
+          spanId: reqCtx.spanId,
+          parentSpanId: reqCtx.parentSpanId || null,
+          requestId,
+          request,
+          timestamp: Date.now(),
+          hostname
+        }
+        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.end = (chunk, encoding) => {
+      if (logSent) {
+        return originalEnd(chunk, encoding)
+      }
+      logSent = true
+      
       const result = originalEnd(chunk, encoding)
 
-      setImmediate(() => {
-        if (logSent) return
-        logSent = true
+      if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
+        responseChunk = chunk
+        responseChunkCaptured = true
+      }
+      
+      process.nextTick(() => {
+        ensureIds()
         
-        try {
-          if (chunk != null && config.captureResponseBody && !responseChunkCaptured) {
-            responseChunk = chunk
-            responseChunkCaptured = true
-          }
-          
-          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
-          }
-          
-          if (config.captureHeaders) {
-            ensureHeaders()
-          }
-          
-          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) { }
+        const statusCode = res.statusCode || 200
+        const duration = Date.now() - startTime
+        const response = { statusCode, durationMs: duration }
+        
+        if (config.captureHeaders) {
+          ensureHeaders()
+        }
+        
+        const requestObj = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
+        }
+        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)
       })
       
       return result
     }
-
-    try {
-      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
-    }
   }
 }