Observabilité : traces, coût et délai

• Une application qui appelle un modèle (appeler un modèle en dix lignes).
• Un compte sur un service de traces, dans la région voulue, ou un serveur pour l'installer chez vous.
• Une règle sur les données : ce qui peut entrer dans une trace, et combien de temps on la garde (le RGPD).

1. Choisir où garder les traces

   Ce qu'on fait : un service en ligne, dans la région voulue, ou un outil installé chez vous ; le tableau des variantes les compare.

2. Instrumenter l'application

   Ce qu'on fait : quelques lignes : un décorateur sur vos fonctions, et le client du modèle enveloppé ; chaque appel devient une trace.

   À vérifier : l'instrumentation officielle d'OpenTelemetry pour OpenAI est encore en bêta.

3. Décider de ce qui entre dans une trace

   Ce qu'on fait : les mesures toujours ; le texte des messages seulement si l'équipe en a besoin, et sans données personnelles.

   À vérifier : dans les conventions d'OpenTelemetry, le contenu des messages, les consignes et la définition des outils sont à activer, pas actifs par défaut.

4. Lire les premières traces

   Ce qu'on fait : le modèle, les tokens, la durée, le délai avant le premier token, et les appels en erreur.

5. Suivre le coût

   Ce qu'on fait : les tokens de chaque appel, multipliés par le prix du modèle ; regroupés par fonction ou par client (les tokens, le routage entre modèles).

   À vérifier : les tokens lus dans le cache se comptent à part : OpenTelemetry a des mesures distinctes pour l'entrée, la sortie, le cache et le raisonnement.

6. Fixer la conservation

   Ce qu'on fait : combien de jours on garde les traces, selon ce qu'elles contiennent ; et qui peut les lire.

Instrumenter avec Langfuse. Les clés et la région, puis un décorateur sur deux fonctions ; chaque appel au modèle devient une trace, rangée sous la fonction qui l'a fait. Le code est celui de la documentation, non exécuté ici.

LANGFUSE_SECRET_KEY="sk-lf-..."
LANGFUSE_PUBLIC_KEY="pk-lf-..."
LANGFUSE_BASE_URL="https://cloud.langfuse.com" # 🇪🇺 EU region
# LANGFUSE_BASE_URL="https://us.cloud.langfuse.com" # 🇺🇸 US region

from langfuse import observe
from langfuse.openai import openai # OpenAI integration

@observe()
def story():
    return openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "What is Langfuse?"}],
    ).choices[0].message.content

@observe()
def main():
    return story()

main()

• Chaque appel au modèle laisse une tracey compris ceux qui échouent
• La trace donne le modèle, les tokens d'entrée et de sortie, la durée
• Le texte des messages n'est enregistré que si c'est décidé, et sans données personnelles
• Les traces sont gardées dans la région voulue, ou chez vous
• Une durée de conservation est fixée, et connue
• Le coût se lit par fonction, ou par client

• Couper l'envoi des traces : retirer les clés du service des variables d'environnement ; l'application continue de tourner.
• Purger les traces qui n'auraient pas dû être gardées, dans le service ou sur votre serveur.

• Langfuse chez vous : un service web et un service de traitement, sur Postgres, ClickHouse, Redis et un stockage compatible S3 ; les modules d'entreprise, journaux d'audit et règles de conservation, demandent une licence.
• LangSmith garde les traces de base 14 jours, les traces étendues 180 jours ; LangChain dit ne pas entraîner de modèle sur vos données.
• OpenTelemetry, sans service imposé : les conventions couvrent les appels, les agents, MCP, et des règles propres à Anthropic, Bedrock, Azure et OpenAI.