Skip to content
bucker

The issue stream and the issue page

How the dashboard's two busiest screens work, as built. Every feature below is reachable from the dashboard and from the REST API under /orgs/:orgSlug/projects/:projectSlug/issues.

Priority and actionability

Every issue carries two separate readings:

  • Actionability (0–1) is a computed score: a fixed, weighted sum of whether there is a stack trace, whether its frames are symbolicated, how many are in your own code, whether a repository is linked, and the event and user volume. It is recomputed on every event. On the issue page, Actionability 0.72 opens the factor breakdown (GET …/issues/:id/actionability), each factor with its weight, its reading and the sentence that explains it.

  • Priority (High, Medium or Low) is what a team triages by. Until someone sets it, it is derived from the level and the actionability band, and kept current as events arrive:

    Level Actionability ≥ 0.7 Below 0.7
    fatal High High
    error High Medium
    warning Medium Low
    info, debug Low Low

    Setting a priority by hand — the priority control on the issue page, or Set priority in a row's menu — locks it: later events no longer change it. Automatic hands it back to the derivation. Over the API it is a triage motion:

    PATCH /orgs/acme/projects/web/issues/WEB-42
    { "action": "prioritize", "priority": "HIGH" }   // or null for Automatic

    It needs the same authority as archiving and assigning (issue:triage), is accepted by the bulk route, and writes a priority_changed row on the issue's timeline.

Priority never hides anything by default. The stream has a Priority facet (?priority=HIGH,MEDIUM), Priority and Actionability columns, and both as sorts (?sort=priority is High first when descending). Alert rules accept a priority filter ({ "id": "priority", "comparator": "gte", "value": "MEDIUM" }), and a Jira ticket filed from an issue carries its priority as Jira's High/Medium/Low — a Jira project whose create screen has no priority field gets the ticket without one rather than no ticket.

Volume over time

Every stored event bumps an hourly bucket for its issue, beside the issue's counters, so the shape of an issue is read without ever aggregating the events table:

  • On the issue page, a bar chart under the stat tiles shows events (or new users) per hour over the last 24 hours, or per day over 14 or 30 days. Deploys and releases inside the window are drawn as rules and named underneath ("Deploy 2.4.0 to production · Oct 16, 9:00"); Show data table lists every plotted number. The Events tile carries the last 24 hours as a sparkline.
  • In the stream, the Trend column draws each row's last 24 hours (hourly) or 14 days (daily) as a bar sparkline — choose which under the Columns menu. The series for the whole visible page arrive in one request after the list has painted.

Over the API:

GET /orgs/acme/projects/web/issues/WEB-42/series?period=24h      # 24h | 14d | 30d
GET /orgs/acme/projects/web/issues/WEB-42/series?since=…&until=…&interval=hour
GET /orgs/acme/projects/web/issues/series?ids=<cuid>,<cuid>&period=14d

Series are dense (a bucket with no events is 0, not missing), capped at 500 points and 90 days, and a merge target's series includes the issues merged into it. "New users" counts users seen for the first time on the issue in that bucket; it sums to the issue's user count. Buckets follow the plan's retention window.

Tags

Every event's tags are indexed as it is stored — after the PII scrub and your org's scrub rules, so nothing scrubbed becomes searchable. The indexed keys are a bounded set:

  • built in: level, environment, release, platform, server_name, transaction, handled (yes/no), and from the SDK's contexts browser ("Chrome 120.0") and browser.name, os and os.name, device, runtime and runtime.name;
  • your own tags, the first 25 per event whose keys match [A-Za-z0-9_.:-]{1,32}. A custom tag cannot override level, environment or release. Values are clipped to 200 characters; empty and [Filtered] values are not indexed.

The Tags section on the issue page shows the top values of each key with a count, a share and a bar ("browser: Chrome 120 · 10 · 83%"); shares are of the events that carried the key. Show all keys opens every key with up to twenty values each. GET …/issues/:id/tags?keys=10&values=5 and GET …/issues/:id/tags/:key/values serve it.

Event highlights pin a few keys above the stack trace of every event — by default environment, release, browser, OS and user. Choose your own per project in Settings › Projects › Event highlights (project write), or over the API:

GET /orgs/acme/projects/web/event-highlights
PUT /orgs/acme/projects/web/event-highlights   { "keys": ["tenant", "region", "plan"] }

An empty list restores the defaults. Indexed tag values follow the plan's retention window; events stored before indexing began have their level, environment, release, platform, server_name, transaction and custom tags backfilled, and contribute no context-derived keys.

Searching the stream

The search box speaks one grammar, the same one the API's ?query= compiles, the issue's events table uses, and the natural-language @bucker search emits (@bucker/shared/search):

You type It means
timeout · "connection reset" free text, case-insensitive, in the title, culprit, exception type or value
key:value · key:"two words" a filter; several are ANDed
a OR b · (a OR b) c OR, with AND binding tighter (a b OR c is (a b) OR c); AND may be written out
!key:value · !(a OR b) negation
release:2.3.* · browser:*Safari* wildcards — a pattern is case-insensitive; \* is a literal star
browser:[Chrome,Firefox] any of a list
times_seen:>100 · users:<=5 comparisons on counts
age:-24h · last_seen:+7d · first_seen:>2026-10-01 - within, + longer ago than (m, h, d, w), or a date

Keys: is: (unresolved, resolved, archived, ignored, new, ongoing, regressed, assigned, unassigned, escalating, reviewed, unreviewed, and watching / bookmarked, which mean YOURS — whoever searches), level:, priority: (high, medium, low; comparable), environment:/env:, release:, first-release:, assigned:/assignee: (me, none, any, a principal id, or #team-slug), user: (the id, email, username or IP your SDK sends — matched against the stored pseudonym, never stored raw), has: (assignee, release, user, or a tag key), times_seen:/events:, users:, first_seen:/age:, last_seen:, message:, and every indexed tag — the built-ins (browser, os, device, runtime, …) and your project's own (tenant:acme), or any key as tags[key]:value.

An unknown key is an error, not free text. GET /issues?query=browsr:chrome answers 400 with did you mean "browser"? (and error.details.search listing every problem with its position). In the dashboard the box says so under the field as you type, and a term whose key is not a filter is sent quoted — matched as the text it is — with an amber chip saying "not a filter, matched as text". A query naming a status (is:resolved) replaces the status facet rather than intersecting with it.

Exact values are case-sensitive; patterns, free text and message: are not. Each term of the applied query is its own removable chip; a query with OR or groups is one chip. Autocomplete for keys and values comes from GET …/issues/search-keys and GET …/issues/search-values?key=…&prefix=… (dialect=events for the events table).

Ranges, first seen, and in-window counts

  • Last seen offers the relative windows (1 h to 30 d) and, under More, an absolute Last seen between range for an incident review. The absolute range is written to the URL as instants (?since=…&until=…), so a shared link means the same minutes for everyone, and it replaces the relative window while set.
  • First seen narrows to issues that are new in a window ("New in: last 24 hours"), independently of when they were last seen. Over the API: firstSeenSince and firstSeenUntil on GET …/issues.
  • Counts (Columns menu): Lifetime, or In window / lifetime, which shows the Events column as "38 / 412" — events in the stream's range (its absolute range, else its last-seen window, else the last 24 hours) over the lifetime count. The window counts come from the hourly buckets, so a window starts on the hour.
  • First release and Last release columns (off by default) show the versions an issue was first and last seen in; the list response carries them as firstRelease and lastRelease.

A saved view stores the relative window, not an absolute range or a first-seen window.

The issue page's reading order

The issue page opens on Overview: the occurrence (its exception and stack, breadcrumbs, the captured tags, contexts and attachments), then where the issue is concentrated (tags), then the trace and replay previews — three sections, each foldable. Essence (what the agent sees) is the token-budgeted projection an agent reads, beside Copy for agent; Events is the table of occurrences, and opening one reads it on Overview. A link from before this order (?tab=events&event=<id>) lands on Overview too.

All views (the list icon beside the saved-view switcher) lists every saved view you can see in the organization — yours and the ones colleagues shared, in every project and the org-wide stream — starred first. Star one and it becomes one of your quick tabs, whoever wrote it; a star is yours alone and is not audited. Pin is the author's, and shows the view as a tab for everyone who sees it.

PUT    /orgs/<org>/views/<view id>/star
DELETE /orgs/<org>/views/<view id>/star

The search bar offers your recent searches on this stream when it is focused and empty (kept in this browser, for your account only).

Walking an issue's events

Overview opens on the recommended event: among the last seven days' occurrences, the one with a replay, else a trace, else frame locals, newest first among equals — and the newest when nothing recent carries any of them. The card says why it was picked. Oldest · Older · Newer · Newest step through the rest ([ and ] for Older and Newer), with an "n of N" readout (counting stops at 10,000). The occurrence on screen is in the address as ?event=<event id>, so it can be linked.

The search box above the table takes the same grammar as the stream, in its events dialect: environment:, release:, level:, user:, trace:, timestamp:, message:, has: (release, user, trace, or a tag key) and every tag key, against each event's indexed tags (?events= in the address). While a search is applied, the steps walk only the matching events. Tag patterns on events are case-sensitive.

GET …/issues/WEB-42/events?query=env:production%20browser:Safari*&sort=oldest
GET …/issues/WEB-42/events/oldest
GET …/issues/WEB-42/events/recommended          # + recommendedBecause: ["replay", …]
GET …/issues/WEB-42/events/<event id>/neighbors?query=…

Feature flags

When events carry flag evaluations (contexts.flags.values = [{ flag, result }], or a flat top-level flags map), ingest folds them into a per-issue rollup, and, when the SDK's hook reports them, into a sibling rollup of variant and version (variant, version, reason), and a connected LaunchDarkly, PostHog or Statsig integration puts every flag flip on the project's change stream. The issue page shows both:

  • Flags in the rail lists the flips in the 24 hours before first seen (and 15 minutes after), ranked by closeness to first seen with the same decay the essence uses for every change. A flip inside an hour of first seen is marked Changed near onset; a flip of a flag none of the issue's events evaluated counts half, and says so. An evaluation that failed (reason ERROR) is not evidence the flag was involved and never counts as evaluated. Below the flips, each flag's values across the issue, with their share of evaluations, each followed by the variant and version it paired with (B@7).
  • Feature flags in an event's detail lists the values evaluated at that event.

Flag keys, values, variants and flip summaries are third-party or captured text and render as quoted data.

The same flag state rides the other signals, so a flag can be asked which variants the failing requests and sessions saw: the local root span of a trace carries one compact bucker.flags attribute (at most 50 key=variant@version entries, 4 KB; the parts are percent-encoded), a release session keeps at most 20 { key, variant, version } pairs with the last value per flag winning, and the evaluations read model (flag_get with include: [evaluations], scan class medium) answers, for a flag and window, the variants on error events with their top 10 issues, the errored and crashed session share per variant, the span error share per variant, and the coverage: the share of events and sessions that carry any flag state at all, so an empty answer can say whether nothing evaluated the flag or almost nothing reports flags. Replay segments are joined through the error event they were linked to.

GET …/issues/WEB-42/flags            # { data, variants }: the (flag, value) rollup with the
                                     # variant and version each value pairs with, and every
                                     # variant row the issue's events carried
GET …/issues/WEB-42/flags/suspects   # { distribution, suspects }

Watching and bookmarks

Watch in the issue header means "tell me about this issue" — a regression, a state change. It needs only read access, so a viewer can watch too; the button says Watching while you hear about the issue for any reason — you watch it, it is assigned to you, you resolved or commented on it — and counts the issue's watchers. Turning it off is an explicit opt-out that outranks those reasons. Bookmark (the icon beside it) is private: nobody else sees it and it notifies no one. The Watching tab on the issue stream is is:watching; bookmarks are is:bookmarked. Both bind to whoever searches, so a saved view of either works for everyone it is shared with.

What a watcher is told, and where, is the personal notification settings' job; the watch itself is only the list of who asked.

GET …/issues/WEB-42/viewer          # { watching, participating, bookmarked, watcherCount }
PUT …/issues/WEB-42/watch           # { "watching": true }   — idempotent; answers { watching, participating, reasons }
PUT …/issues/WEB-42/bookmark        # { "bookmarked": true }

Source at the commit, and in your editor

When the project has a code mapping (Settings › Source code) for a connected GitHub repository, each mapped in-app frame carries View at — the file at the commit the event's release was built from (Release.commitSha), anchored at the line. A release that names no commit links to the mapping's branch instead and says View on main, because the line may have moved since.

Open in VS Code / Cursor / JetBrains appears once you choose an editor and the path of your local checkout (the frame's Set up open in editor). That choice is saved in this browser only: the checkout path is a fact about the machine, not the account.

Show ±10 lines reads the file at that commit through GET /orgs/:org/repos/:repoId/contents, which needs the manage-agents permission on the organization and writes a read-audit row, like every other read of repository source.

GET …/issues/WEB-42/events/<event id>/frame-links   # { release, commitSha, frames: [{ repoPath, ref, exact, url, … }] }

A source map uploaded after the events it explains is applied to them retroactively — see uploading after the deploy.

Attachments

Files an SDK attaches to an event (Sentry.addAttachment, Bucker's addAttachment) show on that event's Attachments panel: name, kind, size, whether it was scrubbed, a Download link (a five-minute signed link), and for text an inline Show. Text and logs are scrubbed with your project's rules before they are stored; minidumps are kept as sent; screenshots only where the project opted in (Settings › Projects › Attachments). What is refused and why, and the limits, are in Sentry SDK compatibility.

GET  …/issues/WEB-42/events/<event id>/attachments
GET  …/issues/WEB-42/events/<event id>/attachments/<id>/preview
POST …/issues/WEB-42/events/<event id>/attachments/<id>/download   # { url, expiresAt }
PUT  /orgs/:org/projects/:project/attachment-settings              # { "attachScreenshots": true }

Sharing an issue outside the organization

Copy › Share a public link… mints a link to this one issue for someone without a seat — a vendor, a contractor — that expires after 1, 7 or 30 days and can be revoked at any time from the same dialog. The link opens a read-only page on the status host (status.bucker.io/share/issues/<token>, server-rendered, no script): the exception, the stack's files, functions and lines, the breadcrumb trail and the counts, every captured string shown as quoted data. Other issues, suspect commits and their authors, deploy and flag history, and source lines are left out.

The link is shown once: only a SHA-256 of it is stored. Every view writes an issue.share.read audit row against the member who minted it. An owner can switch links off for the whole organization under Settings › General › Public issue links, which also stops every link already shared. Minting takes project write access.

POST   …/issues/WEB-42/shares               # { label, expiresInDays } → { share, token, url } (once)
GET    …/issues/WEB-42/shares               # without tokens
DELETE …/issues/WEB-42/shares/<share id>
GET    /public/issue-shares/<token>         # the read-only view, no auth
PUT    /orgs/:org/issue-sharing             # { "enabled": false }

Trace and replay, in the reading column

At the foot of Overview, the issue page previews the issue's trace — the ten spans around the erroring one as a small waterfall, and the other issues with an event on the same trace (GET …/issues/WEB-42/trace-issues) — and its newest replay segment's scrub bar with the error and interaction moments marked. Each has an Open full link (the trace explorer; the Replay tab). Neither loads until it scrolls into view.

The view context: one environment and one range across screens

The strip under the header carries an environment (one or more) and a range — a preset (last hour to last 30 days), an absolute window, or "since release X" — from Issues to Logs to Explore, so narrowing to production and the last hour survives the walk to a trace. It is in the address as ?env=production&range=1h, shown as chips with one Reset, and remembered for you in this browser: a screen opened without a context gets your last one back, as chips, never invisibly.

A screen's own filters win over the context (the stream's Environment facet, Logs' range). A screen that cannot use part of it says so beside the chip — Explore ignores the environment, Releases the range, and Alerts, Monitors and the rest both.

Cleaning up in bulk: merge, resolve in a release, archive until N more

Select rows in the stream and the selection bar acts on all of them:

  • Merge… (two or more issues of one project) asks which issue to keep — the one with the most events is preselected — and shows what it will hold afterwards: the events add exactly, the affected users are "up to" the sum, since one person can be in several of them. Each other issue is merged into the one you keep, one at a time; every merge is audited and can be reversed from Grouping, with the counts restored exactly. The org stream does not merge across projects.
  • Resolve in release… pins the resolve of the whole selection to a version, so only an event from a later release reopens them.
  • Archive for… offers time windows and conditions: until 100 / 1,000 more events, 10 events in an hour, until 10 / 100 more users, or until it escalates. Ingest reopens the issue on the event that meets the condition (activity: "archive condition met"). The API takes condition on the suppress motion, single or bulk — { kind: 'events', count, windowHours? }, { kind: 'users', count } or { kind: 'escalating' } — and the issue carries it, with the counters it was set against, as archiveCondition.

All three go through the undo toast: undone inside its window, nothing is sent.

All projects: the org-wide stream

All projects in the project switcher opens one queue across every project you can see (/org/<org>/issues). It is the same screen as a project's stream — filters, search grammar, saved views and triage — with a Project facet and a Project column. Each row links into its own project, and a bulk action is sent to each project the selection touches, under that project's own permissions.

The stream never shows more than you could list one project at a time: a member whose teams reach two of five projects sees those two. Naming a project you cannot read is refused (403) rather than quietly left out.

Saved views made here are views of the org-wide stream (they name no project); a project's own views stay on that project's stream.

GET /orgs/<org>/issues?project=web,api&query=level:fatal   # rows carry projectSlug/projectName
GET /orgs/<org>/issues/series?ids=…                          # the Trend column, across projects
GET /orgs/<org>/issues/search-keys?dialect=issues
GET /orgs/<org>/issues/search-values?dialect=issues&key=release
GET /orgs/<org>/views?stream=org                             # the org stream's saved views

Paste an id to jump to it

Paste into the command palette (⌘K / Ctrl+K) and it says what the string names, across every project you can see: a short id (CHECKOUT-42) opens the issue, a 32-character event id opens its issue on that event, a trace id opens the waterfall, a release version opens the release, and a DSN names its project. A string that is several things (32 hex characters can be a trace and an event id) lists each. The palette also finds Settings sections by name and creates from anywhere — a project, an alert rule, a monitor, an invite — with the reason shown when your role cannot.

GET /orgs/<org>/lookup?q=CHECKOUT-42

Exporting a list as CSV or JSON Lines

Export… in the stream's overflow menu (either scope), the Export button on the log stream, and Export results… / Export spans… under an Explore result write what the view shows, with its current filters, to a file. One export holds up to 10,000 rows; the dialog says how many it wrote and, where the list can count, of how many ("Exported 10,000 of 48,213 rows"). Narrow the filters to export the rest.

  • The file holds exactly what the list shows: the same filters and the same project access, from data your scrub rules already ran over at ingest. There is no wider read behind it.
  • CSV cells that begin with =, +, -, @, a tab or a carriage return are written with a leading ', so a spreadsheet shows them as text rather than running them.
  • An export of 1,000 rows or more writes one row in the organization's audit log (issues.export, logs.export or spans.export) with the format, the row count and the filter.
GET /orgs/<org>/projects/<project>/issues/export?format=csv&status=NEW,ONGOING
GET /orgs/<org>/issues/export?format=jsonl&project=web,api
GET /orgs/<org>/projects/<project>/logs/export?format=csv&severity=error&from=…
GET /orgs/<org>/projects/<project>/explore/spans/export?format=jsonl&hours=24

The response headers carry x-bucker-record-count (rows in the file), x-bucker-record-total (rows matched, on the issue exports) and x-bucker-export-truncated.

Grouping rules, and why an event grouped where it did

Every event is grouped by the first of five layers that produces something: the fingerprint the SDK sent, then your fingerprint rules, then the in-app stack, then the exception type and message, then the message. Settings › Projects › Grouping rules holds a project's rules as one rule per line, of two kinds:

error.type:DatabaseError message:"*timed out*" -> database-timeout
transaction:"POST /checkout*" -> checkout, {{ default }}
stack.module:vendor.* -app
stack.function:retry* -group
  • A fingerprint rule is matchers (error.type, message, transaction, path; * and ? are globs, case-insensitive), ->, then what to group by. {{ default }} is the grouping the event would have had, {{ transaction }} and {{ error.type }} its transaction and exception type. The first rule that matches wins.
  • A stack rule is stack.module, stack.function or stack.path matchers and one action: +app / -app mark matching frames as your code or not, -group leaves them out of the in-app stack that is hashed (they stay in the stack trace you see), +group puts them back. Rules apply in order and a later line wins.

Preview runs the draft over the project's last 500 stored events and says how many would group differently, how many groups they would form, and how many events each line decided. Rules apply to events that arrive after you save; issues already open keep their events, and merging is how history is combined. Saving needs project write and is audited.

On an event's Details tab, Grouping says which layer decided, in one sentence — naming the rule by its line when one of yours did — and lists exactly what was compared. It is the decision recorded when the event arrived, not a recomputation; an event stored before decisions were kept says so.

GET  /orgs/acme/projects/web/grouping/rules
PUT  /orgs/acme/projects/web/grouping/rules           { "text": "…" }   # 422 lists problems by line
POST /orgs/acme/projects/web/grouping/rules/preview   { "text": "…" }
GET  …/issues/WEB-42/events/<event id>                # + grouping: { strategy, components, rule: { id, line } }

Archiving until it gets worse, escalation, and review

An issue has five states — New, Ongoing, Resolved, Archived, Regressed — and three marks beside them that are not states.

Archive until a condition. Archive for… offers, below the time windows, Until 100 more events, Until 10 events in an hour, Until 10 more users and Until it escalates. The counts start at the moment you archive, not over the issue's lifetime; the event that meets the condition brings the issue back as Ongoing, and its timeline says which condition it was. A window and a condition can be combined; whichever happens first wins. Over the API:

PATCH …/issues/WEB-42
{ "action": "suppress", "condition": { "kind": "events", "count": 500, "windowHours": 24 } }
{ "action": "suppress", "condition": { "kind": "users", "count": 25 } }
{ "action": "suppress", "condition": { "kind": "escalating" }, "archivedUntil": "2026-11-01T00:00:00Z" }

Escalating. Every few minutes Bucker scores each recently active issue's last complete hour against that issue's own hour-of-week profile — the median and spread of the same hour over up to four previous weeks, the way project anomaly alerts are scored — and marks it Escalating when the hour is far above it (and at least 10 events). An issue needs a week of history first. The mark carries the scorer's sentence (observed, expected, band), clears a day after the last such hour, wakes an issue archived until it escalates, and is a lifecycle transition alert rules can watch (escalated). Search: is:escalating. A merged issue is judged on everything merged into it.

Review. Mark reviewed (e on the stream and on an issue; the bulk bar too) records that someone has looked — it is not a resolution. A New issue becomes Ongoing. The For review view (is:unresolved is:unreviewed) is the open issues nobody has marked; an issue returns to it when it regresses, escalates, or comes back from an archive. { "action": "review" }, or "reviewed": false to take the mark back.

Delete and discard

An error you cannot fix — a third-party script, a bot — need not cost quota forever. The issue page's ⋯ menu offers, each behind a confirmation that asks for the short id:

  • Discard future events… — new events of the issue are refused as they arrive, never stored and never billed; the issue and its history stay.
  • Delete… — the issue, its stored events and their raw envelopes are deleted; the next occurrence opens a new issue. An envelope another issue's event shares is kept, and day archives in cold storage keep their copy until they expire.
  • Delete and discard… — both.

A discard covers the issue and everything merged into it. It is decided right after an event is grouped — the first moment its fingerprint exists — and the drop is recorded as invalid with reason discarded_fingerprint, which the drops panel explains and billing takes back out of usage. Settings › Projects › Inbound filters › Discarded issues lists what is discarded, with Stop discarding. All of it needs project write and is recorded in the audit log.

POST   …/issues/WEB-42/discard            { "reason": "vendor widget" }
DELETE …/issues/WEB-42?discard=true       # 200 { deletedIssues, deletedEvents, deletedObjects, discarded }
GET    /orgs/acme/projects/web/discarded-fingerprints
DELETE /orgs/acme/projects/web/discarded-fingerprints/<id>

Comments and @mentions

The issue page's Activity section opens with a comment box, and comments sit in the timeline beside what the system recorded, in time order. Mention… inserts a person or a team; a mentioned person gets an email with a link to the issue — never the comment itself — unless they turned Mentions off under Settings › Notifications. A team mention reaches the team's members at the time. Typing @name by hand stays text and notifies nobody: only a picked mention is one.

A comment is drawn as user-supplied text. Edit and delete wait out an undo toast before they reach the server. Anyone who can triage the issue can comment; only the author can edit; the author or a project admin can delete. Agent principals cannot comment through the API, and every comment the API returns carries flagged — the prompt-injection rule its text trips, or null — so nothing pastes it into an agent's context unexamined.

A mention also lands in the mentioned person's Inbox under Mentions, and by email or Slack as their notification preferences say, held for their quiet hours.

Over MCP, issue_comments_list reads an issue's newest comments with every body scrubbed, quarantined and clipped, and issue_essence says how many there are without carrying a body. issue_comment_create is the one way an agent can comment: it is an approvals action, issue.comment.create, asked of a human by default (an owner can set an ALLOW policy for it), and the comment is posted under the agent's own name and labelled as an agent's.

GET    …/issues/WEB-42/comments
POST   …/issues/WEB-42/comments                { "body": "ask @[Ada](principal:<id>) about the retry" }
PATCH  …/issues/WEB-42/comments/<comment id>   { "body": "…" }
DELETE …/issues/WEB-42/comments/<comment id>
GET|PUT /me/notifications/mentions             { "enabled": false }

A mention is stored per person (issue_comment_mentions) and announced once as an issue.comment.mentioned notice; editing a comment to add someone notifies only them.

Ownership, team assignment and auto-assign

Settings › Projects › Ownership says who owns which code, one rule per line in the shape of a CODEOWNERS file — a path pattern, then owners, @team-slug for a team or a member's email — and, as in CODEOWNERS, a later line wins:

src/** @platform
src/checkout/** @payments
src/legacy/** dana@acme.com

Who would own this? runs the draft against an issue id (its latest event's in-app frames, as repository paths when a code mapping covers them) or a path, and names the owner and the line that decided. Import CODEOWNERS reads .github/CODEOWNERS, CODEOWNERS or docs/CODEOWNERS from the repository the project is mapped to: @org/team becomes the Bucker team with that slug and an email the member with it, and a bare @user (a GitHub account) becomes the member who connected that GitHub account under Connected sign-in accounts — matched on the GitHub login, refreshed each time they sign in with GitHub, and only among this organization's members. Any owner that maps to nobody stays in the rule as written and is listed as unmapped; a line whose owners are all unmapped is skipped and counted, since it would route to nobody. Imported rules are listed apart, replaced by the next import — a push to the default branch that changes the file imports it again — and outranked by rules typed in the editor for the same path.

The rules decide where an alert rule's Notify owner action goes, and who a NEW issue is assigned to: with Assign new issues to their owner on (the default), the worker assigns the owning team (or person) as the issue is created, and failing a rule, the author of the suspect commit when they are a member — the timeline says which. An unassigned issue's Assignee section shows the same suggestion with an Assign button. Issues can be assigned to a team as well as a person (the assign box lists teams first); assigned:#payments finds a team's issues, and is:unassigned means neither.

GET  /orgs/acme/projects/web/ownership
PUT  /orgs/acme/projects/web/ownership                    { "text": "…", "autoAssign": true }
POST /orgs/acme/projects/web/ownership/test               { "issueId": "WEB-42" } | { "path": "src/x.ts" }
POST /orgs/acme/projects/web/ownership/import-codeowners
GET  …/issues/WEB-42/owner                                # the suggestion
PATCH …/issues/WEB-42  { "action": "route", "assigneePrincipalId": null, "assigneeTeamId": "<team id>" }

Latency regressions

Bucker raises an issue when an endpoint gets slower and stays slower, even if nothing throws. Every 15 minutes the worker works out the p95 duration of each endpoint for each complete hour, from server spans. An endpoint is METHOD route: the http.route your framework reports, or the URL path with ids replaced (see dashboards.md). Each environment is judged separately.

An endpoint becomes a LatencyRegression issue when all of these hold:

  • each of the last 3 complete hours had at least 30 calls;
  • the p95 of each of those hours is more than 3 robust deviations above the median p95 of the 7 days before (median and median absolute deviation, so earlier slow hours do not raise the baseline);
  • the regressed p95 is at least 30% and at least 50 ms above that median;
  • the endpoint has not already had a regression issue in that baseline period.

These are the defaults. Change them per project in Settings › Projects › Performance issues. The issue page shows the endpoint, the baseline and regressed windows with their p95, the change, the newest deploy to that environment in the 24 hours before the shift, the five slowest sample traces (linked), and the thresholds it was judged by. It is an ordinary issue: assign, resolve, merge and alert on it as on any other. The worker pass is called performance; an operator can pause it, and PERFORMANCE_ISSUES_ENABLED=false turns it off.

Performance patterns

Every minute the worker reads the traces that have been quiet for two minutes and looks for five patterns that waste time on a code path. Each is raised as an ordinary issue, at level warning, grouped by the pattern, the code path (the trace's endpoint, or its root span name) and what repeated. One N+1 in GET /orders is one issue however many requests hit it, and you can merge, assign, resolve and alert on it like any other issue.

Pattern Issue type Raised when (defaults)
N+1 query NPlusOneQuery the same statement (bucker.db.query) runs at least 5 times under one parent span, taking at least 50 ms in total
N+1 HTTP calls NPlusOneHttp the same outbound call (domain and path) is made at least 5 times under one parent span, taking at least 300 ms in total
Consecutive HTTP calls ConsecutiveHttp off by default. At least 3 outbound calls under one parent run one after another, at least 2 s in total
Slow query SlowQuery a statement takes at least 500 ms, once it has been seen in 100 traces
Large HTTP payload LargeHttpPayload an outbound response body is at least 300,000 bytes (http.response.body.size)

Consecutive HTTP is off because calls that really depend on each other (log in, then fetch) look the same as calls that could run together. Turn it on for services where you know they could. Every threshold, including how many traces must show a pattern before it becomes an issue, is set per project in Settings › Projects › Performance issues.

The issue page lists the offending spans (name, when each started in the trace, and how long it took), links the trace, and shows the thresholds it was judged by. A span that arrives more than two minutes after it started may be missed by these detectors; the worker reads each project's spans once, by start time.