Skip to main content

Vue d’ensemble

Sentry est une intégration MCP officielle disponible dans le MCP Marketplace. Elle utilise l’authentification OAuth, ce qui donne à Devin accès à vos projets Sentry afin qu’il puisse consulter les détails des problèmes, les traces de pile, le fil d’Ariane des événements, etc. Une fois la connexion établie, vous pouvez configurer un triage automatisé des erreurs via des webhooks ou planifier des sessions de remédiation récurrentes pour traiter les erreurs Sentry par lots.

Activer le MCP Sentry

1

Ouvrir le MCP Marketplace

Accédez à Settings > MCP Marketplace et recherchez Sentry.
2

Terminer le processus OAuth

Cliquez sur Enable, puis authentifiez-vous avec le compte Sentry qui a accès à vos projets. Cela accorde à Devin un accès en lecture à vos problèmes, événements et traces de pile Sentry.
3

Vérifier la connexion

Testez la connexion en lançant une session et en demandant à Devin de répertorier les problèmes récents dans l’un de vos projets. Vous pouvez également cliquer sur Test listing tools dans le MCP Marketplace pour confirmer que la connexion fonctionne.

Capacités

Une fois le Sentry MCP activé, Devin peut effectuer les actions suivantes dans n’importe quelle session :
CapacitéDescription
Consulter les détails d’un problèmeAfficher les métadonnées du problème, son statut, son attribution et le nombre d’événements
Récupérer les traces de pile complètesAccéder aux traces de pile complètes pour n’importe quel événement
Lire les fils d’Ariane des événementsAfficher les actions des utilisateurs et les événements système ayant conduit à une erreur
Inspecter les tags de versionVérifier quelle version a introduit ou résolu un problème
Mettre à jour le statut d’un problèmeMarquer des problèmes comme résolus, ignorés ou les attribuer à des membres de l’équipe
Gérer les attributions et les tagsMettre à jour les attributions, les tags et les signets des problèmes
Configurer les alertesAfficher et gérer les règles d’alerte et les paramètres de notification

Pipeline d’auto-triage (piloté par webhook)

Vous pouvez connecter directement les alertes Sentry à Devin afin que les nouvelles erreurs de production soient automatiquement triées. Cela repose sur une intégration interne Sentry qui envoie des webhooks à un service relais appelant l’API Devin.
1

Créer une intégration interne Sentry

Dans votre tableau de bord Sentry, accédez à Settings > Developer Settings > Custom Integrations et cliquez sur Create New Integration > Internal Integration.Configurez-la :
  • Name: Devin Auto-Triage
  • Webhook URL: L’endpoint de votre service relais (par ex. https://your-domain.com/sentry-webhook)
  • Alert Rule Action: Activez on — cela rend l’intégration disponible comme action dans les règles d’alerte
  • Permissions: Accès en lecture à Issue & Event et Project
2

Créer une règle d’alerte

Accédez à Alerts > Create Alert Rule > Issue Alert pour votre projet :
  • When: Un nouveau problème est créé
  • If: Le problème a plus de 50 événements en 1 heure (à ajuster selon votre trafic)
  • Then: Envoyer une notification via Devin Auto-Triage
3

Déployer un gestionnaire de webhook

Créez un petit gestionnaire qui reçoit le payload d’alerte de Sentry et démarre une session Devin. Créez un utilisateur de service dans Settings > Service Users avec l’autorisation ManageOrgSessions (ajoutez également ViewOrgSessions si vous souhaitez lister ou filtrer les sessions via l’API). Stockez le jeton d’API dans DEVIN_API_KEY, l’ID de votre organisation dans DEVIN_ORG_ID et le Client Secret de votre intégration interne Sentry dans SENTRY_CLIENT_SECRET dans l’environnement de votre gestionnaire.
const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json({
  verify: (req, _res, buf) => { req.rawBody = buf; },
}));

function verifySignature(req) {
  const signature = req.headers['sentry-hook-signature'];
  if (!signature) return false;
  const expected = crypto
    .createHmac('sha256', process.env.SENTRY_CLIENT_SECRET)
    .update(req.rawBody)
    .digest('hex');
  if (signature.length !== expected.length) return false;
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
}

app.post('/sentry-webhook', async (req, res) => {
  if (!verifySignature(req)) return res.status(401).send('Bad signature');

  const event = req.body.data?.event;
  if (!event) return res.sendStatus(200);

  const orgId = process.env.DEVIN_ORG_ID;
  const response = await fetch(
    `https://api.devin.ai/v3/organizations/${orgId}/sessions`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.DEVIN_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      prompt: [
        `A Sentry alert fired for a new issue: "${event.title}"`,
        `Culprit: ${event.culprit}`,
        `Sentry URL: ${event.web_url}`,
        ``,
        `Use the Sentry MCP to pull the full stack trace and breadcrumbs.`,
        `Identify the root cause, fix the issue, and open a PR with a`,
        `regression test.`,
      ].join('\n'),
      tags: ['sentry-auto-triage', `project:${event.project}`],
    }),
  });

  const { session_id } = await response.json();
  console.log(`Started Devin session ${session_id} for: ${event.title}`);
  res.sendStatus(200);
});

app.listen(3000);
Déployez-le sur n’importe quelle plateforme pouvant recevoir du trafic HTTPS — un Cloudflare Worker, AWS Lambda ou un petit VPS. Pointez l’URL de webhook de votre intégration interne Sentry vers ce service.
4

Tester le pipeline

Déclenchez une alerte de test dans Sentry (ou baissez temporairement votre seuil), puis vérifiez dans app.devin.ai qu’une nouvelle session taguée sentry-auto-triage a bien été créée.
Le code ci-dessus ajoute à chaque session le tag sentry-auto-triage ainsi que le nom du projet Sentry. Cela vous permet de filtrer ces sessions dans le tableau de bord Devin et de les récupérer via l’API à l’aide du paramètre de requête tags. Pour lister les sessions, l’autorisation ViewOrgSessions est requise pour votre utilisateur de service — consultez la vue d’ensemble de l’API pour le tableau complet des autorisations.

Remédiation planifiée par lot

Au lieu de réagir à chaque alerte individuellement, vous pouvez planifier une session récurrente Devin qui récupère par lot les erreurs Sentry non résolues et crée une session de correction pour chacune d’elles.
1

Créer une planification

Accédez à Settings > Schedules et cliquez sur Créer une planification.
  • Nom : Daily Sentry remediation
  • Fréquence : Tous les jours à 6 h 00 (pour que les PR de correction soient prêtes avant le stand-up)
  • Agent : Devin — cela permet à Devin de lancer une session distincte pour chaque erreur, afin que les corrections s’exécutent en parallèle
  • Prompt :
Utilisez le MCP Sentry pour récupérer toutes les erreurs non résolues
des dernières 24 heures dans le projet payments-api, triées par nombre
d’événements.
Ignorez les erreurs avec le tag `wontfix` ou `expected-behavior`.

Pour les 5 principales erreurs :
1. Récupérez la trace de pile complète et les breadcrumbs
2. Trouvez les fichiers source pertinents dans notre dépôt
3. Identifiez la cause racine
4. Démarrez une session Devin pour ouvrir une PR avec un correctif et un test
   de non-régression, en ajoutant l’URL de l’incident Sentry dans la description de la PR

Publiez un résumé de toutes les erreurs et de leurs PR dans Slack.
2

Examiner et itérer

Après une semaine d’exécutions, ajustez le périmètre :
  • Augmentez ou réduisez le nombre d’erreurs selon le nombre de corrections pouvant être fusionnées
  • Filtrez par projet ou par tag pour vous concentrer sur des zones spécifiques de votre base de code
  • Ajoutez de la Knowledge sur vos conventions de gestion des erreurs afin que les corrections de Devin correspondent aux schémas de votre équipe
Combinez un triage déclenché par webhook pour les erreurs à fort impact (50+ événements/heure) avec une remédiation planifiée par lot pour la longue traîne des problèmes moins fréquents. Cela garantit le traitement des erreurs à la fois urgentes et persistantes.