User feedback and AI issue analysis

Monitor → User feedback collects bug reports from the people using your app, linked to the error, session recording, release and environment they are about. It replaces Sentry's User Feedback: the Sentry feedback widget, Sentry.captureFeedback, the crash-report dialog and the legacy captureUserFeedback all work by pointing the Sentry SDK's DSN at Guidely. Guidely's own SDK has a matching API and dialog.

User feedback is not the same as Feedback (feature requests and voting) or Complaints: a report here is about something that went wrong. A report that is really a feature request can be turned into one from its detail panel.

Sending reports

From Sentry SDKs

Nothing changes in your code beyond the DSN (ingest).

Sentry APIArrives asNotes
Sentry.feedbackIntegration() (the widget)feedback envelope itemScreenshots are attachment items in the same envelope and are stored with the report.
Sentry.captureFeedback({ message, name, email, associatedEventId, url }, { attachments })feedback envelope itemBrowser, Node and every other SDK with captureFeedback.
Sentry.captureUserFeedback({ event_id, name, email, comments }) (SDK 8 and older)user_report envelope itemOne report per error event: a resend is the same report.
Sentry.showReportDialog({ eventId }) (crash-report dialog)GET/POST /api/embed/error-page/?dsn=…&eventId=…The SDK loads the dialog script from Guidely; its labels (title, subtitle, labelSubmit…) and user prefill work as with Sentry.

From the feedback context Guidely keeps the message, contact email, name, page URL, source (widget, api, crash_report_modal…), associated event id and Sentry replay id; from the event, the user, release, environment, tags, browser / OS / device contexts and request headers (cookies and credential headers are dropped).

From Guidely's SDK

guidely.captureFeedback({
  message: "Export never finishes",
  email: "ada@example.com",   // optional (name too)
  associatedEventId,          // optional: defaults to the last error this page reported
  tags: { plan: "pro" },      // optional, strings
  screenshot: file,           // optional: an image Blob/File up to 4 MB
}); // → Promise<{ id, linked }>

guidely.showBugReport();      // the built-in "Report a bug" dialog

The SDK sends the visitor's ids and the session, so the team can watch the recording up to the moment of the report, and flushes the page's last error first so the report links to its issue straight away. The dialog takes an image file or one frame of the current tab through the browser's own share prompt (no screenshot library, nothing captured without the person choosing to share). Both calls are queued by the script-tag snippet. Endpoint: POST /api/v1/sdk/bug-reports?key=pk_… (30 reports per hour per device). Native SDKs (iOS, Android, React Native, Flutter) don't have the API yet.

How a report is linked

  • Issue: the associated event id (Sentry associated_event_id, the user report's event_id, or the Guidely SDK's last error) is looked up among stored error events; the report gets that event's issue and environment. When the error arrives after the report, the report shows Waiting for its error and links when it does (list views and a worker job every 5 minutes; reports look for their error for 7 days).
  • Person: user.id / the SDK's user id and anonymous id link the report to the end user (Users).
  • Recording: a Guidely session recording of the same session (Guidely SDK reports, or the associated error's session) opens at the moment of the report. A Sentry Session Replay id is kept and shown, and links automatically when Guidely stores that Sentry replay under the same id.
  • Release, environment, URL, browser and OS come from the event (or the Guidely SDK's app version and user agent).

Working with reports

  • Inbox: New / Resolved / Spam / All with counts; search (message, name, email, page); filters for linked issue, screenshot, assignee, AI category and release; the header's environment.
  • Detail panel: the message, screenshots (served only to signed-in teammates, never cached), the linked issue with its latest stack, the recording, the person, context and tags.
  • Actions: resolve, spam / not spam, assign, bulk resolve / spam / assign to me, open a ticket in a connected tracker (Linear, Jira, Zendesk, Intercom; ticket source feedback), turn into a feature request, and Email reporter: a teammate writes the email and sends it; nothing is ever sent automatically. Emails go through the project's outbound email with an unsubscribe link, skip suppressed addresses and are refused in HIPAA mode.
  • Issues: the issue page shows a User feedback card ("N people reported this") and the issue list a feedback count badge. Alert payloads can say users reported this with issueFeedbackSummary(issueId) (server/services/user-feedback.ts).
  • Similar reports: new reports from the last 30 days grouped by what they say (word similarity, no AI and no embeddings), biggest first, with a Resolve all action. With AI triage on, the groups get AI names.

Permissions: viewing needs the Viewer role; triage, tickets and bulk actions need Manage insights & alerts (insights.manage); emailing a reporter needs Reply in the Inbox (inbox.reply).

Retention: reports and their screenshots follow the project's event retention (eventRetentionDays, default 365 days). Screenshots are stored in the object storage bucket under feedback/<projectId>/ (the web task may read, write and delete it; the worker may delete) or, without a bucket, in the database.

AI

AI is off until a project admin (Project settings permission) turns it on, separately for:

  • Issue analysis (issue page → AI analysis → Turn on for this project):
    • Summary: what happened, the likely cause, who is affected (frequency, trend, users, releases, browsers).
    • Root cause: the steps from the user's action to the failing line, grounded in stack frames.
    • Suggested fix: a code change for the failing frame (a diff or replacement code), why it works and how to verify it. It builds on the root cause when one exists. No repository access is needed; the prompt builder takes extra source files (extraSources) for when a code integration supplies them.

    Each result is kept per issue and kind with the model, time and author, marked out of date when a newer event arrives, regenerated on demand and rated with thumbs up / down.

  • Feedback triage (User feedback → AI triage switch): new reports get a spam verdict, a category (bug, crash, performance, usability, feature request, question, praise, other) and a sentiment, every 5 minutes in batches of 25. Reports the AI calls spam move to Spam; Not spam puts them back for good. Groups of similar reports get AI names.

What is sent to the model

AI uses the project's own Anthropic API key (Settings → Scout) or Guidely's, like every AI feature.

  • Issue analysis: the issue's title, culprit, level, platform, counts and 14-day trend, releases and browsers; the newest event's exception chain, stack frames (file, function, line, source lines around the innermost app frames), up to 30 breadcrumbs, tags, runtime / OS / browser names, request method and path; and up to 10 user reports about the issue.
  • Never sent: cookies, request headers and bodies, query strings, user ids, emails, IP addresses. Frame variables, tags and breadcrumb data whose names look secret (password, token, key, auth, cookie, session, card…) are redacted, and values that look like secrets (bearer tokens, JWTs, API keys, long hex or base64 strings, card numbers, emails, IPs) are replaced everywhere before sending. Event and report text is marked as data the model must not follow.
  • Feedback triage: the report messages only (scrubbed the same way), not names, emails or context.

Cost and limits

Only Scout's answers are a metered product (scout meter in lib/plans.ts); like Scout's other AI features (insights, tagging, feedback analysis), issue analysis and triage are not metered. They are rate limited instead: 30 analyses per workspace per hour, and 60 triage / group-naming calls per workspace per hour. Group names are cached for a day.

HIPAA mode

In a HIPAA workspace AI works only with the project's own Anthropic key (the customer's own agreement with Anthropic): Guidely's server key is refused, exactly as for Scout (ai/client.ts resolveAiKey). The AI panel and the triage switch say so. Emailing reporters is off in HIPAA mode (Guidely's email provider isn't under a BAA), and opening a report or its screenshot is recorded in the audit log (phi.user_feedback_view).

API

Route
GET /api/v1/projects/:id/user-feedbackList (env, status, q, issue = linked / unlinked / issue id, screenshot, release, assignee, category, page).
PATCH /api/v1/projects/:id/user-feedbackBulk { ids, status?, assigneeId? }.
GET /api/v1/projects/:id/user-feedback/clustersSimilar reports (env, days, ai=1).
GET /api/v1/projects/:id/user-feedback/issue-counts?ids=Feedback counts of issues.
GET/PATCH /api/v1/user-feedback/:idOne report; { status?, assigneeId? }.
GET /api/v1/user-feedback/:id/attachments/:attachmentIdA screenshot.
POST /api/v1/user-feedback/:id/replyEmail the reporter { subject, body, resolve }.
GET /api/v1/errors/:id/feedbackFeedback on an issue.
GET/POST /api/v1/errors/:id/aiAI state; run `{ kind: "summary" \"root_cause" \"fix" }`.
POST /api/v1/errors/:id/ai/:analysisId/vote`{ value: 1 \-1 \0 }`.
GET/PATCH /api/v1/projects/:id/error-ai-settings{ issueAnalysis?, feedbackTriage? }.

Code map

  • apps/web/src/server/sentry/handlers/feedback.ts, server/sentry/error-page.ts: Sentry ingest.
  • apps/web/src/server/services/user-feedback.ts (storage, team API, tickets, retention), user-feedback-ingest.ts (Sentry and Guidely SDK payloads), user-feedback-ai.ts (triage, grouping), error-ai.ts + error-ai-prompt.ts (issue analysis and its scrubbed prompt).
  • Dashboard: app/app/[projectId]/user-feedback, components/user-feedback/, components/errors/issue-ai-panel.tsx, components/errors/issue-feedback.tsx.
  • SDK: packages/sdk-core/src/bug-report.ts, packages/guide-runtime/src/bug-report.ts.