Os painéis dos provedores dizem quanto você gastou. Raramente dizem qual recurso ou qual cliente gastou, e não conseguem dizer por que a conta disparou na terça-feira. O seu próprio log de uso consegue. Este post mostra o esquema do log, um wrapper que o preenche, como calcular o custo por chamada e como deixar dados pessoais de fora. O que fazer com os números está em outros posts: custo por usuário e precificação de SaaS e orçamentos e proteções contra loops.
O que registrar em cada chamada de LLM?
Uma linha por tentativa, novas tentativas incluídas:
| Campo | Exemplo | Por quê |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Séries temporais, linha do tempo de incidentes |
feature |
support_reply |
Custo por recurso |
user_hash |
hmac:4f1c… |
Custo por usuário sem guardar a identidade |
tenant |
acme |
Custo por cliente em apps B2B |
model |
broadnet/deepseek-v4.1-flash | Consulta de preço, comparação entre modelos |
prompt_tokens |
18.240 | Custo de entrada |
cached_tokens |
16.384 | Entrada em cache é mais barata; acompanhe a taxa de cache |
reasoning_tokens |
612 | Custo oculto de saída em modelos de raciocínio |
completion_tokens |
1.104 | Custo de saída (inclui raciocínio) |
cost_usd |
calculado | O número que o financeiro pede |
latency_ms, ttft_ms |
4.210 / 690 | Regressões de desempenho |
status |
200, 429, 503 | Taxas de erro e de novas tentativas |
request_id |
valor de X-Request-ID |
Chamados de suporte e contestação de faturas |
prompt_version |
support-v14 |
Liga mudanças de custo a mudanças de prompt |
Nada de texto do prompt, nada de texto da resposta. Eles vêm depois, e só com mascaramento.
Como calcular o custo por chamada?
Leia o bloco usage e precifique cada tipo de token separadamente. A BroadNet publica preços em formato legível por máquina no pricing.json, com preços por 1M para entrada, entrada em cache e saída de cada modelo:
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
Guarde o arquivo de preços em cache e atualize-o uma vez por dia em vez de baixá-lo a cada chamada. Dois erros fáceis: precificar tokens em cache como entrada nova (superestima o custo) e esquecer que os tokens de raciocínio já estão dentro de completion_tokens (não some duas vezes).
Como fica o wrapper de 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 dá acesso aos cabeçalhos, então você pode guardar o X-Request-ID. Para chamadas em streaming, adicione stream_options={"include_usage": True} e preencha a linha a partir do último chunk, como mostra o post sobre streaming com SSE. Mantenha a HASH_KEY secreta e estável: o mesmo usuário sempre gera o mesmo hash, mas o hash não pode ser revertido sem a chave.
Como atribuir custo a usuários e recursos?
Com as linhas acima em qualquer banco SQL, a atribuição é uma consulta:
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;
Troque feature por user_hash ou tenant para ver o custo por cliente. Três desdobramentos compensam rápido:
- O 1% de usuários mais caros. Muitas vezes é um único loop ou um bot. Uma
cache_rateem queda é o outro sinal de alerta precoce; a calculadora de cache de prompt mostra quanto vale cada ponto de taxa de cache. - Custo por resultado bem-sucedido, não por chamada: cruze com os seus próprios eventos de sucesso.
- Fatia de novas tentativas. Linhas com status 429 ou 5xx mostram quanto você gasta com falhas; veja como lidar com erros 429.
Como manter PII fora dos logs de LLM?
O log mais seguro não tem texto de prompt nenhum. Quando você precisar do texto, para depuração ou avaliações, siga estes passos na ordem:
- Amostre. Guarde texto de uma pequena fração das chamadas e das falhas, não de tudo.
- Mascare antes de gravar. Rode o mascaramento no processo que grava o log. Mascarar depois significa que o texto bruto já está no disco e nos backups.
- Combine detectores. Regex para dados estruturados, uma ferramenta de NER para nomes e endereços.
- Guarde separado. Coloque o texto em outra tabela ou bucket, com acesso mais restrito e retenção curta, ligado pelo
request_id. - Nunca registre segredos. O cheat sheet de logging da OWASP inclui tokens de acesso, senhas e chaves de criptografia entre os dados a excluir; a chave de API entra nessa lista.
Uma camada mínima de 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
Isso pega os casos óbvios e deixa passar nomes, endereços e qualquer coisa fora do comum. O Microsoft Presidio acrescenta reconhecimento de entidades para esses casos, e o README dele diz com todas as letras que não há garantia de que ele encontre todas as informações sensíveis. Conte com falhas: retenção curta e acesso restrito limitam o estrago quando algo escapa.
Onde a BroadNet Inference se encaixa
A BroadNet Inference devolve o bloco usage com tokens em cache e de raciocínio quando o modelo os informa, um X-Request-ID em toda resposta e um arquivo público de preços que você pode carregar para calcular custos. Do lado dela, prompts e respostas são processados para a requisição e não são retidos; ela guarda só registros sem conteúdo, como tempos, contagens de tokens e custo (como funciona a retenção zero de dados). Isso faz dos seus próprios logs a única cópia de qualquer texto de prompt, então as regras de mascaramento acima definem a sua retenção real. As requisições de chat da BroadNet não têm campo de metadados por usuário, então a atribuição fica no seu wrapper. Para orçamentos separados por equipe, use chaves separadas; o guia de chaves explica rótulos e allow-lists.
