azify-logger 1.0.44 → 1.0.46

package/sampling.js

@@ -45,7 +45,7 @@ const sourceSampleRates = {
 }
 
 const shouldSample = (level, source) => {
-  if (source === 'http-client') {
+  if (source === 'http-client' || source === 'pino-stdout') {
     return true
   }
   const key = typeof level === 'string' ? level.toLowerCase() : 'info'

package/server.js

@@ -227,6 +227,7 @@ async function ensureIndexTemplate() {
               userAgent: { type: 'text' },
               environment: { type: 'keyword' },
               hostname: { type: 'keyword' },
+              source: { type: 'keyword' },
               responseBody: { type: 'text' },
               error: {
                 properties: {
@@ -238,7 +239,7 @@ async function ensureIndexTemplate() {
             }
           }
       },
-      priority: 500
+      priority: 1000
     })
   } catch (error) {
   }
@@ -1696,14 +1697,14 @@ async function registerAlertRulesForApp(appName, rules, options = {}) {
 }
 
 function generateTraceId() {
-  return Math.random().toString(36).substring(2, 15) +
-         Math.random().toString(36).substring(2, 15)
+  return require('crypto').randomBytes(16).toString('hex')
 }
 
 function generateSpanId() {
-  return Math.random().toString(36).substring(2, 15)
+  return require('crypto').randomBytes(8).toString('hex')
 }
 
+
 function getOrCreateTraceContext(requestId) {
   if (traceContextMap.has(requestId)) {
     return traceContextMap.get(requestId)
@@ -1836,21 +1837,55 @@ async function handleLog(req, res) {
     ))
   )
 
-  if (shouldFilterLog) {
+  const isRequestOrResponse = messageLower.includes('[request]') || messageLower.includes('[response]')
+  const isAzifyHttpClientLog = (meta && meta.source === 'http-client') || isRequestOrResponse
+  if (!isAzifyHttpClientLog && shouldFilterLog) {
     return res.json({ success: true, message: 'Log filtrado' })
   }
+  if (isRequestOrResponse && process.env.AZIFY_LOGGER_DEBUG === '1') {
+    console.log('[azify-logger][server] REQUEST/RESPONSE received:', (typeof message === 'string' ? message : '').slice(0, 80))
+  }
+  if (isRequestOrResponse && meta && typeof meta === 'object' && meta.source !== 'http-client') {
+    meta = { ...meta, source: 'http-client' }
+  }
 
   const requestId = meta && meta.requestId
 
+  function toTraceIdHex32(val) {
+    if (val == null || typeof val !== 'string') return null
+    const hex = String(val).replace(/[^0-9a-fA-F]/g, '').slice(0, 32)
+    return hex ? hex.padStart(32, '0').slice(0, 32) : null
+  }
+
   let traceContext = null
 
-  if (meta && meta.traceId && meta.spanId) {
-    traceContext = {
-      traceId: meta.traceId,
-      spanId: meta.spanId,
-      parentSpanId: meta.parentSpanId || null
+  if (meta && meta.traceId) {
+    const tid = toTraceIdHex32(meta.traceId)
+    if (tid) {
+      traceContext = {
+        traceId: tid,
+        spanId: meta.spanId != null && meta.spanId !== '' ? String(meta.spanId).slice(0, 16) : generateSpanId(),
+        parentSpanId: meta.parentSpanId != null && meta.parentSpanId !== '' ? String(meta.parentSpanId) : null
+      }
     }
-  } else {
+  }
+
+  if (!traceContext && typeof message === 'string' && /traceId/i.test(message)) {
+    const m = message.match(/"traceId"\s*:\s*"([^"]+)"/)
+    const s = message.match(/"spanId"\s*:\s*"([^"]+)"/)
+    if (m && m[1]) {
+      const tid = toTraceIdHex32(m[1])
+      if (tid) {
+        traceContext = {
+          traceId: tid,
+          spanId: (s && s[1]) ? String(s[1]).slice(0, 16) : generateSpanId(),
+          parentSpanId: null
+        }
+      }
+    }
+  }
+
+  if (!traceContext) {
     try {
       const extractedCtx = propagation.extract(context.active(), req.headers, {
         get (carrier, key) {
@@ -1867,8 +1902,8 @@ async function handleLog(req, res) {
       const spanContext = (span && span.spanContext && span.spanContext()) || null
       if (spanContext && spanContext.traceId && spanContext.spanId) {
         traceContext = {
-          traceId: spanContext.traceId,
-          spanId: spanContext.spanId,
+          traceId: toTraceIdHex32(spanContext.traceId) || String(spanContext.traceId).replace(/-/g, '').padStart(32, '0').slice(0, 32),
+          spanId: String(spanContext.spanId).slice(0, 16),
           parentSpanId: null
         }
       }
@@ -1991,6 +2026,16 @@ async function handleLog(req, res) {
             value = truncateBody(value, false)
           }
           logEntry[key] = value
+        } else if (key === 'error') {
+          if (value != null && typeof value === 'object' && !Array.isArray(value) && (value.message != null || value.stack != null || value.name != null)) {
+            logEntry.error = {
+              message: value.message != null ? String(value.message) : '',
+              stack: value.stack != null ? String(value.stack) : undefined,
+              name: value.name != null ? String(value.name) : undefined
+            }
+          } else if (value != null) {
+            logEntry.error = { message: String(value) }
+          }
         } else {
           logEntry[key] = value
         }
@@ -1999,6 +2044,7 @@ async function handleLog(req, res) {
   }
 
   logEntry.message = message
+  if (isRequestOrResponse) logEntry.source = 'http-client'
 
   const osUrl = process.env.OPENSEARCH_URL || 'http://localhost:9200'
   const appName = logEntry.appName || logEntry.service?.name || 'unknown'
@@ -2008,7 +2054,57 @@ async function handleLog(req, res) {
 
   res.json({ success: true, message: 'Log enviado com sucesso', index: indexName })
 
-  _enqueueOpenSearchWrite(osUrl, indexName, logEntry, serviceName)
+  const docToSend = _trimLogEntryForOpenSearch(logEntry)
+  _enqueueOpenSearchWrite(osUrl, indexName, docToSend, serviceName)
+}
+
+const _opensearchMaxFields = Math.min(Number(process.env.AZIFY_LOGGER_OPENSEARCH_MAX_FIELDS) || 0, 2000) || 900
+
+function _countFields(obj, depth = 0) {
+  if (depth > 15) return 0
+  if (obj == null || typeof obj !== 'object') return 1
+  let n = 0
+  for (const key of Object.keys(obj)) {
+    const v = obj[key]
+    if (v != null && typeof v === 'object' && !Array.isArray(v) && !Buffer.isBuffer(v)) n += _countFields(v, depth + 1)
+    else n += 1
+  }
+  return n
+}
+
+function _stringifyValue(value) {
+  try {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value)
+  } catch (_) {
+    return '[Unable to serialize]'
+  }
+}
+
+function _trimLogEntryForOpenSearch(doc) {
+  if (_countFields(doc) <= _opensearchMaxFields) return doc
+  const out = {}
+  for (const key of Object.keys(doc)) {
+    const value = doc[key]
+    if (value != null && typeof value === 'object' && !Array.isArray(value) && !Buffer.isBuffer(value)) {
+      if (_countFields(value) > 80) {
+        out[key + 'Json'] = _stringifyValue(value)
+      } else {
+        out[key] = value
+      }
+    } else {
+      out[key] = value
+    }
+  }
+  if (_countFields(out) > _opensearchMaxFields) {
+    for (const k of Object.keys(out)) {
+      const v = out[k]
+      if (v != null && typeof v === 'object' && !Array.isArray(v) && !Buffer.isBuffer(v)) {
+        out[k + 'Json'] = _stringifyValue(v)
+        delete out[k]
+      }
+    }
+  }
+  return out
 }
 
 const _openSearchWriteQueue = []
@@ -2026,14 +2122,82 @@ const _logDedupeWindowMs = 5000
 const _logDedupeMaxKeys = 15000
 const _logDedupeSeen = new Map()
 const _logDedupeBucketMs = 80
+const _logDedupeGenericBucketMs = 250
+
+function _normalizeReqResMessageForDedupe(msg) {
+  const s = typeof msg === 'string' ? msg : String(msg || '')
+  return s.replace(/\s+\d+(\.\d+)?ms\s*$/i, '').trimEnd()
+}
+
+function _httpClientDedupeFingerprint(logEntry) {
+  if (!logEntry || logEntry.source !== 'http-client') return null
+  const msg = typeof logEntry.message === 'string' ? logEntry.message.substring(0, 500) : String(logEntry.message || '')
+  const msgLower = msg.trimStart().toLowerCase()
+  const isReq = msgLower.startsWith('[request]')
+  const isRes = msgLower.startsWith('[response]')
+  if (!isReq && !isRes) return null
+
+  const methodRaw =
+    (logEntry.method != null && String(logEntry.method).trim()) ||
+    (logEntry.request && logEntry.request.method != null && String(logEntry.request.method).trim()) ||
+    ''
+  const m = methodRaw.toUpperCase()
+  let url = ''
+  if (logEntry.url != null && String(logEntry.url).trim()) {
+    url = String(logEntry.url).trim()
+  } else if (logEntry.request && typeof logEntry.request === 'object') {
+    url = String(logEntry.request.url || logEntry.request.path || '').trim()
+  }
+  if (!m || !url) return null
+
+  if (isReq) {
+    return `REQUEST|${m}|${url}`
+  }
+  let st = logEntry.statusCode != null ? String(logEntry.statusCode).trim() : ''
+  if (!st && /\bERROR\b/i.test(msg)) {
+    st = 'ERR'
+  }
+  if (!st) {
+    const mStatus = msg.match(/\s(\d{3})\s+(?:\d+(?:\.\d+)?ms\s*)?$/i)
+    if (mStatus) st = mStatus[1]
+  }
+  return `RESPONSE|${m}|${url}|${st || 'na'}`
+}
 
 function _logDedupeKey(serviceName, logEntry) {
   const msg = typeof logEntry.message === 'string' ? logEntry.message.substring(0, 500) : String(logEntry.message || '')
+  const msgLower = msg.trimStart().toLowerCase()
+  const isReqRes = msgLower.includes('[request]') || msgLower.includes('[response]')
   const traceId = logEntry.traceId != null ? String(logEntry.traceId).trim() : ''
   const spanId = logEntry.spanId != null ? String(logEntry.spanId).trim() : ''
+  const msgNorm = _normalizeReqResMessageForDedupe(msg)
+  const msgSig = msgNorm.length > 200 ? msgNorm.slice(0, 200) : msgNorm
+  if (isReqRes) {
+    const kind = msgLower.startsWith('[request]')
+      ? 'REQUEST'
+      : msgLower.startsWith('[response]')
+        ? 'RESPONSE'
+        : (msgLower.includes('[request]') ? 'REQUEST' : 'RESPONSE')
+    const httpFp = _httpClientDedupeFingerprint(logEntry)
+    if (httpFp) {
+      if (traceId) return `rh|${serviceName}|${traceId}|${httpFp}`
+      const requestId = (logEntry.requestId != null ? String(logEntry.requestId).trim() : '') || ''
+      if (requestId) return `rh|${serviceName}|${requestId}|${httpFp}`
+      return null
+    }
+    if (traceId && spanId) return `r|${serviceName}|${traceId}|${spanId}|${kind}|${msgSig}`
+    const ts = logEntry['@timestamp'] != null ? Number(logEntry['@timestamp']) : Date.now()
+    const bucket = Math.floor(ts / _logDedupeBucketMs) * _logDedupeBucketMs
+    return `r|${serviceName}|${bucket}|${kind}|${msgSig}`
+  }
   if (traceId && spanId) return `t|${serviceName}|${traceId}|${spanId}|${msg}`
   const requestId = (logEntry.requestId != null ? String(logEntry.requestId).trim() : '') || ''
-  if (!requestId) return null
+  if (!requestId) {
+    const ts = logEntry['@timestamp'] != null ? Number(logEntry['@timestamp']) : Date.now()
+    const bucket = Math.floor(ts / _logDedupeGenericBucketMs) * _logDedupeGenericBucketMs
+    const msgSig = msg.length > 200 ? msg.slice(0, 200) : msg
+    return `g|${serviceName}|${bucket}|${msgSig}`
+  }
   const ts = logEntry['@timestamp'] != null ? Number(logEntry['@timestamp']) : Date.now()
   const bucket = Math.floor(ts / _logDedupeBucketMs) * _logDedupeBucketMs
   return `b|${serviceName}|${requestId}|${msg}|${bucket}`
@@ -2059,6 +2223,12 @@ function _enqueueOpenSearchWrite(osUrl, indexName, logEntry, serviceName) {
     if (expiry != null && expiry > now) return
     _logDedupeSeen.set(key, now + _logDedupeWindowMs)
   }
+  if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+    const msg = typeof logEntry.message === 'string' ? logEntry.message : ''
+    if (msg.toLowerCase().includes('[request]') || msg.toLowerCase().includes('[response]')) {
+      console.log('[azify-logger][server] REQUEST/RESPONSE enqueued for OpenSearch:', msg.slice(0, 70))
+    }
+  }
   _openSearchWriteQueue.push({ osUrl, indexName, logEntry, serviceName })
   _drainOpenSearchQueue()
 }
@@ -2081,11 +2251,17 @@ function _drainOpenSearchQueue() {
     })
       .then(() => {
         _openSearchFailuresInRow = 0
+        if (process.env.AZIFY_LOGGER_DEBUG === '1') {
+          const msg = typeof job.logEntry.message === 'string' ? job.logEntry.message : ''
+          if (msg.toLowerCase().includes('[request]') || msg.toLowerCase().includes('[response]')) {
+            console.log('[azify-logger][server] REQUEST/RESPONSE written to OpenSearch index=', job.indexName, 'msg=', msg.slice(0, 60))
+          }
+        }
         const SETUP_THROTTLE_MS = 10 * 60 * 1000
         if (!handleLog._lastSetupTime) handleLog._lastSetupTime = new Map()
         const last = handleLog._lastSetupTime.get(job.serviceName) || 0
         const now = Date.now()
-        const shouldRunSetup = job.serviceName !== 'unknown' && job.serviceName !== 'unknown-service' && (now - last >= SETUP_THROTTLE_MS)
+        const shouldRunSetup = job.serviceName !== 'unknown' && job.serviceName !== 'unknown-service' && job.serviceName !== 'unknown-app' && (now - last >= SETUP_THROTTLE_MS)
         if (shouldRunSetup) {
           handleLog._lastSetupTime.set(job.serviceName, now)
           setupGrafanaForApp(job.serviceName).then(() => {

package/store.d.ts

@@ -0,0 +1,68 @@
+export type AzifyRequestContext = {
+  traceId: string
+  spanId: string
+  parentSpanId: string | null
+  requestId: string | null
+}
+
+export type AzifyJobTraceRecord = {
+  traceId: string
+  spanId?: string | null
+  parentSpanId?: string | null
+  requestId?: string | null
+}
+
+export declare const AZIFY_JOB_TRACE_FIELD: '__azifyTraceContext'
+
+export function prepareBullJobTraceContext(data: unknown): {
+  cleanedForLog: unknown
+  ctx: AzifyRequestContext
+  dataForDownstream: unknown
+}
+
+export function captureOriginTraceMeta(): {
+  originTraceId?: string
+  originRequestId?: string
+}
+
+export function addCurrentTraceToBullJobPayload<T>(data: T): T
+
+export function traceAttachmentForBullJob(): Record<string, unknown>
+
+export function runBullJobHandlerInTraceContext<TJob extends { data: unknown }, R>(
+  job: TJob,
+  handler: (job: TJob) => R,
+): R
+
+export function runInBullJobTraceContext<T>(
+  jobData: unknown,
+  fn: (x: {
+    ctx: AzifyRequestContext
+    cleanedForLog: unknown
+    dataForDownstream: unknown
+  }) => T,
+): T
+
+export function runNestBullJobWithTrace<TJob extends { data: unknown }, R>(
+  job: TJob,
+  fn: (x: {
+    job: TJob
+    ctx: AzifyRequestContext
+    cleanedForLog: unknown
+    dataForDownstream: unknown
+  }) => R,
+): R
+
+export function startRequestContext(
+  initial?: Record<string, unknown>,
+): AzifyRequestContext
+export function runWithRequestContext<T>(ctx: AzifyRequestContext, fn: () => T): T
+export function getRequestContext(): AzifyRequestContext | null
+export function getActiveRequestId(): string | null
+export function getLastJobContext(): AzifyRequestContext | null
+export function setLastJobContext(ctx: AzifyRequestContext | null): void
+export function mergeTraceIntoJobPayload(
+  data: unknown,
+  traceContext: AzifyJobTraceRecord | null,
+): unknown
+export function toTraceIdHex(hex32: string | null | undefined): string

package/store.js

@@ -1,6 +1,17 @@
 const { AsyncLocalStorage } = require('async_hooks')
 
+const AZIFY_JOB_TRACE_FIELD = '__azifyTraceContext'
+
 const als = new AsyncLocalStorage()
+let lastJobContext = null
+
+function setLastJobContext(ctx) {
+  lastJobContext = ctx || null
+}
+
+function getLastJobContext() {
+  return lastJobContext
+}
 
 function fastGenerateId(length = 16) {
   const chars = '0123456789abcdef'
@@ -12,21 +23,32 @@ function fastGenerateId(length = 16) {
   return result
 }
 
-function toTraceId(hex32) {
-  const h = (hex32 || '').padStart(32, '0').slice(0, 32)
-  return `${h.substring(0, 8)}-${h.substring(8, 12)}-${h.substring(12, 16)}-${h.substring(16, 20)}-${h.substring(20, 32)}`
+function newRequestIdForJob() {
+  try {
+    const { randomUUID } = require('crypto')
+    if (typeof randomUUID === 'function') {
+      return randomUUID()
+    }
+  } catch (_) {}
+  return `${fastGenerateId(16)}-${fastGenerateId(8)}`
 }
 
-function startRequestContext(initial = {}) {
+function toTraceIdHex(hex32) {
+  const raw = hex32 != null && typeof hex32 === 'string' ? String(hex32).replace(/[^0-9a-fA-F]/g, '').slice(0, 32) : ''
+  const hex = raw || fastGenerateId(16)
+  return hex.padStart(32, '0').slice(0, 32)
+}
+
+function startRequestContext(initial) {
+  if (!initial || typeof initial !== 'object') initial = {}
   const traceHex = initial.traceHex || fastGenerateId(16)
   const spanHex = initial.spanHex || fastGenerateId(8)
-  const ctx = {
-    traceId: toTraceId(traceHex),
-    spanId: spanHex,
-    parentSpanId: initial.parentSpanId || null,
-    requestId: initial.requestId
+  return {
+    traceId: toTraceIdHex(traceHex),
+    spanId: spanHex != null && spanHex !== '' ? String(spanHex).slice(0, 16) : fastGenerateId(8),
+    parentSpanId: initial.parentSpanId != null && initial.parentSpanId !== '' ? String(initial.parentSpanId) : null,
+    requestId: initial.requestId != null && initial.requestId !== '' ? String(initial.requestId) : null
   }
-  return ctx
 }
 
 function runWithRequestContext(ctx, fn) {
@@ -37,11 +59,168 @@ function getRequestContext() {
   return als.getStore() || null
 }
 
+function getActiveRequestId() {
+  const ctx = getRequestContext()
+  if (!ctx?.requestId || String(ctx.requestId) === '') return null
+  return String(ctx.requestId)
+}
+
+function captureOriginTraceMeta() {
+  try {
+    const ctx = getRequestContext() || getLastJobContext()
+    if (!ctx || typeof ctx !== 'object') return {}
+    const out = {}
+    if (ctx.traceId != null && String(ctx.traceId) !== '') {
+      out.originTraceId = String(ctx.traceId)
+    }
+    if (ctx.requestId != null && String(ctx.requestId) !== '') {
+      out.originRequestId = String(ctx.requestId)
+    }
+    return out
+  } catch (_) {
+    return {}
+  }
+}
+
+function mergeTraceIntoJobPayload(data, traceContext) {
+  if (!traceContext || !traceContext.traceId) return data
+  const base = data && typeof data === 'object' && !Array.isArray(data) ? data : {}
+  return {
+    ...base,
+    traceId: traceContext.traceId,
+    spanId: traceContext.spanId ?? null,
+    parentSpanId: traceContext.parentSpanId ?? null,
+    requestId: traceContext.requestId ?? null
+  }
+}
+
+function normalizedJobTrace(raw) {
+  if (!raw || typeof raw !== 'object' || typeof raw.traceId !== 'string') return null
+  return {
+    traceId: String(raw.traceId),
+    spanId: raw.spanId != null ? raw.spanId : null,
+    parentSpanId: raw.parentSpanId != null ? raw.parentSpanId : null,
+    requestId: raw.requestId != null && raw.requestId !== '' ? String(raw.requestId) : null
+  }
+}
+
+function alsContextFromJobTrace(trace) {
+  const fallbackRid = newRequestIdForJob()
+  if (!trace) {
+    return startRequestContext({ requestId: fallbackRid })
+  }
+  const traceHex = String(trace.traceId).replace(/[^0-9a-fA-F]/g, '').slice(0, 32)
+  const spanHex = trace.spanId
+    ? String(trace.spanId).replace(/[^0-9a-fA-F]/g, '').slice(0, 16)
+    : undefined
+  return startRequestContext({
+    traceHex: traceHex || undefined,
+    spanHex: spanHex || undefined,
+    parentSpanId: trace.parentSpanId != null && trace.parentSpanId !== '' ? String(trace.parentSpanId) : undefined,
+    requestId: trace.requestId || fallbackRid
+  })
+}
+
+function captureTraceForJobEnqueue() {
+  try {
+    const ctx = getRequestContext() || getLastJobContext()
+    if (!ctx || typeof ctx !== 'object' || ctx.traceId == null || String(ctx.traceId) === '') {
+      return null
+    }
+    return normalizedJobTrace({
+      traceId: String(ctx.traceId),
+      spanId: ctx.spanId,
+      parentSpanId: ctx.parentSpanId,
+      requestId: ctx.requestId
+    })
+  } catch (_) {
+    return null
+  }
+}
+
+function attachTraceToBullJobData(data, traceRecord) {
+  if (!traceRecord || !traceRecord.traceId) return data
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return data
+  return {
+    ...data,
+    [AZIFY_JOB_TRACE_FIELD]: traceRecord
+  }
+}
+
+function addCurrentTraceToBullJobPayload(data) {
+  const trace = captureTraceForJobEnqueue()
+  if (!trace) return data
+  return attachTraceToBullJobData(data, trace)
+}
+
+function traceAttachmentForBullJob() {
+  const trace = captureTraceForJobEnqueue()
+  if (!trace) return {}
+  return { [AZIFY_JOB_TRACE_FIELD]: trace }
+}
+
+function prepareBullJobTraceContext(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    const ctx = alsContextFromJobTrace(null)
+    return { cleanedForLog: data, ctx, dataForDownstream: data }
+  }
+  const rawTrace = data[AZIFY_JOB_TRACE_FIELD]
+  const hasKey = Object.prototype.hasOwnProperty.call(data, AZIFY_JOB_TRACE_FIELD)
+  let cleaned
+  if (hasKey) {
+    const copy = { ...data }
+    delete copy[AZIFY_JOB_TRACE_FIELD]
+    cleaned = copy
+  } else {
+    cleaned = { ...data }
+  }
+  const trace = normalizedJobTrace(rawTrace)
+  const ctx = alsContextFromJobTrace(trace)
+  const dataForDownstream = trace
+    ? { ...cleaned, [AZIFY_JOB_TRACE_FIELD]: trace }
+    : cleaned
+  return { cleanedForLog: cleaned, ctx, dataForDownstream }
+}
+
+function runBullJobHandlerInTraceContext(job, handler) {
+  const { ctx, cleanedForLog } = prepareBullJobTraceContext(job.data)
+  const nextJob =
+    cleanedForLog !== job.data ? { ...job, data: cleanedForLog } : job
+  return runWithRequestContext(ctx, () => handler(nextJob))
+}
+
+function runInBullJobTraceContext(jobData, fn) {
+  const { ctx, cleanedForLog, dataForDownstream } =
+    prepareBullJobTraceContext(jobData)
+  return runWithRequestContext(ctx, () =>
+    fn({ ctx, cleanedForLog, dataForDownstream }),
+  )
+}
+
+function runNestBullJobWithTrace(job, fn) {
+  return runInBullJobTraceContext(job.data, (bundle) =>
+    fn({ job, ...bundle }),
+  )
+}
+
 module.exports = {
   als,
+  AZIFY_JOB_TRACE_FIELD,
   startRequestContext,
   runWithRequestContext,
-  getRequestContext
+  getRequestContext,
+  getActiveRequestId,
+  getLastJobContext,
+  setLastJobContext,
+  mergeTraceIntoJobPayload,
+  prepareBullJobTraceContext,
+  runBullJobHandlerInTraceContext,
+  runInBullJobTraceContext,
+  runNestBullJobWithTrace,
+  addCurrentTraceToBullJobPayload,
+  traceAttachmentForBullJob,
+  captureOriginTraceMeta,
+  toTraceIdHex
 }