Sinasabi sa iyo ng mga dashboard ng provider kung magkano ang ginastos mo. Bihira nilang sabihin kung aling feature o aling customer ang gumastos nito, at hindi nila masasabi kung bakit tumalon ang bill noong Martes. Kaya iyan ng sarili mong usage log. Ipinapakita ng post na ito ang schema ng log, isang wrapper na pumupuno rito, paano kuwentahin ang gastos kada tawag, at paano ilayo ang personal na data. Nasa ibang post kung ano ang gagawin sa mga numero: gastos kada user at SaaS pricing at budget at loop guard.
Ano ang dapat i-log sa bawat tawag sa LLM?
Isang row kada attempt, kasama ang mga retry:
| Field | Halimbawa | Bakit |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Time series, timeline ng incident |
feature |
support_reply |
Gastos kada feature |
user_hash |
hmac:4f1c… |
Gastos kada user nang hindi itinatago ang pagkakakilanlan |
tenant |
acme |
Gastos kada customer sa mga B2B app |
model |
broadnet/deepseek-v4.1-flash | Paghanap ng presyo, paghahambing ng model |
prompt_tokens |
18,240 | Gastos sa input |
cached_tokens |
16,384 | Mas mura ang cached input; subaybayan ang cache rate |
reasoning_tokens |
612 | Nakatagong gastos sa output ng mga reasoning model |
completion_tokens |
1,104 | Gastos sa output (kasama ang reasoning) |
cost_usd |
kinuwenta | Ang numerong hinihingi ng finance |
latency_ms, ttft_ms |
4,210 / 690 | Regression sa performance |
status |
200, 429, 503 | Rate ng error at retry |
request_id |
value ng X-Request-ID |
Support ticket at pagtutol sa invoice |
prompt_version |
support-v14 |
Iniuugnay ang pagbabago ng gastos sa pagbabago ng prompt |
Walang text ng prompt, walang text ng response. Mamaya pa ang mga iyon, at may redaction lang.
Paano kuwentahin ang gastos kada tawag?
Basahin ang usage block at hiwalay na presyuhan ang bawat uri ng token. Naglalathala ang BroadNet ng machine-readable na presyo sa pricing.json, na may presyo kada 1M para sa input, cached input at output ng bawat model:
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
I-cache ang price file at i-refresh ito araw-araw sa halip na kunin ito sa bawat tawag. Dalawang madaling pagkakamali: pagpresyo sa cached token bilang bagong input (pinapalaki ang gastos), at pagkalimot na nasa loob na ng completion_tokens ang reasoning token (huwag itong idagdag nang dalawang beses).
Ano ang hitsura ng logging wrapper?
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})
Ibinibigay sa iyo ng with_raw_response ang mga header, kaya maitatago mo ang X-Request-ID. Para sa mga naka-stream na tawag, idagdag ang stream_options={"include_usage": True} at punuin ang row mula sa huling chunk, gaya ng ipinakita sa post tungkol sa SSE streaming. Panatilihing lihim at hindi nagbabago ang HASH_KEY: laging napupunta sa parehong hash ang parehong user, pero hindi mababaligtad ang hash nang walang key.
Paano iuugnay ang gastos sa mga user at feature?
Kapag nasa anumang SQL store na ang mga row sa itaas, isang query lang ang attribution:
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;
Palitan ang feature ng user_hash o tenant para sa gastos kada customer. Tatlong follow-up ang mabilis na nagbubunga:
- Top 1% ng mga user ayon sa gastos. Kadalasan ay iisang loop o bot. Ang bumababang
cache_rateang isa pang maagang babala; ipinapakita ng prompt caching calculator kung magkano ang halaga ng bawat punto ng cache rate. - Gastos kada matagumpay na resulta, hindi kada tawag: i-join sa sarili mong success event.
- Bahagi ng retry. Ipinapakita ng mga row na may status na 429 o 5xx kung magkano ang ginagastos mo sa mga pagpalya; tingnan ang paghawak sa mga 429 error.
Paano ilayo ang PII sa mga log ng LLM?
Ang pinakaligtas na log ay walang anumang text ng prompt. Kapag kailangan mo ng text, para sa debugging o eval, sundin ang mga hakbang na ito ayon sa pagkakasunod:
- Mag-sample. Itago ang text para sa maliit na bahagi ng mga tawag at para sa mga pagpalya, hindi para sa lahat.
- Mag-redact bago magsulat. Patakbuhin ang redaction sa prosesong sumusulat ng log. Kapag mamaya pa nag-redact, nasa disk at nasa mga backup na ang raw na text.
- Patungin ang mga detector. Regex para sa structured na data, NER tool para sa pangalan at address.
- Itago nang hiwalay. Ilagay ang text sa ibang table o bucket na mas mahigpit ang access at maikli ang retention, na naka-link gamit ang
request_id. - Huwag kailanman mag-log ng secret. Inililista ng OWASP logging cheat sheet ang access token, password at encryption key sa mga data na hindi dapat isama; kabilang sa listahang iyon ang API key.
Isang minimal na regex layer:
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
Nahuhuli nito ang mga halatang kaso at nalulusutan ng mga pangalan, address at anumang kakaiba. Nagdadagdag ang Microsoft Presidio ng entity recognition para sa mga iyon, at tahasang sinasabi ng README nito na walang garantiyang mahahanap nito ang lahat ng sensitibong impormasyon. Maghanda sa mga malulusutan: nililimitahan ng maikling retention at mahigpit na access ang pinsala kapag may nakalusot.
Saan pumapasok ang BroadNet Inference
Ibinabalik ng BroadNet Inference ang usage block na may cached at reasoning token kapag iniuulat ng model ang mga ito, isang X-Request-ID sa bawat response, at isang pampublikong price file na puwede mong i-load para sa pagkuwenta ng gastos. Sa panig nito, pinoproseso ang mga prompt at sagot para sa request at hindi itinatago; mga record na walang content lang ang itinatago nito, gaya ng timing, bilang ng token at gastos (paano gumagana ang zero data retention). Dahil diyan, ang sarili mong mga log ang tanging kopya ng anumang text ng prompt, kaya ang mga patakaran sa redaction sa itaas ang nagpapasya ng tunay mong retention. Walang per-user na metadata field ang mga chat request ng BroadNet, kaya nasa wrapper mo ang attribution. Para sa hiwalay na budget kada team, gumamit ng hiwalay na key; sinasaklaw ng gabay sa mga key ang mga label at allow-list.
