Add inspect link to spawn events in the inspector

Author: RainingComputers

.vscode/settings.json

@@ -5,6 +5,8 @@
     "amacneil",
     "buildmode",
     "BYTEA",
+    "chancreate",
+    "chansend",
     "checkcgogensync",
     "cloc",
     "clocincludetests",

pkg/inspector/server.go

@@ -22,6 +22,9 @@ func SpawnInspector(platform platforms.Platform, addr string) context.CancelFunc
 	mux.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
 		handleStatic(w, r)
 	})
+	mux.HandleFunc("/isolate/name/", func(w http.ResponseWriter, r *http.Request) {
+		handleInspectPageByName(tmpl, platform, platformName, version, w, r)
+	})
 	mux.HandleFunc("/isolate/", func(w http.ResponseWriter, r *http.Request) {
 		handleInspectPage(tmpl, platform, platformName, version, w, r)
 	})
@@ -77,6 +80,7 @@ func loadTemplates() *template.Template {
 			"hash":        hash,
 			"fmtLine":     fmtLine,
 			"formatAwait": formatAwait,
+			"isSpawn":     isSpawn,
 		}).ParseFS(content, "templates/*.html"),
 	)
 }
@@ -313,6 +317,83 @@ func handleInspectPage(
 	writeHTML(tmpl, w, "inspect", data)
 }
 
+func handleInspectPageByName(
+	tmpl *template.Template,
+	platform platforms.Platform,
+	platformName string,
+	version string,
+	w http.ResponseWriter,
+	r *http.Request,
+) {
+	name := strings.TrimPrefix(r.URL.Path, "/isolate/name/")
+
+	if name == "" {
+		writeHTMLError(
+			tmpl,
+			w,
+			platformName,
+			version,
+			http.StatusBadRequest,
+			"invalid isolate name",
+		)
+		return
+	}
+
+	isolate, err := platform.InspectorGetByName(name)
+	if err != nil {
+		status := http.StatusInternalServerError
+
+		var notExistErr *platforms.PlatformIsolateDoesNotExistError
+		if errors.As(err, &notExistErr) {
+			status = http.StatusNotFound
+		}
+
+		writeHTMLError(tmpl, w, platformName, version, status, err.Error())
+		return
+	}
+
+	traces, err := platform.InspectorTraces(isolate.ID)
+	if err != nil {
+		writeHTMLError(
+			tmpl,
+			w,
+			platformName,
+			version,
+			http.StatusInternalServerError,
+			err.Error(),
+		)
+		return
+	}
+
+	dark := dark(r)
+	hasSource := isolate.Source != ""
+
+	var sourceHTML template.HTML
+	if hasSource {
+		sourceHTML = syntaxHighlightCodeHTML(
+			isolate.Source,
+			isolate.Lang,
+			isolate.Line,
+			dark,
+		)
+	}
+
+	data := inspectPageData{
+		navData: navData{
+			Title:    "Inspect #" + strconv.FormatUint(uint64(isolate.ID), 10),
+			Version:  version,
+			Platform: platformName,
+		},
+		Isolate:    isolate,
+		Variables:  formatContext(isolate.Context),
+		Traces:     formatTraces(traces, isolate.Lang, dark),
+		SourceHTML: sourceHTML,
+		HasSource:  hasSource,
+	}
+
+	writeHTML(tmpl, w, "inspect", data)
+}
+
 func handleVariablesFragment(
 	tmpl *template.Template,
 	platform platforms.Platform,

pkg/inspector/templates/fragments.html

@@ -149,7 +149,14 @@
             <details class="accordion" id="trace-{{ $id }}">
                 <summary class="grid-a2212" id="trace-{{ $id }}-summary">
                     <span id="trace-{{ $id }}-arrival">{{ .ArrivalUTC }}</span>
-                    <span id="trace-{{ $id }}-key">{{ .Key }}</span>
+                    <span id="trace-{{ $id }}-key">
+                        {{ .Key }}
+                        {{ if isSpawn .Key }}
+                            <a class="inspect-link" href="/isolate/name/{{ .Key }}"
+                                >Inspect &rarr;</a
+                            >
+                        {{ end }}
+                    </span>
                     <span id="trace-{{ $id }}-before-line">
                         {{ fmtLine .BeforeLine }}
                     </span>

pkg/inspector/templates/style.css

@@ -63,8 +63,11 @@ a {
   grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
 }
 .grid-a2212 {
-  grid-template-columns: auto 1fr 1fr 0.5fr 0.5fr 1fr;
+  grid-template-columns:
+    1rem minmax(0, 1fr) minmax(0, 1fr) minmax(0, 0.5fr)
+    minmax(0, 0.5fr) minmax(0, 1fr);
   gap: 1rem;
+  align-items: center;
 }
 .col-full {
   grid-column: 1 / -1;
@@ -260,6 +263,11 @@ tr.clickable:hover {
   font-size: 0.875rem;
   list-style: none;
 }
+.accordion summary > span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
 .accordion summary::before {
   content: "▶";
   font-size: 0.625rem;
@@ -333,6 +341,12 @@ tr.clickable:hover {
   color: var(--fg);
 }
 
+/* -=[Inspect Link]=- */
+.inspect-link {
+  display: block;
+  font-size: 0.75rem;
+}
+
 /* -=[Animations]=- */
 .flash {
   animation: flash 0.3s ease-out;

pkg/inspector/templating.go

@@ -113,6 +113,10 @@ func fmtLine(line int) string {
 	return strconv.Itoa(line)
 }
 
+func isSpawn(key string) bool {
+	return strings.HasPrefix(key, "spawn-")
+}
+
 func formatContext(ctxBytes []byte) map[string]string {
 	if len(ctxBytes) == 0 {
 		return nil

pkg/platforms/interface.go

@@ -401,6 +401,7 @@ type Platform interface {
 	InspectorVersion() (string, string)
 	InspectorSummary() (WorkersSummary, error)
 	InspectorGet(id uint) (IsolateState, error)
+	InspectorGetByName(name string) (IsolateState, error)
 	InspectorTraces(id uint) ([]Trace, error)
 	InspectorList(before uint, after uint, limit uint) (IsolateListResult, error)
 }

pkg/platforms/postgres/postgres.go

@@ -183,6 +183,29 @@ func (p Postgres) InspectorGet(id uint) (platforms.IsolateState, error) {
 	return row, nil
 }
 
+func (p Postgres) InspectorGetByName(name string) (platforms.IsolateState, error) {
+	row, err := fetchOne(p.pool, `
+		SELECT id, name, program, source, lang, line, tick, events, status, error,
+			context, created_at
+		FROM isolates
+		WHERE name = $1
+	`, pgx.RowToStructByName[platforms.IsolateState], name)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return platforms.IsolateState{}, &platforms.PlatformIsolateDoesNotExistError{
+				Name: name,
+			}
+		}
+
+		return platforms.IsolateState{}, &platforms.PlatformError{
+			Message: "unable to get isolate " + name,
+			Err:     err,
+		}
+	}
+
+	return row, nil
+}
+
 func (p Postgres) InspectorTraces(id uint) ([]platforms.Trace, error) {
 	traces, err := fetchMany(p.pool, `
 		SELECT id, isolate, key, before_pc, after_pc, line_before, line_after,

pkg/runtimes/dupher/blocks.go

@@ -110,7 +110,9 @@ func Goto(line int, name string) GotoBlock {
 func Impure(line int, stmt func(Context)) AwaitBlock {
 	return Await(line,
 		func(ctx Context) (platforms.Event, error) {
-			return platforms.CheckpointEvent{Id: ctx.GenKey()}, nil
+			key := "impure-" + ctx.GenKey()
+
+			return platforms.CheckpointEvent{Id: key}, nil
 		},
 		func(ctx Context, _ platforms.EventNotify) error {
 			stmt(ctx)
@@ -131,12 +133,12 @@ func SubProgram(
 				return nil, err
 			}
 
-			id := ctx.GenKey()
+			key := "spawn-" + program + "-" + ctx.GenKey()
 
 			return platforms.SpawnEvent{
-				Id:      id,
+				Id:      key,
 				Program: program,
-				Name:    program + "-" + id,
+				Name:    key,
 				Args:    serArgs,
 			}, nil
 		},
@@ -149,10 +151,11 @@ func SubProgram(
 func Chan(line int, ret func(Context, string)) AwaitBlock {
 	return Await(line,
 		func(ctx Context) (platforms.Event, error) {
-			id := ctx.GenKey()
-			ret(ctx, id)
+			key := "chan-" + ctx.GenKey()
+
+			ret(ctx, key)
 
-			return platforms.ChannelCreateEvent{Id: id}, nil
+			return platforms.ChannelCreateEvent{Id: key}, nil
 		},
 		func(ctx Context, _ platforms.EventNotify) error {
 			return nil
@@ -168,8 +171,10 @@ func Send(line int, id func(Context) string, value func(Context) any) AwaitBlock
 				return nil, err
 			}
 
+			key := "chansend-" + ctx.GenKey()
+
 			return platforms.ChannelSendEvent{
-				Id:    id(ctx),
+				Id:    key,
 				Value: data,
 			}, nil
 		},
@@ -205,11 +210,12 @@ func WaitGroup(
 ) AwaitBlock {
 	return Await(line,
 		func(ctx Context) (platforms.Event, error) {
-			id := ctx.GenKey()
-			ret(ctx, id)
+			key := "wg-" + ctx.GenKey()
+
+			ret(ctx, key)
 
 			return platforms.WaitGroupCreateEvent{
-				Id:    id,
+				Id:    key,
 				Value: value(ctx),
 			}, nil
 		},
@@ -261,10 +267,11 @@ func Wait(line int, id func(Context) string) AwaitBlock {
 func Mutex(line int, ret func(Context, string)) AwaitBlock {
 	return Await(line,
 		func(ctx Context) (platforms.Event, error) {
-			id := ctx.GenKey()
-			ret(ctx, id)
+			key := "mutex-" + ctx.GenKey()
+
+			ret(ctx, key)
 
-			return platforms.MutexCreateEvent{Id: id}, nil
+			return platforms.MutexCreateEvent{Id: key}, nil
 		},
 		func(ctx Context, _ platforms.EventNotify) error {
 			return nil
@@ -314,6 +321,7 @@ func RecvAny(
 			},
 		}
 	}
+
 	return AwaitBlock{line: line, futs: futs}
 }
 

pkg/runtimes/dython/deepslate/blocks.py

@@ -169,11 +169,12 @@ def impure_block(
     def _trigger(ctx: Context, notify: EventNotify) -> None:
         stmt(ctx)
 
-    return await_block(
-        line,
-        lambda ctx: CheckpointEvent(id=ctx.gen_key()),
-        _trigger,
-    )
+    def _start(ctx: Context) -> Event:
+        key = "impure-" + ctx.gen_key()
+
+        return CheckpointEvent(id=key)
+
+    return await_block(line, _start, _trigger)
 
 
 def sub_program(
@@ -186,12 +187,12 @@ def _start(ctx: Context) -> Event:
         child_ctx = Context(vars=args)
         ser_args = ser_ctx(child_ctx)
 
-        id_ = ctx.gen_key()
+        key = "spawn-" + program_name + "-" + ctx.gen_key()
 
         return SpawnEvent(
-            id=id_,
+            id=key,
             program=program_name,
-            name=program_name + "-" + id_,
+            name=key,
             args=ser_args,
         )
 
@@ -203,10 +204,11 @@ def _trigger(ctx: Context, notify: EventNotify) -> None:
 
 def chan(line: int, ret: Callable[[Context, str], None]) -> AwaitBlock:
     def _start(ctx: Context) -> Event:
-        id_ = ctx.gen_key()
-        ret(ctx, id_)
+        key = "chan-" + ctx.gen_key()
+
+        ret(ctx, key)
 
-        return ChannelCreateEvent(id=id_)
+        return ChannelCreateEvent(id=key)
 
     def _trigger(ctx: Context, notify: EventNotify) -> None:
         pass
@@ -220,7 +222,10 @@ def send(
     value: Callable[[Context], Any],
 ) -> AwaitBlock:
     def _start(ctx: Context) -> Event:
-        return ChannelSendEvent(id=id(ctx), value=msgspec.msgpack.encode(value(ctx)))
+        return ChannelSendEvent(
+            id=id(ctx),
+            value=msgspec.msgpack.encode(value(ctx)),
+        )
 
     def _trigger(ctx: Context, notify: EventNotify) -> None:
         pass
@@ -287,10 +292,11 @@ def wait_group(
     ret: Callable[[Context, str], None],
 ) -> AwaitBlock:
     def _start(ctx: Context) -> Event:
-        id_ = ctx.gen_key()
-        ret(ctx, id_)
+        key = "wg-" + ctx.gen_key()
+
+        ret(ctx, key)
 
-        return WaitGroupCreateEvent(id=id_, value=value(ctx))
+        return WaitGroupCreateEvent(id=key, value=value(ctx))
 
     def _trigger(ctx: Context, notify: EventNotify) -> None:
         pass
@@ -334,9 +340,11 @@ def _trigger(ctx: Context, notify: EventNotify) -> None:
 
 def mutex(line: int, ret: Callable[[Context, str], None]) -> AwaitBlock:
     def _start(ctx: Context) -> Event:
-        id_ = ctx.gen_key()
-        ret(ctx, id_)
-        return MutexCreateEvent(id=id_)
+        key = "mutex-" + ctx.gen_key()
+
+        ret(ctx, key)
+
+        return MutexCreateEvent(id=key)
 
     def _trigger(ctx: Context, notify: EventNotify) -> None:
         pass