azify-logger 1.0.26 → 1.0.28

package/streams/httpQueue.js

@@ -0,0 +1,357 @@
+const axios = require('axios')
+const http = require('http')
+const https = require('https')
+const path = require('path')
+const { randomUUID } = require('crypto')
+
+const { createRedisProducer, DEFAULT_STREAM_KEY, DEFAULT_REDIS_URL } = require('../queue/redisQueue')
+const { createFileSpool } = require('../queue/fileQueue')
+const { ensureWorker } = require('../queue/workerManager')
+
+const noopTransport = {
+  enqueue () {},
+  async flush () {}
+}
+
+const defaultNumbers = {
+  timeout: 250,
+  maxQueueSize: 2000,
+  batchSize: 25,
+  flushInterval: 100,
+  maxSockets: 10,
+  failureThreshold: 5,
+  failureCooldown: 30000
+}
+
+const envKeys = {
+  timeout: 'AZIFY_LOGGER_HTTP_TIMEOUT',
+  maxQueueSize: 'AZIFY_LOGGER_MAX_QUEUE',
+  batchSize: 'AZIFY_LOGGER_BATCH_SIZE',
+  flushInterval: 'AZIFY_LOGGER_FLUSH_INTERVAL',
+  maxSockets: 'AZIFY_LOGGER_MAX_SOCKETS',
+  failureThreshold: 'AZIFY_LOGGER_FAILURE_THRESHOLD',
+  failureCooldown: 'AZIFY_LOGGER_FAILURE_COOLDOWN'
+}
+
+const exitSignals = ['SIGINT', 'SIGTERM', 'SIGQUIT']
+
+function toNumber (value, fallback, { min = 0, max } = {}) {
+  const numeric = Number(value)
+  if (!Number.isFinite(numeric)) {
+    return fallback
+  }
+  if (numeric < min) {
+    return min
+  }
+  if (typeof max === 'number' && numeric > max) {
+    return max
+  }
+  return numeric
+}
+
+function resolveOptions (overrides = {}) {
+  const resolved = {}
+
+  for (const [key, fallback] of Object.entries(defaultNumbers)) {
+    const envValue = process.env[envKeys[key]]
+    resolved[key] = toNumber(
+      overrides[key] ?? envValue,
+      fallback,
+      key === 'failureThreshold'
+        ? { min: 0 }
+        : key === 'batchSize'
+          ? { min: 1 }
+          : { min: 0 }
+    )
+  }
+
+  if (resolved.maxQueueSize < resolved.batchSize) {
+    resolved.maxQueueSize = resolved.batchSize
+  }
+
+  return resolved
+}
+
+function resolveRedisConfig (overrides = {}) {
+  const redisUrl =
+    overrides.redisUrl ||
+    (overrides.redis && overrides.redis.url) ||
+    process.env.AZIFY_LOGGER_REDIS_URL ||
+    DEFAULT_REDIS_URL
+  
+  if (!redisUrl) {
+    return null
+  }
+
+  const streamKey = overrides.redisStream || (overrides.redis && overrides.redis.stream) || process.env.AZIFY_LOGGER_REDIS_STREAM || process.env.AZIFY_LOGGER_REDIS_QUEUE_KEY || DEFAULT_STREAM_KEY
+  const maxLen = Number(overrides.redisMaxStreamLength ?? (overrides.redis && overrides.redis.maxStreamLength) ?? process.env.AZIFY_LOGGER_REDIS_MAX_STREAM_LENGTH) || undefined
+  const spoolDir = overrides.redisSpoolDir || (overrides.redis && overrides.redis.spoolDir) || process.env.AZIFY_LOGGER_REDIS_SPOOL_DIR
+
+  return {
+    url: redisUrl,
+    streamKey,
+    maxLen,
+    spoolDir
+  }
+}
+
+function createHttpLoggerTransport (loggerUrl, overrides) {
+  if (!loggerUrl) {
+    return noopTransport
+  }
+
+  const options = resolveOptions(overrides)
+  const redisConfig = resolveRedisConfig(overrides)
+
+  if (redisConfig) {
+    try {
+      return createRedisStreamTransport(loggerUrl, options, redisConfig)
+    } catch (err) {
+      // Erro ao inicializar Redis - retornar noopTransport silenciosamente
+      // Não travar aplicação se Redis não estiver disponível
+      // Não logar - silenciar completamente para não poluir logs
+      return noopTransport
+    }
+  }
+
+  // Se Redis não estiver configurado, retornar noopTransport
+  // Não usar fallback síncrono para não travar aplicação
+  return noopTransport
+}
+
+function createRedisStreamTransport (loggerUrl, options, redisConfig) {
+  let producer = null
+  try {
+    producer = createRedisProducer(redisConfig)
+  } catch (err) {
+    // Erro ao criar producer - retornar noopTransport silenciosamente
+    // Não logar - silenciar completamente para não poluir logs
+    return noopTransport
+  }
+
+  if (!producer) {
+    return noopTransport
+  }
+
+  let spool = null
+  try {
+    spool = createFileSpool({
+      directory: redisConfig.spoolDir || path.join(process.cwd(), '.azify-logger-spool'),
+      flushInterval: options.flushInterval,
+      batchSize: options.batchSize,
+      async pushFn (entries) {
+        if (producer) {
+          for (const entry of entries) {
+            try {
+              await producer.enqueue(entry).catch(() => {
+                // Erro ao enfileirar - ignorar silenciosamente
+              })
+            } catch (err) {
+              // Erro ao enfileirar - ignorar silenciosamente
+            }
+          }
+        }
+      }
+    })
+  } catch (err) {
+    // Erro ao criar spool - continuar sem spool silenciosamente
+    // Não logar - silenciar completamente para não poluir logs
+  }
+
+  if (spool) {
+    spool.flush().catch(() => {})
+  }
+
+  try {
+    ensureWorker(redisConfig, { autoRestart: true, stdio: 'inherit' })
+  } catch (err) {
+    // Erro ao garantir worker - continuar sem worker silenciosamente
+    // Não logar - silenciar completamente para não poluir logs
+  }
+
+  function pushEntry(entry) {
+    // OTIMIZAÇÃO: Remover setImmediate aqui - já estamos dentro de um setImmediate (do middleware)
+    // producer.enqueue() já faz seu próprio setImmediate
+    // Isso reduz de 3 para 2 níveis de setImmediate aninhados
+    try {
+      if (!producer) {
+        // Se producer não estiver disponível, tentar spool
+        if (spool) {
+          spool.append(entry).catch(() => {})
+        }
+        return
+      }
+      
+      // Não aguardar - fazer fire-and-forget para não bloquear
+      // producer.enqueue() já faz setImmediate internamente
+      producer.enqueue(entry).catch(() => {
+        // Erro ao enfileirar no Redis - tentar spool
+        if (spool) {
+          spool.append(entry).catch(() => {})
+        }
+      })
+    } catch (err) {
+      // Erro ao preparar entrada - ignorar silenciosamente
+      if (spool) {
+        spool.append(entry).catch(() => {})
+      }
+    }
+  }
+
+  return {
+    enqueue (payload, headers = {}) {
+      // OTIMIZAÇÃO: Criar entry inline para reduzir overhead
+      // randomUUID() e Date.now() são rápidos, mas podemos otimizar verificando producer primeiro
+      try {
+        // Criar entry apenas quando necessário (após verificações básicas)
+        const entry = {
+          id: randomUUID(),
+          loggerUrl,
+          headers,
+          payload,
+          createdAt: Date.now(),
+          attempts: 0
+        }
+        // pushEntry não tem setImmediate agora - chama direto producer.enqueue()
+        // producer.enqueue() faz setImmediate → client.xadd() (Redis I/O assíncrono)
+        pushEntry(entry)
+      } catch (err) {
+        // Erro ao criar entrada - ignorar silenciosamente
+        // Não travar aplicação por erro no logger
+      }
+    },
+    async flush () {
+      try {
+        if (spool) {
+          await spool.flush().catch(() => {
+            // Erro ao fazer flush - ignorar silenciosamente
+          })
+        }
+      } catch (err) {
+        // Erro ao fazer flush - ignorar silenciosamente
+      }
+    }
+  }
+}
+
+function buildInlineTransport (loggerUrl, options) {
+  const { httpAgent, httpsAgent } = createHttpAgents(options)
+
+  const queue = []
+  let flushing = false
+  let flushTimer = null
+  let consecutiveFailures = 0
+  let circuitOpenUntil = 0
+
+  const scheduleFlush = (delay = options.flushInterval) => {
+    if (flushTimer || flushing) {
+      return
+    }
+
+    flushTimer = setTimeout(() => {
+      flushTimer = null
+      void flushQueue()
+    }, delay)
+
+    if (typeof flushTimer.unref === 'function') {
+      flushTimer.unref()
+    }
+  }
+
+  const flushQueue = async (force = false) => {
+    if (flushing) {
+      return
+    }
+
+    const now = Date.now()
+    if (!force && now < circuitOpenUntil) {
+      scheduleFlush(circuitOpenUntil - now)
+      return
+    }
+
+    const batch = queue.splice(0, options.batchSize)
+    if (!batch.length) {
+      return
+    }
+
+    flushing = true
+    try {
+      for (let i = 0; i < batch.length; i += 1) {
+        const { payload, headers } = batch[i]
+        try {
+          await axios.post(loggerUrl, payload, {
+            headers,
+            timeout: options.timeout,
+            httpAgent,
+            httpsAgent,
+            validateStatus: () => true
+          })
+          consecutiveFailures = 0
+        } catch (error) {
+          consecutiveFailures += 1
+
+          if (options.failureThreshold > 0 && consecutiveFailures >= options.failureThreshold) {
+            circuitOpenUntil = Date.now() + options.failureCooldown
+          }
+
+          const remaining = batch.slice(i)
+          if (remaining.length) {
+            queue.unshift(...remaining)
+          }
+
+          throw error
+        }
+      }
+    } catch (_) {
+      // remaining items already reinserted in queue
+    } finally {
+      flushing = false
+      if (queue.length) {
+        scheduleFlush()
+      }
+    }
+  }
+
+  const enqueue = (payload, headers = {}) => {
+    if (queue.length >= options.maxQueueSize) {
+      queue.shift()
+    }
+
+    queue.push({ payload, headers })
+
+    if (queue.length >= options.batchSize) {
+      void flushQueue()
+    } else {
+      scheduleFlush()
+    }
+  }
+
+  const gracefulFlush = () => flushQueue(true)
+  process.on('beforeExit', gracefulFlush)
+  process.on('exit', gracefulFlush)
+  exitSignals.forEach((signal) => {
+    process.on(signal, gracefulFlush)
+  })
+
+  return {
+    enqueue,
+    flush: flushQueue
+  }
+}
+
+function createHttpAgents (options) {
+  const httpAgent = new http.Agent({
+    keepAlive: true,
+    maxSockets: Math.max(1, options.maxSockets)
+  })
+  const httpsAgent = new https.Agent({
+    keepAlive: true,
+    maxSockets: Math.max(1, options.maxSockets)
+  })
+  return { httpAgent, httpsAgent }
+}
+
+module.exports = {
+  createHttpLoggerTransport
+}
+

package/streams/pino.d.ts

@@ -1,9 +1,47 @@
 import { Transform } from 'stream';
 
+export interface HttpTransportOptions {
+  timeout?: number;
+  maxQueueSize?: number;
+  batchSize?: number;
+  flushInterval?: number;
+  maxSockets?: number;
+  failureThreshold?: number;
+  failureCooldown?: number;
+  redisUrl?: string;
+  redisQueueKey?: string;
+  redisMaxQueueLen?: number;
+  redisWorker?: boolean;
+}
+
 export interface PinoStreamOptions {
   loggerUrl?: string;
   serviceName?: string;
   environment?: string;
+  /** Optional low level transport tuning overrides */
+  transportOptions?: HttpTransportOptions;
+  /** Shorthand for transportOptions.timeout */
+  timeout?: number;
+  /** Shorthand for transportOptions.maxQueueSize */
+  maxQueueSize?: number;
+  /** Shorthand for transportOptions.batchSize */
+  batchSize?: number;
+  /** Shorthand for transportOptions.flushInterval */
+  flushInterval?: number;
+  /** Shorthand for transportOptions.maxSockets */
+  maxSockets?: number;
+  /** Shorthand for transportOptions.failureThreshold */
+  failureThreshold?: number;
+  /** Shorthand for transportOptions.failureCooldown */
+  failureCooldown?: number;
+  /** Shorthand for enabling Redis queue */
+  redisUrl?: string;
+  /** Shorthand for queue key used when Redis is enabled */
+  redisQueueKey?: string;
+  /** Shorthand for Redis queue max length */
+  redisMaxQueueLen?: number;
+  /** Disable/enable embedded Redis worker */
+  redisWorker?: boolean;
 }
 
 /**

package/streams/pino.js

@@ -12,17 +12,25 @@ try {
   trace = { getSpan: () => null }
   W3CTraceContextPropagator = class {}
 }
-const axios = require('axios')
+const { createHttpLoggerTransport } = require('./httpQueue')
+const { shouldSample } = require('../sampling')
 
 function createPinoStream(options = {}) {
-  const loggerUrl = options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001'
-  const serviceName = options.serviceName || process.env.APP_NAME || 'app'
-  const environment = options.environment || process.env.NODE_ENV || 'development'
+  const loggerUrl = options.loggerUrl || process.env.AZIFY_LOGGER_URL
+  const serviceName = options.serviceName || process.env.APP_NAME
+  const environment = options.environment || process.env.NODE_ENV
+
+  const transport = createHttpLoggerTransport(loggerUrl, extractTransportOptions(options))
 
   return {
-    write(chunk) {
+    write (chunk) {
       let record
-      try { record = typeof chunk === 'string' ? JSON.parse(chunk) : chunk } catch (_) { return }
+      try {
+        record = typeof chunk === 'string' ? JSON.parse(chunk) : chunk
+      } catch (_) {
+        return
+      }
+
       const levelMap = { 60: 'fatal', 50: 'error', 40: 'warn', 30: 'info', 20: 'debug', 10: 'trace' }
       const level = levelMap[record.level] || 'info'
 
@@ -65,10 +73,39 @@ function createPinoStream(options = {}) {
         ...(spanId && { spanId })
       }
 
+      if (!shouldSample(level, 'logger')) {
+        return
+      }
+
       const payload = { level, message: record.msg || record.message || 'log', meta }
-      axios.post(`${loggerUrl}`, payload, { headers, timeout: 10000 }).catch(() => {})
+      transport.enqueue(payload, headers)
     }
   }
 }
 
 module.exports = createPinoStream
+
+function extractTransportOptions (options) {
+  const {
+    transportOptions = {},
+    timeout,
+    maxQueueSize,
+    batchSize,
+    flushInterval,
+    maxSockets,
+    failureThreshold,
+    failureCooldown
+  } = options
+
+  const overrides = { ...transportOptions }
+
+  if (timeout != null) overrides.timeout = timeout
+  if (maxQueueSize != null) overrides.maxQueueSize = maxQueueSize
+  if (batchSize != null) overrides.batchSize = batchSize
+  if (flushInterval != null) overrides.flushInterval = flushInterval
+  if (maxSockets != null) overrides.maxSockets = maxSockets
+  if (failureThreshold != null) overrides.failureThreshold = failureThreshold
+  if (failureCooldown != null) overrides.failureCooldown = failureCooldown
+
+  return overrides
+}