alchemy 0.69.1 → 0.70.0

package/src/util/telemetry/context.ts

@@ -1,154 +0,0 @@
-import { exec } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
-import { join } from "node:path";
-import pkg from "../../../package.json" with { type: "json" };
-import type { Phase } from "../../alchemy.ts";
-import { CONFIG_DIR } from "./constants.ts";
-import type { Telemetry } from "./types.ts";
-
-async function userId() {
-  const path = join(CONFIG_DIR, "id");
-
-  try {
-    return (await readFile(path, "utf-8")).trim();
-  } catch {}
-
-  try {
-    await mkdir(CONFIG_DIR, { recursive: true });
-  } catch {}
-
-  const id = crypto.randomUUID();
-  try {
-    await writeFile(path, id);
-    console.warn(
-      [
-        "Attention: To help improve Alchemy, we now collect anonymous usage, performance, and error data.",
-        "You can opt out by setting the ALCHEMY_TELEMETRY_DISABLED or DO_NOT_TRACK environment variable to a truthy value.",
-      ].join("\n"),
-    );
-  } catch {
-    return null;
-  }
-
-  return id;
-}
-
-function projectId() {
-  return new Promise<string | null>((resolve) => {
-    exec("git rev-list --max-parents=0 HEAD", (err, stdout) => {
-      if (err) {
-        resolve(null);
-        return;
-      }
-      resolve(stdout.trim());
-    });
-  });
-}
-
-function system(): Telemetry.Context["system"] {
-  return {
-    platform: os.platform(),
-    osVersion: os.release(),
-    arch: os.arch(),
-    cpus: os.cpus().length,
-    memory: os.totalmem() / 1024 / 1024,
-  };
-}
-
-declare global {
-  var Deno:
-    | {
-        version: {
-          deno: string;
-        };
-      }
-    | undefined;
-  var EdgeRuntime: Record<string, unknown> | undefined;
-}
-
-const RUNTIMES = [
-  {
-    name: "bun",
-    detect: () => !!globalThis.Bun,
-    version: () => globalThis.Bun?.version,
-  },
-  {
-    name: "deno",
-    detect: () => !!globalThis.Deno,
-    version: () => globalThis.Deno?.version?.deno,
-  },
-  {
-    name: "workerd",
-    detect: () => !!globalThis.EdgeRuntime,
-    version: () => null,
-  },
-  {
-    name: "node",
-    detect: () => !!globalThis.process?.versions?.node,
-    version: () => process.versions.node,
-  },
-] as const;
-
-function runtime(): Telemetry.Context["runtime"] {
-  for (const runtime of RUNTIMES) {
-    if (runtime.detect()) {
-      return {
-        name: runtime.name,
-        version: runtime.version() ?? null,
-      };
-    }
-  }
-  return {
-    name: null,
-    version: null,
-  };
-}
-
-const PROVIDERS = [
-  { env: "GITHUB_ACTIONS", provider: "GitHub Actions", isCI: true },
-  { env: "GITLAB_CI", provider: "GitLab CI", isCI: true },
-  { env: "CIRCLECI", provider: "CircleCI", isCI: true },
-  { env: "JENKINS_URL", provider: "Jenkins", isCI: true },
-  { env: "TRAVIS", provider: "Travis CI", isCI: true },
-  { env: "NOW_BUILDER", provider: "Vercel", isCI: true },
-  { env: "VERCEL", provider: "Vercel", isCI: false },
-];
-
-function environment(): Telemetry.Context["environment"] {
-  for (const provider of PROVIDERS) {
-    if (process.env[provider.env]) {
-      return {
-        provider: provider.provider,
-        isCI: provider.isCI,
-      };
-    }
-  }
-  return {
-    provider: null,
-    isCI: !!process.env.CI,
-  };
-}
-
-export async function context(input: {
-  sessionId: string;
-  phase?: Phase;
-}): Promise<Telemetry.Context> {
-  const env = environment();
-  const [uid, pid] = await Promise.all([
-    env.isCI ? null : userId(),
-    projectId(),
-  ]);
-  return {
-    userId: uid,
-    projectId: pid,
-    sessionId: input.sessionId,
-    system: system(),
-    runtime: runtime(),
-    environment: env,
-    alchemy: {
-      version: pkg.version,
-      phase: input.phase,
-    },
-  };
-}

package/src/util/telemetry/index.ts

@@ -1,2 +0,0 @@
-export * from "./client.ts";
-export * from "./types.ts";

package/src/util/telemetry/types.ts

@@ -1,105 +0,0 @@
-import type { Phase } from "../../alchemy.ts";
-
-export namespace Telemetry {
-  export interface Context {
-    /** Random UUID generated once per machine and stored in XDG config directory (e.g. `~/Library/Preferences/alchemy` on Mac). Null for CI environments. */
-    userId: string | null;
-    /** Root commit hash for the git repository. Anonymous, stable identifier for anyone using git. */
-    projectId: string | null;
-    /** UUID generated once per application run. */
-    sessionId: string;
-
-    system: {
-      platform: string;
-      osVersion: string;
-      arch: string;
-      cpus: number;
-      memory: number;
-    };
-
-    runtime: {
-      name: string | null;
-      version: string | null;
-    };
-
-    environment: {
-      provider: string | null;
-      isCI: boolean;
-    };
-
-    alchemy: {
-      version: string;
-      phase?: Phase;
-    };
-  }
-
-  export interface BaseEvent {
-    event: string;
-    timestamp: number;
-  }
-
-  export interface SerializedError {
-    name?: string;
-    message: string;
-    stack?: string;
-  }
-
-  export type ErrorInput = Error | SerializedError;
-
-  export interface AppEvent extends BaseEvent {
-    event: "app.start" | "app.success" | "app.error";
-    elapsed?: number;
-    error?: SerializedError;
-  }
-
-  export interface ResourceEvent extends BaseEvent {
-    event:
-      | "resource.start"
-      | "resource.success"
-      | "resource.error"
-      | "resource.skip"
-      | "resource.read";
-    resource: string;
-    status?:
-      | "creating"
-      | "created"
-      | "updating"
-      | "updated"
-      | "deleting"
-      | "deleted";
-    elapsed?: number;
-    error?: SerializedError;
-    replaced?: boolean;
-  }
-
-  export interface CliEvent extends BaseEvent {
-    event: "cli.start" | "cli.success" | "cli.error";
-    command: string;
-  }
-
-  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 | CliEvent;
-  export type EventInput = (
-    | Omit<AppEvent, "timestamp" | "error">
-    | Omit<ResourceEvent, "timestamp" | "error">
-    | Omit<StateStoreEvent, "timestamp" | "error">
-    | Omit<CliEvent, "timestamp" | "error">
-  ) & {
-    error?: ErrorInput;
-  };
-}