azify-logger 1.0.16 → 1.0.18

package/README.md

@@ -86,9 +86,7 @@ const app = express()
 |----------|-----------------------------------|-----------|
 | `APP_NAME` | -                                 | Nome da aplicação |
 | `AZIFY_LOGGER_URL` | `http://localhost:3001/log`       | URL do logger |
-| `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces` | OTLP endpoint |
-| `NODE_ENV` | `development`                     | Ambiente |
-| `AZIFY_LOGGER_AUTOREG_DISABLE` | `""`                              | Se `"1"`, desativa auto-registro do OTEL |
+| `NODE_ENV` | `development` | Ambiente |
 
 ### 🌐 URLs por Ambiente
 
@@ -102,14 +100,14 @@ NODE_ENV=development
 **Staging:**
 ```env
 APP_NAME=minha-app
-AZIFY_LOGGER_URL=http://logs.azify.dev
+AZIFY_LOGGER_URL=https://logsdashboard.azify.dev/send
 NODE_ENV=staging
 ```
 
 **Production:**
 ```env
 APP_NAME=minha-app
-AZIFY_LOGGER_URL=http://logs.azify.com
+AZIFY_LOGGER_URL=https://logsdashboard.azify.prd/send (a conigurar)
 NODE_ENV=production
 ```
 
@@ -167,6 +165,8 @@ if (createAzifyBunyanStream) {
     stream: createAzifyBunyanStream({
       loggerUrl: process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log',
       serviceName: process.env.APP_NAME || 'app'
+      loggerUrl: process.env.AZIFY_LOGGER_URL,
+      serviceName: process.env.APP_NAME
     })
   })
 }
@@ -220,7 +220,6 @@ logger.error('Erro', new Error('Falha'), { context: 'payment' })
 
 Se você precisa subir a infraestrutura do azify-logger:
 
-### 1. Iniciar serviços
 
 ```bash
 ./start-docker.sh

package/index.js

@@ -1,6 +1,19 @@
 const axios = require('axios')
-const { context, propagation, trace } = require('@opentelemetry/api')
-const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+
+let context, propagation, trace, W3CTraceContextPropagator
+try {
+  const otelApi = require('@opentelemetry/api')
+  const otelCore = require('@opentelemetry/core')
+  context = otelApi.context
+  propagation = otelApi.propagation
+  trace = otelApi.trace
+  W3CTraceContextPropagator = otelCore.W3CTraceContextPropagator
+} catch (_) {
+  context = { active: () => ({}) }
+  propagation = { setGlobalPropagator: () => {} }
+  trace = { getSpan: () => null }
+  W3CTraceContextPropagator = class {}
+}
 
 if (process.env.AZIFY_LOGGER_AUTOREG_DISABLE !== '1') {
   try { require('./register-otel') } catch (_) {}
@@ -41,7 +54,7 @@ class AzifyLogger {
    */
   async log(level, message, meta = {}) {
     const span = trace.getSpan(context.active())
-    const spanContext = span?.spanContext()
+    const spanContext = span && span.spanContext()
     
     const logData = {
       level,
@@ -50,7 +63,7 @@ class AzifyLogger {
         ...meta,
         service: {
           name: this.options.serviceName,
-          version: meta.service?.version || '1.0.0'
+          version: (meta.service && meta.service.version) || '1.0.0'
         },
         environment: this.options.environment,
         timestamp: new Date().toISOString(),

package/init.js

@@ -0,0 +1,74 @@
+if (process.env.AZIFY_LOGGER_DISABLE === '1') {
+  module.exports = {}
+} else {
+const Module = require('module')
+const originalRequire = Module.prototype.require
+
+Module.prototype.require = function(id) {
+  const result = originalRequire.call(this, id)
+  
+  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()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.log.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.log.call(this, message, context)
+        }
+        
+        instance.error = function(message, trace, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+          }
+          return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+        }
+        
+        instance.warn = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.warn.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.warn.call(this, message, context)
+        }
+        
+        instance.debug = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.debug.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.debug.call(this, message, context)
+        }
+        
+        instance.verbose = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+          }
+          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

@@ -186,8 +186,8 @@ function createExpressLoggingMiddleware(options = {}) {
       path: req.url,
       headers: sanitizeHeaders(req.headers || {}),
       query: req.query || {},
-      userAgent: req.headers?.['user-agent'] || 'unknown',
-      ip: req.connection?.remoteAddress || req.socket?.remoteAddress || req.ip || 'unknown',
+      userAgent: (req.headers && req.headers['user-agent']) || 'unknown',
+      ip: (req.connection && req.connection.remoteAddress) || (req.socket && req.socket.remoteAddress) || req.ip || 'unknown',
       traceId: requestTraceId,
       spanId: requestSpanId,
       parentSpanId: requestParentSpanId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,13 +27,6 @@
   "author": "Azify",
   "license": "MIT",
   "dependencies": {
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.40.0",
-    "@opentelemetry/core": "^1.28.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.45.0",
-    "@opentelemetry/resources": "^1.28.0",
-    "@opentelemetry/sdk-node": "^0.45.0",
-    "@opentelemetry/semantic-conventions": "^1.28.0",
     "axios": "^1.6.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",
@@ -43,12 +36,23 @@
     "require-in-the-middle": "^7.4.0",
     "uuid": "^9.0.1"
   },
+  "optionalDependencies": {
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.40.0",
+    "@opentelemetry/core": "^1.28.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.45.0",
+    "@opentelemetry/resources": "^1.28.0",
+    "@opentelemetry/sdk-node": "^0.45.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0"
+  },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=12.0.0"
   },
   "files": [
     "index.js",
     "index.d.ts",
+    "init.js",
+    "register.js",
     "store.js",
     "register-otel.js",
     "register-restify.js",

package/register.js

@@ -0,0 +1,456 @@
+if (process.env.AZIFY_LOGGER_DISABLE === '1') {
+  module.exports = {}
+} else {
+try {
+  const bunyan = require('bunyan')
+  const createBunyanStream = require('./streams/bunyan')
+  const { getRequestContext } = require('./store')
+
+  const originalCreate = bunyan.createLogger
+  bunyan.createLogger = function patchedCreateLogger(options) {
+    const logger = originalCreate.call(bunyan, options)
+    try {
+      const level = process.env.AZIFY_LOG_LEVEL || (options && options.level) || 'info'
+      const loggerUrl = process.env.AZIFY_LOGGER_URL || 'http://localhost:3001'
+      const serviceName = process.env.APP_NAME || (options && options.name) || 'app'
+      const environment = process.env.NODE_ENV || 'development'
+
+      logger.addStream({
+        level,
+        type: 'raw',
+        stream: createBunyanStream({ loggerUrl, serviceName, environment })
+      })
+    } catch (_) {}
+    return logger
+  }
+
+  try {
+    const Module = require('module')
+    const originalRequire = Module.prototype.require
+    const { getRequestContext } = require('./store')
+    
+    Module.prototype.require = function(id) {
+      const result = originalRequire.call(this, id)
+      if (id === 'pino' || id.endsWith('/pino')) {
+        if (result && typeof result === 'function') {
+          const originalPino = result
+          
+          const patchedPino = function(options, stream) {
+            const logger = originalPino(options, stream)
+            
+            const originalInfo = logger.info
+            const originalError = logger.error
+            const originalWarn = logger.warn
+            const originalDebug = logger.debug
+            const originalFatal = logger.fatal
+            const originalTrace = logger.trace
+            
+            logger.info = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalInfo.call(this, obj, msg, ...args)
+            }
+            
+            logger.error = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalError.call(this, obj, msg, ...args)
+            }
+            
+            logger.warn = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalWarn.call(this, obj, msg, ...args)
+            }
+            
+            logger.debug = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalDebug.call(this, obj, msg, ...args)
+            }
+            
+            logger.fatal = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalFatal.call(this, obj, msg, ...args)
+            }
+            
+            logger.trace = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+              return originalTrace.call(this, obj, msg, ...args)
+            }
+            
+            return logger
+          }
+          
+          Object.setPrototypeOf(patchedPino, originalPino)
+          Object.assign(patchedPino, originalPino)
+          
+          return patchedPino
+        }
+      }
+      
+      return result
+    }
+    
+  } catch (_) {}
+
+  try {
+    const { Logger } = require('@nestjs/common')
+    if (Logger) {
+      const originalLog = Logger.prototype.log
+      const originalError = Logger.prototype.error
+      const originalWarn = Logger.prototype.warn
+      const originalDebug = Logger.prototype.debug
+      const originalVerbose = Logger.prototype.verbose
+      
+      Logger.prototype.log = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalLog.call(this, message, context)
+        }
+        return originalLog.call(this, message, context)
+      }
+      
+      Logger.prototype.error = function(message, trace, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalError.call(this, message, trace, context)
+        }
+        return originalError.call(this, message, trace, context)
+      }
+      
+      Logger.prototype.warn = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalWarn.call(this, message, context)
+        }
+        return originalWarn.call(this, message, context)
+      }
+      
+      Logger.prototype.debug = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalDebug.call(this, message, context)
+        }
+        return originalDebug.call(this, message, context)
+      }
+      
+      Logger.prototype.verbose = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalVerbose.call(this, message, context)
+        }
+        return originalVerbose.call(this, message, context)
+      }
+      
+    }
+  } catch (_) {}
+
+  try {
+    const originalConsoleLog = console.log
+    const originalConsoleError = console.error
+    const originalConsoleWarn = console.warn
+    
+    console.log = function(...args) {
+      return originalConsoleLog.apply(this, args)
+    }
+    
+    console.error = function(...args) {
+      return originalConsoleError.apply(this, args)
+    }
+    
+    console.warn = function(...args) {
+      return originalConsoleWarn.apply(this, args)
+    }
+  } catch (_) {}
+
+  try {
+    const Module = require('module')
+    const originalRequire = Module.prototype.require
+    
+    Module.prototype.require = function(id) {
+      const result = originalRequire.call(this, id)
+      
+      if (id === 'nestjs-pino' || id.endsWith('/nestjs-pino') || id.includes('nestjs-pino')) {
+        if (result && result.Logger) {
+          const originalLoggerConstructor = result.Logger
+          
+          function PatchedNestJSPinoLogger(context) {
+            const instance = new originalLoggerConstructor(context)
+            
+            instance.error = function(message, trace, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+              }
+              return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+            }
+            
+            instance.log = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.log.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.log.call(this, message, context)
+            }
+            
+            instance.warn = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.warn.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.warn.call(this, message, context)
+            }
+            
+            instance.debug = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.debug.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.debug.call(this, message, context)
+            }
+            
+            instance.verbose = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+            }
+            
+            return instance
+          }
+          
+          Object.setPrototypeOf(PatchedNestJSPinoLogger, originalLoggerConstructor)
+          Object.assign(PatchedNestJSPinoLogger, originalLoggerConstructor)
+          
+          result.Logger = PatchedNestJSPinoLogger
+        }
+        
+        if (result && result.LoggerModule && result.LoggerModule.forRoot) {
+          const originalForRoot = result.LoggerModule.forRoot
+          
+          result.LoggerModule.forRoot = function(options) {
+            const createPinoStream = require('./streams/pino')
+            const stream = createPinoStream()
+            
+            const mergedOptions = {
+              ...options,
+              pinoHttp: {
+                ...(options && options.pinoHttp),
+                stream,
+              },
+            }
+            
+            return originalForRoot.call(this, mergedOptions)
+          }
+          
+          Object.setPrototypeOf(result.LoggerModule.forRoot, originalForRoot)
+          Object.assign(result.LoggerModule.forRoot, originalForRoot)
+        }
+      }
+      
+      return result
+    }
+    
+  } catch (_) {}
+
+  try {
+    const undici = require('undici')
+    if (undici && undici.request) {
+      const originalRequest = undici.request
+      undici.request = function(url, options, callback) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        
+        if (ctx && ctx.traceId) {
+          const headers = (options && options.headers) || {}
+          options = {
+            ...options,
+            headers: {
+              ...headers,
+              'X-Trace-ID': ctx.traceId,
+              'X-Span-ID': ctx.spanId || '',
+              'X-Parent-Span-ID': ctx.parentSpanId || '',
+              'X-Request-ID': ctx.requestId || require('uuid').v4()
+            }
+          }
+        }
+        
+        return originalRequest.call(this, url, options, callback)
+      }
+    }
+  } catch (_) {}
+
+  try {
+    const axios = require('axios')
+    if (axios && axios.create) {
+      const originalCreate = axios.create
+      axios.create = function(config) {
+        const instance = originalCreate.call(this, config)
+        
+        const originalRequest = instance.interceptors.request.use
+        instance.interceptors.request.use = function(fulfilled, rejected) {
+          return originalRequest.call(this, (config) => {
+            const { getRequestContext } = require('./store')
+            const ctx = getRequestContext()
+            
+            if (ctx && ctx.traceId) {
+              config.headers = {
+                ...config.headers,
+                'X-Trace-ID': ctx.traceId,
+                'X-Span-ID': ctx.spanId || '',
+                'X-Parent-Span-ID': ctx.parentSpanId || '',
+                'X-Request-ID': ctx.requestId || require('uuid').v4()
+              }
+            }
+            
+            return fulfilled ? fulfilled(config) : config
+          }, rejected)
+        }
+        
+        return instance
+      }
+    }
+  } catch (_) {}
+
+  try {
+    const Bull = require('bull')
+    const { runWithRequestContext } = require('./store')
+
+    const originalAdd = Bull.prototype.add
+    Bull.prototype.add = function(name, data, opts) {
+      const ctx = getRequestContext()
+
+      if (ctx && ctx.traceId) {
+        data = {
+          ...data,
+          traceId: ctx.traceId,
+          spanId: ctx.spanId,
+          parentSpanId: ctx.parentSpanId,
+          requestId: ctx.requestId,
+        }
+      }
+
+      return originalAdd.call(this, name, data, opts)
+    }
+
+    const originalProcess = Bull.prototype.process
+    Bull.prototype.process = function(name, concurrency, handler) {
+      let actualName, actualConcurrency, actualHandler
+
+      if (typeof name === 'function') {
+        actualHandler = name
+        actualName = '__default__'
+        actualConcurrency = 1
+      } else if (typeof concurrency === 'function') {
+        actualHandler = concurrency
+        actualName = name
+        actualConcurrency = 1
+      } else {
+        actualName = name
+        actualConcurrency = concurrency
+        actualHandler = handler
+      }
+
+      const wrappedHandler = function(job, done) {
+        const { traceId, spanId, parentSpanId, requestId, ...jobData } = job.data
+
+        if (traceId && spanId) {
+          const ctx = {
+            traceId,
+            spanId,
+            parentSpanId,
+            requestId,
+          }
+          
+          return runWithRequestContext(ctx, () => {
+            return actualHandler.call(this, job, done)
+          })
+        } else {
+          const { startRequestContext } = require('./store')
+          const newCtx = startRequestContext({ requestId: require('uuid').v4() })
+          
+          return runWithRequestContext(newCtx, () => {
+            return actualHandler.call(this, job, done)
+          })
+        }
+      }
+
+      if (typeof name === 'function') {
+        return originalProcess.call(this, wrappedHandler)
+      } else if (typeof concurrency === 'function') {
+        return originalProcess.call(this, actualName, wrappedHandler)
+      } else {
+        return originalProcess.call(this, actualName, actualConcurrency, wrappedHandler)
+      }
+    }
+  } catch (_) {}
+} catch (_) {}
+}

package/server.js

@@ -4,14 +4,27 @@ const axios = require('axios')
 const express = require('express')
 const cors = require('cors')
 const os = require('os')
-const { trace, context, propagation } = require('@opentelemetry/api')
-const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+let trace, context, propagation, W3CTraceContextPropagator
+try {
+  const otelApi = require('@opentelemetry/api')
+  const otelCore = require('@opentelemetry/core')
+  trace = otelApi.trace
+  context = otelApi.context
+  propagation = otelApi.propagation
+  W3CTraceContextPropagator = otelCore.W3CTraceContextPropagator
+} catch (_) {
+  trace = { getSpan: () => null }
+  context = { active: () => ({}) }
+  propagation = { extract: () => ({}), inject: () => {} }
+  W3CTraceContextPropagator = class {}
+}
 
 const app = express()
 
 app.set('trust proxy', 1)
 
-app.use(express.json())
+app.use(express.json({ limit: '10mb' }))
+app.use(express.urlencoded({ extended: true, limit: '10mb' }))
 app.use(cors())
 
 const authEnabled = process.env.AZURE_AD_AUTH_ENABLED === 'true'
@@ -33,79 +46,121 @@ const propagator = new W3CTraceContextPropagator()
 const traceContextMap = new Map()
 
 /**
- * Ensures the OpenSearch index exists and is properly configured
+ * Creates an index template for dynamic log indices
+ * This allows OpenSearch to auto-create indices like logs-azipay, logs-assemble, etc.
  * @returns {Promise<void>}
  * @private
  */
-async function ensureIndex() {
-  const indexName = 'logs-azify'
+async function ensureIndexTemplate() {
+  const templateName = 'logs-template'
   const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
+  
   try {
-    await axios.head(`${osUrl}/${indexName}`)
-    console.log(`✅ Índice ${indexName} já existe no OpenSearch`)
-    try {
-      await axios.post(`${osUrl}/${indexName}/_mapping`, {
-        properties: {
-          traceId: { type: 'keyword' },
-          spanId: { type: 'keyword' },
-          parentSpanId: { type: 'keyword' },
-          appName: { type: 'keyword' }
-        }
-      })
-    } catch (mapErr) {}
-  } catch (error) {
-    if (error.response?.status === 404) {
-      try {
-        await axios.put(`${osUrl}/${indexName}`, {
-          settings: {
-            number_of_shards: 1,
-            number_of_replicas: 0
-          },
-          mappings: {
-            properties: {
-              timestamp: { type: 'date' },
-              level: { type: 'keyword' },
-              message: { type: 'text' },
-              service: {
-                properties: {
-                  name: { type: 'keyword' },
-                  version: { type: 'keyword' }
-                }
-              },
-              appName: { type: 'keyword' },
-              traceId: { type: 'keyword' },
-              spanId: { type: 'keyword' },
-              parentSpanId: { type: 'keyword' },
-              userId: { type: 'keyword' },
-              requestId: { type: 'keyword' },
-              method: { type: 'keyword' },
-              url: { type: 'keyword' },
-              statusCode: { type: 'integer' },
-              responseTime: { type: 'float' },
-              ip: { type: 'ip' },
-              userAgent: { type: 'text' },
-              environment: { type: 'keyword' },
-              hostname: { type: 'keyword' },
-              responseBody: { type: 'text' },
-              error: {
-                properties: {
-                  message: { type: 'text' },
-                  stack: { type: 'text' },
-                  name: { type: 'keyword' }
-                }
+    await axios.put(`${osUrl}/_index_template/${templateName}`, {
+      index_patterns: ['logs-*'],
+      template: {
+        settings: {
+          number_of_shards: 1,
+          number_of_replicas: 0,
+          'index.refresh_interval': '5s'
+        },
+        mappings: {
+          properties: {
+            timestamp: { type: 'date' },
+            level: { type: 'keyword' },
+            message: { type: 'text' },
+            service: {
+              properties: {
+                name: { type: 'keyword' },
+                version: { type: 'keyword' }
+              }
+            },
+            appName: { type: 'keyword' },
+            traceId: { type: 'keyword' },
+            spanId: { type: 'keyword' },
+            parentSpanId: { type: 'keyword' },
+            userId: { type: 'keyword' },
+            requestId: { type: 'keyword' },
+            method: { type: 'keyword' },
+            url: { type: 'keyword' },
+            statusCode: { type: 'integer' },
+            responseTime: { type: 'float' },
+            ip: { type: 'ip' },
+            userAgent: { type: 'text' },
+            environment: { type: 'keyword' },
+            hostname: { type: 'keyword' },
+            responseBody: { type: 'text' },
+            error: {
+              properties: {
+                message: { type: 'text' },
+                stack: { type: 'text' },
+                name: { type: 'keyword' }
               }
             }
           }
-        })
-        console.log(`✅ Índice ${indexName} criado no OpenSearch`)
-      } catch (createError) {
-        console.error('❌ Erro ao criar índice:', createError.message)
-      }
+        }
+      },
+      priority: 500
+    })
+    console.log(`✅ Index template ${templateName} criado/atualizado no OpenSearch`)
+    console.log(`   Índices serão criados automaticamente no formato: logs-{service-name}`)
+  } catch (error) {
+    console.error('❌ Erro ao criar index template:', error.message)
+    if (error.response) {
+      console.error('   Detalhes:', error.response.data)
     }
   }
 }
 
-ensureIndex()
+ensureIndexTemplate()
+
+/**
+ * Escapes HTML special characters to prevent XSS attacks
+ * This prevents script injection when data is rendered in OpenSearch Dashboards
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeHtml(str) {
+  if (typeof str !== 'string') return str
+  const map = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+    '/': '&#x2F;'
+  }
+  return str.replace(/[&<>"'/]/g, (m) => map[m])
+}
+
+/**
+ * Sanitizes a value recursively to prevent XSS attacks
+ * Escapes HTML special characters in strings that could be rendered in Dashboards
+ * @param {any} value - Value to sanitize
+ * @returns {any} Sanitized value
+ */
+function sanitizeValue(value) {
+  if (typeof value === 'string') {
+    // Escape HTML special characters to prevent XSS when rendered in Dashboards
+    return escapeHtml(value)
+  }
+  
+  if (Array.isArray(value)) {
+    return value.map(item => sanitizeValue(item))
+  }
+  
+  if (value !== null && typeof value === 'object') {
+    const sanitized = {}
+    for (const key in value) {
+      if (value.hasOwnProperty(key)) {
+        sanitized[key] = sanitizeValue(value[key])
+      }
+    }
+    return sanitized
+  }
+  
+  return value
+}
 
 function generateTraceId() {
   return Math.random().toString(36).substring(2, 15) +
@@ -162,7 +217,18 @@ app.get('/', ensureAuthenticated, (req, res) => {
 })
 
 app.post('/log', async (req, res) => {
-  const { level, message, meta } = req.body
+  let { level, message, meta } = req.body
+  
+  if (typeof message === 'string') {
+    message = sanitizeValue(message)
+  }
+  if (meta) {
+    meta = sanitizeValue(meta)
+  }
+  if (typeof level === 'string') {
+    level = sanitizeValue(level)
+  }
+  
   if (!level || !message) {
     return res.status(400).json({ success: false, message: 'Level and message are required.' })
   }
@@ -183,11 +249,11 @@ app.post('/log', async (req, res) => {
     return res.json({ success: true, message: 'Log filtrado (Prisma verboso)' })
   }
 
-  const requestId = meta?.requestId
+  const requestId = meta && meta.requestId
 
   let traceContext = null
   
-  if (meta?.traceId && meta?.spanId) {
+  if (meta && meta.traceId && meta.spanId) {
     traceContext = {
       traceId: meta.traceId,
       spanId: meta.spanId,
@@ -206,7 +272,8 @@ app.post('/log', async (req, res) => {
         }
       })
 
-      const spanContext = trace.getSpan(extractedCtx)?.spanContext?.() || null
+      const span = trace.getSpan(extractedCtx)
+      const spanContext = (span && span.spanContext && span.spanContext()) || null
       if (spanContext && spanContext.traceId && spanContext.spanId) {
         traceContext = {
           traceId: spanContext.traceId,
@@ -230,16 +297,16 @@ app.post('/log', async (req, res) => {
   }
   
   const logEntry = {
-    timestamp: meta?.timestamp || new Date().toISOString(),
+    timestamp: (meta && meta.timestamp) || new Date().toISOString(),
     level,
     message,
     service: {
-      name: meta?.service?.name || 'unknown-service',
-      version: meta?.service?.version || '1.0.0'
+      name: (meta && meta.service && meta.service.name) || 'unknown-service',
+      version: (meta && meta.service && meta.service.version) || '1.0.0'
     },
-    appName: meta?.appName || meta?.service?.name || undefined,
-    environment: meta?.environment || process.env.NODE_ENV || 'development',
-    hostname: meta?.hostname || os.hostname(),
+    appName: (meta && meta.appName) || (meta && meta.service && meta.service.name) || undefined,
+    environment: (meta && meta.environment) || process.env.NODE_ENV || 'development',
+    hostname: (meta && meta.hostname) || os.hostname(),
     traceId: traceContext.traceId,
     spanId: traceContext.spanId,
     parentSpanId: traceContext.parentSpanId
@@ -255,12 +322,15 @@ app.post('/log', async (req, res) => {
 
   try {
     const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
-    await axios.post(`${osUrl}/logs-azify/_doc`, logEntry, {
+    const serviceName = (logEntry.service.name || 'unknown').toLowerCase().replace(/[^a-z0-9-]/g, '-')
+    const indexName = `logs-${serviceName}`
+    
+    await axios.post(`${osUrl}/${indexName}/_doc`, logEntry, {
       headers: { 'Content-Type': 'application/json' }
     })
     
-    console.log(`✅ [${level.toUpperCase()}] ${message} | traceId: ${traceContext.traceId.substring(0, 8)}... | service: ${logEntry.service.name}`)
-    res.json({ success: true, message: 'Log enviado com sucesso' })
+    console.log(`✅ [${level.toUpperCase()}] ${message} | traceId: ${traceContext.traceId.substring(0, 8)}... | service: ${logEntry.service.name} | index: ${indexName}`)
+    res.json({ success: true, message: 'Log enviado com sucesso', index: indexName })
   } catch (error) {
     console.error('❌ Erro ao enviar log para OpenSearch:', error.message)
     if (error.response) {

package/streams/bunyan.js

@@ -43,7 +43,7 @@ function createBunyanStream(options = {}) {
 
       const meta = {
         ...cleanRecord,
-        service: { name: serviceName, version: record.service?.version || '1.0.0' },
+        service: { name: serviceName, version: (record.service && record.service.version) || '1.0.0' },
         environment,
         timestamp: new Date().toISOString(),
         hostname: require('os').hostname(),
@@ -54,7 +54,7 @@ function createBunyanStream(options = {}) {
 
       const payload = { level, message: record.msg || record.message || 'log', meta }
 
-      axios.post(`${loggerUrl}`, payload, { headers, timeout: 3001 }).catch(() => {})
+      axios.post(`${loggerUrl}`, payload, { headers, timeout: 10000 }).catch(() => {})
     }
   }
 }

package/streams/pino.js

@@ -1,5 +1,17 @@
-const { context, propagation, trace } = require('@opentelemetry/api')
-const { W3CTraceContextPropagator } = require('@opentelemetry/core')
+let context, propagation, trace, W3CTraceContextPropagator
+try {
+  const otelApi = require('@opentelemetry/api')
+  const otelCore = require('@opentelemetry/core')
+  context = otelApi.context
+  propagation = otelApi.propagation
+  trace = otelApi.trace
+  W3CTraceContextPropagator = otelCore.W3CTraceContextPropagator
+} catch (_) {
+  context = { active: () => ({}) }
+  propagation = { setGlobalPropagator: () => {}, inject: () => {} }
+  trace = { getSpan: () => null }
+  W3CTraceContextPropagator = class {}
+}
 const axios = require('axios')
 
 function createPinoStream(options = {}) {
@@ -23,7 +35,7 @@ function createPinoStream(options = {}) {
           spanId = ctx.spanId
         } else {
           const span = trace.getSpan(context.active())
-          const spanContext = span?.spanContext()
+          const spanContext = span && span.spanContext()
           if (spanContext) {
             traceId = spanContext.traceId
             spanId = spanContext.spanId
@@ -44,7 +56,7 @@ function createPinoStream(options = {}) {
 
       const meta = {
         ...record,
-        service: { name: serviceName, version: record.service?.version || '1.0.0' },
+        service: { name: serviceName, version: (record.service && record.service.version) || '1.0.0' },
         environment,
         timestamp: new Date().toISOString(),
         hostname: require('os').hostname(),
@@ -54,7 +66,7 @@ function createPinoStream(options = {}) {
       }
 
       const payload = { level, message: record.msg || record.message || 'log', meta }
-      axios.post(`${loggerUrl}`, payload, { headers, timeout: 3001 }).catch(() => {})
+      axios.post(`${loggerUrl}`, payload, { headers, timeout: 10000 }).catch(() => {})
     }
   }
 }