Let a person belong to many places, or to none
A person was in exactly one project, chosen at approval, and could not use the gateway before that. People belong to several teams and to none, so: - memberships: a person is a member of any number of organizations, teams and projects, or of none; a member of a team or organization may use every project in it. users join/leave, and the people page adds and takes out from either side. Approval no longer needs a project. - personal keys: a key may have an owner and no project. /profile asks what a new key spends against; keys create --for does the same. auth.personal sets default limits for personal use or turns it off. - limits for people: --scope user holds a person across every key, project and the chat page; --per-member on an org, team or project gives each member their own share there. Resolution folds the tree, each per-member limit for the key's owner, and the owner's own, each in its own pool; the quotas page shows and sets both. - the chat page asks what to spend against and checks it per message. - usage records who spent it, so a person's budget survives a restart, personal use and chat included; restore no longer drops rows with no project. Leaving a project revokes the keys made there unless another membership still reaches it. A personal key keeps no threads or notes, which are per project, and is refused rather than dropped into the anonymous pool. Migration 0010 turns each person's project into a membership, adds usage.user_id and backfills it, and makes api_keys.project_id nullable. SQLite cannot drop NOT NULL, so the table is rebuilt; that needs foreign keys off, which only works outside a transaction, so migrations marked for it run on one connection with foreign_key_check before commit. Tested on a populated SQLite store with claims, and on a copy of the cluster's PostgreSQL store: 5 people became members, 17 keys and 3 claims intact, 145 of 577 usage rows and all 69 chat rows attributed. The PostgreSQL store tests, including new membership cases, pass on 16. users move is gone; join and leave replace it. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
429c05a319
commit
098886e0e4
46 files changed
+2372
-468
No files matched your search
+27
-72
@@ -40,6 +40,9 @@ type DB struct {
|
||||
mu sync.RWMutex
|
||||
defaultRPM *int
|
||||
defaultTPM *int
|
||||
// personal is what a person's own use is held to when nobody wrote a
|
||||
// limit for them; see SetPersonalDefaults.
|
||||
personal *Limits
|
||||
}
|
||||
|
||||
// OpenSQLite opens (creating if needed) a database and brings it up to date.
|
||||
@@ -157,7 +160,7 @@ func (s *DB) Projects(ctx context.Context, teamID string) ([]Project, error) {
|
||||
// --- keys ---
|
||||
|
||||
const keyColumns = `id, key_hash, key_prefix, name, project_id, band, routing_profile,
|
||||
created_at, expires_at, revoked_at, last_used_at`
|
||||
created_at, expires_at, revoked_at, last_used_at, user_id`
|
||||
|
||||
// CreateKey stores a key. Only its hash is written; the key itself is the
|
||||
// caller's to show once and then forget.
|
||||
@@ -166,10 +169,11 @@ func (s *DB) CreateKey(ctx context.Context, k Key) error {
|
||||
return errors.New("store: a key needs a hash")
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx,
|
||||
`INSERT INTO api_keys (`+keyColumns+`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
k.ID, k.Hash, k.Prefix, k.Name, k.ProjectID,
|
||||
`INSERT INTO api_keys (`+keyColumns+`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
k.ID, k.Hash, k.Prefix, k.Name, nullString(k.ProjectID),
|
||||
nullString(k.Band), nullString(k.RoutingProfile),
|
||||
millis(k.CreatedAt), nullMillis(k.ExpiresAt), nullMillis(k.RevokedAt), nullMillis(k.LastUsedAt))
|
||||
millis(k.CreatedAt), nullMillis(k.ExpiresAt), nullMillis(k.RevokedAt), nullMillis(k.LastUsedAt),
|
||||
nullString(k.UserID))
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -295,56 +299,6 @@ func (s *DB) LimitsFor(ctx context.Context, scope Scope, id string) (Limits, err
|
||||
return l, nil
|
||||
}
|
||||
|
||||
// Resolve walks a key's chain and returns the most restrictive of each limit.
|
||||
//
|
||||
// One query rather than four lookups: the chain is a fixed three-level join, and
|
||||
// this is called on a cache miss during authentication.
|
||||
func (s *DB) Resolve(ctx context.Context, keyID string) (Effective, error) {
|
||||
var e Effective
|
||||
row := s.db.QueryRowContext(ctx,
|
||||
`SELECT k.id, k.band, k.routing_profile, p.id, t.id, o.id
|
||||
FROM api_keys k
|
||||
JOIN projects p ON p.id = k.project_id
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
WHERE k.id = ?`, keyID)
|
||||
|
||||
var band, profile sql.NullString
|
||||
if err := row.Scan(&e.KeyID, &band, &profile, &e.ProjectID, &e.TeamID, &e.OrgID); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return Effective{}, ErrNotFound
|
||||
}
|
||||
return Effective{}, err
|
||||
}
|
||||
e.Band, e.RoutingProfile = band.String, profile.String
|
||||
|
||||
// Widest first, so a narrower scope can only tighten what it inherits.
|
||||
chain := []struct {
|
||||
scope Scope
|
||||
id string
|
||||
}{
|
||||
{ScopeOrg, e.OrgID},
|
||||
{ScopeTeam, e.TeamID},
|
||||
{ScopeProject, e.ProjectID},
|
||||
{ScopeKey, e.KeyID},
|
||||
}
|
||||
for _, step := range chain {
|
||||
l, err := s.LimitsFor(ctx, step.scope, step.id)
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return Effective{}, err
|
||||
}
|
||||
e.tighten(l)
|
||||
// Kept whole as well as folded in. Enforcement walks this; the folded
|
||||
// values are for showing somebody their ceiling.
|
||||
e.Chain = append(e.Chain, l)
|
||||
}
|
||||
s.applyDefaults(&e)
|
||||
return e, nil
|
||||
}
|
||||
|
||||
// SetDefaultLimits sets what applies to a key no scope gives a limit to.
|
||||
//
|
||||
// A default is a fallback, not a ceiling, so it is applied after the chain and
|
||||
@@ -390,17 +344,18 @@ func (s *DB) applyDefaults(e *Effective) {
|
||||
}
|
||||
}
|
||||
|
||||
// SpendSinceByScope totals cost per key, with the key's place in the tree.
|
||||
// SpendSinceByScope totals cost per key and person, with the key's place in
|
||||
// the tree. Personal keys and the chat page's requests have no project and are
|
||||
// kept: dropping them is what would reset a person's budget on every restart.
|
||||
func (s *DB) SpendSinceByScope(ctx context.Context, since time.Time) ([]ScopeSpend, error) {
|
||||
rows, err := s.db.QueryContext(ctx,
|
||||
`SELECT k.id, p.id, t.id, o.id, SUM(u.cost_micros)
|
||||
`SELECT u.key_id, u.user_id, COALESCE(p.id, ''), COALESCE(t.id, ''), COALESCE(t.org_id, ''),
|
||||
SUM(u.cost_micros)
|
||||
FROM usage u
|
||||
JOIN api_keys k ON k.id = u.key_id
|
||||
JOIN projects p ON p.id = k.project_id
|
||||
JOIN teams t ON t.id = p.team_id
|
||||
JOIN organizations o ON o.id = t.org_id
|
||||
LEFT JOIN projects p ON p.id = NULLIF(u.project_id, '')
|
||||
LEFT JOIN teams t ON t.id = p.team_id
|
||||
WHERE u.ts >= ?
|
||||
GROUP BY k.id, p.id, t.id, o.id`, millis(since))
|
||||
GROUP BY u.key_id, u.user_id, p.id, t.id, t.org_id`, millis(since))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -410,7 +365,7 @@ func (s *DB) SpendSinceByScope(ctx context.Context, since time.Time) ([]ScopeSpe
|
||||
for rows.Next() {
|
||||
var sp ScopeSpend
|
||||
var total sql.NullInt64
|
||||
if err := rows.Scan(&sp.KeyID, &sp.ProjectID, &sp.TeamID, &sp.OrgID, &total); err != nil {
|
||||
if err := rows.Scan(&sp.KeyID, &sp.UserID, &sp.ProjectID, &sp.TeamID, &sp.OrgID, &total); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sp.Micros = total.Int64
|
||||
@@ -469,8 +424,8 @@ func (s *DB) WriteUsage(ctx context.Context, records []Usage) error {
|
||||
return s.inTx(ctx, func(tx conn) error {
|
||||
stmt, err := tx.PrepareContext(ctx,
|
||||
`INSERT INTO usage (ts, key_id, project_id, model, served_model,
|
||||
prompt_tokens, completion_tokens, cost_micros, status, latency_ms)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
|
||||
prompt_tokens, completion_tokens, cost_micros, status, latency_ms, user_id)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -478,7 +433,7 @@ func (s *DB) WriteUsage(ctx context.Context, records []Usage) error {
|
||||
for _, r := range records {
|
||||
if _, err := stmt.ExecContext(ctx, millis(r.At), r.KeyID, r.ProjectID,
|
||||
r.Model, r.ServedModel, r.PromptTokens, r.CompletionTokens,
|
||||
r.CostMicros, r.Status, r.LatencyMs); err != nil {
|
||||
r.CostMicros, r.Status, r.LatencyMs, r.UserID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -539,13 +494,14 @@ type scanner interface{ Scan(...any) error }
|
||||
|
||||
func scanKey(sc scanner) (Key, error) {
|
||||
var k Key
|
||||
var band, profile sql.NullString
|
||||
var band, profile, project, user sql.NullString
|
||||
var expires, revoked, lastUsed sql.NullInt64
|
||||
var created int64
|
||||
if err := sc.Scan(&k.ID, &k.Hash, &k.Prefix, &k.Name, &k.ProjectID,
|
||||
&band, &profile, &created, &expires, &revoked, &lastUsed); err != nil {
|
||||
if err := sc.Scan(&k.ID, &k.Hash, &k.Prefix, &k.Name, &project,
|
||||
&band, &profile, &created, &expires, &revoked, &lastUsed, &user); err != nil {
|
||||
return Key{}, err
|
||||
}
|
||||
k.ProjectID, k.UserID = project.String, user.String
|
||||
k.Band, k.RoutingProfile = band.String, profile.String
|
||||
k.CreatedAt = fromMillis(created)
|
||||
k.ExpiresAt = fromNullMillis(expires)
|
||||
@@ -770,22 +726,21 @@ func (u UserUsage) Tokens() int64 { return u.Prompt + u.Completion }
|
||||
// existed — are grouped under an empty user, which is honest rather than tidy.
|
||||
func (s *DB) UsageByUser(ctx context.Context, since time.Time) ([]UserUsage, error) {
|
||||
rows, err := s.db.QueryContext(ctx, `
|
||||
SELECT COALESCE(k.user_id, ''), COALESCE(us.email, ''), COALESCE(us.name, ''),
|
||||
SELECT u.user_id, COALESCE(us.email, ''), COALESCE(us.name, ''),
|
||||
COUNT(DISTINCT u.key_id),
|
||||
COUNT(*), SUM(u.prompt_tokens), SUM(u.completion_tokens),
|
||||
SUM(u.cost_micros),
|
||||
SUM(CASE WHEN u.status >= 400 THEN 1 ELSE 0 END),
|
||||
MAX(u.ts)
|
||||
FROM usage u
|
||||
LEFT JOIN api_keys k ON k.id = u.key_id
|
||||
LEFT JOIN users us ON us.id = k.user_id
|
||||
LEFT JOIN users us ON us.id = NULLIF(u.user_id, '')
|
||||
WHERE u.ts >= ?
|
||||
-- Every selected column that is not an aggregate has to be grouped.
|
||||
-- SQLite picks an arbitrary row for the rest and carries on; PostgreSQL
|
||||
-- refuses, so this query worked in tests and returned nothing but an
|
||||
-- error on the cluster. The email and name are functionally dependent
|
||||
-- on the user id, so grouping by them changes no result.
|
||||
GROUP BY COALESCE(k.user_id, ''), COALESCE(us.email, ''), COALESCE(us.name, '')
|
||||
GROUP BY u.user_id, COALESCE(us.email, ''), COALESCE(us.name, '')
|
||||
ORDER BY SUM(u.cost_micros) DESC, COUNT(*) DESC`, millis(since))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
||||
Reference in new issue
Block a user