azify-logger 1.0.2

package/middleware-restify.js

@@ -0,0 +1,280 @@
+const axios = require('axios')
+const { als, runWithRequestContext, startRequestContext, getRequestContext } = require('./store')
+
+function createRestifyLoggingMiddleware(options = {}) {
+  const config = {
+    serviceName: options.serviceName || process.env.APP_NAME || 'azipay',
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3000',
+    environment: options.environment || process.env.NODE_ENV || 'development'
+  }
+
+  async function sendLog(level, message, meta = {}) {
+    const logData = {
+      level,
+      message,
+      meta: {
+        ...meta,
+        service: {
+          name: config.serviceName,
+          version: '1.0.0'
+        },
+        environment: config.environment,
+        timestamp: new Date().toISOString(),
+        hostname: require('os').hostname()
+      }
+    }
+
+    try {
+      await axios.post(`${config.loggerUrl}/log`, logData, {
+        timeout: 5000
+      })
+    } catch (error) {}
+  }
+
+  return function azifyLoggingMiddleware(req, res, next) {
+    const startTime = Date.now()
+    const requestId = req.requestId || require('uuid').v4()
+    const middlewareId = require('uuid').v4().substring(0, 8)
+    
+    const reqCtx = startRequestContext({ requestId })
+    req.__azifyTraceId = reqCtx.traceId
+    req.__azifySpanId = reqCtx.spanId
+    req.__azifyParentSpanId = reqCtx.parentSpanId
+    
+    const requestTraceId = req.__azifyTraceId
+    const requestSpanId = req.__azifySpanId
+    const requestParentSpanId = req.__azifyParentSpanId
+    
+    let baseUrl = req.url
+    if (baseUrl.includes('?')) {
+      baseUrl = baseUrl.substring(0, baseUrl.indexOf('?'))
+    }
+    baseUrl = baseUrl.replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '/{id}')
+    baseUrl = baseUrl.replace(/\/[0-9]+/g, '/{id}')
+
+    req._azifyRequestData = {
+      requestId,
+      method: req.method,
+      url: req.url,
+      baseUrl: baseUrl,
+      path: req.url,
+      headers: req.headers,
+      query: req.query,
+      userAgent: req.headers['user-agent'],
+      ip: req.connection.remoteAddress || req.socket.remoteAddress,
+      traceId: requestTraceId,
+      spanId: requestSpanId,
+      parentSpanId: requestParentSpanId
+    }
+
+    if (req.method === 'GET') {
+      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
+    } else {
+      if (req.body !== undefined) {
+        req._azifyRequestData.requestBody = req.body
+      }
+      sendLog('info', `[REQUEST] ${req.method} ${req.url}`, req._azifyRequestData)
+    }
+
+    res.on('finish', () => {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    res.on('close', () => {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    let sentBody
+    let responseLogged = false
+    
+    const originalSend = res.send && res.send.bind(res)
+    if (originalSend) {
+      res.send = function patchedSend() {
+        try {
+          if (arguments.length === 1) {
+            sentBody = arguments[0]
+          } else if (arguments.length >= 2) {
+            sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
+          }
+        } catch (_) {}
+        
+        if (!responseLogged) {
+          logResponse()
+          responseLogged = true
+        }
+        
+        return originalSend.apply(this, arguments)
+      }
+    }
+
+
+    const originalStatus = res.status
+    res.status = function(code) {
+      res._actualStatusCode = code
+      return originalStatus.call(this, code)
+    }
+    
+    const originalWriteHead = res.writeHead
+    res.writeHead = function(statusCode, statusMessage, headers) {
+      res._actualStatusCode = statusCode
+      if (typeof statusMessage === 'object') {
+        headers = statusMessage
+        statusMessage = undefined
+      }
+      return originalWriteHead.call(this, statusCode, statusMessage, headers)
+    }
+    
+    const originalJsonMethod = res.json
+    res.json = function(code, body) {
+      try {
+        if (arguments.length === 1) {
+          sentBody = arguments[0]
+        } else if (arguments.length >= 2) {
+          sentBody = typeof arguments[0] === 'number' ? arguments[1] : (arguments[1] || arguments[0])
+        }
+      } catch (_) {}
+      
+      if (typeof code === 'number') {
+        res._actualStatusCode = code
+      } else {
+        const errorObj = arguments.length === 1 ? arguments[0] : (typeof arguments[0] === 'number' ? arguments[1] : arguments[0])
+        
+        if (errorObj && errorObj.constructor && errorObj.constructor.name === 'ErrCtor') {
+          const errorName = errorObj.toString()
+          if (errorName.includes('InternalServerError') || errorName.includes('InternalError')) {
+            res._actualStatusCode = 500
+            res._actualStatusCode = 500
+          } else if (errorName.includes('BadRequest') || errorName.includes('BadDigest')) {
+            res._actualStatusCode = 400
+          } else if (errorName.includes('NotFound')) {
+            res._actualStatusCode = 404
+          } else if (errorName.includes('Unauthorized')) {
+            res._actualStatusCode = 401
+          } else if (errorName.includes('Forbidden')) {
+            res._actualStatusCode = 403
+          } else {
+            res._actualStatusCode = 500
+          }
+        } else {
+          res._actualStatusCode = res.statusCode || 200
+        }
+      }
+      
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+      
+      return originalJsonMethod.apply(this, arguments)
+    }
+    
+    res.on('finish', function() {
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+    })
+
+    const originalEnd = res.end
+    res.end = function(chunk, encoding) {
+      const duration = Date.now() - startTime
+      
+      let responseBody = sentBody
+      try {
+        if (responseBody == null && chunk) {
+          if (Buffer.isBuffer(chunk)) {
+            responseBody = chunk.toString('utf8')
+          } else if (typeof chunk === 'string') {
+            responseBody = chunk
+          } else {
+            responseBody = JSON.stringify(chunk)
+          }
+        }
+      } catch (_) {}
+
+      if (!responseLogged) {
+        logResponse()
+        responseLogged = true
+      }
+
+      originalEnd.call(this, chunk, encoding)
+    }
+    
+    function logResponse() {
+      const duration = Date.now() - startTime
+      
+      let responseBody = sentBody
+      
+      let serializedResponseBody
+      try {
+        if (typeof responseBody === 'string') {
+          serializedResponseBody = responseBody
+        } else if (Array.isArray(responseBody)) {
+          serializedResponseBody = JSON.stringify(responseBody)
+        } else if (responseBody && typeof responseBody === 'object') {
+          if (responseBody.toJSON && typeof responseBody.toJSON === 'function') {
+            serializedResponseBody = JSON.stringify(responseBody.toJSON())
+          } else if (responseBody.toString && typeof responseBody.toString === 'function' && responseBody.toString() !== '[object Object]') {
+            serializedResponseBody = responseBody.toString()
+          } else {
+            serializedResponseBody = JSON.stringify(responseBody, (key, value) => {
+              if (typeof value === 'function') {
+                return '[Function]'
+              }
+              if (value instanceof Error) {
+                return { name: value.name, message: value.message, stack: value.stack }
+              }
+              return value
+            }, null, 0)
+          }
+        } else {
+          serializedResponseBody = responseBody != null ? String(responseBody) : ''
+        }
+      } catch (error) {
+        try {
+          serializedResponseBody = JSON.stringify(responseBody, null, 2)
+        } catch (secondError) {
+          serializedResponseBody = '[Complex object - serialization failed]'
+        }
+      }
+      
+      const statusCode = res._actualStatusCode || res._statusCode || res.statusCode || 200
+      
+      const responseMessage = serializedResponseBody && serializedResponseBody.length > 0
+        ? `[RESPONSE] ${serializedResponseBody}`
+        : `[RESPONSE] ${req.method} ${req.url} ${statusCode} ${duration}ms`
+      
+      const responseData = {
+        ...req._azifyRequestData,
+        requestBody: req.body,
+        statusCode: statusCode,
+        responseTime: duration,
+        responseHeaders: res.getHeaders ? res.getHeaders() : {},
+        responseBody: serializedResponseBody
+      }
+      
+      try { res._azifyResponseLogged = true } catch (_) {}
+      sendLog('info', responseMessage, responseData)
+    }
+
+    req._azifyContext = reqCtx
+    
+    try {
+      runWithRequestContext(reqCtx, () => {
+        next()
+      })
+    } catch (error) {
+      console.error('Error in azify middleware:', error)
+      next()
+    }
+  }
+}
+
+module.exports = createRestifyLoggingMiddleware
+

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "azify-logger",
+  "version": "1.0.2",
+  "description": "Azify Logger Client - Centralized logging for OpenSearch",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "keywords": [
+    "logging",
+    "opensearch",
+    "centralized",
+    "azify"
+  ],
+  "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",
+    "require-in-the-middle": "^7.4.0",
+    "uuid": "^9.0.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "index.js",
+    "store.js",
+    "register-otel.js",
+    "register-restify.js",
+    "middleware-restify.js",
+    "middleware-express.js",
+    "server.js",
+    "streams/",
+    "package.json",
+    "README.md"
+  ]
+}

package/register-otel.js

@@ -0,0 +1,39 @@
+try {
+  const { NodeSDK } = require('@opentelemetry/sdk-node')
+  const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
+
+  const serviceName = process.env.OTEL_SERVICE_NAME || process.env.APP_NAME || 'app'
+  const serviceVersion = process.env.OTEL_SERVICE_VERSION || '1.0.0'
+
+  process.env.OTEL_SERVICE_NAME = serviceName
+  process.env.OTEL_SERVICE_VERSION = serviceVersion
+
+  console.log(`🔧 Initializing OpenTelemetry for service: ${serviceName}`)
+
+  const sdk = new NodeSDK({
+    serviceName: serviceName,
+    serviceVersion: serviceVersion,
+    instrumentations: [getNodeAutoInstrumentations({
+      '@opentelemetry/instrumentation-http': { 
+        enabled: true,
+        requireParentforOutgoingSpans: false,
+        requireParentforIncomingSpans: false
+      },
+      '@opentelemetry/instrumentation-express': { enabled: true },
+      '@opentelemetry/instrumentation-restify': { enabled: true }
+    })]
+  })
+
+  sdk.start()
+  console.log(`✅ OpenTelemetry initialized for service: ${serviceName}`)
+  
+  process.once('SIGTERM', () => {
+    sdk.shutdown()
+      .then(() => console.log('OpenTelemetry shut down successfully'))
+      .catch((error) => console.error('Error shutting down OpenTelemetry:', error))
+      .finally(() => process.exit(0))
+  })
+} catch (error) {
+  console.warn('⚠️  OpenTelemetry não pôde ser inicializado:', error.message)
+  console.error('Error details:', error)
+}

package/register-restify.js

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