---
title: "LLM usage logging: gastos kada user at feature, walang PII"
description: "I-log ang bawat tawag sa LLM API kasama ang token, gastos, latency at request ID, iugnay ang gastos sa user at feature, i-redact ang PII bago isulat. May Python."
url: https://broadrouter.com/fil/blog/llm-api-usage-logging/
lang: fil
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/llm-api-usage-logging/) (na-update noong 2026-11-14).

# Usage logging ng LLM API: gastos kada user at feature, walang PII

Ng BroadNet Inference team · 4 minutong basa · Nailathala 2026-11-14

Ibalot ang bawat tawag sa LLM sa iisang function na nagre-record ng model, feature, naka-hash na user ID, prompt, cached, reasoning at output token, gastos, latency, status at request ID ng provider. Kuwentahin ang gastos mula sa price table, hindi sa invoice. Metadata ang i-log bilang default; kung kailangan mong itago ang text ng prompt, i-redact ito bago isulat at magtakda ng maikling retention.

## Mga pangunahing punto

-   Isang wrapper, isang log line kada tawag: model, feature, naka-hash na user, bilang ng token, gastos, latency, status, request ID.
-   Kuwentahin ang gastos kada tawag mula sa usage block at price table: magkakaiba ang presyo ng bagong input, cached input at output.
-   I-hash ang mga user ID gamit ang keyed HMAC para makapag-group ka ayon sa user nang hindi itinatago kung sino sila.
-   Metadata ang i-log bilang default. Ang text ng prompt ang pangunahing panganib sa PII; i-redact bago isulat, hindi kailanman pagkatapos.
-   May nalulusutan ang redaction gamit ang regex at NER. Ituring silang isang layer, hindi garantiya.

**Sa page na ito**

1.  Ano ang dapat i-log sa bawat tawag sa LLM?
2.  Paano kuwentahin ang gastos kada tawag?
3.  Ano ang hitsura ng logging wrapper?
4.  Paano iuugnay ang gastos sa mga user at feature?
5.  Paano ilayo ang PII sa mga log ng LLM?
6.  Saan pumapasok ang BroadNet Inference

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](https://broadrouter.com/fil/blog/llm-cost-per-user-saas/) at [budget at loop guard](https://broadrouter.com/fil/blog/llm-api-spend-control/).

## 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](https://broadrouter.com/fil/blog/cached-input-tokens-explained/) |
| `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](https://broadrouter.com/fil/glossary/input-and-output-tokens/). Naglalathala ang BroadNet ng machine-readable na presyo sa [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-api-usage-logging&utm_content=body), na may presyo kada 1M para sa input, cached input at output ng bawat model:

```python
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?

```python
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](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/). 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:

```sql
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:

1.  **Top 1% ng mga user ayon sa gastos.** Kadalasan ay iisang loop o bot. Ang bumababang `cache_rate` ang isa pang maagang babala; ipinapakita ng [prompt caching calculator](https://broadrouter.com/tools/prompt-caching-calculator/) kung magkano ang halaga ng bawat punto ng cache rate.
2.  **Gastos kada matagumpay na resulta**, hindi kada tawag: i-join sa sarili mong success event.
3.  **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](https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/).

## 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:

1.  **Mag-sample.** Itago ang text para sa maliit na bahagi ng mga tawag at para sa mga pagpalya, hindi para sa lahat.
2.  **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.
3.  **Patungin ang mga detector.** Regex para sa structured na data, NER tool para sa pangalan at address.
4.  **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`.
5.  **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](https://broadrouter.com/fil/glossary/api-key/).

Isang minimal na regex layer:

```python
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](https://github.com/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](https://broadrouter.com/fil/privacy/)). 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](https://broadrouter.com/fil/guides/api-keys-ip-allow-lists/) ang mga label at allow-list.

Mga libreng tool para rito (Ingles)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[Cached input token (cached input tokens)](https://broadrouter.com/fil/glossary/cached-input-tokens/)

Ang cached input token ay prompt token na kamakailan lang naproseso ng LLM provider at magagamit ulit mula sa cache sa halip na kuwentahin muli, kadalasang paulit-ulit na prefix gaya ng system prompt o dokumento. Mas mababa ang singil dito kaysa sa bagong input token.

[Reasoning tokens](https://broadrouter.com/fil/glossary/reasoning-tokens/)

Ang reasoning tokens ay mga token na binubuo ng isang reasoning model para pag-isipan ang isang problema bago nito isulat ang nakikitang sagot. Kadalasang sinisingil ang mga ito bilang output token, binibilang sa output limit at sa context window, at puwedeng itago o ibuod ng API.

[Zero data retention (ZDR)](https://broadrouter.com/fil/glossary/zero-data-retention/)

Ang zero data retention (ZDR) ay patakaran kung saan pinoproseso lang ng AI provider ang mga prompt at output para i-serve ang isang request, at hindi na nito itinatago ang content na iyon pagkatapos, sa log, cache o training data. Kadalasang itinatago pa rin ang mga record na walang content, gaya ng bilang ng token at timing.

[Named entity recognition (NER)](https://broadrouter.com/fil/glossary/named-entity-recognition/)

Ang named entity recognition (NER) ay ang task ng paghahanap ng mga pangalan sa text at paglalagay ng uri sa bawat isa, gaya ng tao, organisasyon o lokasyon. Tina-tag ng mga klasikong system ang bawat token; sa mga LLM naman, madalas hinihingi ang listahan ng entities bilang JSON, na sinusuri pagkatapos laban sa source.

[PII (personally identifiable information)](https://broadrouter.com/fil/glossary/pii/)

Ang PII (personally identifiable information) ay impormasyong magagamit para makilala o ma-trace ang pagkakakilanlan ng isang tao, gaya ng pangalan, ID number o biometric record, pati ibang impormasyong naka-link o mali-link sa taong iyon. Personal data ang mas malawak na termino ng GDPR. Sa LLM, tinatanggal ng PII redaction ito sa mga prompt bago lumabas sa system mo.

[Rate limit](https://broadrouter.com/fil/glossary/rate-limit/)

Ang rate limit ay hangganang itinatakda ng API sa dami ng paggamit ng isang client sa isang yugto ng oras, gaya ng request kada minuto o token kada minuto. Tinatanggihan ang mga request na lampas sa limit, kadalasan na may HTTP 429 Too Many Requests, hanggang bumaba ulit ang paggamit.

## Mga tanong

### Paano ko masusubaybayan ang gastos sa LLM API kada user?

Lagyan ng user identifier ang bawat tawag, basahin ang usage block mula sa response, i-multiply ang bilang ng token sa price table mo, at sumulat ng isang log row kada tawag. Mag-group ayon sa user tag. Naka-hash na ID ang gamitin sa halip na email.

### Dapat ko bang i-log ang buong prompt at response?

Hindi bilang default. Doon nakatira ang personal na data. I-log ang bilang ng token at metadata ng bawat tawag, at itago lang ang buong text para sa mga na-sample o pumalyang tawag, pagkatapos ng redaction, na may maikling retention period.

### Bakit iba ang nakuwenta kong gastos sa invoice ng provider?

Kadalasan dahil pinresyuhan ang cached token na parang bagong input, hindi naisama sa output ang reasoning token, o hindi na-log ang mga retry. I-log ang bawat attempt, kasama ang mga pumalya na nagbalik ng usage.

### Paano ko makukuha ang token usage mula sa streaming response?

I-set sa true ang include\_usage sa stream\_options. Dadalhin ng huling chunk ang usage block na may walang lamang choices list.

### Anong PII redaction tool ang dapat kong gamitin para sa log ng LLM?

Magsimula sa regex para sa structured na data gaya ng email, numero ng telepono at numero ng card, at magdagdag ng NER-based na tool gaya ng Microsoft Presidio para sa pangalan at address. Sabi mismo ng README ng Presidio, hindi nito magagarantiyang mahahanap nito ang lahat.

## Magbasa pa

-   [Zero data retention sa LLM API: checklist na may 10 tanong](https://broadrouter.com/fil/blog/zero-data-retention-llm-api-checklist/)
-   [Cached input token: paano nito binabawasan ang LLM API bill mo](https://broadrouter.com/fil/blog/cached-input-tokens-explained/)
-   [Paano ayusin ang 429 error sa LLM API: backoff, jitter at limiter](https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/)
-   [Paliwanag sa LLM streaming: SSE chunk, delta, usage at cancel](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [Gawing bahagi ng document AI workflow mo ang human review](https://broadrouter.com/fil/blog/document-review-queues/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Paano mag-stream ng chat completions at ayusin ang naputol na stream](https://broadrouter.com/fil/guides/streaming-chat-completions/)
-   [Gabay: I-lock ang API key sa mga server mo gamit ang IP allow-list](https://broadrouter.com/fil/guides/api-keys-ip-allow-lists/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-api-usage-logging&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference, mga usage field, request ID at retention (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-api-usage-logging&utm_content=sources)
-   [Machine-readable na presyo ng BroadNet Inference (pricing.json) (Ingles)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-api-usage-logging&utm_content=sources)
-   [OWASP Logging Cheat Sheet, data na hindi dapat isama sa log](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)
-   [README ng Microsoft Presidio, PII detection at ang mga limitasyon nito (kinuha noong 2026-11-14)](https://github.com/microsoft/presidio)
-   [README ng openai-python, pagbasa ng response header gamit ang with\_raw\_response](https://github.com/openai/openai-python)
