azify-logger 1.0.15 → 1.0.17

package/init.js

@@ -0,0 +1,72 @@
+if (process.env.AZIFY_LOGGER_DISABLE === '1') return
+
+const Module = require('module')
+const originalRequire = Module.prototype.require
+
+Module.prototype.require = function(id) {
+  const result = originalRequire.call(this, id)
+  
+  if (id === '@nestjs/common') {
+    if (result && result.Logger) {
+      const originalLoggerConstructor = result.Logger
+      
+      function PatchedLogger(context) {
+        const instance = new originalLoggerConstructor(context)
+        
+        instance.log = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.log.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.log.call(this, message, context)
+        }
+        
+        instance.error = function(message, trace, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+          }
+          return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+        }
+        
+        instance.warn = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.warn.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.warn.call(this, message, context)
+        }
+        
+        instance.debug = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.debug.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.debug.call(this, message, context)
+        }
+        
+        instance.verbose = function(message, context) {
+          const { getRequestContext } = require('./store')
+          const ctx = getRequestContext()
+          if (ctx && ctx.traceId) {
+            return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+          }
+          return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+        }
+        
+        return instance
+      }
+      
+      Object.setPrototypeOf(PatchedLogger, originalLoggerConstructor)
+      Object.assign(PatchedLogger, originalLoggerConstructor)
+      
+      result.Logger = PatchedLogger
+    }
+  }
+  
+  return result
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azify-logger",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Azify Logger Client - Centralized logging for OpenSearch",
   "main": "index.js",
   "types": "index.d.ts",
@@ -49,6 +49,8 @@
   "files": [
     "index.js",
     "index.d.ts",
+    "init.js",
+    "register.js",
     "store.js",
     "register-otel.js",
     "register-restify.js",

package/register.js

@@ -0,0 +1,528 @@
+if (process.env.AZIFY_LOGGER_DISABLE === '1') return
+
+try {
+  const bunyan = require('bunyan')
+  const createBunyanStream = require('./streams/bunyan')
+  const { getRequestContext } = require('./store')
+
+  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'
+
+      logger.addStream({
+        level,
+        type: 'raw',
+        stream: createBunyanStream({ loggerUrl, serviceName, environment })
+      })
+    } catch (_) {}
+    return logger
+  }
+
+  try {
+    const Module = require('module')
+    const originalRequire = Module.prototype.require
+    const { getRequestContext } = require('./store')
+    
+    Module.prototype.require = function(id) {
+      const result = originalRequire.call(this, id)
+      if (id === 'pino' || id.endsWith('/pino')) {
+        if (result && typeof result === 'function') {
+          const originalPino = result
+          
+          const patchedPino = function(options, stream) {
+            const logger = originalPino(options, stream)
+            
+            const originalInfo = logger.info
+            const originalError = logger.error
+            const originalWarn = logger.warn
+            const originalDebug = logger.debug
+            const originalFatal = logger.fatal
+            const originalTrace = logger.trace
+            
+            logger.info = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalInfo.call(this, obj, msg, ...args)
+            }
+            
+            logger.error = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalError.call(this, obj, msg, ...args)
+            }
+            
+            logger.warn = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalWarn.call(this, obj, msg, ...args)
+            }
+            
+            logger.debug = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                // Extract traceId from message if it exists
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalDebug.call(this, obj, msg, ...args)
+            }
+            
+            logger.fatal = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalFatal.call(this, obj, msg, ...args)
+            }
+            
+            logger.trace = function(obj, msg, ...args) {
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                if (typeof obj === 'object' && obj !== null) {
+                  obj.traceId = ctx.traceId
+                  obj.spanId = ctx.spanId
+                  obj.parentSpanId = ctx.parentSpanId
+                  obj.requestId = ctx.requestId
+                } else {
+                  obj = { traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId, requestId: ctx.requestId, msg: obj }
+                }
+              }
+//              else {
+//                // Extract traceId from message if it exists
+//                const messageStr = typeof obj === 'string' ? obj : (typeof msg === 'string' ? msg : '')
+//                const traceMatch = messageStr.match(/\[([a-f0-9-]{8}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{4}-[a-f0-9-]{12})\]/)
+//                if (traceMatch) {
+//                  const extractedTraceId = traceMatch[1]
+//                  if (typeof obj === 'object' && obj !== null) {
+//                    obj.traceId = extractedTraceId
+//                  } else {
+//                    obj = { traceId: extractedTraceId, msg: obj }
+//                  }
+//                }
+//              }
+              return originalTrace.call(this, obj, msg, ...args)
+            }
+            
+            return logger
+          }
+          
+          Object.setPrototypeOf(patchedPino, originalPino)
+          Object.assign(patchedPino, originalPino)
+          
+          return patchedPino
+        }
+      }
+      
+      return result
+    }
+    
+  } catch (_) {}
+
+  try {
+    const { Logger } = require('@nestjs/common')
+    if (Logger) {
+      const originalLog = Logger.prototype.log
+      const originalError = Logger.prototype.error
+      const originalWarn = Logger.prototype.warn
+      const originalDebug = Logger.prototype.debug
+      const originalVerbose = Logger.prototype.verbose
+      
+      Logger.prototype.log = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalLog.call(this, message, context)
+        }
+        return originalLog.call(this, message, context)
+      }
+      
+      Logger.prototype.error = function(message, trace, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalError.call(this, message, trace, context)
+        }
+        return originalError.call(this, message, trace, context)
+      }
+      
+      Logger.prototype.warn = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalWarn.call(this, message, context)
+        }
+        return originalWarn.call(this, message, context)
+      }
+      
+      Logger.prototype.debug = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalDebug.call(this, message, context)
+        }
+        return originalDebug.call(this, message, context)
+      }
+      
+      Logger.prototype.verbose = function(message, context) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        if (ctx && ctx.traceId) {
+          return originalVerbose.call(this, message, context)
+        }
+        return originalVerbose.call(this, message, context)
+      }
+      
+    }
+  } catch (_) {}
+
+  try {
+    const originalConsoleLog = console.log
+    const originalConsoleError = console.error
+    const originalConsoleWarn = console.warn
+    
+    console.log = function(...args) {
+      return originalConsoleLog.apply(this, args)
+    }
+    
+    console.error = function(...args) {
+      return originalConsoleError.apply(this, args)
+    }
+    
+    console.warn = function(...args) {
+      return originalConsoleWarn.apply(this, args)
+    }
+  } catch (_) {}
+
+  try {
+    const Module = require('module')
+    const originalRequire = Module.prototype.require
+    
+    Module.prototype.require = function(id) {
+      const result = originalRequire.call(this, id)
+      
+      if (id === 'nestjs-pino' || id.endsWith('/nestjs-pino') || id.includes('nestjs-pino')) {
+        if (result && result.Logger) {
+          const originalLoggerConstructor = result.Logger
+          
+          function PatchedNestJSPinoLogger(context) {
+            const instance = new originalLoggerConstructor(context)
+            
+            instance.error = function(message, trace, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+              }
+              return originalLoggerConstructor.prototype.error.call(this, message, trace, context)
+            }
+            
+            instance.log = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.log.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.log.call(this, message, context)
+            }
+            
+            instance.warn = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.warn.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.warn.call(this, message, context)
+            }
+            
+            instance.debug = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.debug.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.debug.call(this, message, context)
+            }
+            
+            instance.verbose = function(message, context) {
+              const { getRequestContext } = require('./store')
+              const ctx = getRequestContext()
+              if (ctx && ctx.traceId) {
+                return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+              }
+              return originalLoggerConstructor.prototype.verbose.call(this, message, context)
+            }
+            
+            return instance
+          }
+          
+          Object.setPrototypeOf(PatchedNestJSPinoLogger, originalLoggerConstructor)
+          Object.assign(PatchedNestJSPinoLogger, originalLoggerConstructor)
+          
+          result.Logger = PatchedNestJSPinoLogger
+        }
+        
+        if (result && result.LoggerModule && result.LoggerModule.forRoot) {
+          const originalForRoot = result.LoggerModule.forRoot
+          
+          result.LoggerModule.forRoot = function(options) {
+            const createPinoStream = require('./streams/pino')
+            const stream = createPinoStream()
+            
+            const mergedOptions = {
+              ...options,
+              pinoHttp: {
+                ...(options && options.pinoHttp),
+                stream,
+              },
+            }
+            
+            return originalForRoot.call(this, mergedOptions)
+          }
+          
+          Object.setPrototypeOf(result.LoggerModule.forRoot, originalForRoot)
+          Object.assign(result.LoggerModule.forRoot, originalForRoot)
+        }
+      }
+      
+      return result
+    }
+    
+  } catch (_) {}
+
+  try {
+    const undici = require('undici')
+    if (undici && undici.request) {
+      const originalRequest = undici.request
+      undici.request = function(url, options, callback) {
+        const { getRequestContext } = require('./store')
+        const ctx = getRequestContext()
+        
+        if (ctx && ctx.traceId) {
+          const headers = options?.headers || {}
+          options = {
+            ...options,
+            headers: {
+              ...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()
+            }
+          }
+        }
+        
+        return originalRequest.call(this, url, options, callback)
+      }
+    }
+  } catch (_) {}
+
+  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')
+            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()
+              }
+            }
+            
+            return fulfilled ? fulfilled(config) : config
+          }, rejected)
+        }
+        
+        return instance
+      }
+    }
+  } catch (_) {}
+
+  try {
+    const Bull = require('bull')
+    const { runWithRequestContext } = require('./store')
+
+    const originalAdd = Bull.prototype.add
+    Bull.prototype.add = function(name, data, opts) {
+      const ctx = getRequestContext()
+
+      if (ctx && ctx.traceId) {
+        data = {
+          ...data,
+          traceId: ctx.traceId,
+          spanId: ctx.spanId,
+          parentSpanId: ctx.parentSpanId,
+          requestId: ctx.requestId,
+        }
+      }
+
+      return originalAdd.call(this, name, data, opts)
+    }
+
+    const originalProcess = Bull.prototype.process
+    Bull.prototype.process = function(name, concurrency, handler) {
+      let actualName, actualConcurrency, actualHandler
+
+      if (typeof name === 'function') {
+        actualHandler = name
+        actualName = '__default__'
+        actualConcurrency = 1
+      } else if (typeof concurrency === 'function') {
+        actualHandler = concurrency
+        actualName = name
+        actualConcurrency = 1
+      } else {
+        actualName = name
+        actualConcurrency = concurrency
+        actualHandler = handler
+      }
+
+      const wrappedHandler = function(job, done) {
+        const { traceId, spanId, parentSpanId, requestId, ...jobData } = job.data
+
+        if (traceId && spanId) {
+          const ctx = {
+            traceId,
+            spanId,
+            parentSpanId,
+            requestId,
+          }
+          
+          return runWithRequestContext(ctx, () => {
+            return actualHandler.call(this, job, done)
+          })
+        } else {
+          const { startRequestContext } = require('./store')
+          const newCtx = startRequestContext({ requestId: require('uuid').v4() })
+          
+          return runWithRequestContext(newCtx, () => {
+            return actualHandler.call(this, job, done)
+          })
+        }
+      }
+
+      if (typeof name === 'function') {
+        return originalProcess.call(this, wrappedHandler)
+      } else if (typeof concurrency === 'function') {
+        return originalProcess.call(this, actualName, wrappedHandler)
+      } else {
+        return originalProcess.call(this, actualName, actualConcurrency, wrappedHandler)
+      }
+    }
+  } catch (_) {}
+} catch (_) {}