astrocode-workflow 0.3.1 → 0.3.3

package/src/shared/metrics.ts

@@ -0,0 +1,148 @@
+// src/shared/metrics.ts
+
+export interface TransactionMetrics {
+  startTime: number;
+  duration: number;
+  success: boolean;
+  nestedDepth: number;
+  operation?: string;
+}
+
+export interface InjectionMetrics {
+  sessionId: string;
+  attempts: number;
+  duration: number;
+  success: boolean;
+  agent?: string;
+}
+
+export interface SystemMetrics {
+  transactions: TransactionMetrics[];
+  injections: InjectionMetrics[];
+  errors: Array<{ type: string; message: string; timestamp: number }>;
+}
+
+class MetricsCollector {
+  private transactions: TransactionMetrics[] = [];
+  private injections: InjectionMetrics[] = [];
+  private errors: Array<{ type: string; message: string; timestamp: number }> = [];
+  private maxEntries = 1000; // Keep last 1000 entries per type
+
+  recordTransaction(metrics: TransactionMetrics) {
+    this.transactions.push(metrics);
+    if (this.transactions.length > this.maxEntries) {
+      this.transactions.shift();
+    }
+  }
+
+  recordInjection(metrics: InjectionMetrics) {
+    this.injections.push(metrics);
+    if (this.injections.length > this.maxEntries) {
+      this.injections.shift();
+    }
+  }
+
+  recordError(type: string, message: string) {
+    this.errors.push({ type, message, timestamp: Date.now() });
+    if (this.errors.length > this.maxEntries) {
+      this.errors.shift();
+    }
+  }
+
+  getMetrics(): SystemMetrics {
+    return {
+      transactions: [...this.transactions],
+      injections: [...this.injections],
+      errors: [...this.errors],
+    };
+  }
+
+  getTransactionStats() {
+    const txs = this.transactions;
+    if (txs.length === 0) return null;
+
+    const successful = txs.filter(t => t.success);
+    const failed = txs.filter(t => !t.success);
+
+    return {
+      total: txs.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / txs.length,
+      avgDuration: txs.reduce((sum, t) => sum + t.duration, 0) / txs.length,
+      avgNestedDepth: txs.reduce((sum, t) => sum + t.nestedDepth, 0) / txs.length,
+      minDuration: Math.min(...txs.map(t => t.duration)),
+      maxDuration: Math.max(...txs.map(t => t.duration)),
+    };
+  }
+
+  getInjectionStats() {
+    const injections = this.injections;
+    if (injections.length === 0) return null;
+
+    const successful = injections.filter(i => i.success);
+    const failed = injections.filter(i => !i.success);
+
+    return {
+      total: injections.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / injections.length,
+      avgAttempts: injections.reduce((sum, i) => sum + i.attempts, 0) / injections.length,
+      avgDuration: injections.reduce((sum, i) => sum + i.duration, 0) / injections.length,
+      totalRetries: injections.reduce((sum, i) => sum + Math.max(0, i.attempts - 1), 0),
+    };
+  }
+
+  clear() {
+    this.transactions = [];
+    this.injections = [];
+    this.errors = [];
+  }
+}
+
+// Global singleton
+export const metrics = new MetricsCollector();
+
+// Convenience functions
+export function recordTransaction(metricsData: Omit<TransactionMetrics, 'startTime' | 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: ReturnType<ReturnType<typeof recordTransaction>['start']>, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordTransaction({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordInjection(metricsData: Omit<InjectionMetrics, 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: any, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordInjection({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordError(type: string, message: string) {
+  metrics.recordError(type, message);
+}

package/src/state/db.ts

@@ -5,6 +5,7 @@ import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
 import { nowISO } from "../shared/time";
 import { info, warn } from "../shared/log";
 import { createDatabaseAdapter, DatabaseConnection } from "./adapters";
+import { recordTransaction } from "../shared/metrics";
 
 export type SqliteDb = DatabaseConnection;
 
@@ -74,7 +75,7 @@ function savepointName(depth: number): string {
 }
 
 /** BEGIN IMMEDIATE transaction helper (re-entrant). */
-export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean }): T {
+export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean; operation?: string }): T {
   const adapter = createDatabaseAdapter();
   const available = adapter.isAvailable();
 
@@ -84,13 +85,17 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   }
 
   const depth = getDepth(db);
+  const isNested = depth > 0;
+  const txRecorder = recordTransaction({ nestedDepth: depth, operation: opts?.operation });
 
   if (depth === 0) {
+    const txStart = txRecorder.start();
     db.exec("BEGIN IMMEDIATE");
     setDepth(db, 1);
     try {
       const out = fn();
       db.exec("COMMIT");
+      txRecorder.end(txStart, true);
       return out;
     } catch (e) {
       try {
@@ -98,6 +103,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
       } catch {
         // ignore
       }
+      txRecorder.end(txStart, false);
       throw e;
     } finally {
       setDepth(db, 0);
@@ -107,6 +113,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   // Nested: use SAVEPOINT
   const nextDepth = depth + 1;
   const sp = savepointName(nextDepth);
+  const txStart = txRecorder.start();
 
   db.exec(`SAVEPOINT ${sp}`);
   setDepth(db, nextDepth);
@@ -114,6 +121,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   try {
     const out = fn();
     db.exec(`RELEASE SAVEPOINT ${sp}`);
+    txRecorder.end(txStart, true);
     return out;
   } catch (e) {
     try {
@@ -126,6 +134,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
     } catch {
       // ignore
     }
+    txRecorder.end(txStart, false);
     throw e;
   } finally {
     setDepth(db, depth);