aws-cdk 2.1143.0 → 2.1144.0

package/lib/cli/telemetry/sender.d.ts

@@ -0,0 +1,50 @@
+import type { TelemetryBatch } from './post-telemetry';
+import type { ProxyAgentDiagnostics } from '../proxy-agent';
+/**
+ * What the parent hands to this process.
+ */
+export interface TelemetrySenderConfig {
+    /**
+     * Absolute URL to POST the telemetry payload to.
+     */
+    readonly endpoint: string;
+    /**
+     * The batch of events to deliver.
+     */
+    readonly body: TelemetryBatch;
+    /**
+     * Proxy to route through. An empty string means "explicitly no proxy", as `--proxy ''` does.
+     *
+     * @default - resolved from the inherited proxy environment variables, as in the parent
+     */
+    readonly proxyUrl?: string;
+    /**
+     * Absolute path to a CA bundle to trust. The path, not the contents: a system bundle is ~190KB.
+     *
+     * @default - the default Node trust store, plus anything in `NODE_EXTRA_CA_CERTS`
+     */
+    readonly caBundlePath?: string;
+    /**
+     * Budget for the delivery attempt, in milliseconds.
+     *
+     * @default 10000
+     */
+    readonly timeoutMs?: number;
+}
+/**
+ * POST a telemetry payload, routing through a proxy when one applies.
+ *
+ * Returns the status code for the caller to judge, and lets failures reject: every outcome is handled
+ * in one place, in the entry point.
+ */
+export declare function sendTelemetry(cfg: TelemetrySenderConfig): Promise<number | undefined>;
+export declare function isSuccess(statusCode: number | undefined): boolean;
+/**
+ * Diagnostics for the detached child, which has no IoHost.
+ */
+export declare const senderDiagnostics: ProxyAgentDiagnostics;
+/**
+ * Only visible when the parent was run with `CDK_TELEMETRY_SENDER_DEBUG=1`, which is also what makes
+ * it pass this process's stderr through. Synchronous because `process.exit` discards buffered writes.
+ */
+export declare function trace(message: string): void;

package/lib/cli/telemetry/sender.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.senderDiagnostics = void 0;
+exports.sendTelemetry = sendTelemetry;
+exports.isSuccess = isSuccess;
+exports.trace = trace;
+const fs = __importStar(require("node:fs"));
+const post_telemetry_1 = require("./post-telemetry");
+const api_private_error_1 = require("../../api-private-error");
+const proxy_agent_1 = require("../proxy-agent");
+/**
+ * Budget for the delivery attempt.
+ *
+ * Generous because nothing is waiting on it: this process is detached and the CLI has already exited,
+ * so the only thing a longer timeout costs is a background process living a little longer. It has to
+ * cover a proxy handshake plus the POST on a loaded machine.
+ */
+const NETWORK_TIMEOUT_MS = 10_000;
+/**
+ * POST a telemetry payload, routing through a proxy when one applies.
+ *
+ * Returns the status code for the caller to judge, and lets failures reject: every outcome is handled
+ * in one place, in the entry point.
+ */
+async function sendTelemetry(cfg) {
+    if (!cfg?.endpoint) {
+        throw new api_private_error_1.ToolkitError('NoEndpoint', 'No telemetry endpoint was given');
+    }
+    const url = new URL(cfg.endpoint);
+    // The provider the CLI itself uses, so the child routes the way the parent would have, including
+    // SOCKS and PAC proxies and NO_PROXY from the inherited environment.
+    const { agent } = await new proxy_agent_1.ProxyAgentProvider(exports.senderDiagnostics).create({
+        proxyAddress: cfg.proxyUrl,
+        caBundlePath: cfg.caBundlePath,
+    });
+    const res = await (0, post_telemetry_1.postTelemetry)(url, cfg.body ?? { events: [] }, {
+        agent,
+        timeoutMs: cfg.timeoutMs ?? NETWORK_TIMEOUT_MS,
+    });
+    // Drain, or the socket is never released.
+    res.resume();
+    return res.statusCode;
+}
+function isSuccess(statusCode) {
+    return statusCode !== undefined && statusCode >= 200 && statusCode < 300;
+}
+/**
+ * Diagnostics for the detached child, which has no IoHost.
+ */
+exports.senderDiagnostics = {
+    defaults: {
+        debug: async (message) => trace(message),
+    },
+};
+/**
+ * Only visible when the parent was run with `CDK_TELEMETRY_SENDER_DEBUG=1`, which is also what makes
+ * it pass this process's stderr through. Synchronous because `process.exit` discards buffered writes.
+ */
+function trace(message) {
+    if (process.env.CDK_TELEMETRY_SENDER_DEBUG !== '1') {
+        return;
+    }
+    try {
+        fs.writeSync(2, `[cdk-telemetry-sender] ${message}\n`);
+    }
+    catch {
+        // Diagnostics must never be the reason anything fails.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/telemetry/sink/subprocess-sink.d.ts

@@ -0,0 +1,77 @@
+import type { IIoHost } from '../../io-host';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Reports a successful hand-off, NOT a successful delivery.
+ */
+export declare const DISPATCHED_TRACE = "Telemetry dispatched";
+/**
+ * Properties for the subprocess telemetry sink.
+ */
+export interface SubprocessTelemetrySinkProps {
+    /**
+     * The external endpoint to hit
+     */
+    readonly endpoint: string;
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * Proxy the sender should route through, as configured by `--proxy` or the `proxy` setting.
+     *
+     * @default - resolved from the environment by the sender, as `proxy-agent` does for the rest of the CLI
+     */
+    readonly proxyUrl?: string;
+    /**
+     * Absolute path to the CA bundle to trust, as configured by `--ca-bundle-path` or `AWS_CA_BUNDLE`.
+     *
+     * @default - only the system trust store
+     */
+    readonly caBundlePath?: string;
+    /**
+     * How to locate the bundled sender entry point.
+     *
+     * Injectable so a test can exercise the missing-sender path without reaching into this object's
+     * privates; returning undefined is what "not on disk" looks like.
+     *
+     * @default - looked up relative to this package's root
+     */
+    readonly resolveSender?: () => string | undefined;
+}
+/**
+ * A telemetry sink that delivers events from a detached child process.
+ *
+ * Events are written to a temporary file and handed to a child that outlives us, so the CLI can exit
+ * immediately instead of waiting on the network. Nothing here ever learns whether delivery succeeded.
+ *
+ * Deliberately does not check connectivity first: that check would itself be a network call on the
+ * exit path, which is what this sink exists to avoid.
+ */
+export declare class SubprocessTelemetrySink implements ITelemetrySink {
+    private events;
+    private endpoint;
+    private ioHelper;
+    private senderPath?;
+    private proxyUrl?;
+    private caBundlePath?;
+    constructor(props: SubprocessTelemetrySinkProps);
+    /**
+     * Add an event to the collection.
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    /**
+     * Hand whatever has accumulated to a detached sender.
+     *
+     * Clears the batch either way: delivery is one-shot, the process that would retry has usually
+     * exited, and retaining the events would just re-report the failure and regrow the batch every 30s.
+     * This is the single place delivery failures are handled; `dispatch` reports them by throwing.
+     */
+    flush(): Promise<void>;
+    /**
+     * Hand the batch to a detached sender process.
+     *
+     * Throws if the batch could not be handed over.
+     */
+    private dispatch;
+}

package/lib/cli/telemetry/sink/subprocess-sink.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubprocessTelemetrySink = exports.DISPATCHED_TRACE = void 0;
+// eslint-disable-next-line no-restricted-imports -- the detached sender must outlive the CLI; run/runSync from the subprocess tool monitor the child to completion
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const api_private_1 = require("../../../api-private");
+const api_private_error_1 = require("../../../api-private-error");
+const root_dir_1 = require("../../root-dir");
+/**
+ * The bundled sender entry point, relative to this package's root.
+ */
+const SENDER_ENTRY_POINT = path.join('lib', 'cli', 'telemetry', 'sender-bundle.js');
+/**
+ * Reports a successful hand-off, NOT a successful delivery.
+ */
+exports.DISPATCHED_TRACE = 'Telemetry dispatched';
+/**
+ * A telemetry sink that delivers events from a detached child process.
+ *
+ * Events are written to a temporary file and handed to a child that outlives us, so the CLI can exit
+ * immediately instead of waiting on the network. Nothing here ever learns whether delivery succeeded.
+ *
+ * Deliberately does not check connectivity first: that check would itself be a network call on the
+ * exit path, which is what this sink exists to avoid.
+ */
+class SubprocessTelemetrySink {
+    events = [];
+    endpoint;
+    ioHelper;
+    senderPath;
+    proxyUrl;
+    caBundlePath;
+    constructor(props) {
+        this.endpoint = new URL(props.endpoint);
+        if (!this.endpoint.hostname || !this.endpoint.pathname) {
+            throw new api_private_error_1.ToolkitError('MalformedEndpoint', `Telemetry Endpoint malformed. Received hostname: ${this.endpoint.hostname}, pathname: ${this.endpoint.pathname}`);
+        }
+        this.ioHelper = api_private_1.IoHelper.fromActionAwareIoHost(props.ioHost);
+        this.senderPath = (props.resolveSender ?? resolveSenderPath)();
+        this.proxyUrl = props.proxyUrl;
+        this.caBundlePath = props.caBundlePath;
+        // Batch events every 30 seconds
+        setInterval(() => this.flush(), 30000).unref();
+    }
+    /**
+     * Add an event to the collection.
+     */
+    async emit(event) {
+        this.events.push(event);
+    }
+    /**
+     * Hand whatever has accumulated to a detached sender.
+     *
+     * Clears the batch either way: delivery is one-shot, the process that would retry has usually
+     * exited, and retaining the events would just re-report the failure and regrow the batch every 30s.
+     * This is the single place delivery failures are handled; `dispatch` reports them by throwing.
+     */
+    async flush() {
+        if (this.events.length === 0) {
+            return;
+        }
+        const batch = this.events;
+        this.events = [];
+        try {
+            await this.dispatch(this.endpoint, { events: batch });
+        }
+        catch (e) {
+            // Both hand-off failures arrive here: no sender on disk, and a payload write or spawn that
+            // throws. Nothing retries and no fallback runs, so report how much was lost, not only why.
+            await this.ioHelper.defaults.trace(`Failed to send telemetry event: ${e.message}. Dropped ${batch.length} event(s).`);
+        }
+    }
+    /**
+     * Hand the batch to a detached sender process.
+     *
+     * Throws if the batch could not be handed over.
+     */
+    async dispatch(url, body) {
+        if (!this.senderPath) {
+            throw new api_private_error_1.ToolkitError('SenderNotFound', `Unable to locate the telemetry sender at ${SENDER_ENTRY_POINT}`);
+        }
+        const config = {
+            endpoint: url.href,
+            body,
+            proxyUrl: this.proxyUrl,
+            caBundlePath: this.caBundlePath,
+        };
+        const payload = JSON.stringify(config);
+        // A file rather than the child's stdin: writing to stdin blocks the parent once the payload
+        // outgrows the OS pipe buffer, which is the wait this sink exists to avoid.
+        const payloadPath = path.join(os.tmpdir(), `cdk-telemetry-${process.pid}-${(0, node_crypto_1.randomUUID)()}.json`);
+        try {
+            fs.writeFileSync(payloadPath, payload, { encoding: 'utf-8', mode: 0o600 });
+            const child = (0, node_child_process_1.spawn)(process.execPath, [this.senderPath, payloadPath], {
+                detached: true,
+                // Pass the child's diagnostics through only when asked; otherwise nothing reads them.
+                stdio: senderDebugEnabled() ? ['ignore', 'ignore', 'inherit'] : 'ignore',
+                windowsHide: true,
+                shell: false,
+                // Do not hold a reference to the user's working directory; they may want to delete it.
+                cwd: os.tmpdir(),
+            });
+            // Fires after the CLI may already have exited, so it cannot go through the IoHost. Still the
+            // only notification for a spawn that is refused after this method returns.
+            child.on('error', (e) => {
+                debugTrace(`failed to spawn sender: ${e.message}`);
+                tryUnlink(payloadPath);
+            });
+            // Node reports a refused spawn (ENOENT, EACCES, EMFILE) on that `error` event, which fires
+            // after this method has already returned -- it does NOT throw here. libuv does leave `pid`
+            // unset synchronously though, so this is the one point where the failure can still be reported
+            // as one. Without it the batch is counted as handed off and traced with `pid undefined`.
+            if (child.pid === undefined) {
+                throw new api_private_error_1.ToolkitError('SpawnRefused', 'the sender process was never created');
+            }
+            child.unref();
+            await this.ioHelper.defaults.trace(`${exports.DISPATCHED_TRACE} (pid ${child.pid}, ${Buffer.byteLength(payload)} bytes)`);
+        }
+        catch (e) {
+            tryUnlink(payloadPath);
+            throw new api_private_error_1.ToolkitError('DispatchFailed', `Spawning a sender for POST ${url.hostname}${url.pathname} failed: ${e.message}`);
+        }
+    }
+}
+exports.SubprocessTelemetrySink = SubprocessTelemetrySink;
+/**
+ * Locate the bundled sender entry point inside this package.
+ *
+ * Walks up to the package root, which works both from `lib/` in source and from the released bundle.
+ * `process.argv[1]` is deliberately NOT used: it may be the `.bin/cdk` symlink, the `cdk` alias
+ * package's wrapper, or -- when the CLI is driven programmatically -- somebody else's script.
+ *
+ * Returns undefined if the entry point is not on disk, in which case telemetry is skipped.
+ */
+function resolveSenderPath() {
+    const root = (0, root_dir_1.cliRootDir)(false);
+    if (!root) {
+        return undefined;
+    }
+    const senderPath = path.join(root, SENDER_ENTRY_POINT);
+    return fs.existsSync(senderPath) ? senderPath : undefined;
+}
+function tryUnlink(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // Nothing useful to do about it; the OS cleans its own temp directory.
+    }
+}
+/**
+ * Whether the user asked to see the sender's diagnostics.
+ */
+function senderDebugEnabled() {
+    return process.env.CDK_TELEMETRY_SENDER_DEBUG === '1';
+}
+/**
+ * Diagnostics for failures that surface after the CLI may already have exited, so they cannot go
+ * through the IoHost. Gated behind the same variable as the sender's own traces.
+ */
+function debugTrace(message) {
+    if (!senderDebugEnabled()) {
+        return;
+    }
+    try {
+        fs.writeSync(2, `[cdk-telemetry-dispatch] ${message}\n`);
+    }
+    catch {
+        // Diagnostics must never be the reason anything fails.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subprocess-sink.js","sourceRoot":"","sources":["subprocess-sink.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line no-restricted-imports -- the detached sender must outlive the CLI; run/runSync from the subprocess tool monitor the child to completion\nimport { spawn } from 'node:child_process';\nimport { randomUUID } from 'node:crypto';\nimport * as fs from 'node:fs';\nimport * as os from 'node:os';\nimport * as path from 'node:path';\nimport { IoHelper } from '../../../api-private';\nimport { ToolkitError } from '../../../api-private-error';\nimport type { IIoHost } from '../../io-host';\nimport { cliRootDir } from '../../root-dir';\nimport type { TelemetryBatch } from '../post-telemetry';\nimport type { TelemetrySchema } from '../schema';\nimport type { TelemetrySenderConfig } from '../sender';\nimport type { ITelemetrySink } from './sink-interface';\n\n/**\n * The bundled sender entry point, relative to this package's root.\n */\nconst SENDER_ENTRY_POINT = path.join('lib', 'cli', 'telemetry', 'sender-bundle.js');\n\n/**\n * Reports a successful hand-off, NOT a successful delivery.\n */\nexport const DISPATCHED_TRACE = 'Telemetry dispatched';\n\n/**\n * Properties for the subprocess telemetry sink.\n */\nexport interface SubprocessTelemetrySinkProps {\n  /**\n   * The external endpoint to hit\n   */\n  readonly endpoint: string;\n\n  /**\n   * Where messages are going to be sent\n   */\n  readonly ioHost: IIoHost;\n\n  /**\n   * Proxy the sender should route through, as configured by `--proxy` or the `proxy` setting.\n   *\n   * @default - resolved from the environment by the sender, as `proxy-agent` does for the rest of the CLI\n   */\n  readonly proxyUrl?: string;\n\n  /**\n   * Absolute path to the CA bundle to trust, as configured by `--ca-bundle-path` or `AWS_CA_BUNDLE`.\n   *\n   * @default - only the system trust store\n   */\n  readonly caBundlePath?: string;\n\n  /**\n   * How to locate the bundled sender entry point.\n   *\n   * Injectable so a test can exercise the missing-sender path without reaching into this object's\n   * privates; returning undefined is what \"not on disk\" looks like.\n   *\n   * @default - looked up relative to this package's root\n   */\n  readonly resolveSender?: () => string | undefined;\n}\n\n/**\n * A telemetry sink that delivers events from a detached child process.\n *\n * Events are written to a temporary file and handed to a child that outlives us, so the CLI can exit\n * immediately instead of waiting on the network. Nothing here ever learns whether delivery succeeded.\n *\n * Deliberately does not check connectivity first: that check would itself be a network call on the\n * exit path, which is what this sink exists to avoid.\n */\nexport class SubprocessTelemetrySink implements ITelemetrySink {\n  private events: TelemetrySchema[] = [];\n  private endpoint: URL;\n  private ioHelper: IoHelper;\n  private senderPath?: string;\n  private proxyUrl?: string;\n  private caBundlePath?: string;\n\n  public constructor(props: SubprocessTelemetrySinkProps) {\n    this.endpoint = new URL(props.endpoint);\n\n    if (!this.endpoint.hostname || !this.endpoint.pathname) {\n      throw new ToolkitError('MalformedEndpoint', `Telemetry Endpoint malformed. Received hostname: ${this.endpoint.hostname}, pathname: ${this.endpoint.pathname}`);\n    }\n\n    this.ioHelper = IoHelper.fromActionAwareIoHost(props.ioHost);\n    this.senderPath = (props.resolveSender ?? resolveSenderPath)();\n    this.proxyUrl = props.proxyUrl;\n    this.caBundlePath = props.caBundlePath;\n\n    // Batch events every 30 seconds\n    setInterval(() => this.flush(), 30000).unref();\n  }\n\n  /**\n   * Add an event to the collection.\n   */\n  public async emit(event: TelemetrySchema): Promise<void> {\n    this.events.push(event);\n  }\n\n  /**\n   * Hand whatever has accumulated to a detached sender.\n   *\n   * Clears the batch either way: delivery is one-shot, the process that would retry has usually\n   * exited, and retaining the events would just re-report the failure and regrow the batch every 30s.\n   * This is the single place delivery failures are handled; `dispatch` reports them by throwing.\n   */\n  public async flush(): Promise<void> {\n    if (this.events.length === 0) {\n      return;\n    }\n\n    const batch = this.events;\n    this.events = [];\n\n    try {\n      await this.dispatch(this.endpoint, { events: batch });\n    } catch (e: any) {\n      // Both hand-off failures arrive here: no sender on disk, and a payload write or spawn that\n      // throws. Nothing retries and no fallback runs, so report how much was lost, not only why.\n      await this.ioHelper.defaults.trace(`Failed to send telemetry event: ${e.message}. Dropped ${batch.length} event(s).`);\n    }\n  }\n\n  /**\n   * Hand the batch to a detached sender process.\n   *\n   * Throws if the batch could not be handed over.\n   */\n  private async dispatch(url: URL, body: TelemetryBatch): Promise<void> {\n    if (!this.senderPath) {\n      throw new ToolkitError('SenderNotFound', `Unable to locate the telemetry sender at ${SENDER_ENTRY_POINT}`);\n    }\n\n    const config: TelemetrySenderConfig = {\n      endpoint: url.href,\n      body,\n      proxyUrl: this.proxyUrl,\n      caBundlePath: this.caBundlePath,\n    };\n    const payload = JSON.stringify(config);\n\n    // A file rather than the child's stdin: writing to stdin blocks the parent once the payload\n    // outgrows the OS pipe buffer, which is the wait this sink exists to avoid.\n    const payloadPath = path.join(os.tmpdir(), `cdk-telemetry-${process.pid}-${randomUUID()}.json`);\n\n    try {\n      fs.writeFileSync(payloadPath, payload, { encoding: 'utf-8', mode: 0o600 });\n\n      const child = spawn(process.execPath, [this.senderPath, payloadPath], {\n        detached: true,\n        // Pass the child's diagnostics through only when asked; otherwise nothing reads them.\n        stdio: senderDebugEnabled() ? ['ignore', 'ignore', 'inherit'] : 'ignore',\n        windowsHide: true,\n        shell: false,\n        // Do not hold a reference to the user's working directory; they may want to delete it.\n        cwd: os.tmpdir(),\n      });\n\n      // Fires after the CLI may already have exited, so it cannot go through the IoHost. Still the\n      // only notification for a spawn that is refused after this method returns.\n      child.on('error', (e: Error) => {\n        debugTrace(`failed to spawn sender: ${e.message}`);\n        tryUnlink(payloadPath);\n      });\n\n      // Node reports a refused spawn (ENOENT, EACCES, EMFILE) on that `error` event, which fires\n      // after this method has already returned -- it does NOT throw here. libuv does leave `pid`\n      // unset synchronously though, so this is the one point where the failure can still be reported\n      // as one. Without it the batch is counted as handed off and traced with `pid undefined`.\n      if (child.pid === undefined) {\n        throw new ToolkitError('SpawnRefused', 'the sender process was never created');\n      }\n\n      child.unref();\n\n      await this.ioHelper.defaults.trace(`${DISPATCHED_TRACE} (pid ${child.pid}, ${Buffer.byteLength(payload)} bytes)`);\n    } catch (e: any) {\n      tryUnlink(payloadPath);\n      throw new ToolkitError('DispatchFailed', `Spawning a sender for POST ${url.hostname}${url.pathname} failed: ${e.message}`);\n    }\n  }\n}\n\n/**\n * Locate the bundled sender entry point inside this package.\n *\n * Walks up to the package root, which works both from `lib/` in source and from the released bundle.\n * `process.argv[1]` is deliberately NOT used: it may be the `.bin/cdk` symlink, the `cdk` alias\n * package's wrapper, or -- when the CLI is driven programmatically -- somebody else's script.\n *\n * Returns undefined if the entry point is not on disk, in which case telemetry is skipped.\n */\nfunction resolveSenderPath(): string | undefined {\n  const root = cliRootDir(false);\n  if (!root) {\n    return undefined;\n  }\n\n  const senderPath = path.join(root, SENDER_ENTRY_POINT);\n  return fs.existsSync(senderPath) ? senderPath : undefined;\n}\n\nfunction tryUnlink(filePath: string): void {\n  try {\n    fs.unlinkSync(filePath);\n  } catch {\n    // Nothing useful to do about it; the OS cleans its own temp directory.\n  }\n}\n\n/**\n * Whether the user asked to see the sender's diagnostics.\n */\nfunction senderDebugEnabled(): boolean {\n  return process.env.CDK_TELEMETRY_SENDER_DEBUG === '1';\n}\n\n/**\n * Diagnostics for failures that surface after the CLI may already have exited, so they cannot go\n * through the IoHost. Gated behind the same variable as the sender's own traces.\n */\nfunction debugTrace(message: string): void {\n  if (!senderDebugEnabled()) {\n    return;\n  }\n  try {\n    fs.writeSync(2, `[cdk-telemetry-dispatch] ${message}\\n`);\n  } catch {\n    // Diagnostics must never be the reason anything fails.\n  }\n}\n"]}