@lupaflow/observability 0.1.0

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name":  "@lupaflow/observability",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*",
+                         "pino":  "^9.5.0",
+                         "pino-pretty":  "^13.0.0"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { UsageTracker } from "./tracker"
+export { logger } from "./logger"
+export { Tracer, globalTracer } from "./span"

package/src/logger.ts

@@ -0,0 +1,19 @@
+import pino from "pino"
+import { globalEventBus } from "@lupaflow/core"
+
+const logger = pino({
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "HH:MM:ss",
+      ignore: "pid,hostname",
+    },
+  },
+})
+
+globalEventBus.onAny((event) => {
+  logger.debug({ event: event.name, id: event.id }, `Event: ${event.name}`)
+})
+
+export { logger }

package/src/span.ts

@@ -0,0 +1,69 @@
+import { generateId } from "@lupaflow/core"
+
+interface Span {
+  id: string
+  name: string
+  parentId?: string
+  startTime: number
+  endTime?: number
+  status: "open" | "closed" | "error"
+  metadata?: Record<string, unknown>
+}
+
+export class Tracer {
+  private spans: Map<string, Span> = new Map()
+  private stack: string[] = []
+
+  start(name: string, metadata?: Record<string, unknown>): string {
+    const id = generateId()
+    const parentId = this.stack[this.stack.length - 1]
+    const span: Span = {
+      id,
+      name,
+      parentId,
+      startTime: Date.now(),
+      status: "open",
+      metadata,
+    }
+    this.spans.set(id, span)
+    this.stack.push(id)
+    return id
+  }
+
+  end(id: string, metadata?: Record<string, unknown>): void {
+    const span = this.spans.get(id)
+    if (!span) return
+    span.endTime = Date.now()
+    span.status = "closed"
+    span.metadata = { ...span.metadata, ...metadata }
+    this.stack = this.stack.filter((s) => s !== id)
+  }
+
+  error(id: string, error: string): void {
+    const span = this.spans.get(id)
+    if (!span) return
+    span.endTime = Date.now()
+    span.status = "error"
+    span.metadata = { ...span.metadata, error }
+    this.stack = this.stack.filter((s) => s !== id)
+  }
+
+  getTrace(id: string): Span | undefined {
+    return this.spans.get(id)
+  }
+
+  getActiveSpans(): Span[] {
+    return Array.from(this.spans.values()).filter((s) => s.status === "open")
+  }
+
+  getAllSpans(): Span[] {
+    return Array.from(this.spans.values())
+  }
+
+  clear(): void {
+    this.spans.clear()
+    this.stack = []
+  }
+}
+
+export const globalTracer = new Tracer()

package/src/tracker.ts

@@ -0,0 +1,88 @@
+import { globalEventBus } from "@lupaflow/core"
+import type { LupaEvent, ProviderCompleteEvent, LLMTokenEvent } from "@lupaflow/types"
+
+interface UsageRecord {
+  provider: string
+  model: string
+  tokens: number
+  cost: number
+  latencyMs: number
+  timestamp: number
+}
+
+const TOKEN_COST_PER_1K: Record<string, { input: number; output: number }> = {
+  "openai/gpt-4o-mini": { input: 0.00015, output: 0.0006 },
+  "openai/gpt-4o": { input: 0.0025, output: 0.01 },
+  "llama-3.1-70b-versatile": { input: 0.00059, output: 0.00079 },
+  "llama-3.1-8b-instant": { input: 0.00005, output: 0.00008 },
+  "gemini-1.5-flash": { input: 0.000075, output: 0.0003 },
+  "gemini-1.5-pro": { input: 0.00125, output: 0.005 },
+}
+
+function estimateCost(provider: string, model: string, tokens: number, isOutput = false): number {
+  const key = model
+  const rates = TOKEN_COST_PER_1K[key]
+  if (!rates) return 0
+  const rate = isOutput ? rates.output : rates.input
+  return (tokens / 1000) * rate
+}
+
+export class UsageTracker {
+  private records: UsageRecord[] = []
+  private totalTokens = 0
+  private totalCost = 0
+
+  constructor() {
+    globalEventBus.on("provider:complete", (event: LupaEvent) => {
+      const e = event as ProviderCompleteEvent
+      const isOutput = e.name === "provider:complete"
+      const cost = estimateCost(e.provider, e.model, e.tokens, isOutput)
+
+      this.records.push({
+        provider: e.provider,
+        model: e.model,
+        tokens: e.tokens,
+        cost,
+        latencyMs: e.latencyMs,
+        timestamp: e.timestamp,
+      })
+
+      this.totalTokens += e.tokens
+      this.totalCost += cost
+
+      globalEventBus.emit("llm:token", {
+        tokens: e.tokens,
+        cost,
+      } as LLMTokenEvent)
+    })
+  }
+
+  getTotalTokens(): number {
+    return this.totalTokens
+  }
+
+  getTotalCost(): number {
+    return this.totalCost
+  }
+
+  getRecords(): UsageRecord[] {
+    return [...this.records]
+  }
+
+  getSummary(): { totalTokens: number; totalCost: number; totalCalls: number; avgLatencyMs: number } {
+    const calls = this.records.length
+    const avgLatency = calls > 0 ? this.records.reduce((s, r) => s + r.latencyMs, 0) / calls : 0
+    return {
+      totalTokens: this.totalTokens,
+      totalCost: this.totalCost,
+      totalCalls: calls,
+      avgLatencyMs: Math.round(avgLatency),
+    }
+  }
+
+  reset(): void {
+    this.records = []
+    this.totalTokens = 0
+    this.totalCost = 0
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})