ceos/opencode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(stats): add unique user charts

Browse source
This commit is contained in:
Adam 2026-06-20 14:54:15 -05:00
commit 24c70ec974
No known key found for this signature in database
GPG key ID: 9CB48779AF150E75
13 changed files with 327 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

3
packages/stats/core/migrations/20260620000000_unique_users/migration.sql Normal file
View file

@ -0,0 +1,3 @@
ALTER TABLE `geo_stat` ADD `unique_users` bigint NOT NULL DEFAULT 0;--> statement-breakpoint
ALTER TABLE `model_stat` ADD `unique_users` bigint NOT NULL DEFAULT 0;--> statement-breakpoint
ALTER TABLE `provider_stat` ADD `unique_users` bigint NOT NULL DEFAULT 0;

1
packages/stats/core/src/database/schema.ts
View file

@ -123,6 +123,7 @@ function metricColumns() {
return {
sessions: bigint({ mode: "number" }).notNull().default(0),
requests: bigint({ mode: "number" }).notNull().default(0),
unique_users: bigint({ mode: "number" }).notNull().default(0),
input_tokens: bigint({ mode: "number" }).notNull().default(0),
output_tokens: bigint({ mode: "number" }).notNull().default(0),
reasoning_tokens: bigint({ mode: "number" }).notNull().default(0),

1
packages/stats/core/src/domain/geo.ts
View file

@ -145,6 +145,7 @@ export class GeoStatRepo extends Context.Service<GeoStatRepo, GeoStatRepo.Servic
continent: inserted("continent"),
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),

45
packages/stats/core/src/domain/home.ts
View file

@ -21,7 +21,7 @@ export type TokenCostEntry = { model: string; total: number; input: number; outp
export type CacheRatioEntry = { model: string; ratio: number; cached: number; uncached: number; total: number }
export type SessionCostEntry = { model: string; cost: number; tokens: number }
export type CountryEntry = { country: string; continent: string; tokens: number; share: number; rank: number }
export type ModelUsagePoint = { date: string; tokens: number; sessions: number; cost: number }
export type ModelUsagePoint = { date: string; tokens: number; users: number; sessions: number; cost: number }
export type ModelMixEntry = { label: string; tokens: number; share: number }
export type ModelPeerEntry = {
model: string
@ -82,6 +82,7 @@ export type StatsLabData = {
export type StatsHomeData = {
updatedAt: string | null
usage: Record<UsageProduct, Record<UsageRange, UsagePoint[]>>
users: Record<UsageProduct, Record<UsageRange, UsagePoint[]>>
leaderboard: Record<UsageProduct, Record<UsageRange, LeaderboardEntry[]>>
market: Record<UsageRange, MarketDay[]>
tokenCost: Record<TokenProduct, TokenCostEntry[]>
@ -118,6 +119,7 @@ type ModelAggregate = {
model: string
provider: string
sessions: number
uniqueUsers: number
inputTokens: number
outputTokens: number
reasoningTokens: number
@ -200,6 +202,18 @@ function buildStatsHomeData(
),
),
),
users: createUsageProductRecord((product) =>
createRangeRecord((range) =>
buildUsagePoints(
normalized,
product,
range,
getWindow(range, earliest, latest),
getWindow("1W", earliest, latest),
"users",
),
),
),
leaderboard: createUsageProductRecord((product) =>
createRangeRecord((range) => buildLeaderboard(normalized, product, getWindow("1W", earliest, latest))),
),
@ -340,6 +354,7 @@ function emptyStatsHomeData(): StatsHomeData {
return {
updatedAt: null,
usage: createUsageProductRecord(() => createRangeRecord(() => [])),
users: createUsageProductRecord(() => createRangeRecord(() => [])),
leaderboard: createUsageProductRecord(() => createRangeRecord(() => [])),
market: createRangeRecord(() => []),
tokenCost: createTokenProductRecord(() => []),
@ -355,28 +370,39 @@ function buildUsagePoints(
range: UsageRange,
window: DateWindow,
rankWindow: DateWindow,
metric: "tokens" | "users" = "tokens",
) {
const modelOrder = aggregateByModelName(rowsForProduct(rows, product, rankWindow.start, rankWindow.end))
.toSorted((a, b) => b.totalTokens - a.totalTokens)
.toSorted((a, b) => modelUsageValue(b, metric) - modelUsageValue(a, metric))
.slice(0, TOP_MODEL_SEGMENT_LIMIT)
.map((item) => item.model)
return createBuckets(window, range).map((bucket) => {
const bucketRows = aggregateByModelName(rowsForProduct(rows, product, bucket.start, bucket.end))
const byModel = new Map(bucketRows.map((item) => [item.model, item.totalTokens]))
const segmentTokens = modelOrder.map((model) => ({ model, tokens: byModel.get(model) ?? 0 }))
const knownTokens = segmentTokens.reduce((sum, item) => sum + item.tokens, 0)
const totalTokens = bucketRows.reduce((sum, item) => sum + item.totalTokens, 0)
const byModel = new Map(bucketRows.map((item) => [item.model, modelUsageValue(item, metric)]))
const segments = modelOrder.map((model) => ({ model, value: byModel.get(model) ?? 0 }))
const knownValue = segments.reduce((sum, item) => sum + item.value, 0)
const totalValue = bucketRows.reduce((sum, item) => sum + modelUsageValue(item, metric), 0)
return {
date: bucket.label,
segments: [
...segmentTokens.map((item) => ({ model: item.model, value: round(item.tokens / 1_000_000_000_000, 4) })),
{ model: "Other", value: round(Math.max(totalTokens - knownTokens, 0) / 1_000_000_000_000, 4) },
...segments.map((item) => ({ model: item.model, value: usagePointValue(item.value, metric) })),
{ model: "Other", value: usagePointValue(Math.max(totalValue - knownValue, 0), metric) },
],
}
})
}
function modelUsageValue(item: ModelAggregate, metric: "tokens" | "users") {
if (metric === "users") return item.uniqueUsers
return item.totalTokens
}
function usagePointValue(value: number, metric: "tokens" | "users") {
if (metric === "users") return value
return round(value / 1_000_000_000_000, 4)
}
function buildLeaderboard(rows: StatMetricRow[], product: UsageProduct, rankWindow: DateWindow) {
const previous = new Map(
aggregateByModelName(rowsForProduct(rows, product, rankWindow.previousStart, rankWindow.previousEnd)).map(
@ -502,6 +528,7 @@ function buildModelUsage(rows: StatMetricRow[], window: DateWindow, range: Usage
return {
date: bucket.label,
tokens: aggregate.totalTokens,
users: aggregate.uniqueUsers,
sessions: aggregate.sessions,
cost: round(microcentsToDollars(aggregate.totalCostMicrocents), 2),
}
@ -601,6 +628,7 @@ function combineRowsForModel(model: string, rows: StatMetricRow[]): ModelAggrega
model,
provider: "unknown",
sessions: 0,
uniqueUsers: 0,
inputTokens: 0,
outputTokens: 0,
reasoningTokens: 0,
@ -617,6 +645,7 @@ function combineModelAggregate(current: ModelAggregate | undefined, row: StatMet
model: row.model,
provider: row.provider,
sessions: (current?.sessions ?? 0) + row.sessions,
uniqueUsers: (current?.uniqueUsers ?? 0) + row.uniqueUsers,
inputTokens: (current?.inputTokens ?? 0) + row.inputTokens,
outputTokens: (current?.outputTokens ?? 0) + row.outputTokens,
reasoningTokens: (current?.reasoningTokens ?? 0) + row.reasoningTokens,

5
packages/stats/core/src/domain/inference.ts
View file

@ -40,6 +40,7 @@ export function buildStatsQuery(periodStart: Date, periodEnd: Date, dimension: S
const aggregateColumns = `
COUNT(DISTINCT session) AS sessions,
COUNT(*) AS requests,
COUNT(DISTINCT user_key) AS unique_users,
COALESCE(SUM(tokens_input), 0) AS input_tokens,
COALESCE(SUM(tokens_output), 0) AS output_tokens,
COALESCE(SUM(tokens_reasoning), 0) AS reasoning_tokens,
@ -70,6 +71,8 @@ WITH normalized AS (
UPPER(COALESCE(NULLIF(cf_country, ''), 'ZZ')) AS country,
COALESCE(NULLIF(cf_continent, ''), '') AS continent,
session,
COALESCE(NULLIF(workspace, ''), '') AS workspace,
COALESCE(NULLIF(api_key, ''), '') AS api_key,
status,
duration AS duration_ms,
time_to_first_byte AS ttfb_ms,
@ -108,6 +111,7 @@ WITH normalized AS (
country,
continent,
session,
COALESCE(NULLIF(workspace, ''), NULLIF(api_key, '')) AS user_key,
status,
duration_ms,
ttfb_ms,
@ -197,6 +201,7 @@ function toStatBaseAggregate(data: AthenaData): StatBaseAggregate[] {
tier: normalizeTier(data.tier || "unknown"),
sessions: integer(data, "sessions"),
requests: integer(data, "requests"),
unique_users: integer(data, "unique_users"),
input_tokens: integer(data, "input_tokens"),
output_tokens: integer(data, "output_tokens"),
reasoning_tokens: integer(data, "reasoning_tokens"),

3
packages/stats/core/src/domain/model.ts
View file

@ -27,6 +27,7 @@ export type ModelStatMetric = {
provider: string
model: string
sessions: number
uniqueUsers: number
inputTokens: number
outputTokens: number
reasoningTokens: number
@ -64,6 +65,7 @@ export class ModelStatRepo extends Context.Service<ModelStatRepo, ModelStatRepo.
provider: modelStat.provider,
model: modelStat.model,
sessions: modelStat.sessions,
uniqueUsers: modelStat.unique_users,
inputTokens: modelStat.input_tokens,
outputTokens: modelStat.output_tokens,
reasoningTokens: modelStat.reasoning_tokens,
@ -101,6 +103,7 @@ export class ModelStatRepo extends Context.Service<ModelStatRepo, ModelStatRepo.
provider_model: inserted("provider_model"),
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),

1
packages/stats/core/src/domain/provider.ts
View file

@ -115,6 +115,7 @@ export class ProviderStatRepo extends Context.Service<ProviderStatRepo, Provider
set: {
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),

4
packages/stats/core/src/domain/stat.ts
View file

@ -12,6 +12,7 @@ export type StatBaseAggregate = {
tier: string
sessions: number
requests: number
unique_users: number
input_tokens: number
output_tokens: number
reasoning_tokens: number
@ -41,6 +42,7 @@ export type StatBaseRow = {
source?: string
sessions?: number
requests?: number
unique_users?: number
input_tokens?: number
output_tokens?: number
reasoning_tokens?: number
@ -71,6 +73,7 @@ export function toStatBaseRow(data: StatBaseAggregate) {
source: "all",
sessions: data.sessions,
requests: data.requests,
unique_users: data.unique_users,
input_tokens: data.input_tokens,
output_tokens: data.output_tokens,
reasoning_tokens: data.reasoning_tokens,
@ -122,6 +125,7 @@ export function combineRows<T extends StatBaseRow>(left: T, right: T): T {
...left,
sessions: (left.sessions ?? 0) + (right.sessions ?? 0),
requests: (left.requests ?? 0) + (right.requests ?? 0),
unique_users: (left.unique_users ?? 0) + (right.unique_users ?? 0),
input_tokens: (left.input_tokens ?? 0) + (right.input_tokens ?? 0),
output_tokens: (left.output_tokens ?? 0) + (right.output_tokens ?? 0),
reasoning_tokens: (left.reasoning_tokens ?? 0) + (right.reasoning_tokens ?? 0),

17
packages/stats/core/src/honeycomb-backfill.ts
View file

@ -242,6 +242,7 @@ function metricQuery(breakdowns: string[], limit: number, filters: ReturnType<ty
calculations: [
{ op: "COUNT_DISTINCT", column: "session" },
{ op: "COUNT" },
{ op: "COUNT_DISTINCT", column: "workspace" },
{ op: "SUM", column: "tokens.input" },
{ op: "SUM", column: "tokens.output" },
{ op: "SUM", column: "tokens.reasoning" },
@ -374,9 +375,15 @@ function classifyRows(file: string, rows: RawRow[]): ImportKey {
}
function hasMetricHeaders(headers: Set<string>) {
return ["sumtokens", "sumtokensinput", "inputtokens", "totaltokens", "avgduration", "countdistinctsession"].some(
(header) => headers.has(header),
)
return [
"sumtokens",
"sumtokensinput",
"inputtokens",
"totaltokens",
"avgduration",
"countdistinctsession",
"countdistinctworkspace",
].some((header) => headers.has(header))
}
function hasHeader(headers: Set<string>, names: string[]) {
@ -447,6 +454,7 @@ function baseAggregate(row: RawRow, grain: Grain, opts: ImportOptions): StatBase
tier: tier(row),
sessions: integer(row, "sessions", ["COUNT_DISTINCT(session)"]),
requests: integer(row, "requests", ["COUNT", "COUNT()"]),
unique_users: integer(row, "unique_users", ["COUNT_DISTINCT(workspace)", "COUNT_DISTINCT(api_key)"]),
input_tokens: integer(row, "input_tokens", ["SUM(tokens.input)", "SUM(tokens_input)"]),
output_tokens: integer(row, "output_tokens", ["SUM(tokens.output)", "SUM(tokens_output)"]),
reasoning_tokens: integer(row, "reasoning_tokens", ["SUM(tokens.reasoning)", "SUM(tokens_reasoning)"]),
@ -808,6 +816,7 @@ async function upsertModelRows(db: ReturnType<typeof drizzle>, rows: ModelStatRo
provider_model: inserted("provider_model"),
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),
@ -845,6 +854,7 @@ async function upsertProviderRows(db: ReturnType<typeof drizzle>, rows: Provider
set: {
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),
@ -887,6 +897,7 @@ async function upsertGeoRows(db: ReturnType<typeof drizzle>, rows: GeoStatRow[],
continent: inserted("continent"),
sessions: inserted("sessions"),
requests: inserted("requests"),
unique_users: inserted("unique_users"),
input_tokens: inserted("input_tokens"),
output_tokens: inserted("output_tokens"),
reasoning_tokens: inserted("reasoning_tokens"),

8
packages/stats/core/src/stat-sync.ts
View file

@ -11,6 +11,7 @@ import { startOfIsoWeek } from "./domain/stat"
const DATALAKE_INGESTION_LAG_MS = 5 * 60_000
const STATS_DATA_START_MS = new Date("2026-05-28T00:00:00.000Z").getTime()
const WEEK_MS = 7 * 86_400_000
const DISPLAY_WINDOW_MS = 56 * 86_400_000
export type SyncStatsResult = { ok: true; rows: number; startedAt: string; periodStart: string; periodEnd: string }
export type SyncStatsError = AthenaQueryError | AthenaQueryTimeoutError | DatabaseError
@ -23,7 +24,12 @@ export const syncStats: () => Effect.Effect<
const startedAt = yield* DateTime.nowAsDate
const periodEnd = new Date(Math.floor((startedAt.getTime() - DATALAKE_INGESTION_LAG_MS) / 60_000) * 60_000)
// May 27 was partial, so keep Athena stats anchored at the first complete day.
const periodStart = new Date(Math.max(startOfIsoWeek(periodEnd).getTime() - WEEK_MS, STATS_DATA_START_MS))
const periodStart = new Date(
Math.max(
Math.min(startOfIsoWeek(periodEnd).getTime() - WEEK_MS, periodEnd.getTime() - DISPLAY_WINDOW_MS),
STATS_DATA_START_MS,
),
)
const athena = yield* Athena
const modelStats = yield* ModelStatRepo
const providerStats = yield* ProviderStatRepo