alchemy 2.0.0-beta.18 → 2.0.0-beta.19

package/bin/alchemy.ts

@@ -7,6 +7,7 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import packageJson from "../package.json" with { type: "json" };
 import { AlchemyContextLive } from "../src/AlchemyContext.ts";
 import { inkCLI } from "../src/Cli/InkCLI.tsx";
+import { TelemetryLive } from "../src/Telemetry/Layer.ts";
 import { PlatformServices, runMain } from "../src/Util/PlatformServices.ts";
 
 import { handleCancellation } from "./commands/_shared.ts";
@@ -45,6 +46,7 @@ const services = Layer.mergeAll(
   Layer.provideMerge(AlchemyContextLive, PlatformServices),
   FetchHttpClient.layer,
   ConfigProvider.layer(ConfigProvider.fromEnv()),
+  TelemetryLive,
   inkCLI(),
 );
 

package/bin/commands/_shared.ts

@@ -11,6 +11,7 @@ import * as Flag from "effect/unstable/cli/Flag";
 
 import { AuthError } from "../../src/Auth/AuthProvider.ts";
 import type * as Stack from "../../src/Stack.ts";
+import { recordCli } from "../../src/Telemetry/Metrics.ts";
 import { PromptCancelled } from "../../src/Util/Clank.ts";
 
 export const USER = Config.string("USER").pipe(
@@ -218,6 +219,39 @@ export const parseSince = (value: string): Date => {
   return parsed;
 };
 
+/**
+ * Wraps a CLI command handler with a top-level OpenTelemetry span
+ * (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
+ *
+ * `attrs` runs against the parsed command args and contributes
+ * additional attributes to the span (e.g. stage, profile, dry-run flag).
+ *
+ * Usage:
+ * ```ts
+ * Command.make(
+ *   "deploy",
+ *   { ...flags },
+ *   instrumentCommand("deploy", (a) => ({
+ *     "alchemy.stage": a.stage,
+ *     "alchemy.profile": a.profile,
+ *   }))(execStack),
+ * );
+ * ```
+ */
+export const instrumentCommand =
+  <Args>(
+    command: string,
+    attrs: (args: Args) => Record<string, unknown> = () => ({}),
+  ) =>
+  <A, E, R>(
+    handler: (args: Args) => Effect.Effect<A, E, R>,
+  ): ((args: Args) => Effect.Effect<A, E, R>) =>
+  (args) =>
+    handler(args).pipe(
+      Effect.withSpan(`cli.${command}`, { attributes: attrs(args) }),
+      recordCli(command),
+    );
+
 export const importStack = Effect.fn(function* (main: string) {
   const path = yield* Path.Path;
   const module = yield* Effect.promise(

package/bin/commands/bootstrap.ts

@@ -21,7 +21,7 @@ import * as AWSRegion from "../../src/AWS/Region.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile } from "./_shared.ts";
+import { envFile, instrumentCommand } from "./_shared.ts";
 
 const awsProfile = Flag.string("profile").pipe(
   Flag.withDescription("AWS profile to use for credentials"),
@@ -50,7 +50,14 @@ export const bootstrapCommand = Command.make(
     region: awsRegion,
     destroy: bootstrapDestroy,
   },
-  Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
+  instrumentCommand(
+    "bootstrap",
+    (a: { profile: string; region: string | undefined; destroy: boolean }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.region": a.region ?? "",
+      "alchemy.destroy": a.destroy,
+    }),
+  )(Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
     const logger = Logger.layer([fileLogger("bootstrap.txt")]);
 
     return yield* Effect.gen(function* () {
@@ -113,5 +120,5 @@ export const bootstrapCommand = Command.make(
         );
       });
     }).pipe(Effect.provide(logger));
-  }),
+  })),
 );

package/bin/commands/deploy.ts

@@ -21,12 +21,30 @@ import {
   envFile,
   force,
   importStack,
+  instrumentCommand,
   main,
   profile,
   stage,
   yes,
 } from "./_shared.ts";
 
+const stackSpanAttrs = (args: {
+  main: string;
+  stage: string;
+  profile: string;
+  dryRun?: boolean;
+  force?: boolean;
+  yes?: boolean;
+  destroy?: boolean;
+}) => ({
+  "alchemy.stage": args.stage,
+  "alchemy.profile": args.profile,
+  "alchemy.main": args.main,
+  "alchemy.dry_run": !!args.dryRun,
+  "alchemy.force": !!args.force,
+  "alchemy.destroy": !!args.destroy,
+});
+
 const execStack = Effect.fn(function* ({
   main,
   stage,
@@ -118,7 +136,7 @@ export const deployCommand = Command.make(
     yes,
     profile,
   },
-  execStack,
+  instrumentCommand("deploy", stackSpanAttrs)(execStack),
 );
 
 export const destroyCommand = Command.make(
@@ -131,11 +149,12 @@ export const destroyCommand = Command.make(
     yes,
     profile,
   },
-  (args) =>
+  instrumentCommand("destroy", stackSpanAttrs)((args) =>
     execStack({
       ...args,
       destroy: true,
     }),
+  ),
 );
 
 export const planCommand = Command.make(
@@ -146,10 +165,11 @@ export const planCommand = Command.make(
     stage,
     profile,
   },
-  (args) =>
+  instrumentCommand("plan", stackSpanAttrs)((args) =>
     execStack({
       ...args,
       // plan is the same as deploy with dryRun always set to true
       dryRun: true,
     }),
+  ),
 );

package/bin/commands/login.ts

@@ -18,7 +18,14 @@ import * as State from "../../src/State/index.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, importStack, main, profile, stage } from "./_shared.ts";
+import {
+  envFile,
+  importStack,
+  instrumentCommand,
+  main,
+  profile,
+  stage,
+} from "./_shared.ts";
 
 const loginConfigure = Flag.boolean("configure").pipe(
   Flag.withDescription(
@@ -36,7 +43,15 @@ export const loginCommand = Command.make(
     profile,
     configure: loginConfigure,
   },
-  Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
+  instrumentCommand(
+    "login",
+    (a: { main: string; stage: string; profile: string; configure: boolean }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+      "alchemy.configure": a.configure,
+    }),
+  )(Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
     const stackEffect = yield* importStack(main);
 
     const authProviders: AuthProviders["Service"] = {};
@@ -92,5 +107,5 @@ export const loginCommand = Command.make(
         { discard: true },
       );
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/bin/commands/logs.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   formatLocalTimestamp,
   importStack,
+  instrumentCommand,
   main,
   parseResourceFilter,
   parseSince,
@@ -52,7 +53,15 @@ export const logsCommand = Command.make(
     limit: logsLimit,
     since: logsSince,
   },
-  Effect.fnUntraced(function* ({
+  instrumentCommand(
+    "logs",
+    (a: { main: string; stage: string; profile: string; limit: number }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+      "alchemy.limit": a.limit,
+    }),
+  )(Effect.fnUntraced(function* ({
     main,
     stage,
     envFile,
@@ -153,5 +162,5 @@ export const logsCommand = Command.make(
         }
       }).pipe(Effect.provide(stack.services));
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/bin/commands/profile.ts

@@ -18,12 +18,15 @@ import { CloudflareAuth } from "../../src/Cloudflare/Auth/AuthProvider.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, profile } from "./_shared.ts";
+import { envFile, instrumentCommand, profile } from "./_shared.ts";
 
 const showCommand = Command.make(
   "show",
   { profile, envFile },
-  Effect.fnUntraced(function* ({ profile, envFile }) {
+  instrumentCommand(
+    "profile.show",
+    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
+  )(Effect.fnUntraced(function* ({ profile, envFile }) {
     const stored = yield* getProfile(profile);
     if (stored == null) {
       const config = yield* readConfig;
@@ -80,13 +83,16 @@ const showCommand = Command.make(
         yield* provider.prettyPrint(profile, cfg);
       }
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );
 
 const clearCommand = Command.make(
   "clear",
   { profile },
-  Effect.fnUntraced(function* ({ profile }) {
+  instrumentCommand(
+    "profile.clear",
+    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
+  )(Effect.fnUntraced(function* ({ profile }) {
     const removed = yield* deleteProfile(profile);
     yield* deleteProfileCredentials(profile);
     if (removed) {
@@ -98,7 +104,7 @@ const clearCommand = Command.make(
         `Profile '${profile}' not found in profiles.json; removed any stray credentials directory.`,
       );
     }
-  }),
+  })),
 );
 
 export const profileCommand = Command.make("profile", {}).pipe(

package/bin/commands/state.ts

@@ -15,7 +15,15 @@ import * as Clank from "../../src/Util/Clank.ts";
 import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
 import { fileLogger } from "../../src/Util/FileLogger.ts";
 
-import { envFile, importStack, main, profile, stage, yes } from "./_shared.ts";
+import {
+  envFile,
+  importStack,
+  instrumentCommand,
+  main,
+  profile,
+  stage,
+  yes,
+} from "./_shared.ts";
 
 /**
  * When set, the State service is replaced with the on-disk
@@ -91,7 +99,7 @@ const withStateService = <A, E>(
 const stacksCommand = Command.make(
   "stacks",
   { main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* (args) {
+  instrumentCommand("state.stacks")(Effect.fnUntraced(function* (args) {
     yield* withStateService(args, (state) =>
       Effect.gen(function* () {
         const stacks = yield* state.listStacks();
@@ -104,13 +112,13 @@ const stacksCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const stagesCommand = Command.make(
   "stages",
   { stack: stackArg, main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* ({ stack: stackName, ...rest }) {
+  instrumentCommand("state.stages")(Effect.fnUntraced(function* ({ stack: stackName, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const stages = yield* state.listStages(stackName);
@@ -123,7 +131,7 @@ const stagesCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const resourcesCommand = Command.make(
@@ -139,7 +147,7 @@ const resourcesCommand = Command.make(
     profile,
     local: localFlag,
   },
-  Effect.fnUntraced(function* ({ stack: stackName, stageName, ...rest }) {
+  instrumentCommand("state.resources")(Effect.fnUntraced(function* ({ stack: stackName, stageName, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const fqns = yield* state.list({ stack: stackName, stage: stageName });
@@ -152,7 +160,7 @@ const resourcesCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const getCommand = Command.make(
@@ -169,7 +177,7 @@ const getCommand = Command.make(
     profile,
     local: localFlag,
   },
-  Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn, ...rest }) {
+  instrumentCommand("state.get")(Effect.fnUntraced(function* ({ stack: stackName, stageName, fqn, ...rest }) {
     yield* withStateService(rest, (state) =>
       Effect.gen(function* () {
         const value = yield* state.get({
@@ -187,13 +195,13 @@ const getCommand = Command.make(
         yield* Console.log(JSON.stringify(encodeState(value), null, 2));
       }),
     );
-  }),
+  })),
 );
 
 const treeCommand = Command.make(
   "tree",
   { main, envFile, stage, profile, local: localFlag },
-  Effect.fnUntraced(function* (args) {
+  instrumentCommand("state.tree")(Effect.fnUntraced(function* (args) {
     yield* withStateService(args, (state) =>
       Effect.gen(function* () {
         const stacks = [...(yield* state.listStacks())].sort();
@@ -221,7 +229,7 @@ const treeCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 const clearStackArg = Argument.string("stack").pipe(
@@ -255,7 +263,7 @@ const clearCommand = Command.make(
     local: localFlag,
     yes,
   },
-  Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag, ...rest }) {
+  instrumentCommand("state.clear")(Effect.fnUntraced(function* ({ stack: stackOpt, stageName: stageOpt, yes: yesFlag, ...rest }) {
     const stackName = Option.getOrUndefined(stackOpt);
     const stageName = Option.getOrUndefined(stageOpt);
 
@@ -308,7 +316,7 @@ const clearCommand = Command.make(
         }
       }),
     );
-  }),
+  })),
 );
 
 export const stateCommand = Command.make("state", {}).pipe(

package/bin/commands/tail.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   formatLocalTimestamp,
   importStack,
+  instrumentCommand,
   main,
   parseResourceFilter,
   profile,
@@ -36,7 +37,14 @@ export const tailCommand = Command.make(
     profile,
     filter: resourceFilter,
   },
-  Effect.fnUntraced(function* ({ main, stage, envFile, profile, filter }) {
+  instrumentCommand(
+    "tail",
+    (a: { main: string; stage: string; profile: string }) => ({
+      "alchemy.stage": a.stage,
+      "alchemy.profile": a.profile,
+      "alchemy.main": a.main,
+    }),
+  )(Effect.fnUntraced(function* ({ main, stage, envFile, profile, filter }) {
     const stackEffect = yield* importStack(main);
 
     const services = Layer.mergeAll(
@@ -134,5 +142,5 @@ export const tailCommand = Command.make(
         }).pipe(Stream.runForEach((line) => Console.log(line)));
       }).pipe(Effect.provide(stack.services));
     }).pipe(Effect.provide(services));
-  }),
+  })),
 );

package/lib/Agent/lsp/client.d.ts

@@ -96,9 +96,9 @@ export declare const makeLSPClient: (id: string, proc: Subprocess, root: string)
                 readonly character: number;
             };
         };
+        readonly source?: string | undefined;
         readonly code?: string | number | undefined;
         readonly severity?: number | undefined;
-        readonly source?: string | undefined;
     }[], never, never>;
     getDiagnostics: (path: string) => Effect.Effect<never[] | {
         readonly message: string;
@@ -112,9 +112,9 @@ export declare const makeLSPClient: (id: string, proc: Subprocess, root: string)
                 readonly character: number;
             };
         };
+        readonly source?: string | undefined;
         readonly code?: string | number | undefined;
         readonly severity?: number | undefined;
-        readonly source?: string | undefined;
     }[], never, never>;
     onDiagnostics: (callback: (uri: string, diagnostics: Diagnostic[]) => Effect.Effect<void>) => Effect.Effect<void, never, never>;
     shutdown: Effect.Effect<void, never, never>;

package/lib/Apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Apply.d.ts","sourceRoot":"","sources":["../src/Apply.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAQ7C,OAAO,EAGL,GAAG,EACJ,MAAM,cAAc,CAAC;AAItB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,EAAc,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAG/D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EASL,KAAK,EACL,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,IAAI,EACd,GAAG,GAAG,KAAK,EACX,GAAG,GAAG,KAAK,IACT,MAAM,CAAC,MAAM,CACf;KACG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,EACD,GAAG,EACH,GAAG,CACJ,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,IAAI,IAAI;KACvC,EAAE,IAAI,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,SAC5C,MAAM,GACN,SAAS,GACT,KAAK,GACL,KAAK,GACL,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;CACrD,CAAC;AAwBF,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,IAAI,EAClC,MAAM,CAAC,KACN,MAAM,CAAC,MAAM,CACd,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAC1B,MAAM,CAAC,qBAAqB,GAAG,MAAM,CAAC,kBAAkB,GAAG,eAAe,EAC1E,GAAG,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CA+DC,CAAC"}
+{"version":3,"file":"Apply.d.ts","sourceRoot":"","sources":["../src/Apply.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAQ7C,OAAO,EAGL,GAAG,EACJ,MAAM,cAAc,CAAC;AAItB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,EAAc,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAG/D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EASL,KAAK,EACL,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,IAAI,EACd,GAAG,GAAG,KAAK,EACX,GAAG,GAAG,KAAK,IACT,MAAM,CAAC,MAAM,CACf;KACG,CAAC,IAAI,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,EACD,GAAG,EACH,GAAG,CACJ,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,IAAI,IAAI;KACvC,EAAE,IAAI,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,SAC5C,MAAM,GACN,SAAS,GACT,KAAK,GACL,KAAK,GACL,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;CACrD,CAAC;AA2DF,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,IAAI,EAClC,MAAM,CAAC,KACN,MAAM,CAAC,MAAM,CACd,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAC1B,MAAM,CAAC,qBAAqB,GAAG,MAAM,CAAC,kBAAkB,GAAG,eAAe,EAC1E,GAAG,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAuE1B,CAAC"}

package/lib/Apply.js

@@ -11,8 +11,28 @@ import {} from "./Plan.js";
 import { findProviderByType } from "./Provider.js";
 import { Stack } from "./Stack.js";
 import { Stage } from "./Stage.js";
+import { recordResourceOp } from "./Telemetry/Metrics.js";
 import { State, StateStoreError, } from "./State/index.js";
 const provideLifecycleScope = (fqn, instanceId) => (effect) => Effect.serviceOption(ArtifactStore).pipe(Effect.map(Option.getOrElse(createArtifactStore)), Effect.flatMap((store) => effect.pipe(Effect.provideService(Artifacts, makeScopedArtifacts(store, fqn)), Effect.provideService(InstanceId, instanceId))));
+/**
+ * Instruments a single provider lifecycle call with an OTel span
+ * (`provider.<op>`), the resource counter / duration histogram, and the
+ * scoped artifacts/instance services normally supplied by
+ * {@link provideLifecycleScope}.
+ *
+ * This is the only call site through which provider lifecycle methods
+ * are dispatched, so wrapping it here gives us a fully-instrumented
+ * toolchain without touching any individual provider implementation.
+ */
+const instrumentLifecycle = (op, fqn, resourceType, logicalId, instanceId) => (effect) => effect.pipe(provideLifecycleScope(fqn, instanceId), recordResourceOp(resourceType, op), Effect.withSpan(`provider.${op}`, {
+    attributes: {
+        "alchemy.resource.fqn": fqn,
+        "alchemy.resource.type": resourceType,
+        "alchemy.resource.logical_id": logicalId,
+        "alchemy.resource.instance_id": instanceId,
+        "alchemy.resource.op": op,
+    },
+}));
 export const apply = (plan) => Effect.gen(function* () {
     const cli = yield* Cli;
     const session = yield* cli.startApplySession(plan);
@@ -35,7 +55,12 @@ export const apply = (plan) => Effect.gen(function* () {
     }
     const outputs = Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
     return yield* Output.evaluate(plan.output, outputs);
-}).pipe(ensureArtifactStore);
+}).pipe(ensureArtifactStore, Effect.withSpan("apply", {
+    attributes: {
+        "alchemy.resources.count": Object.keys(plan.resources).length,
+        "alchemy.deletions.count": Object.keys(plan.deletions).length,
+    },
+}));
 // ── Phase 1: concurrent initial execution ──────────────────────────────────
 //
 // Each resource gets a Deferred<void> that signals "I have some output
@@ -189,7 +214,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
                     instanceId,
                     bindings: excludeDeletedBindings(node.bindings),
                 })
-                    .pipe(provideLifecycleScope(fqn, instanceId));
+                    .pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
                 yield* commit({
                     status: "creating",
                     fqn,
@@ -226,7 +251,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
                 session: scopedSession,
                 output: attr,
             })
-                .pipe(provideLifecycleScope(fqn, instanceId));
+                .pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
             yield* commit({
                 status: "created",
                 fqn,
@@ -307,7 +332,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
                 // @ts-expect-error - type system says this can be undefined, can it be?
                 output: node.state.attr,
             })
-                .pipe(provideLifecycleScope(fqn, instanceId));
+                .pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
             if (node.state.status === "replaced") {
                 yield* commit({
                     // The live replacement changed, but cleanup of older generations still
@@ -401,7 +426,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
                     instanceId,
                     bindings: excludeDeletedBindings(node.bindings),
                 })
-                    .pipe(provideLifecycleScope(fqn, instanceId));
+                    .pipe(instrumentLifecycle("precreate", fqn, node.resource.Type, logicalId, instanceId));
                 yield* commit({
                     status: "replacing",
                     fqn,
@@ -440,7 +465,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
                 session: scopedSession,
                 output: attr,
             })
-                .pipe(provideLifecycleScope(fqn, instanceId));
+                .pipe(instrumentLifecycle("create", fqn, node.resource.Type, logicalId, instanceId));
             yield* commit({
                 // Creation of the new generation succeeded; from here on the only remaining
                 // work is draining the old chain via garbage collection.
@@ -475,7 +500,14 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
         // @ts-expect-error - node is never, this should be unreachable
         return yield* Effect.die(`Unknown action: ${node.action}`);
     });
-});
+}).pipe(Effect.withSpan("apply.resource", {
+    attributes: {
+        "alchemy.resource.fqn": fqn,
+        "alchemy.resource.type": node.resource.Type,
+        "alchemy.resource.logical_id": node.resource.LogicalId,
+        "alchemy.resource.action": node.action,
+    },
+}));
 // ── Phase 3: imperative convergence loop ───────────────────────────────────
 //
 // After the initial concurrent pass, some resources may have been created
@@ -519,7 +551,7 @@ const converge = Effect.fnUntraced(function* (plan, tracker, terminalStatuses, s
                 olds: oldProps,
                 output: tracker[fqn].output,
             })
-                .pipe(provideLifecycleScope(fqn, instanceId));
+                .pipe(instrumentLifecycle("update", fqn, node.resource.Type, logicalId, instanceId));
             tracker[fqn] = {
                 output: attr,
                 props: newProps,
@@ -647,7 +679,7 @@ const collectGarbage = Effect.fnUntraced(function* (plan, session) {
                         session: scopedSession,
                         bindings: [],
                     })
-                        .pipe(provideLifecycleScope(fqn, instanceId));
+                        .pipe(instrumentLifecycle("delete", fqn, resourceType, logicalId, instanceId));
                 }
                 if (isDeleteNode(node)) {
                     yield* state.delete({