BroadRouter
Mulai

Logging pemakaian API LLM: biaya per pengguna dan fitur, tanpa PII

Oleh tim BroadNet Inference · 4 menit baca · Dipublikasikan

Bungkus setiap panggilan LLM dalam satu fungsi yang mencatat model, fitur, ID pengguna yang di-hash, token prompt, cache, penalaran, dan output, biaya, latensi, status, serta request ID dari penyedia. Hitung biaya dari tabel harga, bukan dari invoice. Catat metadata secara default; jika harus menyimpan teks prompt, redaksi sebelum ditulis dan tetapkan masa simpan yang singkat.

Dasbor penyedia memberi tahu berapa yang Anda habiskan. Dasbor itu jarang memberi tahu fitur mana atau pelanggan mana yang menghabiskannya, dan tidak bisa menjelaskan mengapa tagihan melonjak pada hari Selasa. Log pemakaian Anda sendiri bisa. Artikel ini menunjukkan skema log, wrapper yang mengisinya, cara menghitung biaya per panggilan, dan cara menjauhkan data pribadi. Apa yang dilakukan dengan angka-angka itu dibahas di tempat lain: biaya per pengguna dan harga SaaS serta anggaran dan pengaman loop.

Apa yang perlu dicatat untuk setiap panggilan LLM?

Satu baris per percobaan, termasuk retry:

Field Contoh Alasan
ts 2026-11-14T09:12:03Z Deret waktu, linimasa insiden
feature support_reply Biaya per fitur
user_hash hmac:4f1c… Biaya per pengguna tanpa menyimpan identitas
tenant acme Biaya per pelanggan di aplikasi B2B
model broadnet/deepseek-v4.1-flash Pencarian harga, perbandingan model
prompt_tokens 18.240 Biaya input
cached_tokens 16.384 Input cache lebih murah; pantau cache rate
reasoning_tokens 612 Biaya output tersembunyi pada model penalaran
completion_tokens 1.104 Biaya output (termasuk penalaran)
cost_usd dihitung Angka yang ditanyakan tim keuangan
latency_ms, ttft_ms 4.210 / 690 Regresi performa
status 200, 429, 503 Tingkat error dan retry
request_id nilai X-Request-ID Tiket dukungan dan sengketa invoice
prompt_version support-v14 Mengaitkan perubahan biaya dengan perubahan prompt

Tanpa teks prompt, tanpa teks respons. Keduanya menyusul nanti, dan hanya dengan redaksi.

Bagaimana menghitung biaya per panggilan?

Baca blok usage dan hitung harga setiap jenis token secara terpisah. BroadNet menerbitkan harga yang dapat dibaca mesin di pricing.json, dengan harga per 1 juta untuk input, input cache, dan output per 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

Cache file harga dan perbarui setiap hari, jangan mengambilnya di setiap panggilan. Dua kesalahan yang mudah terjadi: menghargai token cache sebagai input baru (biaya jadi terlalu tinggi), dan lupa bahwa token penalaran sudah termasuk di completion_tokens (jangan dijumlahkan dua kali).

Seperti apa wrapper logging-nya?

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 memberi Anda akses ke header, sehingga Anda bisa menyimpan X-Request-ID. Untuk panggilan streaming, tambahkan stream_options={"include_usage": True} dan isi baris log dari chunk terakhir, seperti ditunjukkan di artikel streaming SSE. Jaga HASH_KEY tetap rahasia dan stabil: pengguna yang sama selalu dipetakan ke hash yang sama, tetapi hash tidak bisa dibalik tanpa kuncinya.

Bagaimana mengatribusikan biaya ke pengguna dan fitur?

Dengan baris-baris di atas di penyimpanan SQL mana pun, atribusi cukup dengan satu kueri:

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;

Ganti feature dengan user_hash atau tenant untuk biaya per pelanggan. Tiga analisis lanjutan cepat membuahkan hasil:

  1. 1% pengguna teratas berdasarkan biaya. Sering kali satu loop atau bot. cache_rate yang menurun adalah peringatan dini lainnya; kalkulator prompt caching menunjukkan nilai setiap poin cache rate.
  2. Biaya per hasil yang berhasil, bukan per panggilan: gabungkan dengan event keberhasilan Anda sendiri.
  3. Porsi retry. Baris dengan status 429 atau 5xx menunjukkan berapa yang Anda habiskan untuk kegagalan; lihat menangani error 429.

Bagaimana menjauhkan PII dari log LLM?

Log yang paling aman sama sekali tidak berisi teks prompt. Ketika Anda membutuhkan teks, untuk debugging atau evaluasi, ikuti langkah-langkah ini secara berurutan:

  1. Ambil sampel. Simpan teks hanya untuk sebagian kecil panggilan dan untuk kegagalan, bukan untuk semuanya.
  2. Redaksi sebelum menulis. Jalankan redaksi di proses yang menulis log. Meredaksi belakangan berarti teks mentah sudah tersimpan di disk dan backup.
  3. Lapisi detektornya. Regex untuk data terstruktur, tool NER untuk nama dan alamat.
  4. Simpan terpisah. Taruh teks di tabel atau bucket lain dengan akses lebih ketat dan masa simpan singkat, dihubungkan lewat request_id.
  5. Jangan pernah mencatat rahasia. OWASP logging cheat sheet mencantumkan access token, kata sandi, dan kunci enkripsi di antara data yang harus dikecualikan; kunci API termasuk dalam daftar itu.

Lapisan regex minimal:

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

Ini menangkap kasus yang jelas dan melewatkan nama, alamat, dan apa pun yang tidak biasa. Microsoft Presidio menambahkan pengenalan entitas untuk hal-hal itu, dan README-nya terus terang menyebut tidak ada jaminan bahwa ia akan menemukan semua informasi sensitif. Rencanakan untuk hal yang terlewat: masa simpan singkat dan akses yang ketat membatasi kerusakan ketika ada yang lolos.

Di mana posisi BroadNet Inference?

BroadNet Inference mengembalikan blok usage beserta token cache dan penalaran jika model melaporkannya, X-Request-ID di setiap respons, dan file harga publik yang bisa Anda muat untuk menghitung biaya. Di sisinya, prompt dan jawaban diproses untuk permintaan itu dan tidak disimpan; BroadNet hanya menyimpan catatan tanpa konten seperti waktu, jumlah token, dan biaya (cara kerja zero data retention). Itu menjadikan log Anda sendiri satu-satunya salinan teks prompt, sehingga aturan redaksi di atas menentukan masa simpan Anda yang sebenarnya. Permintaan chat BroadNet tidak memiliki field metadata per pengguna, jadi atribusi berada di wrapper Anda. Untuk anggaran terpisah per tim, gunakan kunci terpisah; panduan kunci membahas label dan allow-list.

Pertanyaan umum

Bagaimana cara melacak biaya API LLM per pengguna?

Tandai setiap panggilan dengan identifier pengguna, baca blok usage dari respons, kalikan jumlah token dengan tabel harga Anda, lalu tulis satu baris log per panggilan. Kelompokkan berdasarkan tanda pengguna. Gunakan ID yang di-hash, bukan email.

Apakah saya perlu mencatat prompt dan respons secara lengkap?

Tidak secara default. Di situlah data pribadi berada. Catat jumlah token dan metadata untuk setiap panggilan, dan simpan teks lengkap hanya untuk panggilan sampel atau yang gagal, setelah diredaksi, dengan masa simpan yang singkat.

Mengapa biaya yang saya hitung berbeda dari invoice penyedia?

Biasanya karena token cache dihargai sebagai input baru, token penalaran tidak dimasukkan ke output, atau retry tidak dicatat. Catat setiap percobaan, termasuk yang gagal tetapi mengembalikan usage.

Bagaimana mendapatkan pemakaian token dari respons streaming?

Tetapkan include_usage di stream_options menjadi true. Chunk terakhir kemudian membawa blok usage dengan daftar choices yang kosong.

Tool redaksi PII apa yang sebaiknya dipakai untuk log LLM?

Mulailah dengan regex untuk data terstruktur seperti email, nomor telepon, dan nomor kartu, lalu tambahkan tool berbasis NER seperti Microsoft Presidio untuk nama dan alamat. README Presidio sendiri menyebut bahwa ia tidak bisa menjamin menemukan semuanya.

Baca sebagai MarkdownTanya ChatGPTTanya ClaudeTanya Perplexity