Allow to interrupt fibers in debugger UI (#80)

mattiamanzati · web-flow · commit 46d59f16caaa · 2025-10-08T18:49:14.000+02:00
diff --git a/.changeset/puny-trains-rush.md b/.changeset/puny-trains-rush.md
@@ -0,0 +1,5 @@
+---
+"effect-vscode": minor
+---
+
+Allow to interrupt fibers in debugger UI
diff --git a/package.json b/package.json
@@ -112,6 +112,11 @@
         "title": "Effect Dev Tools: Reveal Fiber Current Span Location",
         "icon": "$(go-to-file)"
       },
+      {
+        "command": "effect.interruptDebugFiber",
+        "title": "Effect Dev Tools: Interrupt Fiber",
+        "icon": "$(debug-stop)"
+      },
       {
         "command": "effect.resetTracerExtended",
         "title": "Effect Dev Tools: Reset Tracer Extended",
@@ -258,7 +263,12 @@
         },
         {
           "command": "effect.revealFiberCurrentSpan",
-          "when": "inDebugMode && view === effect-debug-fibers",
+          "when": "inDebugMode && view === effect-debug-fibers && (viewItem === fiber || viewItem === fiber-interrupting)",
+          "group": "inline"
+        },
+        {
+          "command": "effect.interruptDebugFiber",
+          "when": "inDebugMode && view === effect-debug-fibers && viewItem === fiber",
           "group": "inline"
         }
       ]
diff --git a/src/DebugEnv.ts b/src/DebugEnv.ts
@@ -267,13 +267,22 @@ export class FiberEntry extends Data.Class<{
   readonly stack: Array<SpanStackEntry>
   readonly isCurrent: boolean
   readonly isInterruptible: boolean
+  readonly isInterrupted: boolean
+  readonly children: ReadonlyArray<string>
+  readonly startTimeMillis: number
+  readonly lifeTimeMillis: number
+  readonly interrupt: Effect.Effect<void>
 }> {
 }
 
 const CurrentFiberSchema = Schema.Array(Schema.Struct({
   id: Schema.String,
   isCurrent: Schema.Boolean,
-  isInterruptible: Schema.Boolean
+  isInterrupted: Schema.Boolean,
+  isInterruptible: Schema.Boolean,
+  children: Schema.Array(Schema.String),
+  startTimeMillis: Schema.Number,
+  lifeTimeMillis: Schema.Number
 }))
 
 const getCurrentFibers = (threadId: number | undefined) =>
@@ -291,9 +300,27 @@ const getCurrentFibers = (threadId: number | undefined) =>
     Effect.flatMap((fibers) =>
       Effect.all(
         fibers.map((fiber, idx) =>
-          Effect.map(
+          Effect.flatMap(
             getFiberCurrentSpan(`(globalThis["effect/devtools/instrumentation"].fibers || [])[${idx}]`, 1, threadId),
-            (stack) => new FiberEntry({ ...fiber, stack })
+            (stack) =>
+              Effect.gen(function*() {
+                const runtime = yield* Effect.runtime<DebugChannel.DebugChannel>()
+
+                return new FiberEntry({
+                  ...fiber,
+                  stack,
+                  interrupt: Effect.provide(
+                    DebugChannel.DebugChannel.evaluate({
+                      expression: `globalThis["effect/devtools/instrumentation"].interruptFiber(${
+                        JSON.stringify(fiber.id)
+                      })`,
+                      guessFrameId: true,
+                      threadId
+                    }),
+                    runtime
+                  ).pipe(Effect.ignoreLogged)
+                })
+              })
           )
         ),
         { concurrency: "unbounded" }
diff --git a/src/DebugFibersProvider.ts b/src/DebugFibersProvider.ts
@@ -1,24 +1,47 @@
-import type * as Array from "effect/Array"
+import * as Array from "effect/Array"
+import * as DateTime from "effect/DateTime"
+import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
 import * as SubscriptionRef from "effect/SubscriptionRef"
 import * as vscode from "vscode"
+import type * as DebugChannel from "./DebugChannel"
 import * as Debug from "./DebugEnv"
+import * as DurationUtils from "./utils/Duration"
 import { registerCommand, revealFile, TreeDataProvider, treeDataProvider } from "./VsCode"
 
-class TreeNode {
+class FiberNode {
+  readonly _tag = "FiberNode"
+  public interruptionRequested = false
   constructor(readonly entry: Debug.FiberEntry) {}
 }
 
+class FiberMetadataNode {
+  readonly _tag = "FiberMetadataNode"
+  constructor(readonly name: string, readonly value: string) {}
+}
+
+class AttributeNode {
+  readonly _tag = "AttributeNode"
+  constructor(readonly name: string, readonly variable: DebugChannel.VariableReference) {}
+}
+
+class VariableNode {
+  readonly _tag = "VariableNode"
+  constructor(readonly variable: DebugChannel.VariableReference) {}
+}
+
+type TreeNode = FiberNode | FiberMetadataNode | AttributeNode | VariableNode
+
 export const DebugFibersProviderLive = treeDataProvider<TreeNode>("effect-debug-fibers")(
   (refresh) =>
     Effect.gen(function*() {
       const debug = yield* Debug.DebugEnv
       let nodes: Array<TreeNode> = []
 
       yield* registerCommand("effect.revealFiberCurrentSpan", (node: TreeNode) => {
-        if (node && node.entry.stack.length > 0) {
+        if (node && node._tag === "FiberNode" && node.entry.stack.length > 0) {
           const stackEntry = node.entry.stack[0]
           if (stackEntry.path) {
             return revealFile(
@@ -30,15 +53,25 @@ export const DebugFibersProviderLive = treeDataProvider<TreeNode>("effect-debug-
         return Effect.void
       })
 
+      yield* registerCommand("effect.interruptDebugFiber", (node: TreeNode) => {
+        if (node && node._tag === "FiberNode") {
+          return node.entry.interrupt.pipe(
+            Effect.ensuring(Effect.sync(() => node.interruptionRequested = true)),
+            Effect.ensuring(refresh(Option.some(node)))
+          )
+        }
+        return Effect.void
+      })
+
       const capture = (threadId?: number) =>
         Effect.gen(function*() {
           const sessionOption = yield* (SubscriptionRef.get(debug.session))
           if (Option.isNone(sessionOption)) {
             nodes = []
           } else {
             const session = sessionOption.value
-            const pairs = yield* (session.currentFibers(threadId))
-            nodes = pairs.map((_) => new TreeNode(_))
+            const rootData = yield* (session.currentFibers(threadId))
+            nodes = rootData.map((_) => new FiberNode(_))
           }
           yield* (refresh(Option.none()))
         })
@@ -67,7 +100,55 @@ export const DebugFibersProviderLive = treeDataProvider<TreeNode>("effect-debug-
       return TreeDataProvider<TreeNode>({
         children: Option.match({
           onNone: () => Effect.succeedSome(nodes),
-          onSome: () => Effect.succeedNone
+          onSome: (node) => {
+            switch (node._tag) {
+              case "FiberNode": {
+                const childs: Array<TreeNode> = [
+                  new FiberMetadataNode(
+                    "Started At",
+                    DateTime.make(node.entry.startTimeMillis).pipe(
+                      Option.map(
+                        DateTime.formatLocal({ dateStyle: "medium", timeStyle: "long" })
+                      ),
+                      Option.getOrElse(() => String(node.entry.startTimeMillis))
+                    )
+                  ),
+                  new FiberMetadataNode(
+                    "Lifetime",
+                    DurationUtils.format(Duration.millis(node.entry.lifeTimeMillis))
+                  ),
+                  new FiberMetadataNode(
+                    "Interruptible",
+                    node.entry.isInterruptible ? "true" : "false"
+                  ),
+                  new FiberMetadataNode(
+                    "Interrupted",
+                    node.entry.isInterrupted ? "true" : "false"
+                  ),
+                  ...node.entry.stack[0]?.attributes.map(([name, variable]) => new AttributeNode(name, variable)) ?? [],
+                  ...nodes.filter((_) => _._tag === "FiberNode" && node.entry.children.includes(_.entry.id))
+                ]
+                return Effect.succeedSome(childs)
+              }
+              case "FiberMetadataNode": {
+                return Effect.succeedNone
+              }
+              case "AttributeNode": {
+                return node.variable.children.pipe(
+                  Effect.map(Array.map((_) => new VariableNode(_))),
+                  Effect.orElseSucceed(() => []),
+                  Effect.asSome
+                )
+              }
+              case "VariableNode": {
+                return node.variable.children.pipe(
+                  Effect.map(Array.map((_) => new VariableNode(_))),
+                  Effect.orElseSucceed(() => []),
+                  Effect.asSome
+                )
+              }
+            }
+          }
         }),
         treeItem: (node) => Effect.succeed(treeItem(node))
       })
@@ -77,20 +158,57 @@ export const DebugFibersProviderLive = treeDataProvider<TreeNode>("effect-debug-
 // === helpers ===
 
 const treeItem = (node: TreeNode): vscode.TreeItem => {
-  const item = new vscode.TreeItem(
-    "Fiber#" + node.entry.id + (node.entry.isInterruptible ? "" : " (uninterruptible)"),
-    vscode.TreeItemCollapsibleState.None
-  )
-  if (node.entry.isCurrent) {
-    item.iconPath = new vscode.ThemeIcon("arrow-small-right")
-  }
-  const firstEntry = node.entry.stack[0]
-  if (firstEntry) {
-    item.description = firstEntry.name
-    if (firstEntry.path) {
-      item.tooltip = firstEntry.path + ":" + firstEntry.line + ":" + firstEntry.column
+  switch (node._tag) {
+    case "FiberNode": {
+      const item = new vscode.TreeItem(
+        "Fiber#" + node.entry.id + (node.entry.isInterrupted ? " (interrupting)" : "") +
+          (node.entry.isInterruptible ? "" : " (uninterruptible)") +
+          (node.interruptionRequested ? " (interruption requested)" : ""),
+        vscode.TreeItemCollapsibleState.Collapsed
+      )
+      item.contextValue = node.interruptionRequested || node.entry.isInterrupted ? "fiber-interrupting" : "fiber"
+      if (node.entry.isCurrent) {
+        item.iconPath = new vscode.ThemeIcon("arrow-small-right")
+      }
+      const firstEntry = node.entry.stack[0]
+      if (firstEntry) {
+        item.description = firstEntry.name
+        if (firstEntry.path) {
+          item.tooltip = firstEntry.path + ":" + firstEntry.line + ":" + firstEntry.column
+        }
+      }
+
+      return item
+    }
+    case "FiberMetadataNode": {
+      const item = new vscode.TreeItem(node.name, vscode.TreeItemCollapsibleState.None)
+      item.contextValue = "fiberMetadata"
+      item.description = node.value
+      return item
+    }
+    case "AttributeNode": {
+      const item = new vscode.TreeItem(
+        node.name + ":",
+        node.variable.isContainer
+          ? vscode.TreeItemCollapsibleState.Collapsed
+          : vscode.TreeItemCollapsibleState.None
+      )
+      item.contextValue = "attribute"
+      item.description = node.variable.value
+      item.tooltip = node.variable.value
+      return item
+    }
+    case "VariableNode": {
+      const item = new vscode.TreeItem(
+        node.variable.name + ":",
+        node.variable.isContainer
+          ? vscode.TreeItemCollapsibleState.Collapsed
+          : vscode.TreeItemCollapsibleState.None
+      )
+      item.contextValue = "variable"
+      item.description = node.variable.value
+      item.tooltip = node.variable.value
+      return item
     }
   }
-
-  return item
 }
diff --git a/src/instrumentation/instrumentation.compiled.ts b/src/instrumentation/instrumentation.compiled.ts
diff --git a/src/instrumentation/instrumentation.ts b/src/instrumentation/instrumentation.ts
@@ -52,6 +52,7 @@ if (!(instrumentationKey in globalThis)) {
     "getFiberCurrentSpanStack": getFiberCurrentSpanStack,
     "getFiberCurrentContext": getFiberCurrentContext,
     "getAliveFibers": getAliveFibers,
+    "interruptFiber": interruptFiber,
     "getAutoPauseConfig": getAutoPauseConfig,
     "togglePauseOnDefects": togglePauseOnDefects,
     "getAndUnsetPauseStateToReveal": getAndUnsetPauseStateToReveal
@@ -139,14 +140,29 @@ if (!(instrumentationKey in globalThis)) {
       .flatMap((context) => [...context.unsafeMap.entries()])
   }
 
+  function encodeFiberId(fiber: Fiber.Runtime<any, any>) {
+    return fiber.id().id.toString()
+  }
+
   function getAliveFibers() {
     return fibers.map((fiber) => ({
-      "id": fiber.id().id.toString(),
+      "id": encodeFiberId(fiber),
       "isCurrent": fiber === (globalThis as any)["effect/FiberCurrent"],
-      "isInterruptible": fiber && "currentRuntimeFlags" in fiber && interruptible(fiber.currentRuntimeFlags as any)
+      "isInterruptible": fiber && "currentRuntimeFlags" in fiber && interruptible(fiber.currentRuntimeFlags as any),
+      "isInterrupted": fiber && "isInterrupted" in fiber && typeof fiber.isInterrupted === "function" &&
+        fiber.isInterrupted(),
+      "children": "getChildren" in fiber && typeof fiber.getChildren === "function"
+        ? [...fiber.getChildren()].map(encodeFiberId)
+        : [],
+      "startTimeMillis": fiber.id().startTimeMillis,
+      "lifeTimeMillis": Date.now() - fiber.id().startTimeMillis
     }))
   }
 
+  function interruptFiber(fiberId: string) {
+    fibers.forEach((fiber) => encodeFiberId(fiber) === fiberId && fiber.unsafeInterruptAsFork(fiber.id()))
+  }
+
   function getAutoPauseConfig() {
     return {
       "pauseOnDefects": debuggerState.pauseOnDefects
diff --git a/tsup.instrumentation.config.ts b/tsup.instrumentation.config.ts
@@ -20,7 +20,7 @@ export default defineConfig({
       const path = yield* Path.Path
       const compiled = yield* fs.readFileString("out/instrumentation.global.js")
       const code =
-        `(function(){ var Array = globalThis.Array; var Object = globalThis.Object; var String = globalThis.String; \n${compiled}} )()`
+        `(function(){ var Array = globalThis.Array; var Object = globalThis.Object; var String = globalThis.String; var Date = globalThis.Date; \n${compiled}} )()`
       yield* fs.writeFileString(
         path.join(__dirname, "src", "instrumentation", "instrumentation.compiled.ts"),
         `/* eslint-disable @effect/dprint */\nexport const compiledInstrumentationString = ${JSON.stringify(code)}`

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"effect-vscode": minor
 +---
++
 +Allow to interrupt fibers in debugger UI