azify-logger 1.0.43 → 1.0.45

package/README.md

@@ -95,16 +95,16 @@ O `azify-logger` inclui um OpenTelemetry Collector configurado para receber trac
 Para habilitar o envio de traces, configure a variável de ambiente na sua aplicação:
 
 ```bash
-OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318/v1/traces
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:3001/v1/traces
 ```
 
 ### URLs
 
 | Ambiente | URL |
 |----------|-----|
-| **Development** | `http://localhost:4318/v1/traces` |
+| **Development (Docker)** | `http://localhost:3001/v1/traces` |
 | **Staging** | `https://logsdashboard.azify.dev/v1/traces` |
-| **Production** | `https://cadence.aztech.host/v1/traces` | 
+| **Production** | `https://cadence.aztech.host/v1/traces` |
 
 ## 🔍 Como Funciona
 

package/index.js

@@ -1,3 +1,71 @@
+if (process.env.AZIFY_LOGGER_DISABLE !== '1') {
+  try {
+    require('./register-http-client-early')
+  } catch (_) {}
+}
+
+if (typeof global.__AZIFY_NODE_REQUIRE === 'undefined') {
+  try {
+    const Mod = require('module')
+    global.__AZIFY_NODE_REQUIRE = Mod.prototype.require
+  } catch (_) {}
+}
+if (process.env.AZIFY_LOGGER_DISABLE !== '1') {
+  let earlyPatch
+  try {
+    earlyPatch = require('./register-http-client-early')
+    if (earlyPatch && typeof earlyPatch.patchUndiciInCache === 'function') {
+      try { earlyPatch.patchUndiciInCache() } catch (_) {}
+    }
+  } catch (e) {
+    earlyPatch = null
+  }
+  try { require('./register') } catch (_) {}
+  if (earlyPatch && typeof earlyPatch.patchUndiciInCache === 'function') {
+    try {
+      earlyPatch.patchUndiciInCache()
+      if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+        try { process.stderr.write('[azify-logger] INDEX: patchUndiciInCache() called\n') } catch (_) {}
+      }
+    } catch (_) {}
+    if (typeof setImmediate === 'function') setImmediate(earlyPatch.patchUndiciInCache)
+    if (typeof earlyPatch.patchGlobalDispatcherInPlace === 'function') {
+      let tick = 0
+      const iv = setInterval(function () {
+        try { earlyPatch.patchUndiciInCache() } catch (_) {}
+        try { earlyPatch.patchGlobalDispatcherInPlace() } catch (_) {}
+        if (++tick >= 600) clearInterval(iv)
+      }, 100)
+    }
+    if (typeof setTimeout === 'function') {
+      setTimeout(earlyPatch.patchUndiciInCache, 100)
+      setTimeout(earlyPatch.patchUndiciInCache, 500)
+      setTimeout(earlyPatch.patchUndiciInCache, 1500)
+      setTimeout(earlyPatch.patchUndiciInCache, 3000)
+      setTimeout(earlyPatch.patchUndiciInCache, 5000)
+      setTimeout(function () {
+        earlyPatch.patchUndiciInCache()
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] patchUndiciInCache 7s delay done\n') } catch (_) {}
+      }, 7000)
+      setTimeout(function () {
+        earlyPatch.patchUndiciInCache()
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] patchUndiciInCache 10s delay done\n') } catch (_) {}
+      }, 10000)
+      setTimeout(function () {
+        earlyPatch.patchUndiciInCache()
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] patchUndiciInCache 15s delay done\n') } catch (_) {}
+      }, 15000)
+      setTimeout(function () {
+        earlyPatch.patchUndiciInCache()
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] patchUndiciInCache 20s delay done\n') } catch (_) {}
+      }, 20000)
+      setTimeout(function () {
+        earlyPatch.patchUndiciInCache()
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] patchUndiciInCache 25s delay done\n') } catch (_) {}
+      }, 25000)
+    }
+  }
+}
 require('./otel-env')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const nativeConsole = {
@@ -25,7 +93,6 @@ try {
 
 if (process.env.AZIFY_LOGGER_AUTOREG_DISABLE !== '1') {
   try { require('./register-otel') } catch (_) {}
-  try { require('./register') } catch (_) {}
   try { require('./register-restify') } catch (_) {}
 }
 
@@ -54,7 +121,7 @@ class AzifyLogger {
         : process.env.AZIFY_LOGGER_AWAIT_DELIVERY === 'true',
       ...options
     }
-    
+
     this.transport = createHttpLoggerTransport(this.options.loggerUrl, {
       awaitDelivery: this.options.awaitDelivery
     })
@@ -73,7 +140,7 @@ class AzifyLogger {
   async log(level, message, meta = {}) {
     const span = trace.getSpan(context.active())
     const spanContext = span && span.spanContext()
-    
+
     const logData = {
       level,
       message,
@@ -194,9 +261,18 @@ function createAzifyLoggerFromEnv() {
     loggerUrl: process.env.AZIFY_LOGGER_URL,
     environment: process.env.NODE_ENV
   })
-  
+
   interceptConsole(logger)
-  
+
+  if (process.env.AZIFY_LOGGER_DISABLE !== '1') {
+    try {
+      process.stderr.write('[AZIFY] createAzifyLoggerFromEnv: patching undici in cache\n')
+      const early = require('./register-http-client-early')
+      if (typeof early.patchUndiciInCache === 'function') early.patchUndiciInCache()
+      if (typeof early.flushEarlyLogQueue === 'function') early.flushEarlyLogQueue()
+    } catch (_) {}
+  }
+
   return logger
 }
 
@@ -327,8 +403,9 @@ function createNestLogger() {
 }
 
 if (process.env.AZIFY_LOGGER_DISABLE !== '1') {
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] INDEX loading init\n') } catch (_) {}
   require('./init')
-  require('./register')
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') try { process.stderr.write('[azify-logger] INDEX register already loaded at top\n') } catch (_) {}
 }
 
 module.exports = AzifyLogger
@@ -347,4 +424,4 @@ module.exports.middleware = {
 }
 module.exports.startLoggerWorker = require('./queue/workerManager').startLoggerWorker
 module.exports.stopLoggerWorker = require('./queue/workerManager').stopLoggerWorker
-module.exports.ensureLoggerWorker = require('./queue/workerManager').ensureWorker
+module.exports.ensureLoggerWorker = require('./queue/workerManager').ensureWorker

package/init.js

@@ -7,14 +7,24 @@ const originalRequire = Module.prototype.require
 
 Module.prototype.require = function(id) {
   const result = originalRequire.call(this, id)
-  
+
+  const idStr = typeof id === 'string' ? id : ''
+  if (idStr === 'undici' || (idStr.indexOf('undici') !== -1 && idStr.indexOf('undici-package') === -1)) {
+    if (result && typeof result === 'object' && (result.request || result.fetch)) {
+      try {
+        const early = require('./register-http-client-early')
+        if (early && typeof early.patchUndiciExports === 'function') early.patchUndiciExports(result)
+      } catch (_) {}
+    }
+  }
+
   if (id === '@nestjs/common') {
     if (result && result.Logger) {
       const originalLoggerConstructor = result.Logger
-      
+
       function PatchedLogger(context) {
         const instance = new originalLoggerConstructor(context)
-        
+
         instance.log = function(message, context) {
           const { getRequestContext } = require('./store')
           const ctx = getRequestContext()
@@ -23,7 +33,7 @@ Module.prototype.require = function(id) {
           }
           return originalLoggerConstructor.prototype.log.call(this, message, context)
         }
-        
+
         instance.error = function(message, trace, context) {
           const { getRequestContext } = require('./store')
           const ctx = getRequestContext()
@@ -32,7 +42,7 @@ Module.prototype.require = function(id) {
           }
           return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
         }
-        
+
         instance.warn = function(message, context) {
           const { getRequestContext } = require('./store')
           const ctx = getRequestContext()
@@ -41,7 +51,7 @@ Module.prototype.require = function(id) {
           }
           return originalLoggerConstructor.prototype.warn.call(this, message, context)
         }
-        
+
         instance.debug = function(message, context) {
           const { getRequestContext } = require('./store')
           const ctx = getRequestContext()
@@ -50,7 +60,7 @@ Module.prototype.require = function(id) {
           }
           return originalLoggerConstructor.prototype.debug.call(this, message, context)
         }
-        
+
         instance.verbose = function(message, context) {
           const { getRequestContext } = require('./store')
           const ctx = getRequestContext()
@@ -59,17 +69,17 @@ Module.prototype.require = function(id) {
           }
           return originalLoggerConstructor.prototype.verbose.call(this, message, context)
         }
-        
+
         return instance
       }
-      
+
       Object.setPrototypeOf(PatchedLogger, originalLoggerConstructor)
       Object.assign(PatchedLogger, originalLoggerConstructor)
-      
+
       result.Logger = PatchedLogger
     }
   }
-  
+
   return result
 }
 }

package/middleware-express.js

@@ -105,7 +105,7 @@ function createExpressLoggingMiddleware(options = {}) {
   }
   const config = {
     serviceName: svcName,
-    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log',
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || process.env.LOG_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',
@@ -114,7 +114,12 @@ function createExpressLoggingMiddleware(options = {}) {
   }
 
   const transport = createHttpLoggerTransport(config.loggerUrl, {})
-
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    try {
+      const usingRedis = !!(process.env.AZIFY_LOGGER_REDIS_URL && process.env.AZIFY_LOGGER_REDIS_PASSWORD)
+      process.stderr.write(`[azify-logger] Express middleware created service=${config.serviceName || 'unknown'} loggerUrl=${(config.loggerUrl || '').replace(/\/log.*$/, '/log')} transport=${usingRedis ? 'redis' : 'http'}\n`)
+    } catch (_) {}
+  }
   const hostname = os.hostname()
   
   const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
@@ -279,38 +284,41 @@ function createExpressLoggingMiddleware(options = {}) {
 
     if (config.logRequest) {
       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
-        let requestBody = null
-        if (config.captureRequestBody && req.body !== undefined && req.body != null) {
-          requestBody = safeSerializeBody(req.body)
-          request.body = requestBody
-        }
-        
-        const meta = {
-          traceId: reqCtx.traceId,
-          spanId: reqCtx.spanId,
-          parentSpanId: reqCtx.parentSpanId || null,
-          requestId,
-          request,
-          requestBody,
-          timestamp: Date.now(),
-          hostname
+        try {
+          runWithRequestContext(reqCtx, () => {
+          ensureIds()
+          ensureHeaders()
+          const request = {
+            id: requestId,
+            method,
+            url,
+            path,
+            ip: clientIp
+          }
+          if (query) request.query = query
+          if (config.captureHeaders && cachedHeaders) request.headers = cachedHeaders
+          let requestBody = null
+          if (config.captureRequestBody && req.body !== undefined && req.body != null) {
+            requestBody = safeSerializeBody(req.body)
+            request.body = requestBody
+          }
+          const meta = {
+            traceId: reqCtx.traceId,
+            spanId: reqCtx.spanId,
+            parentSpanId: reqCtx.parentSpanId || null,
+            requestId,
+            request,
+            requestBody,
+            timestamp: Date.now(),
+            hostname
+          }
+          if (serviceObj) meta.service = serviceObj
+          if (config.environment) meta.environment = config.environment
+          logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
+          })
+        } catch (err) {
+          try { process.stderr.write(`[azify-logger] [REQUEST] log error: ${err && err.message}\n`) } catch (_) {}
         }
-        if (serviceObj) meta.service = serviceObj
-        if (config.environment) meta.environment = config.environment
-        
-        logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
       })
     }
   
@@ -326,19 +334,14 @@ function createExpressLoggingMiddleware(options = {}) {
       
       if (!logSent) {
         logSent = true
-        
         process.nextTick(() => {
           try {
+            runWithRequestContext(reqCtx, () => {
             ensureIds()
-            
             const statusCode = res.statusCode || 200
             const duration = Date.now() - startTime
             const response = { statusCode, durationMs: duration }
-            
-            if (config.captureHeaders) {
-              ensureHeaders()
-            }
-            
+            if (config.captureHeaders) ensureHeaders()
             const requestObj = {
               id: requestId,
               method,
@@ -348,7 +351,6 @@ function createExpressLoggingMiddleware(options = {}) {
             }
             if (query) requestObj.query = query
             if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
-            
             const meta = {
               traceId: reqCtx.traceId,
               spanId: reqCtx.spanId,
@@ -361,7 +363,6 @@ function createExpressLoggingMiddleware(options = {}) {
             }
             if (serviceObj) meta.service = serviceObj
             if (config.environment) meta.environment = config.environment
-            
             const chunkToProcess = (responseChunk !== null && responseChunkCaptured) ? responseChunk : null
             emitResponseLog(meta, chunkToProcess)
             if (meta.traceId && meta.spanId && config.serviceName) {
@@ -379,6 +380,7 @@ function createExpressLoggingMiddleware(options = {}) {
                 url
               })
             }
+            })
           } catch (err) {
             try {
               ensureIds()
@@ -420,12 +422,12 @@ function createExpressLoggingMiddleware(options = {}) {
                   url
                 })
               }
-            } catch (_) {
+            } catch (innerErr) {
+              try { process.stderr.write(`[azify-logger] [RESPONSE] log error: ${innerErr && innerErr.message}\n`) } catch (_) {}
             }
           }
         })
       }
-      
       return result
     }
 

package/middleware-pino.js

@@ -0,0 +1,173 @@
+try { require('./register') } catch (_) {}
+require('./otel-env')
+const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
+const { createHttpLoggerTransport } = require('./streams/httpQueue')
+const { sendSpanToOtel, setEndpointOverride } = require('./trace-export')
+const os = require('os')
+
+let trace, otelContext
+try {
+  const otelApi = require('@opentelemetry/api')
+  trace = otelApi.trace
+  otelContext = otelApi.context
+} catch (_) {
+  trace = { getSpan: () => null }
+  otelContext = { active: () => ({}) }
+}
+
+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 createPinoHttpLoggingMiddleware(options = {}) {
+  const svcName = options.serviceName || process.env.APP_NAME
+  if (svcName) {
+    process.env.OTEL_SERVICE_NAME = svcName
+    process.env.SERVICE_NAME = svcName
+  }
+  const otelEndpoint = options.otelEndpoint || options.otelExporterEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
+  if (otelEndpoint) {
+    setEndpointOverride(otelEndpoint)
+  }
+  const config = {
+    serviceName: svcName,
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log',
+    environment: options.environment || process.env.NODE_ENV,
+    logRequest: options.logRequest !== false && process.env.AZIFY_LOGGER_LOG_REQUEST !== 'false',
+  }
+
+  const transport = createHttpLoggerTransport(config.loggerUrl, {})
+  const hostname = os.hostname()
+  const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
+
+  function getOtelTraceContext() {
+    try {
+      const activeContext = otelContext.active()
+      const span = trace.getSpan(activeContext)
+      if (span) {
+        const spanContext = span.spanContext()
+        if (spanContext && spanContext.traceId && spanContext.spanId) {
+          const traceHex = spanContext.traceId.replace(/-/g, '')
+          return {
+            traceId: traceHex.length === 32 ? `${traceHex.substring(0, 8)}-${traceHex.substring(8, 12)}-${traceHex.substring(12, 16)}-${traceHex.substring(16, 20)}-${traceHex.substring(20, 32)}` : spanContext.traceId,
+            spanId: spanContext.spanId,
+            parentSpanId: null
+          }
+        }
+      }
+    } catch (_) {}
+    return null
+  }
+
+  function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') return
+
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
+  }
+
+  return function azifyPinoLoggingMiddleware(req, res, next) {
+    const startTime = Date.now()
+    const method = req.method
+    const url = req.url
+    const path = req.path || url
+
+    let reqCtx = null
+
+    function ensureRequestContext() {
+      if (reqCtx) return reqCtx
+
+      const otelCtx = getOtelTraceContext()
+      const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(req.headers['x-trace-id'])
+
+      reqCtx = startRequestContext({
+        requestId: req.requestId || fastUUID(),
+        traceHex: traceHex || undefined,
+        parentSpanId: otelCtx?.parentSpanId || req.headers['x-parent-span-id'] || null
+      })
+
+      if (otelCtx) {
+        reqCtx.traceId = otelCtx.traceId
+        reqCtx.spanId = otelCtx.spanId
+      }
+
+      return reqCtx
+    }
+
+    const ctx = ensureRequestContext()
+
+    req.traceId = ctx.traceId
+    req.spanId = ctx.spanId
+    req.parentSpanId = ctx.parentSpanId
+    req.requestId = ctx.requestId
+
+    const logWithContext = (level, message, meta) => {
+      const otelCtx = getOtelTraceContext()
+      const currentCtx = getRequestContext() || ensureRequestContext()
+      meta.traceId = otelCtx?.traceId || meta.traceId || currentCtx.traceId
+      meta.spanId = otelCtx?.spanId || meta.spanId || currentCtx.spanId
+      meta.parentSpanId = otelCtx?.parentSpanId || meta.parentSpanId || currentCtx.parentSpanId
+      sendLog(level, message, meta)
+    }
+
+    const sameTraceMeta = () => ({
+      traceId: ctx.traceId,
+      spanId: ctx.spanId,
+      parentSpanId: ctx.parentSpanId,
+      requestId: ctx.requestId
+    })
+
+    if (config.logRequest) {
+      sendLog('info', `[REQUEST] ${method} ${path}`, {
+        method,
+        url: path,
+        hostname,
+        service: serviceObj,
+        environment: config.environment,
+        ...sameTraceMeta()
+      })
+    }
+
+    const originalEnd = res.end
+    res.end = function(...args) {
+      res.end = originalEnd
+
+      const duration = Date.now() - startTime
+      const statusCode = res.statusCode
+
+      if (config.logRequest) {
+        sendLog('info', `[RESPONSE] ${method} ${path}`, {
+          method,
+          url: path,
+          statusCode,
+          duration,
+          hostname,
+          service: serviceObj,
+          environment: config.environment,
+          ...sameTraceMeta()
+        })
+      }
+
+      return res.end.apply(res, args)
+    }
+
+    runWithRequestContext(ctx, () => {
+      next()
+    })
+  }
+}
+
+module.exports = createPinoHttpLoggingMiddleware

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -82,6 +82,8 @@
     "azify-logger-worker": "scripts/redis-worker.js"
   },
   "files": [
+    "preload.js",
+    "register-http-client-early.js",
     "trace-export.js",
     "otel-env.js",
     "index.js",
@@ -94,9 +96,11 @@
     "middleware-restify.js",
     "middleware-express.js",
     "middleware-express.d.ts",
+    "middleware-pino.js",
     "middleware-fastify.js",
     "server.js",
     "sampling.js",
+    "pino-config.js",
     "queue/",
     "scripts/redis-worker.js",
     "streams/",

package/pino-config.js

@@ -0,0 +1,26 @@
+const createPinoStream = require('./streams/pino')
+
+/**
+ * Helper para configurar Pino com azify-logger de forma simples
+ */
+function createAzifyPinoTransport(options = {}) {
+  const loggerUrl = options.loggerUrl || process.env.AZIFY_LOGGER_URL
+  const serviceName = options.serviceName || process.env.APP_NAME
+  const environment = options.environment || process.env.NODE_ENV
+
+  if (!loggerUrl) {
+    return null
+  }
+
+  return {
+    target: require.resolve('./streams/pino'),
+    options: {
+      loggerUrl,
+      serviceName,
+      environment,
+      ...options
+    }
+  }
+}
+
+module.exports = { createAzifyPinoTransport }

package/preload.js

@@ -0,0 +1,15 @@
+'use strict'
+if (process.env.AZIFY_LOGGER_DISABLE === '1') return
+try {
+  const path = require('path')
+  const early = require(path.join(__dirname, 'register-http-client-early.js'))
+  if (!early || typeof early.patchUndiciExports !== 'function') return
+  try {
+    const cwd = process.cwd()
+    const resolvePaths = cwd ? [cwd, path.join(cwd, 'dist'), path.join(cwd, 'src')] : undefined
+    const undiciPath = resolvePaths ? require.resolve('undici', { paths: resolvePaths }) : require.resolve('undici')
+    require(undiciPath)
+  } catch (_) {}
+  if (early.patchUndiciInCache) early.patchUndiciInCache()
+  require(path.join(__dirname, 'index.js'))
+} catch (_) {}