Serveur MCP Dynatrace : du symptôme au correctif avec un assistant de code

Serveur MCP Dynatrace dans un assistant de code : une méthode en cinq étapes pour relier une lenteur en production au code, puis vérifier le correctif.
Serveur MCP Dynatrace : du symptôme au correctif avec un assistant de code

Le serveur MCP Dynatrace permet à un assistant de code d’interroger les données d’observabilité de production pendant qu’il lit votre dépôt. Ce détail change la nature d’une investigation : l’assistant ne devine plus où se trouve la lenteur à partir du seul code source, il la constate dans les traces, les métriques et les problèmes détectés, puis remonte jusqu’aux lignes concernées.

Sans ce lien, un développeur jongle entre deux mondes. D’un côté l’éditeur, où un assistant propose des refactorisations plausibles ; de l’autre la console d’observabilité, où se trouvent les faits. La traduction entre les deux se fait à la main, souvent sous la pression d’un incident.

Cet article propose une méthode reproductible, en cinq étapes, pour passer du symptôme au correctif avec un assistant connecté au serveur MCP de Dynatrace, et surtout pour vérifier que le correctif a réellement produit l’effet attendu.

Ce que le serveur MCP Dynatrace apporte à un assistant de code

Un serveur MCP expose des outils qu’un modèle peut appeler (le principe est détaillé dans notre guide du Model Context Protocol). Celui de Dynatrace donne accès au contexte de la plateforme : problèmes ouverts, entités et leurs relations, données interrogeables en DQL dans Grail, métriques de processus et d’hôtes. L’assistant peut ainsi découvrir une entité, suivre ses dépendances et récupérer les mesures pertinentes sans que vous écriviez la requête vous-même.

Dynatrace publie aussi des skills : des instructions prêtes à l’emploi qui expliquent à un agent comment interroger efficacement la plateforme, quels types d’entités existent et comment vérifier un correctif. Le serveur ouvre l’accès ; les skills orientent la démarche.

Point important si vous avez suivi des tutoriels plus anciens : le serveur local open source (dynatrace-oss/dynatrace-mcp, lancé via npx) est désormais déprécié. Dynatrace recommande le serveur MCP distant, hébergé dans votre environnement SaaS et décrit dans la documentation officielle du serveur MCP Dynatrace. C’est lui que nous utilisons ci-dessous.

Un scénario typique : la latence qui grimpe sans raison apparente

Prenons un exemple volontairement banal. Une API de commandes, écrite en Python, répond en 300 ms en temps normal. Depuis la dernière mise en production, le 95e centile dépasse 4 secondes sur l’endpoint qui liste les commandes d’un client. Le code a peu changé : un champ « adresse de livraison » a été ajouté à la réponse. Dynatrace a ouvert un problème de dégradation du temps de réponse sur le service.

La revue de code n’a rien relevé d’alarmant. C’est exactement le type de situation où un assistant qui ne voit que le code tournera en rond, et où les données de production font la différence.

En pratique

Étape 1 — Connecter l’assistant au serveur MCP

Le serveur distant se joint par une URL, en transport HTTP, avec un jeton de plateforme dans l’en-tête d’autorisation. Dans un hôte qui accepte une configuration JSON, cela ressemble à ceci (la clé racine, servers ou mcpServers, dépend de l’hôte ; l’URL exacte est indiquée dans la documentation) :

{
  "servers": {
    "dynatrace-mcp": {
      "url": "https://VOTRE-ENV.apps.dynatrace.com/platform-reserved/mcp-gateway/v0.1/servers/dynatrace-mcp/mcp",
      "headers": {
        "Authorization": "Bearer <JETON_DE_PLATEFORME>"
      }
    }
  }
}

Le jeton doit porter les permissions d’accès à la passerelle MCP (mcp-gateway:servers:invoke et mcp-gateway:servers:read à la date d’écriture), plus les permissions de lecture Grail nécessaires aux données visées, par exemple storage:spans:read. Créez un jeton dédié, en lecture seule, avec une date d’expiration ; les raisons sont détaillées dans notre article pour sécuriser un serveur MCP. Une fois connecté, vérifiez que l’assistant liste bien les outils Dynatrace avant d’aller plus loin.

Étape 2 — Partir du symptôme, pas de l’hypothèse

Formulez la première question à partir de ce que vous observez, sans orienter l’assistant vers une cause supposée :

Quel problème Dynatrace est ouvert sur le service api-commandes ?
Depuis quand, et quels endpoints sont les plus touchés ?

Laissez l’assistant identifier l’entité, le problème et la fenêtre temporelle. Demandez-lui de citer la période et les chiffres sur lesquels il s’appuie.

Étape 3 — Descendre jusqu’aux appels coûteux

Demandez ensuite ce qui compose le temps de réponse : appels de base de données, appels sortants, temps CPU. Pour contrôler la réponse, rien n’empêche de lancer soi-même une requête équivalente dans un Notebook. Par exemple, pour compter les requêtes SQL émises par le service :

fetch spans, from: now() - 2h
| filter service.name == "api-commandes"
| filter isNotNull(db.query.text)
| summarize appels = count(), duree_moy = avg(duration), by: { db.query.text }
| sort appels desc
| limit 10

Le nom exact des champs (db.query.text ou db.statement selon l’instrumentation) est à adapter à vos données. Dans notre scénario, le résultat est sans appel : une même requête SELECT sur la table des adresses est exécutée des dizaines de fois par appel de l’endpoint.

Étape 4 — Relier la mesure au code

C’est ici que l’assistant de code prend tout son intérêt : il dispose à la fois de la requête SQL observée et du dépôt. Demandez-lui de retrouver l’endroit qui l’émet. Il identifie une boucle qui charge l’adresse de chaque commande une par une, le classique problème « N+1 » :

# Avant : une requête par commande
for commande in commandes:
    commande.adresse = db.fetch_one(
        "SELECT * FROM adresses WHERE id = %s", (commande.adresse_id,)
    )

# Après : une seule requête pour toutes les commandes
ids = [c.adresse_id for c in commandes]
adresses = db.fetch_all("SELECT * FROM adresses WHERE id = ANY(%s)", (ids,))
par_id = {a.id: a for a in adresses}
for commande in commandes:
    commande.adresse = par_id.get(commande.adresse_id)

Relisez le correctif comme n’importe quelle contribution : l’assistant propose, vous validez.

Étape 5 — Vérifier l’effet après déploiement

Un correctif n’est terminé que lorsque la production le confirme. Après le déploiement, reposez la même question au serveur MCP : nombre de requêtes SQL par appel, temps de réponse au 95e centile, état du problème. Si la courbe ne bouge pas, la cause était ailleurs et l’investigation reprend avec de nouvelles données plutôt qu’avec une intuition.

Bonnes pratiques

  • Exiger que chaque affirmation de l’assistant soit accompagnée de la période et des valeurs mesurées.
  • Contre-vérifier les conclusions importantes par une requête DQL lancée soi-même.
  • Utiliser un jeton personnel ou d’équipe, en lecture seule, avec date d’expiration.
  • Garder la main sur toute action en production : l’assistant propose, un humain applique.
  • Surveiller la consommation de requêtes et de tokens : une investigation bavarde a un coût.
  • Conserver la conversation utile dans le ticket d’incident pour le post-mortem.

Questions fréquentes

Le serveur MCP Dynatrace peut-il modifier ma production ?

Son usage principal est la consultation des données. Les droits effectifs dépendent du jeton que vous lui fournissez : accordez uniquement des permissions de lecture pour ce type d’usage.

Quel assistant de code utiliser ?

Tout hôte compatible MCP peut fonctionner. Dynatrace propose aussi des intégrations dédiées, comme le plugin pour Cursor ou un agent Copilot Studio dans Teams.

Faut-il connaître DQL pour en profiter ?

Non pour démarrer, l’assistant construit les requêtes. Mais savoir lire une requête DQL aide beaucoup à vérifier ce qu’il a réellement interrogé.

Conclusion

Le serveur MCP Dynatrace ne remplace pas le jugement du développeur : il supprime la traduction manuelle entre la console et l’éditeur. En partant du symptôme mesuré, en reliant la mesure au code puis en vérifiant le résultat en production, on transforme une intuition en boucle de correction courte et contrôlable. Pour aller au bout de la démarche, tracez aussi ces échanges, comme nous le montrons pour observer les agents MCP avec OpenTelemetry.

Pour aller plus loin : From symptom to fix in minutes: AI-assisted development with Dynatrace MCP (blog Dynatrace, en anglais).

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.

Total
0
Shares
1 comment
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Model Context Protocol (MCP) expliqué : hôte, client, serveur, outils et transports

Model Context Protocol (MCP) expliqué : hôte, client, serveur, outils et transports

Next Post
Sécuriser serveur MCP : tokens, moindre privilège, injection de prompt et validation humaine

Sécuriser serveur MCP : tokens, moindre privilège, injection de prompt et validation humaine

Related Posts