@open-mercato/shared 0.6.7-develop.6828.1.ab1620a63e → 0.6.7-develop.6842.1.8cd8a8883c

package/src/lib/logger/extension.ts

@@ -0,0 +1,59 @@
+import type { LogLevel } from './level'
+
+export type LoggerExtensionRecord = {
+  level: LogLevel
+  namespace: string
+  message: string
+  fields: Record<string, unknown>
+  time: number
+}
+
+export type LoggerExtension = {
+  /**
+   * Add process-local context (for example trace/span ids) to both the local
+   * line and the optional remote sink.
+   */
+  enrich?(): Record<string, unknown> | undefined
+  /**
+   * Observe a record after the local transport writes it. Implementations must
+   * never throw into application code.
+   */
+  emit?(record: LoggerExtensionRecord): void
+}
+
+const GLOBAL_KEY = Symbol.for('@open-mercato/shared.loggerExtension')
+
+type LoggerExtensionStore = {
+  active?: LoggerExtension
+}
+
+function store(): LoggerExtensionStore {
+  const globalStore = globalThis as unknown as Record<symbol, LoggerExtensionStore | undefined>
+  let current = globalStore[GLOBAL_KEY]
+  if (!current) {
+    current = {}
+    globalStore[GLOBAL_KEY] = current
+  }
+  return current
+}
+
+/**
+ * Register the single process-wide logger extension. The returned disposer only
+ * clears the extension when it is still the active registration.
+ */
+export function registerLoggerExtension(extension: LoggerExtension): () => void {
+  store().active = extension
+  return () => {
+    const current = store()
+    if (current.active === extension) current.active = undefined
+  }
+}
+
+export function getLoggerExtension(): LoggerExtension | undefined {
+  return store().active
+}
+
+/** Test-only: clear the process-wide extension. */
+export function resetLoggerExtension(): void {
+  store().active = undefined
+}

package/src/lib/logger/index.ts

@@ -1,9 +1,17 @@
 import { selectTransport } from './transport'
+import { getLoggerExtension } from './extension'
+import { isLevelEnabled, type LogLevel } from './level'
 
 export type { LogLevel } from './level'
 export { getLogLevel, isLevelEnabled, resetLogLevelCache, OM_LOG_LEVEL_ENV } from './level'
 export { resetServerLoggerCache, OM_LOG_DESTINATION_ENV } from './transport.server'
 export { resetLogPrettyCache, OM_LOG_PRETTY_ENV } from './transport.pretty'
+export {
+  getLoggerExtension,
+  registerLoggerExtension,
+  resetLoggerExtension,
+} from './extension'
+export type { LoggerExtension, LoggerExtensionRecord } from './extension'
 
 export type LogBindings = Record<string, unknown>
 
@@ -18,11 +26,61 @@ export interface Logger {
 
 const loggerRegistry = new Map<string, Logger>()
 
+function createExtendedLogger(
+  namespace: string,
+  transport: Logger,
+  bindings: LogBindings = {},
+): Logger {
+  const emit = (
+    level: LogLevel,
+    msg: string,
+    fields?: LogBindings,
+  ): void => {
+    if (!isLevelEnabled(level)) return
+
+    const extension = getLoggerExtension()
+    let context: LogBindings = {}
+    try {
+      context = extension?.enrich?.() ?? {}
+    } catch {
+      // Observability must never alter application behavior.
+    }
+
+    const mergedFields = { ...fields, ...context }
+    transport[level](msg, mergedFields)
+
+    try {
+      extension?.emit?.({
+        level,
+        namespace,
+        message: msg,
+        fields: { ...bindings, ...mergedFields },
+        time: Date.now(),
+      })
+    } catch {
+      // Remote logging is best-effort; the local line has already been written.
+    }
+  }
+
+  return {
+    debug: (msg, fields) => emit('debug', msg, fields),
+    info: (msg, fields) => emit('info', msg, fields),
+    warn: (msg, fields) => emit('warn', msg, fields),
+    error: (msg, fields) => emit('error', msg, fields),
+    child: (childBindings) =>
+      createExtendedLogger(
+        namespace,
+        transport.child(childBindings),
+        { ...bindings, ...childBindings },
+      ),
+  }
+}
+
 /** Create (or reuse) a namespaced logger. `namespace` is attached as `name`. */
 export function createLogger(namespace: string): Logger {
   const existing = loggerRegistry.get(namespace)
   if (existing) return existing
-  const created = selectTransport(namespace)
+  const created = createExtendedLogger(namespace, selectTransport(namespace))
   loggerRegistry.set(namespace, created)
   return created
 }

package/src/lib/modules/registry.ts

@@ -69,3 +69,13 @@ export function getModules(): Module[] {
   }
   return modules
 }
+
+/**
+ * Non-throwing counterpart of `getModules()` for call sites that have a
+ * meaningful degraded behavior when bootstrap has not run — route unit tests
+ * exercise a single handler without `registerModules()`, and a hard throw there
+ * turns an unrelated assertion into a bootstrap error.
+ */
+export function tryGetModules(): Module[] | null {
+  return getGlobalModules()
+}

package/src/lib/redis/__tests__/connection.test.ts

@@ -5,9 +5,11 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('rediss://:secret@example.cache.amazonaws.com:6379/2')).toEqual({
       host: 'example.cache.amazonaws.com',
       port: 6379,
+      username: undefined,
       password: 'secret',
       db: 2,
       tls: {},
+      family: undefined,
     })
   })
 
@@ -15,9 +17,23 @@ describe('parseRedisUrl', () => {
     expect(parseRedisUrl('redis://:secret@localhost:6379/0')).toEqual({
       host: 'localhost',
       port: 6379,
+      username: undefined,
       password: 'secret',
       db: 0,
       tls: undefined,
+      family: undefined,
+    })
+  })
+
+  it('preserves ACL credentials and supported address-family options', () => {
+    expect(parseRedisUrl('rediss://app%2Duser:p%40ss@example.com:6380/4?family=6')).toEqual({
+      host: 'example.com',
+      port: 6380,
+      username: 'app-user',
+      password: 'p@ss',
+      db: 4,
+      tls: {},
+      family: 6,
     })
   })
 })

package/src/lib/redis/connection.ts

@@ -21,9 +21,11 @@ const logger = createLogger('shared').child({ component: 'redis' })
 export type ParsedRedisConnection = {
   host: string
   port: number
+  username?: string
   password?: string
   db?: number
   tls?: Record<string, unknown>
+  family?: number
 }
 
 /**
@@ -59,12 +61,8 @@ export function getRedisUrlOrThrow(prefix?: string): string {
 }
 
 /**
- * Parse a redis:// URL into a {host, port, password, db} object
- * suitable for BullMQ / ioredis structured connection options.
- *
- * @deprecated Prefer passing the full URL via `{ url: getRedisUrl(...) }` to
- * BullMQ/ioredis — this preserves rediss://, username, database, and query
- * params that structured parsing may lose. Kept for backward compatibility.
+ * Parse a redis:// URL into structured connection options suitable for
+ * BullMQ and ioredis.
  */
 export function parseRedisUrl(url: string): ParsedRedisConnection {
   try {
@@ -72,12 +70,17 @@ export function parseRedisUrl(url: string): ParsedRedisConnection {
     const dbStr = parsed.pathname ? parsed.pathname.slice(1) : ''
     const dbParsed = dbStr !== '' ? parseInt(dbStr, 10) : NaN
     const db = Number.isNaN(dbParsed) ? undefined : dbParsed
+    const familyValue = parsed.searchParams.get('family')
+    const familyParsed = familyValue !== null ? parseInt(familyValue, 10) : NaN
+    const family = [0, 4, 6].includes(familyParsed) ? familyParsed : undefined
     return {
       host: parsed.hostname || 'localhost',
       port: parseInt(parsed.port, 10) || 6379,
-      password: parsed.password || undefined,
+      username: parsed.username ? decodeURIComponent(parsed.username) : undefined,
+      password: parsed.password ? decodeURIComponent(parsed.password) : undefined,
       db,
       tls: parsed.protocol === 'rediss:' ? {} : undefined,
+      family,
     }
   } catch {
     const safeUrl = url.replace(/\/\/[^:]*:[^@]*@/, '//<redacted>@')

package/src/lib/telemetry/runtime.ts

@@ -0,0 +1,72 @@
+export type TelemetryTraceCarrier = Record<string, string>
+
+export type TelemetryRuntime = {
+  /**
+   * True only when the active SDK may safely use the process-global W3C
+   * propagator for cross-boundary extraction.
+   */
+  canUseGlobalTracePropagation(): boolean
+  captureTraceContext(): TelemetryTraceCarrier
+  continueTrace<T>(
+    carrier: TelemetryTraceCarrier | undefined,
+    name: string,
+    fn: () => T,
+    options?: { kind?: 'internal' | 'server' | 'client' | 'producer' | 'consumer' },
+  ): T
+  recordHttpDuration(method: string, route: string, status: number, startedAt: number): void
+  reportError(
+    error: unknown,
+    context?: {
+      module?: string
+      attributes?: Record<string, string | number | boolean | undefined>
+    },
+  ): void
+  shutdown(): Promise<void>
+}
+
+const GLOBAL_KEY = Symbol.for('@open-mercato/shared.telemetryRuntime')
+const ENABLED_BACKENDS = new Set(['console', 'signoz', 'newrelic', 'otlp'])
+
+type TelemetryRuntimeStore = {
+  active?: TelemetryRuntime
+}
+
+function store(): TelemetryRuntimeStore {
+  const globalStore = globalThis as unknown as Record<symbol, TelemetryRuntimeStore | undefined>
+  let current = globalStore[GLOBAL_KEY]
+  if (!current) {
+    current = {}
+    globalStore[GLOBAL_KEY] = current
+  }
+  return current
+}
+
+/**
+ * This check is intentionally owned by shared code so hosts can decide whether
+ * to dynamically import the telemetry package without evaluating that package.
+ */
+export function isTelemetryBackendEnabled(raw?: string): boolean {
+  const value = raw ?? (
+    typeof process === 'undefined'
+      ? undefined
+      : process.env.TELEMETRY_BACKEND
+  )
+  return ENABLED_BACKENDS.has((value ?? '').trim().toLowerCase())
+}
+
+export function registerTelemetryRuntime(runtime: TelemetryRuntime): () => void {
+  store().active = runtime
+  return () => {
+    const current = store()
+    if (current.active === runtime) current.active = undefined
+  }
+}
+
+export function getTelemetryRuntime(): TelemetryRuntime | undefined {
+  return store().active
+}
+
+/** Test-only: clear the process-wide telemetry bridge. */
+export function resetTelemetryRuntime(): void {
+  store().active = undefined
+}