azify-logger 1.0.13 → 1.0.15

package/index.js

@@ -73,7 +73,7 @@ class AzifyLogger {
         })
       } catch (_) {}
 
-      await axios.post(`${this.options.loggerUrl}/log`, logData, {
+      await axios.post(`${this.options.loggerUrl}`, logData, {
         timeout: 5000,
         headers
       })
@@ -162,7 +162,6 @@ function createAzifyLoggerFromEnv() {
     environment: process.env.NODE_ENV || 'development'
   })
   
-  // Automatically intercept console methods
   interceptConsole(logger)
   
   return logger
@@ -181,33 +180,128 @@ function interceptConsole(logger) {
 
   console.log = (...args) => {
     originalConsoleLog(...args);
-    void logger.info(args.join(' '));
+    const { getRequestContext } = require('./store');
+    const ctx = getRequestContext();
+    const message = args.join(' ');
+    if (message.includes('failed after')) {
+    }
+    if (ctx && ctx.traceId) {
+      void logger.info(message, { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId });
+    } else {
+      void logger.info(message);
+    }
   };
 
   console.error = (...args) => {
     originalConsoleError(...args);
-    void logger.error(args.join(' '));
+    const { getRequestContext } = require('./store');
+    const ctx = getRequestContext();
+    if (ctx && ctx.traceId) {
+      void logger.error(args.join(' '), { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId });
+    } else {
+      void logger.error(args.join(' '));
+    }
   };
 
   console.warn = (...args) => {
     originalConsoleWarn(...args);
-    void logger.warn(args.join(' '));
+    const { getRequestContext } = require('./store');
+    const ctx = getRequestContext();
+    if (ctx && ctx.traceId) {
+      void logger.warn(args.join(' '), { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId });
+    } else {
+      void logger.warn(args.join(' '));
+    }
   };
 
   console.info = (...args) => {
     originalConsoleInfo(...args);
-    void logger.info(args.join(' '));
+    const { getRequestContext } = require('./store');
+    const ctx = getRequestContext();
+    if (ctx && ctx.traceId) {
+      void logger.info(args.join(' '), { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId });
+    } else {
+      void logger.info(args.join(' '));
+    }
   };
 
   console.debug = (...args) => {
     originalConsoleDebug(...args);
-    void logger.debug(args.join(' '));
+    const { getRequestContext } = require('./store');
+    const ctx = getRequestContext();
+    if (ctx && ctx.traceId) {
+      void logger.debug(args.join(' '), { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId });
+    } else {
+      void logger.debug(args.join(' '));
+    }
   };
 }
 
+/**
+ * Creates a NestJS logger configuration that sends logs to azify-logger
+ * @returns {Object} NestJS logger configuration
+ * @example
+ * const app = await NestFactory.create(AppModule, {
+ *   logger: createNestLogger()
+ * });
+ */
+function createNestLogger() {
+  const { getRequestContext } = require('./store')
+  const pino = require('pino')
+
+  return {
+    log: (message, context) => {
+      const ctx = getRequestContext()
+      if (ctx && ctx.traceId) {
+        pino().info(message, context || '')
+      } else {
+        pino().info(message, context || '')
+      }
+    },
+    error: (message, trace, context) => {
+      const ctx = getRequestContext()
+      if (ctx && ctx.traceId) {
+        pino().error(message, trace || '', context || '')
+      } else {
+        pino().error(message, trace || '', context || '')
+      }
+    },
+    warn: (message, context) => {
+      const ctx = getRequestContext()
+      if (ctx && ctx.traceId) {
+        pino().warn(message, context || '')
+      } else {
+        pino().warn(message, context || '')
+      }
+    },
+    debug: (message, context) => {
+      const ctx = getRequestContext()
+      if (ctx && ctx.traceId) {
+        pino().debug(message, context || '')
+      } else {
+        pino().debug(message, context || '')
+      }
+    },
+    verbose: (message, context) => {
+      const ctx = getRequestContext()
+      if (ctx && ctx.traceId) {
+        pino().info(message, context || '')
+      } else {
+        pino().info(message, context || '')
+      }
+    }
+  }
+}
+
+if (process.env.AZIFY_LOGGER_DISABLE !== '1') {
+  require('./init')
+  require('./register')
+}
+
 module.exports = AzifyLogger
 module.exports.createAzifyLogger = createAzifyLogger
 module.exports.createAzifyLoggerFromEnv = createAzifyLoggerFromEnv
+module.exports.createNestLogger = createNestLogger
 module.exports.interceptConsole = interceptConsole
 module.exports.streams = {
   createBunyanStream: require('./streams/bunyan'),

package/middleware-express.d.ts

@@ -17,4 +17,4 @@ declare function createExpressLoggingMiddleware(options?: {
   environment?: string;
 }): ExpressMiddleware;
 
-export default createExpressLoggingMiddleware;
+export = createExpressLoggingMiddleware;

package/middleware-express.js

@@ -63,14 +63,85 @@ function createExpressLoggingMiddleware(options = {}) {
     const requestId = req.requestId || require('uuid').v4()
     const middlewareId = require('uuid').v4().substring(0, 8)
     
-    const reqCtx = startRequestContext({ requestId })
-    req.__azifyTraceId = reqCtx.traceId
-    req.__azifySpanId = reqCtx.spanId
-    req.__azifyParentSpanId = reqCtx.parentSpanId
+    let existingTraceId = null
+    let existingSpanId = null
+    let existingParentSpanId = null
     
-    const requestTraceId = req.__azifyTraceId
-    const requestSpanId = req.__azifySpanId
-    const requestParentSpanId = req.__azifyParentSpanId
+    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
+    }
+    
+    let reqCtx
+    if (existingTraceId) {
+      reqCtx = {
+        traceId: existingTraceId,
+        spanId: existingSpanId || require('uuid').v4().substring(0, 16),
+        parentSpanId: existingParentSpanId,
+        requestId: requestId
+      }
+    } else {
+      reqCtx = startRequestContext({ requestId })
+    }
+    
+    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 baseUrl = req.url
     if (baseUrl.includes('?')) {
@@ -79,13 +150,41 @@ function createExpressLoggingMiddleware(options = {}) {
     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']
+      
+      for (const key of Object.keys(sanitized)) {
+        if (sensitiveHeaders.includes(key.toLowerCase())) {
+          sanitized[key] = '***'
+        }
+      }
+      
+      return sanitized
+    }
+
+    function sanitizeBody(body) {
+      if (!body || typeof body !== 'object') return body
+      
+      const sanitized = Array.isArray(body) ? [...body] : { ...body }
+      const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'api_key', 'accessToken', 'access_token', 'refreshToken', 'refresh_token', 'clientSecret', 'client_secret']
+      
+      for (const key of Object.keys(sanitized)) {
+        if (sensitiveFields.includes(key) || key.toLowerCase().includes('password') || key.toLowerCase().includes('secret')) {
+          sanitized[key] = '***'
+        }
+      }
+      
+      return sanitized
+    }
+
     req._azifyRequestData = {
       requestId,
       method: req.method,
       url: req.url,
       baseUrl: baseUrl,
       path: req.url,
-      headers: req.headers || {},
+      headers: sanitizeHeaders(req.headers || {}),
       query: req.query || {},
       userAgent: req.headers?.['user-agent'] || 'unknown',
       ip: req.connection?.remoteAddress || req.socket?.remoteAddress || req.ip || 'unknown',
@@ -98,7 +197,7 @@ function createExpressLoggingMiddleware(options = {}) {
       sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
     } else {
       if (req.body !== undefined) {
-        req._azifyRequestData.requestBody = req.body
+        req._azifyRequestData.requestBody = sanitizeBody(req.body)
       }
       sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
     }
@@ -108,6 +207,10 @@ function createExpressLoggingMiddleware(options = {}) {
         logResponse()
         responseLogged = true
       }
+      console.log = originalConsole.log
+      console.info = originalConsole.info
+      console.warn = originalConsole.warn
+      console.error = originalConsole.error
     })
 
     res.on('close', () => {
@@ -115,6 +218,10 @@ function createExpressLoggingMiddleware(options = {}) {
         logResponse()
         responseLogged = true
       }
+      console.log = originalConsole.log
+      console.info = originalConsole.info
+      console.warn = originalConsole.warn
+      console.error = originalConsole.error
     })
 
     let sentBody

package/middleware-restify.js

@@ -1,14 +1,44 @@
+/**
+ * Creates a Restify 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 'azipay')
+ * @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} Restify middleware function
+ * @example
+ * const azifyMiddleware = require('azify-logger/middleware-restify');
+ * server.use(azifyMiddleware({ serviceName: 'my-app' }));
+ */
 const axios = require('axios')
 const { als, runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
 
 function createRestifyLoggingMiddleware(options = {}) {
   const config = {
     serviceName: options.serviceName || process.env.APP_NAME || 'azipay',
-    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001',
+    loggerUrl: (options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log').replace(/\/log$/, '') + '/log',
     environment: options.environment || process.env.NODE_ENV || 'development'
   }
 
-  async function sendLog(level, message, meta = {}) {
+  const pendingLogs = new Set()
+
+  let exitHandlerInstalled = false
+  if (!exitHandlerInstalled) {
+    exitHandlerInstalled = true
+    
+    process.on('uncaughtException', (err) => {
+      console.error('[AZIFY] Uncaught exception:', err.message)
+      
+      if (pendingLogs.size > 0) {
+        setTimeout(() => {
+          process.exit(1)
+        }, 500)
+      } else {
+        process.exit(1)
+      }
+    })
+  }
+
+  function sendLog(level, message, meta = {}) {
     const logData = {
       level,
       message,
@@ -24,26 +54,59 @@ function createRestifyLoggingMiddleware(options = {}) {
       }
     }
 
-    try {
-      await axios.post(`${config.loggerUrl}/log`, logData, {
-        timeout: 5000
-      })
-    } catch (error) {}
+    const logId = Math.random().toString(36).substring(7)
+    pendingLogs.add(logId)
+    
+    axios.post(`${config.loggerUrl}`, logData, {
+      timeout: 2000
+    }).then(() => {
+      pendingLogs.delete(logId)
+    }).catch(() => {
+      pendingLogs.delete(logId)
+    })
+  }
+
+  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 sanitized
+  }
+
+  function sanitizeBody(body) {
+    if (!body || typeof body !== 'object') return body
+    
+    const sanitized = Array.isArray(body) ? [...body] : { ...body }
+    const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'api_key', 'accessToken', 'access_token', 'refreshToken', 'refresh_token', 'clientSecret', 'client_secret']
+    
+    for (const key of Object.keys(sanitized)) {
+      if (sensitiveFields.includes(key) || key.toLowerCase().includes('password') || key.toLowerCase().includes('secret')) {
+        sanitized[key] = '***'
+      }
+    }
+    
+    return sanitized
   }
 
   return function azifyLoggingMiddleware(req, res, next) {
     const startTime = Date.now()
     const requestId = req.requestId || require('uuid').v4()
-    const middlewareId = require('uuid').v4().substring(0, 8)
     
-    const reqCtx = startRequestContext({ requestId })
-    req.__azifyTraceId = reqCtx.traceId
-    req.__azifySpanId = reqCtx.spanId
-    req.__azifyParentSpanId = reqCtx.parentSpanId
+    if (res._azifySetup) {
+      return next()
+    }
+    res._azifySetup = true
     
-    const requestTraceId = req.__azifyTraceId
-    const requestSpanId = req.__azifySpanId
-    const requestParentSpanId = req.__azifyParentSpanId
+    const reqCtx = startRequestContext({ requestId })
+    const requestTraceId = reqCtx.traceId
+    const requestSpanId = reqCtx.spanId
+    const requestParentSpanId = reqCtx.parentSpanId
     
     let baseUrl = req.url
     if (baseUrl.includes('?')) {
@@ -58,7 +121,7 @@ function createRestifyLoggingMiddleware(options = {}) {
       url: req.url,
       baseUrl: baseUrl,
       path: req.url,
-      headers: req.headers,
+      headers: sanitizeHeaders(req.headers),
       query: req.query,
       userAgent: req.headers['user-agent'],
       ip: req.connection.remoteAddress || req.socket.remoteAddress,
@@ -71,27 +134,13 @@ function createRestifyLoggingMiddleware(options = {}) {
       sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
     } else {
       if (req.body !== undefined) {
-        req._azifyRequestData.requestBody = req.body
+        req._azifyRequestData.requestBody = sanitizeBody(req.body)
       }
       sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
     }
 
-    res.on('finish', () => {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-    })
-
-    res.on('close', () => {
-      if (!responseLogged) {
-        logResponse()
-        responseLogged = true
-      }
-    })
-
+    res._azifyResponseLogged = false
     let sentBody
-    let responseLogged = false
     
     const originalSend = res.send && res.send.bind(res)
     if (originalSend) {
@@ -104,9 +153,9 @@ function createRestifyLoggingMiddleware(options = {}) {
           }
         } catch (_) {}
         
-        if (!responseLogged) {
+        if (!res._azifyResponseLogged) {
+          res._azifyResponseLogged = true
           logResponse()
-          responseLogged = true
         }
         
         return originalSend.apply(this, arguments)
@@ -165,21 +214,8 @@ function createRestifyLoggingMiddleware(options = {}) {
           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) {
@@ -198,9 +234,9 @@ function createRestifyLoggingMiddleware(options = {}) {
         }
       } catch (_) {}
 
-      if (!responseLogged) {
+      if (!res._azifyResponseLogged) {
         logResponse()
-        responseLogged = true
+        res._azifyResponseLogged = true
       }
 
       originalEnd.call(this, chunk, encoding)
@@ -265,14 +301,46 @@ function createRestifyLoggingMiddleware(options = {}) {
 
     req._azifyContext = reqCtx
     
-    try {
-      runWithRequestContext(reqCtx, () => {
-        next()
-      })
-    } catch (error) {
-      console.error('Error in azify middleware:', error)
-      next()
+    const originalNext = next
+    const wrappedNext = (err) => {
+      if (err && !res._azifyResponseLogged) {
+        const errorData = {
+          ...req._azifyRequestData,
+          statusCode: res.statusCode || 500,
+          responseTime: Date.now() - startTime,
+          error: {
+            message: err.message || String(err),
+            stack: err.stack,
+            name: err.name,
+            code: err.code
+          }
+        }
+        sendLog('error', `[ERROR] ${req.method} ${req.url}: ${err.message || String(err)}`, errorData)
+        res._azifyResponseLogged = true
+      }
+      return originalNext(err)
     }
+    
+    res.on('error', (error) => {
+      if (!res._azifyResponseLogged) {
+        const errorData = {
+          ...req._azifyRequestData,
+          statusCode: res.statusCode || 500,
+          responseTime: Date.now() - startTime,
+          error: {
+            message: error.message,
+            stack: error.stack,
+            name: error.name
+          }
+        }
+        sendLog('error', `[ERROR] ${req.method} ${req.url}: ${error.message}`, errorData)
+        res._azifyResponseLogged = true
+      }
+    })
+    
+    runWithRequestContext(reqCtx, () => {
+      wrappedNext()
+    })
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",

package/register-restify.js

@@ -1,13 +1,5 @@
 console.log('🔧 @azify/logger-client/register-restify carregando...')
 
-function generateTraceId() {
-  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15) + Date.now().toString(36)
-}
-
-function generateSpanId() {
-  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 7)
-}
-
 const Module = require('module')
 const originalRequire = Module.prototype.require
 
@@ -16,185 +8,9 @@ let patched = false
 Module.prototype.require = function(id) {
   const module = originalRequire.apply(this, arguments)
   
-  if (id && typeof id === 'string' && id.includes('restify')) {
-  }
-  
   if (!patched && (id === 'restify' || id.endsWith('/restify') || id.includes('restify/lib'))) {
     patched = true
-    console.log('  ✅ Restify detectado! Aplicando patches...')
-    
-    try {
-      let trace, context
-      try {
-        const otel = require('@opentelemetry/api')
-        trace = otel.trace
-        context = otel.context
-      } catch (_) {}
-      
-      const ServerProto = module.Server && module.Server.prototype
-      
-      if (!ServerProto) return module
-  
-  function wrapAsyncMiddleware(handler) {
-    const isAsync = handler && handler.constructor && handler.constructor.name === 'AsyncFunction'
-    const takesThree = typeof handler === 'function' && handler.length === 3
-    
-    if (isAsync && takesThree) {
-      return function wrappedAsyncMiddleware(req, res, next) {
-        try {
-          const promise = handler(req, res, next)
-          if (promise && typeof promise.then === 'function') {
-            promise.catch(next)
-          }
-        } catch (err) {
-          next(err)
-        }
-      }
-    }
-    return handler
-  }
-  
-  if (ServerProto && !ServerProto.__azifyPatchedUse) {
-    const originalUse = ServerProto.use
-    ServerProto.use = function patchedUse(...handlers) {
-      const patched = handlers.map(h => wrapAsyncMiddleware(h))
-      return originalUse.apply(this, patched)
-    }
-    
-    const originalPre = ServerProto.pre
-    ServerProto.pre = function patchedPre(...handlers) {
-      const patched = handlers.map(h => wrapAsyncMiddleware(h))
-      return originalPre.apply(this, patched)
-    }
-    
-    ServerProto.__azifyPatchedUse = true
-    console.log('✅ Restify 11 async middleware patch aplicado')
-  }
-
-  if (ServerProto && !ServerProto.__azifyReqResLogged) {
-    const { createAzifyLoggerFromEnv } = require('./index.js')
-    const azifyLogger = createAzifyLoggerFromEnv()
-    
-    ServerProto.use(function azifyAutoRR (req, res, next) {
-      if (req.__azifyLogged) return next()
-      req.__azifyLogged = true
-      const start = Date.now()
-
-      let traceId, spanId
-      
-      if (trace && context) {
-        const span = trace.getSpan(context.active())
-        const spanContext = span?.spanContext()
-        
-        if (spanContext) {
-          traceId = spanContext.traceId
-          spanId = spanContext.spanId
-        }
-      }
-      
-      if (!traceId) {
-        traceId = generateTraceId()
-        spanId = generateSpanId()
-      }
-      
-      req.__azifyTrace = { traceId, spanId }
-      
-      const requestId = req.requestId || req.id || (req.getId && req.getId())
-      
-      const requestMeta = {
-        requestId,
-        method: req.method,
-        url: req.url,
-        path: req.path(),
-        headers: req.headers,
-        query: req.query,
-        params: req.params,
-        userAgent: req.headers?.['user-agent'],
-        ip: (req.connection && req.connection.remoteAddress) || (req.socket && req.socket.remoteAddress),
-        requestBody: req.body,
-        traceId,
-        spanId
-      }
-
-      azifyLogger.info(`[REQUEST] ${req.method} ${req.url}`, requestMeta)
-
-      const originalSend = res.send
-      const originalJson = res.json
-      
-      function logResponse(methodName, ...args) {
-        const statusCode = res.statusCode || (typeof args[0] === 'number' ? args[0] : 200)
-        const body = (args.length === 1) ? args[0] : (typeof args[0] === 'number' ? args[1] : (args[1] || args[0]))
-        
-        const { traceId, spanId } = req.__azifyTrace || {}
-        
-        const responseMeta = {
-          requestId,
-          method: req.method,
-          url: req.url,
-          statusCode,
-          responseTime: Date.now() - start,
-          responseBody: body,
-          responseHeaders: res.getHeaders?.() || {},
-          traceId,
-          spanId,
-          responseMethod: methodName
-        }
-
-        const message = (typeof body === 'string' && body.length > 0)
-          ? body
-          : `[RESPONSE] ${req.method} ${req.url} ${statusCode} ${Date.now() - start}ms`
-        azifyLogger.info(message, responseMeta)
-      }
-      
-      res.send = function wrappedSend (...args) {
-        logResponse('send', ...args)
-        res.__azifyResponseLogged = true
-        return originalSend.apply(this, args)
-      }
-      
-      if (originalJson) {
-        res.json = function wrappedJson (...args) {
-          logResponse('json', ...args)
-          res.__azifyResponseLogged = true
-          return originalJson.apply(this, args)
-        }
-      }
-
-      const originalEnd = res.end
-      res.end = function wrappedEnd(chunk, encoding) {
-        if (!res.__azifyResponseLogged && chunk) {
-          const { traceId, spanId } = req.__azifyTrace || {}
-          
-          const responseMeta = {
-            requestId,
-            method: req.method,
-            url: req.url,
-            statusCode: res.statusCode,
-            responseTime: Date.now() - start,
-            responseBody: chunk,
-            responseHeaders: res.getHeaders?.() || {},
-            traceId,
-            spanId,
-            responseMethod: 'end'
-          }
-
-          const message = (typeof chunk === 'string' && chunk.length > 0)
-            ? chunk
-            : `[RESPONSE] ${req.method} ${req.url} ${res.statusCode} ${Date.now() - start}ms`
-          azifyLogger.info(message, responseMeta)
-          res.__azifyResponseLogged = true
-        }
-        
-        return originalEnd.call(this, chunk, encoding)
-      }
-
-      next()
-    })
-      ServerProto.__azifyReqResLogged = true
-    }
-    } catch (error) {
-      console.error('❌ Erro ao aplicar patches no Restify:', error.message)
-    }
+    console.log('  ✅ Restify detectado!')
   }
   
   return module

package/server.js

@@ -167,6 +167,22 @@ app.post('/log', async (req, res) => {
     return res.status(400).json({ success: false, message: 'Level and message are required.' })
   }
 
+  const shouldFilterLog = (
+    message.includes('prisma:query') ||
+    message.includes('prisma:info') ||
+    message.includes('Starting a mysql pool') ||
+    message.includes('SELECT `') ||
+    message.includes('INSERT `') ||
+    message.includes('UPDATE `') ||
+    message.includes('DELETE `') ||
+    message.includes('%s: %s') ||
+    message.includes('Application Startup Time')
+  )
+
+  if (shouldFilterLog) {
+    return res.json({ success: true, message: 'Log filtrado (Prisma verboso)' })
+  }
+
   const requestId = meta?.requestId
 
   let traceContext = null

package/streams/bunyan.d.ts

@@ -0,0 +1,19 @@
+import { Writable } from 'stream';
+
+export interface BunyanStreamOptions {
+  loggerUrl?: string;
+  serviceName?: string;
+  environment?: string;
+}
+
+/**
+ * Creates a Bunyan stream for azify-logger
+ * @param options - Configuration options
+ * @returns Writable stream
+ * @example
+ * const bunyanStream = require('azify-logger/streams/bunyan');
+ * const stream = bunyanStream({ loggerUrl: 'http://localhost:3001' });
+ */
+declare function createBunyanStream(options?: BunyanStreamOptions): Writable;
+
+export = createBunyanStream;

package/streams/bunyan.js

@@ -39,8 +39,10 @@ function createBunyanStream(options = {}) {
 
       const headers = {}
 
+      const { time, v, level: _, msg, name, hostname: bunyanHostname, pid, ...cleanRecord } = record
+
       const meta = {
-        ...record,
+        ...cleanRecord,
         service: { name: serviceName, version: record.service?.version || '1.0.0' },
         environment,
         timestamp: new Date().toISOString(),
@@ -52,7 +54,7 @@ function createBunyanStream(options = {}) {
 
       const payload = { level, message: record.msg || record.message || 'log', meta }
 
-      axios.post(`${loggerUrl}/log`, payload, { headers, timeout: 3001 }).catch(() => {})
+      axios.post(`${loggerUrl}`, payload, { headers, timeout: 3001 }).catch(() => {})
     }
   }
 }

package/streams/pino.d.ts

@@ -0,0 +1,19 @@
+import { Transform } from 'stream';
+
+export interface PinoStreamOptions {
+  loggerUrl?: string;
+  serviceName?: string;
+  environment?: string;
+}
+
+/**
+ * Creates a Pino stream for azify-logger
+ * @param options - Configuration options
+ * @returns Transform stream
+ * @example
+ * const pinoStream = require('azify-logger/streams/pino');
+ * const stream = pinoStream({ loggerUrl: 'http://localhost:3001' });
+ */
+declare function createPinoStream(options?: PinoStreamOptions): Transform;
+
+export = createPinoStream;

package/streams/pino.js

@@ -16,11 +16,18 @@ function createPinoStream(options = {}) {
 
       let traceId, spanId
       try {
-        const span = trace.getSpan(context.active())
-        const spanContext = span?.spanContext()
-        if (spanContext) {
-          traceId = spanContext.traceId
-          spanId = spanContext.spanId
+        const { getRequestContext } = require('../store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          traceId = ctx.traceId
+          spanId = ctx.spanId
+        } else {
+          const span = trace.getSpan(context.active())
+          const spanContext = span?.spanContext()
+          if (spanContext) {
+            traceId = spanContext.traceId
+            spanId = spanContext.spanId
+          }
         }
       } catch (_) {}
 
@@ -47,7 +54,7 @@ function createPinoStream(options = {}) {
       }
 
       const payload = { level, message: record.msg || record.message || 'log', meta }
-      axios.post(`${loggerUrl}/log`, payload, { headers, timeout: 3001 }).catch(() => {})
+      axios.post(`${loggerUrl}`, payload, { headers, timeout: 3001 }).catch(() => {})
     }
   }
 }