BroadRouter
Начать

Логирование LLM API: стоимость по пользователям и функциям без ПДн

Команда BroadNet Inference · 4 мин чтения · Опубликовано

Оберните каждый вызов LLM в одну функцию, которая записывает модель, функцию продукта, хэш ID пользователя, входные, кэшированные, рассуждающие и выходные токены, стоимость, задержку, статус и ID запроса у провайдера. Стоимость считайте по таблице цен, а не по счёту. По умолчанию логируйте метаданные; если текст промптов всё же нужен, маскируйте его до записи и храните недолго.

Панели провайдеров показывают, сколько вы потратили. Но они редко показывают, какая функция или какой клиент это потратил, и не объяснят, почему счёт подскочил во вторник. Ваш собственный лог использования — объяснит. В этой статье — схема лога, обёртка, которая его заполняет, расчёт стоимости вызова и способы не пускать в лог персональные данные (ПДн). Что делать с полученными цифрами, разобрано отдельно: в статьях о стоимости на пользователя и ценообразовании 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. Верхний 1% пользователей по стоимости. Часто это один зациклившийся процесс или бот. Второй ранний сигнал — падение cache_rate; калькулятор кэширования промптов показывает, сколько стоит каждый процентный пункт доли кэша.
  2. Стоимость успешного результата, а не вызова: соедините данные с собственными событиями успеха.
  3. Доля повторов. Строки со статусом 429 или 5xx показывают, сколько вы тратите на сбои; см. статью об обработке ошибок 429.

Как не пускать ПДн в логи LLM?

Самый безопасный лог вообще не содержит текста промптов. Если текст нужен для отладки или оценки, действуйте по шагам в таком порядке:

  1. Делайте выборку. Храните текст для небольшой доли вызовов и для сбоев, а не для всего подряд.
  2. Маскируйте до записи. Запускайте маскирование в том же процессе, который пишет лог. Если маскировать позже, сырой текст уже лежит на диске и в резервных копиях.
  3. Комбинируйте детекторы. Регулярные выражения — для структурированных данных, NER-инструмент — для имён и адресов.
  4. Храните отдельно. Кладите текст в отдельную таблицу или бакет со строгим доступом и коротким сроком хранения, связывая по request_id.
  5. Никогда не логируйте секреты. 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 нет поля для метаданных пользователя, так что распределение по пользователям живёт в вашей обёртке. Для раздельных бюджетов команд используйте раздельные ключи; метки и белые списки описаны в руководстве по ключам.

Вопросы и ответы

Как отслеживать стоимость LLM API по каждому пользователю?

Помечайте каждый вызов идентификатором пользователя, читайте блок usage из ответа, умножайте число токенов на таблицу цен и пишите одну строку лога на вызов. Группируйте по метке пользователя. Используйте хэш ID, а не email.

Нужно ли логировать промпты и ответы целиком?

По умолчанию — нет. Именно в них живут персональные данные. Для каждого вызова логируйте число токенов и метаданные, а полный текст храните только для выборки вызовов или неудачных вызовов, после маскирования и с коротким сроком хранения.

Почему моя расчётная стоимость не совпадает со счётом провайдера?

Обычно потому, что кэшированные токены посчитали по цене нового входа, токены рассуждений не включили в выход или повторы не попали в лог. Логируйте каждую попытку, включая неудачные, если они вернули usage.

Как получить расход токенов из потокового ответа?

Задайте stream_options include_usage равным true. Тогда последний фрагмент придёт с блоком usage и пустым списком choices.

Каким инструментом маскировать ПДн в логах LLM?

Начните с регулярных выражений для структурированных данных — email, телефонов, номеров карт — и добавьте инструмент на основе NER, например Microsoft Presidio, для имён и адресов. В README самого Presidio сказано, что он не гарантирует найти всё.

Открыть в MarkdownСпросить ChatGPTСпросить ClaudeСпросить Perplexity