Панели провайдеров показывают, сколько вы потратили. Но они редко показывают, какая функция или какой клиент это потратил, и не объяснят, почему счёт подскочил во вторник. Ваш собственный лог использования — объяснит. В этой статье — схема лога, обёртка, которая его заполняет, расчёт стоимости вызова и способы не пускать в лог персональные данные (ПДн). Что делать с полученными цифрами, разобрано отдельно: в статьях о стоимости на пользователя и ценообразовании SaaS и о бюджетах и защите от циклов.
Что логировать для каждого вызова LLM?
Одну строку на попытку, включая повторы:
| Поле | Пример | Зачем |
|---|---|---|
ts |
2026-11-14T09:12:03Z | Временные ряды, хронология инцидентов |
feature |
support_reply |
Стоимость по функциям |
user_hash |
hmac:4f1c… |
Стоимость по пользователям без хранения личности |
tenant |
acme |
Стоимость по клиентам в B2B-приложениях |
model |
broadnet/deepseek-v4.1-flash | Поиск цены, сравнение моделей |
prompt_tokens |
18 240 | Стоимость входа |
cached_tokens |
16 384 | Вход из кэша дешевле; следите за долей кэша |
reasoning_tokens |
612 | Скрытая стоимость выхода у моделей с рассуждениями |
completion_tokens |
1 104 | Стоимость выхода (включая рассуждения) |
cost_usd |
расчётное | Цифра, которую спрашивают финансисты |
latency_ms, ttft_ms |
4 210 / 690 | Регрессии производительности |
status |
200, 429, 503 | Доля ошибок и повторов |
request_id |
значение X-Request-ID |
Обращения в поддержку и споры по счетам |
prompt_version |
support-v14 |
Связывает изменения стоимости с изменениями промпта |
Ни текста промпта, ни текста ответа. Они появятся позже и только с маскированием.
Как посчитать стоимость одного вызова?
Прочитайте блок usage и посчитайте каждый тип токенов отдельно. BroadNet публикует машиночитаемые цены в pricing.json: для каждой модели — цены за 1 млн токенов входа, входа из кэша и выхода:
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
Кэшируйте файл цен и обновляйте его раз в день, а не загружайте при каждом вызове. Две частые ошибки: считать кэшированные токены по цене нового входа (завышает стоимость) и забывать, что токены рассуждений уже входят в completion_tokens (не прибавляйте их дважды).
Как выглядит обёртка для логирования?
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 даёт доступ к заголовкам, так что можно сохранить X-Request-ID. Для потоковых вызовов добавьте stream_options={"include_usage": True} и заполняйте строку из последнего фрагмента, как показано в статье о стриминге через SSE. Держите HASH_KEY в секрете и не меняйте его: один и тот же пользователь всегда даёт один и тот же хэш, но без ключа хэш не обратить.
Как распределить стоимость по пользователям и функциям?
Если строки выше лежат в любом 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;
Замените feature на user_hash или tenant, чтобы получить стоимость по клиентам. Быстро окупаются три следующих шага:
- Верхний 1% пользователей по стоимости. Часто это один зациклившийся процесс или бот. Второй ранний сигнал — падение
cache_rate; калькулятор кэширования промптов показывает, сколько стоит каждый процентный пункт доли кэша. - Стоимость успешного результата, а не вызова: соедините данные с собственными событиями успеха.
- Доля повторов. Строки со статусом 429 или 5xx показывают, сколько вы тратите на сбои; см. статью об обработке ошибок 429.
Как не пускать ПДн в логи LLM?
Самый безопасный лог вообще не содержит текста промптов. Если текст нужен для отладки или оценки, действуйте по шагам в таком порядке:
- Делайте выборку. Храните текст для небольшой доли вызовов и для сбоев, а не для всего подряд.
- Маскируйте до записи. Запускайте маскирование в том же процессе, который пишет лог. Если маскировать позже, сырой текст уже лежит на диске и в резервных копиях.
- Комбинируйте детекторы. Регулярные выражения — для структурированных данных, NER-инструмент — для имён и адресов.
- Храните отдельно. Кладите текст в отдельную таблицу или бакет со строгим доступом и коротким сроком хранения, связывая по
request_id. - Никогда не логируйте секреты. OWASP Logging Cheat Sheet относит токены доступа, пароли и ключи шифрования к данным, которые нельзя писать в логи; API-ключ — из того же списка.
Минимальный уровень на регулярных выражениях:
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
Он ловит очевидные случаи и пропускает имена, адреса и всё необычное. Microsoft Presidio добавляет для них распознавание сущностей, а в его README прямо сказано, что нет гарантии найти всю чувствительную информацию. Закладывайте пропуски в план: короткий срок хранения и строгий доступ ограничивают ущерб, когда что-то проскочит.
Как сюда вписывается BroadNet Inference
BroadNet Inference возвращает блок usage с кэшированными токенами и токенами рассуждений, когда модель их сообщает, X-Request-ID в каждом ответе и публичный файл цен, который можно загрузить для расчёта стоимости. На её стороне промпты и ответы обрабатываются для запроса и не хранятся; сохраняются только записи без содержимого, такие как время, число токенов и стоимость (как работает нулевое хранение данных). Поэтому ваши собственные логи — единственная копия текста промптов, и именно правила маскирования выше определяют ваше реальное хранение. В чат-запросах BroadNet нет поля для метаданных пользователя, так что распределение по пользователям живёт в вашей обёртке. Для раздельных бюджетов команд используйте раздельные ключи; метки и белые списки описаны в руководстве по ключам.
