Profilage continu avec Pyroscope ou Parca : du span lent au code coupable

Profilage continu avec Pyroscope ou Parca : licences, lien trace vers profil, eBPF et état des profils OpenTelemetry, pour trouver le code coupable.
Profilage continu avec Pyroscope ou Parca : du span lent au code coupable

Votre trace lente montre qu’un span de 900 ms passe son temps « dans le service de paiement », et c’est tout. Le profilage continu répond à la question suivante : quelle fonction, quelle ligne, a consommé ce temps de CPU ? Deux outils open source se disputent ce terrain, Grafana Pyroscope et Parca. Cet article part de la décision que vous devez prendre en exploitation, et non d’une visite des interfaces.

Les faits viennent des pages GitHub des deux projets et de leur documentation officielle, lues le 11 novembre 2026. Je n’ai installé ni l’un ni l’autre pour cet article : ce qui n’est pas vérifié est signalé comme tel.

Si vous débutez avec les traces, commencez par l’anatomie d’un span OpenTelemetry. Le profil vient en complément du span : il explique le « pourquoi » là où la trace donne le « où ».

Le problème : la trace dit où, pas pourquoi

Une trace découpe une requête en spans. Elle désigne le maillon lent, mais pas le code coupable. Pour aller plus loin, on ajoute souvent des logs, puis des spans manuels, puis on redéploie. Chaque tour coûte du temps d’astreinte.

Un profileur échantillonne la pile d’appels à intervalle régulier. Plus une fonction apparaît souvent dans les échantillons, plus elle consomme. Rendu en flamegraph, le résultat se lit d’un coup d’œil. Le mot « continu » signifie que l’échantillonnage tourne en permanence en production, pas seulement pendant une enquête. Vous disposez donc déjà du profil quand l’incident survient.

Profilage continu : choisir entre Pyroscope et Parca

Voici ce que disent les dépôts, sans conclusion hâtive :

  • Grafana Pyroscope : licence AGPL-3.0, environ 11 700 étoiles sur la page du dépôt. Il se présente comme une « plateforme de profilage continu » qui aide à déboguer jusqu’à une seule ligne de code. Les profils arrivent par Grafana Alloy (collecte en pull ou en push), par des SDK (Go, Java, Python, Ruby, Node.js, .NET, Rust) ou par OTLP depuis le profileur eBPF d’OpenTelemetry.
  • Parca : licence Apache 2.0, environ 5 000 étoiles. Il propose un serveur qui stocke et interroge les profils dans le temps, et Parca Agent, un profileur eBPF pour l’ensemble du système. La page du dépôt cite C, C++, Rust et Go pour l’agent.

Pour la date du dernier commit et les versions, la page GitHub lue ne les affichait pas : vérifiez-les vous-même avant de choisir. Le choix tient en deux questions.

  1. Avez-vous besoin du lien trace vers profil ? La documentation Pyroscope décrit des « span profiles » pour Go, Java, Ruby, .NET et Python. Dans les pages de Parca que j’ai lues, la corrélation avec les traces n’est pas décrite. Je ne l’affirme donc pas.
  2. Quelle licence votre entreprise accepte-t-elle ? L’AGPL-3.0 impose des obligations si vous modifiez le serveur et le proposez en réseau. Apache 2.0 est plus permissive. Faites valider ce point par votre service juridique.

Du span lent au profil : comment le lien fonctionne

Le mécanisme documenté par Pyroscope est simple. Chaque échantillon de profil porte des libellés : span_id identifie le span actif au moment de l’échantillon, et trace_id la trace qui le contient. Un span qui peut avoir un profil porte l’attribut pyroscope.profile.id, dont la valeur est l’identifiant du span. Grafana s’en sert pour proposer le saut du span vers son profil.

Exemple illustratif des libellés d'un échantillon de profil : span_id, trace_id et l'attribut pyroscope.profile.id posé sur le span

Pour que Grafana trouve le couple trace et profil, la documentation demande de configurer la source de données Tempo dans Grafana. Elle renvoie à une page « Traces to profiles » pour le détail, que je n’ai pas relue. Pour monter Tempo, voir notre article sur Grafana Tempo avec kube-prometheus-stack.

Étapes : instrumenter un service Go

Voici l’exemple de la documentation officielle pour Go. Il suppose que vous avez déjà un tracer OpenTelemetry (tp) et un serveur Pyroscope sur le port 4040.

  1. Installez le module : go get github.com/grafana/otel-profiling-go.
  2. Démarrez le SDK Pyroscope au lancement du processus.
  3. Enveloppez votre fournisseur de traces avec otelpyroscope.NewTracerProvider.
Extrait de code Go tiré de la documentation Pyroscope : imports otelpyroscope et pyroscope-go, pyroscope.Start avec ApplicationName et ServerAddress, puis otel.SetTracerProvider

Le point critique est la troisième étape : sans l’enveloppe, les profils existent mais ne portent pas le span_id, et le saut depuis la trace est impossible. Remplacez my-service et l’adresse par vos valeurs.

Ce que le lien ne garantit pas

La documentation est explicite sur les limites. Voici celles qui comptent pour l’astreinte :

  • Par défaut, seul le span racine local est marqué. Son profil inclut les échantillons de ses spans enfants. Go et Java peuvent marquer chaque span.
  • L’attribut pyroscope.profile.id ne garantit pas la présence d’échantillons.
  • Le profileur échantillonne : un span très court peut n’avoir aucun échantillon, et un span avec peu d’échantillons peut tromper.
  • Évitez les noms de span dynamiques (URL, SQL) : ils dégradent les performances.

Conséquence pratique : le profil sert à confirmer une hypothèse sur des spans longs, pas à expliquer un span de 2 ms. Pour la différence entre identifiants de corrélation, lisez aussi corrélation ID ou trace ID.

Parca et eBPF : profiler sans toucher au code

Si vos services sont en C, C++, Rust ou Go et que vous ne voulez pas modifier le code, l’approche eBPF est séduisante. Parca Agent découvre les cibles depuis Kubernetes ou systemd et pousse les profils vers le serveur. La documentation de Parca décrit un stockage dédié où chaque série est identifiée par sa combinaison de libellés, ce qui permet de comparer des profils entre processus ou versions du code.

Capture de l'interface web de Parca tirée du dépôt parca-dev/parca : graphique de séries CPU, puis flamegraph en icicle coloré par binaire
Source : github.com

La capture, issue du dépôt Apache 2.0, montre le graphique de consommation puis le flamegraph inversé (icicle). Pour comprendre ce que l’eBPF change côté exploitation, voyez eBPF et Cilium sur Kubernetes.

OpenTelemetry et les profils : où en est-on ?

OpenTelemetry travaille sur un signal « profiles ». Selon l’annonce du blog officiel, il est entré en alpha publique, et il « ne doit pas être utilisé pour des charges de production critiques ». L’annonce note aussi que les backends prêts pour la production n’existaient pas encore, avec Beta et GA comme prochaines étapes. Je n’ai pas pu relever la date de l’annonce : vérifiez l’état actuel avant de vous engager.

Concrètement, n’attendez pas ce standard pour commencer. Pyroscope accepte déjà l’OTLP depuis le profileur eBPF d’OpenTelemetry d’après son README.

Bonnes pratiques

  • Commencez par un seul service critique, pas toute la flotte.
  • Gardez les noms de span stables et peu nombreux.
  • Mesurez le surcoût du profileur en préproduction avant d’activer la production : je n’ai pas de chiffre vérifié à vous donner.
  • Documentez dans le runbook : « span lent, ouvrir le profil du span, chercher la fonction la plus large ».
  • Notez la licence retenue et la date de votre vérification.

Questions fréquentes

Quelle différence entre profilage continu et trace ?

La trace mesure le temps passé par étape de requête. Le profil échantillonne les piles d’appels et indique quelles fonctions consomment du CPU ou de la mémoire. Les deux se complètent.

Pyroscope ou Parca : lequel choisir ?

Si vous voulez sauter d’un span vers son profil dans Grafana, la documentation de Pyroscope le décrit. Si l’eBPF sans modification de code et la licence Apache 2.0 priment, Parca mérite un essai. Testez les deux sur un service avant de trancher.

Et Dynatrace ?

Cet article ne traite que d’outils open source tiers. Pour ce que fait Dynatrace dans ce domaine, consultez docs.dynatrace.com en séparant SaaS et Managed : je n’en mélange aucune fonction ici.

Conclusion

Le profilage continu transforme « le span est lent » en « cette fonction est coupable », à condition de lier profils et traces. Choisissez selon la licence, le lien avec vos traces et votre langage. Sources : documentation Pyroscope, documentation Parca.

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

Total
0
Shares
Laisser un commentaire

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

Previous Post
Tutoriel eBPF : apprendre pas à pas avec bpf-developer-tutorial

Tutoriel eBPF : apprendre pas à pas avec bpf-developer-tutorial

Next Post
OpenCost Kubernetes : relier coûts et observabilité

OpenCost Kubernetes : relier coûts et observabilité

Related Posts