alchemy 0.51.1 → 0.51.3

package/src/state/instrumented-state-store.ts

@@ -0,0 +1,97 @@
+import type { State, StateStore } from "../state.ts";
+import type { ITelemetryClient } from "../util/telemetry/client.ts";
+import type { Telemetry } from "../util/telemetry/types.ts";
+
+//todo(michael): we should also handle serde here
+export class InstrumentedStateStore<T extends StateStore>
+  implements StateStore
+{
+  private readonly stateStore: StateStore;
+  private readonly telemetryClient: ITelemetryClient;
+  private readonly stateStoreClass: string;
+
+  constructor(stateStore: StateStore, telemetryClient: ITelemetryClient) {
+    this.stateStore = stateStore;
+    this.telemetryClient = telemetryClient;
+    this.stateStoreClass = stateStore.constructor.name;
+  }
+
+  private async callWithTelemetry<T>(
+    event: Telemetry.StateStoreEvent["event"],
+    fn: () => Promise<T>,
+  ): Promise<T> {
+    const start = performance.now();
+    let error: unknown;
+    return await fn()
+      .catch((err) => (error = err))
+      .finally(() => {
+        this.telemetryClient.record({
+          event,
+          stateStoreClass: this.stateStoreClass,
+          elapsed: performance.now() - start,
+          error: error instanceof Error ? error : new Error(String(error)),
+        });
+      });
+  }
+
+  async init() {
+    if (this.stateStore.init == null) {
+      return;
+    }
+    await this.callWithTelemetry(
+      "stateStore.init",
+      this.stateStore.init.bind(this.stateStore),
+    );
+  }
+  async deinit() {
+    if (this.stateStore.deinit == null) {
+      return;
+    }
+    await this.callWithTelemetry(
+      "stateStore.deinit",
+      this.stateStore.deinit.bind(this.stateStore),
+    );
+  }
+  async list() {
+    return await this.callWithTelemetry(
+      "stateStore.list",
+      this.stateStore.list.bind(this.stateStore),
+    );
+  }
+  async count() {
+    return await this.callWithTelemetry(
+      "stateStore.count",
+      this.stateStore.count.bind(this.stateStore),
+    );
+  }
+  async get(key: string) {
+    return await this.callWithTelemetry(
+      "stateStore.get",
+      this.stateStore.get.bind(this.stateStore, key),
+    );
+  }
+  async getBatch(ids: string[]) {
+    return await this.callWithTelemetry(
+      "stateStore.getBatch",
+      this.stateStore.getBatch.bind(this.stateStore, ids),
+    );
+  }
+  async all() {
+    return await this.callWithTelemetry(
+      "stateStore.all",
+      this.stateStore.all.bind(this.stateStore),
+    );
+  }
+  async set(key: string, value: State) {
+    await this.callWithTelemetry(
+      "stateStore.set",
+      this.stateStore.set.bind(this.stateStore, key, value),
+    );
+  }
+  async delete(key: string) {
+    await this.callWithTelemetry(
+      "stateStore.delete",
+      this.stateStore.delete.bind(this.stateStore, key),
+    );
+  }
+}

package/src/util/telemetry/client.ts

@@ -54,13 +54,9 @@ export class TelemetryClient implements ITelemetryClient {
   }
 
   record(event: Telemetry.EventInput, timestamp = Date.now()) {
-    if (!this.context) {
-      return;
-    }
     const payload = {
       ...event,
       error: this.serializeError(event.error),
-      context: this.context,
       timestamp,
     } as Telemetry.Event;
     this.events.push(payload);
@@ -93,9 +89,10 @@ export class TelemetryClient implements ITelemetryClient {
   }
 
   private async send(events: Telemetry.Event[]) {
-    if (events.length === 0) {
+    if (events.length === 0 || this.context) {
       return;
     }
+    const { userId, ...data } = this.context!;
     const response = await fetch(`${POSTHOG_CLIENT_API_HOST}/batch`, {
       method: "POST",
       headers: {
@@ -104,13 +101,18 @@ export class TelemetryClient implements ITelemetryClient {
       body: JSON.stringify({
         api_key: POSTHOG_PROJECT_ID,
         historical_migration: false,
-        batch: events.map((e) => ({
-          event: e.event,
-          properties: {
-            distinct_id: this.context?.sessionId,
-          },
-          timestamp: new Date(e.timestamp).toISOString(),
-        })),
+        batch: events.map((e) => {
+          const { event, ...eventData } = e;
+          return {
+            event: event,
+            properties: {
+              distinct_id: userId,
+              ...data,
+              ...eventData,
+            },
+            timestamp: new Date(e.timestamp).toISOString(),
+          };
+        }),
       }),
     });
     if (!response.ok) {

package/src/util/telemetry/types.ts

@@ -35,7 +35,6 @@ export namespace Telemetry {
 
   export interface BaseEvent {
     event: string;
-    context: Context;
     timestamp: number;
   }
 
@@ -73,10 +72,27 @@ export namespace Telemetry {
     replaced?: boolean;
   }
 
-  export type Event = AppEvent | ResourceEvent;
+  export interface StateStoreEvent extends BaseEvent {
+    event:
+      | "stateStore.init"
+      | "stateStore.deinit"
+      | "stateStore.list"
+      | "stateStore.count"
+      | "stateStore.get"
+      | "stateStore.getBatch"
+      | "stateStore.all"
+      | "stateStore.set"
+      | "stateStore.delete";
+    stateStoreClass: string;
+    elapsed?: number;
+    error?: SerializedError;
+  }
+
+  export type Event = AppEvent | ResourceEvent | StateStoreEvent;
   export type EventInput = (
     | Omit<AppEvent, "context" | "timestamp" | "error">
     | Omit<ResourceEvent, "context" | "timestamp" | "error">
+    | Omit<StateStoreEvent, "context" | "timestamp" | "error">
   ) & {
     error?: ErrorInput;
   };