Les tableaux de bord des fournisseurs vous disent ce que vous avez dépensé. Ils vous disent rarement quelle fonctionnalité ou quel client l’a dépensé, et ne peuvent pas expliquer pourquoi une facture a bondi mardi. Votre propre journal d’usage le peut. Cet article présente le schéma du journal, une fonction d’enveloppe qui le remplit, le calcul du coût par appel et la manière de tenir les données personnelles à l’écart. Ce qu’on fait des chiffres est traité ailleurs : coût par utilisateur et tarification SaaS et budgets et garde-fous contre les boucles.
Que journaliser pour chaque appel LLM ?
Une ligne par tentative, relances comprises :
| Champ | Exemple | Pourquoi |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Séries temporelles, chronologies d’incidents |
feature |
support_reply |
Coût par fonctionnalité |
user_hash |
hmac:4f1c… |
Coût par utilisateur sans stocker l’identité |
tenant |
acme |
Coût par client dans les applications B2B |
model |
broadnet/deepseek-v4.1-flash | Recherche du prix, comparaisons de modèles |
prompt_tokens |
18 240 | Coût d’entrée |
cached_tokens |
16 384 | L’entrée en cache coûte moins cher ; suivez le taux de cache |
reasoning_tokens |
612 | Coût de sortie caché des modèles de raisonnement |
completion_tokens |
1 104 | Coût de sortie (raisonnement inclus) |
cost_usd |
calculé | Le chiffre que demande la finance |
latency_ms, ttft_ms |
4 210 / 690 | Régressions de performance |
status |
200, 429, 503 | Taux d’erreurs et de relances |
request_id |
valeur de X-Request-ID |
Tickets de support et contestations de facture |
prompt_version |
support-v14 |
Relie les variations de coût aux changements de prompt |
Pas de texte de prompt, pas de texte de réponse. Ils viennent plus tard, et seulement avec masquage.
Comment calculer le coût de chaque appel ?
Lisez le bloc usage et tarifez chaque type de token séparément. BroadNet publie des prix lisibles par machine dans pricing.json, avec des prix par million pour l’entrée, l’entrée en cache et la sortie de chaque modèle :
import json, urllib.request
PRICES = {m["id"]: m for m in json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))["models"]}
def call_cost(model: str, usage) -> float:
p = PRICES[model]
details = getattr(usage, "prompt_tokens_details", None)
cached = (getattr(details, "cached_tokens", 0) or 0) if details else 0
new_input = usage.prompt_tokens - cached
return (
new_input * (p.get("input_per_m") or 0)
+ cached * (p.get("cached_input_per_m") or p.get("input_per_m") or 0)
+ usage.completion_tokens * (p.get("output_per_m") or 0)
) / 1_000_000
Mettez le fichier de prix en cache et rafraîchissez-le chaque jour plutôt que de le télécharger à chaque appel. Deux erreurs faciles : compter les tokens en cache au prix d’une entrée nouvelle (ce qui surestime le coût), et oublier que les tokens de raisonnement sont déjà inclus dans completion_tokens (ne les ajoutez pas deux fois).
À quoi ressemble la fonction d’enveloppe de journalisation ?
import hashlib, hmac, os, time, logging
from openai import OpenAI
log = logging.getLogger("llm.usage")
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
HASH_KEY = os.environ["USAGE_HASH_KEY"].encode()
def user_hash(user_id: str) -> str:
return "hmac:" + hmac.new(HASH_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]
def chat(*, feature: str, user_id: str, prompt_version: str, **kwargs):
t0 = time.perf_counter()
row = {"feature": feature, "user_hash": user_hash(user_id),
"model": kwargs["model"], "prompt_version": prompt_version}
try:
raw = client.chat.completions.with_raw_response.create(**kwargs)
resp = raw.parse()
u = resp.usage
d = getattr(u, "completion_tokens_details", None)
row.update(
status=200,
request_id=raw.headers.get("x-request-id"),
prompt_tokens=u.prompt_tokens,
cached_tokens=getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0,
reasoning_tokens=(getattr(d, "reasoning_tokens", 0) or 0) if d else 0,
completion_tokens=u.completion_tokens,
cost_usd=round(call_cost(kwargs["model"], u), 6),
)
return resp
except Exception as e:
row.update(status=getattr(e, "status_code", "error"),
request_id=getattr(getattr(e, "response", None), "headers", {}).get("x-request-id"))
raise
finally:
row["latency_ms"] = int((time.perf_counter() - t0) * 1000)
log.info("llm_call", extra={"llm": row})
with_raw_response vous donne les en-têtes, ce qui permet de garder le X-Request-ID. Pour les appels en streaming, ajoutez stream_options={"include_usage": True} et remplissez la ligne à partir du dernier chunk, comme le montre l’article sur le streaming SSE. Gardez HASH_KEY secrète et stable : un même utilisateur donne toujours le même hachage, mais le hachage ne peut pas être inversé sans la clé.
Comment attribuer le coût aux utilisateurs et aux fonctionnalités ?
Avec les lignes ci-dessus dans n’importe quelle base SQL, l’attribution tient en une requête :
SELECT feature, model,
count(*) AS calls,
sum(cost_usd) AS cost,
sum(cached_tokens)::float / nullif(sum(prompt_tokens), 0) AS cache_rate,
avg(completion_tokens) AS avg_out
FROM llm_calls
WHERE ts >= now() - interval '7 days'
GROUP BY feature, model
ORDER BY cost DESC;
Remplacez feature par user_hash ou tenant pour obtenir le coût par client. Trois analyses complémentaires rapportent vite :
- Le 1 % d’utilisateurs le plus coûteux. Souvent une seule boucle ou un bot. Un
cache_rateen baisse est l’autre signal d’alerte précoce ; le calculateur de prompt caching montre ce que vaut chaque point de taux de cache. - Le coût par résultat réussi, et non par appel : faites une jointure avec vos propres événements de succès.
- La part des relances. Les lignes au statut 429 ou 5xx montrent combien vous dépensez en échecs ; voir gérer les erreurs 429.
Comment tenir les PII à l’écart des journaux LLM ?
Le journal le plus sûr ne contient aucun texte de prompt. Quand vous avez besoin du texte, pour déboguer ou pour des évaluations, suivez ces étapes dans l’ordre :
- Échantillonnez. Gardez le texte pour une petite part des appels et pour les échecs, pas pour tout.
- Masquez avant d’écrire. Faites le masquage dans le processus qui écrit le journal. Masquer plus tard signifie que le texte brut est déjà sur le disque et dans les sauvegardes.
- Combinez les détecteurs. Des regex pour les données structurées, un outil de NER pour les noms et les adresses.
- Stockez à part. Placez le texte dans une autre table ou un autre bucket, avec un accès plus strict et une courte durée de conservation, relié par
request_id. - Ne journalisez jamais de secrets. L’OWASP Logging Cheat Sheet range les jetons d’accès, les mots de passe et les clés de chiffrement parmi les données à exclure ; la clé d’API a sa place sur cette liste.
Une couche de regex minimale :
import re
PATTERNS = [
(re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+"), "[EMAIL]"),
(re.compile(r"\+?\d[\d\s().-]{7,}\d"), "[PHONE]"),
(re.compile(r"\b(?:\d[ -]?){13,19}\b"), "[CARD]"),
(re.compile(r"\b(sk|key|bearer)[-_ ]?[A-Za-z0-9]{16,}\b", re.I), "[SECRET]"),
]
def redact(text: str) -> str:
for pat, label in PATTERNS:
text = pat.sub(label, text)
return text
Elle attrape les cas évidents et laisse passer les noms, les adresses et tout ce qui sort de l’ordinaire. Microsoft Presidio ajoute la reconnaissance d’entités pour ces cas, et son README dit clairement qu’il n’y a aucune garantie qu’il trouve toutes les informations sensibles. Prévoyez des oublis : une courte conservation et un accès restreint limitent les dégâts quand quelque chose passe à travers.
La place de BroadNet Inference
BroadNet Inference renvoie le bloc usage avec les tokens en cache et de raisonnement quand le modèle les indique, un X-Request-ID sur chaque réponse, et un fichier de prix public que vous pouvez charger pour calculer les coûts. De son côté, les prompts et les réponses sont traités pour la requête et ne sont pas conservés ; il ne garde que des enregistrements sans contenu, comme les durées, les nombres de tokens et le coût (fonctionnement de la conservation zéro des données). Vos propres journaux sont donc la seule copie de tout texte de prompt, et ce sont les règles de masquage ci-dessus qui déterminent votre conservation réelle. Les requêtes de chat de BroadNet n’ont pas de champ de métadonnées par utilisateur : l’attribution se fait dans votre fonction d’enveloppe. Pour des budgets séparés par équipe, utilisez des clés séparées ; le guide des clés couvre les libellés et les listes d’IP autorisées.
