Deletes chatdebug's process-global step counters: the `stepCounters` and `runRefCounts` maps, `refCountMu`, `trackRunRef`, `releaseRunRef`, `nextStepNumber`, `syncStepCounter` and `CleanupStepCounter`, the `runtime.AddCleanup` hook that `ContextWithRun` registered for every run context, and the two `CleanupStepCounter` calls in `FinalizeRun`. Since #31007 the database numbers steps, so no production code reads them. **Why it is safe:** after #31007 no production code reads the counters. Production code only maintained them: `ContextWithRun` registered a reference for every run context and `FinalizeRun` called `CleanupStepCounter`, and this PR removes both. A search of `coderd/` and `enterprise/` for the deleted names finds nothing now. The deleted tests covered only the deleted code: `TestNextStepNumber_Concurrent` and `TestSyncStepCounter_AdvancesCounter` checked counter values, and the three garbage-collection tests in `context_internal_test.go` checked that a counter lives until the last `RunContext` for its run is collected. The 20 `t.Cleanup(func() { CleanupStepCounter(runID) })` lines go with them. `TestReuseStep_PreservesExistingHolder` and `TestBeginStepReuseStep` stay. The `FinalizeRun` doc comment no longer mentions the counter. **Review focus:** `ContextWithRun` is now a plain `context.WithValue`. Code that copies a `RunContext`, such as `runnerDebugTurn.contextLocked`, no longer affects anything, because no state is tied to the struct's lifetime. Validation: - `go test -race -count=1 -p 4 -parallel 4 ./coderd/x/chatd/chatdebug/...` passes. - `go test -count=1 -run Debug ./coderd/x/chatd/` (19 tests) passes, and the 25 chatd debug-run tests pass under `-race` (`go test -race -run '^(TestActiveServer_ChatTurnDebugRun.*|TestRunnerDebugTurn.*|TestProposeChatTitle_DebugRun|TestArchiveChatDeletesDebugRuns|TestEditMessageDebugCleanup.*|TestQuickgen.*|TestMaybeGenerateChatTitle.*|TestPrepareManualTitleDebugRunCreateFailure)$' ./coderd/x/chatd/`). - `golangci-lint run --fix=false ./coderd/x/chatd/chatdebug/...` reports 0 issues, and the pre-commit hook passed. ## Stack This stack deletes the stale debug-run sweep, then simplifies the chatdebug debug-run, stream wrapper and step numbering code, drops the indexes the sweep used, and last deletes a runner debug field that lost its only reader with the heartbeats. The debug-run and stream wrapper refactors each sit on a test-only layer that pins the behavior they keep. 1. #30988 Delete the chat debug run and step heartbeats 2. #30989 Delete `FinalizeStale` and the stale threshold 3. #30995 Delete the `FinalizeStaleChatDebugRows` query 4. #30933 Pin the debug runs that turns, titles and status labels record 5. #30934 Create and finalize debug runs through one helper 6. #30980 Table the stream wrapper tests and cover their status rules 7. #30981 Share one finalize-once lifecycle between the stream wrappers 8. #31007 Number chat debug steps in the database 9. This PR: Delete the process-global step counters 10. #31009 Drop the chat debug stale-sweep indexes 11. #31010 Drop the unused `runnerCtx` from the runner debug turn > Xum, an AI agent, opened this PR for @ibetitsmike and wrote this description.
49 lines
1.1 KiB
Go
49 lines
1.1 KiB
Go
package chatdebug
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
)
|
|
|
|
type (
|
|
runContextKey struct{}
|
|
reuseStepKey struct{}
|
|
reuseHolder struct {
|
|
mu sync.Mutex
|
|
handle *stepHandle
|
|
}
|
|
)
|
|
|
|
// ContextWithRun stores rc in ctx.
|
|
func ContextWithRun(ctx context.Context, rc *RunContext) context.Context {
|
|
if rc == nil {
|
|
panic("chatdebug: nil RunContext")
|
|
}
|
|
return context.WithValue(ctx, runContextKey{}, rc)
|
|
}
|
|
|
|
// RunFromContext returns the debug run context stored in ctx.
|
|
func RunFromContext(ctx context.Context) (*RunContext, bool) {
|
|
rc, ok := ctx.Value(runContextKey{}).(*RunContext)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return rc, true
|
|
}
|
|
|
|
// ReuseStep marks ctx so wrapped model calls under it share one debug step.
|
|
func ReuseStep(ctx context.Context) context.Context {
|
|
if holder, ok := reuseHolderFromContext(ctx); ok {
|
|
return context.WithValue(ctx, reuseStepKey{}, holder)
|
|
}
|
|
return context.WithValue(ctx, reuseStepKey{}, &reuseHolder{})
|
|
}
|
|
|
|
func reuseHolderFromContext(ctx context.Context) (*reuseHolder, bool) {
|
|
holder, ok := ctx.Value(reuseStepKey{}).(*reuseHolder)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
return holder, true
|
|
}
|