Files
ai/controllers/trace_export.go
zeekay 1569f5288b usage: one prompt on every path, and cache writes billed as writes
prompt_tokens meant two things. The family and relay paths recorded the
part of the prompt read fresh, the table path and the providers the
whole prompt, so a cached enso-auto row read cache_read > prompt. No
path recorded a cache write: Anthropic's cache_creation_input_tokens
was folded into the fresh read and billed at the input rate, though a
write is priced above it, and OpenRouter's cache_write_tokens was not
read at all. cache_write_tokens was 0 on every row.

A record's prompt is now every input token, with the cache reads and
writes parts of it, whatever shape the upstream reported: OpenAI's
cached_tokens inside prompt_tokens, OpenRouter's cache_write_tokens
beside them, Anthropic's two counts beside input_tokens. Pricing bills
the input rate on the part read fresh and each cache part at its own
rate: a family SKU's cache_read and cache_write (a resold model's
input_cache_read and input_cache_write plus the vendor's fee), else the
input rate. The Anthropic provider and the OpenAI adapter over
Anthropic now read both cache counts, and the providers' settles pass
them.
2026-10-09 03:59:41 -07:00

100 lines
4.2 KiB
Go

// Copyright 2023-2026 Hanzo AI Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package controllers
import (
"context"
"time"
"github.com/google/uuid"
)
// ServedUsage is the trace input for a request that was BILLED ELSEWHERE — a
// co-resident subsystem that debits commerce itself (zen's Meter in the unified
// cloud binary) but must still land in the ONE usage warehouse + o11y span
// plane this package owns. Money is exact nano-USD when the biller knows it
// (zen computes both retail and upstream COGS per served tier); 0 falls back to
// the rate-table recompute.
type ServedUsage struct {
Owner string // billing org (who paid) — the warehouse partition key
User string // actor, "owner/name" when known
Model string // the SKU the caller requested (zen5, …)
Provider string // serving family label ("zen")
RequestID string
Status string // "success" | "error" | "failover" (an arm that failed)
ErrorMsg string
PromptTokens int // the WHOLE prompt; CachedTokens is a part of it
CompletionTokens int
BilledNano int64 // exact retail billed, nano-USD; 0 = recompute from rates
CostNano int64 // exact upstream COGS, nano-USD; 0 = recompute from rates
StartTime time.Time
Served string // the arm that generated the answer (gen_ai.response.model)
Vendor string // the provider that ran that arm (gen_ai.provider.name)
Failover string // the arms that failed before it, with why
CachedTokens int // of PromptTokens: served from the upstream's prompt cache
WrittenTokens int // of PromptTokens: written to the upstream's prompt cache
ReasoningTokens int // of CompletionTokens: spent reasoning
First time.Duration // time from StartTime to the first token of the answer
}
// TraceServedUsage emits the warehouse row (hanzo.cloud_usage) + gen_ai span for
// a self-billed request — recordTrace WITHOUT recordUsage, so the commerce debit
// the caller already made is never doubled. One warehouse writer, two billers,
// zero double-billing. Safe under a nil/zero input: an empty Owner still writes
// an (unattributed) row so traffic is never silently invisible; StartTime zero
// anchors at now.
func TraceServedUsage(ctx context.Context, in ServedUsage) {
if in.StartTime.IsZero() {
in.StartTime = time.Now().UTC()
}
if in.RequestID == "" {
in.RequestID = uuid.NewString()
}
recordTrace(ctx, servedRecord(in), in.StartTime)
}
// servedRecord projects a ServedUsage onto the usage record recordTrace writes.
func servedRecord(in ServedUsage) *usageRecord {
// The record counts the prompt as every path does: PromptTokens is the whole
// prompt, and CacheReadTokens and CacheWriteTokens the parts of it read from and
// written to the upstream's cache.
cached := min(max(in.CachedTokens, 0), max(in.PromptTokens, 0))
written := min(max(in.WrittenTokens, 0), max(in.PromptTokens, 0)-cached)
return &usageRecord{
Owner: in.Owner,
Organization: in.Owner,
User: in.User,
Model: in.Model,
Provider: in.Provider,
PromptTokens: max(in.PromptTokens, 0),
CacheReadTokens: cached,
CacheWriteTokens: written,
CompletionTokens: in.CompletionTokens,
TotalTokens: in.PromptTokens + in.CompletionTokens,
Served: in.Served,
Vendor: in.Vendor,
Failover: in.Failover,
ReasoningTokens: in.ReasoningTokens,
First: in.First,
Currency: "USD",
Status: in.Status,
ErrorMsg: in.ErrorMsg,
RequestID: in.RequestID,
BilledNanoExact: &in.BilledNano,
CostNanoExact: &in.CostNano,
}
}