@depup/aws-cdk 2.1117.0-depup.0

package/lib/cli/telemetry/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,67 @@
+import { type EventType, type ErrorDetails } from './schema';
+import type { ITelemetrySink } from './sink/sink-interface';
+import type { Context } from '../../api/context';
+import type { CliIoHost } from '../io-host/cli-io-host';
+export interface TelemetrySessionProps {
+    readonly ioHost: CliIoHost;
+    readonly client: ITelemetrySink;
+    readonly arguments: any;
+    readonly context: Context;
+}
+export interface TelemetryEvent {
+    readonly eventType: EventType;
+    readonly duration: number;
+    readonly error?: ErrorDetails;
+    readonly counters?: Record<string, number>;
+}
+/**
+ * Timer of a single event
+ */
+export interface Timing {
+    /**
+     * Total time spent in this operation
+     */
+    totalMs: number;
+    /**
+     * Count of operations that together took `totalMs`.
+     */
+    count: number;
+}
+export declare class TelemetrySession {
+    private readonly props;
+    private ioHost;
+    private client;
+    private _sessionInfo?;
+    private span?;
+    private count;
+    constructor(props: TelemetrySessionProps);
+    begin(): Promise<void>;
+    attachRegion(region: string): Promise<void>;
+    /**
+     * Attach a language guess
+     */
+    attachLanguage(language: string | undefined): void;
+    /**
+     * Attach our best guess at running under an agent or not
+     */
+    attachAgent(isAgent: boolean | undefined): void;
+    /**
+     * Attach the CDK library version
+     *
+     * By default the telemetry will guess at the CDK library version if it so
+     * happens that the CDK project is an NPM project and the CDK CLI is executed
+     * in the root of NPM project with `aws-cdk-lib` available in `node_modules`.
+     * This may succeed or may fail.
+     *
+     * Once we have produced and loaded the cloud assembly more accurate
+     * information becomes available that we can add in.
+     */
+    attachCdkLibVersion(libVersion: string): void;
+    /**
+     * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost
+     * and notifies with an optional error message in the data.
+     */
+    end(error?: ErrorDetails): Promise<void>;
+    emit(event: TelemetryEvent): Promise<void>;
+    private get sessionInfo();
+}

package/lib/cli/telemetry/session.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetrySession = void 0;
+const crypto_1 = require("crypto");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const installation_id_1 = require("./installation-id");
+const library_version_1 = require("./library-version");
+const sanitation_1 = require("./sanitation");
+const ci_systems_1 = require("../ci-systems");
+const messages_1 = require("../telemetry/messages");
+const ci_1 = require("../util/ci");
+const version_1 = require("../version");
+const error_1 = require("./error");
+const ABORTED_ERROR_MESSAGE = '__CDK-Toolkit__Aborted';
+class TelemetrySession {
+    constructor(props) {
+        this.props = props;
+        this.count = 0;
+        this.ioHost = props.ioHost;
+        this.client = props.client;
+    }
+    async begin() {
+        // sanitize the raw cli input
+        const { path, parameters } = (0, sanitation_1.sanitizeCommandLineArguments)(this.props.arguments);
+        this._sessionInfo = {
+            identifiers: {
+                installationId: await (0, installation_id_1.getOrCreateInstallationId)(this.ioHost.asIoHelper()),
+                sessionId: (0, crypto_1.randomUUID)(),
+                telemetryVersion: '2.0',
+                cdkCliVersion: (0, version_1.versionNumber)(),
+                cdkLibraryVersion: await (0, library_version_1.getLibraryVersion)(this.ioHost.asIoHelper()),
+            },
+            event: {
+                command: {
+                    path,
+                    parameters,
+                    config: {
+                        context: (0, sanitation_1.sanitizeContext)(this.props.context),
+                    },
+                },
+            },
+            environment: {
+                ci: (0, ci_1.isCI)() || Boolean((0, ci_systems_1.detectCiSystem)()),
+                os: {
+                    platform: process.platform,
+                    release: process.release.name,
+                },
+                nodeVersion: process.version,
+            },
+            project: {},
+        };
+        // If SIGINT has a listener installed, its default behavior will be removed (Node.js will no longer exit).
+        // This ensures that on SIGINT we process safely close the telemetry session before exiting.
+        process.on('SIGINT', async () => {
+            try {
+                await this.end({
+                    name: error_1.USER_INTERRUPTED_CODE,
+                    message: ABORTED_ERROR_MESSAGE,
+                });
+            }
+            catch (e) {
+                await this.ioHost.defaults.trace(`Ending Telemetry failed: ${e.message}`);
+            }
+            process.exit(1);
+        });
+        // Begin the session span
+        this.span = await this.ioHost.asIoHelper().span(messages_1.CLI_PRIVATE_SPAN.COMMAND).begin({});
+    }
+    async attachRegion(region) {
+        this.sessionInfo.identifiers = {
+            ...this.sessionInfo.identifiers,
+            region,
+        };
+    }
+    /**
+     * Attach a language guess
+     */
+    attachLanguage(language) {
+        // Don't want to crash accidentally
+        if (!this._sessionInfo) {
+            return;
+        }
+        if (language) {
+            mutable(this.sessionInfo.project).language = language;
+        }
+    }
+    /**
+     * Attach our best guess at running under an agent or not
+     */
+    attachAgent(isAgent) {
+        // Don't want to crash accidentally
+        if (!this._sessionInfo) {
+            return;
+        }
+        mutable(this.sessionInfo.environment).agent = isAgent;
+    }
+    /**
+     * Attach the CDK library version
+     *
+     * By default the telemetry will guess at the CDK library version if it so
+     * happens that the CDK project is an NPM project and the CDK CLI is executed
+     * in the root of NPM project with `aws-cdk-lib` available in `node_modules`.
+     * This may succeed or may fail.
+     *
+     * Once we have produced and loaded the cloud assembly more accurate
+     * information becomes available that we can add in.
+     */
+    attachCdkLibVersion(libVersion) {
+        // Don't want to crash accidentally
+        if (!this._sessionInfo) {
+            return;
+        }
+        mutable(this.sessionInfo.identifiers).cdkLibraryVersion = libVersion;
+    }
+    /**
+     * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost
+     * and notifies with an optional error message in the data.
+     */
+    async end(error) {
+        await this.span?.end({ error });
+        // Ideally span.end() should no-op if called twice, but that is not the case right now
+        this.span = undefined;
+        await this.client.flush();
+    }
+    async emit(event) {
+        this.count += 1;
+        return this.client.emit({
+            event: {
+                command: this.sessionInfo.event.command,
+                state: getState(event.error),
+                eventType: event.eventType,
+            },
+            identifiers: {
+                ...this.sessionInfo.identifiers,
+                eventId: `${this.sessionInfo.identifiers.sessionId}:${this.count}`,
+                timestamp: new Date().toISOString(),
+            },
+            environment: this.sessionInfo.environment,
+            project: this.sessionInfo.project,
+            duration: {
+                total: event.duration,
+            },
+            ...(event.error ? {
+                error: {
+                    name: event.error.name,
+                },
+            } : {}),
+            ...(event.counters && Object.keys(event.counters).length > 0 ? { counters: event.counters } : {}),
+        });
+    }
+    get sessionInfo() {
+        if (!this._sessionInfo) {
+            throw new toolkit_lib_1.ToolkitError('SessionNotInitialized', 'Session Info not initialized. Call begin() first.');
+        }
+        return this._sessionInfo;
+    }
+}
+exports.TelemetrySession = TelemetrySession;
+function getState(error) {
+    if (error) {
+        return isAbortedError(error) ? 'ABORTED' : 'FAILED';
+    }
+    return 'SUCCEEDED';
+}
+function isAbortedError(error) {
+    if (error?.name === 'ToolkitError' && error?.message?.includes(ABORTED_ERROR_MESSAGE)) {
+        return true;
+    }
+    return false;
+}
+function mutable(x) {
+    return x;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["session.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AACpC,sDAAoD;AACpD,uDAA8D;AAC9D,uDAAsD;AACtD,6CAA6E;AAK7E,8CAA+C;AAG/C,oDAAyD;AACzD,mCAAkC;AAClC,wCAA2C;AAC3C,mCAAgD;AAEhD,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AA+BvD,MAAa,gBAAgB;IAO3B,YAA6B,KAA4B;QAA5B,UAAK,GAAL,KAAK,CAAuB;QAFjD,UAAK,GAAG,CAAC,CAAC;QAGhB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,6BAA6B;QAC7B,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,IAAA,yCAA4B,EAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChF,IAAI,CAAC,YAAY,GAAG;YAClB,WAAW,EAAE;gBACX,cAAc,EAAE,MAAM,IAAA,2CAAyB,EAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;gBACzE,SAAS,EAAE,IAAA,mBAAU,GAAE;gBACvB,gBAAgB,EAAE,KAAK;gBACvB,aAAa,EAAE,IAAA,uBAAa,GAAE;gBAC9B,iBAAiB,EAAE,MAAM,IAAA,mCAAiB,EAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;aACrE;YACD,KAAK,EAAE;gBACL,OAAO,EAAE;oBACP,IAAI;oBACJ,UAAU;oBACV,MAAM,EAAE;wBACN,OAAO,EAAE,IAAA,4BAAe,EAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;qBAC7C;iBACF;aACF;YACD,WAAW,EAAE;gBACX,EAAE,EAAE,IAAA,SAAI,GAAE,IAAI,OAAO,CAAC,IAAA,2BAAc,GAAE,CAAC;gBACvC,EAAE,EAAE;oBACF,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI;iBAC9B;gBACD,WAAW,EAAE,OAAO,CAAC,OAAO;aAC7B;YACD,OAAO,EAAE,EAAE;SACZ,CAAC;QAEF,0GAA0G;QAC1G,4FAA4F;QAC5F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,GAAG,CAAC;oBACb,IAAI,EAAE,6BAAqB;oBAC3B,OAAO,EAAE,qBAAqB;iBAC/B,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,CAAM,EAAE,CAAC;gBAChB,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,2BAAgB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACtF,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,MAAc;QACtC,IAAI,CAAC,WAAW,CAAC,WAAW,GAAG;YAC7B,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW;YAC/B,MAAM;SACP,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,QAA4B;QAChD,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACxD,CAAC;IACH,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,OAA4B;QAC7C,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC;IACxD,CAAC;IAED;;;;;;;;;;OAUG;IACI,mBAAmB,CAAC,UAAkB;QAC3C,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,iBAAiB,GAAG,UAAU,CAAC;IACvE,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,GAAG,CAAC,KAAoB;QACnC,MAAM,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAChC,sFAAsF;QACtF,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,KAAqB;QACrC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QAEhB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACtB,KAAK,EAAE;gBACL,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO;gBACvC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;aAC3B;YACD,WAAW,EAAE;gBACX,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW;gBAC/B,OAAO,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,EAAE;gBAClE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC;YACD,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW;YACzC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;YACjC,QAAQ,EAAE;gBACR,KAAK,EAAE,KAAK,CAAC,QAAQ;aACtB;YACD,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBAChB,KAAK,EAAE;oBACL,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI;iBACvB;aACF,CAAC,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,KAAK,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClG,CAAC,CAAC;IACL,CAAC;IAED,IAAY,WAAW;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,IAAI,0BAAY,CAAC,uBAAuB,EAAE,mDAAmD,CAAC,CAAC;QACvG,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF;AA/JD,4CA+JC;AAED,SAAS,QAAQ,CAAC,KAAoB;IACpC,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;IACtD,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,SAAS,cAAc,CAAC,KAAoB;IAC1C,IAAI,KAAK,EAAE,IAAI,KAAK,cAAc,IAAI,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC;QACtF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,OAAO,CAAmB,CAAI;IACrC,OAAO,CAAC,CAAC;AACX,CAAC","sourcesContent":["import { randomUUID } from 'crypto';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { getOrCreateInstallationId } from './installation-id';\nimport { getLibraryVersion } from './library-version';\nimport { sanitizeCommandLineArguments, sanitizeContext } from './sanitation';\nimport { type EventType, type SessionSchema, type State, type ErrorDetails } from './schema';\nimport type { ITelemetrySink } from './sink/sink-interface';\nimport type { Context } from '../../api/context';\nimport type { IMessageSpan } from '../../api-private';\nimport { detectCiSystem } from '../ci-systems';\nimport type { CliIoHost } from '../io-host/cli-io-host';\nimport type { EventResult } from '../telemetry/messages';\nimport { CLI_PRIVATE_SPAN } from '../telemetry/messages';\nimport { isCI } from '../util/ci';\nimport { versionNumber } from '../version';\nimport { USER_INTERRUPTED_CODE } from './error';\n\nconst ABORTED_ERROR_MESSAGE = '__CDK-Toolkit__Aborted';\n\nexport interface TelemetrySessionProps {\n  readonly ioHost: CliIoHost;\n  readonly client: ITelemetrySink;\n  readonly arguments: any;\n  readonly context: Context;\n}\n\nexport interface TelemetryEvent {\n  readonly eventType: EventType;\n  readonly duration: number;\n  readonly error?: ErrorDetails;\n  readonly counters?: Record<string, number>;\n}\n\n/**\n * Timer of a single event\n */\nexport interface Timing {\n  /**\n   * Total time spent in this operation\n   */\n  totalMs: number;\n\n  /**\n   * Count of operations that together took `totalMs`.\n   */\n  count: number;\n}\n\nexport class TelemetrySession {\n  private ioHost: CliIoHost;\n  private client: ITelemetrySink;\n  private _sessionInfo?: SessionSchema;\n  private span?: IMessageSpan<EventResult>;\n  private count = 0;\n\n  constructor(private readonly props: TelemetrySessionProps) {\n    this.ioHost = props.ioHost;\n    this.client = props.client;\n  }\n\n  public async begin() {\n    // sanitize the raw cli input\n    const { path, parameters } = sanitizeCommandLineArguments(this.props.arguments);\n    this._sessionInfo = {\n      identifiers: {\n        installationId: await getOrCreateInstallationId(this.ioHost.asIoHelper()),\n        sessionId: randomUUID(),\n        telemetryVersion: '2.0',\n        cdkCliVersion: versionNumber(),\n        cdkLibraryVersion: await getLibraryVersion(this.ioHost.asIoHelper()),\n      },\n      event: {\n        command: {\n          path,\n          parameters,\n          config: {\n            context: sanitizeContext(this.props.context),\n          },\n        },\n      },\n      environment: {\n        ci: isCI() || Boolean(detectCiSystem()),\n        os: {\n          platform: process.platform,\n          release: process.release.name,\n        },\n        nodeVersion: process.version,\n      },\n      project: {},\n    };\n\n    // If SIGINT has a listener installed, its default behavior will be removed (Node.js will no longer exit).\n    // This ensures that on SIGINT we process safely close the telemetry session before exiting.\n    process.on('SIGINT', async () => {\n      try {\n        await this.end({\n          name: USER_INTERRUPTED_CODE,\n          message: ABORTED_ERROR_MESSAGE,\n        });\n      } catch (e: any) {\n        await this.ioHost.defaults.trace(`Ending Telemetry failed: ${e.message}`);\n      }\n      process.exit(1);\n    });\n\n    // Begin the session span\n    this.span = await this.ioHost.asIoHelper().span(CLI_PRIVATE_SPAN.COMMAND).begin({});\n  }\n\n  public async attachRegion(region: string) {\n    this.sessionInfo.identifiers = {\n      ...this.sessionInfo.identifiers,\n      region,\n    };\n  }\n\n  /**\n   * Attach a language guess\n   */\n  public attachLanguage(language: string | undefined) {\n    // Don't want to crash accidentally\n    if (!this._sessionInfo) {\n      return;\n    }\n\n    if (language) {\n      mutable(this.sessionInfo.project).language = language;\n    }\n  }\n\n  /**\n   * Attach our best guess at running under an agent or not\n   */\n  public attachAgent(isAgent: boolean | undefined) {\n    // Don't want to crash accidentally\n    if (!this._sessionInfo) {\n      return;\n    }\n\n    mutable(this.sessionInfo.environment).agent = isAgent;\n  }\n\n  /**\n   * Attach the CDK library version\n   *\n   * By default the telemetry will guess at the CDK library version if it so\n   * happens that the CDK project is an NPM project and the CDK CLI is executed\n   * in the root of NPM project with `aws-cdk-lib` available in `node_modules`.\n   * This may succeed or may fail.\n   *\n   * Once we have produced and loaded the cloud assembly more accurate\n   * information becomes available that we can add in.\n   */\n  public attachCdkLibVersion(libVersion: string) {\n    // Don't want to crash accidentally\n    if (!this._sessionInfo) {\n      return;\n    }\n\n    mutable(this.sessionInfo.identifiers).cdkLibraryVersion = libVersion;\n  }\n\n  /**\n   * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost\n   * and notifies with an optional error message in the data.\n   */\n  public async end(error?: ErrorDetails) {\n    await this.span?.end({ error });\n    // Ideally span.end() should no-op if called twice, but that is not the case right now\n    this.span = undefined;\n    await this.client.flush();\n  }\n\n  public async emit(event: TelemetryEvent): Promise<void> {\n    this.count += 1;\n\n    return this.client.emit({\n      event: {\n        command: this.sessionInfo.event.command,\n        state: getState(event.error),\n        eventType: event.eventType,\n      },\n      identifiers: {\n        ...this.sessionInfo.identifiers,\n        eventId: `${this.sessionInfo.identifiers.sessionId}:${this.count}`,\n        timestamp: new Date().toISOString(),\n      },\n      environment: this.sessionInfo.environment,\n      project: this.sessionInfo.project,\n      duration: {\n        total: event.duration,\n      },\n      ...(event.error ? {\n        error: {\n          name: event.error.name,\n        },\n      } : {}),\n      ...(event.counters && Object.keys(event.counters).length > 0 ? { counters: event.counters } : {}),\n    });\n  }\n\n  private get sessionInfo(): SessionSchema {\n    if (!this._sessionInfo) {\n      throw new ToolkitError('SessionNotInitialized', 'Session Info not initialized. Call begin() first.');\n    }\n    return this._sessionInfo;\n  }\n}\n\nfunction getState(error?: ErrorDetails): State {\n  if (error) {\n    return isAbortedError(error) ? 'ABORTED' : 'FAILED';\n  }\n  return 'SUCCEEDED';\n}\n\nfunction isAbortedError(error?: ErrorDetails) {\n  if (error?.name === 'ToolkitError' && error?.message?.includes(ABORTED_ERROR_MESSAGE)) {\n    return true;\n  }\n  return false;\n}\n\nfunction mutable<A extends object>(x: A): { -readonly [k in keyof A]: A[k] } {\n  return x;\n}\n"]}

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

@@ -0,0 +1,44 @@
+import type { Agent } from 'https';
+import type { IIoHost } from '../../io-host';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the Endpoint Telemetry Client
+ */
+export interface EndpointTelemetrySinkProps {
+    /**
+     * The external endpoint to hit
+     */
+    readonly endpoint: string;
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * The agent responsible for making the network requests.
+     *
+     * Use this to set up a proxy connection.
+     *
+     * @default - Uses the shared global node agent
+     */
+    readonly agent?: Agent;
+}
+/**
+ * The telemetry client that hits an external endpoint.
+ */
+export declare class EndpointTelemetrySink implements ITelemetrySink {
+    private events;
+    private endpoint;
+    private ioHelper;
+    private agent?;
+    constructor(props: EndpointTelemetrySinkProps);
+    /**
+     * Add an event to the collection.
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+    /**
+     * Returns true if telemetry successfully posted, false otherwise.
+     */
+    private https;
+}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointTelemetrySink = void 0;
+const https_1 = require("https");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const network_detector_1 = require("../../../api/network-detector");
+const api_private_1 = require("../../../api-private");
+const REQUEST_ATTEMPT_TIMEOUT_MS = 500;
+/**
+ * The telemetry client that hits an external endpoint.
+ */
+class EndpointTelemetrySink {
+    constructor(props) {
+        this.events = [];
+        this.endpoint = new URL(props.endpoint);
+        if (!this.endpoint.hostname || !this.endpoint.pathname) {
+            throw new toolkit_lib_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.agent = props.agent;
+        // Batch events every 30 seconds
+        setInterval(() => this.flush(), 30000).unref();
+    }
+    /**
+     * Add an event to the collection.
+     */
+    async emit(event) {
+        try {
+            this.events.push(event);
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);
+        }
+    }
+    async flush() {
+        try {
+            if (this.events.length === 0) {
+                return;
+            }
+            const res = await this.https(this.endpoint, { events: this.events });
+            // Clear the events array after successful output
+            if (res) {
+                this.events = [];
+            }
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to send telemetry event: ${e.message}`);
+        }
+    }
+    /**
+     * Returns true if telemetry successfully posted, false otherwise.
+     */
+    async https(url, body) {
+        // Check connectivity before attempting network request
+        const hasConnectivity = await network_detector_1.NetworkDetector.hasConnectivity(this.agent);
+        if (!hasConnectivity) {
+            await this.ioHelper.defaults.trace('No internet connectivity detected, skipping telemetry');
+            return false;
+        }
+        try {
+            const res = await doRequest(url, body, this.agent);
+            // Successfully posted
+            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                await this.ioHelper.defaults.trace('Telemetry Sent Successfully');
+                return true;
+            }
+            await this.ioHelper.defaults.trace(`Telemetry Unsuccessful: POST ${url.hostname}${url.pathname}: ${res.statusCode}:${res.statusMessage}`);
+            return false;
+        }
+        catch (e) {
+            await this.ioHelper.defaults.trace(`Telemetry Error: POST ${url.hostname}${url.pathname}: ${JSON.stringify(e)}`);
+            return false;
+        }
+    }
+}
+exports.EndpointTelemetrySink = EndpointTelemetrySink;
+/**
+ * A Promisified version of `https.request()`
+ */
+function doRequest(url, data, agent) {
+    return new Promise((ok, ko) => {
+        const payload = JSON.stringify(data);
+        const req = (0, https_1.request)({
+            hostname: url.hostname,
+            port: url.port || null,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'content-length': payload.length,
+            },
+            agent,
+            timeout: REQUEST_ATTEMPT_TIMEOUT_MS,
+        }, ok);
+        req.on('error', ko);
+        req.on('timeout', () => {
+            const error = new toolkit_lib_1.ToolkitError('RequestTimeout', `Timeout after ${REQUEST_ATTEMPT_TIMEOUT_MS}ms, aborting request`);
+            req.destroy(error);
+        });
+        req.end(payload);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"endpoint-sink.js","sourceRoot":"","sources":["endpoint-sink.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IncomingMessage } from 'http';\nimport type { Agent } from 'https';\nimport { request } from 'https';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { NetworkDetector } from '../../../api/network-detector';\nimport { IoHelper } from '../../../api-private';\nimport type { IIoHost } from '../../io-host';\nimport type { TelemetrySchema } from '../schema';\nimport type { ITelemetrySink } from './sink-interface';\n\nconst REQUEST_ATTEMPT_TIMEOUT_MS = 500;\n\n/**\n * Properties for the Endpoint Telemetry Client\n */\nexport interface EndpointTelemetrySinkProps {\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   * The agent responsible for making the network requests.\n   *\n   * Use this to set up a proxy connection.\n   *\n   * @default - Uses the shared global node agent\n   */\n  readonly agent?: Agent;\n}\n\n/**\n * The telemetry client that hits an external endpoint.\n */\nexport class EndpointTelemetrySink implements ITelemetrySink {\n  private events: TelemetrySchema[] = [];\n  private endpoint: URL;\n  private ioHelper: IoHelper;\n  private agent?: Agent;\n\n  public constructor(props: EndpointTelemetrySinkProps) {\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.agent = props.agent;\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    try {\n      this.events.push(event);\n    } catch (e: any) {\n      // Never throw errors, just log them via ioHost\n      await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);\n    }\n  }\n\n  public async flush(): Promise<void> {\n    try {\n      if (this.events.length === 0) {\n        return;\n      }\n\n      const res = await this.https(this.endpoint, { events: this.events });\n\n      // Clear the events array after successful output\n      if (res) {\n        this.events = [];\n      }\n    } catch (e: any) {\n      // Never throw errors, just log them via ioHost\n      await this.ioHelper.defaults.trace(`Failed to send telemetry event: ${e.message}`);\n    }\n  }\n\n  /**\n   * Returns true if telemetry successfully posted, false otherwise.\n   */\n  private async https(\n    url: URL,\n    body: { events: TelemetrySchema[] },\n  ): Promise<boolean> {\n    // Check connectivity before attempting network request\n    const hasConnectivity = await NetworkDetector.hasConnectivity(this.agent);\n    if (!hasConnectivity) {\n      await this.ioHelper.defaults.trace('No internet connectivity detected, skipping telemetry');\n      return false;\n    }\n\n    try {\n      const res = await doRequest(url, body, this.agent);\n\n      // Successfully posted\n      if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {\n        await this.ioHelper.defaults.trace('Telemetry Sent Successfully');\n        return true;\n      }\n\n      await this.ioHelper.defaults.trace(`Telemetry Unsuccessful: POST ${url.hostname}${url.pathname}: ${res.statusCode}:${res.statusMessage}`);\n\n      return false;\n    } catch (e: any) {\n      await this.ioHelper.defaults.trace(`Telemetry Error: POST ${url.hostname}${url.pathname}: ${JSON.stringify(e)}`);\n      return false;\n    }\n  }\n}\n\n/**\n * A Promisified version of `https.request()`\n */\nfunction doRequest(\n  url: URL,\n  data: { events: TelemetrySchema[] },\n  agent?: Agent,\n) {\n  return new Promise<IncomingMessage>((ok, ko) => {\n    const payload: string = JSON.stringify(data);\n    const req = request({\n      hostname: url.hostname,\n      port: url.port || null,\n      path: url.pathname,\n      method: 'POST',\n      headers: {\n        'content-type': 'application/json',\n        'content-length': payload.length,\n      },\n      agent,\n      timeout: REQUEST_ATTEMPT_TIMEOUT_MS,\n    }, ok);\n\n    req.on('error', ko);\n    req.on('timeout', () => {\n      const error = new ToolkitError('RequestTimeout', `Timeout after ${REQUEST_ATTEMPT_TIMEOUT_MS}ms, aborting request`);\n      req.destroy(error);\n    });\n\n    req.end(payload);\n  });\n}\n"]}

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

@@ -0,0 +1,32 @@
+import { type IIoHost } from '@aws-cdk/toolkit-lib';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the FileTelemetryClient
+ */
+export interface FileTelemetrySinkProps {
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * The local file to log telemetry data to.
+     */
+    readonly logFilePath: string;
+}
+/**
+ * A telemetry client that collects events writes them to a file
+ */
+export declare class FileTelemetrySink implements ITelemetrySink {
+    private ioHelper;
+    private logFilePath;
+    /**
+     * Create a new FileTelemetryClient
+     */
+    constructor(props: FileTelemetrySinkProps);
+    /**
+     * Emit an event.
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTelemetrySink = void 0;
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const fs = require("fs-extra");
+const api_private_1 = require("../../../api-private");
+/**
+ * A telemetry client that collects events writes them to a file
+ */
+class FileTelemetrySink {
+    /**
+     * Create a new FileTelemetryClient
+     */
+    constructor(props) {
+        this.ioHelper = api_private_1.IoHelper.fromActionAwareIoHost(props.ioHost);
+        this.logFilePath = props.logFilePath;
+        if (fs.existsSync(this.logFilePath)) {
+            throw new toolkit_lib_1.ToolkitError('TelemetryFileExists', `Telemetry file already exists at ${this.logFilePath}`);
+        }
+        // Create the file
+        fs.ensureFileSync(this.logFilePath);
+        fs.writeJsonSync(this.logFilePath, []);
+    }
+    /**
+     * Emit an event.
+     */
+    async emit(event) {
+        try {
+            const json = fs.readJsonSync(this.logFilePath);
+            json.push(event);
+            fs.writeJSONSync(this.logFilePath, json, { spaces: 2 });
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);
+        }
+    }
+    async flush() {
+        return;
+    }
+}
+exports.FileTelemetrySink = FileTelemetrySink;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/telemetry/sink/funnel.d.ts

@@ -0,0 +1,16 @@
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+export interface FunnelProps {
+    readonly sinks: ITelemetrySink[];
+}
+/**
+ * A funnel is a combination of one or more sinks.
+ * The sink functions are executed in parallel, and a maximum of 5
+ * sinks are supported per funnel.
+ */
+export declare class Funnel {
+    private readonly sinks;
+    constructor(props: FunnelProps);
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

package/lib/cli/telemetry/sink/funnel.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Funnel = void 0;
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+/**
+ * A funnel is a combination of one or more sinks.
+ * The sink functions are executed in parallel, and a maximum of 5
+ * sinks are supported per funnel.
+ */
+class Funnel {
+    constructor(props) {
+        if (props.sinks.length > 5) {
+            throw new toolkit_lib_1.ToolkitError('MaxSinksExceeded', `Funnel class supports a maximum of 5 parallel sinks, got ${props.sinks.length} sinks.`);
+        }
+        this.sinks = props.sinks;
+    }
+    async emit(event) {
+        // Funnel class enforces a maximum of 5 parallel sinks
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        await Promise.all(this.sinks.map(sink => sink.emit(event)));
+    }
+    async flush() {
+        // Funnel class enforces a maximum of 5 parallel sinks
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        await Promise.all(this.sinks.map(sink => sink.flush()));
+    }
+}
+exports.Funnel = Funnel;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/telemetry/sink/io-host-sink.d.ts

@@ -0,0 +1,27 @@
+import type { IIoHost } from '@aws-cdk/toolkit-lib';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the StdoutTelemetryClient
+ */
+export interface IoHostTelemetrySinkProps {
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+}
+/**
+ * A telemetry client that collects events and flushes them to stdout.
+ */
+export declare class IoHostTelemetrySink implements ITelemetrySink {
+    private ioHelper;
+    /**
+     * Create a new StdoutTelemetryClient
+     */
+    constructor(props: IoHostTelemetrySinkProps);
+    /**
+     * Emit an event
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

package/lib/cli/telemetry/sink/io-host-sink.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoHostTelemetrySink = void 0;
+const api_private_1 = require("../../../api-private");
+/**
+ * A telemetry client that collects events and flushes them to stdout.
+ */
+class IoHostTelemetrySink {
+    /**
+     * Create a new StdoutTelemetryClient
+     */
+    constructor(props) {
+        this.ioHelper = api_private_1.IoHelper.fromActionAwareIoHost(props.ioHost);
+    }
+    /**
+     * Emit an event
+     */
+    async emit(event) {
+        try {
+            // Format the events as a JSON string with pretty printing
+            const output = JSON.stringify(event, null, 2);
+            // Write to IoHost
+            await this.ioHelper.defaults.trace(`--- TELEMETRY EVENT ---\n${output}\n-----------------------\n`);
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);
+        }
+    }
+    async flush() {
+        return;
+    }
+}
+exports.IoHostTelemetrySink = IoHostTelemetrySink;
+//# sourceMappingURL=data:application/json;base64,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