@dotdo/postgres 0.1.0

package/src/routing/cost-metrics.ts

@@ -0,0 +1,408 @@
+/**
+ * Cost Metrics Collector
+ *
+ * Task: postgres-d6g.9
+ *
+ * Collects and analyzes routing cost metrics to optimize decisions.
+ *
+ * Cost Model:
+ * - Worker: $0.02 per million CPU ms
+ * - DO: $12.50 per million requests + wall time
+ * - WebSocket hibernation: 95% cheaper for idle DO connections
+ */
+
+export type RuntimeType = 'worker' | 'durable-object'
+
+export interface QueryExecution {
+  queryId: string
+  sql: string
+  runtime: RuntimeType
+  cpuTimeMs: number
+  wallTimeMs: number
+  timestamp: number
+  sqlHash?: string
+  metadata?: {
+    queryType?: string
+    tablesAccessed?: string[]
+    rowsReturned?: number
+    [key: string]: unknown
+  }
+}
+
+export interface WebSocketSession {
+  connectionId: string
+  activeTimeMs: number
+  hibernatedTimeMs: number
+  messagesCount: number
+}
+
+export interface TimeWindow {
+  since?: number
+  until?: number
+}
+
+export interface RuntimeCosts {
+  cpuCost: number
+  requestCost: number
+  durationCost: number
+  hibernationSavings: number
+}
+
+export interface CostSummary {
+  worker: {
+    executionCount: number
+    totalCpuTimeMs: number
+    avgCpuTimeMs: number
+    p50CpuTimeMs: number
+    p95CpuTimeMs: number
+    p99CpuTimeMs: number
+    totalCost: number
+  }
+  durableObject: {
+    executionCount: number
+    totalCpuTimeMs: number
+    avgCpuTimeMs: number
+    p50CpuTimeMs: number
+    p95CpuTimeMs: number
+    p99CpuTimeMs: number
+    totalCost: number
+  }
+  totalCpuTimeMs: number
+  totalCost: number
+}
+
+export interface CostBreakdown {
+  byQueryType: Record<string, { cost: number; count: number; avgCpuTimeMs: number }>
+  byTable: Record<string, { cost: number; count: number; avgCpuTimeMs: number }>
+}
+
+export interface RuntimeComparison {
+  workerCost: number
+  doCost: number
+  recommendation: RuntimeType
+  savingsPercent: number
+}
+
+export interface Anomaly {
+  queryId: string
+  sql: string
+  cpuTimeMs: number
+  reason: string
+}
+
+export interface AnomalyReport {
+  slowQueries: Anomaly[]
+  routingInefficiencies: Anomaly[]
+}
+
+export interface CollectorConfig {
+  /** Worker CPU cost per million ms (default: $0.02) */
+  workerCpuCostPerMillion?: number
+
+  /** DO request cost per million requests (default: $12.50) */
+  doRequestCostPerMillion?: number
+
+  /** DO duration cost per GB-second (default: $12.50) */
+  doDurationCostPerGbSecond?: number
+
+  /** DO memory in MB for duration calculation (default: 128) */
+  doMemoryMb?: number
+
+  /** Maximum number of executions to retain */
+  maxExecutions?: number
+
+  /** Slow query threshold in ms */
+  slowQueryThresholdMs?: number
+
+  /** CPU time threshold for routing decision (default: 50ms) */
+  cpuTimeThresholdMs?: number
+}
+
+export class CostMetricsCollector {
+  private executions: QueryExecution[] = []
+  private webSocketSessions: WebSocketSession[] = []
+  private config: Required<CollectorConfig>
+
+  constructor(config: CollectorConfig = {}) {
+    this.config = {
+      workerCpuCostPerMillion: config.workerCpuCostPerMillion ?? 0.02,
+      doRequestCostPerMillion: config.doRequestCostPerMillion ?? 12.50,
+      doDurationCostPerGbSecond: config.doDurationCostPerGbSecond ?? 12.50,
+      doMemoryMb: config.doMemoryMb ?? 128,
+      maxExecutions: config.maxExecutions ?? 10000,
+      slowQueryThresholdMs: config.slowQueryThresholdMs ?? 100,
+      cpuTimeThresholdMs: config.cpuTimeThresholdMs ?? 50,
+    }
+  }
+
+  recordExecution(execution: QueryExecution): void {
+    this.executions.push(execution)
+
+    // Evict oldest if over limit
+    if (this.executions.length > this.config.maxExecutions) {
+      this.executions.sort((a, b) => a.timestamp - b.timestamp)
+      this.executions = this.executions.slice(-this.config.maxExecutions)
+    }
+  }
+
+  recordWebSocketSession(session: WebSocketSession): void {
+    this.webSocketSessions.push(session)
+  }
+
+  getExecutions(window?: TimeWindow): QueryExecution[] {
+    let filtered = this.executions
+
+    if (window?.since) {
+      filtered = filtered.filter(e => e.timestamp >= window.since!)
+    }
+
+    if (window?.until) {
+      filtered = filtered.filter(e => e.timestamp <= window.until!)
+    }
+
+    return filtered
+  }
+
+  calculateCosts(window?: TimeWindow): CostSummary & { worker: RuntimeCosts; durableObject: RuntimeCosts } {
+    const executions = this.getExecutions(window)
+
+    const workerExecs = executions.filter(e => e.runtime === 'worker')
+    const doExecs = executions.filter(e => e.runtime === 'durable-object')
+
+    // Worker costs
+    const workerCpuTimeMs = workerExecs.reduce((sum, e) => sum + e.cpuTimeMs, 0)
+    const workerCpuCost = (workerCpuTimeMs / 1_000_000) * this.config.workerCpuCostPerMillion
+
+    // DO costs
+    const doRequestCost = (doExecs.length / 1_000_000) * this.config.doRequestCostPerMillion
+    const doWallTimeSeconds = doExecs.reduce((sum, e) => sum + e.wallTimeMs, 0) / 1000
+    const doMemoryGb = this.config.doMemoryMb / 1024
+    const doDurationCost = doWallTimeSeconds * doMemoryGb * this.config.doDurationCostPerGbSecond
+
+    // Calculate hibernation savings
+    let hibernationSavings = 0
+    for (const session of this.webSocketSessions) {
+      const totalTime = session.activeTimeMs + session.hibernatedTimeMs
+      if (totalTime > 0) {
+        // Hibernation saves ~95% of duration cost for hibernated time
+        const potentialCost = (session.hibernatedTimeMs / 1000) * doMemoryGb * this.config.doDurationCostPerGbSecond
+        hibernationSavings += potentialCost * 0.95
+      }
+    }
+
+    const doCpuTimeMs = doExecs.reduce((sum, e) => sum + e.cpuTimeMs, 0)
+
+    return {
+      worker: {
+        cpuCost: workerCpuCost,
+        requestCost: 0,
+        durationCost: 0,
+        hibernationSavings: 0,
+        executionCount: workerExecs.length,
+        totalCpuTimeMs: workerCpuTimeMs,
+        avgCpuTimeMs: workerExecs.length > 0 ? workerCpuTimeMs / workerExecs.length : 0,
+        ...this.calculatePercentiles(workerExecs.map(e => e.cpuTimeMs)),
+        totalCost: workerCpuCost,
+      },
+      durableObject: {
+        cpuCost: 0,
+        requestCost: doRequestCost,
+        durationCost: doDurationCost,
+        hibernationSavings,
+        executionCount: doExecs.length,
+        totalCpuTimeMs: doCpuTimeMs,
+        avgCpuTimeMs: doExecs.length > 0 ? doCpuTimeMs / doExecs.length : 0,
+        ...this.calculatePercentiles(doExecs.map(e => e.cpuTimeMs)),
+        totalCost: doRequestCost + doDurationCost - hibernationSavings,
+      },
+      totalCpuTimeMs: workerCpuTimeMs + doCpuTimeMs,
+      totalCost: workerCpuCost + doRequestCost + doDurationCost - hibernationSavings,
+    }
+  }
+
+  private calculatePercentiles(values: number[]): { p50CpuTimeMs: number; p95CpuTimeMs: number; p99CpuTimeMs: number } {
+    if (values.length === 0) {
+      return { p50CpuTimeMs: 0, p95CpuTimeMs: 0, p99CpuTimeMs: 0 }
+    }
+
+    const sorted = [...values].sort((a, b) => a - b)
+
+    const percentile = (p: number) => {
+      const index = Math.ceil((p / 100) * sorted.length) - 1
+      return sorted[Math.max(0, index)] ?? 0
+    }
+
+    return {
+      p50CpuTimeMs: percentile(50),
+      p95CpuTimeMs: percentile(95),
+      p99CpuTimeMs: percentile(99),
+    }
+  }
+
+  compareRuntimes(sqlHash: string): RuntimeComparison {
+    const executions = this.executions.filter(e => e.sqlHash === sqlHash)
+
+    const workerExecs = executions.filter(e => e.runtime === 'worker')
+    const doExecs = executions.filter(e => e.runtime === 'durable-object')
+
+    // Calculate average costs
+    const avgWorkerCpuTimeMs = workerExecs.length > 0
+      ? workerExecs.reduce((sum, e) => sum + e.cpuTimeMs, 0) / workerExecs.length
+      : 0
+
+    const workerCost = (avgWorkerCpuTimeMs / 1_000_000) * this.config.workerCpuCostPerMillion
+
+    // For DO, include request cost per query
+    const doRequestCostPerQuery = this.config.doRequestCostPerMillion / 1_000_000
+    const avgDoWallTimeMs = doExecs.length > 0
+      ? doExecs.reduce((sum, e) => sum + e.wallTimeMs, 0) / doExecs.length
+      : 0
+    const doMemoryGb = this.config.doMemoryMb / 1024
+    const doDurationCostPerQuery = (avgDoWallTimeMs / 1000) * doMemoryGb * this.config.doDurationCostPerGbSecond
+    const doCost = doRequestCostPerQuery + doDurationCostPerQuery
+
+    // Default to worker for simple queries if no data
+    if (workerExecs.length === 0 && doExecs.length === 0) {
+      return {
+        workerCost: 0,
+        doCost: 0,
+        recommendation: 'worker',
+        savingsPercent: 0,
+      }
+    }
+
+    const recommendation: RuntimeType = workerCost <= doCost ? 'worker' : 'durable-object'
+    const maxCost = Math.max(workerCost, doCost)
+    const minCost = Math.min(workerCost, doCost)
+    const savingsPercent = maxCost > 0 ? ((maxCost - minCost) / maxCost) * 100 : 0
+
+    return {
+      workerCost,
+      doCost,
+      recommendation,
+      savingsPercent,
+    }
+  }
+
+  getSummary(window?: TimeWindow): CostSummary {
+    const costs = this.calculateCosts(window)
+
+    return {
+      worker: {
+        executionCount: costs.worker.executionCount,
+        totalCpuTimeMs: costs.worker.totalCpuTimeMs,
+        avgCpuTimeMs: costs.worker.avgCpuTimeMs,
+        p50CpuTimeMs: costs.worker.p50CpuTimeMs,
+        p95CpuTimeMs: costs.worker.p95CpuTimeMs,
+        p99CpuTimeMs: costs.worker.p99CpuTimeMs,
+        totalCost: costs.worker.totalCost,
+      },
+      durableObject: {
+        executionCount: costs.durableObject.executionCount,
+        totalCpuTimeMs: costs.durableObject.totalCpuTimeMs,
+        avgCpuTimeMs: costs.durableObject.avgCpuTimeMs,
+        p50CpuTimeMs: costs.durableObject.p50CpuTimeMs,
+        p95CpuTimeMs: costs.durableObject.p95CpuTimeMs,
+        p99CpuTimeMs: costs.durableObject.p99CpuTimeMs,
+        totalCost: costs.durableObject.totalCost,
+      },
+      totalCpuTimeMs: costs.totalCpuTimeMs,
+      totalCost: costs.totalCost,
+    }
+  }
+
+  getCostBreakdown(window?: TimeWindow): CostBreakdown {
+    const executions = this.getExecutions(window)
+
+    const byQueryType: CostBreakdown['byQueryType'] = {}
+    const byTable: CostBreakdown['byTable'] = {}
+
+    for (const exec of executions) {
+      const cost = this.calculateExecutionCost(exec)
+      const queryType = exec.metadata?.queryType ?? 'UNKNOWN'
+
+      if (!byQueryType[queryType]) {
+        byQueryType[queryType] = { cost: 0, count: 0, avgCpuTimeMs: 0 }
+      }
+      byQueryType[queryType].cost += cost
+      byQueryType[queryType].count++
+      byQueryType[queryType].avgCpuTimeMs =
+        (byQueryType[queryType].avgCpuTimeMs * (byQueryType[queryType].count - 1) + exec.cpuTimeMs) /
+        byQueryType[queryType].count
+
+      const tables = exec.metadata?.tablesAccessed ?? []
+      for (const table of tables) {
+        if (!byTable[table]) {
+          byTable[table] = { cost: 0, count: 0, avgCpuTimeMs: 0 }
+        }
+        byTable[table].cost += cost
+        byTable[table].count++
+        byTable[table].avgCpuTimeMs =
+          (byTable[table].avgCpuTimeMs * (byTable[table].count - 1) + exec.cpuTimeMs) /
+          byTable[table].count
+      }
+    }
+
+    return { byQueryType, byTable }
+  }
+
+  private calculateExecutionCost(exec: QueryExecution): number {
+    if (exec.runtime === 'worker') {
+      return (exec.cpuTimeMs / 1_000_000) * this.config.workerCpuCostPerMillion
+    } else {
+      const requestCost = this.config.doRequestCostPerMillion / 1_000_000
+      const doMemoryGb = this.config.doMemoryMb / 1024
+      const durationCost = (exec.wallTimeMs / 1000) * doMemoryGb * this.config.doDurationCostPerGbSecond
+      return requestCost + durationCost
+    }
+  }
+
+  detectAnomalies(): AnomalyReport {
+    const slowQueries: Anomaly[] = []
+    const routingInefficiencies: Anomaly[] = []
+
+    for (const exec of this.executions) {
+      // Detect slow queries
+      if (exec.cpuTimeMs >= this.config.slowQueryThresholdMs) {
+        slowQueries.push({
+          queryId: exec.queryId,
+          sql: exec.sql,
+          cpuTimeMs: exec.cpuTimeMs,
+          reason: `CPU time ${exec.cpuTimeMs}ms exceeds threshold ${this.config.slowQueryThresholdMs}ms`,
+        })
+      }
+
+      // Detect routing inefficiencies (Worker used for complex queries)
+      if (exec.runtime === 'worker' && exec.cpuTimeMs > this.config.cpuTimeThresholdMs) {
+        routingInefficiencies.push({
+          queryId: exec.queryId,
+          sql: exec.sql,
+          cpuTimeMs: exec.cpuTimeMs,
+          reason: `Worker used for query with ${exec.cpuTimeMs}ms CPU time (threshold: ${this.config.cpuTimeThresholdMs}ms)`,
+        })
+      }
+    }
+
+    return { slowQueries, routingInefficiencies }
+  }
+
+  exportJSON(): string {
+    return JSON.stringify({
+      executions: this.executions,
+      webSocketSessions: this.webSocketSessions,
+      summary: this.getSummary(),
+      config: this.config,
+    })
+  }
+
+  importJSON(json: string): void {
+    const data = JSON.parse(json)
+    this.executions = data.executions ?? []
+    this.webSocketSessions = data.webSocketSessions ?? []
+  }
+
+  clear(): void {
+    this.executions = []
+    this.webSocketSessions = []
+  }
+}