- Every question asked of Claude is recorded: when, the kind of list, the model, the tokens read and written (also for an answer that was no name but was billed) and how it ended: a name made, a name taken from the kept ones, or a failure and why. Nothing of the facts that were sent is recorded. Records older than a year are removed (migration 0022). - GET /providers/anthropic/usage (admin) gives the totals of the last days (1 to 365, 30 by default), a row for each day with calls and an estimate of the cost in dollars, worked out from the tokens and the price of the model. It says it is an estimate and flags calls to a model whose price is not known. - A Costs section in the admin area shows the last 7, 30 or 90 days.
115 lines
4 KiB
Go
115 lines
4 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/uptrace/bun"
|
|
|
|
"codeberg.org/squidd/sonda/internal/naming"
|
|
)
|
|
|
|
// NamingRepo keeps the names Claude gave, and counts the genres of songs for the facts about a list. It implements
|
|
// naming.Store.
|
|
type NamingRepo struct{ db *bun.DB }
|
|
|
|
// NewNamingRepo builds a NamingRepo.
|
|
func NewNamingRepo(db *bun.DB) *NamingRepo { return &NamingRepo{db: db} }
|
|
|
|
// Get returns a kept name, found=false when there is none.
|
|
func (r *NamingRepo) Get(ctx context.Context, key string) (naming.Suggestion, bool, error) {
|
|
var s naming.Suggestion
|
|
err := r.db.QueryRowContext(ctx, "SELECT name, description FROM generated_names WHERE key = ?", key).Scan(&s.Name, &s.Description)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return naming.Suggestion{}, false, nil
|
|
}
|
|
if err != nil {
|
|
return naming.Suggestion{}, false, fmt.Errorf("read a kept name: %w", err)
|
|
}
|
|
s.Source = naming.SourceClaude // only what Claude gave is kept
|
|
return s, true, nil
|
|
}
|
|
|
|
// Put keeps a name. When the key is there already, from a request that asked at the same time, the first stays.
|
|
func (r *NamingRepo) Put(ctx context.Context, key string, s naming.Suggestion, now time.Time) error {
|
|
_, err := r.db.ExecContext(ctx,
|
|
"INSERT INTO generated_names (key, name, description, created_at) VALUES (?, ?, ?, ?) ON CONFLICT (key) DO NOTHING",
|
|
key, s.Name, s.Description, now.Unix())
|
|
if err != nil {
|
|
return fmt.Errorf("keep a name: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GenreCounts returns how many of the songs have each genre, as the files spell it.
|
|
func (r *NamingRepo) GenreCounts(ctx context.Context, trackIDs []int64) (map[string]int, error) {
|
|
out := map[string]int{}
|
|
if len(trackIDs) == 0 {
|
|
return out, nil
|
|
}
|
|
rows, err := r.db.QueryContext(ctx, "SELECT genre, COUNT(DISTINCT track_id) FROM track_genres WHERE track_id IN (?) GROUP BY genre", bun.In(trackIDs))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("count genres: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var (
|
|
g string
|
|
n int
|
|
)
|
|
if err := rows.Scan(&g, &n); err != nil {
|
|
return nil, err
|
|
}
|
|
out[g] = n
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// keepUsage is how long the account of the calls is kept.
|
|
const keepUsage = 365 * 24 * time.Hour
|
|
|
|
// Record keeps the account of one call to Claude, and forgets the ones that are older than a year.
|
|
func (r *NamingRepo) Record(ctx context.Context, c naming.Call) error {
|
|
_, err := r.db.ExecContext(ctx,
|
|
`INSERT INTO claude_usage (at, kind, model, outcome, reason, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
c.At.Unix(), c.Kind, c.Model, c.Outcome, c.Reason, c.Usage.Input, c.Usage.Output, c.Usage.CacheRead, c.Usage.CacheWrite)
|
|
if err != nil {
|
|
return fmt.Errorf("record a call: %w", err)
|
|
}
|
|
if _, err := r.db.ExecContext(ctx, "DELETE FROM claude_usage WHERE at < ?", c.At.Add(-keepUsage).Unix()); err != nil {
|
|
return fmt.Errorf("forget old calls: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Since returns what happened from a moment on, a row for each day (UTC) and model, the newest day first.
|
|
func (r *NamingRepo) Since(ctx context.Context, since time.Time) ([]naming.DayRow, error) {
|
|
rows, err := r.db.QueryContext(ctx,
|
|
`SELECT at / 86400, model,
|
|
SUM(CASE WHEN outcome = 'made' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN outcome = 'kept' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN outcome = 'failed' THEN 1 ELSE 0 END),
|
|
SUM(input_tokens), SUM(output_tokens), SUM(cache_read_tokens), SUM(cache_write_tokens)
|
|
FROM claude_usage WHERE at >= ? GROUP BY 1, 2 ORDER BY 1 DESC, 2`, since.Unix())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read what Claude cost: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
out := []naming.DayRow{}
|
|
for rows.Next() {
|
|
var (
|
|
d naming.DayRow
|
|
day int64
|
|
)
|
|
if err := rows.Scan(&day, &d.Model, &d.Made, &d.Kept, &d.Failed, &d.Usage.Input, &d.Usage.Output, &d.Usage.CacheRead, &d.Usage.CacheWrite); err != nil {
|
|
return nil, err
|
|
}
|
|
d.Day = time.Unix(day*86400, 0).UTC()
|
|
out = append(out, d)
|
|
}
|
|
return out, rows.Err()
|
|
}
|