pi-observability 1.0.1 → 1.3.1

package/extensions/lib/storage/jsonl-store.ts

@@ -0,0 +1,29 @@
+import type { JsonlStore, RawBackend } from "./types.js";
+
+export function createJsonlStore<T>(backend: RawBackend, name: string): JsonlStore<T> {
+  const fileName = `${name}.jsonl`;
+
+  return {
+    async append(value: T): Promise<void> {
+      const line = JSON.stringify(value);
+      await backend.append(fileName, line);
+    },
+
+    async read(options?: { last?: number }): Promise<T[]> {
+      const lines = await backend.readLines(fileName, options);
+      const results: T[] = [];
+      for (const line of lines) {
+        try {
+          results.push(JSON.parse(line) as T);
+        } catch (err) {
+          console.error(`[storage] corrupt JSONL line in ${fileName}, skipping:`, err);
+        }
+      }
+      return results;
+    },
+
+    async trim(options: { keepLast: number }): Promise<void> {
+      await backend.trimLines(fileName, options.keepLast);
+    },
+  };
+}

package/extensions/lib/storage/memory-backend.ts

@@ -0,0 +1,37 @@
+import type { RawBackend } from "./types.js";
+
+export function createMemoryBackend(initial?: Map<string, string>): RawBackend {
+  const store = initial ?? new Map<string, string>();
+
+  return {
+    async read(name) {
+      return store.get(name);
+    },
+
+    async write(name, content) {
+      store.set(name, content);
+    },
+
+    async append(name, line) {
+      const existing = store.get(name) ?? "";
+      store.set(name, `${existing}${line}\n`);
+    },
+
+    async readLines(name, options) {
+      const text = store.get(name);
+      if (!text) return [];
+      const lines = text.split("\n").filter((l) => l.trim());
+      if (options?.last !== undefined && options.last > 0) {
+        return lines.slice(-options.last);
+      }
+      return lines;
+    },
+
+    async trimLines(name, keepLast) {
+      const lines = await this.readLines(name);
+      if (lines.length <= keepLast) return;
+      const kept = lines.slice(-keepLast);
+      store.set(name, kept.map((l) => `${l}\n`).join(""));
+    },
+  };
+}

package/extensions/lib/storage/types.ts

@@ -0,0 +1,23 @@
+export interface JsonStore<T> {
+  load(): Promise<T>;
+  save(value: T): Promise<void>;
+}
+
+export interface JsonlStore<T> {
+  append(value: T): Promise<void>;
+  read(options?: { last?: number }): Promise<T[]>;
+  trim(options: { keepLast: number }): Promise<void>;
+}
+
+export interface Storage {
+  json<T>(name: string, options?: { defaults?: T }): JsonStore<T>;
+  jsonl<T>(name: string): JsonlStore<T>;
+}
+
+export interface RawBackend {
+  read(name: string): Promise<string | undefined>;
+  write(name: string, content: string): Promise<void>;
+  append(name: string, line: string): Promise<void>;
+  readLines(name: string, options?: { last?: number }): Promise<string[]>;
+  trimLines(name: string, keepLast: number): Promise<void>;
+}