azify-logger 1.0.26 → 1.0.29

package/queue/fileQueue.js

@@ -0,0 +1,100 @@
+const fs = require('fs')
+const path = require('path')
+
+function createFileSpool(options = {}) {
+  const directory = options.directory || path.join(process.cwd(), '.azify-logger-spool')
+  const flushInterval = options.flushInterval || 5000
+  const batchSize = options.batchSize || 100
+  const pushFn = typeof options.pushFn === 'function' ? options.pushFn : null
+
+  if (!pushFn) {
+    return null
+  }
+
+  fs.mkdirSync(directory, { recursive: true })
+
+  let scheduled = false
+  let flushing = false
+
+  const scheduleFlush = () => {
+    if (scheduled) {
+      return
+    }
+    scheduled = true
+    const timer = setTimeout(async () => {
+      scheduled = false
+      await flush().catch(() => {})
+    }, flushInterval)
+    if (typeof timer.unref === 'function') {
+      timer.unref()
+    }
+  }
+
+  async function append(entry) {
+    const filePath = path.join(directory, `spool-${process.pid}.ndjson`)
+    await fs.promises.appendFile(filePath, JSON.stringify(entry) + '\n')
+    scheduleFlush()
+  }
+
+  async function flush() {
+    if (flushing) {
+      return
+    }
+    flushing = true
+    try {
+      const files = (await fs.promises.readdir(directory)).filter((file) => file.endsWith('.ndjson'))
+      for (const file of files) {
+        const fullPath = path.join(directory, file)
+        const drainingPath = `${fullPath}.draining`
+        try {
+          await fs.promises.rename(fullPath, drainingPath)
+        } catch (err) {
+          if (err.code === 'ENOENT') {
+            continue
+          }
+          throw err
+        }
+
+        const content = await fs.promises.readFile(drainingPath, 'utf8').catch(() => '')
+        if (!content) {
+          await fs.promises.unlink(drainingPath).catch(() => {})
+          continue
+        }
+
+        const lines = content.split('\n').filter(Boolean)
+        while (lines.length) {
+          const slice = lines.splice(0, batchSize)
+          const entries = slice.map((line) => {
+            try {
+              return JSON.parse(line)
+            } catch (_) {
+              return null
+            }
+          }).filter(Boolean)
+          if (entries.length > 0) {
+            await pushFn(entries).catch(async () => {
+              const remaining = entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n'
+              await fs.promises.appendFile(fullPath, remaining)
+              throw new Error('Failed to flush file spool entries back to Redis')
+            })
+          }
+        }
+
+        await fs.promises.unlink(drainingPath).catch(() => {})
+      }
+    } finally {
+      flushing = false
+    }
+  }
+
+  return {
+    append,
+    flush
+  }
+}
+
+module.exports = {
+  createFileSpool
+}
+
+

package/queue/redisQueue.js

@@ -0,0 +1,179 @@
+const Redis = require('ioredis')
+
+const DEFAULT_REDIS_URL = process.env.AZIFY_LOGGER_REDIS_URL || 'redis://localhost:6381'
+const DEFAULT_STREAM_KEY = process.env.AZIFY_LOGGER_REDIS_STREAM || process.env.AZIFY_LOGGER_REDIS_QUEUE_KEY || 'azify-logger:stream'
+const DEFAULT_MAXLEN = Number(process.env.AZIFY_LOGGER_REDIS_MAX_STREAM_LENGTH) || 100000
+
+const defaultRedisOptions = {
+  enableAutoPipelining: true,
+  maxRetriesPerRequest: null,
+  retryStrategy(times) {
+    const delay = Math.min(1000 * Math.pow(1.5, times), 10000)
+    return delay
+  },
+  reconnectOnError(err) {
+    const msg = err && err.message ? err.message : ''
+    if (msg.includes('READONLY') || msg.includes('ECONNRESET') || msg.includes('ECONNREFUSED')) {
+      return true
+    }
+    return false
+  }
+}
+
+function createRedisProducer(config = {}) {
+  const url = config.url || process.env.AZIFY_LOGGER_REDIS_URL || DEFAULT_REDIS_URL
+  if (!url) {
+    throw new Error('Redis URL is required to initialize the azify-logger Redis producer.')
+  }
+
+  const streamKey = config.streamKey || DEFAULT_STREAM_KEY
+  const maxLen = Number.isFinite(config.maxLen) ? config.maxLen : DEFAULT_MAXLEN
+  const redisOptions = { ...defaultRedisOptions, ...(config.redisOptions || {}) }
+
+  const client = new Redis(url, redisOptions)
+  let lastConnectionErrorLog = 0
+  let lastEnqueueErrorLog = 0
+  let connectionErrorCount = 0
+  const ERROR_LOG_INTERVAL = 300000
+  
+  if (typeof global.__azifyLoggerRedisErrorLogged === 'undefined') {
+    global.__azifyLoggerRedisErrorLogged = false
+    global.__azifyLoggerRedisErrorLastLog = 0
+  }
+  
+  client.on('error', (err) => {
+    const now = Date.now()
+    if (!global.__azifyLoggerRedisErrorLogged && now - global.__azifyLoggerRedisErrorLastLog > ERROR_LOG_INTERVAL) {
+      if (err && (err.code === 'ECONNREFUSED' || err.message?.includes('ECONNREFUSED') || err.message?.includes('Redis'))) {
+        global.__azifyLoggerRedisErrorLogged = true
+        global.__azifyLoggerRedisErrorLastLog = now
+        connectionErrorCount++
+        process.stderr.write('[azify-logger] ⚠️  Redis indisponível. O sistema de logging está desabilitado. A aplicação continua funcionando normalmente.\n')
+        lastConnectionErrorLog = now
+      }
+    }
+  })
+  client.on('end', () => {
+  })
+  client.on('connect', () => {
+    if (connectionErrorCount > 0 || global.__azifyLoggerRedisErrorLogged) {
+      connectionErrorCount = 0
+      lastConnectionErrorLog = 0
+      global.__azifyLoggerRedisErrorLogged = false
+      global.__azifyLoggerRedisErrorLastLog = 0
+    }
+  })
+
+  const batch = []
+  let batchTimer = null
+  const BATCH_SIZE = 1
+  const BATCH_TIMEOUT = 0
+  let flushing = false
+
+  function flushBatch() {
+    if (flushing || batch.length === 0) return
+    flushing = true
+
+    const entriesToFlush = batch.splice(0, BATCH_SIZE)
+    if (!entriesToFlush.length) {
+      flushing = false
+      return
+    }
+
+    setImmediate(() => {
+      if (entriesToFlush.length === 1) {
+        const entry = entriesToFlush[0]
+        if (entry) {
+          const payload = JSON.stringify(entry)
+          client.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload).catch(() => {})
+        }
+      } else {
+        const pipeline = client.pipeline()
+        let validCount = 0
+        
+        for (let i = 0; i < entriesToFlush.length; i++) {
+          const entry = entriesToFlush[i]
+          if (!entry) continue
+          const payload = JSON.stringify(entry)
+          pipeline.xadd(streamKey, 'MAXLEN', '~', maxLen, '*', 'entry', payload)
+          validCount++
+        }
+        
+        if (validCount > 0) {
+          pipeline.exec().catch(() => {})
+        }
+      }
+      
+      flushing = false
+      if (batch.length >= BATCH_SIZE) {
+        flushBatch()
+      } else if (batch.length > 0) {
+        scheduleFlush()
+      }
+    })
+  }
+
+  function scheduleFlush() {
+    if (batchTimer || flushing) return
+    
+    if (batch.length >= BATCH_SIZE) {
+      flushBatch()
+    } else if (BATCH_TIMEOUT === 0) {
+      setImmediate(() => {
+        if (!flushing) {
+          flushBatch()
+        }
+      })
+    } else {
+      batchTimer = setTimeout(() => {
+        batchTimer = null
+        flushBatch()
+      }, BATCH_TIMEOUT)
+      
+      if (typeof batchTimer.unref === 'function') {
+        batchTimer.unref()
+      }
+    }
+  }
+
+  function enqueue(entry) {
+    batch.push(entry)
+    
+    if (batch.length >= BATCH_SIZE) {
+      if (batchTimer) {
+        clearTimeout(batchTimer)
+        batchTimer = null
+      }
+      flushBatch()
+    } else if (batch.length === 1) {
+      scheduleFlush()
+    }
+  }
+
+  async function close() {
+    if (batchTimer) {
+      clearTimeout(batchTimer)
+      batchTimer = null
+    }
+    while (batch.length > 0) {
+      flushBatch()
+      await new Promise(resolve => setTimeout(resolve, 10))
+    }
+    await client.quit().catch(() => {})
+  }
+
+  return {
+    enqueue,
+    client,
+    streamKey,
+    close,
+    flush: flushBatch
+  }
+}
+
+module.exports = {
+  createRedisProducer,
+  DEFAULT_REDIS_URL,
+  DEFAULT_STREAM_KEY,
+  DEFAULT_MAXLEN
+}

package/queue/workerManager.js

@@ -0,0 +1,111 @@
+const { fork } = require('child_process')
+const path = require('path')
+
+let workerProcess = null
+let restarting = false
+
+function buildEnv(redisConfig = {}, extraEnv = {}) {
+  const env = { ...process.env, ...extraEnv }
+
+  if (redisConfig.url) env.AZIFY_LOGGER_REDIS_URL = String(redisConfig.url)
+  if (redisConfig.streamKey) env.AZIFY_LOGGER_REDIS_STREAM = String(redisConfig.streamKey)
+  if (redisConfig.streamKey) env.AZIFY_LOGGER_REDIS_QUEUE_KEY = String(redisConfig.streamKey)
+  if (redisConfig.maxLen != null) env.AZIFY_LOGGER_REDIS_MAX_STREAM_LENGTH = String(redisConfig.maxLen)
+
+  return env
+}
+
+function spawnWorker(redisConfig, options = {}) {
+  if (workerProcess && !workerProcess.killed) {
+    return workerProcess
+  }
+
+  const scriptPath = path.resolve(__dirname, '..', 'scripts', 'redis-worker.js')
+  const env = buildEnv(redisConfig, options.env)
+  const stdio = options.stdio || 'inherit'
+  const autoRestart = options.autoRestart !== false
+  const restartDelay = options.restartDelay ?? 1000
+
+  try {
+    workerProcess = fork(scriptPath, [], { env, stdio })
+  } catch (error) {
+    console.error('[azify-logger] Falha ao iniciar worker Redis:', error)
+    workerProcess = null
+    return null
+  }
+
+  const cleanup = () => {
+    if (workerProcess && !workerProcess.killed) {
+      workerProcess.kill()
+      workerProcess = null
+    }
+  }
+
+  process.once('exit', cleanup)
+  process.once('SIGINT', () => {
+    cleanup()
+    process.exit(0)
+  })
+  process.once('SIGTERM', () => {
+    cleanup()
+    process.exit(0)
+  })
+
+  if (stdio !== 'inherit') {
+    workerProcess.on('message', (msg) => {
+      if (msg && msg.type === 'azify-logger:ready') {
+        console.log('[azify-logger] Worker Redis ativo')
+      }
+    })
+  } else {
+    console.log('[azify-logger] Worker Redis iniciado (PID', workerProcess.pid, ')')
+  }
+
+  workerProcess.on('exit', (code, signal) => {
+    const reason = signal || code
+    console.warn('[azify-logger] Worker Redis finalizado:', reason)
+    workerProcess = null
+    if (autoRestart && !restarting && process.env.AZIFY_LOGGER_EMBEDDED_WORKER !== '0') {
+      restarting = true
+      setTimeout(() => {
+        restarting = false
+        spawnWorker(redisConfig, options)
+      }, restartDelay)
+    }
+  })
+
+  workerProcess.on('error', (error) => {
+    console.error('[azify-logger] Erro no worker Redis:', error)
+  })
+
+  return workerProcess
+}
+
+function ensureWorker(redisConfig, options = {}) {
+  if (process.env.AZIFY_LOGGER_EMBEDDED_WORKER === '0') {
+    return null
+  }
+  return spawnWorker(redisConfig, options)
+}
+
+function startLoggerWorker(options = {}) {
+  return spawnWorker(options.redisConfig || {}, options)
+}
+
+function stopLoggerWorker() {
+  if (workerProcess && !workerProcess.killed) {
+    workerProcess.kill()
+    workerProcess = null
+  }
+}
+
+function getWorkerProcess() {
+  return workerProcess
+}
+
+module.exports = {
+  ensureWorker,
+  startLoggerWorker,
+  stopLoggerWorker,
+  getWorkerProcess
+}

package/register-otel.js

@@ -1,6 +1,8 @@
 try {
   const { NodeSDK } = require('@opentelemetry/sdk-node')
-  const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node')
+  const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http')
+  const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express')
+  const { RestifyInstrumentation } = require('@opentelemetry/instrumentation-restify')
 
   const serviceName = process.env.OTEL_SERVICE_NAME || process.env.APP_NAME || 'app'
   const serviceVersion = process.env.OTEL_SERVICE_VERSION || '1.0.0'
@@ -8,22 +10,70 @@ try {
   process.env.OTEL_SERVICE_NAME = serviceName
   process.env.OTEL_SERVICE_VERSION = serviceVersion
 
+  let collectorHost = null
+  let collectorPath = null
+  try {
+    const target = new URL(process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log')
+    collectorHost = target.host
+    collectorPath = target.pathname || '/'
+  } 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']
+      if (requestId) {
+        span.setAttribute('azify.request_id', requestId)
+      }
+    }
+  })
+
+  const expressInstrumentation = new ExpressInstrumentation({
+    enabled: true,
+    ignoreLayersType: ['router', 'middleware']
+  })
+
+  const restifyInstrumentation = new RestifyInstrumentation({
+    enabled: true
+  })
+
   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 }
-    })]
+    serviceName,
+    serviceVersion,
+    instrumentations: [
+      httpInstrumentation,
+      expressInstrumentation,
+      restifyInstrumentation
+    ]
   })
 
   sdk.start()
-  
+
   process.once('SIGTERM', () => {
     sdk.shutdown()
       .finally(() => process.exit(0))