Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions changelog.d/fixed-merge-celebration-external.md
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
- Activity Monitor: a PR merged by anyone — a maintainer's `gh pr merge --admin` as much as the hive's own sweep — now leaves the board with the bee fly-off and a merge toast naming the merger (`#16644 merged by @clubanderson` / `merged by 🐝 hive`); `recently_merged` is the union of the audit log and the merged ledger with `merged_by`, an `issue_comment` on a just-merged PR no longer reads as "closed", and a closed-not-merged exit keeps its quiet toast (hivecommons/hive#16658).
35 changes: 35 additions & 0 deletions src/pkg/dashboard/merged_ledger.go
Original file line number Diff line number Diff line change
Expand Up @@ -397,6 +397,41 @@ func (l *MergedLedger) ClosedBy(repo string, issue, exclude int) int {
return 0
}

// Since lists the entries merged at or after since and not after now
// (plus the minute of clock skew Summary allows), newest first. The stage
// tracker's recently_merged reads it so a merge GitHub reported — by
// anyone — is a terminal fact for the SPA as soon as the ledger has it.
func (l *MergedLedger) Since(since, now time.Time) []MergedLedgerEntry {
if l == nil {
return nil
}
l.mu.Lock()
defer l.mu.Unlock()
var out []MergedLedgerEntry
for i := len(l.entries) - 1; i >= 0; i-- {
e := l.entries[i]
if e.MergedAt.After(now.Add(time.Minute)) {
continue
}
if e.MergedAt.Before(since) {
break
}
out = append(out, e)
}
return out
}

// Has reports whether the ledger lists repo#number as merged.
func (l *MergedLedger) Has(repo string, number int) bool {
if l == nil || number <= 0 {
return false
}
l.mu.Lock()
defer l.mu.Unlock()
_, ok := l.index[mergedLedgerKey(repo, number)]
return ok
}

// Len is the number of listed (unpruned) entries.
func (l *MergedLedger) Len() int {
l.mu.Lock()
Expand Down
127 changes: 89 additions & 38 deletions src/pkg/dashboard/stage_tracker.go
Original file line number Diff line number Diff line change
Expand Up @@ -77,13 +77,20 @@ type StageTrackerResponse struct {
// Engine is the ADR-0025 central stage engine's mode and counters for
// the tracker's status strip; absent when the hive has no engine.
Engine *stageengine.Status `json:"engine,omitempty"`
// RecentlyMerged lists the pull requests the hive saw merge within
// stageTrackerMergedWindow, from the audit log's pr_merged entries
// (sweep, queue, relay and human merges observed by the PR poller
// alike). Items only ever lists open work, so a merged PR simply
// drops out of Items on the next build; this side list is what lets
// the SPA tell "merged" from "closed" between two polls and play its
// opt-in merge sound for the right rows.
// RecentlyMerged lists the pull requests GitHub reports merged within
// stageTrackerMergedWindow, whoever merged them: the audit log's
// pr_merged entries (the hive's own sweep, queue, relay and forge
// merges, written the instant the merge call returns, and the PR
// poller's observations of human merges) united with the merged
// ledger's entries over the same window (webhook `closed` deliveries
// and their confirming reads, the closed sweep). Items only ever lists
// open work, so a merged PR simply drops out of Items on the next
// build; this side list is the terminal snapshot that lets the SPA
// tell "merged" from "closed" between two polls and celebrate the
// right rows. Before hivecommons/hive#16658 it carried audit entries
// only, so a merge by a human (`gh pr merge`) reached it minutes
// after the row had left — or never, when the PR poller's settle
// scan was behind — and the row vanished in silence.
RecentlyMerged []StageTrackerMerged `json:"recently_merged,omitempty"`
// RecentlyClosed lists the pull requests that left Items closed but
// not merged within stageTrackerMergedWindow — superseded, withdrawn,
Expand Down Expand Up @@ -127,6 +134,10 @@ type StageTrackerMerged struct {
Repo string `json:"repo"`
Number int `json:"number"`
MergedAt time.Time `json:"merged_at"`
// MergedBy is MergedByHive when the hive performed the merge, else the
// merger's GitHub login; "" when not (yet) known. The SPA's merge
// toast reads it ("merged by 🐝 hive" / "merged by @login").
MergedBy string `json:"merged_by,omitempty"`
}

// StageTrackerClosed is one recently closed, unmerged pull request.
Expand Down Expand Up @@ -177,54 +188,94 @@ func stageTrackerRepoQualifier(status *StatusPayload) func(string) string {
}
}

// stageTrackerRecentlyMerged reads the pr_merged audit entries newer than
// now-stageTrackerMergedWindow from the in-memory ring: newest first, one
// entry per (repo, number) after qualify has mapped short repo names onto
// the owner/name Items use. The ring holds auditRingCap entries and is the
// only source consulted — a window this short never needs the on-disk log,
// and reading files on every tracker build would defeat its cache.
// stageTrackerRecentlyMerged lists the PRs merged within
// now-stageTrackerMergedWindow, by anyone: the pr_merged audit entries in
// the in-memory ring united with the merged ledger's entries over the same
// window, newest first, one entry per (repo, number) after qualify has
// mapped short repo names onto the owner/name Items use. The ring holds
// auditRingCap entries and is the only audit source consulted — a window
// this short never needs the on-disk log, and reading files on every
// tracker build would defeat its cache.
func (s *Server) stageTrackerRecentlyMerged(now time.Time, qualify func(string) string) []StageTrackerMerged {
return s.stageTrackerMergedSince(now, stageTrackerMergedWindow, qualify)
}

// stageTrackerMergedSince is stageTrackerRecentlyMerged over any window.
func (s *Server) stageTrackerMergedSince(now time.Time, window time.Duration, qualify func(string) string) []StageTrackerMerged {
if s == nil || s.audit == nil {
if s == nil {
return nil
}
if qualify == nil {
qualify = func(repo string) string { return repo }
}
seen := map[string]bool{}
index := map[string]int{}
var out []StageTrackerMerged
for _, e := range s.audit.RecentWithPrefixSince(now.Add(-window), github.AuditActionPRMerged) {
if e.Action != github.AuditActionPRMerged {
continue
}
repo, ok := collect.AuditEntryRepo(e)
if !ok {
continue
}
repo = qualify(repo)
number := e.Target
if number == 0 {
if m := stageTrackerAuditNumberRe.FindStringSubmatch(e.Detail); m != nil {
number, _ = strconv.Atoi(m[1])
key := func(repo string, number int) string { return strings.ToLower(repo) + "#" + strconv.Itoa(number) }
// An audit entry whose short repo name no configured repo accounts for
// stays short, while the ledger qualified the same merge with the
// configured org: match the two on the short name so one merge is
// listed once.
short := func(repo string) string { return strings.ToLower(repo[strings.LastIndex(repo, "/")+1:]) }
shortIndex := map[string]int{}
// Audit entries first: the hive's own merge writes one the instant the
// merge call returns, so its merged_at is the sharpest.
if s.audit != nil {
for _, e := range s.audit.RecentWithPrefixSince(now.Add(-window), github.AuditActionPRMerged) {
if e.Action != github.AuditActionPRMerged {
continue
}
repo, ok := collect.AuditEntryRepo(e)
if !ok {
continue
}
repo = qualify(repo)
attrs := parseAuditDetailAttrs(e.Detail)
number := e.Target
if number == 0 {
if m := stageTrackerAuditNumberRe.FindStringSubmatch(e.Detail); m != nil {
number, _ = strconv.Atoi(m[1])
}
}
if number <= 0 {
continue
}
k := key(repo, number)
if i, dup := index[k]; dup {
if out[i].MergedBy == "" {
out[i].MergedBy = mergedByFromAudit(attrs)
}
continue
}
at, err := time.Parse(time.RFC3339, e.Timestamp)
if err != nil {
at = now
}
index[k] = len(out)
if !strings.Contains(repo, "/") {
shortIndex[key(short(repo), number)] = len(out)
}
out = append(out, StageTrackerMerged{Repo: repo, Number: number, MergedAt: at.UTC(), MergedBy: mergedByFromAudit(attrs)})
}
if number <= 0 {
continue
}
// Then the ledger: a merge GitHub reported through a webhook, its
// confirming read or the closed sweep, by whoever performed it, is a
// terminal fact for the SPA the moment the row leaves — it must not
// wait for the PR poller's settle scan to write an audit line.
for _, e := range s.mergedLedger().Since(now.Add(-window), now) {
repo := qualify(e.Repo)
k := key(repo, e.Number)
i, dup := index[k]
if !dup {
i, dup = shortIndex[key(short(repo), e.Number)]
}
key := repo + "#" + strconv.Itoa(number)
if seen[key] {
if dup {
if out[i].MergedBy == "" {
out[i].MergedBy = e.MergedBy
}
continue
}
seen[key] = true
at, err := time.Parse(time.RFC3339, e.Timestamp)
if err != nil {
at = now
}
out = append(out, StageTrackerMerged{Repo: repo, Number: number, MergedAt: at.UTC()})
index[k] = len(out)
out = append(out, StageTrackerMerged{Repo: repo, Number: e.Number, MergedAt: e.MergedAt.UTC(), MergedBy: e.MergedBy})
}
sort.SliceStable(out, func(i, j int) bool {
if !out[i].MergedAt.Equal(out[j].MergedAt) {
Expand Down
4 changes: 4 additions & 0 deletions src/pkg/dashboard/stage_tracker_cues_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -43,6 +43,8 @@ func stageTrackerCuesJS(t *testing.T, html string) string {
jsFunc(t, html, "stageTrackerPRTitles"),
jsFunc(t, html, "stageTrackerMergedText"),
jsFunc(t, html, "stageTrackerMergedByText"),
jsFunc(t, html, "stageTrackerMergerText"),
jsFunc(t, html, "stageTrackerMergedByOf"),
jsFunc(t, html, "stageTrackerMergedPopHtml"),
jsFunc(t, html, "stageTrackerPRKey"),
"let _stageTrackerEvents = {}; var _stageTrackerPRTitle = {};",
Expand Down Expand Up @@ -332,6 +334,8 @@ func stageTrackerCelebrateJS(t *testing.T, html string) string {
jsFunc(t, html, "stageTrackerPRTitles"),
jsFunc(t, html, "stageTrackerMergedText"),
jsFunc(t, html, "stageTrackerMergedByText"),
jsFunc(t, html, "stageTrackerMergerText"),
jsFunc(t, html, "stageTrackerMergedByOf"),
jsFunc(t, html, "stageTrackerMergedPopHtml"),
jsFunc(t, html, "stageTrackerMergedSync"),
jsFunc(t, html, "stageTrackerMergedHoldback"),
Expand Down
74 changes: 74 additions & 0 deletions src/pkg/dashboard/stage_tracker_external_merge_celebrate_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,74 @@
package dashboard

import (
"strings"
"testing"
)

// TestStageTrackerExternalMergeCelebrateNode (hivecommons/hive#16658): a
// row that leaves the payload is celebrated on any merged terminal fact,
// whoever merged it — the hive's own sweep (bee + "merged by 🐝 hive") and
// a maintainer's `gh pr merge --admin` (bee + "merged by @clubanderson")
// alike; a closed-not-merged exit draws only the quiet info toast; and a
// close the server later corrects to a merge still celebrates once.
func TestStageTrackerExternalMergeCelebrateNode(t *testing.T) {
html := indexHTML(t)
js := strings.Replace(stageTrackerCelebrateJS(t, html), stageTrackerMergingHoldOffJS, stageTrackerMergingHoldJS(t, html), 1)
runStageTrackerRowActionsScript(t, js+stageTrackerCelebrateFixture+`
const iso = ms => new Date(ms).toISOString();
const srv = (all, today) => ({ all_time: all, today, total_7d: today, total_30d: today, recent: [], tz: 'UTC', day_start: iso(stageTrackerLocalMidnight(clock)) });
const pr = (num, extra) => Object.assign({ repo: 'o/r', kind: 'pr', number: num, stage: 50, title: 'fix ' + num }, extra || {});
const merged = (num, by) => ({ repo: 'o/r', number: num, merged_at: iso(clock), merged_by: by });
const poll = d => { _stageTracker = d; stageTrackerNoteMerges(d); };
const lastBanner = () => banners.children[banners.children.length - 1].innerHTML;
// Banners time out across the ticks below, so count the ones made, not the ones still up.
let made = 0; const _banner = stageTrackerMergeBanner; stageTrackerMergeBanner = (...a) => { made++; return _banner(...a); };
panel.appendChild(row('o/r/pr#16644')); panel.appendChild(row('o/r/pr#16645')); panel.appendChild(row('o/r/pr#16646')); panel.appendChild(row('o/r/pr#16647'));
poll({ items: [pr(16644), pr(16645), pr(16646), pr(16647)], merged: srv(10, 1) });
// #16645: the hive's own merge → bee + banner naming the hive.
tick(10000);
poll({ items: [pr(16644), pr(16646), pr(16647)], recently_merged: [merged(16645, 'hive')], merged: srv(11, 2) });
tick(0);
assert.strictEqual(made, 1, 'hive merge: one banner');
assert.ok(lastBanner().includes('#16645</span> merged by <span class="merge-banner-by">🐝 hive</span>'), lastBanner());
assert.strictEqual(flights().length, 1, 'hive merge: one bee');
flights()[0]._ev.animationend();
// #16644: merged by hand (gh pr merge --admin --squash), no audit line
// yet — recently_merged carries it from the ledger with the merger → the
// same bee + banner, naming @clubanderson.
tick(10000);
poll({ items: [pr(16646), pr(16647)], recently_merged: [merged(16644, 'clubanderson'), merged(16645, 'hive')], merged: srv(12, 3) });
tick(0);
assert.strictEqual(made, 2, 'external merge: one banner');
assert.ok(lastBanner().includes('#16644</span> merged by <span class="merge-banner-by">@clubanderson</span>'), lastBanner());
assert.strictEqual(flights().length, 1, 'external merge: one bee');
assert.deepStrictEqual(toasts, [], 'a merge is never a closed toast');
flights()[0]._ev.animationend();
// #16646: closed, not merged → one quiet info toast, no bee, no banner.
tick(10000);
poll({ items: [pr(16647)], recently_closed: [{ repo: 'o/r', number: 16646, closed_at: iso(clock) }], recently_merged: [merged(16644, 'clubanderson'), merged(16645, 'hive')], merged: srv(12, 3) });
tick(0);
assert.deepStrictEqual(toasts, [['info', '#16646 closed · closed without merging']]);
assert.strictEqual(made, 2, 'no banner for a close'); assert.strictEqual(flights().length, 0, 'no bee for a close');
// #16647: a bot's comment on the just-merged PR read as "closed" first;
// the next poll carries the merge → the celebration still fires, once.
tick(10000);
poll({ items: [], recently_closed: [{ repo: 'o/r', number: 16647, closed_at: iso(clock) }], recently_merged: [merged(16644, 'clubanderson'), merged(16645, 'hive')], merged: srv(12, 3) });
tick(0);
assert.strictEqual(toasts.length, 2); assert.strictEqual(toasts[1][1], '#16647 closed · closed without merging');
assert.strictEqual(made, 2); assert.strictEqual(flights().length, 0);
tick(10000);
poll({ items: [], recently_merged: [merged(16647, 'clubanderson'), merged(16644, 'clubanderson'), merged(16645, 'hive')], merged: srv(13, 4) });
tick(0);
assert.strictEqual(made, 3, 'a close corrected to a merge celebrates');
assert.ok(lastBanner().includes('#16647</span> merged by <span class="merge-banner-by">@clubanderson</span>'), lastBanner());
assert.strictEqual(flights().length, 1);
flights()[0]._ev.animationend();
tick(10000);
poll({ items: [], recently_merged: [merged(16647, 'clubanderson'), merged(16644, 'clubanderson'), merged(16645, 'hive')], merged: srv(13, 4) });
tick(0);
assert.strictEqual(made, 3, 'never twice'); assert.strictEqual(flights().length, 0);
assert.strictEqual(toasts.length, 2);
console.log('ok');
`)
}
79 changes: 79 additions & 0 deletions src/pkg/dashboard/stage_tracker_external_merge_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
package dashboard

import (
"testing"
"time"

"github.com/hivecommons/hive/pkg/github"
)

// TestStageTrackerRecentlyMergedAnyMerger (hivecommons/hive#16658):
// recently_merged is the union of the audit's pr_merged lines and the
// merged ledger, each naming the merger — so a PR a maintainer merged by
// hand (`gh pr merge --admin`), which reaches the ledger through the
// webhook's closed read long before the PR poller writes an audit line,
// is a terminal fact for the SPA the moment its row leaves. One merge
// known to both sources is listed once, newest first.
func TestStageTrackerRecentlyMergedAnyMerger(t *testing.T) {
now := time.Date(2026, 10, 20, 21, 0, 0, 0, time.UTC)
s, store := stageTrackerFixture(t, now)
ts := func(d time.Duration) string { return now.Add(-d).UTC().Format(time.RFC3339) }

s.audit.LogRecordAt(ts(3*time.Minute), "system", github.AuditActionPRMerged, "method=squash, path=sweep", "governor", "acme/console", 16645)
s.recordMergedSnapshots([]github.WebhookItemSnapshot{
{Repo: "acme/console", Number: 16644, IsPR: true, State: "closed", Merged: true, MergedAt: now.Add(-time.Minute), MergedBy: "clubanderson"},
{Repo: "acme/console", Number: 16645, IsPR: true, State: "closed", Merged: true, MergedAt: now.Add(-3 * time.Minute), MergedBy: "hive-bot", MergedByHive: true},
{Repo: "acme/console", Number: 16600, IsPR: true, State: "closed", Merged: true, MergedAt: now.Add(-stageTrackerMergedWindow - time.Minute), MergedBy: "alice"},
{Repo: "acme/console", Number: 16646, IsPR: true, State: "closed", Merged: false, UpdatedAt: now.Add(-time.Minute)},
})

got := s.buildStageTracker(s.status, store, now).RecentlyMerged
want := []StageTrackerMerged{
{Repo: "acme/console", Number: 16644, MergedAt: now.Add(-time.Minute), MergedBy: "clubanderson"},
{Repo: "acme/console", Number: 16645, MergedAt: now.Add(-3 * time.Minute), MergedBy: MergedByHive},
}
if len(got) != len(want) {
t.Fatalf("recently_merged = %+v, want %+v", got, want)
}
for i := range want {
if got[i].Repo != want[i].Repo || got[i].Number != want[i].Number || !got[i].MergedAt.Equal(want[i].MergedAt) || got[i].MergedBy != want[i].MergedBy {
t.Fatalf("recently_merged[%d] = %+v, want %+v", i, got[i], want[i])
}
}
}

// TestStageTrackerClosedSnapshotNeverOutranksMerge (hivecommons/hive#16658):
// a closed-but-not-merged snapshot for a PR the ledger holds as merged
// (an issue_comment hint cannot tell the two apart) is not listed in
// recently_closed, and a later merged snapshot for a PR already listed
// there withdraws it — "closed" is never the SPA's final word on a merge.
func TestStageTrackerClosedSnapshotNeverOutranksMerge(t *testing.T) {
s := &Server{}
now := time.Now()
closed := func(n int) github.WebhookItemSnapshot {
return github.WebhookItemSnapshot{Repo: "o/r", Number: n, IsPR: true, State: "closed", UpdatedAt: now}
}
merged := func(n int, by string) github.WebhookItemSnapshot {
return github.WebhookItemSnapshot{Repo: "o/r", Number: n, IsPR: true, State: "closed", Merged: true, MergedAt: now, MergedBy: by}
}
// Merge known first: the closed read is ignored.
s.recordMergedSnapshots([]github.WebhookItemSnapshot{merged(16644, "clubanderson")})
s.noteClosedSnapshots([]github.WebhookItemSnapshot{closed(16644), closed(16646)})
if got := s.stageTrackerRecentlyClosed(now); len(got) != 1 || got[0].Number != 16646 {
t.Fatalf("recently closed = %+v, want [16646]", got)
}
// Closed read first, merge after: the entry is withdrawn.
s.noteClosedSnapshots([]github.WebhookItemSnapshot{closed(16647)})
if got := s.stageTrackerRecentlyClosed(now); len(got) != 2 {
t.Fatalf("recently closed = %+v, want 16647 and 16646", got)
}
snaps := []github.WebhookItemSnapshot{merged(16647, "clubanderson")}
s.recordMergedSnapshots(snaps)
s.forgetClosedSnapshots(snaps)
if got := s.stageTrackerRecentlyClosed(now); len(got) != 1 || got[0].Number != 16646 {
t.Fatalf("recently closed after the merge = %+v, want [16646]", got)
}
if !s.mergedLedger().Has("o/r", 16647) || s.mergedLedger().Has("o/r", 16646) {
t.Fatal("ledger: want 16647 merged and 16646 not")
}
}
Loading
Loading