azify-logger 1.0.40 → 1.0.41

package/README.md

@@ -73,7 +73,7 @@ await fastify.listen({ port: 3000 })
 | `APP_NAME` | -                                  | Nome da aplicação |
 | `AZIFY_LOGGER_URL` | `http://localhost:3001/log`        | URL do logger |
 | `AZIFY_LOGGER_REDIS_URL` | `redis://localhost:6381`           | URL do Redis (fila de logs) |
-| `AZIFY_LOGGER_REDIS_PASSWORD` | —                                  | **Obrigatório só em produção.** Em `NODE_ENV=production` o Redis exige senha; em dev/staging é opcional. |
+| `AZIFY_LOGGER_REDIS_PASSWORD` | —                                  | **Obrigatório em todos os ambientes.** Sem senha, a app continua (usa HTTP direto) e a mensagem de aviso é exibida. |
 | `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces`  | Endpoint OTLP para traces (opcional) |
 | `NODE_ENV` | `development`                      | Ambiente |
 

package/index.js

@@ -1,3 +1,4 @@
+require('./otel-env')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const nativeConsole = {
   log: console.log.bind(console),

package/init.js

@@ -1,6 +1,7 @@
 if (process.env.AZIFY_LOGGER_DISABLE === '1') {
   module.exports = {}
 } else {
+require('./otel-env')
 const Module = require('module')
 const originalRequire = Module.prototype.require
 

package/middleware-express.js

@@ -1,3 +1,4 @@
+require('./otel-env')
 const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const { Worker } = require('worker_threads')

package/middleware-fastify.js

@@ -1,14 +1,18 @@
+require('./otel-env')
 const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
+const { sendSpanToOtel, setEndpointOverride } = require('./trace-export')
 const os = require('os')
 
-let trace, otelContext
+let trace, otelContext, tracer
 try {
   const otelApi = require('@opentelemetry/api')
   trace = otelApi.trace
   otelContext = otelApi.context
+  tracer = trace.getTracer('azify-logger', '1.0.0')
 } catch (_) {
   trace = { getSpan: () => null }
   otelContext = { active: () => ({}) }
+  tracer = null
 }
 
 function fastUUID() {
@@ -75,8 +79,17 @@ function pickHeaders(source) {
 }
 
 function createFastifyLoggingPlugin(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: options.serviceName || process.env.APP_NAME,
+    serviceName: svcName,
     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',
@@ -101,49 +114,83 @@ function createFastifyLoggingPlugin(options = {}) {
     } catch (_) {}
   }
 
+  function toTraceId(sc) {
+    if (!sc?.traceId || !sc?.spanId) return null
+    const traceHex = (sc.traceId || '').replace(/-/g, '').padStart(32, '0').slice(0, 32)
+    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)}` : sc.traceId,
+      traceIdHex: traceHex,
+      spanId: sc.spanId,
+      parentSpanId: null
+    }
+  }
+
   return async function azifyFastifyPlugin(fastify, opts) {
     fastify.addHook('onRequest', async (request, reply) => {
       let reqCtx = null
-      
-      function getOtelTraceContext() {
+      let libSpan = null
+      let libTraceId = null
+      let libSpanId = null
+
+      let libTraceIdHex = null
+      if (tracer) {
         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
-              }
+          const parentCtx = otelContext.active()
+          const existingSpan = trace.getSpan(parentCtx) || (request.opentelemetry && typeof request.opentelemetry === 'function' ? request.opentelemetry()?.span : null)
+          libSpan = tracer.startSpan('azify-logger.request', {
+            attributes: {
+              'http.method': request.method,
+              'http.url': request.url
             }
+          }, existingSpan ? trace.setSpan(parentCtx, existingSpan) : parentCtx)
+          const tid = toTraceId(libSpan.spanContext())
+          if (tid) {
+            libTraceId = tid.traceId
+            libTraceIdHex = tid.traceIdHex
+            libSpanId = tid.spanId
           }
         } catch (_) {}
-        return null
       }
-      
+      if (!libTraceId) {
+        if (request.opentelemetry && typeof request.opentelemetry === 'function') {
+          try {
+            const o = request.opentelemetry()
+            const tid = o?.span ? toTraceId(o.span.spanContext()) : null
+            if (tid) {
+              libTraceId = tid.traceId
+              libTraceIdHex = tid.traceIdHex
+              libSpanId = tid.spanId
+            }
+          } catch (_) {}
+        }
+        if (!libTraceId) {
+          try {
+            const span = trace.getSpan(otelContext.active())
+            const tid = span ? toTraceId(span.spanContext()) : null
+            if (tid) {
+              libTraceId = tid.traceId
+              libTraceIdHex = tid.traceIdHex
+              libSpanId = tid.spanId
+            }
+          } catch (_) {}
+        }
+      }
+
       function ensureRequestContext() {
         if (reqCtx) return reqCtx
-        
-        const otelCtx = getOtelTraceContext()
-        const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
-        
+        const traceHex = libTraceId ? libTraceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
         reqCtx = startRequestContext({
           requestId: request.requestId || fastUUID(),
           traceHex: traceHex || undefined,
-          parentSpanId: otelCtx?.parentSpanId || request.headers['x-parent-span-id'] || null
+          parentSpanId: request.headers['x-parent-span-id'] || null
         })
-        
-        if (otelCtx) {
-          reqCtx.traceId = otelCtx.traceId
-          reqCtx.spanId = otelCtx.spanId
+        if (libTraceId && libSpanId) {
+          reqCtx.traceId = libTraceId
+          reqCtx.spanId = libSpanId
         }
-        
         return reqCtx
       }
-      
+
       const ctx = ensureRequestContext()
       
       runWithRequestContext(ctx, () => {})
@@ -161,12 +208,10 @@ function createFastifyLoggingPlugin(options = {}) {
       let headersCached = false
       
       const logWithContext = (level, message, meta) => {
-        const otelCtx = getOtelTraceContext()
         const ctx = getRequestContext() || ensureRequestContext()
-        
-        meta.traceId = otelCtx?.traceId || meta.traceId || ctx.traceId
-        meta.spanId = otelCtx?.spanId || meta.spanId || ctx.spanId
-        meta.parentSpanId = otelCtx?.parentSpanId || meta.parentSpanId || ctx.parentSpanId
+        meta.traceId = libTraceId || meta.traceId || ctx.traceId
+        meta.spanId = libSpanId || meta.spanId || ctx.spanId
+        meta.parentSpanId = ctx.parentSpanId || null
         sendLog(level, message, meta)
       }
       
@@ -178,16 +223,9 @@ function createFastifyLoggingPlugin(options = {}) {
         
         const ctx = ensureRequestContext()
         
-        const otelCtx = getOtelTraceContext()
-        if (otelCtx) {
-          traceId = otelCtx.traceId
-          spanId = otelCtx.spanId
-          parentSpanId = otelCtx.parentSpanId
-        } else {
-          traceId = ctx.traceId
-          spanId = ctx.spanId
-          parentSpanId = ctx.parentSpanId || request.headers['x-parent-span-id'] || null
-        }
+        traceId = libTraceId || ctx.traceId
+        spanId = libSpanId || ctx.spanId
+        parentSpanId = ctx.parentSpanId || request.headers['x-parent-span-id'] || null
         
         requestId = ctx.requestId || request.requestId || fastUUID()
         clientIp = request.ip || request.socket?.remoteAddress || 'unknown'
@@ -225,6 +263,7 @@ function createFastifyLoggingPlugin(options = {}) {
         logSent: false,
         requestId: null,
         traceId: null,
+        traceIdHex: libTraceIdHex,
         spanId: null,
         parentSpanId: null,
         clientIp: null,
@@ -232,7 +271,10 @@ function createFastifyLoggingPlugin(options = {}) {
         cachedHeaders: null,
         idsCreated: false,
         headersCached: false,
-        reqCtx: null
+        reqCtx: null,
+        libSpan,
+        libTraceId,
+        libSpanId
       }
 
       if (config.logRequest) {
@@ -253,13 +295,13 @@ function createFastifyLoggingPlugin(options = {}) {
             requestObj.body = safeSerializeBody(request.body)
           }
           
-          const otelCtx = getOtelTraceContext()
           const ctx = getRequestContext() || ensureRequestContext()
           
           const meta = {
-            traceId: otelCtx?.traceId || ctx.traceId,
-            spanId: otelCtx?.spanId || ctx.spanId,
-            parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
+            traceId: libTraceId || ctx.traceId,
+            traceIdHex: libTraceIdHex || (ctx.traceId ? ctx.traceId.replace(/-/g, '').slice(0, 32) : null),
+            spanId: libSpanId || ctx.spanId,
+            parentSpanId: ctx.parentSpanId || null,
             requestId,
             request: requestObj,
             timestamp: Date.now(),
@@ -279,6 +321,13 @@ function createFastifyLoggingPlugin(options = {}) {
       
       logger.logSent = true
       
+      if (logger.libSpan) {
+        try {
+          logger.libSpan.setAttribute('http.status_code', reply.statusCode || 200)
+          logger.libSpan.end()
+        } catch (_) {}
+      }
+      
       if (config.captureResponseBody && payload != null && !logger.responseChunkCaptured) {
         logger.responseChunk = payload
         logger.responseChunkCaptured = true
@@ -288,58 +337,41 @@ function createFastifyLoggingPlugin(options = {}) {
       const method = logger.method
       const url = logger.url
       const path = logger.path
+      const capturedTraceId = logger.libTraceId || null
+      const capturedTraceIdHex = logger.traceIdHex || (capturedTraceId ? capturedTraceId.replace(/-/g, '').slice(0, 32) : null)
+      const capturedSpanId = logger.libSpanId || null
+      const capturedParentSpanId = null
       
       let reqCtx = null
       let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
       let idsCreated = false
       let headersCached = false
       
-      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 ensureRequestContext() {
         if (reqCtx) return reqCtx
         
-        const otelCtx = getOtelTraceContext()
-        const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
+        const traceHex = capturedTraceId ? capturedTraceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(request.headers['x-trace-id'])
         
         reqCtx = startRequestContext({
           requestId: request.requestId || fastUUID(),
           traceHex: traceHex || undefined,
-          parentSpanId: otelCtx?.parentSpanId || request.headers['x-parent-span-id'] || null
+          parentSpanId: capturedParentSpanId || request.headers['x-parent-span-id'] || null
         })
         
-        if (otelCtx) {
-          reqCtx.traceId = otelCtx.traceId
-          reqCtx.spanId = otelCtx.spanId
+        if (capturedTraceId && capturedSpanId) {
+          reqCtx.traceId = capturedTraceId
+          reqCtx.spanId = capturedSpanId
         }
         
         return reqCtx
       }
       
       const logWithContext = (level, message, meta) => {
-        const otelCtx = getOtelTraceContext()
         const ctx = getRequestContext() || ensureRequestContext()
         
-        meta.traceId = otelCtx?.traceId || meta.traceId || ctx.traceId
-        meta.spanId = otelCtx?.spanId || meta.spanId || ctx.spanId
-        meta.parentSpanId = otelCtx?.parentSpanId || meta.parentSpanId || ctx.parentSpanId
+        meta.traceId = capturedTraceId || meta.traceId || ctx.traceId
+        meta.spanId = capturedSpanId || meta.spanId || ctx.spanId
+        meta.parentSpanId = capturedParentSpanId || meta.parentSpanId || ctx.parentSpanId
         sendLog(level, message, meta)
       }
       
@@ -351,11 +383,10 @@ function createFastifyLoggingPlugin(options = {}) {
         
         const ctx = ensureRequestContext()
         
-        const otelCtx = getOtelTraceContext()
-        if (otelCtx) {
-          traceId = otelCtx.traceId
-          spanId = otelCtx.spanId
-          parentSpanId = otelCtx.parentSpanId
+        if (capturedTraceId && capturedSpanId) {
+          traceId = capturedTraceId
+          spanId = capturedSpanId
+          parentSpanId = capturedParentSpanId
         } else {
           traceId = ctx.traceId
           spanId = ctx.spanId
@@ -408,13 +439,13 @@ function createFastifyLoggingPlugin(options = {}) {
         if (query) requestObj.query = query
         if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
         
-        const otelCtx = getOtelTraceContext()
         const ctx = getRequestContext() || ensureRequestContext()
         
         const meta = {
-          traceId: otelCtx?.traceId || ctx.traceId,
-          spanId: otelCtx?.spanId || ctx.spanId,
-          parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
+          traceId: capturedTraceId || ctx.traceId,
+          traceIdHex: capturedTraceIdHex || (ctx.traceId ? ctx.traceId.replace(/-/g, '').slice(0, 32) : null),
+          spanId: capturedSpanId || ctx.spanId,
+          parentSpanId: capturedParentSpanId != null ? capturedParentSpanId : (ctx.parentSpanId || null),
           requestId,
           request: requestObj,
           response,
@@ -426,6 +457,23 @@ function createFastifyLoggingPlugin(options = {}) {
         
         const chunkToProcess = (logger.responseChunk !== null && logger.responseChunkCaptured) ? logger.responseChunk : null
         emitResponseLog(meta, chunkToProcess)
+        const traceIdForSpan = meta.traceId
+        const spanIdForSpan = meta.spanId
+        if (traceIdForSpan && spanIdForSpan && config.serviceName) {
+          const startNs = BigInt(logger.startTime) * BigInt(1e6)
+          const endNs = BigInt(meta.timestamp || Date.now()) * BigInt(1e6)
+          sendSpanToOtel({
+            traceId: traceIdForSpan,
+            spanId: spanIdForSpan,
+            serviceName: config.serviceName,
+            name: `request handler - ${logger.path || url}`,
+            startTimeNs: startNs,
+            endTimeNs: endNs,
+            statusCode: reply.statusCode || 200,
+            method,
+            url
+          })
+        }
       })
       
       return payload

package/middleware-restify.js

@@ -1,15 +1,46 @@
-const { startRequestContext, runWithRequestContext, getRequestContext } = require('./store')
+require('./otel-env')
+const { startRequestContext, runWithRequestContext, getRequestContext, als } = require('./store')
 const { createHttpLoggerTransport } = require('./streams/httpQueue')
 const os = require('os')
 
-let trace, otelContext
+let trace, otelContext, otelRootContext
 try {
   const otelApi = require('@opentelemetry/api')
   trace = otelApi.trace
   otelContext = otelApi.context
+  otelRootContext = otelApi.ROOT_CONTEXT
 } catch (_) {
   trace = { getSpan: () => null }
-  otelContext = { active: () => ({}) }
+  otelContext = { active: () => ({}), with: (_ctx, fn) => fn() }
+  otelRootContext = null
+}
+
+let emergencySendLog = null
+let unhandledRejectionInstalled = false
+function installUnhandledRejectionHandler () {
+  if (unhandledRejectionInstalled) return
+  unhandledRejectionInstalled = true
+  process.on('unhandledRejection', (reason, promise) => {
+    try {
+      if (emergencySendLog) {
+        const err = reason instanceof Error ? reason : new Error(String(reason))
+        const meta = {
+          error: { message: err.message, name: err.name, stack: err.stack }
+        }
+        try {
+          const ctx = getRequestContext()
+          if (ctx) {
+            meta.requestId = ctx.requestId
+            meta.traceId = ctx.traceId
+            meta.spanId = ctx.spanId
+            meta.parentSpanId = ctx.parentSpanId || null
+          }
+        } catch (_) {}
+        const message = err.message || '[azify-logger] Unhandled rejection'
+        emergencySendLog('error', message, meta)
+      }
+    } catch (_) {}
+  })
 }
 
 function fastUUID() {
@@ -47,9 +78,9 @@ function pickHeaders (source) {
   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)
@@ -64,7 +95,8 @@ function createRestifyLoggingMiddleware (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
+    environment: options.environment || process.env.NODE_ENV,
+    logRequest: options.logRequest !== false && process.env.AZIFY_LOGGER_LOG_REQUEST !== 'false'
   }
 
   const transport = createHttpLoggerTransport(config.loggerUrl, {})
@@ -73,12 +105,12 @@ function createRestifyLoggingMiddleware (options = {}) {
 
   function sendLog (level, message, meta = {}) {
     if (!transport || typeof transport.enqueue !== 'function') return
-    
+
     if (serviceObj) meta.service = serviceObj
     if (config.environment) meta.environment = config.environment
     meta.timestamp = Date.now()
     meta.hostname = hostname
-    
+
     transport.enqueue({
       level,
       message,
@@ -86,6 +118,11 @@ function createRestifyLoggingMiddleware (options = {}) {
     }, { 'content-type': 'application/json' })
   }
 
+  if (emergencySendLog === null) {
+    emergencySendLog = sendLog
+    installUnhandledRejectionHandler()
+  }
+
   return function azifyLoggingMiddleware (req, res, next) {
     const startTime = Date.now()
 
@@ -112,31 +149,27 @@ function createRestifyLoggingMiddleware (options = {}) {
       } catch (_) {}
       return null
     }
-    
+
     function ensureRequestContext() {
       const otelCtx = getOtelTraceContext()
       const traceHex = otelCtx ? otelCtx.traceId.replace(/-/g, '').substring(0, 32) : sanitizeTraceHex(req.headers['x-trace-id'])
-      
+
       const 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 reqCtx = ensureRequestContext()
     const requestId = reqCtx.requestId
-    
-    runWithRequestContext(reqCtx, () => {
-      next()
-    })
 
     let normalizedPath = req.url
     if (normalizedPath.includes('?')) {
@@ -155,6 +188,26 @@ function createRestifyLoggingMiddleware (options = {}) {
       ip: req.connection.remoteAddress || req.socket.remoteAddress
     }
 
+    runWithRequestContext(reqCtx, () => {
+      if (config.logRequest) {
+        process.nextTick(() => {
+          try {
+            const meta = {
+              traceId: reqCtx.traceId,
+              spanId: reqCtx.spanId,
+              parentSpanId: reqCtx.parentSpanId || null,
+              requestId,
+              request: requestSnapshot,
+              timestamp: Date.now(),
+              hostname
+            }
+            sendLog('info', `[REQUEST] ${req.method} ${req.url}`, meta)
+          } catch (_) {}
+        })
+      }
+      next()
+    })
+
     let responseStatus
     const originalStatus = res.status
     if (typeof originalStatus === 'function') {
@@ -181,56 +234,127 @@ function createRestifyLoggingMiddleware (options = {}) {
 
     let logSent = false
 
+    function runOutsideOtelContext (fn) {
+      if (otelRootContext != null && typeof otelContext.with === 'function') {
+        return otelContext.with(otelRootContext, fn)
+      }
+      return fn()
+    }
+
     function emitLog (level, message, extraMeta = {}) {
       if (logSent) return
       logSent = true
-      
-      process.nextTick(() => {
-        const duration = Date.now() - startTime
-        const statusCode = responseStatus || res.statusCode || 200
-        const responseHeaders = typeof res.getHeaders === 'function' ? res.getHeaders() : {}
-        
-        const otelCtx = getOtelTraceContext()
-        const ctx = getRequestContext() || reqCtx
 
-        const meta = {
-          traceId: otelCtx?.traceId || ctx.traceId,
-          spanId: otelCtx?.spanId || ctx.spanId,
-          parentSpanId: otelCtx?.parentSpanId || ctx.parentSpanId || null,
-          requestId,
-          request: requestSnapshot,
-          response: {
-            statusCode,
-            headers: pickHeaders(responseHeaders),
-            durationMs: duration
-          },
-          ...extraMeta
-        }
+      setImmediate(() => {
+        runOutsideOtelContext(() => {
+          try {
+            const duration = Date.now() - startTime
+            const statusCode = responseStatus ?? 200
+
+            const meta = {
+              traceId: reqCtx.traceId,
+              spanId: reqCtx.spanId,
+              parentSpanId: reqCtx.parentSpanId || null,
+              requestId,
+              request: requestSnapshot,
+              response: {
+                statusCode,
+                headers: {},
+                durationMs: duration
+              },
+              ...extraMeta
+            }
 
-        sendLog(level, message, meta)
+            sendLog(level, message, meta)
+          } catch (err) {
+            const errPayload = {
+              traceId: reqCtx.traceId,
+              spanId: reqCtx.spanId,
+              parentSpanId: reqCtx.parentSpanId || null,
+              requestId,
+              request: requestSnapshot,
+              error: {
+                message: err && err.message ? err.message : String(err),
+                name: err && err.name ? err.name : 'Error',
+                stack: err && err.stack ? err.stack : undefined
+              }
+            }
+            setImmediate(() => {
+              try {
+                sendLog('error', (requestSnapshot && (requestSnapshot.method + ' ' + requestSnapshot.url)) || 'request', errPayload)
+              } catch (_) {}
+            })
+          }
+        })
       })
     }
 
     function finalize (level = 'info', errorMeta) {
       if (logSent) return
-      const message = `${req.method} ${req.url}`
-      const meta = errorMeta ? { error: errorMeta } : {}
-      emitLog(level, message, meta)
+      try {
+        const message = `${requestSnapshot.method} ${requestSnapshot.url}`
+        const meta = errorMeta ? { error: errorMeta } : {}
+        emitLog(level, message, meta)
+      } catch (err) {
+        try {
+          emitLog('error', `${requestSnapshot.method} ${requestSnapshot.url}`, { error: err && err.message ? err.message : String(err) })
+        } catch (_) {}
+      }
+    }
+
+    function runOutsideRequestContext (fn) {
+      als.run(undefined, fn)
     }
 
     res.on('finish', () => {
-      finalize('info')
+      runOutsideOtelContext(() => {
+        runOutsideRequestContext(() => {
+          try {
+            finalize('info')
+          } catch (err) {
+            const errPayload = {
+              traceId: reqCtx.traceId,
+              spanId: reqCtx.spanId,
+              parentSpanId: reqCtx.parentSpanId || null,
+              requestId,
+              request: requestSnapshot,
+              error: {
+                message: err && err.message ? err.message : String(err),
+                name: err && err.name ? err.name : 'Error',
+                stack: err && err.stack ? err.stack : undefined
+              }
+            }
+            setImmediate(() => {
+              try {
+                sendLog('error', (requestSnapshot && (requestSnapshot.method + ' ' + requestSnapshot.url)) || 'request', errPayload)
+              } catch (_) {}
+            })
+          }
+        })
+      })
     })
 
     res.on('close', () => {
-      finalize('warn', { message: 'response closed before finish' })
+      runOutsideOtelContext(() => {
+        runOutsideRequestContext(() => {
+          try {
+            finalize('warn', { message: 'response closed before finish' })
+          } catch (_) {}
+        })
+      })
     })
 
     res.on('error', (err) => {
-      finalize('error', {
-        message: err && err.message ? err.message : String(err),
-        name: err && err.name ? err.name : 'Error',
-        stack: err && err.stack ? err.stack : undefined
+      runOutsideOtelContext(() => {
+        runOutsideRequestContext(() => {
+          try {
+            finalize('error', {
+              message: err && err.message ? err.message : String(err),
+              name: err && err.name ? err.name : 'Error',
+              stack: err && err.stack ? err.stack : undefined
+            })
+          } catch (_) {}
+        })
       })
     })
 

package/otel-env.js

@@ -0,0 +1,42 @@
+if (process.env.OTEL_TRACES_SAMPLER === undefined) {
+  process.env.OTEL_TRACES_SAMPLER = 'always_on'
+}
+
+try {
+  const Module = require('module')
+  const { pathToFileURL } = require('url')
+  const parentURL = pathToFileURL(require.resolve('./otel-env.js')).href
+  Module.register('import-in-the-middle/hook.mjs', parentURL, {
+    data: { include: ['@opentelemetry/sdk-node'] }
+  })
+  const { Hook } = require('import-in-the-middle')
+  const { SimpleSpanProcessor } = require('@opentelemetry/sdk-trace-base')
+  new Hook(['@opentelemetry/sdk-node'], (exported) => {
+    if (!exported?.NodeSDK) return
+    const Original = exported.NodeSDK
+    const { AlwaysOnSampler } = exported.tracing || require('@opentelemetry/sdk-trace-base')
+    class Patched extends Original {
+      constructor (config = {}) {
+        if (!config.sampler) {
+          config = { ...config, sampler: new AlwaysOnSampler() }
+        }
+        if (config.traceExporter && !config.spanProcessor && !config.spanProcessors) {
+          config = { ...config, spanProcessor: new SimpleSpanProcessor(config.traceExporter) }
+        }
+        const inst = (config.instrumentations || []).flat()
+        const hasFastifyOtel = inst.some(i => i && /fastifyotel|@fastify\/otel/i.test(String(i.instrumentationName || i?.constructor?.name || '')))
+        if (hasFastifyOtel) {
+          config = {
+            ...config,
+            instrumentations: inst.filter(i => {
+              const n = String(i?.instrumentationName || i?.constructor?.name || '')
+              return !n.includes('@opentelemetry/instrumentation-fastify')
+            })
+          }
+        }
+        super(config)
+      }
+    }
+    exported.NodeSDK = Patched
+  })
+} catch (_) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -57,8 +57,9 @@
     "cors": "^2.8.5",
     "dotenv": "^17.2.3",
     "express": "^4.18.2",
-    "fastify-plugin": "^5.0.0",
     "express-session": "^1.17.3",
+    "fastify-plugin": "^5.0.0",
+    "import-in-the-middle": "^3.0.0",
     "ioredis": "^5.8.2",
     "js-yaml": "^4.1.0",
     "passport": "^0.6.0",
@@ -81,6 +82,8 @@
     "azify-logger-worker": "scripts/redis-worker.js"
   },
   "files": [
+    "trace-export.js",
+    "otel-env.js",
     "index.js",
     "index.d.ts",
     "init.js",

package/queue/redisQueue.js

@@ -30,9 +30,8 @@ function createRedisProducer(config = {}) {
   const maxLen = Number.isFinite(config.maxLen) ? config.maxLen : DEFAULT_MAXLEN
   const password = config.password ?? process.env.AZIFY_LOGGER_REDIS_PASSWORD
   const pass = password != null && String(password).trim() !== '' ? String(password).trim() : null
-  const isProd = process.env.NODE_ENV === 'production'
-  if (!pass && isProd) {
-    throw new Error('Redis requires a password in production. Set AZIFY_LOGGER_REDIS_PASSWORD (or options.redis.password).')
+  if (!pass) {
+    throw new Error('Redis requires a password. Set AZIFY_LOGGER_REDIS_PASSWORD (or options.redis.password).')
   }
 
   const redisOptions = { ...defaultRedisOptions, ...(config.redisOptions || {}) }

package/register-otel.js

@@ -1,12 +1,13 @@
 try {
   const { NodeSDK } = require('@opentelemetry/sdk-node')
+  const { AlwaysOnSampler } = require('@opentelemetry/core')
   const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
   const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express')
   const { RestifyInstrumentation } = require('@opentelemetry/instrumentation-restify')
   const { Resource } = require('@opentelemetry/resources')
   const { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } = require('@opentelemetry/semantic-conventions')
 
-  const serviceName = process.env.OTEL_SERVICE_NAME || process.env.APP_NAME || 'app'
+  const serviceName = process.env.OTEL_SERVICE_NAME || process.env.SERVICE_NAME || process.env.APP_NAME || 'app'
   const serviceVersion = process.env.OTEL_SERVICE_VERSION || '1.0.0'
 
   process.env.OTEL_SERVICE_NAME = serviceName
@@ -18,43 +19,25 @@ try {
     process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = otlpEndpoint
   }
 
-  let collectorHost = null
-  let collectorPath = null
+  let ignoreOutgoingUrls = []
   try {
-    const target = new URL(process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log')
-    collectorHost = target.host
-    collectorPath = target.pathname || '/'
+    const u = process.env.AZIFY_LOGGER_URL
+    if (u) {
+      const t = new URL(u)
+      const base = t.origin + (t.pathname || '/').replace(/\/$/, '') || t.origin + '/'
+      ignoreOutgoingUrls = [base, base + '/']
+    }
   } catch (_) {}
 
-  const isLoggerRequest = (host, path) => {
-    if (!collectorHost || typeof host !== 'string') return false
-    if (host !== collectorHost) return false
-    return typeof path === 'string' && path.startsWith(collectorPath)
-  }
-
   const httpInstrumentation = new HttpInstrumentation({
     enabled: true,
     requireParentforOutgoingSpans: false,
     requireParentforIncomingSpans: false,
-    ignoreIncomingRequestHook (req) {
-      if (!collectorHost) return false
-      const host = req.headers?.host
-      const url = req.url
-      return typeof host === 'string' && isLoggerRequest(host, url)
-    },
-    ignoreOutgoingRequestHook (res) {
-      try {
-        if (!collectorHost) return false
-        const host = res?.host
-        const path = res?.path
-        return isLoggerRequest(host, path)
-      } catch (_) {
-        return false
-      }
-    },
-    requestHook (span, { options }) {
-      if (!options?.headers) return
-      const requestId = options.headers['x-request-id'] || options.headers['X-Request-ID']
+    ignoreIncomingPaths: ['/log', '/send', '/v1/traces'],
+    ignoreOutgoingUrls: ignoreOutgoingUrls.length ? ignoreOutgoingUrls : undefined,
+    requestHook (span, request) {
+      if (!request?.getHeader) return
+      const requestId = request.getHeader('x-request-id') || request.getHeader('X-Request-ID')
       if (requestId) {
         span.setAttribute('azify.request_id', requestId)
       }
@@ -173,6 +156,7 @@ try {
       [SEMRESATTRS_SERVICE_VERSION]: serviceVersion
     }),
     spanProcessor,
+    sampler: new AlwaysOnSampler(),
     instrumentations: [
       httpInstrumentation,
       expressInstrumentation,

package/scripts/redis-worker.js

@@ -27,9 +27,8 @@ const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: MAX_SOCKETS })
 
 const REDIS_PASSWORD = process.env.AZIFY_LOGGER_REDIS_PASSWORD
 const pass = REDIS_PASSWORD != null && String(REDIS_PASSWORD).trim() !== '' ? String(REDIS_PASSWORD).trim() : null
-const isProd = process.env.NODE_ENV === 'production'
-if (!pass && isProd) {
-  process.stderr.write('[azify-logger] ❌ Redis requires a password in production. Set AZIFY_LOGGER_REDIS_PASSWORD (e.g. in env/app.env or your environment).\n')
+if (!pass) {
+  process.stderr.write('[azify-logger] ⚠️  Redis requires a password. No password set. Set AZIFY_LOGGER_REDIS_PASSWORD to use Redis. Exiting.\n')
   process.exit(1)
 }
 

package/server.js

@@ -499,7 +499,26 @@ async function setupGrafanaForApp(appName) {
 
     try {
       const tempoDatasourceUid = `tempo-${appName.toLowerCase()}`
-      const tempoUrl = runningInDocker ? 'http://azify-tempo:3200' : 'http://localhost:3200'
+      const tempoUrl = runningInDocker ? 'http://tempo:3200' : 'http://localhost:3200'
+      const serviceFilter = `{ resource.service.name="${appName}" }`
+      const tempoJsonData = {
+        httpMethod: 'GET',
+        defaultQuery: serviceFilter,
+        tracesToLogs: {
+          datasourceUid: datasourceUid,
+          tags: ['job', 'service', 'pod'],
+          mappedTags: [{ key: 'service.name', value: 'service' }],
+          mapTagNamesEnabled: false,
+          spanStartTimeShift: '-1m',
+          spanEndTimeShift: '1m',
+          filterByTraceID: true,
+          filterBySpanID: false,
+          customQuery: true,
+          query: `traceId:"\${__trace.traceId}"`
+        },
+        nodeGraph: { enabled: false },
+        search: { hide: true }
+      }
       const tempoDatasourceConfig = {
         name: `Tempo-${appName}`,
         type: 'tempo',
@@ -507,28 +526,7 @@ async function setupGrafanaForApp(appName) {
         url: tempoUrl,
         uid: tempoDatasourceUid,
         isDefault: false,
-        jsonData: {
-          httpMethod: 'GET',
-          tracesToLogs: {
-            datasourceUid: datasourceUid,
-            tags: ['job', 'service', 'pod'],
-            mappedTags: [{ key: 'service.name', value: 'service' }],
-            mapTagNamesEnabled: false,
-            spanStartTimeShift: '1h',
-            spanEndTimeShift: '1h',
-            filterByTraceID: false,
-            filterBySpanID: false
-          },
-          serviceMap: {
-            datasourceUid: datasourceUid
-          },
-          nodeGraph: {
-            enabled: true
-          },
-          search: {
-            hide: false
-          }
-        },
+        jsonData: tempoJsonData,
         editable: true,
         version: 1
       }
@@ -1699,7 +1697,7 @@ async function handleLog(req, res) {
       parentSpanId: null
     }
   }
-  
+  const traceIdHex = (meta && meta.traceIdHex) || (traceContext.traceId ? String(traceContext.traceId).replace(/-/g, '').padStart(32, '0').slice(0, 32) : null)
   const logEntry = {
     '@timestamp': (meta && meta.timestamp) || new Date().toISOString(),
     level,
@@ -1711,14 +1709,14 @@ async function handleLog(req, res) {
     appName: (meta && meta.appName) || (meta && meta.service && meta.service.name) || undefined,
     environment: (meta && meta.environment) || process.env.NODE_ENV,
     hostname: (meta && meta.hostname) || os.hostname(),
-    traceId: traceContext.traceId,
+    traceId: traceIdHex || traceContext.traceId,
     spanId: traceContext.spanId,
     parentSpanId: traceContext.parentSpanId
   }
 
   if (meta) {
     Object.keys(meta).forEach(key => {
-      if (!['timestamp', 'service', 'environment', 'hostname', 'traceId', 'spanId', 'parentSpanId'].includes(key)) {
+      if (!['timestamp', 'service', 'environment', 'hostname', 'traceId', 'traceIdHex', 'spanId', 'parentSpanId'].includes(key)) {
         let value = meta[key]
         
         if (typeof value === 'string') {

package/streams/httpQueue.js

@@ -94,9 +94,8 @@ function resolveRedisConfig (overrides = {}) {
   const spoolDir = overrides.redisSpoolDir || (overrides.redis && overrides.redis.spoolDir) || process.env.AZIFY_LOGGER_REDIS_SPOOL_DIR
   const password = overrides.redisPassword ?? (overrides.redis && overrides.redis.password) ?? process.env.AZIFY_LOGGER_REDIS_PASSWORD
   const pass = password != null && String(password).trim() !== '' ? String(password).trim() : undefined
-  const isProd = process.env.NODE_ENV === 'production'
 
-  if (!pass && isProd) {
+  if (!pass) {
     return null
   }
 
@@ -128,14 +127,13 @@ function createHttpLoggerTransport (loggerUrl, overrides) {
     }
   }
 
-  const isProd = process.env.NODE_ENV === 'production'
   const redisUrl = overrides.redisUrl || (overrides.redis && overrides.redis.url) || process.env.AZIFY_LOGGER_REDIS_URL || DEFAULT_REDIS_URL
   const password = overrides.redisPassword ?? (overrides.redis && overrides.redis.password) ?? process.env.AZIFY_LOGGER_REDIS_PASSWORD
   const pass = password != null && String(password).trim() !== '' ? String(password).trim() : undefined
-  if (isProd && redisUrl && !pass) {
-    if (typeof global.__azifyLoggerProdPasswordWarned === 'undefined') {
-      global.__azifyLoggerProdPasswordWarned = true
-      process.stderr.write('[azify-logger] ⚠️  Redis requires a password in production. Using direct HTTP (no Redis). Set AZIFY_LOGGER_REDIS_PASSWORD to use Redis.\n')
+  if (redisUrl && !pass) {
+    if (typeof global.__azifyLoggerRedisPasswordWarned === 'undefined') {
+      global.__azifyLoggerRedisPasswordWarned = true
+      process.stderr.write('[azify-logger] ⚠️  Redis requires a password. No password set. Using direct HTTP (no Redis). Set AZIFY_LOGGER_REDIS_PASSWORD to use Redis.\n')
     }
   }
 

package/trace-export.js

@@ -0,0 +1,85 @@
+const http = require('http')
+const https = require('https')
+
+let _endpoint = null
+let _endpointOverride = null
+function setEndpointOverride(url) {
+  _endpointOverride = url || null
+  _endpoint = null
+}
+function getEndpoint() {
+  if (_endpoint != null) return _endpoint
+  const url = _endpointOverride || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
+  if (!url) return null
+  try {
+    _endpoint = new URL(url.includes('/v1/') ? url : String(url).replace(/\/$/, '') + '/v1/traces')
+    return _endpoint
+  } catch (_) {
+    return null
+  }
+}
+
+function normalizeHex(val, len) {
+  if (!val || typeof val !== 'string') return null
+  const hex = val.replace(/[^0-9a-fA-F]/g, '').padStart(len, '0').slice(0, len)
+  return hex || null
+}
+
+function sendSpanToOtel(opts) {
+  const endpoint = getEndpoint()
+  if (!endpoint) return
+  const { traceId, spanId, serviceName, name, startTimeNs, endTimeNs, statusCode, method, url } = opts
+  const traceIdHex = normalizeHex(traceId, 32)
+  const spanIdHex = normalizeHex(spanId, 16)
+  if (!traceIdHex || !spanIdHex || !serviceName) return
+  const svc = String(serviceName).trim() || 'unknown'
+  const spanName = name || 'request'
+  const start = startTimeNs || BigInt(Date.now()) * BigInt(1e6)
+  const end = endTimeNs || BigInt(Date.now()) * BigInt(1e6)
+  const attrs = [
+    { key: 'http.method', value: { stringValue: String(method || 'GET') } },
+    { key: 'http.url', value: { stringValue: String(url || '') } }
+  ]
+  if (statusCode != null) {
+    attrs.push({ key: 'http.status_code', value: { stringValue: String(statusCode) } })
+  }
+  const resourceSpans = [{
+    resource: {
+      attributes: [
+        { key: 'service.name', value: { stringValue: svc } },
+        { key: 'service.version', value: { stringValue: '1.0.0' } }
+      ]
+    },
+    scopeSpans: [{
+      spans: [{
+        traceId: traceIdHex,
+        spanId: spanIdHex,
+        name: spanName,
+        kind: 1,
+        startTimeUnixNano: String(start),
+        endTimeUnixNano: String(end),
+        attributes: attrs
+      }]
+    }]
+  }]
+  const payload = JSON.stringify({ resourceSpans })
+  const urlObj = endpoint
+  const protocol = urlObj.protocol === 'https:' ? https : http
+  const options = {
+    hostname: urlObj.hostname,
+    port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+    path: urlObj.pathname,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload)
+    }
+  }
+  const req = protocol.request(options, () => {})
+  req.on('error', () => {})
+  req.setTimeout(2000, () => { req.destroy() })
+  req.write(payload)
+  req.end()
+}
+
+module.exports = { sendSpanToOtel, getEndpoint, setEndpointOverride }