azify-logger 1.0.26 → 1.0.28

package/register.js

@@ -4,16 +4,144 @@ if (process.env.AZIFY_LOGGER_DISABLE === '1') {
 try {
   const bunyan = require('bunyan')
   const createBunyanStream = require('./streams/bunyan')
+  const { createHttpLoggerTransport } = require('./streams/httpQueue')
   const { getRequestContext } = require('./store')
+  const { randomUUID, randomBytes } = require('crypto')
+  const { performance } = require('perf_hooks')
+  const { URL } = require('url')
+  const os = require('os')
+
+  const { shouldSample, markSource, HTTP_CLIENT_MODE } = require('./sampling')
+
+  const serviceName = process.env.APP_NAME
+  const environment = process.env.NODE_ENV
+  const loggerUrlFromEnv = process.env.AZIFY_LOGGER_URL
+
+  let loggerEndpoint
+  try {
+    loggerEndpoint = new URL(loggerUrlFromEnv)
+  } catch (_) {
+    loggerEndpoint = new URL('http://localhost:3001/log')
+  }
+
+  const loggerUrlString = loggerEndpoint.toString()
+  const transport = createHttpLoggerTransport(loggerUrlString)
+
+  const flushTransport = () => transport.flush().catch(() => {})
+  process.once('beforeExit', flushTransport)
+  process.once('exit', flushTransport)
+
+  const normalizedLoggerOrigin = `${loggerEndpoint.protocol}//${loggerEndpoint.host}`
+  const normalizedLoggerPath = normalizePath(loggerEndpoint.pathname || '/')
+
+  const SENSITIVE_HEADER_KEYS = new Set([
+    'authorization',
+    'cookie',
+    'set-cookie',
+    'x-api-key',
+    'x-auth-token',
+    'x-access-token',
+    'proxy-authorization'
+  ])
+
+  function sanitizeHeaderEntries(headers) {
+    const sanitized = {}
+    if (!headers) {
+      return sanitized
+    }
+
+    const assignValue = (key, value) => {
+      if (key == null) {
+        return
+      }
+      const lower = String(key).toLowerCase()
+      if (!lower) {
+        return
+      }
+      sanitized[lower] = SENSITIVE_HEADER_KEYS.has(lower) ? '***' : String(value)
+    }
+
+    if (typeof headers.forEach === 'function') {
+      headers.forEach((value, key) => assignValue(key, value))
+    } else if (Array.isArray(headers)) {
+      headers.forEach(([key, value]) => assignValue(key, value))
+    } else if (typeof headers === 'object') {
+      Object.entries(headers).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((inner) => assignValue(key, inner))
+        } else if (value != null) {
+          assignValue(key, value)
+        }
+      })
+    }
+
+    return sanitized
+  }
+
+  function sendOutboundLog(level, message, meta) {
+    const source = meta && meta.__source
+    if (!shouldSample(level, source)) {
+      return
+    }
+
+    const payload = {
+      level,
+      message,
+      meta: {
+        ...meta,
+        service: {
+          name: serviceName,
+          version: (meta && meta.service && meta.service.version) || '1.0.0'
+        },
+        environment,
+        timestamp: new Date().toISOString(),
+        hostname: os.hostname()
+      }
+    }
+
+    transport.enqueue(payload, {
+      'content-type': 'application/json'
+    })
+  }
+
+  function normalizePath(path) {
+    if (!path) {
+      return '/'
+    }
+    const trimmed = String(path).replace(/\/+$/, '')
+    return trimmed === '' ? '/' : trimmed
+  }
+
+  function isLoggerApiCall(meta) {
+    if (!meta || !meta.url) {
+      return false
+    }
+
+    const candidate = meta.url
+
+    try {
+      const target = new URL(candidate, normalizedLoggerOrigin)
+      const targetOrigin = `${target.protocol}//${target.host}`
+      const targetPath = normalizePath(target.pathname)
+      return targetOrigin === normalizedLoggerOrigin && targetPath === normalizedLoggerPath
+    } catch (_) {
+      if (typeof candidate === 'string') {
+        const relativePath = normalizePath(candidate)
+        return relativePath === normalizedLoggerPath
+      }
+    }
+
+    return false
+  }
 
   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'
+      const loggerUrl = process.env.AZIFY_LOGGER_URL
+      const serviceName = process.env.APP_NAME || (options && options.name)
+      const environment = process.env.NODE_ENV
 
       logger.addStream({
         level,
@@ -350,33 +478,170 @@ try {
 
   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')
+    if (axios) {
+      const { getRequestContext, runWithRequestContext } = require('./store')
+
+      const buildUrl = (config) => {
+        const url = config.url || ''
+        if (/^https?:\/\//i.test(url)) {
+          return url
+        }
+
+        if (config.baseURL) {
+          try {
+            return new URL(url, config.baseURL).toString()
+          } catch (_) {
+            const base = String(config.baseURL).replace(/\/$/, '')
+            const path = String(url).replace(/^\//, '')
+            return `${base}/${path}`
+          }
+        }
+
+        return url
+      }
+
+      const patchInstance = (instance) => {
+        if (instance.__azifyLoggerPatched) {
+          return instance
+        }
+        instance.__azifyLoggerPatched = true
+
+        if (HTTP_CLIENT_MODE === 'off') {
+          return instance
+        }
+
+        instance.interceptors.request.use(
+          (config) => {
+            const method = (config.method || 'get').toUpperCase()
+            const url = buildUrl(config)
+            const testMeta = { url }
+            if (isLoggerApiCall(testMeta)) {
+              return config
+            }
+
             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()
+            const traceId = (ctx?.traceId) || randomUUID()
+            const parentSpanId = (ctx?.spanId) || null
+            const requestId = (ctx?.requestId) || randomUUID()
+            const spanId = randomBytes(8).toString('hex')
+
+            config.headers = {
+              ...(config.headers || {}),
+              'x-trace-id': traceId,
+              'x-span-id': spanId,
+              'x-parent-span-id': parentSpanId || '',
+              'x-request-id': requestId
+            }
+
+            const requestMeta = {
+              traceId,
+              spanId,
+              parentSpanId,
+              requestId,
+              method,
+              url,
+              headers: config.headers
+            }
+
+            markSource(requestMeta, 'http-client')
+            config.__azifyLogger = {
+              meta: requestMeta,
+              start: performance.now()
+            }
+            const childCtx = { traceId, spanId, parentSpanId, requestId }
+            config.__azifyChildCtx = childCtx
+
+            if (HTTP_CLIENT_MODE === 'all') {
+              sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+            }
+
+            return config
+          },
+          (error) => Promise.reject(error)
+        )
+
+        instance.interceptors.response.use(
+          (response) => {
+            const url = buildUrl(response.config)
+            const testMeta = { url }
+            if (isLoggerApiCall(testMeta)) {
+              return response
+            }
+
+            const marker = response.config?.__azifyLogger
+            const childCtx = response.config?.__azifyChildCtx
+
+            if (marker && marker.meta) {
+              const duration = Number((performance.now() - marker.start).toFixed(2))
+              const shouldLogResponse =
+                HTTP_CLIENT_MODE === 'all' ||
+                (HTTP_CLIENT_MODE === 'errors' && response.status >= 400)
+
+              if (shouldLogResponse) {
+                const meta = {
+                  ...marker.meta,
+                  statusCode: response.status,
+                  responseTimeMs: duration,
+                  responseHeaders: response.headers,
+                  responseBody: response.data
+                }
+                
+                markSource(meta, 'http-client')
+                const message = `[RESPONSE] ${meta.method} ${meta.url} ${response.status} ${duration}ms`
+                const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
+                
+                sendOutboundLog(level, message, meta)
               }
             }
-            
-            return fulfilled ? fulfilled(config) : config
-          }, rejected)
-        }
-        
+
+            return response
+          },
+          (error) => {
+            const config = error?.config
+            if (config) {
+              const url = buildUrl(config)
+              const testMeta = { url }
+              if (isLoggerApiCall(testMeta)) {
+                return Promise.reject(error)
+              }
+            }
+
+            const marker = config?.__azifyLogger
+            const childCtx = config?.__azifyChildCtx
+
+            if (marker && marker.meta) {
+              const duration = Number((performance.now() - marker.start).toFixed(2))
+              const meta = {
+                ...marker.meta,
+                responseTimeMs: duration,
+                error: {
+                  name: error?.name || 'Error',
+                  message: error?.message || String(error),
+                  stack: error?.stack
+                }
+              }
+              markSource(meta, 'http-client')
+              const message = `[ERROR] ${meta.method} ${meta.url}`
+              
+              sendOutboundLog('error', message, meta)
+            }
+
+            return Promise.reject(error)
+          }
+        )
+
         return instance
       }
+
+      patchInstance(axios)
+
+      if (axios.create) {
+        const originalCreate = axios.create
+        axios.create = function(config) {
+          const instance = originalCreate.call(this, config)
+          return patchInstance(instance)
+        }
+      }
     }
   } catch (_) {}
 
@@ -387,63 +652,9 @@ try {
         g.__azifyLoggerFetchPatched = true
 
         const { getRequestContext, runWithRequestContext } = require('./store')
-        const { randomUUID, randomBytes } = require('crypto')
-        const { performance } = require('perf_hooks')
-        const axios = require('axios')
-        const os = require('os')
-
-        const serviceName = process.env.APP_NAME || 'app'
-        const loggerUrl = process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log'
-        const environment = process.env.NODE_ENV || 'development'
-
-        async function sendLog(level, message, meta) {
-          const payload = {
-            level,
-            message,
-            meta: {
-              ...meta,
-              service: {
-                name: serviceName,
-                version: (meta && meta.service && meta.service.version) || '1.0.0'
-              },
-              environment,
-              timestamp: new Date().toISOString(),
-              hostname: os.hostname()
-            }
-          }
-
-          try {
-            await axios.post(loggerUrl, payload, { timeout: 5000 })
-          } catch (error) {
-            console.error('Erro ao enviar log:', error && error.message ? error.message : error)
-          }
-        }
 
         const originalFetch = globalThis.fetch.bind(globalThis)
 
-        function sanitizeHeaders(headers) {
-          const SENSITIVE_HEADER_KEYS = new Set([
-            'authorization',
-            'cookie',
-            'set-cookie',
-            'x-api-key',
-            'x-auth-token',
-            'x-access-token',
-            'proxy-authorization'
-          ])
-
-          const sanitized = {}
-          headers.forEach((value, key) => {
-            const lower = key.toLowerCase()
-            if (SENSITIVE_HEADER_KEYS.has(lower)) {
-              sanitized[lower] = '***'
-            } else {
-              sanitized[lower] = value
-            }
-          })
-          return sanitized
-        }
-
         function ensureRequest(input, init) {
           if (typeof Request !== 'undefined' && input instanceof Request) {
             return init ? new Request(input, init) : input
@@ -452,14 +663,23 @@ try {
         }
 
         globalThis.fetch = async function patchedFetch(input, init) {
+          if (HTTP_CLIENT_MODE === 'off') {
+            return originalFetch(input, init)
+          }
+          
           const request = ensureRequest(input, init)
           const method = request.method.toUpperCase()
           const url = request.url
 
+          const testMeta = { url }
+          if (isLoggerApiCall(testMeta)) {
+            return originalFetch(request)
+          }
+
           const ctx = getRequestContext()
-          const traceId = (ctx && ctx.traceId) || randomUUID()
-          const parentSpanId = (ctx && ctx.spanId) || null
-          const requestId = (ctx && ctx.requestId) || randomUUID()
+          const traceId = (ctx?.traceId) || randomUUID()
+          const parentSpanId = (ctx?.spanId) || null
+          const requestId = (ctx?.requestId) || randomUUID()
           const spanId = randomBytes(8).toString('hex')
 
           request.headers.set('x-trace-id', traceId)
@@ -474,11 +694,13 @@ try {
             requestId,
             method,
             url,
-            headers: sanitizeHeaders(request.headers)
+            headers: Object.fromEntries(request.headers.entries())
           }
 
-          const start = performance.now()
-          void sendLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+          markSource(requestMeta, 'http-client')
+          if (HTTP_CLIENT_MODE === 'all') {
+            sendOutboundLog('info', `[REQUEST] ${method} ${url}`, requestMeta)
+          }
 
           const childCtx = {
             traceId,
@@ -487,25 +709,67 @@ try {
             requestId
           }
 
+          const start = performance.now()
+
           try {
             const response = await runWithRequestContext(childCtx, function() {
               return originalFetch(request)
             })
 
             const duration = Number((performance.now() - start).toFixed(2))
-            const responseMeta = {
-              ...requestMeta,
-              statusCode: response.status,
-              responseTimeMs: duration
-            }
-
-            const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
-            if (response.status >= 500) {
-              void sendLog('error', message, responseMeta)
-            } else if (response.status >= 400) {
-              void sendLog('warn', message, responseMeta)
-            } else {
-              void sendLog('info', message, responseMeta)
+            const shouldLogResponse =
+              HTTP_CLIENT_MODE === 'all' ||
+              (HTTP_CLIENT_MODE === 'errors' && response.status >= 400)
+
+            if (shouldLogResponse) {
+              (async () => {
+                try {
+                  const clonedResponse = response.clone()
+                  const contentType = response.headers.get('content-type') || ''
+                  
+                  let responseBody = null
+                  
+                  if (contentType.includes('application/json') || contentType.includes('text/')) {
+                    const bodyText = await clonedResponse.text()
+                    if (contentType.includes('application/json')) {
+                      try {
+                        responseBody = JSON.parse(bodyText)
+                      } catch (_) {
+                        responseBody = bodyText
+                      }
+                    } else {
+                      responseBody = bodyText
+                    }
+                  }
+
+                  const responseMeta = {
+                    ...requestMeta,
+                    statusCode: response.status,
+                    responseTimeMs: duration,
+                    responseHeaders: Object.fromEntries(response.headers.entries()),
+                    responseBody: responseBody
+                  }
+                  
+                  markSource(responseMeta, 'http-client')
+                  const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
+                  
+                  const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
+                  sendOutboundLog(level, message, responseMeta)
+                } catch (_) {
+                  const responseMeta = {
+                    ...requestMeta,
+                    statusCode: response.status,
+                    responseTimeMs: duration,
+                    responseHeaders: Object.fromEntries(response.headers.entries()),
+                    responseBody: null
+                  }
+                  
+                  markSource(responseMeta, 'http-client')
+                  const message = `[RESPONSE] ${method} ${url} ${response.status} ${duration}ms`
+                  const level = response.status >= 500 ? 'error' : response.status >= 400 ? 'warn' : 'info'
+                  sendOutboundLog(level, message, responseMeta)
+                }
+              })()
             }
 
             return response
@@ -515,13 +779,14 @@ try {
               ...requestMeta,
               responseTimeMs: duration
             }
+            markSource(errorMeta, 'http-client')
             const err = error instanceof Error ? error : new Error(String(error))
             errorMeta.error = {
               name: err.name,
               message: err.message,
               stack: err.stack
             }
-            void sendLog('error', `[ERROR] ${method} ${url}`, errorMeta)
+            void sendOutboundLog('error', `[ERROR] ${method} ${url}`, errorMeta)
             throw error
           }
         }

package/sampling.js

@@ -0,0 +1,79 @@
+const clampRate = (value) => {
+  if (value === null || value === undefined || value === '') {
+    return null
+  }
+  const numeric = Number(value)
+  if (!Number.isFinite(numeric)) {
+    return null
+  }
+  return Math.max(0, Math.min(1, numeric))
+}
+
+const defaultSampleRate = clampRate(process.env.AZIFY_LOGGER_SAMPLE_RATE) ?? 1
+
+const resolveSampleRate = (envName, fallback) => {
+  const parsed = clampRate(process.env[envName])
+  return parsed === null ? fallback : parsed
+}
+
+const levelSampleRates = {
+  default: defaultSampleRate,
+  fatal: resolveSampleRate('AZIFY_LOGGER_SAMPLE_RATE_FATAL', defaultSampleRate),
+  error: resolveSampleRate('AZIFY_LOGGER_SAMPLE_RATE_ERROR', defaultSampleRate),
+  warn: resolveSampleRate('AZIFY_LOGGER_SAMPLE_RATE_WARN', defaultSampleRate),
+  info: resolveSampleRate('AZIFY_LOGGER_SAMPLE_RATE_INFO', defaultSampleRate),
+  debug: resolveSampleRate(
+    'AZIFY_LOGGER_SAMPLE_RATE_DEBUG',
+    defaultSampleRate < 1 ? defaultSampleRate : 0.05
+  ),
+  trace: resolveSampleRate(
+    'AZIFY_LOGGER_SAMPLE_RATE_TRACE',
+    defaultSampleRate < 1 ? defaultSampleRate : 0.02
+  )
+}
+
+const HTTP_CLIENT_MODE = (process.env.AZIFY_LOGGER_HTTP_CLIENT_LOGGING || 'all').toLowerCase()
+
+const httpClientSampleRate = resolveSampleRate(
+  'AZIFY_LOGGER_HTTP_SAMPLE_RATE',
+  HTTP_CLIENT_MODE === 'all' ? 1 : 1  // Sempre 1.0 (100%) quando HTTP_CLIENT_MODE === 'all'
+)
+
+const sourceSampleRates = {
+  'http-client': httpClientSampleRate,
+  logger: resolveSampleRate('AZIFY_LOGGER_SAMPLE_RATE_LOGGER', defaultSampleRate)
+}
+
+const shouldSample = (level, source) => {
+  const key = typeof level === 'string' ? level.toLowerCase() : 'info'
+  let rate = levelSampleRates[key] ?? levelSampleRates.default
+  if (source && sourceSampleRates[source] !== undefined) {
+    rate = Math.min(rate, sourceSampleRates[source])
+  }
+  if (rate >= 1) {
+    return true
+  }
+  if (rate <= 0) {
+    return false
+  }
+  return Math.random() < rate
+}
+
+const markSource = (meta, source) => {
+  if (!meta || typeof meta !== 'object' || !source) {
+    return
+  }
+  Object.defineProperty(meta, '__source', {
+    value: source,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+module.exports = {
+  shouldSample,
+  markSource,
+  HTTP_CLIENT_MODE
+}
+
+