azify-logger 1.0.26 → 1.0.29

package/server.js

@@ -22,6 +22,11 @@ try {
 
 const app = express()
 
+const allowedExternalIPs = (process.env.ALLOWED_SOURCE_IPS || '')
+  .split(',')
+  .map(ip => ip.trim())
+  .filter(Boolean)
+
 app.set('trust proxy', 1)
 
 app.use(express.json({ limit: '10mb' }))
@@ -77,7 +82,11 @@ function validateNetworkAccess(req, res, next) {
                    req.connection.remoteAddress ||
                    req.socket.remoteAddress
   
-  if (!IS_LOCAL && !isPrivateOrLocalhost(clientIP)) {
+  if (
+    !IS_LOCAL &&
+    !isPrivateOrLocalhost(clientIP) &&
+    !(allowedExternalIPs.length > 0 && allowedExternalIPs.includes(clientIP))
+  ) {
     return res.status(403).json({
       success: false,
       message: 'Forbidden. Access denied - endpoint only accessible from same server (localhost/private IPs).',
@@ -111,7 +120,7 @@ async function ensureIndexTemplate() {
           mappings: {
             properties: {
             '@timestamp': { type: 'date' },
-              level: { type: 'keyword' },
+              level: { type: 'text', fields: { keyword: { type: 'keyword' } } },
               message: { type: 'text' },
               service: {
                 properties: {
@@ -162,21 +171,40 @@ function escapeForSQLite(str) {
   return str.replace(/'/g, "''").replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r')
 }
 
+function runSqlite(sql) {
+  const dbPath = process.env.GRAFANA_SQLITE_PATH || '/var/lib/grafana/grafana.db'
+  const grafanaContainer = process.env.GRAFANA_DOCKER_CONTAINER || 'azify-grafana'
+  const { execSync } = require('child_process')
+  const localDbExists = fs.existsSync(dbPath)
+  const escapedForLocal = sql.replace(/"/g, '""')
+  const escapedForDocker = sql.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$')
+
+  const command = localDbExists
+    ? `sqlite3 ${dbPath} "${escapedForLocal}"`
+    : `docker exec ${grafanaContainer} sh -c "sqlite3 ${dbPath} \\"${escapedForDocker}\\""`;
+
+  try {
+    if (!localDbExists) {
+      console.log(`[runSqlite] Executando comando via docker exec no container ${grafanaContainer}`)
+    }
+    return execSync(command, { encoding: 'utf8' }).trim()
+  } catch (error) {
+    const stderr = error.stderr?.toString()?.trim()
+    throw new Error(stderr || error.message)
+  }
+}
+
 async function createOrgViaSQLite(appName) {
   const dbPath = '/var/lib/grafana/grafana.db'
 
   try {
     console.log(`[createOrgViaSQLite] Verificando database em ${dbPath}...`)
     if (!fs.existsSync(dbPath)) {
-      console.error(`[createOrgViaSQLite] ❌ Database não encontrado em ${dbPath}`)
-      throw new Error(`Database não encontrado em ${dbPath}`)
+      console.log(`[createOrgViaSQLite] Banco não acessível localmente; tentando via docker exec`)
     }
-    
-    const { execSync } = require('child_process')
-    
+
     console.log(`[createOrgViaSQLite] Verificando se Organization '${appName}' já existe...`)
-    const checkCmd = `sqlite3 ${dbPath} "SELECT id FROM org WHERE name='${appName}';" 2>/dev/null || echo ""`
-    const existingId = execSync(checkCmd, { encoding: 'utf8' }).trim()
+    const existingId = runSqlite(`SELECT id FROM org WHERE name='${appName}';`)
     
     if (existingId && existingId !== '') {
       console.log(`[createOrgViaSQLite] ✅ Organization '${appName}' já existe (ID: ${existingId})`)
@@ -184,8 +212,7 @@ async function createOrgViaSQLite(appName) {
     }
     
     console.log(`[createOrgViaSQLite] Criando Organization '${appName}'...`)
-    const createCmd = `sqlite3 ${dbPath} "INSERT INTO org (name, version, created, updated) VALUES ('${appName}', 1, datetime('now'), datetime('now')); SELECT id FROM org WHERE name='${appName}';" 2>/dev/null`
-    const newId = execSync(createCmd, { encoding: 'utf8' }).trim()
+    const newId = runSqlite(`INSERT INTO org (name, version, created, updated) VALUES ('${appName}', 1, datetime('now'), datetime('now')); SELECT id FROM org WHERE name='${appName}';`)
     
     if (newId && newId !== '') {
       console.log(`[createOrgViaSQLite] ✅ Organization '${appName}' criada com sucesso (ID: ${newId})`)
@@ -201,10 +228,14 @@ async function createOrgViaSQLite(appName) {
 }
 
 async function setupGrafanaForApp(appName) {
-  const grafanaUrl = process.env.GRAFANA_URL || 'http://azify-grafana:3000'
+  const runningInDocker = fs.existsSync('/.dockerenv')
+  const defaultGrafanaUrl = runningInDocker ? 'http://azify-grafana:3000' : 'http://127.0.0.1:3002'
+  const grafanaUrl = process.env.GRAFANA_URL || defaultGrafanaUrl
   const grafanaAdminUser = process.env.GRAFANA_ADMIN_USER || 'admin'
   const grafanaAdminPassword = process.env.GRAFANA_ADMIN_PASSWORD || process.env.GF_SECURITY_ADMIN_PASSWORD || 'admin'
-  const opensearchUrl = process.env.OPENSEARCH_URL || 'http://azify-opensearch:9200'
+  const defaultOpensearchUrl = runningInDocker ? 'http://azify-opensearch:9200' : 'http://127.0.0.1:9200'
+  const opensearchUrl = process.env.OPENSEARCH_URL || defaultOpensearchUrl
+  const grafanaOpensearchUrl = process.env.GRAFANA_OPENSEARCH_URL || (runningInDocker ? 'http://azify-opensearch:9200' : opensearchUrl)
 
   if (!setupGrafanaForApp._cache) {
     setupGrafanaForApp._cache = new Set()
@@ -252,11 +283,11 @@ async function setupGrafanaForApp(appName) {
             org = await createOrgViaSQLite(appName)
             if (!org) {
               console.error(`[setupGrafana] ❌ Não foi possível criar Organization via SQLite para ${appName}`)
-              return
+              throw new Error(`SQLite não criou organization para ${appName}`)
             }
           } catch (sqliteError) {
             console.error(`[setupGrafana] ❌ Erro ao criar Organization via SQLite: ${sqliteError.message}`)
-            return
+            throw sqliteError
           }
         }
       } else {
@@ -266,18 +297,18 @@ async function setupGrafanaForApp(appName) {
           org = await createOrgViaSQLite(appName)
           if (!org) {
             console.error(`[setupGrafana] ❌ Não foi possível criar Organization via SQLite para ${appName}`)
-            return
+            throw new Error(`SQLite não criou organization para ${appName}`)
           }
         } catch (sqliteError) {
           console.error(`[setupGrafana] ❌ Erro ao criar Organization via SQLite: ${sqliteError.message}`)
-          return
+          throw sqliteError
         }
       }
     }
 
     if (!org) {
       console.error(`[setupGrafana] ❌ Organization não encontrada/criada para ${appName}`)
-      return
+      throw new Error(`Organization não encontrada ou criada para ${appName}`)
     }
     
     console.log(`[setupGrafana] ✅ Organization encontrada/criada: ${org.name} (ID: ${org.id})`)
@@ -330,20 +361,21 @@ async function setupGrafanaForApp(appName) {
           }
         } catch (userError) {
           const dbUserId = await new Promise((resolve) => {
-            const { execSync } = require('child_process')
             try {
-              const result = execSync(`sqlite3 /var/lib/grafana/grafana.db "SELECT id FROM user WHERE email='${trimmedEmail}';"`, { encoding: 'utf8' }).trim()
+              const result = runSqlite(`SELECT id FROM user WHERE email='${trimmedEmail}';`)
               resolve(result || null)
-            } catch {
+            } catch (err) {
+              console.error(`[setupGrafana] ❌ Falha ao buscar usuário ${trimmedEmail} via SQLite: ${err.message}`)
               resolve(null)
             }
           })
           
           if (dbUserId) {
-            const { execSync } = require('child_process')
             try {
-              execSync(`sqlite3 /var/lib/grafana/grafana.db "INSERT OR IGNORE INTO org_user (org_id, user_id, role, created, updated) VALUES (${org.id}, ${dbUserId}, 'Admin', datetime('now'), datetime('now')); UPDATE org_user SET role='Admin' WHERE org_id=${org.id} AND user_id=${dbUserId};"`, { encoding: 'utf8' })
-            } catch {
+              runSqlite(`INSERT OR IGNORE INTO org_user (org_id, user_id, role, created, updated) VALUES (${org.id}, ${dbUserId}, 'Admin', datetime('now'), datetime('now')); UPDATE org_user SET role='Admin' WHERE org_id=${org.id} AND user_id=${dbUserId};`)
+            } catch (fallbackError) {
+              console.error(`[setupGrafana] ❌ Falha ao promover ${trimmedEmail} via SQLite: ${fallbackError.message}`)
+              throw fallbackError
             }
           }
         }
@@ -357,7 +389,7 @@ async function setupGrafanaForApp(appName) {
       name: `OpenSearch-${appName}`,
       type: 'grafana-opensearch-datasource',
       access: 'proxy',
-      url: opensearchUrl,
+      url: grafanaOpensearchUrl,
       uid: datasourceUid,
       isDefault: true,
       jsonData: {
@@ -367,7 +399,7 @@ async function setupGrafanaForApp(appName) {
         esVersion: '2.11.1',
         version: '2.11.1',
         logMessageField: 'message',
-        logLevelField: 'level',
+        logLevelField: 'level.keyword',
         maxConcurrentShardRequests: 5,
         includeFrozen: false,
         xpack: false,
@@ -416,25 +448,16 @@ async function setupGrafanaForApp(appName) {
           if (createError.response?.status === 401) {
             console.log(`[setupGrafana] 🔄 Tentando criar datasource via SQLite...`)
             try {
-              const { execSync } = require('child_process')
               const dsJson = JSON.stringify(datasourceConfig.jsonData)
               const dsName = escapeForSQLite(datasourceConfig.name)
-              const opensearchUrlEscaped = escapeForSQLite(opensearchUrl)
+              const opensearchUrlEscaped = escapeForSQLite(grafanaOpensearchUrl)
               const dsUidEscaped = escapeForSQLite(datasourceUid)
               const jsonEscaped = dsJson.replace(/'/g, "''")
-              const tempFile = `/tmp/ds_${org.id}_${Date.now()}.sql`
-              const sql = `INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0); SELECT last_insert_rowid();`
-              fs.writeFileSync(tempFile, sql)
-              const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
-              const dsId = execSync(cmd, { encoding: 'utf8' }).trim()
-              fs.unlinkSync(tempFile)
+              runSqlite(`INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0);`)
+              const dsId = runSqlite('SELECT last_insert_rowid();')
               console.log(`[setupGrafana] ✅ Datasource criado via SQLite: ${datasourceUid} (ID: ${dsId})`)
             } catch (sqliteError) {
               console.error(`[setupGrafana] ❌ Erro ao criar datasource via SQLite: ${sqliteError.message}`)
-              try { 
-                const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('ds_'))
-                tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
-              } catch {}
             }
           }
         }
@@ -443,25 +466,16 @@ async function setupGrafanaForApp(appName) {
         if (error.response?.status === 401) {
           console.log(`[setupGrafana] 🔄 Tentando criar datasource via SQLite (erro 401 na verificação)...`)
           try {
-            const { execSync } = require('child_process')
             const dsJson = JSON.stringify(datasourceConfig.jsonData)
             const dsName = escapeForSQLite(datasourceConfig.name)
-            const opensearchUrlEscaped = escapeForSQLite(opensearchUrl)
+            const opensearchUrlEscaped = escapeForSQLite(grafanaOpensearchUrl)
             const dsUidEscaped = escapeForSQLite(datasourceUid)
             const jsonEscaped = dsJson.replace(/'/g, "''")
-            const tempFile = `/tmp/ds2_${org.id}_${Date.now()}.sql`
-            const sql = `INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0); SELECT last_insert_rowid();`
-            fs.writeFileSync(tempFile, sql)
-            const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
-            const dsId = execSync(cmd, { encoding: 'utf8' }).trim()
-            fs.unlinkSync(tempFile)
+            runSqlite(`INSERT INTO data_source (org_id, version, type, name, access, url, is_default, json_data, uid, created, updated, basic_auth, with_credentials) VALUES (${org.id}, 1, 'grafana-opensearch-datasource', '${dsName}', 'proxy', '${opensearchUrlEscaped}', ${datasourceConfig.isDefault ? 1 : 0}, '${jsonEscaped}', '${dsUidEscaped}', datetime('now'), datetime('now'), 0, 0);`)
+            const dsId = runSqlite('SELECT last_insert_rowid();')
             console.log(`[setupGrafana] ✅ Datasource criado via SQLite: ${datasourceUid} (ID: ${dsId})`)
           } catch (sqliteError) {
             console.error(`[setupGrafana] ❌ Erro ao criar datasource via SQLite: ${sqliteError.message}`)
-            try { 
-              const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('ds'))
-              tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
-            } catch {}
           }
         }
       }
@@ -491,7 +505,7 @@ async function setupGrafanaForApp(appName) {
               datasource: { uid: datasourceUid, type: 'grafana-opensearch-datasource' },
               targets: [{
                 refId: 'A',
-                query: `message:"[REQUEST]" AND NOT message:"[RESPONSE]" AND ${indexFilter}`,
+                query: `message:"[RESPONSE]" AND ${indexFilter}`,
                 bucketAggs: [{
                   id: '2',
                   type: 'date_histogram',
@@ -711,7 +725,6 @@ async function setupGrafanaForApp(appName) {
       if (error.response?.status === 401 && typeof dashboardConfig !== 'undefined' && dashboardConfig && dashboardConfig.dashboard) {
         console.log(`[setupGrafana] 🔄 Tentando criar dashboard via SQLite...`)
         try {
-          const { execSync } = require('child_process')
           const dashboardUid = `dashboard-${appName.toLowerCase()}`
           const dashboardTitle = `Application Health - ${appName}`
           const dashboardJson = JSON.stringify(dashboardConfig.dashboard)
@@ -720,19 +733,11 @@ async function setupGrafanaForApp(appName) {
           const slug = dashboardTitle.toLowerCase().replace(/[^a-z0-9-]/g, '-')
           const slugEscaped = escapeForSQLite(slug)
           const uidEscaped = escapeForSQLite(dashboardUid)
-          const tempFile = `/tmp/dash_${org.id}_${Date.now()}.sql`
-          const sql = `INSERT INTO dashboard (org_id, version, slug, title, data, created, updated, uid, is_folder, folder_id) VALUES (${org.id}, 0, '${slugEscaped}', '${escapedTitle}', '${escapedJson}', datetime('now'), datetime('now'), '${uidEscaped}', 0, 0); SELECT last_insert_rowid();`
-          fs.writeFileSync(tempFile, sql)
-          const cmd = `sqlite3 /var/lib/grafana/grafana.db < ${tempFile}`
-          const dashboardId = execSync(cmd, { encoding: 'utf8' }).trim()
-          fs.unlinkSync(tempFile)
+          runSqlite(`INSERT INTO dashboard (org_id, version, slug, title, data, created, updated, uid, is_folder, folder_id) VALUES (${org.id}, 0, '${slugEscaped}', '${escapedTitle}', '${escapedJson}', datetime('now'), datetime('now'), '${uidEscaped}', 0, 0);`)
+          const dashboardId = runSqlite('SELECT last_insert_rowid();')
           console.log(`[setupGrafana] ✅ Dashboard criado via SQLite: ${dashboardTitle} (ID: ${dashboardId})`)
         } catch (sqliteError) {
           console.error(`[setupGrafana] ❌ Erro ao criar dashboard via SQLite: ${sqliteError.message}`)
-          try { 
-            const tempFiles = fs.readdirSync('/tmp').filter(f => f.startsWith('dash_'))
-            tempFiles.forEach(f => { try { fs.unlinkSync(`/tmp/${f}`) } catch {} })
-          } catch {}
         }
       } else {
         console.error(`[setupGrafana] ⚠️  Não foi possível criar dashboard via SQLite: dashboardConfig não disponível`)
@@ -932,7 +937,7 @@ async function handleLog(req, res) {
       version: (meta && meta.service && meta.service.version) || '1.0.0'
     },
     appName: (meta && meta.appName) || (meta && meta.service && meta.service.name) || undefined,
-    environment: (meta && meta.environment) || process.env.NODE_ENV || 'development',
+    environment: (meta && meta.environment) || process.env.NODE_ENV,
     hostname: (meta && meta.hostname) || os.hostname(),
     traceId: traceContext.traceId,
     spanId: traceContext.spanId,
@@ -952,22 +957,91 @@ async function handleLog(req, res) {
           }
         }
         
-        if (key === 'responseBody') {
-          if (typeof value === 'object' && value !== null) {
-            try {
-              value = JSON.stringify(value)
-            } catch (e) {
-              return
+        const truncateBody = (bodyValue, forResponse = false) => {
+          if (forResponse) {
+            if (typeof bodyValue === 'string') {
+              return bodyValue
+            } else if (Buffer.isBuffer(bodyValue)) {
+              return bodyValue.toString('utf8')
+            } else if (typeof bodyValue === 'object' && bodyValue !== null) {
+              try {
+                return JSON.stringify(bodyValue)
+              } catch (_) {
+                return String(bodyValue)
+              }
             }
-          } else if (typeof value === 'string' && value.length > 10000) {
-            value = value.substring(0, 10000) + '... [truncated]'
+            return String(bodyValue)
           }
-          if (typeof value === 'object' && value !== null) {
-            return
+          
+          if (typeof bodyValue === 'string') {
+            if (bodyValue.trim().startsWith('{') || bodyValue.trim().startsWith('[')) {
+              try {
+                let parsed = JSON.parse(bodyValue)
+                if (typeof parsed === 'object') {
+                  return parsed
+                }
+              } catch (_) { }
+            }
+            return bodyValue
+          } else if (typeof bodyValue === 'object' && bodyValue !== null) {
+            return bodyValue
+          } else if (Buffer.isBuffer(bodyValue)) {
+            try {
+              let str = bodyValue.toString('utf8')
+              if (str.trim().startsWith('{') || str.trim().startsWith('[')) {
+                try {
+                  return JSON.parse(str)
+                } catch (_) {
+                  return str
+                }
+              }
+              return str
+            } catch (_) {
+              return '[Unable to serialize Buffer]'
+            }
           }
+          return bodyValue
         }
         
-        logEntry[key] = value
+        if (key === 'request' && value && typeof value === 'object' && value.body !== undefined) {
+          const processedBody = truncateBody(value.body, false)
+          if (typeof processedBody === 'string' && processedBody.length > 5000) {
+            logEntry.requestBody = processedBody
+            delete value.body
+          } else {
+            value.body = processedBody
+          }
+        } else if (key === 'response' && value && typeof value === 'object') {
+          if (value.statusCode != null) {
+            logEntry.statusCode = value.statusCode
+          }
+          if (value.durationMs != null) {
+            logEntry.responseTime = value.durationMs
+          }
+          if (value.body !== undefined) {
+            const processedBody = truncateBody(value.body, true)
+            let bodyString
+            if (typeof processedBody === 'string') {
+              bodyString = processedBody
+            } else {
+              bodyString = JSON.stringify(processedBody)
+            }
+            logEntry.responseBody = bodyString
+            const { body, ...responseWithoutBody } = value
+            logEntry[key] = responseWithoutBody
+          } else {
+            logEntry[key] = value
+          }
+        } else if (key === 'responseBody' || key === 'requestBody') {
+          if (key === 'responseBody') {
+            value = truncateBody(value, true)
+          } else {
+            value = truncateBody(value, false)
+          }
+          logEntry[key] = value
+        } else {
+          logEntry[key] = value
+        }
       }
     })
   }
@@ -1004,6 +1078,27 @@ async function handleLog(req, res) {
     
     res.json({ success: true, message: 'Log enviado com sucesso', index: indexName })
   } catch (error) {
+    const status = error?.response?.status
+    const errorMsg = error?.response?.data?.error?.reason ||
+      error?.response?.data?.message ||
+      error?.message ||
+      'Erro desconhecido'
+
+    console.error('❌ Falha ao enviar log para OpenSearch', {
+      status,
+      message: errorMsg
+    })
+
+    if (error?.response?.data) {
+      try {
+        console.error('📦 Resposta OpenSearch:', JSON.stringify(error.response.data).substring(0, 2000))
+      } catch (_) {
+        console.error('📦 Resposta OpenSearch (raw):', error.response.data)
+      }
+    } else if (error?.code) {
+      console.error('⚙️  Código de erro:', error.code)
+    }
+
     res.status(500).json({ success: false, message: 'Erro ao enviar log para OpenSearch' })
   }
 }

package/store.js

@@ -2,8 +2,14 @@ const { AsyncLocalStorage } = require('async_hooks')
 
 const als = new AsyncLocalStorage()
 
-function generateId(bytes = 16) {
-  return require('crypto').randomBytes(bytes).toString('hex')
+function fastGenerateId(length = 16) {
+  const chars = '0123456789abcdef'
+  let result = ''
+  const totalChars = length * 2
+  for (let i = 0; i < totalChars; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)]
+  }
+  return result
 }
 
 function toTraceId(hex32) {
@@ -12,8 +18,8 @@ function toTraceId(hex32) {
 }
 
 function startRequestContext(initial = {}) {
-  const traceHex = initial.traceHex || generateId(16)
-  const spanHex = initial.spanHex || generateId(8)
+  const traceHex = initial.traceHex || fastGenerateId(16)
+  const spanHex = initial.spanHex || fastGenerateId(8)
   const ctx = {
     traceId: toTraceId(traceHex),
     spanId: spanHex,

package/streams/bunyan.d.ts

@@ -1,9 +1,35 @@
 import { Writable } 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 BunyanStreamOptions {
   loggerUrl?: string;
   serviceName?: string;
   environment?: string;
+  transportOptions?: HttpTransportOptions;
+  timeout?: number;
+  maxQueueSize?: number;
+  batchSize?: number;
+  flushInterval?: number;
+  maxSockets?: number;
+  failureThreshold?: number;
+  failureCooldown?: number;
+  redisUrl?: string;
+  redisQueueKey?: string;
+  redisMaxQueueLen?: number;
+  redisWorker?: boolean;
 }
 
 /**

package/streams/bunyan.js

@@ -1,12 +1,12 @@
-const { AsyncLocalStorage } = require('async_hooks')
-const axios = require('axios')
-
-const globalContext = new Map()
+const { createHttpLoggerTransport } = require('./httpQueue')
+const { shouldSample, markSource } = require('../sampling')
 
 function createBunyanStream(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(record) {
@@ -52,11 +52,42 @@ function createBunyanStream(options = {}) {
         ...(spanId && { spanId })
       }
 
+      markSource(meta, 'logger')
+
+      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 = createBunyanStream
+
+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
+}