> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Intégration Sentry
> Connectez Devin à Sentry pour automatiser le triage et la remédiation des erreurs
## Vue d’ensemble
Sentry est une intégration MCP officielle disponible dans le [MCP Marketplace](/fr/work-with-devin/mcp). 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
Accédez à **Settings > MCP Marketplace** et recherchez **Sentry**.
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.
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ème | Afficher 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ètes | Accéder aux traces de pile complètes pour n’importe quel événement |
| Lire les fils d’Ariane des événements | Afficher les actions des utilisateurs et les événements système ayant conduit à une erreur |
| Inspecter les tags de version | Vérifier quelle version a introduit ou résolu un problème |
| Mettre à jour le statut d’un problème | Marquer des problèmes comme résolus, ignorés ou les attribuer à des membres de l’équipe |
| Gérer les attributions et les tags | Mettre à jour les attributions, les tags et les signets des problèmes |
| Configurer les alertes | Afficher 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.
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**
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**
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](/fr/api-reference/v3/overview) 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.
```javascript theme={null}
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.
Déclenchez une alerte de test dans Sentry (ou baissez temporairement votre seuil), puis vérifiez dans [app.devin.ai](https://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](/fr/api-reference/v3/sessions/organizations-sessions) à 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](/fr/api-reference/v3/overview) 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](/fr/work-with-devin/advanced-capabilities) qui récupère par lot les erreurs Sentry non résolues et crée une session de correction pour chacune d’elles.
Accédez à **Settings > [Schedules](/fr/product-guides/scheduled-sessions)** 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.
```
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](/fr/product-guides/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.
## Ressources connexes
* [Guide complet : triage automatique des erreurs Sentry](/fr/use-cases/gallery/api-sentry-auto-triage)
* [Guide complet : remédiation quotidienne des erreurs Sentry](/fr/use-cases/gallery/scheduled-sentry-remediation)
* [Documentation de la MCP Marketplace](/fr/work-with-devin/mcp)
* [Référence de l’API Devin](/fr/api-reference/overview)