Le dashboard dei provider ti dicono quanto hai speso. Raramente ti dicono quale funzione o quale cliente l’ha speso, e non possono dirti perché la fattura è schizzata martedì. Il tuo log di utilizzo può farlo. Questo articolo mostra lo schema del log, un wrapper che lo compila, come calcolare il costo di ogni chiamata e come tenere fuori i dati personali. Che cosa fare con i numeri è trattato altrove: costo per utente e prezzi di un SaaS e budget e protezioni contro i loop.
Che cosa registrare per ogni chiamata LLM?
Una riga per tentativo, retry compresi:
| Campo | Esempio | Perché |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Serie temporali, cronologia degli incidenti |
feature |
support_reply |
Costo per funzione |
user_hash |
hmac:4f1c… |
Costo per utente senza salvarne l’identità |
tenant |
acme |
Costo per cliente nelle app B2B |
model |
broadnet/deepseek-v4.1-flash | Ricerca del prezzo, confronti tra modelli |
prompt_tokens |
18.240 | Costo dell’input |
cached_tokens |
16.384 | L’input in cache costa meno; monitora il tasso di cache |
reasoning_tokens |
612 | Costo nascosto dell’output nei modelli di ragionamento |
completion_tokens |
1.104 | Costo dell’output (ragionamento incluso) |
cost_usd |
calcolato | Il numero che chiede l’amministrazione |
latency_ms, ttft_ms |
4.210 / 690 | Regressioni di prestazioni |
status |
200, 429, 503 | Tassi di errore e di retry |
request_id |
valore di X-Request-ID |
Ticket di supporto e contestazioni delle fatture |
prompt_version |
support-v14 |
Collega le variazioni di costo alle modifiche del prompt |
Niente testo del prompt, niente testo della risposta. Quelli vengono dopo, e solo con l’oscuramento.
Come si calcola il costo di ogni chiamata?
Leggi il blocco usage e prezza separatamente ogni tipo di token. BroadNet pubblica i prezzi in formato leggibile dalle macchine in pricing.json, con i prezzi per 1M di input, input in cache e output per ogni modello:
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
Tieni in cache il file dei prezzi e aggiornalo ogni giorno invece di scaricarlo a ogni chiamata. Due errori facili: prezzare i token in cache come input nuovo (sovrastima il costo) e dimenticare che i token di ragionamento sono già dentro completion_tokens (non sommarli due volte).
Com’è il wrapper di logging?
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 ti dà gli header, così puoi conservare l’X-Request-ID. Per le chiamate in streaming, aggiungi stream_options={"include_usage": True} e compila la riga dall’ultimo chunk, come mostrato nell’articolo sullo streaming SSE. Tieni HASH_KEY segreta e stabile: lo stesso utente corrisponde sempre allo stesso hash, ma senza la chiave l’hash non si può invertire.
Come si attribuiscono i costi a utenti e funzioni?
Con le righe qui sopra in un qualsiasi database SQL, l’attribuzione è una query:
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;
Sostituisci feature con user_hash o tenant per il costo per cliente. Tre approfondimenti ripagano subito:
- L’1% degli utenti che costa di più. Spesso è un singolo loop o un bot. Un
cache_ratein calo è l’altro segnale d’allarme precoce; il calcolatore del prompt caching mostra quanto vale ogni punto di tasso di cache. - Costo per esito positivo, non per chiamata: collega le righe ai tuoi eventi di successo.
- Quota di retry. Le righe con stato 429 o 5xx mostrano quanto spendi in fallimenti; vedi gestire gli errori 429.
Come si tengono le PII fuori dai log LLM?
Il log più sicuro non contiene alcun testo dei prompt. Quando ti serve il testo, per il debug o per le valutazioni, segui questi passi nell’ordine:
- Campiona. Conserva il testo per una piccola parte delle chiamate e per i fallimenti, non per tutto.
- Oscura prima di scrivere. Esegui l’oscuramento nel processo che scrive il log. Oscurare dopo significa che il testo grezzo è già su disco e nei backup.
- Combina i rilevatori. Regex per i dati strutturati, uno strumento NER per nomi e indirizzi.
- Salva separatamente. Metti il testo in una tabella o in un bucket diverso con accessi più restrittivi e conservazione breve, collegato tramite
request_id. - Non registrare mai segreti. Il cheat sheet di OWASP sul logging include token di accesso, password e chiavi di cifratura tra i dati da escludere; la chiave API va in quell’elenco.
Un livello minimo di regex:
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
Questo intercetta i casi ovvi e si lascia sfuggire nomi, indirizzi e tutto ciò che è insolito. Microsoft Presidio aggiunge il riconoscimento delle entità per questi casi, e il suo README dice chiaramente che non c’è garanzia che trovi tutte le informazioni sensibili. Metti in conto le mancate rilevazioni: conservazione breve e accessi ristretti limitano i danni quando qualcosa passa.
Dove si inserisce BroadNet Inference
BroadNet Inference restituisce il blocco usage con token in cache e di ragionamento quando il modello li riporta, un X-Request-ID in ogni risposta e un file prezzi pubblico che puoi caricare per calcolare i costi. Dal suo lato, prompt e risposte vengono elaborati per la richiesta e non conservati; tiene solo registrazioni prive di contenuto come tempi, conteggi dei token e costi (come funziona la zero data retention). Così i tuoi log sono l’unica copia di qualsiasi testo dei prompt, e le regole di oscuramento qui sopra decidono la tua conservazione effettiva. Le richieste chat di BroadNet non hanno un campo di metadati per utente, quindi l’attribuzione sta nel tuo wrapper. Per budget separati per team, usa chiavi separate; la guida alle chiavi spiega etichette e allow-list.
