alchemy 0.69.1 → 0.70.1

package/src/planetscale/password.ts

@@ -1,8 +1,8 @@
-import { isDeepStrictEqual } from "node:util";
 import { alchemy } from "../alchemy.ts";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import type { Secret } from "../secret.ts";
+import { diff } from "../util/diff.ts";
 import { lowercaseId } from "../util/nanoid.ts";
 import { createPlanetScaleClient, type PlanetScaleProps } from "./api.ts";
 import type { Branch } from "./branch.ts";
@@ -357,16 +357,3 @@ export const Password = Resource(
     };
   },
 );
-
-/**
- * Returns an array of keys in `b` that are different from `a`.
- */
-const diff = <T>(a: T, b: NoInfer<T>) => {
-  const keys: (keyof T)[] = [];
-  for (const key in a) {
-    if (!isDeepStrictEqual(a[key], b[key])) {
-      keys.push(key);
-    }
-  }
-  return keys;
-};

package/src/resource.ts

@@ -2,6 +2,7 @@ import { apply } from "./apply.ts";
 import type { Context } from "./context.ts";
 import { DestroyStrategy } from "./destroy.ts";
 import { Scope as _Scope, type Scope } from "./scope.ts";
+import { createAndSendEvent } from "./util/telemetry.ts";
 
 declare global {
   var ALCHEMY_PROVIDERS: Map<ResourceKind, Provider<string, any>>;
@@ -178,11 +179,17 @@ export function Resource<
         const error = new Error(
           `Resource ${resourceID} already exists in the stack and is of a different type: '${otherResource?.[ResourceKind]}' !== '${type}'`,
         );
-        scope.telemetryClient.record({
-          event: "resource.error",
-          resource: type,
+        createAndSendEvent(
+          {
+            event: "resource.error",
+            resource: type,
+            phase: scope.phase,
+            status: "unknown",
+            duration: 0,
+            replaced: false,
+          },
           error,
-        });
+        );
         throw error;
       }
     }

package/src/scope.ts

@@ -29,7 +29,7 @@ import {
 import { logger } from "./util/logger.ts";
 import { AsyncMutex } from "./util/mutex.ts";
 import { ALCHEMY_ROOT } from "./util/root-dir.ts";
-import type { ITelemetryClient } from "./util/telemetry/client.ts";
+import { createAndSendEvent } from "./util/telemetry.ts";
 
 export class RootScopeStateAttemptError extends Error {
   constructor() {
@@ -76,10 +76,11 @@ export interface ScopeOptions extends ProviderCredentials {
    */
   destroyStrategy?: DestroyStrategy;
   /**
-   * The telemetry client to use for the scope.
+   * Whether to disable telemetry for the scope.
    *
+   * @default false
    */
-  telemetryClient?: ITelemetryClient;
+  noTrack?: boolean;
   /**
    * The logger to use for the scope.
    */
@@ -102,6 +103,10 @@ export interface ScopeOptions extends ProviderCredentials {
    * @default process.cwd()
    */
   rootDir?: string;
+  /**
+   * The Alchemy profile to use for authoriziing requests.
+   */
+  profile?: string;
   /**
    * Whether this is the application that was selected with `--app`
    *
@@ -197,11 +202,12 @@ export class Scope {
   public readonly adopt: boolean;
   public readonly destroyStrategy: DestroyStrategy;
   public readonly logger: LoggerApi;
-  public readonly telemetryClient: ITelemetryClient;
+  public readonly noTrack: boolean;
   public readonly dataMutex: AsyncMutex;
   public readonly rootDir: string;
   public readonly dotAlchemy: string;
   public readonly isSelected: boolean | undefined;
+  public readonly profile: string | undefined;
 
   // Provider credentials for scope-level credential overrides
   public readonly providerCredentials: ProviderCredentials;
@@ -235,12 +241,13 @@ export class Scope {
       tunnel,
       force,
       destroyStrategy,
-      telemetryClient,
       logger,
       adopt,
       dotAlchemy,
       rootDir,
       isSelected,
+      noTrack,
+      profile,
       ...providerCredentials
     } = options;
 
@@ -267,12 +274,14 @@ export class Scope {
     }
 
     this.stage = stage ?? this.parent?.stage ?? DEFAULT_STAGE;
+    this.profile = profile ?? this.parent?.profile;
     this.parent?.children.set(this.scopeName!, this);
     this.quiet = quiet ?? this.parent?.quiet ?? false;
     if (this.parent && !this.scopeName) {
       throw new Error("Scope name is required when creating a child scope");
     }
     this.password = password ?? this.parent?.password;
+    this.noTrack = noTrack ?? this.parent?.noTrack ?? false;
     const resolvedPhase = phase ?? this.parent?.phase;
     if (resolvedPhase === undefined) {
       throw new Error("Phase is required");
@@ -307,14 +316,7 @@ export class Scope {
       stateStore ??
       this.parent?.stateStore ??
       ((scope) => new FileSystemStateStore(scope));
-    this.telemetryClient = telemetryClient ?? this.parent?.telemetryClient!;
-    this.state = new InstrumentedStateStore(
-      this.stateStore(this),
-      this.telemetryClient,
-    );
-    if (!telemetryClient && !this.parent?.telemetryClient) {
-      throw new Error("Telemetry client is required");
-    }
+    this.state = new InstrumentedStateStore(this.stateStore(this));
     this.dataMutex = new AsyncMutex();
   }
 
@@ -413,12 +415,7 @@ export class Scope {
   }
 
   public async init() {
-    await Promise.all([
-      this.state.init?.(),
-      this.telemetryClient.ready.catch((error) => {
-        this.logger.warn("Telemetry initialization failed:", error);
-      }),
-    ]);
+    await Promise.all([this.state.init?.()]);
   }
 
   public async deinit() {
@@ -515,26 +512,15 @@ export class Scope {
     return this.finalize();
   }
 
-  /**
-   * The telemetry client for the root scope.
-   * This is used so that app-level hooks are only called once.
-   */
-  private get rootTelemetryClient(): ITelemetryClient | null {
-    if (!this.parent) {
-      return this.telemetryClient;
-    }
-    return null;
-  }
-
   public async finalize(options?: { force?: boolean; noop?: boolean }) {
     const shouldForce =
       options?.force ||
       this.parent === undefined ||
       this?.parent?.scopeName === this.root.scopeName;
     if (this.phase === "read") {
-      this.rootTelemetryClient?.record({
-        event: "app.success",
-        elapsed: performance.now() - this.startedAt,
+      createAndSendEvent({
+        event: "alchemy.success",
+        duration: performance.now() - this.startedAt,
       });
       return;
     }
@@ -583,23 +569,21 @@ export class Scope {
         force: shouldForce,
         noop: options?.noop,
       });
-      this.rootTelemetryClient?.record({
-        event: "app.success",
-        elapsed: performance.now() - this.startedAt,
+      createAndSendEvent({
+        event: "alchemy.success",
+        duration: performance.now() - this.startedAt,
       });
     } else if (this.isErrored) {
       this.logger.warn("Scope is in error, skipping finalize");
-      this.rootTelemetryClient?.record({
-        event: "app.error",
-        error: new Error("Scope failed"),
-        elapsed: performance.now() - this.startedAt,
-      });
+      createAndSendEvent(
+        {
+          event: "alchemy.error",
+          duration: performance.now() - this.startedAt,
+        },
+        new Error("Scope failed"),
+      );
     }
 
-    await this.rootTelemetryClient?.finalize()?.catch((error) => {
-      this.logger.warn("Telemetry finalization failed:", error);
-    });
-
     if (!this.parent && process.env.ALCHEMY_TEST_KILL_ON_FINALIZE) {
       await this.cleanup();
       process.exit(0);

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

@@ -1,6 +1,8 @@
 import type { State, StateStore } from "../state.ts";
-import type { ITelemetryClient } from "../util/telemetry/client.ts";
-import type { Telemetry } from "../util/telemetry/types.ts";
+import {
+  createAndSendEvent,
+  type StateStoreTelemetryData,
+} from "../util/telemetry.ts";
 
 //todo(michael): we should also handle serde here
 export class InstrumentedStateStore<T extends StateStore>
@@ -9,17 +11,15 @@ export class InstrumentedStateStore<T extends StateStore>
   /** @internal */
   __phantom?: T;
   private readonly stateStore: StateStore;
-  private readonly telemetryClient: ITelemetryClient;
   private readonly stateStoreClass: string;
 
-  constructor(stateStore: StateStore, telemetryClient: ITelemetryClient) {
+  constructor(stateStore: StateStore) {
     this.stateStore = stateStore;
-    this.telemetryClient = telemetryClient;
     this.stateStoreClass = stateStore.constructor.name;
   }
 
   private async callWithTelemetry<T>(
-    event: Telemetry.StateStoreEvent["event"],
+    event: StateStoreTelemetryData["event"],
     fn: () => Promise<T>,
   ): Promise<T> {
     const start = performance.now();
@@ -30,17 +30,18 @@ export class InstrumentedStateStore<T extends StateStore>
       error = err;
       throw err;
     } finally {
-      this.telemetryClient.record({
-        event,
-        stateStoreClass: this.stateStoreClass,
-        elapsed: performance.now() - start,
-        error:
-          error instanceof Error
-            ? error
-            : error
-              ? new Error(String(error))
-              : undefined,
-      });
+      createAndSendEvent(
+        {
+          event,
+          stateStore: this.stateStoreClass,
+          duration: performance.now() - start,
+        },
+        error instanceof Error
+          ? error
+          : error
+            ? new Error(String(error))
+            : undefined,
+      );
     }
   }
 
@@ -49,7 +50,7 @@ export class InstrumentedStateStore<T extends StateStore>
       return;
     }
     await this.callWithTelemetry(
-      "stateStore.init",
+      "statestore.init",
       this.stateStore.init.bind(this.stateStore),
     );
   }
@@ -58,49 +59,49 @@ export class InstrumentedStateStore<T extends StateStore>
       return;
     }
     await this.callWithTelemetry(
-      "stateStore.deinit",
+      "statestore.deinit",
       this.stateStore.deinit.bind(this.stateStore),
     );
   }
   async list() {
     return await this.callWithTelemetry(
-      "stateStore.list",
+      "statestore.list",
       this.stateStore.list.bind(this.stateStore),
     );
   }
   async count() {
     return await this.callWithTelemetry(
-      "stateStore.count",
+      "statestore.count",
       this.stateStore.count.bind(this.stateStore),
     );
   }
   async get(key: string) {
     return await this.callWithTelemetry(
-      "stateStore.get",
+      "statestore.get",
       this.stateStore.get.bind(this.stateStore, key),
     );
   }
   async getBatch(ids: string[]) {
     return await this.callWithTelemetry(
-      "stateStore.getBatch",
+      "statestore.getBatch",
       this.stateStore.getBatch.bind(this.stateStore, ids),
     );
   }
   async all() {
     return await this.callWithTelemetry(
-      "stateStore.all",
+      "statestore.all",
       this.stateStore.all.bind(this.stateStore),
     );
   }
   async set(key: string, value: State) {
     await this.callWithTelemetry(
-      "stateStore.set",
+      "statestore.set",
       this.stateStore.set.bind(this.stateStore, key, value),
     );
   }
   async delete(key: string) {
     await this.callWithTelemetry(
-      "stateStore.delete",
+      "statestore.delete",
       this.stateStore.delete.bind(this.stateStore, key),
     );
   }

package/src/test/bun.ts

@@ -4,7 +4,6 @@ import { afterAll, beforeAll, it } from "bun:test";
 import path from "node:path";
 import { alchemy } from "../alchemy.ts";
 import { Scope } from "../scope.ts";
-import { NoopTelemetryClient } from "../util/telemetry/index.ts";
 import type { TestOptions } from "./options.ts";
 
 /**
@@ -103,7 +102,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
     // parent: globalTestScope,
     stateStore: defaultOptions?.stateStore,
     phase: "up",
-    telemetryClient: new NoopTelemetryClient(),
+    noTrack: true,
     local: defaultOptions.local,
   });
 

package/src/test/vitest.ts

@@ -8,7 +8,6 @@ import {
   FileSystemStateStore,
   SQLiteStateStore,
 } from "../state/index.ts";
-import { NoopTelemetryClient } from "../util/telemetry/client.ts";
 import type { TestOptions } from "./options.ts";
 
 /**
@@ -132,7 +131,7 @@ export function test(
     scopeName: `${defaultOptions.prefix ? `${defaultOptions.prefix}-` : ""}${path.basename(meta.filename)}`,
     stateStore: defaultOptions?.stateStore,
     phase: "up",
-    telemetryClient: new NoopTelemetryClient(),
+    noTrack: true,
     quiet: defaultOptions.quiet,
     password: process.env.ALCHEMY_PASSWORD,
     local: defaultOptions.local,

package/src/util/diff.ts

@@ -0,0 +1,14 @@
+import { isDeepStrictEqual } from "node:util";
+
+/**
+ * Returns an array of keys in `b` that are different from `a`.
+ */
+export const diff = <T>(a: T, b: NoInfer<T>) => {
+  const keys: (keyof T)[] = [];
+  for (const key in a) {
+    if (!isDeepStrictEqual(a[key], b[key])) {
+      keys.push(key);
+    }
+  }
+  return keys;
+};

package/src/util/idempotent-spawn.ts

@@ -112,7 +112,7 @@ export async function idempotentSpawn({
     const child = spawn(cmd, {
       shell: true,
       cwd,
-      stdio: ["ignore", out.fd, out.fd], // stdout/stderr -> files (OS-level)
+      stdio: ["inherit", out.fd, out.fd], // stdout/stderr -> files (OS-level)
       env,
       detached: false,
     });