elasticdash-test 0.1.17 → 0.1.18-alpha

package/src/interceptors/ai-interceptor.ts

@@ -1,6 +1,8 @@
 import { getCurrentTrace } from '../trace-adapter/context.js'
 import { getCaptureContext } from '../capture/recorder.js'
 import { rawDateNow } from './side-effects.js'
+import { getObservabilityContext, getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext } from './telemetry-push.js'
+import type { WorkflowEvent } from '../capture/event.js'
 
 type UsageInfo = { inputTokens?: number; outputTokens?: number; totalTokens?: number }
 
@@ -385,9 +387,12 @@ export function installAIInterceptor(): void {
 
     const provider = detectProvider(url)
     const traceAtCall = getCurrentTrace()
+    const obsCtx = getObservabilityContext()
 
-    // No match or no active trace: pass through unchanged
-    if (!provider || !traceAtCall) {
+    const httpCtx = getHttpRunContext()
+
+    // No match or no active context: pass through unchanged
+    if (!provider || (!traceAtCall && !obsCtx && !httpCtx)) {
       return originalFetch!(input, init)
     }
 
@@ -414,7 +419,106 @@ export function installAIInterceptor(): void {
 
     const ctx = getCaptureContext()
 
-    if (ctx) {
+    // Observability-only mode: no trace handle, no capture context — record via pushTelemetryEvent
+    if (!traceAtCall && !ctx && obsCtx) {
+      const id = obsCtx.nextId()
+      const start = rawDateNow()
+      const eventInput = { url, provider, model, prompt, messages }
+
+      const response = await originalFetch!(input, init)
+
+      if (isStreaming && response.body) {
+        const [streamForCaller, streamForRecorder] = response.body.tee()
+        bufferSSEStream(provider, streamForRecorder).then((completion) => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs })
+        }).catch(() => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+        })
+        return new Response(streamForCaller, { status: response.status, statusText: response.statusText, headers: response.headers })
+      }
+
+      try {
+        const cloned = response.clone()
+        const responseBody = await cloned.json() as Record<string, unknown>
+        const completion = extractCompletion(provider, responseBody)
+        const usage = extractUsage(provider, responseBody)
+        const durationMs = rawDateNow() - start
+        const event: WorkflowEvent = {
+          id, type: 'ai', name: model, input: eventInput, output: { completion },
+          timestamp: start, durationMs,
+          ...(usage ? { usage } : {}),
+        }
+        pushTelemetryEvent(event)
+      } catch {
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, timestamp: start, durationMs })
+      }
+
+      return response
+    }
+
+    // HTTP mode (no capture context): replay frozen AI events or execute live + push telemetry
+    if (!ctx && httpCtx) {
+      const id = httpCtx.nextId()
+      const eventInput = { url, provider, model, prompt, messages }
+
+      // Replay frozen step
+      const frozen = getHttpFrozenEvent(id)
+      if (frozen && frozen.type === 'ai') {
+        pushTelemetryEvent(frozen)
+        const frozenOutput = frozen.output as Record<string, unknown> | null
+        const completion = frozenOutput ? extractCompletion(provider, frozenOutput) : '(replayed)'
+
+        if (isStreaming) {
+          return new Response(synthesizeSSEStream(provider, completion), {
+            status: 200,
+            headers: { 'Content-Type': provider === 'gemini' ? 'application/json' : 'text/event-stream' },
+          })
+        }
+
+        const body = frozenOutput?.streamed === true
+          ? synthesizeCompletionJSON(provider, completion)
+          : (frozenOutput ?? synthesizeCompletionJSON(provider, completion))
+        return new Response(JSON.stringify(body), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      // Not frozen → execute live, push telemetry
+      const start = rawDateNow()
+      const response = await originalFetch!(input, init)
+
+      if (isStreaming && response.body) {
+        const [streamForCaller, streamForRecorder] = response.body.tee()
+        bufferSSEStream(provider, streamForRecorder).then((completion) => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { streamed: true, completion }, timestamp: start, durationMs })
+        }).catch(() => {
+          const durationMs = rawDateNow() - start
+          pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, streamed: true, streamRaw: '', timestamp: start, durationMs })
+        })
+        return new Response(streamForCaller, { status: response.status, statusText: response.statusText, headers: response.headers })
+      }
+
+      try {
+        const cloned = response.clone()
+        const responseBody = await cloned.json() as Record<string, unknown>
+        const completion = extractCompletion(provider, responseBody)
+        const usage = extractUsage(provider, responseBody)
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: { completion }, timestamp: start, durationMs, ...(usage ? { usage } : {}) })
+      } catch {
+        const durationMs = rawDateNow() - start
+        pushTelemetryEvent({ id, type: 'ai', name: model, input: eventInput, output: null, timestamp: start, durationMs })
+      }
+
+      return response
+    }
+
+    if (ctx && traceAtCall) {
       const { recorder, replay } = ctx
       const id = recorder.nextId()
       const start = rawDateNow()
@@ -505,7 +609,9 @@ export function installAIInterceptor(): void {
       return response
     }
 
-    // No capture context — original behaviour (outside of a workflow run)
+    // No capture context — original behaviour (trace handle only, outside of a workflow run)
+    if (!traceAtCall) return originalFetch!(input, init)
+
     const response = await originalFetch!(input, init)
 
     if (isStreaming && response.body) {

package/src/interceptors/db-auto.ts

@@ -1,4 +1,7 @@
 import { getCaptureContext } from '../capture/recorder.js'
+import { getCurrentTrace } from '../trace-adapter/context.js'
+import { rawDateNow } from './side-effects.js'
+import { getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
 
 type AnyFn = (...args: unknown[]) => unknown
 
@@ -10,6 +13,14 @@ interface MethodPatch {
 
 const appliedPatches: MethodPatch[] = []
 
+function toTraceArgs(input: unknown): Record<string, unknown> | undefined {
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    return input as Record<string, unknown>
+  }
+  if (input === undefined) return undefined
+  return { value: input }
+}
+
 function wrapProtoMethod(proto: object, method: string, eventName: string): void {
   const p = proto as Record<string, unknown>
   if (typeof p[method] !== 'function') return
@@ -24,58 +35,143 @@ function wrapProtoMethod(proto: object, method: string, eventName: string): void
     }
 
     const ctx = getCaptureContext()
-    if (!ctx) return original.apply(this, args)
+    const httpCtx = getHttpRunContext()
+    const obsCtx = getObservabilityContext()
+    const input = args.length === 1 ? args[0] : args
+
+    if (!ctx && !httpCtx && !obsCtx) return original.apply(this, args)
+
+    // Observability-only mode: record and push, no mocks/replay
+    if (!ctx && !httpCtx && obsCtx) {
+      const id = obsCtx.nextId()
+      const start = rawDateNow()
+
+      let result: unknown
+      try {
+        result = original.apply(this, args)
+      } catch (err) {
+        pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+        throw err
+      }
+
+      if (result != null && typeof (result as Promise<unknown>).then === 'function') {
+        return (result as Promise<unknown>)
+          .then((output: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output, timestamp: start, durationMs: rawDateNow() - start })
+            return output
+          })
+          .catch((err: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+            throw err
+          })
+      }
+
+      pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: result, timestamp: start, durationMs: rawDateNow() - start })
+      return result
+    }
 
-    const { recorder, replay } = ctx
+    // HTTP mode (no capture context): replay frozen events or execute live
+    if (!ctx && httpCtx) {
+      const id = httpCtx.nextId()
+
+      // Replay frozen step
+      const frozen = getHttpFrozenEvent(id)
+      if (frozen && frozen.type === 'db') {
+        pushTelemetryEvent(frozen)
+        return Promise.resolve(frozen.output)
+      }
+
+      // Not frozen → execute live, push telemetry
+      const start = rawDateNow()
+
+      let result: unknown
+      try {
+        result = original.apply(this, args)
+      } catch (err) {
+        pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+        throw err
+      }
+
+      if (result != null && typeof (result as Promise<unknown>).then === 'function') {
+        return (result as Promise<unknown>)
+          .then((output: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output, timestamp: start, durationMs: rawDateNow() - start })
+            return output
+          })
+          .catch((err: unknown) => {
+            pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs: rawDateNow() - start })
+            throw err
+          })
+      }
+
+      pushTelemetryEvent({ id, type: 'db', name: eventName, input, output: result, timestamp: start, durationMs: rawDateNow() - start })
+      return result
+    }
+
+    // Capture mode (enhanced with telemetry + TraceHandle)
+    const trace = getCurrentTrace()
+    const { recorder, replay } = ctx!
     const id = recorder.nextId()
 
     if (replay.shouldReplay(id)) {
       const historicalEvent = replay.getRecordedEvent(id)
       if (historicalEvent) recorder.record(historicalEvent)
-      return Promise.resolve(replay.getRecordedResult(id))
+      if (httpCtx) pushTelemetryEvent(historicalEvent ?? { id, type: 'db', name: eventName, input, output: null, timestamp: rawDateNow(), durationMs: 0 })
+      const replayed = replay.getRecordedResult(id)
+      if (trace && typeof trace.recordToolCall === 'function') {
+        trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: replayed, workflowEventId: id })
+      }
+      return Promise.resolve(replayed)
     }
 
-    const start = Date.now()
-    const input = args.length === 1 ? args[0] : args
+    const start = rawDateNow()
 
     let result: unknown
     try {
       result = original.apply(this, args)
     } catch (err) {
-      recorder.record({
-        id, type: 'db', name: eventName,
-        input, output: { error: String(err) },
-        timestamp: start, durationMs: Date.now() - start,
-      })
+      const durationMs = rawDateNow() - start
+      const event = { id, type: 'db' as const, name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs }
+      recorder.record(event)
+      if (httpCtx) pushTelemetryEvent(event)
+      if (trace && typeof trace.recordToolCall === 'function') {
+        trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: { error: String(err) }, workflowEventId: id, durationMs })
+      }
       throw err
     }
 
     if (result != null && typeof (result as Promise<unknown>).then === 'function') {
       return (result as Promise<unknown>)
         .then((output: unknown) => {
-          recorder.record({
-            id, type: 'db', name: eventName,
-            input, output,
-            timestamp: start, durationMs: Date.now() - start,
-          })
+          const durationMs = rawDateNow() - start
+          const event = { id, type: 'db' as const, name: eventName, input, output, timestamp: start, durationMs }
+          recorder.record(event)
+          if (httpCtx) pushTelemetryEvent(event)
+          if (trace && typeof trace.recordToolCall === 'function') {
+            trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: output, workflowEventId: id, durationMs })
+          }
           return output
         })
         .catch((err: unknown) => {
-          recorder.record({
-            id, type: 'db', name: eventName,
-            input, output: { error: String(err) },
-            timestamp: start, durationMs: Date.now() - start,
-          })
+          const durationMs = rawDateNow() - start
+          const event = { id, type: 'db' as const, name: eventName, input, output: { error: String(err) }, timestamp: start, durationMs }
+          recorder.record(event)
+          if (httpCtx) pushTelemetryEvent(event)
+          if (trace && typeof trace.recordToolCall === 'function') {
+            trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result: { error: String(err) }, workflowEventId: id, durationMs })
+          }
           throw err
         })
     }
 
     // Sync return (rare for DB calls)
-    recorder.record({
-      id, type: 'db', name: eventName,
-      input, output: result,
-      timestamp: start, durationMs: Date.now() - start,
-    })
+    const durationMs = rawDateNow() - start
+    const event = { id, type: 'db' as const, name: eventName, input, output: result, timestamp: start, durationMs }
+    recorder.record(event)
+    if (httpCtx) pushTelemetryEvent(event)
+    if (trace && typeof trace.recordToolCall === 'function') {
+      trace.recordToolCall({ name: eventName, args: toTraceArgs(input), result, workflowEventId: id, durationMs })
+    }
     return result
   }
 }

package/src/interceptors/db.ts

@@ -1,9 +1,25 @@
 import { getCaptureContext } from '../capture/recorder.js'
+import { getCurrentTrace } from '../trace-adapter/context.js'
+import { rawDateNow } from './side-effects.js'
+import { getHttpRunContext, getHttpFrozenEvent, pushTelemetryEvent, tryAutoInitHttpContext, getObservabilityContext } from './telemetry-push.js'
+
+function toTraceArgs(input: unknown): Record<string, unknown> | undefined {
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    return input as Record<string, unknown>
+  }
+  if (input === undefined) return undefined
+  return { value: input }
+}
 
 /**
  * Wraps named methods on a DB client instance in-place so their calls are
  * recorded as "db" events. Returns the same client object.
  *
+ * Supports all three execution modes:
+ * - Capture mode: replay from TraceRecorder / ReplayController
+ * - HTTP mode: replay frozen events from dashboard, push telemetry
+ * - Observability mode: record and push telemetry
+ *
  * @param client  Any DB client (pg.Client, redis client, mongoose Model, etc.)
  * @param methodNames  Method names to wrap
  * @param label  Optional label prefix for event names (defaults to constructor name)
@@ -20,30 +36,89 @@ export function wrapDB<T extends object>(
     if (typeof original !== 'function') continue
 
     ;(client as Record<string, unknown>)[method] = async (...args: unknown[]) => {
+      await tryAutoInitHttpContext()
       const ctx = getCaptureContext()
-      if (!ctx) return (original as (...a: unknown[]) => unknown).apply(client, args)
+      const httpCtx = getHttpRunContext()
+      const obsCtx = getObservabilityContext()
+      const name = `${prefix}.${method}`
+      const input = args.length === 1 ? args[0] : args
+
+      if (!ctx && !httpCtx && !obsCtx) return (original as (...a: unknown[]) => unknown).apply(client, args)
+
+      // Observability-only mode: record and push, no mocks/replay
+      if (!ctx && !httpCtx && obsCtx) {
+        const id = obsCtx.nextId()
+        const start = rawDateNow()
+        try {
+          const output = await (original as (...a: unknown[]) => unknown).apply(client, args)
+          pushTelemetryEvent({ id, type: 'db', name, input, output, timestamp: start, durationMs: rawDateNow() - start })
+          return output
+        } catch (e) {
+          pushTelemetryEvent({ id, type: 'db', name, input, output: { error: String(e) }, timestamp: start, durationMs: rawDateNow() - start })
+          throw e
+        }
+      }
+
+      // HTTP mode (no capture context): replay frozen events or execute live
+      if (!ctx && httpCtx) {
+        const id = httpCtx.nextId()
 
-      const { recorder, replay } = ctx
+        // Replay frozen step
+        const frozen = getHttpFrozenEvent(id)
+        if (frozen && frozen.type === 'db') {
+          pushTelemetryEvent(frozen)
+          return frozen.output
+        }
+
+        // Not frozen → execute live, push telemetry
+        const start = rawDateNow()
+        try {
+          const output = await (original as (...a: unknown[]) => unknown).apply(client, args)
+          pushTelemetryEvent({ id, type: 'db', name, input, output, timestamp: start, durationMs: rawDateNow() - start })
+          return output
+        } catch (e) {
+          pushTelemetryEvent({ id, type: 'db', name, input, output: { error: String(e) }, timestamp: start, durationMs: rawDateNow() - start })
+          throw e
+        }
+      }
+
+      // Capture mode
+      const trace = getCurrentTrace()
+      const { recorder, replay } = ctx!
       const id = recorder.nextId()
-      const name = `${prefix}.${method}`
 
       if (replay.shouldReplay(id)) {
-        return replay.getRecordedResult(id)
+        const historical = replay.getRecordedEvent(id)
+        if (historical) recorder.record(historical)
+        if (httpCtx) pushTelemetryEvent(historical ?? { id, type: 'db', name, input, output: null, timestamp: rawDateNow(), durationMs: 0 })
+        const replayed = replay.getRecordedResult(id)
+        if (trace && typeof trace.recordToolCall === 'function') {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result: replayed, workflowEventId: id })
+        }
+        return replayed
       }
 
-      const start = Date.now()
-      const output = await (original as (...a: unknown[]) => unknown).apply(client, args)
-      recorder.record({
-        id,
-        type: 'db',
-        name,
-        input: args.length === 1 ? args[0] : args,
-        output,
-        timestamp: start,
-        durationMs: Date.now() - start,
-      })
-
-      return output
+      const start = rawDateNow()
+      try {
+        const output = await (original as (...a: unknown[]) => unknown).apply(client, args)
+        const durationMs = rawDateNow() - start
+        const event = { id, type: 'db' as const, name, input, output, timestamp: start, durationMs }
+        recorder.record(event)
+        if (httpCtx) pushTelemetryEvent(event)
+        if (trace && typeof trace.recordToolCall === 'function') {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result: output, workflowEventId: id, durationMs })
+        }
+        return output
+      } catch (e) {
+        const durationMs = rawDateNow() - start
+        const event = { id, type: 'db' as const, name, input, output: { error: String(e) }, timestamp: start, durationMs }
+        recorder.record(event)
+        if (httpCtx) pushTelemetryEvent(event)
+        if (trace && typeof trace.recordToolCall === 'function') {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result: { error: String(e) }, workflowEventId: id, durationMs })
+        }
+        throw e
+      }
     }
   }