From 6f22fc4d6507892ac7c6bf162a70440c1a2c014b Mon Sep 17 00:00:00 2001 From: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> Date: Thu, 29 Oct 2026 20:16:27 -0400 Subject: [PATCH 1/3] fix: warn once per PR on review dispatch promotion Signed-off-by: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> --- changelog.d/fixed-15578.md | 1 + src/cmd/hive/main_sweeps.go | 6 +++++- src/cmd/hive/warn_once_pr.go | 5 +++-- src/cmd/hive/warn_once_pr_test.go | 12 ++++++++++++ 4 files changed, 21 insertions(+), 3 deletions(-) create mode 100644 changelog.d/fixed-15578.md diff --git a/changelog.d/fixed-15578.md b/changelog.d/fixed-15578.md new file mode 100644 index 0000000000..97105f7f33 --- /dev/null +++ b/changelog.d/fixed-15578.md @@ -0,0 +1 @@ +- The "review dispatch promoted" warning is now logged once per PR while it stays promoted instead of every cycle, so it no longer trips the repeated-unclassified-error self-report ([#15578](https://github.com/hivecommons/hive/issues/15578)). diff --git a/src/cmd/hive/main_sweeps.go b/src/cmd/hive/main_sweeps.go index 5adbb646aa..0182af412d 100644 --- a/src/cmd/hive/main_sweeps.go +++ b/src/cmd/hive/main_sweeps.go @@ -2477,9 +2477,13 @@ func planReviewDispatchWith(ctx context.Context, cfg *config.Config, actionable for _, f := range plan.ForcedFixes { logger.Warn("review fix forced: changes_requested head starved by the revisit path", "repo", f.Repo, "pr", f.Number, "head", f.HeadSHA, "reason", f.Reason, "cycles", f.Cycles, "limit", review.RevisitStarvationCycles) } + promotedNow := map[string]struct{}{} for _, w := range plan.Promoted { - logger.Warn("review dispatch promoted: head starved of a reviewer walked ahead of the queue", "repo", w.Repo, "pr", w.Number, "head", w.HeadSHA, "reason", w.Reason, "cycles", w.Cycles, "since", w.FirstAt, "limit", review.ReviewWaitStarvationCycles) + key := prWarnKey(w.Repo, w.Number) + promotedNow[key] = struct{}{} + logger.Log(context.Background(), reviewPromotedWarn.level(key), "review dispatch promoted: head starved of a reviewer walked ahead of the queue", "repo", w.Repo, "pr", w.Number, "head", w.HeadSHA, "reason", w.Reason, "cycles", w.Cycles, "since", w.FirstAt, "limit", review.ReviewWaitStarvationCycles) } + reviewPromotedWarn.retain(promotedNow) for _, w := range plan.Waiting { logger.Info("review dispatch waiting: perspectives still owed, no reviewer this cycle", "repo", w.Repo, "pr", w.Number, "head", w.HeadSHA, "reason", w.Reason) } diff --git a/src/cmd/hive/warn_once_pr.go b/src/cmd/hive/warn_once_pr.go index 3182a47d19..7651d2f9c1 100644 --- a/src/cmd/hive/warn_once_pr.go +++ b/src/cmd/hive/warn_once_pr.go @@ -44,6 +44,7 @@ func (w *prWarnOnce) retain(active map[string]struct{}) { } var ( - humanLabelWarn prWarnOnce - reviewExpiredWarn prWarnOnce + humanLabelWarn prWarnOnce + reviewExpiredWarn prWarnOnce + reviewPromotedWarn prWarnOnce ) diff --git a/src/cmd/hive/warn_once_pr_test.go b/src/cmd/hive/warn_once_pr_test.go index 8c57366438..d3ab791a15 100644 --- a/src/cmd/hive/warn_once_pr_test.go +++ b/src/cmd/hive/warn_once_pr_test.go @@ -23,3 +23,15 @@ func TestPRWarnOnce(t *testing.T) { t.Fatal("cleared condition should re-arm") } } + +func TestReviewPromotedWarnOncePerPR(t *testing.T) { + reviewPromotedWarn.retain(map[string]struct{}{}) + k := prWarnKey("o/r", 15565) + if reviewPromotedWarn.level(k) != slog.LevelWarn { + t.Fatal("first promotion should warn") + } + if reviewPromotedWarn.level(k) != slog.LevelDebug { + t.Fatal("repeat promotion of the same PR should not warn again") + } + reviewPromotedWarn.retain(map[string]struct{}{}) +} From 44bbacd86fdd28e65364f910a67fed8430340c0c Mon Sep 17 00:00:00 2001 From: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> Date: Fri, 30 Oct 2026 03:40:39 -0400 Subject: [PATCH 2/3] =?UTF-8?q?=F0=9F=8C=B1=20test:=20cover=20warn-once=20?= =?UTF-8?q?promotion=20through=20the=20review=20dispatch=20loop?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Drive planReviewDispatchWith across several passes instead of poking the package-global tracker, so the test covers the dispatcher wiring. Refs #15627 Signed-off-by: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> --- src/cmd/hive/warn_once_pr_test.go | 73 ++++++++++++++++++++++++++++--- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/src/cmd/hive/warn_once_pr_test.go b/src/cmd/hive/warn_once_pr_test.go index d3ab791a15..9d0482e40f 100644 --- a/src/cmd/hive/warn_once_pr_test.go +++ b/src/cmd/hive/warn_once_pr_test.go @@ -1,8 +1,16 @@ package main import ( + "bytes" + "context" + "fmt" "log/slog" + "strings" "testing" + "time" + + "github.com/hivecommons/hive/pkg/github" + "github.com/hivecommons/hive/pkg/review" ) func TestPRWarnOnce(t *testing.T) { @@ -24,14 +32,65 @@ func TestPRWarnOnce(t *testing.T) { } } -func TestReviewPromotedWarnOncePerPR(t *testing.T) { +func promotedWarnCount(log string, pr int) (warns, debugs int) { + for _, line := range strings.Split(log, "\n") { + if !strings.Contains(line, "review dispatch promoted") || !strings.Contains(line, fmt.Sprintf("pr=%d ", pr)) { + continue + } + switch { + case strings.Contains(line, "level=WARN"): + warns++ + case strings.Contains(line, "level=DEBUG"): + debugs++ + } + } + return warns, debugs +} + +func TestPlanReviewDispatch_PromotionWarnsOncePerPR(t *testing.T) { + redirectReviewPaths(t) reviewPromotedWarn.retain(map[string]struct{}{}) - k := prWarnKey("o/r", 15565) - if reviewPromotedWarn.level(k) != slog.LevelWarn { - t.Fatal("first promotion should warn") + t.Cleanup(func() { reviewPromotedWarn.retain(map[string]struct{}{}) }) + + const otherPR = 4322 + pass := func(numbers ...int) string { + t.Helper() + var waits []review.ReviewWaitRecord + actionable := &github.ActionableResult{} + for _, n := range numbers { + waits = append(waits, review.ReviewWaitRecord{Repo: "hivecommons/hive", Number: n, HeadSHA: reviewTestSHA, Reason: review.ReviewWaitNoFreeReviewer, Cycles: review.ReviewWaitStarvationCycles, FirstAt: time.Now().Add(-time.Hour)}) + actionable.PRs.Items = append(actionable.PRs.Items, github.PullRequest{Repo: "hivecommons/hive", Number: n, Title: "test: add coverage", Author: "hive-bot", HeadSHA: reviewTestSHA}) + } + if err := review.WriteDispatchState("", review.DispatchState{Waits: waits}); err != nil { + t.Fatal(err) + } + var buf bytes.Buffer + logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{Level: slog.LevelDebug})) + plan := planReviewDispatchWith(context.Background(), reviewSwarmConfig(), actionable, nil, nil, nil, logger) + if len(plan.Promoted) != len(numbers) { + t.Fatalf("promoted = %+v, want %d heads", plan.Promoted, len(numbers)) + } + return buf.String() } - if reviewPromotedWarn.level(k) != slog.LevelDebug { - t.Fatal("repeat promotion of the same PR should not warn again") + expect := func(log string, pr, warns, debugs int) { + t.Helper() + if w, d := promotedWarnCount(log, pr); w != warns || d != debugs { + t.Fatalf("PR %d promotion logs: warn=%d debug=%d, want warn=%d debug=%d\n%s", pr, w, d, warns, debugs, log) + } } - reviewPromotedWarn.retain(map[string]struct{}{}) + + first := pass(4321, otherPR) + expect(first, 4321, 1, 0) + expect(first, otherPR, 1, 0) + + second := pass(4321, otherPR) + expect(second, 4321, 0, 1) + expect(second, otherPR, 0, 1) + + third := pass(4321) + expect(third, 4321, 0, 1) + + fourth := pass(4321, otherPR) + expect(fourth, 4321, 0, 1) + expect(fourth, otherPR, 1, 0) } From ff6ecc26575bd78e6d9c1b9763a9304ad3673ba7 Mon Sep 17 00:00:00 2001 From: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> Date: Fri, 30 Oct 2026 04:02:29 -0400 Subject: [PATCH 3/3] test: keep two heads in every promotion pass so a lone starved head is promotable Signed-off-by: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> --- src/cmd/hive/warn_once_pr_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/cmd/hive/warn_once_pr_test.go b/src/cmd/hive/warn_once_pr_test.go index 9d0482e40f..1399b00196 100644 --- a/src/cmd/hive/warn_once_pr_test.go +++ b/src/cmd/hive/warn_once_pr_test.go @@ -53,6 +53,9 @@ func TestPlanReviewDispatch_PromotionWarnsOncePerPR(t *testing.T) { t.Cleanup(func() { reviewPromotedWarn.retain(map[string]struct{}{}) }) const otherPR = 4322 + // fillerPR has no wait record: promotion only reorders a list of two or + // more heads, so it keeps a pass with a single starved head promotable. + const fillerPR = 4399 pass := func(numbers ...int) string { t.Helper() var waits []review.ReviewWaitRecord @@ -61,6 +64,7 @@ func TestPlanReviewDispatch_PromotionWarnsOncePerPR(t *testing.T) { waits = append(waits, review.ReviewWaitRecord{Repo: "hivecommons/hive", Number: n, HeadSHA: reviewTestSHA, Reason: review.ReviewWaitNoFreeReviewer, Cycles: review.ReviewWaitStarvationCycles, FirstAt: time.Now().Add(-time.Hour)}) actionable.PRs.Items = append(actionable.PRs.Items, github.PullRequest{Repo: "hivecommons/hive", Number: n, Title: "test: add coverage", Author: "hive-bot", HeadSHA: reviewTestSHA}) } + actionable.PRs.Items = append(actionable.PRs.Items, github.PullRequest{Repo: "hivecommons/hive", Number: fillerPR, Title: "test: add coverage", Author: "hive-bot", HeadSHA: reviewTestSHA}) if err := review.WriteDispatchState("", review.DispatchState{Waits: waits}); err != nil { t.Fatal(err) }