alchemy 0.51.1 → 0.51.2

package/src/cloudflare/miniflare/miniflare.ts

@@ -1,13 +1,6 @@
-import {
-  MiniflareCoreError,
-  type Miniflare,
-  type MiniflareOptions,
-  type RemoteProxyConnectionString,
-  type WorkerOptions,
-} from "miniflare";
+import * as miniflare from "miniflare";
 import path from "node:path";
 import { findOpenPort } from "../../util/find-open-port.ts";
-import { logger } from "../../util/logger.ts";
 import {
   promiseWithResolvers,
   type PromiseWithResolvers,
@@ -24,14 +17,14 @@ import {
 } from "./remote-binding-proxy.ts";
 
 class MiniflareServer {
-  miniflare?: Miniflare;
-  workers = new Map<string, WorkerOptions>();
+  miniflare?: miniflare.Miniflare;
+  workers = new Map<string, miniflare.WorkerOptions>();
   workerProxies = new Map<string, MiniflareWorkerProxy>();
   remoteBindingProxies = new Map<string, RemoteBindingProxy>();
 
   stream = new WritableStream<{
     worker: MiniflareWorkerOptions;
-    promise: PromiseWithResolvers<MiniflareWorkerProxy>;
+    promise: PromiseWithResolvers<{ url: string }>;
   }>({
     write: async ({ worker, promise }) => {
       try {
@@ -48,7 +41,7 @@ class MiniflareServer {
   writer = this.stream.getWriter();
 
   async push(worker: MiniflareWorkerOptions) {
-    const promise = promiseWithResolvers<MiniflareWorkerProxy>();
+    const promise = promiseWithResolvers<{ url: string }>();
     const [, server] = await Promise.all([
       this.writer.write({ worker, promise }),
       promise.promise,
@@ -73,12 +66,6 @@ class MiniflareServer {
         this.miniflare.setOptions(await this.miniflareOptions()),
       );
     } else {
-      const { Miniflare } = await import("miniflare").catch(() => {
-        throw new Error(
-          "Miniflare is not installed, but is required in local mode for Workers. Please run `npm install miniflare`.",
-        );
-      });
-
       // Miniflare intercepts SIGINT and exits with 130, which is not a failure.
       // No one likes to see a non-zero exit code when they Ctrl+C, so here's our workaround.
       process.on("exit", (code) => {
@@ -86,26 +73,21 @@ class MiniflareServer {
           process.exit(0);
         }
       });
-      this.miniflare = new Miniflare(await this.miniflareOptions());
+      this.miniflare = new miniflare.Miniflare(await this.miniflareOptions());
       await withErrorRewrite(this.miniflare.ready);
     }
-    const existing = this.workerProxies.get(worker.name);
-    if (existing) {
-      return existing;
+    const existingProxy = this.workerProxies.get(worker.name);
+    if (existingProxy) {
+      return existingProxy;
     }
-    const server = new MiniflareWorkerProxy({
-      getDirectURL: async () => {
-        const url = await this.miniflare?.unsafeGetDirectURL(worker.name);
-        if (!url) {
-          throw new Error(`Worker "${worker.name}" is not running`);
-        }
-        return url;
-      },
-      fetch: this.createRequestHandler(worker.name),
+    const newProxy = new MiniflareWorkerProxy({
+      name: worker.name,
+      port: worker.port ?? (await findOpenPort()),
+      miniflare: this.miniflare,
     });
-    this.workerProxies.set(worker.name, server);
-    await server.listen(worker.port ?? (await findOpenPort()));
-    return server;
+    this.workerProxies.set(worker.name, newProxy);
+    await newProxy.ready;
+    return newProxy;
   }
 
   private async dispose() {
@@ -125,7 +107,7 @@ class MiniflareServer {
 
   private async maybeCreateRemoteProxy(
     worker: MiniflareWorkerOptions,
-  ): Promise<RemoteProxyConnectionString | undefined> {
+  ): Promise<miniflare.RemoteProxyConnectionString | undefined> {
     const bindings = buildRemoteBindings(worker);
     if (bindings.length === 0) {
       return undefined;
@@ -148,52 +130,11 @@ class MiniflareServer {
     return proxy.connectionString;
   }
 
-  private createRequestHandler(name: string) {
-    return async (req: Request) => {
-      try {
-        if (!this.miniflare) {
-          return new Response(
-            "[Alchemy] Miniflare is not initialized. Please try again.",
-            {
-              status: 503,
-            },
-          );
-        }
-        const worker = await this.miniflare?.getWorker(name);
-        if (!worker) {
-          return new Response(
-            `[Alchemy] Cannot find worker "${name}". Please try again.`,
-            {
-              status: 503,
-            },
-          );
-        }
-        const res = await worker.fetch(req.url, {
-          method: req.method,
-          headers: req.headers as any,
-          body: req.body as any,
-          duplex: "half",
-          redirect: "manual",
-        });
-        return res as unknown as Response;
-      } catch (error) {
-        logger.error(error);
-        return new Response(
-          `[Alchemy] Internal server error: ${String(error)}`,
-          {
-            status: 500,
-          },
-        );
-      }
-    };
-  }
-
-  private async miniflareOptions(): Promise<MiniflareOptions> {
-    const { getDefaultDevRegistryPath } = await import("miniflare");
+  private async miniflareOptions(): Promise<miniflare.MiniflareOptions> {
     return {
       workers: Array.from(this.workers.values()),
       defaultPersistRoot: path.join(process.cwd(), ".alchemy/miniflare"),
-      unsafeDevRegistryPath: getDefaultDevRegistryPath(),
+      unsafeDevRegistryPath: miniflare.getDefaultDevRegistryPath(),
       analyticsEngineDatasetsPersist: true,
       cachePersist: true,
       d1Persist: true,
@@ -202,6 +143,9 @@ class MiniflareServer {
       r2Persist: true,
       secretsStorePersist: true,
       workflowsPersist: true,
+      log: process.env.DEBUG
+        ? new miniflare.Log(miniflare.LogLevel.DEBUG)
+        : undefined,
     };
   }
 }
@@ -219,7 +163,7 @@ async function withErrorRewrite<T>(promise: Promise<T>) {
     return await promise;
   } catch (error) {
     if (
-      error instanceof MiniflareCoreError &&
+      error instanceof miniflare.MiniflareCoreError &&
       error.code === "ERR_MODULE_STRING_SCRIPT"
     ) {
       throw new ExternalDependencyError();

package/src/scope.ts

@@ -15,6 +15,7 @@ import {
 import type { State, StateStore, StateStoreType } from "./state.ts";
 import { D1StateStore } from "./state/d1-state-store.ts";
 import { FileSystemStateStore } from "./state/file-system-state-store.ts";
+import { InstrumentedStateStore } from "./state/instrumented-state-store.ts";
 import {
   createDummyLogger,
   createLoggerInstance,
@@ -201,12 +202,15 @@ export class Scope {
 
     this.stateStore =
       options.stateStore ?? this.parent?.stateStore ?? defaultStateStore;
-    this.state = this.stateStore(this);
+    this.telemetryClient =
+      options.telemetryClient ?? this.parent?.telemetryClient!;
+    this.state = new InstrumentedStateStore(
+      this.stateStore(this),
+      this.telemetryClient,
+    );
     if (!options.telemetryClient && !this.parent?.telemetryClient) {
       throw new Error("Telemetry client is required");
     }
-    this.telemetryClient =
-      options.telemetryClient ?? this.parent?.telemetryClient!;
     this.dataMutex = new AsyncMutex();
   }
 

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;
   };