azify-logger 1.0.26 → 1.0.29

package/middleware-fastify.js

@@ -0,0 +1,348 @@
+const { startRequestContext } = require('./store')
+const { createHttpLoggerTransport } = require('./streams/httpQueue')
+const os = require('os')
+
+function fastUUID() {
+  const timestamp = Date.now().toString(36)
+  const randomPart = Math.random().toString(36).substring(2, 15)
+  const randomPart2 = Math.random().toString(36).substring(2, 15)
+  return `${timestamp}-${randomPart}-${randomPart2}`.substring(0, 36)
+}
+
+function sanitizeTraceHex(value) {
+  if (!value || typeof value !== 'string') return null
+  const hex = value.replace(/[^0-9a-fA-F]/g, '').toLowerCase()
+  if (!hex) return null
+  return hex.padEnd(32, '0').slice(0, 32)
+}
+
+function safeSerializeBody(payload) {
+  if (payload == null) return ''
+  if (typeof payload === 'string') return payload
+  if (Buffer.isBuffer(payload)) return payload.toString('utf8')
+  try {
+    return JSON.stringify(payload)
+  } catch (err) {
+    try {
+      return String(payload)
+    } catch {
+      return ''
+    }
+  }
+}
+
+const HEADER_WHITELIST = new Set([
+  'content-type',
+  'content-length',
+  'accept',
+  'accept-encoding',
+  'user-agent',
+  'host',
+  'x-request-id',
+  'x-trace-id',
+  'x-span-id',
+  'x-parent-span-id'
+])
+
+function pickHeaders(source) {
+  if (!source || typeof source !== 'object') {
+    return {}
+  }
+  const result = {}
+  for (const key in source) {
+    const lower = key.toLowerCase()
+    if (!HEADER_WHITELIST.has(lower)) continue
+    
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue
+    
+    const value = source[key]
+    if (Array.isArray(value)) {
+      result[key] = value.map(String)
+    } else if (value != null) {
+      result[key] = String(value)
+    }
+  }
+  return result
+}
+
+function createFastifyLoggingPlugin(options = {}) {
+  const config = {
+    serviceName: options.serviceName || process.env.APP_NAME,
+    loggerUrl: options.loggerUrl || process.env.AZIFY_LOGGER_URL || 'http://localhost:3001/log',
+    environment: options.environment || process.env.NODE_ENV,
+    captureResponseBody: options.captureResponseBody !== false && process.env.AZIFY_LOGGER_CAPTURE_RESPONSE_BODY !== 'false',
+    captureRequestBody: options.captureRequestBody !== false && process.env.AZIFY_LOGGER_CAPTURE_REQUEST_BODY !== 'false',
+    logRequest: options.logRequest !== false && process.env.AZIFY_LOGGER_LOG_REQUEST !== 'false',
+    captureHeaders: options.captureHeaders !== undefined ? options.captureHeaders : process.env.AZIFY_LOGGER_CAPTURE_HEADERS === 'true'
+  }
+
+  const transport = createHttpLoggerTransport(config.loggerUrl, {})
+  const hostname = os.hostname()
+  const serviceObj = config.serviceName ? { name: config.serviceName, version: '1.0.0' } : null
+
+  function sendLog(level, message, meta = {}) {
+    if (!transport || typeof transport.enqueue !== 'function') return
+    
+    transport.enqueue({
+      level,
+      message,
+      meta
+    }, { 'content-type': 'application/json' })
+  }
+
+  return async function azifyFastifyPlugin(fastify, opts) {
+    fastify.addHook('onRequest', async (request, reply) => {
+      const startTime = Date.now()
+      const method = request.method
+      const url = request.url
+      const path = request.routerPath || url
+      
+      let responseChunk = null
+      let responseChunkCaptured = false
+      let logSent = false
+      
+      let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
+      let idsCreated = false
+      let headersCached = false
+      let reqCtx = null
+      
+      const logWithContext = (level, message, meta) => {
+        if (!reqCtx) {
+          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
+          reqCtx = startRequestContext({
+            requestId: requestId || request.requestId || fastUUID(),
+            traceHex,
+            parentSpanId: request.headers['x-parent-span-id'] || null
+          })
+        }
+        meta.traceId = meta.traceId || reqCtx.traceId
+        meta.spanId = meta.spanId || reqCtx.spanId
+        meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+        sendLog(level, message, meta)
+      }
+      
+      function ensureIds() {
+        if (idsCreated) return
+        idsCreated = true
+        
+        query = request.query || null
+        
+        if (!reqCtx) {
+          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
+          reqCtx = startRequestContext({
+            requestId: request.requestId || fastUUID(),
+            traceHex,
+            parentSpanId: request.headers['x-parent-span-id'] || null
+          })
+        }
+        
+        requestId = reqCtx.requestId || request.requestId || fastUUID()
+        traceId = reqCtx.traceId
+        spanId = reqCtx.spanId
+        parentSpanId = reqCtx.parentSpanId || request.headers['x-parent-span-id'] || null
+        
+        clientIp = request.ip || request.socket?.remoteAddress || 'unknown'
+        request.requestId = requestId
+      }
+      
+      function ensureHeaders() {
+        if (headersCached) return
+        headersCached = true
+        if (config.captureHeaders) {
+          cachedHeaders = pickHeaders(request.headers || {})
+        } else {
+          cachedHeaders = {}
+        }
+      }
+      
+      function emitResponseLog(meta, chunk) {
+        if (!config.captureResponseBody || chunk == null) {
+          logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+          return
+        }
+
+        if (!meta.response) meta.response = {}
+        meta.response.body = safeSerializeBody(chunk)
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+      }
+
+      request.azifyLogger = {
+        startTime,
+        method,
+        url,
+        path,
+        responseChunk: null,
+        responseChunkCaptured: false,
+        logSent: false,
+        requestId: null,
+        traceId: null,
+        spanId: null,
+        parentSpanId: null,
+        clientIp: null,
+        query: null,
+        cachedHeaders: null,
+        idsCreated: false,
+        headersCached: false,
+        reqCtx: null
+      }
+
+      if (config.logRequest) {
+        process.nextTick(() => {
+          ensureIds()
+          ensureHeaders()
+          
+          const requestObj = {
+            id: requestId,
+            method,
+            url,
+            path,
+            ip: clientIp
+          }
+          if (query) requestObj.query = query
+          if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
+          if (config.captureRequestBody && request.body !== undefined && request.body != null) {
+            requestObj.body = safeSerializeBody(request.body)
+          }
+          
+          const meta = {
+            traceId: reqCtx.traceId,
+            spanId: reqCtx.spanId,
+            parentSpanId: reqCtx.parentSpanId || null,
+            requestId,
+            request: requestObj,
+            timestamp: Date.now(),
+            hostname
+          }
+          if (serviceObj) meta.service = serviceObj
+          if (config.environment) meta.environment = config.environment
+          
+          logWithContext('info', `[REQUEST] ${method} ${url}`, meta)
+        })
+      }
+    })
+
+    fastify.addHook('onSend', async (request, reply, payload) => {
+      const logger = request.azifyLogger
+      if (!logger || logger.logSent) return payload
+      
+      logger.logSent = true
+      
+      if (config.captureResponseBody && payload != null && !logger.responseChunkCaptured) {
+        logger.responseChunk = payload
+        logger.responseChunkCaptured = true
+      }
+      
+      const startTime = logger.startTime
+      const method = logger.method
+      const url = logger.url
+      const path = logger.path
+      
+      let requestId, traceId, spanId, parentSpanId, clientIp, query, cachedHeaders
+      let idsCreated = false
+      let headersCached = false
+      let reqCtx = null
+      
+      const logWithContext = (level, message, meta) => {
+        if (!reqCtx) {
+          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
+          reqCtx = startRequestContext({
+            requestId: requestId || request.requestId || fastUUID(),
+            traceHex,
+            parentSpanId: request.headers['x-parent-span-id'] || null
+          })
+        }
+        meta.traceId = meta.traceId || reqCtx.traceId
+        meta.spanId = meta.spanId || reqCtx.spanId
+        meta.parentSpanId = meta.parentSpanId || reqCtx.parentSpanId
+        sendLog(level, message, meta)
+      }
+      
+      function ensureIds() {
+        if (idsCreated) return
+        idsCreated = true
+        
+        query = request.query || null
+        
+        if (!reqCtx) {
+          const traceHex = sanitizeTraceHex(request.headers['x-trace-id'])
+          reqCtx = startRequestContext({
+            requestId: request.requestId || fastUUID(),
+            traceHex,
+            parentSpanId: request.headers['x-parent-span-id'] || null
+          })
+        }
+        
+        requestId = reqCtx.requestId || request.requestId || fastUUID()
+        traceId = reqCtx.traceId
+        spanId = reqCtx.spanId
+        parentSpanId = reqCtx.parentSpanId || request.headers['x-parent-span-id'] || null
+        
+        clientIp = request.ip || request.socket?.remoteAddress || 'unknown'
+      }
+      
+      function ensureHeaders() {
+        if (headersCached) return
+        headersCached = true
+        if (config.captureHeaders) {
+          cachedHeaders = pickHeaders(request.headers || {})
+        } else {
+          cachedHeaders = {}
+        }
+      }
+      
+      function emitResponseLog(meta, chunk) {
+        if (!config.captureResponseBody || chunk == null) {
+          logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+          return
+        }
+
+        if (!meta.response) meta.response = {}
+        meta.response.body = safeSerializeBody(chunk)
+        logWithContext('info', `[RESPONSE] ${method} ${url}`, meta)
+      }
+      
+      process.nextTick(() => {
+        ensureIds()
+        
+        const statusCode = reply.statusCode || 200
+        const duration = Date.now() - startTime
+        const response = { statusCode, durationMs: duration }
+        
+        if (config.captureHeaders) {
+          ensureHeaders()
+        }
+        
+        const requestObj = {
+          id: requestId,
+          method,
+          url,
+          path,
+          ip: clientIp
+        }
+        if (query) requestObj.query = query
+        if (config.captureHeaders && cachedHeaders) requestObj.headers = cachedHeaders
+        
+        const meta = {
+          traceId: reqCtx.traceId,
+          spanId: reqCtx.spanId,
+          parentSpanId: reqCtx.parentSpanId || null,
+          requestId,
+          request: requestObj,
+          response,
+          timestamp: Date.now(),
+          hostname
+        }
+        if (serviceObj) meta.service = serviceObj
+        if (config.environment) meta.environment = config.environment
+        
+        const chunkToProcess = (logger.responseChunk !== null && logger.responseChunkCaptured) ? logger.responseChunk : null
+        emitResponseLog(meta, chunkToProcess)
+      })
+      
+      return payload
+    })
+  }
+}
+
+module.exports = createFastifyLoggingPlugin
+