Passer au contenu principal
GitLab unifie les tickets, la revue de code, l’intégration continue et le déploiement continu dans une seule interface. Connecter AppSignal à GitLab couvre le même terrain que l’intégration GitHub : GitLab est une intégration personnelle : chaque utilisateur qui souhaite l’utiliser doit effectuer la configuration pour lui-même sur chaque application AppSignal.
GitLab propose plusieurs façons de se connecter à des outils tiers. AppSignal se connecte à l’aide d’un jeton d’accès personnel GitLab et de l’URL de votre projet, ce qui est pris en charge sur GitLab.com, GitLab Self-Managed et GitLab Dedicated. GitLab propose également des applications OAuth, mais AppSignal ne prend pas encore en charge la connexion à GitLab via OAuth.
Site web : https://gitlab.com

Étape 1. Créer un jeton d’accès personnel GitLab

  1. Connectez-vous à GitLab et accédez à vos Settings utilisateur.
  2. Dans la barre latérale gauche, sélectionnez Access tokens, puis ouvrez Personal access tokens (https://gitlab.com/-/user_settings/personal_access_tokens sur GitLab.com).
  3. Sélectionnez Add new token. GitLab vous permet de créer un jeton d’accès personnel fine-grained ou legacy. Choisissez legacy, car ses scopes correspondent directement à ce dont AppSignal a besoin.
  4. Renseignez :
    • Token name : AppSignal
    • Expiration date : choisissez une date qui correspond à la politique de votre organisation.
    • Scopes : sélectionnez read_api, read_repository et api. AppSignal a besoin des trois.
  5. Sélectionnez Create personal access token et copiez immédiatement le jeton. GitLab ne l’affiche qu’une seule fois.
Créer un ticket est une action d’écriture, les scopes en lecture seule ne suffisent donc pas à eux seuls. Sur GitLab 15.5 et versions ultérieures, AppSignal n’enregistre pas un jeton sans le scope api. Il affiche une erreur demandant un jeton qui en dispose. Les versions antérieures de GitLab n’indiquent pas les scopes d’un jeton, AppSignal ne peut donc pas les vérifier.GitLab ne vous permet pas de modifier les scopes d’un jeton après sa création. Pour les ajuster, créez un nouveau jeton et mettez à jour l’intégration dans AppSignal.
Les jetons fine-grained peuvent également fonctionner, mais leurs permissions sur les ressources sont beaucoup plus granulaires, et il n’est pas évident de savoir quelle combinaison choisir. Nous prévoyons de faire évoluer cette intégration vers les applications OAuth de GitLab, la façon la plus récente de connecter des outils tiers à GitLab.

Étape 2. Ajouter l’intégration dans AppSignal

  1. Dans AppSignal, ouvrez l’application que vous souhaitez connecter.
  2. Allez dans App settings → Integrations. Sous Personal issue tracker integrations, sélectionnez Configure à côté de GitLab.
  3. Renseignez le formulaire :
    • Token : collez le jeton d’accès personnel que vous avez créé à l’étape 1. L’indication du champ précise le scope dont AppSignal a besoin.
    • GitLab URL : l’URL complète vers le projet GitLab, par exemple https://gitlab.com/your-namespace/your-project. Pour GitLab Self-Managed, utilisez le hostname de votre instance, par exemple https://gitlab.example.com/your-group/your-project.
  4. Sélectionnez Create integration.
Vous pouvez revenir sur cette page à tout moment pour Update integration ou Remove integration. Lorsque de nouvelles fonctionnalités GitLab nécessitent plus de permissions, AppSignal affiche une bannière vous demandant de mettre à jour votre jeton GitLab. Sélectionnez Update GitLab token, puis enregistrez un jeton avec les scopes de l’étape 1.

Étape 3. Répétez pour chaque utilisateur

Comme il s’agit d’une intégration personnelle, chaque membre de l’équipe qui souhaite que les liens de source, les liens de backtrace ou la création de tickets fonctionnent dans son propre compte AppSignal doit répéter les étapes 1 et 2 avec son propre jeton GitLab. Le code évolue en permanence, donc un backtrace est plus utile lorsqu’il pointe vers la révision qui était déployée au moment où l’erreur s’est produite. Connecter GitLab renseigne le champ Repo URL de votre application, vous n’avez donc pas à le définir manuellement. Vous pouvez le vérifier sous App settings → General, où ce champ contient l’URL de votre projet GitLab. AppSignal détecte le fournisseur à partir de cette URL et construit les liens de backtrace et de comparaison correspondants. Une fois que les marqueurs de déploiement signalent la revision déployée, AppSignal lie chaque ligne de backtrace à la révision, au chemin et à la ligne correspondants dans votre dépôt GitLab, afin que vous puissiez passer d’une erreur au code qui a été déployé. Pour la configuration complète, consultez la documentation sur les liens de backtrace.

Créer des tickets GitLab pour les incidents

AppSignal ne crée pas de tickets GitLab automatiquement, afin d’éviter une surcharge de tickets. Pour en créer un pour un incident d’erreur :
  1. Ouvrez l’écran de détails de l’incident d’erreur.
  2. Dans le panneau Actions, sélectionnez Send to GitLab.
AppSignal crée le ticket dans le projet GitLab lié, et vous pouvez l’ouvrir depuis la page de l’incident par la suite. La création de tickets nécessite un jeton avec le scope api en plus des scopes de lecture, décrits à l’étape 1.

Suivre les tickets liés depuis l’incident

Cette fonctionnalité est en bêta, dans le cadre d’AppSignal Labs. Demandez au support de l’activer pour votre organisation.
Le panneau Actions affiche un bouton pour chaque ticket GitLab lié, intitulé View #123 in GitLab. Chaque bouton affiche le statut du ticket sous forme de badge :
  • Premium et Ultimate : le statut tel que GitLab le nomme, comme To do ou un statut personnalisé comme In review.
  • Free : Open ou Closed.
Le panneau Actions d'un incident dans AppSignal avec un bouton View #2 in GitLab et un badge de statut In progress AppSignal met à jour le badge dès que le ticket change dans GitLab. Les changements de statut apparaissent aussi dans le logbook de l’incident. Par exemple : Changed the status of #123 on GitLab from To do → In review. L’entrée indique qui a effectué le changement dans GitLab. Quelques limitations à connaître :
  • Un nouveau ticket reçoit son badge peu après que vous l’avez envoyé à GitLab, une fois que GitLab en a informé AppSignal.
  • Les tickets envoyés à GitLab avant cette fonctionnalité n’affichent aucun badge jusqu’à leur prochain changement dans GitLab.
  • Le logbook n’affiche pas le premier statut d’un ticket, car il n’existe pas de statut antérieur avec lequel le comparer.
  • Les badges fonctionnent pour un seul projet GitLab par application. Si vous et vos coéquipiers connectez des projets différents, seuls les tickets du projet enregistré en dernier affichent un badge.

Activer les mises à jour de statut

GitLab envoie les changements de statut à AppSignal via un webhook sur votre projet GitLab. AppSignal l’ajoute lorsque vous enregistrez l’intégration :
  1. Allez dans App settings → Integrations, puis sélectionnez Configure à côté de GitLab.
  2. Sélectionnez Update integration. Si l’intégration est nouvelle, sélectionnez Create integration.
Vous avez besoin du rôle Maintainer ou Owner sur le projet GitLab. Sans ce rôle, l’intégration est tout de même enregistrée. AppSignal affiche alors : “Two-way sync is off: AppSignal couldn’t add a webhook to this GitLab project.” Demandez à un Maintainer d’enregistrer l’intégration, ou obtenez le rôle et enregistrez-la à nouveau. Pour lier un ticket GitLab qui existe déjà, ouvrez l’onglet Summary de l’incident. Écrivez une note dans le champ Logbook avec l’URL du ticket, par exemple https://gitlab.com/your-namespace/your-project/-/issues/42, puis sélectionnez Post note. Le logbook enregistre Linked #42 on GitLab, et le ticket apparaît dans le panneau Actions. Son badge de statut s’affiche dès que le ticket change à nouveau dans GitLab. Un commentaire seul ne compte pas. Le serveur MCP d’AppSignal lie les tickets de la même manière lorsqu’un agent IA écrit une note sur un incident. AppSignal lie un ticket uniquement lorsque toutes les conditions suivantes sont remplies. Sinon, il ignore l’URL, et la note est quand même publiée.
  • Vous avez ajouté l’intégration GitLab à l’application vous-même. AppSignal recherche le ticket avec votre jeton.
  • Le ticket se trouve dans le projet GitLab que vous avez connecté à l’application, et votre jeton peut le lire.
  • La note contient l’URL complète du ticket, avec /-/issues/ ou /-/work_items/. Les références comme #42 ou your-group/your-project#42 ne sont pas liées, pas plus que les URL de merge requests.
  • Le ticket n’est pas encore lié à l’incident. Modifier la note ne crée pas de doublons.

Changer de projet ou supprimer l’intégration

  • Passer à un autre projet GitLab : enregistrez l’intégration avec l’URL du nouveau projet. AppSignal déplace son webhook vers le nouveau projet. Vous avez besoin du rôle Maintainer ou Owner sur le nouveau projet.
  • Supprimer l’intégration : AppSignal conserve le webhook tant qu’une autre personne de l’application utilise encore l’intégration. Il supprime le webhook lorsque la dernière personne la supprime.

Marqueurs de déploiement depuis GitLab CI/CD

Pour signaler les déploiements à AppSignal depuis un pipeline GitLab CI/CD, consultez la documentation sur les marqueurs de déploiement pour l’approche recommandée via l’option de configuration revision, ou l’exemple de l’API Markers si votre stack n’inclut pas d’intégration AppSignal.

Dépannage

AppSignal indique que le jeton n’a pas le scope api. AppSignal a besoin de api pour créer des tickets. GitLab ne vous permet pas de modifier les scopes d’un jeton. Créez un nouveau jeton legacy avec read_api, read_repository et api, puis enregistrez-le dans AppSignal. L’envoi d’un incident vers GitLab échoue. Le jeton n’a peut-être pas le scope api. AppSignal ne peut pas le vérifier pour les jetons enregistrés avant qu’il ne commence à vérifier les scopes, ni sur GitLab avant la version 15.5. Créez un nouveau jeton avec les trois scopes et mettez à jour l’intégration dans AppSignal. Les tickets liés n’affichent aucun badge de statut. Vérifiez que le projet GitLab dispose du webhook AppSignal, sous Settings → Webhooks dans GitLab. S’il est absent, un Maintainer enregistre à nouveau l’intégration, comme décrit dans Activer les mises à jour de statut. AppSignal n’a pas pu supprimer son webhook. Un Maintainer du projet GitLab peut le supprimer sous Settings → Webhooks dans GitLab. AppSignal signale l’intégration GitLab comme invalide. Vérifiez quels scopes le jeton possède réellement. read_registry et read_repository se trouvent côte à côte dans la liste des scopes de GitLab, et un jeton qui accorde read_registry au lieu de read_api ne peut pas lire votre projet. Les liens de source dans AppSignal n’ouvrent pas le bon fichier. Dans AppSignal, allez dans App settings → Integrations et sélectionnez Configure à côté de GitLab. Confirmez que l’URL GitLab pointe vers la racine du projet (par exemple https://gitlab.com/namespace/project), et non vers un sous-chemin, une branche ou une URL .git.

Liste des intégrations