BroadRouter
Inizia

Log di utilizzo delle API LLM: costo per utente e funzione, senza PII

A cura del team di BroadNet Inference · 4 min di lettura · Pubblicato

Avvolgi ogni chiamata LLM in un’unica funzione che registra modello, funzione, ID utente con hash, token di prompt, in cache, di ragionamento e di output, costo, latenza, stato e request ID del provider. Calcola il costo da una tabella prezzi, non dalla fattura. Di default registra solo i metadati; se devi conservare il testo dei prompt, oscuralo prima di scriverlo e imposta una conservazione breve.

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:

  1. L’1% degli utenti che costa di più. Spesso è un singolo loop o un bot. Un cache_rate in calo è l’altro segnale d’allarme precoce; il calcolatore del prompt caching mostra quanto vale ogni punto di tasso di cache.
  2. Costo per esito positivo, non per chiamata: collega le righe ai tuoi eventi di successo.
  3. 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:

  1. Campiona. Conserva il testo per una piccola parte delle chiamate e per i fallimenti, non per tutto.
  2. 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.
  3. Combina i rilevatori. Regex per i dati strutturati, uno strumento NER per nomi e indirizzi.
  4. Salva separatamente. Metti il testo in una tabella o in un bucket diverso con accessi più restrittivi e conservazione breve, collegato tramite request_id.
  5. 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.

Domande frequenti

Come monitoro il costo delle API LLM per utente?

Etichetta ogni chiamata con un identificativo dell’utente, leggi il blocco usage dalla risposta, moltiplica i conteggi dei token per la tua tabella prezzi e scrivi una riga di log per chiamata. Raggruppa per etichetta utente. Usa un ID con hash invece di un’email.

Devo registrare prompt e risposte completi?

Non di default. È lì che stanno i dati personali. Registra conteggi dei token e metadati per ogni chiamata, e conserva il testo completo solo per le chiamate campionate o fallite, dopo l’oscuramento, con un periodo di conservazione breve.

Perché il costo che calcolo è diverso dalla fattura del provider?

Di solito perché i token in cache sono stati prezzati come input nuovo, i token di ragionamento sono stati esclusi dall’output o i retry non sono stati registrati. Registra ogni tentativo, compresi quelli falliti che hanno restituito usage.

Come ottengo l’utilizzo dei token da una risposta in streaming?

Imposta include_usage a true in stream_options. L’ultimo chunk contiene allora il blocco usage con un elenco choices vuoto.

Quale strumento usare per oscurare le PII nei log LLM?

Parti dalle regex per i dati strutturati come email, numeri di telefono e numeri di carta, e aggiungi uno strumento basato su NER come Microsoft Presidio per nomi e indirizzi. Lo stesso README di Presidio dice che non può garantire di trovare tutto.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity