Automated Error Analysis with Sentry MCP

<Tip>
  See [Sentry MCP Documentation](https://docs.sentry.io/product/sentry-mcp/) for detailed configuration options
</Tip>

The Sentry MCP supports multiple configuration methods. For Continue CLI, OAuth is recommended:

**Option 1: OAuth Configuration (Recommended)**

The Sentry MCP will prompt for OAuth authentication when first used. Simply follow the authorization flow.

**Option 2: STDIO Mode with Auth Token**

For local development or self-hosted Sentry installations, you can use STDIO mode:
```bash
npx @sentry/mcp-server@latest --access-token=YOUR_SENTRY_TOKEN --host=sentry.io
```

Or use environment variables:
```bash
SENTRY_ACCESS_TOKEN=your-token SENTRY_HOST=sentry.io
```

<Info>
  The `--host` parameter is required and should point to your Sentry instance (e.g., `sentry.io` or `sentry.example.com` for self-hosted).
</Info>

1. Go to [User Auth Tokens](https://sentry.io/settings/account/api/auth-tokens/) in Sentry
   - For self-hosted Sentry, use: `https://YOUR-SENTRY-DOMAIN/settings/account/api/auth-tokens/`
2. Click **Create New Token**
3. Name it "Continue CLI Error Analysis"
4. **Select these permission scopes** (required for full functionality):
   - `org:read` - **Required** - Access organization information
   - `project:read` - **Required** - Read project configurations
   - `project:releases` - **Required** - Access release information for deployment tracking
   - `event:read` - **Required** - Read detailed error event data and stack traces
   - `event:write` - Optional - Update error events (for marking as resolved)
   - `member:read` - Recommended - Read team member information for auto-assignment
   - `team:read` - Recommended - Access team data for routing issues
5. Copy the token immediately (you won't see it again!)
6. Note your organization slug (found in your Sentry URL: `https://sentry.io/organizations/YOUR-ORG-SLUG`)
7. Note your Sentry host URL (typically `https://sentry.io` or your self-hosted domain)

<Info>
  **Sentry MCP Connection**: The MCP server connects via OAuth to `https://mcp.sentry.dev/mcp` and handles authentication securely. For local development, you can use STDIO mode with your auth token.
</Info>

1. Install GitHub CLI if not already installed
2. Run `gh auth login` and follow the prompts
3. Choose authentication method (browser or token)
4. Grant necessary permissions when prompted (`issues:write` is **required** for creating issues)

<Steps>
  <Step title="Add the Pre-Built Agent">
    Visit the [Sentry Continuous AI Agent](https://continue.dev/continuedev/sentry-continuous-ai-agent) on Continue Mission Control and click **"Install Agent"** or run:
    
    ```bash
    cn --agent continuedev/sentry-continuous-ai-agent
    ```

    This agent includes:
    - **Optimized prompts** for Sentry error analysis and GitHub issue creation
    - **Built-in rules** for consistent formatting and error handling
    - **[Sentry MCP](https://docs.sentry.io/product/sentry-mcp/)** for more reliable API interactions
    - **Automatic authentication** via OAuth flow
  </Step>

  <Step title="Run Error Analysis">
    Navigate to your project directory and enter this prompt in the Continue CLI TUI:
    
    ```
    Analyze recent Sentry errors and create GitHub issues for critical bugs with suggested fixes
    ```

    That's it! The agent handles everything automatically.
  </Step>
</Steps>

<Info>
  **Why Use the Agent?** Results are more consistent and debugging is easier thanks to the Sentry MCP integration and pre-tested prompts.
</Info>

    The MCP server will automatically prompt for OAuth authentication when you first use it.
  </Step>

  <Step title="Verify Sentry Connection">
    Test your Sentry MCP connection with this prompt:
    
    ```
    List my Sentry organizations and projects
    ```
  </Step>

  <Step title="Create Custom Error Analysis Prompts">
    Use this prompt template with Continue CLI to analyze Sentry errors:

    ```
    Analyze Sentry errors from the past 24 hours:
    - Group errors by root cause
    - Identify the top 5 most critical issues by frequency and impact
    - For each critical issue, provide:
      * Stack trace analysis
      * Affected user count
      * First seen and last seen timestamps
      * Suggested fix based on error context
    - Create GitHub issues using gh CLI with:
      * Title format: '🐛 [Sentry] [Error Type]: Brief description'
      * Labels: 'bug', 'sentry', 'production'
      * Priority labels based on severity
      * Full error context and suggested fix in the body
    Execute the commands and confirm each issue was created.
    ```
  </Step>
</Steps>

For each unresolved Sentry error with 'critical' or 'high' severity:
1. Analyze the error using Sentry MCP
2. Create a GitHub issue with gh CLI:
   - Title: '🐛 [Sentry] [Error Type]: Brief description'
   - Body with:
     * Error summary and impact (affected users, frequency)
     * Full stack trace
     * Environment details (browser, OS, release version)
     * Link to Sentry issue
     * Root cause analysis from AI
     * Suggested fix with code snippets
     * Related Sentry issues
   - Labels: 'bug', 'sentry', 'production', and severity label
   - Assignees: Team member based on code ownership
3. Update Sentry issue with GitHub issue link
4. Confirm creation with GitHub issue URL

name: Sentry Error Monitoring

on:
  push:
    branches:
      - main
  schedule:
    # Run every 6 hours
    - cron: "0 */6 * * *"
  workflow_dispatch: # Allow manual triggers

jobs:
  monitor-errors:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: "22"

      # Create Sentry release for better error tracking
      - name: Create Sentry release
        uses: getsentry/action-release@v1
        env:
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
        with:
          environment: production

      - name: Install Continue CLI
        run: |
          npm install -g @continuedev/cli
          echo "✅ Continue CLI installed"

      - name: Authenticate GitHub CLI
        run: |
          echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
          echo "✅ GitHub CLI authenticated"

      - name: Analyze Sentry Errors and Create Issues
        env:
          CONTINUE_API_KEY: ${{ secrets.CONTINUE_API_KEY }}
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
        run: |
          echo "🔍 Analyzing Sentry errors..."
          
          # Use Continue CLI to analyze errors and generate comprehensive issue descriptions
          cn -p "Using Sentry MCP, analyze errors from the past 6 hours for project $SENTRY_PROJECT:
                 1. Filter for unresolved errors with high or critical severity
                 2. Group similar errors to avoid duplicates
                 3. For each unique critical error:
                    - Generate a comprehensive issue description including:
                      * Error summary with frequency and user impact metrics
                      * Full stack trace with highlighted problem areas
                      * Environment details (browser, OS, release version)
                      * Link to Sentry issue dashboard
                      * Root cause analysis using AI
                      * Step-by-step reproduction if available
                      * Suggested fix with code examples
                      * Related errors or patterns
                    - Check if a GitHub issue already exists for this error
                    - If not, create a new issue with the generated description
                    - Use gh CLI: gh issue create --title '[Sentry] [Error Type]: Brief description' --body 'AI-generated comprehensive analysis' --label 'bug,sentry,critical,needs-investigation'
                    - Link the GitHub issue back to Sentry
                 4. Generate a summary report with:
                    - Total errors analyzed
                    - New issues created with URLs
                    - Errors skipped (already tracked)
                    - Release correlation if available

                 Sentry Organization: $SENTRY_ORG
                 Project: $SENTRY_PROJECT
                 Only process errors not already tracked in GitHub."

      - name: Post workflow summary
        if: always()
        run: |
          echo "## 📊 Sentry Error Monitoring Summary" >> $GITHUB_STEP_SUMMARY
          echo "✅ Workflow completed at $(date)" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "Check the 'Analyze Sentry Errors' step above for:" >> $GITHUB_STEP_SUMMARY
          echo "- Number of errors analyzed" >> $GITHUB_STEP_SUMMARY
          echo "- GitHub issues created" >> $GITHUB_STEP_SUMMARY
          echo "- Errors already tracked" >> $GITHUB_STEP_SUMMARY