@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-trace.1

package/src/internal/fiberRuntime.ts

@@ -1969,31 +1969,20 @@ export const all = <
   arg: Arg,
   options?: O
 ): Effect.All.Return<Arg, O> => {
-  // Capture stack trace early (while user code is on stack)
-  const rawStack = new Error().stack ?? ""
-
   const [effects, reconcile] = allResolveInput(arg)
-  const count = Array.isArray(effects) ? effects.length : undefined
-
-  let result: Effect.Effect<any, any, any>
 
   if (options?.mode === "validate") {
-    result = allValidate(effects, reconcile, options) as any
+    return allValidate(effects, reconcile, options) as any
   } else if (options?.mode === "either") {
-    result = allEither(effects, reconcile, options) as any
-  } else {
-    result = options?.discard !== true && reconcile._tag === "Some"
-      ? core.map(
-        forEach(effects, identity, options as any),
-        reconcile.value
-      ) as any
-      : forEach(effects, identity, options as any) as any
+    return allEither(effects, reconcile, options) as any
   }
 
-  // Set operation metadata in trace field for OpSupervision
-  ;(result as any).trace = core.makeOperationMeta("all", rawStack, count)
-
-  return result as Effect.All.Return<Arg, O>
+  return options?.discard !== true && reconcile._tag === "Some"
+    ? core.map(
+      forEach(effects, identity, options as any),
+      reconcile.value
+    ) as any
+    : forEach(effects, identity, options as any) as any
 }
 
 /* @internal */
@@ -2136,12 +2125,8 @@ export const forEach: {
     readonly discard?: boolean | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }
-) => {
-  // Capture stack trace early (while user code is on stack)
-  const rawStack = new Error().stack ?? ""
-  const count = Array.isArray(self) ? self.length : undefined
-
-  const result = core.withFiberRuntime<A | void, E, R>((r) => {
+) =>
+  core.withFiberRuntime<A | void, E, R>((r) => {
     const isRequestBatchingEnabled = options?.batching === true ||
       (options?.batching === "inherit" && r.getFiberRef(core.currentRequestBatching))
 
@@ -2182,13 +2167,7 @@ export const forEach: {
           forEachParN(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)
         )
     )
-  })
-
-  // Set operation metadata in trace field for OpSupervision
-  ;(result as any).trace = core.makeOperationMeta("forEach", rawStack, count)
-
-  return result
-})
+  }))
 
 /* @internal */
 export const forEachParUnbounded = <A, B, E, R>(
@@ -2418,34 +2397,12 @@ export const forEachParN = <A, B, E, R>(
   })
 
 /* @internal */
-export const fork = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Fiber.RuntimeFiber<A, E>, never, R> => {
-  // Capture stack trace immediately while user code is on stack
-  // Creating Error object is cheap; parsing is delayed until we know capture is enabled
-  const rawStack = new Error().stack ?? ""
-
-  const result: Effect.Effect<Fiber.RuntimeFiber<A, E>, never, R> = core.withFiberRuntime((state, status) => {
-    // Check if capture is enabled, then parse the pre-captured stack if needed
-    const capturedLocation = state.getFiberRef(core.currentCaptureStackTraces) && rawStack
-      ? tracer.parseSourceLocationFromStack(rawStack)
-      : undefined
-
-    const fiber = unsafeForkWithLocation(self, state, status.runtimeFlags, null, capturedLocation)
-    return core.succeed(fiber)
-  })
-
-  // Set operation metadata in trace field for OpSupervision
-  ;(result as any).trace = core.makeOperationMeta("fork", rawStack, 1)
-
-  return result
-}
+export const fork = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Fiber.RuntimeFiber<A, E>, never, R> =>
+  core.withFiberRuntime((state, status) => core.succeed(unsafeFork(self, state, status.runtimeFlags)))
 
 /* @internal */
-export const forkDaemon = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Fiber.RuntimeFiber<A, E>, never, R> => {
-  const rawStack = new Error().stack ?? ""
-  const result = forkWithScopeOverride(self, fiberScope.globalScope)
-  ;(result as any).trace = core.makeOperationMeta("forkDaemon", rawStack, 1)
-  return result
-}
+export const forkDaemon = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Fiber.RuntimeFiber<A, E>, never, R> =>
+  forkWithScopeOverride(self, fiberScope.globalScope)
 
 /* @internal */
 export const forkWithErrorHandler = dual<
@@ -2479,19 +2436,6 @@ export const unsafeFork = <A, E, R, E2, B>(
   return childFiber
 }
 
-/** @internal */
-export const unsafeForkWithLocation = <A, E, R, E2, B>(
-  effect: Effect.Effect<A, E, R>,
-  parentFiber: FiberRuntime<B, E2>,
-  parentRuntimeFlags: RuntimeFlags.RuntimeFlags,
-  overrideScope: fiberScope.FiberScope | null = null,
-  capturedLocation: tracer.SourceLocation | undefined = undefined
-): FiberRuntime<A, E> => {
-  const childFiber = unsafeMakeChildFiberWithLocation(effect, parentFiber, parentRuntimeFlags, overrideScope, capturedLocation)
-  childFiber.resume(effect)
-  return childFiber
-}
-
 /** @internal */
 export const unsafeForkUnstarted = <A, E, R, E2, B>(
   effect: Effect.Effect<A, E, R>,
@@ -2509,28 +2453,11 @@ export const unsafeMakeChildFiber = <A, E, R, E2, B>(
   parentFiber: FiberRuntime<B, E2>,
   parentRuntimeFlags: RuntimeFlags.RuntimeFlags,
   overrideScope: fiberScope.FiberScope | null = null
-): FiberRuntime<A, E> => {
-  return unsafeMakeChildFiberWithLocation(effect, parentFiber, parentRuntimeFlags, overrideScope, undefined)
-}
-
-/** @internal */
-export const unsafeMakeChildFiberWithLocation = <A, E, R, E2, B>(
-  effect: Effect.Effect<A, E, R>,
-  parentFiber: FiberRuntime<B, E2>,
-  parentRuntimeFlags: RuntimeFlags.RuntimeFlags,
-  overrideScope: fiberScope.FiberScope | null = null,
-  capturedLocation: tracer.SourceLocation | undefined = undefined
 ): FiberRuntime<A, E> => {
   const childId = FiberId.unsafeMake()
   const parentFiberRefs = parentFiber.getFiberRefs()
   const childFiberRefs = fiberRefs.forkAs(parentFiberRefs, childId)
   const childFiber = new FiberRuntime<A, E>(childId, childFiberRefs, parentRuntimeFlags)
-
-  // Set pre-captured source location if enabled
-  if (capturedLocation && parentFiber.getFiberRef(core.currentCaptureStackTraces)) {
-    childFiber.setFiberRef(core.currentSourceLocation, capturedLocation)
-  }
-
   const childContext = fiberRefs.getOrDefault(
     childFiberRefs,
     core.currentContext as unknown as FiberRef.FiberRef<Context.Context<R>>

package/src/internal/layer/circular.ts

@@ -131,13 +131,6 @@ export const enableOpSupervision: Layer.Layer<never> = layer.scopedDiscard(
   )
 )
 
-/** @internal */
-export const enableOperationTracing: Layer.Layer<never> = layer.scopedDiscard(
-  fiberRuntime.withRuntimeFlagsScoped(
-    runtimeFlagsPatch.enable(runtimeFlags.OperationTracing)
-  )
-)
-
 /** @internal */
 export const enableRuntimeMetrics: Layer.Layer<never> = layer.scopedDiscard(
   fiberRuntime.withRuntimeFlagsScoped(
@@ -173,13 +166,6 @@ export const disableOpSupervision: Layer.Layer<never> = layer.scopedDiscard(
   )
 )
 
-/** @internal */
-export const disableOperationTracing: Layer.Layer<never> = layer.scopedDiscard(
-  fiberRuntime.withRuntimeFlagsScoped(
-    runtimeFlagsPatch.disable(runtimeFlags.OperationTracing)
-  )
-)
-
 /** @internal */
 export const disableRuntimeMetrics: Layer.Layer<never> = layer.scopedDiscard(
   fiberRuntime.withRuntimeFlagsScoped(

package/src/internal/layer.ts

@@ -963,10 +963,6 @@ export const scopedContext = <A, E, R>(
   return scoped
 }
 
-/** @internal */
-export const enableSourceCapture: Layer.Layer<never> =
-  fiberRefLocallyScoped(core.currentCaptureStackTraces, true)
-
 /** @internal */
 export const scope: Layer.Layer<Scope.Scope> = scopedContext(
   core.map(

package/src/internal/logger.ts

@@ -11,7 +11,9 @@ import type * as Logger from "../Logger.js"
 import type * as LogLevel from "../LogLevel.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
+import * as SourceLocation from "../SourceLocation.js"
 import * as Cause from "./cause.js"
+import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import { consoleTag } from "./defaultServices/console.js"
 import * as fiberId_ from "./fiberId.js"
@@ -178,7 +180,7 @@ const textOnly = /^[^\s"=]*$/
  */
 const format = (quoteValue: (s: string) => string, whitespace?: number | string | undefined) =>
 (
-  { annotations, cause, date, fiberId, logLevel, message, spans }: Logger.Logger.Options<unknown>
+  { annotations, cause, context, date, fiberId, logLevel, message, spans }: Logger.Logger.Options<unknown>
 ): string => {
   const formatValue = (value: string): string => value.match(textOnly) ? value : quoteValue(value)
   const format = (label: string, value: string): string => `${logSpan_.formatLabel(label)}=${formatValue(value)}`
@@ -188,6 +190,12 @@ const format = (quoteValue: (s: string) => string, whitespace?: number | string
   out += append("level", logLevel.label)
   out += append("fiber", fiberId_.threadName(fiberId))
 
+  // Include source trace if available
+  const sourceTrace = FiberRefs.getOrDefault(context, core.currentSourceTrace)
+  if (sourceTrace !== undefined) {
+    out += append("source", SourceLocation.format(sourceTrace))
+  }
+
   const messages = Arr.ensure(message)
   for (let i = 0; i < messages.length; i++) {
     out += append("message", Inspectable.toStringUnknown(messages[i], whitespace))
@@ -226,8 +234,11 @@ export const structuredLogger = makeLogger<unknown, {
   readonly cause: string | undefined
   readonly annotations: Record<string, unknown>
   readonly spans: Record<string, number>
+  readonly source:
+    | { readonly path: string; readonly line: number; readonly column: number; readonly label?: string }
+    | undefined
 }>(
-  ({ annotations, cause, date, fiberId, logLevel, message, spans }) => {
+  ({ annotations, cause, context, date, fiberId, logLevel, message, spans }) => {
     const now = date.getTime()
     const annotationsObj: Record<string, unknown> = {}
     const spansObj: Record<string, number> = {}
@@ -245,15 +256,41 @@ export const structuredLogger = makeLogger<unknown, {
     }
 
     const messageArr = Arr.ensure(message)
-    return {
+    const sourceTrace = FiberRefs.getOrDefault(context, core.currentSourceTrace)
+
+    const result: {
+      message: unknown
+      logLevel: string
+      timestamp: string
+      cause: string | undefined
+      annotations: Record<string, unknown>
+      spans: Record<string, number>
+      fiberId: string
+      source: { path: string; line: number; column: number; label?: string } | undefined
+    } = {
       message: messageArr.length === 1 ? structuredMessage(messageArr[0]) : messageArr.map(structuredMessage),
       logLevel: logLevel.label,
       timestamp: date.toISOString(),
       cause: Cause.isEmpty(cause) ? undefined : Cause.pretty(cause, { renderErrorCause: true }),
       annotations: annotationsObj,
       spans: spansObj,
-      fiberId: fiberId_.threadName(fiberId)
+      fiberId: fiberId_.threadName(fiberId),
+      source: undefined
     }
+
+    if (sourceTrace !== undefined) {
+      const sourceObj: { path: string; line: number; column: number; label?: string } = {
+        path: sourceTrace.path,
+        line: sourceTrace.line,
+        column: sourceTrace.column
+      }
+      if (sourceTrace.label !== undefined) {
+        sourceObj.label = sourceTrace.label
+      }
+      result.source = sourceObj
+    }
+
+    return result
   }
 )
 

package/src/internal/runtimeFlags.ts

@@ -23,9 +23,6 @@ export const WindDown: RuntimeFlags.RuntimeFlag = 1 << 4 as RuntimeFlags.Runtime
 /** @internal */
 export const CooperativeYielding: RuntimeFlags.RuntimeFlag = 1 << 5 as RuntimeFlags.RuntimeFlag
 
-/** @internal */
-export const OperationTracing: RuntimeFlags.RuntimeFlag = 1 << 6 as RuntimeFlags.RuntimeFlag
-
 /** @internal */
 export const allFlags: ReadonlyArray<RuntimeFlags.RuntimeFlag> = [
   None,
@@ -33,8 +30,7 @@ export const allFlags: ReadonlyArray<RuntimeFlags.RuntimeFlag> = [
   OpSupervision,
   RuntimeMetrics,
   WindDown,
-  CooperativeYielding,
-  OperationTracing
+  CooperativeYielding
 ]
 
 const print = (flag: RuntimeFlags.RuntimeFlag) => {
@@ -51,9 +47,6 @@ const print = (flag: RuntimeFlags.RuntimeFlag) => {
     case OpSupervision: {
       return "OpSupervision"
     }
-    case OperationTracing: {
-      return "OperationTracing"
-    }
     case Interruption: {
       return "Interruption"
     }
@@ -118,9 +111,6 @@ export const none: RuntimeFlags.RuntimeFlags = make(None)
 /** @internal */
 export const opSupervision = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, OpSupervision)
 
-/** @internal */
-export const operationTracing = (self: RuntimeFlags.RuntimeFlags): boolean => isEnabled(self, OperationTracing)
-
 /** @internal */
 export const render = (self: RuntimeFlags.RuntimeFlags): string => {
   const active: Array<string> = []

package/src/internal/tracer.ts

@@ -3,12 +3,9 @@
  */
 import * as Context from "../Context.js"
 import type * as Exit from "../Exit.js"
-import type * as FiberRef from "../FiberRef.js"
 import { constFalse } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
 import type * as Option from "../Option.js"
 import type * as Tracer from "../Tracer.js"
-import * as core from "./core.js"
 
 /** @internal */
 export const TracerTypeId: Tracer.TracerTypeId = Symbol.for("effect/Tracer") as Tracer.TracerTypeId
@@ -151,143 +148,3 @@ export const addSpanStackTrace = (options: Tracer.SpanOptions | undefined): Trac
 export const DisablePropagation = Context.Reference<Tracer.DisablePropagation>()("effect/Tracer/DisablePropagation", {
   defaultValue: constFalse
 })
-
-// -----------------------------------------------------------------------------
-// Source Location Capture
-// -----------------------------------------------------------------------------
-
-/**
- * Represents a source code location captured from a stack trace.
- * @internal
- */
-export interface SourceLocation {
-  readonly file: string
-  readonly line: number
-  readonly column: number
-  readonly functionName?: string
-}
-
-// Cache for source locations: raw frame string -> SourceLocation
-// Maximum cache size to prevent unbounded memory growth in long-running services
-const MAX_SOURCE_LOCATION_CACHE_SIZE = 1000
-const sourceLocationCache = new Map<string, SourceLocation>()
-
-/**
- * Evicts the oldest cache entry if at capacity (FIFO eviction).
- * Maps maintain insertion order, so the first key is the oldest.
- * @internal
- */
-const evictOldestCacheEntry = (): void => {
-  if (sourceLocationCache.size >= MAX_SOURCE_LOCATION_CACHE_SIZE) {
-    const firstKey = sourceLocationCache.keys().next().value
-    if (firstKey !== undefined) {
-      sourceLocationCache.delete(firstKey)
-    }
-  }
-}
-
-/**
- * Parses source location from a pre-captured stack trace string with caching.
- * This is used when the stack was captured earlier (while user code was on stack)
- * but parsing is delayed until we know capture is enabled.
- *
- * @internal
- */
-export const parseSourceLocationFromStack = (stack: string): SourceLocation | undefined => {
-  const lines = stack.split("\n")
-  // Find first non-internal frame (skip Error, fork, unsafeMakeChildFiber, etc.)
-  const userFrame = findUserFrame(lines)
-  if (!userFrame) return undefined
-
-  const cacheKey = userFrame.raw // Use raw frame string as key
-
-  const cached = sourceLocationCache.get(cacheKey)
-  if (cached) return cached
-
-  const parsed = parseStackFrame(userFrame.raw)
-  if (parsed) {
-    evictOldestCacheEntry() // Ensure cache doesn't grow unbounded
-    sourceLocationCache.set(cacheKey, parsed)
-  }
-  return parsed
-}
-
-/**
- * Captures the source location from the current stack trace with caching.
- * Uses the raw stack frame string as the cache key for fast lookups.
- *
- * Note: Uses the current Error.stackTraceLimit value (typically 10-15).
- * If capturing deeply nested call sites, configure Error.stackTraceLimit
- * globally before importing Effect (e.g., Error.stackTraceLimit = 25).
- *
- * @internal
- */
-export const captureSourceLocationCached = (): SourceLocation | undefined => {
-  const traceError = new Error()
-  if (!traceError.stack) return undefined
-  return parseSourceLocationFromStack(traceError.stack)
-}
-
-const findUserFrame = (stack: Array<string>): { raw: string; index: number } | undefined => {
-  // Skip frames from Effect internals
-  for (let i = 1; i < stack.length; i++) {
-    const frame = stack[i]
-    if (
-      frame &&
-      !isInternalFrame(frame)
-    ) {
-      return { raw: frame.trim(), index: i }
-    }
-  }
-  return undefined
-}
-
-const isInternalFrame = (frame: string): boolean => {
-  // Skip internal directories
-  if (frame.includes("/internal/")) return true
-  // Skip Effect core source files
-  if (frame.includes("/packages/effect/src/")) return true
-  if (frame.includes("/effect/dist/")) return true
-  // Skip node_modules (for published effect packages)
-  if (frame.includes("node_modules/effect/")) return true
-  if (frame.includes("node_modules/@effect/")) return true
-  // Skip specific internal functions
-  if (frame.includes("fiberRuntime")) return true
-  if (frame.includes("captureSourceLocation")) return true
-  if (frame.includes("effect_internal_function")) return true
-  return false
-}
-
-const parseStackFrame = (frame: string): SourceLocation | undefined => {
-  // Parse "at functionName (file:line:col)" or "at file:line:col"
-  const match = frame.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/)
-  if (!match) return undefined
-
-  return {
-    functionName: match[1],
-    file: match[2],
-    line: parseInt(match[3], 10),
-    column: parseInt(match[4], 10)
-  }
-}
-
-// -----------------------------------------------------------------------------
-// OTel Context Propagation
-// -----------------------------------------------------------------------------
-
-/**
- * FiberRef for propagating OpenTelemetry span context through Effect's fiber hierarchy.
- *
- * When fibers are forked, they inherit this FiberRef's value from their parent.
- * This allows supervisors to maintain correct parent-child span relationships
- * even when the OTel AsyncLocalStorage context is lost due to Effect's fiber scheduler.
- *
- * The value is typed as `unknown` to avoid a direct dependency on @opentelemetry/api.
- * Consumers should cast to `OtelApi.Context` when using.
- *
- * @internal
- */
-export const currentOtelSpanContext: FiberRef.FiberRef<unknown> = globalValue(
-  "effect/Tracer/currentOtelSpanContext",
-  () => core.fiberRefUnsafeMake<unknown>(undefined)
-)