@cdktn/commons 0.25.0-pre.52 → 0.25.0-pre.54

package/build/telemetry.test.js

@@ -0,0 +1,1501 @@
+"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 });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const Sentry = __importStar(require("@sentry/node"));
+const fs = __importStar(require("fs-extra"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const telemetry_1 = require("./telemetry");
+const terraform_1 = require("./terraform");
+const config_1 = require("./config");
+const construct_maker_target_1 = require("./construct-maker-target");
+const errors_1 = require("./errors");
+const DEFAULT_TARGET_VERSIONS_AS_ATTRIBUTES = {
+    target_terraform: config_1.DEFAULT_TARGET_VERSIONS.terraform,
+    target_opentofu: config_1.DEFAULT_TARGET_VERSIONS.opentofu,
+};
+// Mirrors recordEnvelope in tools/sentry-sink.mjs: an envelope-format change
+// is fixed in both.
+function parseMetricItems(envelopeBodies) {
+    const items = [];
+    for (const body of envelopeBodies) {
+        const lines = body.split("\n").filter(Boolean);
+        for (let i = 0; i < lines.length - 1; i++) {
+            let header;
+            try {
+                header = JSON.parse(lines[i]);
+            }
+            catch (_a) {
+                continue;
+            }
+            if (header.type === "trace_metric") {
+                const payload = JSON.parse(lines[i + 1]);
+                items.push(...payload.items);
+            }
+        }
+    }
+    return items;
+}
+function attributeValues(item) {
+    return Object.fromEntries(Object.entries(item.attributes).map(([k, v]) => [k, v.value]));
+}
+// On every metric of a command; the exact set is pinned once, on
+// cli.command.completed.
+const COMMAND_ATTRIBUTES = [
+    "arch",
+    "binary",
+    "binary_version",
+    "ci",
+    "command",
+    "language",
+    "os",
+    "package_manager",
+    "server.address",
+    "target_opentofu",
+    "target_terraform",
+    "targets_declared",
+    "validate_installed_binary",
+];
+// Each metric of that name as its value plus exactly the attributes it adds
+// to the command's, so `toEqual` fails on any attribute that is not listed.
+function metrics(items, name) {
+    return items
+        .filter((item) => item.name === name)
+        .map((item) => ({
+        value: item.value,
+        ...Object.fromEntries(Object.entries(attributeValues(item)).filter(([key]) => !key.startsWith("sentry.") && !COMMAND_ATTRIBUTES.includes(key))),
+    }));
+}
+describe("telemetry", () => {
+    let workdir;
+    let envelopeBodies;
+    const originalCwd = process.cwd();
+    const originalCheckpointDisable = process.env.CHECKPOINT_DISABLE;
+    const originalSentryEnvironment = process.env.SENTRY_ENVIRONMENT;
+    function initSentryWithCapturingTransport() {
+        Sentry.init({
+            dsn: "https://public@example.invalid/1",
+            release: "cdktn-cli-test",
+            environment: "production",
+            tracesSampleRate: 0,
+            serverName: "cdktn-cli",
+            // each test inits its own client; process-level integrations would
+            // pile up listeners across tests and are irrelevant to metrics
+            defaultIntegrations: false,
+            transport: (options) => Sentry.createTransport(options, async (request) => {
+                envelopeBodies.push(request.body);
+                return { statusCode: 200 };
+            }),
+        });
+    }
+    async function deliveredItems() {
+        expect(await Sentry.flush(2000)).toBe(true);
+        return parseMetricItems(envelopeBodies);
+    }
+    beforeEach(() => {
+        workdir = fs.mkdtempSync(path.join(os.tmpdir(), "cdktn-telemetry-"));
+        process.chdir(workdir);
+        envelopeBodies = [];
+        delete process.env.CHECKPOINT_DISABLE;
+        delete process.env.SENTRY_ENVIRONMENT;
+        // the probe is process-global (see terraform.ts); a seeded output keeps
+        // the binary attributes independent of the machine running the tests
+        (0, terraform_1.seedTerraformCliProbeForTests)(Promise.resolve("Terraform v1.9.0\non darwin_arm64\n"));
+    });
+    afterEach(async () => {
+        (0, telemetry_1.setUsageTelemetryEnabled)(undefined);
+        (0, telemetry_1.resetCommandTelemetry)();
+        (0, telemetry_1.setProjectTargetAttributes)(undefined);
+        (0, terraform_1.seedTerraformCliProbeForTests)();
+        await Sentry.close(1000);
+        process.chdir(originalCwd);
+        fs.removeSync(workdir);
+        if (originalCheckpointDisable === undefined) {
+            delete process.env.CHECKPOINT_DISABLE;
+        }
+        else {
+            process.env.CHECKPOINT_DISABLE = originalCheckpointDisable;
+        }
+        if (originalSentryEnvironment === undefined) {
+            delete process.env.SENTRY_ENVIRONMENT;
+        }
+        else {
+            process.env.SENTRY_ENVIRONMENT = originalSentryEnvironment;
+        }
+    });
+    describe("sendTelemetry delivery (real client + capturing transport)", () => {
+        it("stamps the command, language, binary and target attributes on every command metric", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+                sendUsageTelemetry: true,
+                targetVersions: { terraform: ">=1.9.0", opentofu: ">=1.8.0" },
+                validateInstalledBinary: true,
+            });
+            initSentryWithCapturingTransport();
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            await (0, telemetry_1.sendTelemetry)("synth", { totalTime: 1234, language: "typescript" });
+            await (0, telemetry_1.sendTelemetry)("synth", { error: true, synthOrigin: "watch" });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => i.name)).toEqual([
+                "cli.command.invoked",
+                "cli.command.completed",
+                "cli.synth.duration",
+                "cli.command.error",
+            ]);
+            const [invoked, completed, duration, error] = items;
+            for (const metric of items) {
+                expect(attributeValues(metric)).toMatchObject({
+                    command: "synth",
+                    os: process.platform,
+                    arch: process.arch,
+                    binary: "terraform",
+                    binary_version: "1.9.0",
+                    target_terraform: ">=1.9.0",
+                    target_opentofu: ">=1.8.0",
+                    targets_declared: true,
+                    validate_installed_binary: true,
+                });
+            }
+            // the language comes from cdktf.json at start and from the payload
+            // at the end; the error metric has no payload and reuses the start read
+            expect(attributeValues(invoked).language).toBe("typescript");
+            expect(attributeValues(completed).language).toBe("typescript");
+            expect(duration.type).toBe("distribution");
+            expect(duration.value).toBe(1234);
+            expect(attributeValues(error)).toMatchObject({
+                error_type: "unexpected",
+                language: "typescript",
+                synth_origin: "watch",
+            });
+        });
+        it("uses the target attributes captured at command start over the current cwd", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                targetVersions: { terraform: ">=1.0.0" },
+            });
+            initSentryWithCapturingTransport();
+            (0, telemetry_1.setProjectTargetAttributes)({
+                targets_declared: true,
+                validate_installed_binary: false,
+                target_opentofu: ">=1.7.0",
+            });
+            await (0, telemetry_1.startCommandTelemetry)("convert");
+            await (0, telemetry_1.sendTelemetry)("convert", {});
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => i.name)).toEqual([
+                "cli.command.invoked",
+                "cli.command.completed",
+            ]);
+            for (const metric of items) {
+                expect(metric.attributes.target_opentofu.value).toBe(">=1.7.0");
+                expect(metric.attributes.target_terraform).toBeUndefined();
+            }
+        });
+        it.each([
+            ["Usage", "Usage"],
+            ["External", "External"],
+            ["Internal", "Internal"],
+            ["Something Else", "unexpected"],
+        ])("stamps error_type %p as %p on cli.command.error", async (errorType, expected) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+            await (0, telemetry_1.sendTelemetry)("deploy", { error: true, errorType });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const error = parseMetricItems(envelopeBodies).find((i) => i.name === "cli.command.error");
+            expect(error.attributes.error_type.value).toBe(expected);
+            expect(error.attributes.command.value).toBe("deploy");
+        });
+        it("forwards exactly the allow-listed attribute set and nothing else from the payload", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                totalTime: 5,
+                language: "typescript",
+                synthOrigin: "watch",
+                stackMetadata: [{ stackName: "prod-vpc", backend: "s3" }],
+                requiredProviders: [{ aws: { source: "aws" } }],
+                stackName: "prod-vpc",
+                outdir: "/Users/x/secret",
+                resources: { aws: { secret_resource: 3 } },
+            });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            const invoked = items.find((i) => i.name === "cli.command.invoked");
+            const completed = items.find((i) => i.name === "cli.command.completed");
+            const keys = Object.keys(completed.attributes);
+            // the start metric carries the base set; the end-of-run scalars ride
+            // on completed only
+            expect(Object.keys(invoked.attributes).sort()).toEqual(keys.filter((key) => key !== "synth_origin").sort());
+            // the one place that fails when an attribute is added: extend it
+            // deliberately, together with the collected-data list in the docs
+            expect(keys.filter((key) => !key.startsWith("sentry.")).sort()).toEqual([
+                "arch",
+                "binary",
+                "binary_version",
+                "ci",
+                "command",
+                "language",
+                "os",
+                "package_manager",
+                // server.address is the fixed serverName from init
+                "server.address",
+                "synth_origin",
+                "target_opentofu",
+                "target_terraform",
+                "targets_declared",
+                "validate_installed_binary",
+            ]);
+            // stamped by the SDK from init; a patch bump may add more of them
+            expect(keys).toEqual(expect.arrayContaining(["sentry.release", "sentry.environment"]));
+            const bytes = envelopeBodies.join("\n");
+            expect(bytes).not.toContain("prod-vpc");
+            expect(bytes).not.toContain("/Users/x/secret");
+            expect(bytes).not.toContain("secret_resource");
+        });
+    });
+    describe("sendTelemetry payload mapping", () => {
+        beforeEach(() => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+        });
+        it("counts get targets per normalized provider/module and puts only totals on the command metric", async () => {
+            const provider = (constraint) => new construct_maker_target_1.ConstructsMakerProviderTarget(new config_1.TerraformProviderConstraint(constraint), config_1.Language.TYPESCRIPT).trackingPayload;
+            const module = (constraint) => new construct_maker_target_1.ConstructsMakerModuleTarget(new config_1.TerraformModuleConstraint(constraint), config_1.Language.TYPESCRIPT).trackingPayload;
+            await (0, telemetry_1.sendTelemetry)("get", {
+                targets: [
+                    provider("registry.terraform.io/hashicorp/aws@~> 5.0"),
+                    provider("Hashicorp/AWS@~> 6.0"),
+                    provider("Kreuzwerker/Docker"),
+                    module("terraform-aws-modules/vpc/aws@5.0.0"),
+                    module("./modules/secret-name"),
+                ],
+            });
+            const items = await deliveredItems();
+            const totals = { provider_count: 3, module_count: 2 };
+            expect(metrics(items, "cli.command.completed")).toEqual([
+                { value: 1, ...totals },
+            ]);
+            expect(metrics(items, "cli.get.provider")).toEqual([
+                { value: 2, provider: "hashicorp/aws", ...totals },
+                { value: 1, provider: "kreuzwerker/docker", ...totals },
+            ]);
+            expect(metrics(items, "cli.get.module")).toEqual([
+                { value: 1, module: "local", ...totals },
+                { value: 1, module: "terraform-aws-modules/vpc/aws", ...totals },
+            ]);
+            expect(envelopeBodies.join("\n")).not.toContain("secret-name");
+        });
+        it("counts init providers per normalized provider and puts only the total on the command metric", async () => {
+            await (0, telemetry_1.sendTelemetry)("init", {
+                projectId: "should-not-be-sent",
+                addedProviders: [
+                    "aws@~>5.0",
+                    "hashicorp/random",
+                    "registry.terraform.io/hashicorp/aws",
+                ],
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.command.completed")).toEqual([
+                { value: 1, provider_count: 3 },
+            ]);
+            expect(metrics(items, "cli.init.provider")).toEqual([
+                { value: 2, provider: "hashicorp/aws", provider_count: 3 },
+                { value: 1, provider: "hashicorp/random", provider_count: 3 },
+            ]);
+            expect(envelopeBodies.join("\n")).not.toContain("should-not-be-sent");
+        });
+        it.each([
+            [
+                "get",
+                (sources) => ({
+                    targets: sources.map((source) => ({ type: "provider", source })),
+                }),
+                "cli.get.provider",
+                { provider_count: 40, module_count: 0 },
+            ],
+            [
+                "init",
+                (sources) => ({ addedProviders: sources }),
+                "cli.init.provider",
+                { provider_count: 40 },
+            ],
+        ])("%s folds the providers past 32 into one truncated count", async (command, payload, metric, totals) => {
+            const sources = Array.from({ length: 40 }, (_, k) => `acme/p${String(k).padStart(2, "0")}`);
+            await (0, telemetry_1.sendTelemetry)(command, payload([...sources].reverse()));
+            const items = await deliveredItems();
+            expect(metrics(items, metric)).toEqual([
+                ...sources
+                    .slice(0, 32)
+                    .map((provider) => ({ value: 1, provider, ...totals })),
+                { value: 8, truncated: true, ...totals },
+            ]);
+            expect(metrics(items, "cli.command.completed")).toEqual([
+                { value: 1, ...totals },
+            ]);
+        });
+        it("counts the run as completed even when a per-source metric cannot be built", async () => {
+            await (0, telemetry_1.sendTelemetry)("get", {
+                targets: [null, { type: "provider", source: 7 }],
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.command.completed")).toEqual([
+                { value: 1, provider_count: 1, module_count: 0 },
+            ]);
+            expect(metrics(items, "cli.get.provider")).toEqual([]);
+        });
+    });
+    describe("stack metrics", () => {
+        // one JSON-synthesized stack the way the library writes it: metadata
+        // carries the stack name and resource ids (imports/moved), overrides
+        // are keyed by schema type, module overrides by source
+        const stackMetadata = [
+            {
+                version: "0.21.0",
+                stackName: "SECRET-STACK-NAME",
+                backend: "s3",
+                overrides: {
+                    stack: ["terraform.required_version"],
+                    aws_s3_bucket: ["tags", "region"],
+                    "module.../secret-path/vpc": ["providers"],
+                },
+                imports: { aws_s3_bucket: ["secret-resource-id"] },
+                moved: {
+                    aws_s3_bucket: ["secret-resource-id"],
+                    aws_iam_role: ["secret-resource-id"],
+                },
+            },
+            {
+                version: "0.21.0",
+                stackName: "SECRET-STACK-NAME-2",
+                backend: "remote",
+                cloud: "tfc",
+            },
+        ];
+        const requiredProviders = [
+            {
+                aws: { source: "aws", version: "~> 5.0" },
+                docker: {
+                    source: "registry.terraform.io/kreuzwerker/docker",
+                    version: "3.0.2",
+                },
+                google: { source: "hashicorp/google", version: "x".repeat(100) },
+            },
+            {
+                random: { source: "hashicorp/random" },
+                vault: {
+                    source: "tfe.corp.example.com/acme-org/vault",
+                    version: "~> 3.0",
+                },
+            },
+        ];
+        const noCounts = { override_count: 0, import_count: 0, moved_count: 0 };
+        beforeEach(() => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                sendUsageTelemetry: true,
+                terraformProviders: [
+                    "aws@~>5.0",
+                    { name: "docker", source: "kreuzwerker/docker", version: "3.0.2" },
+                ],
+            });
+            initSentryWithCapturingTransport();
+        });
+        it("delivers no stack, provider or override metric when the project opts out", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                sendUsageTelemetry: false,
+            });
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                language: "typescript",
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 0,
+            });
+            expect(await deliveredItems()).toEqual([]);
+        });
+        it("counts stacks by backend, cloud and library version with their group sizes", async () => {
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                language: "typescript",
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 0,
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toEqual([
+                {
+                    value: 1,
+                    backend: "remote",
+                    cloud: true,
+                    library_version: "0.21.0",
+                    ...noCounts,
+                },
+                {
+                    value: 1,
+                    backend: "s3",
+                    cloud: false,
+                    library_version: "0.21.0",
+                    override_count: 4,
+                    import_count: 1,
+                    moved_count: 2,
+                },
+            ]);
+            for (const stack of items.filter((i) => i.name === "cli.stack")) {
+                expect(attributeValues(stack)).toMatchObject({
+                    command: "deploy",
+                    language: "typescript",
+                });
+            }
+            expect(items.some((i) => i.name === "cli.stack.failed")).toBe(false);
+            expect(items.some((i) => i.name === "cli.command.completed")).toBe(true);
+        });
+        it("counts overrides per resource type, reducing module sources to their kind", async () => {
+            await (0, telemetry_1.sendTelemetry)("synth", { stackMetadata, requiredProviders });
+            expect(metrics(await deliveredItems(), "cli.stack.override")).toEqual([
+                { value: 1, resource_type: "aws_s3_bucket", override_count: 2 },
+                { value: 1, resource_type: "module.local", override_count: 1 },
+                { value: 1, resource_type: "stack", override_count: 1 },
+            ]);
+        });
+        it("counts required providers by normalized source, validated constraint and binding", async () => {
+            await (0, telemetry_1.sendTelemetry)("diff", { stackMetadata, requiredProviders });
+            expect(metrics(await deliveredItems(), "cli.stack.provider")).toEqual([
+                {
+                    value: 1,
+                    provider: "hashicorp/aws",
+                    version_constraint: "~> 5.0",
+                    binding: "generated",
+                },
+                {
+                    value: 1,
+                    provider: "hashicorp/google",
+                    version_constraint: "invalid",
+                    binding: "prebuilt",
+                },
+                { value: 1, provider: "hashicorp/random", binding: "prebuilt" },
+                {
+                    value: 1,
+                    provider: "kreuzwerker/docker",
+                    version_constraint: "3.0.2",
+                    binding: "generated",
+                },
+                {
+                    value: 1,
+                    provider: "private-registry",
+                    version_constraint: "~> 3.0",
+                    binding: "prebuilt",
+                },
+            ]);
+        });
+        it("classifies bindings against the project the command started in, not the current cwd", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("diff");
+            const elsewhere = path.join(workdir, "elsewhere");
+            fs.mkdirSync(elsewhere);
+            fs.writeJsonSync(path.join(elsewhere, "cdktf.json"), {
+                terraformProviders: ["google"],
+            });
+            process.chdir(elsewhere);
+            await (0, telemetry_1.sendTelemetry)("diff", { stackMetadata, requiredProviders });
+            expect(metrics(await deliveredItems(), "cli.stack.provider").map((p) => [
+                p.provider,
+                p.binding,
+            ])).toEqual([
+                ["hashicorp/aws", "generated"],
+                ["hashicorp/google", "prebuilt"],
+                ["hashicorp/random", "prebuilt"],
+                ["kreuzwerker/docker", "generated"],
+                ["private-registry", "prebuilt"],
+            ]);
+        });
+        it.each([3, 300])("sends the same stack events for %d alike stacks, with the stack count as their value", async (count) => {
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                stackMetadata: Array.from({ length: count }, (_, i) => ({
+                    version: "0.21.0",
+                    stackName: `stack-${i}`,
+                    backend: "s3",
+                    overrides: { aws_s3_bucket: ["tags"] },
+                })),
+                requiredProviders: Array.from({ length: count }, () => ({
+                    aws: { source: "aws", version: "~> 5.0" },
+                    random: { source: "hashicorp/random" },
+                })),
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toEqual([
+                {
+                    value: count,
+                    backend: "s3",
+                    cloud: false,
+                    library_version: "0.21.0",
+                    override_count: count,
+                    import_count: 0,
+                    moved_count: 0,
+                },
+            ]);
+            expect(metrics(items, "cli.stack.provider")).toEqual([
+                {
+                    value: count,
+                    provider: "hashicorp/aws",
+                    version_constraint: "~> 5.0",
+                    binding: "generated",
+                },
+                { value: count, provider: "hashicorp/random", binding: "prebuilt" },
+            ]);
+            expect(metrics(items, "cli.stack.override")).toEqual([
+                {
+                    value: count,
+                    resource_type: "aws_s3_bucket",
+                    override_count: count,
+                },
+            ]);
+        });
+        it("groups providers on what is sent: spellings and private hosts collapse, constraints do not", async () => {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [{}, {}, {}],
+                requiredProviders: [
+                    {
+                        aws: { source: "aws", version: "~>5.0" },
+                        vault: { source: "tfe.leak-one.example/leak-org-one/vault" },
+                    },
+                    {
+                        aws: { source: "Hashicorp/AWS", version: "~> 5.0" },
+                        // a stack counts once per group, however many entries reach it
+                        vault: { source: "registry.leak-two.example/leak-org-two/vault" },
+                        consul: { source: "mirror.leak-three.example/leak-org-two/consul" },
+                    },
+                    {
+                        aws: {
+                            source: "registry.terraform.io/hashicorp/aws",
+                            version: "~> 5.0",
+                        },
+                        aws6: { source: "aws", version: "~> 6.0" },
+                    },
+                ],
+            });
+            expect(metrics(await deliveredItems(), "cli.stack.provider")).toEqual([
+                {
+                    value: 3,
+                    provider: "hashicorp/aws",
+                    version_constraint: "~> 5.0",
+                    binding: "generated",
+                },
+                { value: 2, provider: "private-registry", binding: "prebuilt" },
+                {
+                    value: 1,
+                    provider: "hashicorp/aws",
+                    version_constraint: "~> 6.0",
+                    binding: "generated",
+                },
+            ]);
+            expect(envelopeBodies.join("\n")).not.toContain("leak");
+        });
+        it("sums the group sizes of the stacks in a group and the paths of an override type", async () => {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [
+                    {
+                        backend: "local",
+                        overrides: { aws_s3_bucket: ["a", "b", "c"], "bad key 1": ["x"] },
+                        imports: { aws_s3_bucket: ["id"] },
+                    },
+                    {
+                        backend: "local",
+                        overrides: {
+                            aws_s3_bucket: ["a"],
+                            "bad key 2": ["x"],
+                            "bad key 3": ["x", "y", "z"],
+                        },
+                        moved: { aws_s3_bucket: ["id", "id"] },
+                    },
+                ],
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toEqual([
+                {
+                    value: 2,
+                    backend: "local",
+                    cloud: false,
+                    override_count: 9,
+                    import_count: 1,
+                    moved_count: 2,
+                },
+            ]);
+            expect(metrics(items, "cli.stack.override")).toEqual([
+                { value: 2, resource_type: "aws_s3_bucket", override_count: 4 },
+                { value: 2, resource_type: "other", override_count: 5 },
+            ]);
+        });
+        it("keeps the 32 most required providers and folds the rest into one truncated count", async () => {
+            const sources = Array.from({ length: 40 }, (_, k) => `acme/p${String(k).padStart(2, "0")}`);
+            // provider k is required by 40 - k stacks
+            const requiredByStack = sources.map((_, stack) => Object.fromEntries(sources
+                .slice(0, sources.length - stack)
+                .map((source, k) => [`p${k}`, { source }])));
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: sources.map(() => ({})),
+                requiredProviders: requiredByStack,
+            });
+            const providers = metrics(await deliveredItems(), "cli.stack.provider");
+            expect(providers).toEqual([
+                ...sources.slice(0, 32).map((provider, k) => ({
+                    value: 40 - k,
+                    provider,
+                    binding: "prebuilt",
+                })),
+                { value: 36, truncated: true },
+            ]);
+            expect(providers.reduce((total, p) => total + p.value, 0)).toBe(820);
+        });
+        it("keeps the first 32 override types by name on a tie and folds the rest with their paths", async () => {
+            const types = Array.from({ length: 34 }, (_, k) => `aws_t${String(k).padStart(2, "0")}`);
+            const longer = {
+                aws_t32: ["a", "b"],
+                aws_t33: ["a", "b", "c"],
+            };
+            const paths = (type) => { var _a; return (_a = longer[type]) !== null && _a !== void 0 ? _a : ["a"]; };
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [
+                    {
+                        overrides: Object.fromEntries([...types].reverse().map((type) => [type, paths(type)])),
+                    },
+                ],
+            });
+            expect(metrics(await deliveredItems(), "cli.stack.override")).toEqual([
+                ...types.slice(0, 32).map((resource_type) => ({
+                    value: 1,
+                    resource_type,
+                    override_count: 1,
+                })),
+                { value: 2, override_count: 5, truncated: true },
+            ]);
+        });
+        it("keeps the 8 largest stack groups and folds the rest with their group sizes", async () => {
+            // library version 0.k.0 is used by k + 1 stacks, each with one import
+            const stacksOfVersion = (k) => Array.from({ length: k + 1 }, () => ({
+                version: `0.${k}.0`,
+                backend: "s3",
+                imports: { aws_s3_bucket: ["id"] },
+            }));
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: Array.from({ length: 10 }, (_, k) => stacksOfVersion(k)).flat(),
+            });
+            const stacks = metrics(await deliveredItems(), "cli.stack");
+            expect(stacks).toEqual([
+                ...[9, 8, 7, 6, 5, 4, 3, 2].map((k) => ({
+                    value: k + 1,
+                    backend: "s3",
+                    cloud: false,
+                    library_version: `0.${k}.0`,
+                    ...noCounts,
+                    import_count: k + 1,
+                })),
+                { value: 3, truncated: true, ...noCounts, import_count: 3 },
+            ]);
+            expect(stacks.reduce((total, s) => total + s.value, 0)).toBe(55);
+        });
+        it("bounds the stack events of a run whatever the project's shape, in the envelope of the command metric", async () => {
+            const forty = Array.from({ length: 40 }, (_, k) => k);
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                stackMetadata: Array.from({ length: 300 }, (_, i) => ({
+                    version: `1.${i}.0`,
+                    overrides: Object.fromEntries(forty.map((k) => [`aws_type_${k}`, ["tags"]])),
+                })),
+                requiredProviders: Array.from({ length: 300 }, () => Object.fromEntries(forty.map((k) => [`p${k}`, { source: `acme/p${k}` }]))),
+            });
+            const items = await deliveredItems();
+            const count = (name) => metrics(items, name).length;
+            const total = (name) => metrics(items, name).reduce((sum, m) => sum + m.value, 0);
+            expect([
+                count("cli.stack"),
+                count("cli.stack.provider"),
+                count("cli.stack.override"),
+            ]).toEqual([9, 33, 33]);
+            expect(total("cli.stack")).toBe(300);
+            expect(total("cli.stack.provider")).toBe(300 * 40);
+            expect(count("cli.command.completed")).toBe(1);
+            expect(envelopeBodies).toHaveLength(1);
+        });
+        it("leaves the stacks to the command when its synth is nested: only the selected ones, under its name", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("deploy");
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                totalTime: 42,
+                stackMetadata,
+                requiredProviders,
+            });
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                stackMetadata: stackMetadata.slice(1),
+                requiredProviders: requiredProviders.slice(1),
+            });
+            const items = await deliveredItems();
+            expect(items
+                .filter((i) => i.name.startsWith("cli.stack"))
+                .map((i) => [i.name, attributeValues(i).command, i.value])).toEqual([
+                ["cli.stack", "deploy", 1],
+                ["cli.stack.provider", "deploy", 1],
+                ["cli.stack.provider", "deploy", 1],
+            ]);
+            expect(items.some((i) => i.name === "cli.synth.duration" &&
+                attributeValues(i).command === "synth")).toBe(true);
+        });
+        it("reports the stacks of a synth run under synth", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            await (0, telemetry_1.sendTelemetry)("synth", { stackMetadata, requiredProviders });
+            const stacks = (await deliveredItems()).filter((i) => i.name === "cli.stack");
+            expect(stacks.map((i) => attributeValues(i).command)).toEqual([
+                "synth",
+                "synth",
+            ]);
+        });
+        it("reports the stacks once per process: a watch session's later deploys add only their failures", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("watch");
+            await (0, telemetry_1.sendTelemetry)("deploy", { stackMetadata, requiredProviders });
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 1,
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toHaveLength(2);
+            expect(metrics(items, "cli.stack.provider")).toHaveLength(5);
+            expect(metrics(items, "cli.stack.override")).toHaveLength(3);
+            expect(metrics(items, "cli.stack.failed")).toEqual([{ value: 1 }]);
+        });
+        it("counts failed stacks and never serializes their failure messages", async () => {
+            await (0, telemetry_1.sendTelemetry)("destroy", {
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 2,
+                failedStacks: ["failed to destroy SECRET-STACK-NAME: /Users/x/state"],
+            });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            const failed = items.find((i) => i.name === "cli.stack.failed");
+            expect(failed.value).toBe(2);
+            expect(failed.attributes.command.value).toBe("destroy");
+            // the failure thrown next is counted as cli.command.error, not here
+            expect(items.some((i) => i.name === "cli.command.completed")).toBe(false);
+            expect(envelopeBodies.join("\n")).not.toContain("failed to destroy");
+            expect(envelopeBodies.join("\n")).not.toContain("/Users/x");
+        });
+        it("counts no completed run and no failed stack for a run that failed before any stack did", async () => {
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 0,
+                runFailed: true,
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toHaveLength(2);
+            expect(metrics(items, "cli.stack.failed")).toEqual([]);
+            expect(items.some((i) => i.name === "cli.command.completed")).toBe(false);
+        });
+        it("never serializes stack names, resource ids or module paths", async () => {
+            await (0, telemetry_1.sendTelemetry)("deploy", {
+                language: "typescript",
+                stackMetadata,
+                requiredProviders,
+                failedStackCount: 1,
+            });
+            const items = await deliveredItems();
+            // the scan below is over two stacks, three override types, five
+            // providers and the failed count
+            expect(items.filter((i) => i.name.startsWith("cli.stack"))).toHaveLength(11);
+            const bytes = envelopeBodies.join("\n");
+            expect(bytes).not.toContain("SECRET-STACK-NAME");
+            expect(bytes).not.toContain("secret-resource-id");
+            expect(bytes).not.toContain("secret-path");
+            expect(bytes).not.toContain("tfe.corp.example.com");
+            expect(bytes).not.toContain("acme-org");
+        });
+        // the metadata is read from disk, written by whatever library version
+        // the project has
+        it("tolerates malformed metadata entries and counts only the real stacks", async () => {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [null, "nope", { overrides: "nope", imports: [] }],
+                requiredProviders: [undefined, undefined, { aws: "nope" }],
+            });
+            const items = await deliveredItems();
+            expect(metrics(items, "cli.stack")).toEqual([
+                { value: 1, backend: "unknown", cloud: false, ...noCounts },
+            ]);
+            expect(metrics(items, "cli.stack.override")).toEqual([]);
+            expect(metrics(items, "cli.stack.provider")).toEqual([
+                { value: 1, provider: "hashicorp/aws", binding: "generated" },
+            ]);
+            expect(items.some((i) => i.name === "cli.command.completed")).toBe(true);
+        });
+    });
+    describe("attribute validation", () => {
+        beforeEach(() => {
+            initSentryWithCapturingTransport();
+        });
+        it("omits an unsupported language, read from cdktf.json at start or passed at the end", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "rust; DROP TABLE",
+            });
+            await (0, telemetry_1.startCommandTelemetry)("convert");
+            await (0, telemetry_1.sendTelemetry)("convert", { language: "cobol; DROP TABLE" });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => i.name)).toEqual([
+                "cli.command.invoked",
+                "cli.command.completed",
+            ]);
+            for (const item of items) {
+                expect(item.attributes).not.toHaveProperty("language");
+            }
+            expect(envelopeBodies.join("\n")).not.toContain("DROP TABLE");
+        });
+        it.each([
+            ["synth", { synthOrigin: "watch" }, "synth_origin", "watch"],
+            ["synth", { synthOrigin: "/Users/x" }, "synth_origin", undefined],
+            ["init", { isRemote: true }, "is_remote", true],
+            ["init", { template: "go" }, "template", "go"],
+            ["convert", { numberOfProviders: 2 }, "provider_count", 2],
+            ["convert", { numberOfModules: 1 }, "module_count", 1],
+            ["convert", { convertedLines: 42 }, "converted_lines", 42],
+            ["convert", { convertedLines: "42" }, "converted_lines", undefined],
+            ["convert", { convertedLines: NaN }, "converted_lines", undefined],
+        ])("%s: %j forwards %s as %j", async (command, payload, attribute, expected) => {
+            await (0, telemetry_1.sendTelemetry)(command, payload);
+            expect(await Sentry.flush(2000)).toBe(true);
+            const completed = parseMetricItems(envelopeBodies).find((i) => i.name === "cli.command.completed");
+            if (expected === undefined) {
+                expect(completed.attributes).not.toHaveProperty(attribute);
+            }
+            else {
+                expect(attributeValues(completed)[attribute]).toBe(expected);
+            }
+        });
+        it.each([
+            [">= 1.9.0", ">=1.9.0"],
+            ["~1.8", ">=1.8.0 <1.9.0-0"],
+            ["1.2.3 - 2.0.0", ">=1.2.3 <=2.0.0"],
+            [">=1.0.0 <2.0.0 || 1.2.3", ">=1.0.0 <2.0.0||1.2.3"],
+            ["latest /Users/x", "invalid"],
+            [">= 1.0.0-LEAK-TV-PRERELEASE.corp.example.com", "invalid"],
+            ["1.2.3-acme.internal", "invalid"],
+            ["1.2.3+LEAK-TV-BUILD.johns-macbook", "invalid"],
+            [">=1.0.0 <2.0.0 || 1.2.3-LEAK-OR.host", "invalid"],
+            [">=1.0.0 " + "||1.0.0 ".repeat(10), "invalid"],
+        ])("forwards the declared target %p as %p", (range, expected) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                targetVersions: { terraform: range },
+            });
+            expect((0, telemetry_1.getProjectTargetAttributes)(workdir).target_terraform).toBe(expected);
+        });
+        it("reduces a backend outside the built-in kinds and override keys outside the type grammar to other", async () => {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [
+                    {
+                        version: "0.21.0+build." + "x".repeat(40),
+                        backend: "s3 bucket=/Users/x/state",
+                        overrides: {
+                            aws_s3_bucket: ["tags"],
+                            terraform_remote_state: ["backend"],
+                            "module.terraform-aws-modules/vpc/aws": ["providers"],
+                            "resource with spaces /Users/x": ["tags"],
+                            AWS_S3_Bucket: ["tags"],
+                            ["aws_" + "x".repeat(70)]: ["tags"],
+                        },
+                    },
+                    { version: "dev-/Users/x", backend: "S3" },
+                    { version: "dev-/Users/x" },
+                ],
+            });
+            const items = await deliveredItems();
+            // build metadata is stripped like binary_version; a version without a
+            // MAJOR.MINOR.PATCH prefix yields no attribute at all
+            expect(metrics(items, "cli.stack").map((stack) => [
+                stack.backend,
+                stack.library_version,
+            ])).toEqual([
+                ["other", "0.21.0"],
+                ["other", undefined],
+                ["unknown", undefined],
+            ]);
+            expect(metrics(items, "cli.stack.override").map((o) => [
+                o.resource_type,
+                o.override_count,
+            ])).toEqual([
+                ["aws_s3_bucket", 1],
+                ["module.terraform-aws-modules/vpc/aws", 1],
+                ["other", 3],
+                ["terraform_remote_state", 1],
+            ]);
+            expect(envelopeBodies.join("\n")).not.toContain("/Users/x");
+        });
+    });
+    describe("provider binding classification", () => {
+        beforeEach(() => {
+            initSentryWithCapturingTransport();
+        });
+        async function bindingOf(source) {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [{}],
+                requiredProviders: [{ provider: { source } }],
+            });
+            return metrics(await deliveredItems(), "cli.stack.provider").map((provider) => provider.binding);
+        }
+        it.each([
+            ["aws", "generated"],
+            ["Hashicorp/Random", "generated"],
+            ["kreuzwerker/docker", "generated"],
+            ["hashicorp/google", "generated"],
+            ["azurerm", "generated"],
+            ["hashicorp/null", "prebuilt"],
+            ["tfe.corp.example.com/acme-org/vault", "generated"],
+            // another private source is not the generated one, even though both
+            // reach the metric as "private-registry"
+            ["tfe.corp.example.com/other-org/vault", "prebuilt"],
+        ])("sends the required provider %s as %s for the project's terraformProviders", async (source, expected) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                terraformProviders: [
+                    "aws@~>5.0",
+                    "hashicorp/random@3.6.0",
+                    "registry.terraform.io/kreuzwerker/docker",
+                    { name: "google", source: "hashicorp/google", version: "~> 5.0" },
+                    { name: "azurerm" },
+                    { version: "1.0.0" },
+                    42,
+                    "TFE.corp.example.com/acme-org/vault@~>3.0",
+                ],
+            });
+            expect(await bindingOf(source)).toEqual([expected]);
+        });
+        it("sends every provider as prebuilt when terraformProviders is not a list", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                terraformProviders: "aws",
+            });
+            expect(await bindingOf("aws")).toEqual(["prebuilt"]);
+        });
+    });
+    describe("source normalization", () => {
+        beforeEach(() => {
+            initSentryWithCapturingTransport();
+        });
+        it.each([
+            ["aws", "hashicorp/aws"],
+            ["aws@~>5.0", "hashicorp/aws"],
+            ["Hashicorp/AWS@5.1.0", "hashicorp/aws"],
+            ["registry.terraform.io/hashicorp/aws", "hashicorp/aws"],
+            ["registry.opentofu.org/hashicorp/aws", "hashicorp/aws"],
+            ["tfe.leak-host.example/leak-org/aws", "private-registry"],
+            ["localhost:8080/leak-org/aws", "private-registry"],
+            ["./leak-provider", "other"],
+            ["../leak/provider", "other"],
+            ["/abs/leak/provider", "other"],
+            ["leak-a/b/c", "other"],
+            ["", "other"],
+            ["registry.terraform.io/leak-namespace", "other"],
+            [`${"n".repeat(65)}/aws`, "other"],
+            [`${"n".repeat(64)}/aws`, `${"n".repeat(64)}/aws`],
+            [`${"n".repeat(64)}/${"t".repeat(64)}`, "other"],
+        ])("sends the provider source %s as %s", async (source, expected) => {
+            await (0, telemetry_1.sendTelemetry)("get", { targets: [{ type: "provider", source }] });
+            expect(metrics(await deliveredItems(), "cli.get.provider").map((item) => item.provider)).toEqual([expected]);
+            expect(envelopeBodies.join("\n")).not.toContain("leak");
+        });
+        it.each([
+            ["terraform-aws-modules/vpc/aws", "terraform-aws-modules/vpc/aws"],
+            ["Terraform-AWS-Modules/VPC/aws", "terraform-aws-modules/vpc/aws"],
+            // one row per fallthrough: everything the grammar rejects is "other"
+            ["Terraform-AWS-Modules/leak-vpc/aws?ref=v5.0.0", "other"],
+            [`${"n".repeat(64)}/vpc/aws`, `${"n".repeat(64)}/vpc/aws`],
+            [`${"n".repeat(65)}/vpc/aws`, "other"],
+            ["app.terraform.io/leak-org/vpc/aws", "private-registry"],
+            ["./modules/leak-vpc", "local"],
+            ["../shared/leak-vpc", "local"],
+            ["/abs/path/leak-vpc", "local"],
+            ["git@github.com:leak-org/repo.git", "git"],
+            ["github.com/leak-org/repo", "git"],
+            ["bitbucket.org/leak-org/repo", "git"],
+            ["https://leak-host.example/vpc.zip", "git"],
+            ["s3-eu-west-1.amazonaws.com/leak-bucket/vpc.zip", "git"],
+            ["www.googleapis.com/storage/v1/leak-bucket/vpc", "git"],
+            // forced getters without a URL scheme behind them
+            ["git::leak-host.example/leak-org/repo.git", "git"],
+            ["hg::leak-host.example/leak-repo", "git"],
+            ["s3::leak-bucket/vpc.zip", "git"],
+            ["gcs::leak-bucket/vpc", "git"],
+        ])("sends the module source %s as %s", async (source, expected) => {
+            await (0, telemetry_1.sendTelemetry)("get", { targets: [{ type: "module", source }] });
+            expect(metrics(await deliveredItems(), "cli.get.module").map((item) => item.module)).toEqual([expected]);
+            expect(envelopeBodies.join("\n")).not.toContain("leak");
+        });
+        it.each([
+            [">= 1.2, < 2.0", ">= 1.2, < 2.0"],
+            ["~> 5.0", "~> 5.0"],
+            ["= 1.0", "= 1.0"],
+            ["!= 1.2.3", "!= 1.2.3"],
+            ["1.2.3", "1.2.3"],
+            ["  >= 1.0 ,  < 2.0  ", ">= 1.0, < 2.0"],
+            ["~>5.0,!=5.1.0", "~> 5.0, != 5.1.0"],
+            [">= 1.0.0-leak-prerelease.corp", "invalid"],
+            ["1.2.3+leak-build.host", "invalid"],
+            ["~> 5.0 # /Users/leak", "invalid"],
+            [">= 1.2 || < 2.0", "invalid"],
+            // valid by the grammar, over the length a constraint may have
+            [Array(12).fill("!= 1.0.0").join(", "), "invalid"],
+        ])("sends the provider constraint %p as %p", async (version, expected) => {
+            await (0, telemetry_1.sendTelemetry)("synth", {
+                stackMetadata: [{}],
+                requiredProviders: [{ aws: { source: "aws", version } }],
+            });
+            expect(metrics(await deliveredItems(), "cli.stack.provider").map((provider) => provider.version_constraint)).toEqual([expected]);
+            expect(envelopeBodies.join("\n")).not.toContain("leak");
+        });
+    });
+    describe("package manager", () => {
+        beforeEach(() => {
+            initSentryWithCapturingTransport();
+        });
+        afterEach(() => {
+            jest.dontMock("./node-package-manager");
+        });
+        // a copy of the module whose node detector is replaced
+        function telemetryWithNodeDetector(detect) {
+            let copy;
+            jest.isolateModules(() => {
+                jest.doMock("./node-package-manager", () => ({
+                    detectNodePackageManager: detect,
+                }));
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                copy = require("./telemetry");
+            });
+            return copy;
+        }
+        // one successful and one failed end, so every command metric is covered
+        async function runMetrics(telemetry = { startCommandTelemetry: telemetry_1.startCommandTelemetry, sendTelemetry: telemetry_1.sendTelemetry }) {
+            await telemetry.startCommandTelemetry("synth");
+            await telemetry.sendTelemetry("synth", {});
+            await telemetry.sendTelemetry("synth", { error: true });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => i.name)).toEqual([
+                "cli.command.invoked",
+                "cli.command.completed",
+                "cli.command.error",
+            ]);
+            return items;
+        }
+        it.each([
+            ["no lockfile", "npm", {}],
+            ["a pnpm lockfile", "pnpm", { "pnpm-lock.yaml": "" }],
+            ["a yarn lockfile", "yarn", { "yarn.lock": "" }],
+            ["a .yarnrc.yml", "yarn-berry", { ".yarnrc.yml": "" }],
+            [
+                "a declared npm",
+                "npm",
+                { "package.json": '{"packageManager":"npm@10.8.2"}' },
+            ],
+            [
+                "a declared pnpm with a hash",
+                "pnpm",
+                { "package.json": '{"packageManager":"pnpm@10.26.0+sha512.LEAK"}' },
+            ],
+            [
+                "a declared yarn 1",
+                "yarn",
+                { "package.json": '{"packageManager":"yarn@1.22.22"}' },
+            ],
+            [
+                "a declared yarn 4",
+                "yarn-berry",
+                { "package.json": '{"packageManager":"yarn@4.1.0"}' },
+            ],
+            [
+                "an unknown declared manager",
+                "npm",
+                { "package.json": '{"packageManager":"bun@1.1.0-LEAK"}' },
+            ],
+        ])("reports a typescript project with %s as %p on every command metric", async (_name, expected, files) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+            });
+            for (const [name, content] of Object.entries(files)) {
+                fs.writeFileSync(path.join(workdir, name), content);
+            }
+            for (const item of await runMetrics()) {
+                expect(attributeValues(item).package_manager).toBe(expected);
+            }
+            const bytes = envelopeBodies.join("\n");
+            expect(bytes).not.toContain("LEAK");
+            expect(bytes).not.toContain("10.26.0");
+        });
+        it.each([
+            ["python", { app: "pipenv run python main.py" }, {}, "pipenv"],
+            ["python", { app: "python3 main.py" }, {}, "pip"],
+            ["java", {}, { "build.gradle": "" }, "gradle"],
+            ["java", {}, { "pom.xml": "" }, "maven"],
+            ["csharp", {}, {}, "nuget"],
+            ["go", {}, {}, "go"],
+        ])("reports a %s project with %j and files %j as %p", async (language, config, files, expected) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language,
+                ...config,
+            });
+            for (const [name, content] of Object.entries(files)) {
+                fs.writeFileSync(path.join(workdir, name), content);
+            }
+            for (const item of await runMetrics()) {
+                expect(attributeValues(item).package_manager).toBe(expected);
+            }
+        });
+        it.each([
+            ["no cdktf.json", undefined],
+            ["an unsupported language", { language: "rust" }],
+            ["no language", { app: "pipenv run python main.py" }],
+            ["a python project without an app command", { language: "python" }],
+        ])("omits the attribute with %s", async (_name, cdktfJson) => {
+            if (cdktfJson) {
+                fs.writeJsonSync(path.join(workdir, "cdktf.json"), cdktfJson);
+            }
+            // lockfiles alone never identify a project
+            fs.writeFileSync(path.join(workdir, "pnpm-lock.yaml"), "");
+            fs.writeFileSync(path.join(workdir, "build.gradle"), "");
+            for (const item of await runMetrics()) {
+                expect(item.attributes).not.toHaveProperty("package_manager");
+            }
+        });
+        it("keeps the value detected at start when the cwd changes before the end", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+            });
+            fs.writeFileSync(path.join(workdir, "pnpm-lock.yaml"), "");
+            const elsewhere = fs.mkdtempSync(path.join(os.tmpdir(), "cdktn-else-"));
+            try {
+                await (0, telemetry_1.startCommandTelemetry)("convert");
+                process.chdir(elsewhere);
+                await (0, telemetry_1.sendTelemetry)("convert", {});
+                await (0, telemetry_1.sendTelemetry)("convert", { error: true });
+                expect(await Sentry.flush(2000)).toBe(true);
+            }
+            finally {
+                process.chdir(workdir);
+                fs.removeSync(elsewhere);
+            }
+            const items = parseMetricItems(envelopeBodies);
+            expect(items).toHaveLength(3);
+            for (const item of items) {
+                expect(attributeValues(item).package_manager).toBe("pnpm");
+            }
+        });
+        it("forgets the value with the run", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), { language: "go" });
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            (0, telemetry_1.resetCommandTelemetry)();
+            await (0, telemetry_1.sendTelemetry)("synth", {});
+            expect(await Sentry.flush(2000)).toBe(true);
+            const completed = parseMetricItems(envelopeBodies).find((i) => i.name === "cli.command.completed");
+            expect(completed.attributes).not.toHaveProperty("package_manager");
+        });
+        it("omits a detector value outside the closed set", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+            });
+            const telemetry = telemetryWithNodeDetector(() => "bun@1.1.0 /Users/x");
+            for (const item of await runMetrics(telemetry)) {
+                expect(item.attributes).not.toHaveProperty("package_manager");
+            }
+            expect(envelopeBodies.join("\n")).not.toContain("bun");
+        });
+        it("omits the attribute when detection throws", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "typescript",
+            });
+            const telemetry = telemetryWithNodeDetector(() => {
+                throw new Error("EACCES");
+            });
+            for (const item of await runMetrics(telemetry)) {
+                expect(item.attributes).not.toHaveProperty("package_manager");
+            }
+        });
+        it("normalizes to members of the closed set only", () => {
+            for (const name of telemetry_1.PACKAGE_MANAGERS) {
+                expect((0, telemetry_1.normalizePackageManager)(name)).toBe(name);
+            }
+            for (const value of [
+                "bun",
+                "NPM",
+                "pnpm@10.26.0+sha512.abc",
+                "/usr/local/bin/npm",
+                "",
+                1,
+                null,
+                undefined,
+                ["npm"],
+            ]) {
+                expect((0, telemetry_1.normalizePackageManager)(value)).toBeUndefined();
+            }
+        });
+    });
+    describe("run lifecycle", () => {
+        beforeEach(() => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "python",
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+        });
+        it("counts the run once as invoked at start, even when reporting is initialized again", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("init");
+            // init runs get, which initializes reporting a second time
+            await (0, telemetry_1.startCommandTelemetry)("get");
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => i.name)).toEqual(["cli.command.invoked"]);
+            expect(attributeValues(items[0])).toMatchObject({
+                command: "init",
+                language: "python",
+            });
+        });
+        it("counts only the run's own command as completed; a nested operation adds its own metrics", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("deploy");
+            await (0, telemetry_1.sendTelemetry)("synth", { totalTime: 42, language: "python" });
+            await (0, telemetry_1.sendTelemetry)("deploy", { language: "python" });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => [i.name, attributeValues(i).command])).toEqual([
+                ["cli.command.invoked", "deploy"],
+                ["cli.synth.duration", "synth"],
+                ["cli.command.completed", "deploy"],
+            ]);
+        });
+        it("counts a failed run once as error, never as completed", async () => {
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            await (0, telemetry_1.sendTelemetry)("synth", { error: true, errorType: "External" });
+            expect(await Sentry.flush(2000)).toBe(true);
+            expect(parseMetricItems(envelopeBodies).map((i) => i.name)).toEqual([
+                "cli.command.invoked",
+                "cli.command.error",
+            ]);
+        });
+        it("emits nothing at start when usage telemetry is off, and stays a no-op afterwards", async () => {
+            (0, telemetry_1.setUsageTelemetryEnabled)(false);
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            (0, telemetry_1.setUsageTelemetryEnabled)(true);
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            await Sentry.flush(2000);
+            expect(parseMetricItems(envelopeBodies)).toHaveLength(0);
+        });
+    });
+    // the bundle has one copy of this module per entry point: bin/cmds/handlers.js
+    // captures the decision and starts the run, bin/cdktn.js counts the failure
+    describe("shared across module copies", () => {
+        let second;
+        beforeEach(() => {
+            jest.isolateModules(() => {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                second = require("./telemetry");
+            });
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "go",
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+        });
+        it("observes the captured decision and targets, the started command and its language from the other copy", async () => {
+            // the project opts out; only the decision captured by the first copy
+            // lets the second one emit
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                language: "go",
+                sendUsageTelemetry: false,
+            });
+            (0, telemetry_1.setUsageTelemetryEnabled)(true);
+            (0, telemetry_1.setProjectTargetAttributes)({ target_opentofu: ">=1.7.0" });
+            await (0, telemetry_1.startCommandTelemetry)("deploy");
+            await second.startCommandTelemetry("synth");
+            await second.sendTelemetry("synth", { language: "go" });
+            await second.sendTelemetry("deploy", { error: true, errorType: "Usage" });
+            expect(await Sentry.flush(2000)).toBe(true);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.map((i) => [i.name, attributeValues(i).command])).toEqual([
+                ["cli.command.invoked", "deploy"],
+                ["cli.command.error", "deploy"],
+            ]);
+            expect(attributeValues(items[1])).toMatchObject({
+                language: "go",
+                package_manager: "go",
+                target_opentofu: ">=1.7.0",
+            });
+            expect(items[1].attributes).not.toHaveProperty("target_terraform");
+        });
+    });
+    describe("sendTelemetry gating", () => {
+        it.each([
+            { env: undefined, captured: undefined, flag: undefined, emits: true },
+            { env: undefined, captured: undefined, flag: true, emits: true },
+            { env: undefined, captured: undefined, flag: false, emits: false },
+            // convert chdirs into a throwaway project that opts out
+            { env: undefined, captured: true, flag: false, emits: true },
+            { env: undefined, captured: false, flag: true, emits: false },
+            { env: "1", captured: undefined, flag: true, emits: false },
+            { env: "1", captured: true, flag: true, emits: false },
+        ])("CHECKPOINT_DISABLE=$env, captured=$captured, flag=$flag -> emits $emits", async ({ env, captured, flag, emits }) => {
+            if (flag !== undefined) {
+                fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                    sendUsageTelemetry: flag,
+                });
+            }
+            initSentryWithCapturingTransport();
+            (0, telemetry_1.setUsageTelemetryEnabled)(captured);
+            if (env !== undefined) {
+                process.env.CHECKPOINT_DISABLE = env;
+            }
+            await (0, telemetry_1.startCommandTelemetry)("convert");
+            await (0, telemetry_1.sendTelemetry)("convert", {});
+            await Sentry.flush(2000);
+            const items = parseMetricItems(envelopeBodies);
+            expect(items.some((i) => i.name === "cli.command.invoked")).toBe(emits);
+            expect(items.some((i) => i.name === "cli.command.completed")).toBe(emits);
+            if (!emits) {
+                expect(items).toHaveLength(0);
+            }
+        });
+    });
+    describe("cli.error from the Errors factories", () => {
+        afterEach(() => {
+            errors_1.Errors.setScope("unknown");
+        });
+        // the scope is read when the error is built, not when the factory is
+        // created: a factory-time binding reports every error as "unknown"
+        it("counts constructed errors by type with the command set at call time", async () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                sendUsageTelemetry: true,
+            });
+            initSentryWithCapturingTransport();
+            errors_1.Errors.setScope("deploy");
+            errors_1.Errors.Usage("no stacks selected", undefined, { stackName: "secret" });
+            errors_1.Errors.External("terraform exited with code 1");
+            expect(await Sentry.flush(2000)).toBe(true);
+            const errors = parseMetricItems(envelopeBodies).filter((i) => i.name === "cli.error");
+            expect(errors).toHaveLength(2);
+            expect(errors.map((e) => e.attributes.type.value)).toEqual([
+                "Usage",
+                "External",
+            ]);
+            for (const error of errors) {
+                expect(error.attributes.command.value).toBe("deploy");
+                expect(error.attributes).not.toHaveProperty("message");
+                expect(error.attributes).not.toHaveProperty("stackName");
+            }
+            expect(JSON.stringify(errors)).not.toContain("secret");
+            expect(JSON.stringify(errors)).not.toContain("no stacks selected");
+        });
+    });
+    describe("binary attributes", () => {
+        async function invokedAttributes(versionOutput) {
+            (0, terraform_1.seedTerraformCliProbeForTests)(Promise.resolve(versionOutput));
+            initSentryWithCapturingTransport();
+            await (0, telemetry_1.startCommandTelemetry)("synth");
+            expect(await Sentry.flush(2000)).toBe(true);
+            return attributeValues(parseMetricItems(envelopeBodies)[0]);
+        }
+        it.each([
+            ["Terraform v1.10.0-alpha20250101", "terraform", "1.10.0"],
+            [
+                "OpenTofu v1.2.3-LEAK-HOST.corp.example.com+LEAK-BUILD/Users/x",
+                "opentofu",
+                "1.2.3",
+            ],
+        ])("reduces the probed version of %p to its release", async (versionOutput, binary, release) => {
+            expect(await invokedAttributes(versionOutput)).toMatchObject({
+                binary,
+                binary_version: release,
+            });
+            expect(envelopeBodies.join("\n")).not.toContain("LEAK");
+        });
+        it("sends no version for an unrecognised product: a wrapper's output has no product version line", async () => {
+            const attributes = await invokedAttributes("connected to 10.0.0.1 as LEAK-USER (wrapper 3.4.5)\nTerraform v1.9.0\n");
+            expect(attributes.binary).toBe("unknown");
+            expect(attributes).not.toHaveProperty("binary_version");
+            expect(envelopeBodies.join("\n")).not.toContain("LEAK-USER");
+        });
+    });
+    describe("getProjectTargetAttributes", () => {
+        it("reads declared targets and the validation flag", () => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), {
+                targetVersions: { opentofu: "~1.8" },
+                validateInstalledBinary: true,
+            });
+            expect((0, telemetry_1.getProjectTargetAttributes)(workdir)).toEqual({
+                targets_declared: true,
+                validate_installed_binary: true,
+                target_opentofu: ">=1.8.0 <1.9.0-0",
+            });
+        });
+        it.each([
+            [{}],
+            [{ targetVersions: "nope" }],
+            [{ targetVersions: [] }],
+            [undefined],
+        ])("falls back to the defaults for a cdktf.json of %j", (config) => {
+            if (config) {
+                fs.writeJsonSync(path.join(workdir, "cdktf.json"), config);
+            }
+            expect((0, telemetry_1.getProjectTargetAttributes)(workdir)).toEqual({
+                targets_declared: false,
+                validate_installed_binary: false,
+                ...DEFAULT_TARGET_VERSIONS_AS_ATTRIBUTES,
+            });
+        });
+    });
+    describe("getUsageTelemetryConsent", () => {
+        it.each([
+            // init templates render the flag as a string; a boolean-only check
+            // would opt every freshly init'ed project out
+            [{ sendUsageTelemetry: "true" }, true],
+            [{ sendUsageTelemetry: "false" }, false],
+            [{}, undefined],
+            // malformed is unset, not an opt-out
+            [{ sendUsageTelemetry: "yes" }, undefined],
+        ])("reads %j as %p", (config, expected) => {
+            fs.writeJsonSync(path.join(workdir, "cdktf.json"), config);
+            expect((0, telemetry_1.getUsageTelemetryConsent)(workdir)).toBe(expected);
+        });
+        it("returns undefined when no cdktf.json exists", () => {
+            expect((0, telemetry_1.getUsageTelemetryConsent)(workdir)).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.test.js","sourceRoot":"","sources":["../src/telemetry.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as Sentry from \"@sentry/node\";\nimport * as fs from \"fs-extra\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport {\n  sendTelemetry,\n  startCommandTelemetry,\n  resetCommandTelemetry,\n  getProjectTargetAttributes,\n  getUsageTelemetryConsent,\n  normalizePackageManager,\n  PACKAGE_MANAGERS,\n  setProjectTargetAttributes,\n  setUsageTelemetryEnabled,\n} from \"./telemetry\";\nimport { seedTerraformCliProbeForTests } from \"./terraform\";\nimport {\n  DEFAULT_TARGET_VERSIONS,\n  Language,\n  TerraformModuleConstraint,\n  TerraformProviderConstraint,\n} from \"./config\";\nimport {\n  ConstructsMakerModuleTarget,\n  ConstructsMakerProviderTarget,\n} from \"./construct-maker-target\";\nimport { Errors } from \"./errors\";\n\nconst DEFAULT_TARGET_VERSIONS_AS_ATTRIBUTES = {\n  target_terraform: DEFAULT_TARGET_VERSIONS.terraform,\n  target_opentofu: DEFAULT_TARGET_VERSIONS.opentofu,\n};\n\n// A real client with a capturing transport proves the metric envelope\n// reaches the transport and survives a bounded flush; a mocked @sentry/node\n// would pass even if metrics were dropped before exit.\n\ntype MetricItem = {\n  name: string;\n  type: string;\n  value: number;\n  attributes: Record<string, { value: unknown; type: string }>;\n};\n\n// Mirrors recordEnvelope in tools/sentry-sink.mjs: an envelope-format change\n// is fixed in both.\nfunction parseMetricItems(envelopeBodies: string[]): MetricItem[] {\n  const items: MetricItem[] = [];\n  for (const body of envelopeBodies) {\n    const lines = body.split(\"\\n\").filter(Boolean);\n    for (let i = 0; i < lines.length - 1; i++) {\n      let header;\n      try {\n        header = JSON.parse(lines[i]);\n      } catch {\n        continue;\n      }\n      if (header.type === \"trace_metric\") {\n        const payload = JSON.parse(lines[i + 1]);\n        items.push(...payload.items);\n      }\n    }\n  }\n  return items;\n}\n\nfunction attributeValues(item: MetricItem) {\n  return Object.fromEntries(\n    Object.entries(item.attributes).map(([k, v]) => [k, v.value]),\n  );\n}\n\n// On every metric of a command; the exact set is pinned once, on\n// cli.command.completed.\nconst COMMAND_ATTRIBUTES = [\n  \"arch\",\n  \"binary\",\n  \"binary_version\",\n  \"ci\",\n  \"command\",\n  \"language\",\n  \"os\",\n  \"package_manager\",\n  \"server.address\",\n  \"target_opentofu\",\n  \"target_terraform\",\n  \"targets_declared\",\n  \"validate_installed_binary\",\n];\n\n// Each metric of that name as its value plus exactly the attributes it adds\n// to the command's, so `toEqual` fails on any attribute that is not listed.\nfunction metrics(items: MetricItem[], name: string): Record<string, any>[] {\n  return items\n    .filter((item) => item.name === name)\n    .map((item) => ({\n      value: item.value,\n      ...Object.fromEntries(\n        Object.entries(attributeValues(item)).filter(\n          ([key]) =>\n            !key.startsWith(\"sentry.\") && !COMMAND_ATTRIBUTES.includes(key),\n        ),\n      ),\n    }));\n}\n\ndescribe(\"telemetry\", () => {\n  let workdir: string;\n  let envelopeBodies: string[];\n  const originalCwd = process.cwd();\n  const originalCheckpointDisable = process.env.CHECKPOINT_DISABLE;\n  const originalSentryEnvironment = process.env.SENTRY_ENVIRONMENT;\n\n  function initSentryWithCapturingTransport() {\n    Sentry.init({\n      dsn: \"https://public@example.invalid/1\",\n      release: \"cdktn-cli-test\",\n      environment: \"production\",\n      tracesSampleRate: 0,\n      serverName: \"cdktn-cli\",\n      // each test inits its own client; process-level integrations would\n      // pile up listeners across tests and are irrelevant to metrics\n      defaultIntegrations: false,\n      transport: (options) =>\n        Sentry.createTransport(options, async (request) => {\n          envelopeBodies.push(request.body as string);\n          return { statusCode: 200 };\n        }),\n    });\n  }\n\n  async function deliveredItems(): Promise<MetricItem[]> {\n    expect(await Sentry.flush(2000)).toBe(true);\n    return parseMetricItems(envelopeBodies);\n  }\n\n  beforeEach(() => {\n    workdir = fs.mkdtempSync(path.join(os.tmpdir(), \"cdktn-telemetry-\"));\n    process.chdir(workdir);\n    envelopeBodies = [];\n    delete process.env.CHECKPOINT_DISABLE;\n    delete process.env.SENTRY_ENVIRONMENT;\n    // the probe is process-global (see terraform.ts); a seeded output keeps\n    // the binary attributes independent of the machine running the tests\n    seedTerraformCliProbeForTests(\n      Promise.resolve(\"Terraform v1.9.0\\non darwin_arm64\\n\"),\n    );\n  });\n\n  afterEach(async () => {\n    setUsageTelemetryEnabled(undefined);\n    resetCommandTelemetry();\n    setProjectTargetAttributes(undefined);\n    seedTerraformCliProbeForTests();\n    await Sentry.close(1000);\n    process.chdir(originalCwd);\n    fs.removeSync(workdir);\n    if (originalCheckpointDisable === undefined) {\n      delete process.env.CHECKPOINT_DISABLE;\n    } else {\n      process.env.CHECKPOINT_DISABLE = originalCheckpointDisable;\n    }\n    if (originalSentryEnvironment === undefined) {\n      delete process.env.SENTRY_ENVIRONMENT;\n    } else {\n      process.env.SENTRY_ENVIRONMENT = originalSentryEnvironment;\n    }\n  });\n\n  describe(\"sendTelemetry delivery (real client + capturing transport)\", () => {\n    it(\"stamps the command, language, binary and target attributes on every command metric\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"typescript\",\n        sendUsageTelemetry: true,\n        targetVersions: { terraform: \">=1.9.0\", opentofu: \">=1.8.0\" },\n        validateInstalledBinary: true,\n      });\n      initSentryWithCapturingTransport();\n\n      await startCommandTelemetry(\"synth\");\n      await sendTelemetry(\"synth\", { totalTime: 1234, language: \"typescript\" });\n      await sendTelemetry(\"synth\", { error: true, synthOrigin: \"watch\" });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => i.name)).toEqual([\n        \"cli.command.invoked\",\n        \"cli.command.completed\",\n        \"cli.synth.duration\",\n        \"cli.command.error\",\n      ]);\n      const [invoked, completed, duration, error] = items;\n\n      for (const metric of items) {\n        expect(attributeValues(metric)).toMatchObject({\n          command: \"synth\",\n          os: process.platform,\n          arch: process.arch,\n          binary: \"terraform\",\n          binary_version: \"1.9.0\",\n          target_terraform: \">=1.9.0\",\n          target_opentofu: \">=1.8.0\",\n          targets_declared: true,\n          validate_installed_binary: true,\n        });\n      }\n      // the language comes from cdktf.json at start and from the payload\n      // at the end; the error metric has no payload and reuses the start read\n      expect(attributeValues(invoked).language).toBe(\"typescript\");\n      expect(attributeValues(completed).language).toBe(\"typescript\");\n      expect(duration.type).toBe(\"distribution\");\n      expect(duration.value).toBe(1234);\n      expect(attributeValues(error)).toMatchObject({\n        error_type: \"unexpected\",\n        language: \"typescript\",\n        synth_origin: \"watch\",\n      });\n    });\n\n    it(\"uses the target attributes captured at command start over the current cwd\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        targetVersions: { terraform: \">=1.0.0\" },\n      });\n      initSentryWithCapturingTransport();\n      setProjectTargetAttributes({\n        targets_declared: true,\n        validate_installed_binary: false,\n        target_opentofu: \">=1.7.0\",\n      });\n\n      await startCommandTelemetry(\"convert\");\n      await sendTelemetry(\"convert\", {});\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => i.name)).toEqual([\n        \"cli.command.invoked\",\n        \"cli.command.completed\",\n      ]);\n      for (const metric of items) {\n        expect(metric.attributes.target_opentofu.value).toBe(\">=1.7.0\");\n        expect(metric.attributes.target_terraform).toBeUndefined();\n      }\n    });\n\n    it.each([\n      [\"Usage\", \"Usage\"],\n      [\"External\", \"External\"],\n      [\"Internal\", \"Internal\"],\n      [\"Something Else\", \"unexpected\"],\n    ])(\n      \"stamps error_type %p as %p on cli.command.error\",\n      async (errorType, expected) => {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n          sendUsageTelemetry: true,\n        });\n        initSentryWithCapturingTransport();\n\n        await sendTelemetry(\"deploy\", { error: true, errorType });\n        expect(await Sentry.flush(2000)).toBe(true);\n\n        const error = parseMetricItems(envelopeBodies).find(\n          (i) => i.name === \"cli.command.error\",\n        )!;\n        expect(error.attributes.error_type.value).toBe(expected);\n        expect(error.attributes.command.value).toBe(\"deploy\");\n      },\n    );\n\n    it(\"forwards exactly the allow-listed attribute set and nothing else from the payload\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"typescript\",\n        sendUsageTelemetry: true,\n      });\n      initSentryWithCapturingTransport();\n\n      await startCommandTelemetry(\"synth\");\n      await sendTelemetry(\"synth\", {\n        totalTime: 5,\n        language: \"typescript\",\n        synthOrigin: \"watch\",\n        stackMetadata: [{ stackName: \"prod-vpc\", backend: \"s3\" }],\n        requiredProviders: [{ aws: { source: \"aws\" } }],\n        stackName: \"prod-vpc\",\n        outdir: \"/Users/x/secret\",\n        resources: { aws: { secret_resource: 3 } },\n      });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      const invoked = items.find((i) => i.name === \"cli.command.invoked\")!;\n      const completed = items.find((i) => i.name === \"cli.command.completed\")!;\n      const keys = Object.keys(completed.attributes);\n      // the start metric carries the base set; the end-of-run scalars ride\n      // on completed only\n      expect(Object.keys(invoked.attributes).sort()).toEqual(\n        keys.filter((key) => key !== \"synth_origin\").sort(),\n      );\n      // the one place that fails when an attribute is added: extend it\n      // deliberately, together with the collected-data list in the docs\n      expect(keys.filter((key) => !key.startsWith(\"sentry.\")).sort()).toEqual([\n        \"arch\",\n        \"binary\",\n        \"binary_version\",\n        \"ci\",\n        \"command\",\n        \"language\",\n        \"os\",\n        \"package_manager\",\n        // server.address is the fixed serverName from init\n        \"server.address\",\n        \"synth_origin\",\n        \"target_opentofu\",\n        \"target_terraform\",\n        \"targets_declared\",\n        \"validate_installed_binary\",\n      ]);\n      // stamped by the SDK from init; a patch bump may add more of them\n      expect(keys).toEqual(\n        expect.arrayContaining([\"sentry.release\", \"sentry.environment\"]),\n      );\n      const bytes = envelopeBodies.join(\"\\n\");\n      expect(bytes).not.toContain(\"prod-vpc\");\n      expect(bytes).not.toContain(\"/Users/x/secret\");\n      expect(bytes).not.toContain(\"secret_resource\");\n    });\n  });\n\n  describe(\"sendTelemetry payload mapping\", () => {\n    beforeEach(() => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        sendUsageTelemetry: true,\n      });\n      initSentryWithCapturingTransport();\n    });\n\n    it(\"counts get targets per normalized provider/module and puts only totals on the command metric\", async () => {\n      const provider = (constraint: string) =>\n        new ConstructsMakerProviderTarget(\n          new TerraformProviderConstraint(constraint),\n          Language.TYPESCRIPT,\n        ).trackingPayload;\n      const module = (constraint: string) =>\n        new ConstructsMakerModuleTarget(\n          new TerraformModuleConstraint(constraint),\n          Language.TYPESCRIPT,\n        ).trackingPayload;\n\n      await sendTelemetry(\"get\", {\n        targets: [\n          provider(\"registry.terraform.io/hashicorp/aws@~> 5.0\"),\n          provider(\"Hashicorp/AWS@~> 6.0\"),\n          provider(\"Kreuzwerker/Docker\"),\n          module(\"terraform-aws-modules/vpc/aws@5.0.0\"),\n          module(\"./modules/secret-name\"),\n        ],\n      });\n\n      const items = await deliveredItems();\n      const totals = { provider_count: 3, module_count: 2 };\n      expect(metrics(items, \"cli.command.completed\")).toEqual([\n        { value: 1, ...totals },\n      ]);\n      expect(metrics(items, \"cli.get.provider\")).toEqual([\n        { value: 2, provider: \"hashicorp/aws\", ...totals },\n        { value: 1, provider: \"kreuzwerker/docker\", ...totals },\n      ]);\n      expect(metrics(items, \"cli.get.module\")).toEqual([\n        { value: 1, module: \"local\", ...totals },\n        { value: 1, module: \"terraform-aws-modules/vpc/aws\", ...totals },\n      ]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"secret-name\");\n    });\n\n    it(\"counts init providers per normalized provider and puts only the total on the command metric\", async () => {\n      await sendTelemetry(\"init\", {\n        projectId: \"should-not-be-sent\",\n        addedProviders: [\n          \"aws@~>5.0\",\n          \"hashicorp/random\",\n          \"registry.terraform.io/hashicorp/aws\",\n        ],\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.command.completed\")).toEqual([\n        { value: 1, provider_count: 3 },\n      ]);\n      expect(metrics(items, \"cli.init.provider\")).toEqual([\n        { value: 2, provider: \"hashicorp/aws\", provider_count: 3 },\n        { value: 1, provider: \"hashicorp/random\", provider_count: 3 },\n      ]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"should-not-be-sent\");\n    });\n\n    it.each([\n      [\n        \"get\",\n        (sources: string[]) => ({\n          targets: sources.map((source) => ({ type: \"provider\", source })),\n        }),\n        \"cli.get.provider\",\n        { provider_count: 40, module_count: 0 },\n      ],\n      [\n        \"init\",\n        (sources: string[]) => ({ addedProviders: sources }),\n        \"cli.init.provider\",\n        { provider_count: 40 },\n      ],\n    ])(\n      \"%s folds the providers past 32 into one truncated count\",\n      async (command, payload, metric, totals) => {\n        const sources = Array.from(\n          { length: 40 },\n          (_, k) => `acme/p${String(k).padStart(2, \"0\")}`,\n        );\n\n        await sendTelemetry(command, payload([...sources].reverse()));\n\n        const items = await deliveredItems();\n        expect(metrics(items, metric)).toEqual([\n          ...sources\n            .slice(0, 32)\n            .map((provider) => ({ value: 1, provider, ...totals })),\n          { value: 8, truncated: true, ...totals },\n        ]);\n        expect(metrics(items, \"cli.command.completed\")).toEqual([\n          { value: 1, ...totals },\n        ]);\n      },\n    );\n\n    it(\"counts the run as completed even when a per-source metric cannot be built\", async () => {\n      await sendTelemetry(\"get\", {\n        targets: [null, { type: \"provider\", source: 7 }],\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.command.completed\")).toEqual([\n        { value: 1, provider_count: 1, module_count: 0 },\n      ]);\n      expect(metrics(items, \"cli.get.provider\")).toEqual([]);\n    });\n  });\n\n  describe(\"stack metrics\", () => {\n    // one JSON-synthesized stack the way the library writes it: metadata\n    // carries the stack name and resource ids (imports/moved), overrides\n    // are keyed by schema type, module overrides by source\n    const stackMetadata = [\n      {\n        version: \"0.21.0\",\n        stackName: \"SECRET-STACK-NAME\",\n        backend: \"s3\",\n        overrides: {\n          stack: [\"terraform.required_version\"],\n          aws_s3_bucket: [\"tags\", \"region\"],\n          \"module.../secret-path/vpc\": [\"providers\"],\n        },\n        imports: { aws_s3_bucket: [\"secret-resource-id\"] },\n        moved: {\n          aws_s3_bucket: [\"secret-resource-id\"],\n          aws_iam_role: [\"secret-resource-id\"],\n        },\n      },\n      {\n        version: \"0.21.0\",\n        stackName: \"SECRET-STACK-NAME-2\",\n        backend: \"remote\",\n        cloud: \"tfc\",\n      },\n    ];\n    const requiredProviders = [\n      {\n        aws: { source: \"aws\", version: \"~> 5.0\" },\n        docker: {\n          source: \"registry.terraform.io/kreuzwerker/docker\",\n          version: \"3.0.2\",\n        },\n        google: { source: \"hashicorp/google\", version: \"x\".repeat(100) },\n      },\n      {\n        random: { source: \"hashicorp/random\" },\n        vault: {\n          source: \"tfe.corp.example.com/acme-org/vault\",\n          version: \"~> 3.0\",\n        },\n      },\n    ];\n    const noCounts = { override_count: 0, import_count: 0, moved_count: 0 };\n\n    beforeEach(() => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        sendUsageTelemetry: true,\n        terraformProviders: [\n          \"aws@~>5.0\",\n          { name: \"docker\", source: \"kreuzwerker/docker\", version: \"3.0.2\" },\n        ],\n      });\n      initSentryWithCapturingTransport();\n    });\n\n    it(\"delivers no stack, provider or override metric when the project opts out\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        sendUsageTelemetry: false,\n      });\n\n      await sendTelemetry(\"deploy\", {\n        language: \"typescript\",\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 0,\n      });\n\n      expect(await deliveredItems()).toEqual([]);\n    });\n\n    it(\"counts stacks by backend, cloud and library version with their group sizes\", async () => {\n      await sendTelemetry(\"deploy\", {\n        language: \"typescript\",\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 0,\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.stack\")).toEqual([\n        {\n          value: 1,\n          backend: \"remote\",\n          cloud: true,\n          library_version: \"0.21.0\",\n          ...noCounts,\n        },\n        {\n          value: 1,\n          backend: \"s3\",\n          cloud: false,\n          library_version: \"0.21.0\",\n          override_count: 4,\n          import_count: 1,\n          moved_count: 2,\n        },\n      ]);\n      for (const stack of items.filter((i) => i.name === \"cli.stack\")) {\n        expect(attributeValues(stack)).toMatchObject({\n          command: \"deploy\",\n          language: \"typescript\",\n        });\n      }\n      expect(items.some((i) => i.name === \"cli.stack.failed\")).toBe(false);\n      expect(items.some((i) => i.name === \"cli.command.completed\")).toBe(true);\n    });\n\n    it(\"counts overrides per resource type, reducing module sources to their kind\", async () => {\n      await sendTelemetry(\"synth\", { stackMetadata, requiredProviders });\n\n      expect(metrics(await deliveredItems(), \"cli.stack.override\")).toEqual([\n        { value: 1, resource_type: \"aws_s3_bucket\", override_count: 2 },\n        { value: 1, resource_type: \"module.local\", override_count: 1 },\n        { value: 1, resource_type: \"stack\", override_count: 1 },\n      ]);\n    });\n\n    it(\"counts required providers by normalized source, validated constraint and binding\", async () => {\n      await sendTelemetry(\"diff\", { stackMetadata, requiredProviders });\n\n      expect(metrics(await deliveredItems(), \"cli.stack.provider\")).toEqual([\n        {\n          value: 1,\n          provider: \"hashicorp/aws\",\n          version_constraint: \"~> 5.0\",\n          binding: \"generated\",\n        },\n        {\n          value: 1,\n          provider: \"hashicorp/google\",\n          version_constraint: \"invalid\",\n          binding: \"prebuilt\",\n        },\n        { value: 1, provider: \"hashicorp/random\", binding: \"prebuilt\" },\n        {\n          value: 1,\n          provider: \"kreuzwerker/docker\",\n          version_constraint: \"3.0.2\",\n          binding: \"generated\",\n        },\n        {\n          value: 1,\n          provider: \"private-registry\",\n          version_constraint: \"~> 3.0\",\n          binding: \"prebuilt\",\n        },\n      ]);\n    });\n\n    it(\"classifies bindings against the project the command started in, not the current cwd\", async () => {\n      await startCommandTelemetry(\"diff\");\n      const elsewhere = path.join(workdir, \"elsewhere\");\n      fs.mkdirSync(elsewhere);\n      fs.writeJsonSync(path.join(elsewhere, \"cdktf.json\"), {\n        terraformProviders: [\"google\"],\n      });\n      process.chdir(elsewhere);\n\n      await sendTelemetry(\"diff\", { stackMetadata, requiredProviders });\n\n      expect(\n        metrics(await deliveredItems(), \"cli.stack.provider\").map((p) => [\n          p.provider,\n          p.binding,\n        ]),\n      ).toEqual([\n        [\"hashicorp/aws\", \"generated\"],\n        [\"hashicorp/google\", \"prebuilt\"],\n        [\"hashicorp/random\", \"prebuilt\"],\n        [\"kreuzwerker/docker\", \"generated\"],\n        [\"private-registry\", \"prebuilt\"],\n      ]);\n    });\n\n    it.each([3, 300])(\n      \"sends the same stack events for %d alike stacks, with the stack count as their value\",\n      async (count) => {\n        await sendTelemetry(\"deploy\", {\n          stackMetadata: Array.from({ length: count }, (_, i) => ({\n            version: \"0.21.0\",\n            stackName: `stack-${i}`,\n            backend: \"s3\",\n            overrides: { aws_s3_bucket: [\"tags\"] },\n          })),\n          requiredProviders: Array.from({ length: count }, () => ({\n            aws: { source: \"aws\", version: \"~> 5.0\" },\n            random: { source: \"hashicorp/random\" },\n          })),\n        });\n\n        const items = await deliveredItems();\n        expect(metrics(items, \"cli.stack\")).toEqual([\n          {\n            value: count,\n            backend: \"s3\",\n            cloud: false,\n            library_version: \"0.21.0\",\n            override_count: count,\n            import_count: 0,\n            moved_count: 0,\n          },\n        ]);\n        expect(metrics(items, \"cli.stack.provider\")).toEqual([\n          {\n            value: count,\n            provider: \"hashicorp/aws\",\n            version_constraint: \"~> 5.0\",\n            binding: \"generated\",\n          },\n          { value: count, provider: \"hashicorp/random\", binding: \"prebuilt\" },\n        ]);\n        expect(metrics(items, \"cli.stack.override\")).toEqual([\n          {\n            value: count,\n            resource_type: \"aws_s3_bucket\",\n            override_count: count,\n          },\n        ]);\n      },\n    );\n\n    it(\"groups providers on what is sent: spellings and private hosts collapse, constraints do not\", async () => {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [{}, {}, {}],\n        requiredProviders: [\n          {\n            aws: { source: \"aws\", version: \"~>5.0\" },\n            vault: { source: \"tfe.leak-one.example/leak-org-one/vault\" },\n          },\n          {\n            aws: { source: \"Hashicorp/AWS\", version: \"~> 5.0\" },\n            // a stack counts once per group, however many entries reach it\n            vault: { source: \"registry.leak-two.example/leak-org-two/vault\" },\n            consul: { source: \"mirror.leak-three.example/leak-org-two/consul\" },\n          },\n          {\n            aws: {\n              source: \"registry.terraform.io/hashicorp/aws\",\n              version: \"~> 5.0\",\n            },\n            aws6: { source: \"aws\", version: \"~> 6.0\" },\n          },\n        ],\n      });\n\n      expect(metrics(await deliveredItems(), \"cli.stack.provider\")).toEqual([\n        {\n          value: 3,\n          provider: \"hashicorp/aws\",\n          version_constraint: \"~> 5.0\",\n          binding: \"generated\",\n        },\n        { value: 2, provider: \"private-registry\", binding: \"prebuilt\" },\n        {\n          value: 1,\n          provider: \"hashicorp/aws\",\n          version_constraint: \"~> 6.0\",\n          binding: \"generated\",\n        },\n      ]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"leak\");\n    });\n\n    it(\"sums the group sizes of the stacks in a group and the paths of an override type\", async () => {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [\n          {\n            backend: \"local\",\n            overrides: { aws_s3_bucket: [\"a\", \"b\", \"c\"], \"bad key 1\": [\"x\"] },\n            imports: { aws_s3_bucket: [\"id\"] },\n          },\n          {\n            backend: \"local\",\n            overrides: {\n              aws_s3_bucket: [\"a\"],\n              \"bad key 2\": [\"x\"],\n              \"bad key 3\": [\"x\", \"y\", \"z\"],\n            },\n            moved: { aws_s3_bucket: [\"id\", \"id\"] },\n          },\n        ],\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.stack\")).toEqual([\n        {\n          value: 2,\n          backend: \"local\",\n          cloud: false,\n          override_count: 9,\n          import_count: 1,\n          moved_count: 2,\n        },\n      ]);\n      expect(metrics(items, \"cli.stack.override\")).toEqual([\n        { value: 2, resource_type: \"aws_s3_bucket\", override_count: 4 },\n        { value: 2, resource_type: \"other\", override_count: 5 },\n      ]);\n    });\n\n    it(\"keeps the 32 most required providers and folds the rest into one truncated count\", async () => {\n      const sources = Array.from(\n        { length: 40 },\n        (_, k) => `acme/p${String(k).padStart(2, \"0\")}`,\n      );\n      // provider k is required by 40 - k stacks\n      const requiredByStack = sources.map((_, stack) =>\n        Object.fromEntries(\n          sources\n            .slice(0, sources.length - stack)\n            .map((source, k) => [`p${k}`, { source }]),\n        ),\n      );\n\n      await sendTelemetry(\"synth\", {\n        stackMetadata: sources.map(() => ({})),\n        requiredProviders: requiredByStack,\n      });\n\n      const providers = metrics(await deliveredItems(), \"cli.stack.provider\");\n      expect(providers).toEqual([\n        ...sources.slice(0, 32).map((provider, k) => ({\n          value: 40 - k,\n          provider,\n          binding: \"prebuilt\",\n        })),\n        { value: 36, truncated: true },\n      ]);\n      expect(providers.reduce((total, p) => total + p.value, 0)).toBe(820);\n    });\n\n    it(\"keeps the first 32 override types by name on a tie and folds the rest with their paths\", async () => {\n      const types = Array.from(\n        { length: 34 },\n        (_, k) => `aws_t${String(k).padStart(2, \"0\")}`,\n      );\n      const longer: Record<string, string[]> = {\n        aws_t32: [\"a\", \"b\"],\n        aws_t33: [\"a\", \"b\", \"c\"],\n      };\n      const paths = (type: string) => longer[type] ?? [\"a\"];\n\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [\n          {\n            overrides: Object.fromEntries(\n              [...types].reverse().map((type) => [type, paths(type)]),\n            ),\n          },\n        ],\n      });\n\n      expect(metrics(await deliveredItems(), \"cli.stack.override\")).toEqual([\n        ...types.slice(0, 32).map((resource_type) => ({\n          value: 1,\n          resource_type,\n          override_count: 1,\n        })),\n        { value: 2, override_count: 5, truncated: true },\n      ]);\n    });\n\n    it(\"keeps the 8 largest stack groups and folds the rest with their group sizes\", async () => {\n      // library version 0.k.0 is used by k + 1 stacks, each with one import\n      const stacksOfVersion = (k: number) =>\n        Array.from({ length: k + 1 }, () => ({\n          version: `0.${k}.0`,\n          backend: \"s3\",\n          imports: { aws_s3_bucket: [\"id\"] },\n        }));\n\n      await sendTelemetry(\"synth\", {\n        stackMetadata: Array.from({ length: 10 }, (_, k) =>\n          stacksOfVersion(k),\n        ).flat(),\n      });\n\n      const stacks = metrics(await deliveredItems(), \"cli.stack\");\n      expect(stacks).toEqual([\n        ...[9, 8, 7, 6, 5, 4, 3, 2].map((k) => ({\n          value: k + 1,\n          backend: \"s3\",\n          cloud: false,\n          library_version: `0.${k}.0`,\n          ...noCounts,\n          import_count: k + 1,\n        })),\n        { value: 3, truncated: true, ...noCounts, import_count: 3 },\n      ]);\n      expect(stacks.reduce((total, s) => total + s.value, 0)).toBe(55);\n    });\n\n    it(\"bounds the stack events of a run whatever the project's shape, in the envelope of the command metric\", async () => {\n      const forty = Array.from({ length: 40 }, (_, k) => k);\n\n      await sendTelemetry(\"deploy\", {\n        stackMetadata: Array.from({ length: 300 }, (_, i) => ({\n          version: `1.${i}.0`,\n          overrides: Object.fromEntries(\n            forty.map((k) => [`aws_type_${k}`, [\"tags\"]]),\n          ),\n        })),\n        requiredProviders: Array.from({ length: 300 }, () =>\n          Object.fromEntries(\n            forty.map((k) => [`p${k}`, { source: `acme/p${k}` }]),\n          ),\n        ),\n      });\n\n      const items = await deliveredItems();\n      const count = (name: string) => metrics(items, name).length;\n      const total = (name: string) =>\n        metrics(items, name).reduce((sum, m) => sum + m.value, 0);\n      expect([\n        count(\"cli.stack\"),\n        count(\"cli.stack.provider\"),\n        count(\"cli.stack.override\"),\n      ]).toEqual([9, 33, 33]);\n      expect(total(\"cli.stack\")).toBe(300);\n      expect(total(\"cli.stack.provider\")).toBe(300 * 40);\n      expect(count(\"cli.command.completed\")).toBe(1);\n      expect(envelopeBodies).toHaveLength(1);\n    });\n\n    it(\"leaves the stacks to the command when its synth is nested: only the selected ones, under its name\", async () => {\n      await startCommandTelemetry(\"deploy\");\n      await sendTelemetry(\"synth\", {\n        totalTime: 42,\n        stackMetadata,\n        requiredProviders,\n      });\n      await sendTelemetry(\"deploy\", {\n        stackMetadata: stackMetadata.slice(1),\n        requiredProviders: requiredProviders.slice(1),\n      });\n\n      const items = await deliveredItems();\n      expect(\n        items\n          .filter((i) => i.name.startsWith(\"cli.stack\"))\n          .map((i) => [i.name, attributeValues(i).command, i.value]),\n      ).toEqual([\n        [\"cli.stack\", \"deploy\", 1],\n        [\"cli.stack.provider\", \"deploy\", 1],\n        [\"cli.stack.provider\", \"deploy\", 1],\n      ]);\n      expect(\n        items.some(\n          (i) =>\n            i.name === \"cli.synth.duration\" &&\n            attributeValues(i).command === \"synth\",\n        ),\n      ).toBe(true);\n    });\n\n    it(\"reports the stacks of a synth run under synth\", async () => {\n      await startCommandTelemetry(\"synth\");\n      await sendTelemetry(\"synth\", { stackMetadata, requiredProviders });\n\n      const stacks = (await deliveredItems()).filter(\n        (i) => i.name === \"cli.stack\",\n      );\n      expect(stacks.map((i) => attributeValues(i).command)).toEqual([\n        \"synth\",\n        \"synth\",\n      ]);\n    });\n\n    it(\"reports the stacks once per process: a watch session's later deploys add only their failures\", async () => {\n      await startCommandTelemetry(\"watch\");\n      await sendTelemetry(\"deploy\", { stackMetadata, requiredProviders });\n      await sendTelemetry(\"deploy\", {\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 1,\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.stack\")).toHaveLength(2);\n      expect(metrics(items, \"cli.stack.provider\")).toHaveLength(5);\n      expect(metrics(items, \"cli.stack.override\")).toHaveLength(3);\n      expect(metrics(items, \"cli.stack.failed\")).toEqual([{ value: 1 }]);\n    });\n\n    it(\"counts failed stacks and never serializes their failure messages\", async () => {\n      await sendTelemetry(\"destroy\", {\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 2,\n        failedStacks: [\"failed to destroy SECRET-STACK-NAME: /Users/x/state\"],\n      });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      const failed = items.find((i) => i.name === \"cli.stack.failed\")!;\n      expect(failed.value).toBe(2);\n      expect(failed.attributes.command.value).toBe(\"destroy\");\n      // the failure thrown next is counted as cli.command.error, not here\n      expect(items.some((i) => i.name === \"cli.command.completed\")).toBe(false);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"failed to destroy\");\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"/Users/x\");\n    });\n\n    it(\"counts no completed run and no failed stack for a run that failed before any stack did\", async () => {\n      await sendTelemetry(\"deploy\", {\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 0,\n        runFailed: true,\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.stack\")).toHaveLength(2);\n      expect(metrics(items, \"cli.stack.failed\")).toEqual([]);\n      expect(items.some((i) => i.name === \"cli.command.completed\")).toBe(false);\n    });\n\n    it(\"never serializes stack names, resource ids or module paths\", async () => {\n      await sendTelemetry(\"deploy\", {\n        language: \"typescript\",\n        stackMetadata,\n        requiredProviders,\n        failedStackCount: 1,\n      });\n\n      const items = await deliveredItems();\n      // the scan below is over two stacks, three override types, five\n      // providers and the failed count\n      expect(items.filter((i) => i.name.startsWith(\"cli.stack\"))).toHaveLength(\n        11,\n      );\n      const bytes = envelopeBodies.join(\"\\n\");\n      expect(bytes).not.toContain(\"SECRET-STACK-NAME\");\n      expect(bytes).not.toContain(\"secret-resource-id\");\n      expect(bytes).not.toContain(\"secret-path\");\n      expect(bytes).not.toContain(\"tfe.corp.example.com\");\n      expect(bytes).not.toContain(\"acme-org\");\n    });\n\n    // the metadata is read from disk, written by whatever library version\n    // the project has\n    it(\"tolerates malformed metadata entries and counts only the real stacks\", async () => {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [null, \"nope\", { overrides: \"nope\", imports: [] }],\n        requiredProviders: [undefined, undefined, { aws: \"nope\" }],\n      });\n\n      const items = await deliveredItems();\n      expect(metrics(items, \"cli.stack\")).toEqual([\n        { value: 1, backend: \"unknown\", cloud: false, ...noCounts },\n      ]);\n      expect(metrics(items, \"cli.stack.override\")).toEqual([]);\n      expect(metrics(items, \"cli.stack.provider\")).toEqual([\n        { value: 1, provider: \"hashicorp/aws\", binding: \"generated\" },\n      ]);\n      expect(items.some((i) => i.name === \"cli.command.completed\")).toBe(true);\n    });\n  });\n\n  describe(\"attribute validation\", () => {\n    beforeEach(() => {\n      initSentryWithCapturingTransport();\n    });\n\n    it(\"omits an unsupported language, read from cdktf.json at start or passed at the end\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"rust; DROP TABLE\",\n      });\n\n      await startCommandTelemetry(\"convert\");\n      await sendTelemetry(\"convert\", { language: \"cobol; DROP TABLE\" });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => i.name)).toEqual([\n        \"cli.command.invoked\",\n        \"cli.command.completed\",\n      ]);\n      for (const item of items) {\n        expect(item.attributes).not.toHaveProperty(\"language\");\n      }\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"DROP TABLE\");\n    });\n\n    it.each([\n      [\"synth\", { synthOrigin: \"watch\" }, \"synth_origin\", \"watch\"],\n      [\"synth\", { synthOrigin: \"/Users/x\" }, \"synth_origin\", undefined],\n      [\"init\", { isRemote: true }, \"is_remote\", true],\n      [\"init\", { template: \"go\" }, \"template\", \"go\"],\n      [\"convert\", { numberOfProviders: 2 }, \"provider_count\", 2],\n      [\"convert\", { numberOfModules: 1 }, \"module_count\", 1],\n      [\"convert\", { convertedLines: 42 }, \"converted_lines\", 42],\n      [\"convert\", { convertedLines: \"42\" }, \"converted_lines\", undefined],\n      [\"convert\", { convertedLines: NaN }, \"converted_lines\", undefined],\n    ])(\n      \"%s: %j forwards %s as %j\",\n      async (command, payload, attribute, expected) => {\n        await sendTelemetry(command, payload);\n        expect(await Sentry.flush(2000)).toBe(true);\n\n        const completed = parseMetricItems(envelopeBodies).find(\n          (i) => i.name === \"cli.command.completed\",\n        )!;\n        if (expected === undefined) {\n          expect(completed.attributes).not.toHaveProperty(attribute);\n        } else {\n          expect(attributeValues(completed)[attribute]).toBe(expected);\n        }\n      },\n    );\n\n    it.each([\n      [\">= 1.9.0\", \">=1.9.0\"],\n      [\"~1.8\", \">=1.8.0 <1.9.0-0\"],\n      [\"1.2.3 - 2.0.0\", \">=1.2.3 <=2.0.0\"],\n      [\">=1.0.0 <2.0.0 || 1.2.3\", \">=1.0.0 <2.0.0||1.2.3\"],\n      [\"latest /Users/x\", \"invalid\"],\n      [\">= 1.0.0-LEAK-TV-PRERELEASE.corp.example.com\", \"invalid\"],\n      [\"1.2.3-acme.internal\", \"invalid\"],\n      [\"1.2.3+LEAK-TV-BUILD.johns-macbook\", \"invalid\"],\n      [\">=1.0.0 <2.0.0 || 1.2.3-LEAK-OR.host\", \"invalid\"],\n      [\">=1.0.0 \" + \"||1.0.0 \".repeat(10), \"invalid\"],\n    ])(\"forwards the declared target %p as %p\", (range, expected) => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        targetVersions: { terraform: range },\n      });\n      expect(getProjectTargetAttributes(workdir).target_terraform).toBe(\n        expected,\n      );\n    });\n\n    it(\"reduces a backend outside the built-in kinds and override keys outside the type grammar to other\", async () => {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [\n          {\n            version: \"0.21.0+build.\" + \"x\".repeat(40),\n            backend: \"s3 bucket=/Users/x/state\",\n            overrides: {\n              aws_s3_bucket: [\"tags\"],\n              terraform_remote_state: [\"backend\"],\n              \"module.terraform-aws-modules/vpc/aws\": [\"providers\"],\n              \"resource with spaces /Users/x\": [\"tags\"],\n              AWS_S3_Bucket: [\"tags\"],\n              [\"aws_\" + \"x\".repeat(70)]: [\"tags\"],\n            },\n          },\n          { version: \"dev-/Users/x\", backend: \"S3\" },\n          { version: \"dev-/Users/x\" },\n        ],\n      });\n\n      const items = await deliveredItems();\n      // build metadata is stripped like binary_version; a version without a\n      // MAJOR.MINOR.PATCH prefix yields no attribute at all\n      expect(\n        metrics(items, \"cli.stack\").map((stack) => [\n          stack.backend,\n          stack.library_version,\n        ]),\n      ).toEqual([\n        [\"other\", \"0.21.0\"],\n        [\"other\", undefined],\n        [\"unknown\", undefined],\n      ]);\n      expect(\n        metrics(items, \"cli.stack.override\").map((o) => [\n          o.resource_type,\n          o.override_count,\n        ]),\n      ).toEqual([\n        [\"aws_s3_bucket\", 1],\n        [\"module.terraform-aws-modules/vpc/aws\", 1],\n        [\"other\", 3],\n        [\"terraform_remote_state\", 1],\n      ]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"/Users/x\");\n    });\n  });\n\n  describe(\"provider binding classification\", () => {\n    beforeEach(() => {\n      initSentryWithCapturingTransport();\n    });\n\n    async function bindingOf(source: string) {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [{}],\n        requiredProviders: [{ provider: { source } }],\n      });\n      return metrics(await deliveredItems(), \"cli.stack.provider\").map(\n        (provider) => provider.binding,\n      );\n    }\n\n    it.each([\n      [\"aws\", \"generated\"],\n      [\"Hashicorp/Random\", \"generated\"],\n      [\"kreuzwerker/docker\", \"generated\"],\n      [\"hashicorp/google\", \"generated\"],\n      [\"azurerm\", \"generated\"],\n      [\"hashicorp/null\", \"prebuilt\"],\n      [\"tfe.corp.example.com/acme-org/vault\", \"generated\"],\n      // another private source is not the generated one, even though both\n      // reach the metric as \"private-registry\"\n      [\"tfe.corp.example.com/other-org/vault\", \"prebuilt\"],\n    ])(\n      \"sends the required provider %s as %s for the project's terraformProviders\",\n      async (source, expected) => {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n          terraformProviders: [\n            \"aws@~>5.0\",\n            \"hashicorp/random@3.6.0\",\n            \"registry.terraform.io/kreuzwerker/docker\",\n            { name: \"google\", source: \"hashicorp/google\", version: \"~> 5.0\" },\n            { name: \"azurerm\" },\n            { version: \"1.0.0\" },\n            42,\n            \"TFE.corp.example.com/acme-org/vault@~>3.0\",\n          ],\n        });\n\n        expect(await bindingOf(source)).toEqual([expected]);\n      },\n    );\n\n    it(\"sends every provider as prebuilt when terraformProviders is not a list\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        terraformProviders: \"aws\",\n      });\n\n      expect(await bindingOf(\"aws\")).toEqual([\"prebuilt\"]);\n    });\n  });\n\n  describe(\"source normalization\", () => {\n    beforeEach(() => {\n      initSentryWithCapturingTransport();\n    });\n\n    it.each([\n      [\"aws\", \"hashicorp/aws\"],\n      [\"aws@~>5.0\", \"hashicorp/aws\"],\n      [\"Hashicorp/AWS@5.1.0\", \"hashicorp/aws\"],\n      [\"registry.terraform.io/hashicorp/aws\", \"hashicorp/aws\"],\n      [\"registry.opentofu.org/hashicorp/aws\", \"hashicorp/aws\"],\n      [\"tfe.leak-host.example/leak-org/aws\", \"private-registry\"],\n      [\"localhost:8080/leak-org/aws\", \"private-registry\"],\n      [\"./leak-provider\", \"other\"],\n      [\"../leak/provider\", \"other\"],\n      [\"/abs/leak/provider\", \"other\"],\n      [\"leak-a/b/c\", \"other\"],\n      [\"\", \"other\"],\n      [\"registry.terraform.io/leak-namespace\", \"other\"],\n      [`${\"n\".repeat(65)}/aws`, \"other\"],\n      [`${\"n\".repeat(64)}/aws`, `${\"n\".repeat(64)}/aws`],\n      [`${\"n\".repeat(64)}/${\"t\".repeat(64)}`, \"other\"],\n    ])(\"sends the provider source %s as %s\", async (source, expected) => {\n      await sendTelemetry(\"get\", { targets: [{ type: \"provider\", source }] });\n\n      expect(\n        metrics(await deliveredItems(), \"cli.get.provider\").map(\n          (item) => item.provider,\n        ),\n      ).toEqual([expected]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"leak\");\n    });\n\n    it.each([\n      [\"terraform-aws-modules/vpc/aws\", \"terraform-aws-modules/vpc/aws\"],\n      [\"Terraform-AWS-Modules/VPC/aws\", \"terraform-aws-modules/vpc/aws\"],\n      // one row per fallthrough: everything the grammar rejects is \"other\"\n      [\"Terraform-AWS-Modules/leak-vpc/aws?ref=v5.0.0\", \"other\"],\n      [`${\"n\".repeat(64)}/vpc/aws`, `${\"n\".repeat(64)}/vpc/aws`],\n      [`${\"n\".repeat(65)}/vpc/aws`, \"other\"],\n      [\"app.terraform.io/leak-org/vpc/aws\", \"private-registry\"],\n      [\"./modules/leak-vpc\", \"local\"],\n      [\"../shared/leak-vpc\", \"local\"],\n      [\"/abs/path/leak-vpc\", \"local\"],\n      [\"git@github.com:leak-org/repo.git\", \"git\"],\n      [\"github.com/leak-org/repo\", \"git\"],\n      [\"bitbucket.org/leak-org/repo\", \"git\"],\n      [\"https://leak-host.example/vpc.zip\", \"git\"],\n      [\"s3-eu-west-1.amazonaws.com/leak-bucket/vpc.zip\", \"git\"],\n      [\"www.googleapis.com/storage/v1/leak-bucket/vpc\", \"git\"],\n      // forced getters without a URL scheme behind them\n      [\"git::leak-host.example/leak-org/repo.git\", \"git\"],\n      [\"hg::leak-host.example/leak-repo\", \"git\"],\n      [\"s3::leak-bucket/vpc.zip\", \"git\"],\n      [\"gcs::leak-bucket/vpc\", \"git\"],\n    ])(\"sends the module source %s as %s\", async (source, expected) => {\n      await sendTelemetry(\"get\", { targets: [{ type: \"module\", source }] });\n\n      expect(\n        metrics(await deliveredItems(), \"cli.get.module\").map(\n          (item) => item.module,\n        ),\n      ).toEqual([expected]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"leak\");\n    });\n\n    it.each([\n      [\">= 1.2, < 2.0\", \">= 1.2, < 2.0\"],\n      [\"~> 5.0\", \"~> 5.0\"],\n      [\"= 1.0\", \"= 1.0\"],\n      [\"!= 1.2.3\", \"!= 1.2.3\"],\n      [\"1.2.3\", \"1.2.3\"],\n      [\"  >= 1.0 ,  < 2.0  \", \">= 1.0, < 2.0\"],\n      [\"~>5.0,!=5.1.0\", \"~> 5.0, != 5.1.0\"],\n      [\">= 1.0.0-leak-prerelease.corp\", \"invalid\"],\n      [\"1.2.3+leak-build.host\", \"invalid\"],\n      [\"~> 5.0 # /Users/leak\", \"invalid\"],\n      [\">= 1.2 || < 2.0\", \"invalid\"],\n      // valid by the grammar, over the length a constraint may have\n      [Array(12).fill(\"!= 1.0.0\").join(\", \"), \"invalid\"],\n    ])(\"sends the provider constraint %p as %p\", async (version, expected) => {\n      await sendTelemetry(\"synth\", {\n        stackMetadata: [{}],\n        requiredProviders: [{ aws: { source: \"aws\", version } }],\n      });\n\n      expect(\n        metrics(await deliveredItems(), \"cli.stack.provider\").map(\n          (provider) => provider.version_constraint,\n        ),\n      ).toEqual([expected]);\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"leak\");\n    });\n  });\n\n  describe(\"package manager\", () => {\n    beforeEach(() => {\n      initSentryWithCapturingTransport();\n    });\n\n    afterEach(() => {\n      jest.dontMock(\"./node-package-manager\");\n    });\n\n    // a copy of the module whose node detector is replaced\n    function telemetryWithNodeDetector(detect: () => string) {\n      let copy!: typeof import(\"./telemetry\");\n      jest.isolateModules(() => {\n        jest.doMock(\"./node-package-manager\", () => ({\n          detectNodePackageManager: detect,\n        }));\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        copy = require(\"./telemetry\");\n      });\n      return copy;\n    }\n\n    // one successful and one failed end, so every command metric is covered\n    async function runMetrics(\n      telemetry: Pick<\n        typeof import(\"./telemetry\"),\n        \"startCommandTelemetry\" | \"sendTelemetry\"\n      > = { startCommandTelemetry, sendTelemetry },\n    ): Promise<MetricItem[]> {\n      await telemetry.startCommandTelemetry(\"synth\");\n      await telemetry.sendTelemetry(\"synth\", {});\n      await telemetry.sendTelemetry(\"synth\", { error: true });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => i.name)).toEqual([\n        \"cli.command.invoked\",\n        \"cli.command.completed\",\n        \"cli.command.error\",\n      ]);\n      return items;\n    }\n\n    it.each([\n      [\"no lockfile\", \"npm\", {}],\n      [\"a pnpm lockfile\", \"pnpm\", { \"pnpm-lock.yaml\": \"\" }],\n      [\"a yarn lockfile\", \"yarn\", { \"yarn.lock\": \"\" }],\n      [\"a .yarnrc.yml\", \"yarn-berry\", { \".yarnrc.yml\": \"\" }],\n      [\n        \"a declared npm\",\n        \"npm\",\n        { \"package.json\": '{\"packageManager\":\"npm@10.8.2\"}' },\n      ],\n      [\n        \"a declared pnpm with a hash\",\n        \"pnpm\",\n        { \"package.json\": '{\"packageManager\":\"pnpm@10.26.0+sha512.LEAK\"}' },\n      ],\n      [\n        \"a declared yarn 1\",\n        \"yarn\",\n        { \"package.json\": '{\"packageManager\":\"yarn@1.22.22\"}' },\n      ],\n      [\n        \"a declared yarn 4\",\n        \"yarn-berry\",\n        { \"package.json\": '{\"packageManager\":\"yarn@4.1.0\"}' },\n      ],\n      [\n        \"an unknown declared manager\",\n        \"npm\",\n        { \"package.json\": '{\"packageManager\":\"bun@1.1.0-LEAK\"}' },\n      ],\n    ])(\n      \"reports a typescript project with %s as %p on every command metric\",\n      async (_name, expected, files) => {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n          language: \"typescript\",\n        });\n        for (const [name, content] of Object.entries(files)) {\n          fs.writeFileSync(path.join(workdir, name), content as string);\n        }\n\n        for (const item of await runMetrics()) {\n          expect(attributeValues(item).package_manager).toBe(expected);\n        }\n        const bytes = envelopeBodies.join(\"\\n\");\n        expect(bytes).not.toContain(\"LEAK\");\n        expect(bytes).not.toContain(\"10.26.0\");\n      },\n    );\n\n    it.each([\n      [\"python\", { app: \"pipenv run python main.py\" }, {}, \"pipenv\"],\n      [\"python\", { app: \"python3 main.py\" }, {}, \"pip\"],\n      [\"java\", {}, { \"build.gradle\": \"\" }, \"gradle\"],\n      [\"java\", {}, { \"pom.xml\": \"\" }, \"maven\"],\n      [\"csharp\", {}, {}, \"nuget\"],\n      [\"go\", {}, {}, \"go\"],\n    ])(\n      \"reports a %s project with %j and files %j as %p\",\n      async (language, config, files, expected) => {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n          language,\n          ...config,\n        });\n        for (const [name, content] of Object.entries(files)) {\n          fs.writeFileSync(path.join(workdir, name), content as string);\n        }\n\n        for (const item of await runMetrics()) {\n          expect(attributeValues(item).package_manager).toBe(expected);\n        }\n      },\n    );\n\n    it.each([\n      [\"no cdktf.json\", undefined],\n      [\"an unsupported language\", { language: \"rust\" }],\n      [\"no language\", { app: \"pipenv run python main.py\" }],\n      [\"a python project without an app command\", { language: \"python\" }],\n    ])(\"omits the attribute with %s\", async (_name, cdktfJson) => {\n      if (cdktfJson) {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), cdktfJson);\n      }\n      // lockfiles alone never identify a project\n      fs.writeFileSync(path.join(workdir, \"pnpm-lock.yaml\"), \"\");\n      fs.writeFileSync(path.join(workdir, \"build.gradle\"), \"\");\n\n      for (const item of await runMetrics()) {\n        expect(item.attributes).not.toHaveProperty(\"package_manager\");\n      }\n    });\n\n    it(\"keeps the value detected at start when the cwd changes before the end\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"typescript\",\n      });\n      fs.writeFileSync(path.join(workdir, \"pnpm-lock.yaml\"), \"\");\n      const elsewhere = fs.mkdtempSync(path.join(os.tmpdir(), \"cdktn-else-\"));\n\n      try {\n        await startCommandTelemetry(\"convert\");\n        process.chdir(elsewhere);\n        await sendTelemetry(\"convert\", {});\n        await sendTelemetry(\"convert\", { error: true });\n        expect(await Sentry.flush(2000)).toBe(true);\n      } finally {\n        process.chdir(workdir);\n        fs.removeSync(elsewhere);\n      }\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items).toHaveLength(3);\n      for (const item of items) {\n        expect(attributeValues(item).package_manager).toBe(\"pnpm\");\n      }\n    });\n\n    it(\"forgets the value with the run\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), { language: \"go\" });\n\n      await startCommandTelemetry(\"synth\");\n      resetCommandTelemetry();\n      await sendTelemetry(\"synth\", {});\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const completed = parseMetricItems(envelopeBodies).find(\n        (i) => i.name === \"cli.command.completed\",\n      )!;\n      expect(completed.attributes).not.toHaveProperty(\"package_manager\");\n    });\n\n    it(\"omits a detector value outside the closed set\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"typescript\",\n      });\n      const telemetry = telemetryWithNodeDetector(() => \"bun@1.1.0 /Users/x\");\n\n      for (const item of await runMetrics(telemetry)) {\n        expect(item.attributes).not.toHaveProperty(\"package_manager\");\n      }\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"bun\");\n    });\n\n    it(\"omits the attribute when detection throws\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"typescript\",\n      });\n      const telemetry = telemetryWithNodeDetector(() => {\n        throw new Error(\"EACCES\");\n      });\n\n      for (const item of await runMetrics(telemetry)) {\n        expect(item.attributes).not.toHaveProperty(\"package_manager\");\n      }\n    });\n\n    it(\"normalizes to members of the closed set only\", () => {\n      for (const name of PACKAGE_MANAGERS) {\n        expect(normalizePackageManager(name)).toBe(name);\n      }\n      for (const value of [\n        \"bun\",\n        \"NPM\",\n        \"pnpm@10.26.0+sha512.abc\",\n        \"/usr/local/bin/npm\",\n        \"\",\n        1,\n        null,\n        undefined,\n        [\"npm\"],\n      ]) {\n        expect(normalizePackageManager(value)).toBeUndefined();\n      }\n    });\n  });\n\n  describe(\"run lifecycle\", () => {\n    beforeEach(() => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"python\",\n        sendUsageTelemetry: true,\n      });\n      initSentryWithCapturingTransport();\n    });\n\n    it(\"counts the run once as invoked at start, even when reporting is initialized again\", async () => {\n      await startCommandTelemetry(\"init\");\n      // init runs get, which initializes reporting a second time\n      await startCommandTelemetry(\"get\");\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => i.name)).toEqual([\"cli.command.invoked\"]);\n      expect(attributeValues(items[0])).toMatchObject({\n        command: \"init\",\n        language: \"python\",\n      });\n    });\n\n    it(\"counts only the run's own command as completed; a nested operation adds its own metrics\", async () => {\n      await startCommandTelemetry(\"deploy\");\n      await sendTelemetry(\"synth\", { totalTime: 42, language: \"python\" });\n      await sendTelemetry(\"deploy\", { language: \"python\" });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => [i.name, attributeValues(i).command])).toEqual([\n        [\"cli.command.invoked\", \"deploy\"],\n        [\"cli.synth.duration\", \"synth\"],\n        [\"cli.command.completed\", \"deploy\"],\n      ]);\n    });\n\n    it(\"counts a failed run once as error, never as completed\", async () => {\n      await startCommandTelemetry(\"synth\");\n      await sendTelemetry(\"synth\", { error: true, errorType: \"External\" });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      expect(parseMetricItems(envelopeBodies).map((i) => i.name)).toEqual([\n        \"cli.command.invoked\",\n        \"cli.command.error\",\n      ]);\n    });\n\n    it(\"emits nothing at start when usage telemetry is off, and stays a no-op afterwards\", async () => {\n      setUsageTelemetryEnabled(false);\n\n      await startCommandTelemetry(\"synth\");\n      setUsageTelemetryEnabled(true);\n      await startCommandTelemetry(\"synth\");\n      await Sentry.flush(2000);\n\n      expect(parseMetricItems(envelopeBodies)).toHaveLength(0);\n    });\n  });\n\n  // the bundle has one copy of this module per entry point: bin/cmds/handlers.js\n  // captures the decision and starts the run, bin/cdktn.js counts the failure\n  describe(\"shared across module copies\", () => {\n    type Telemetry = typeof import(\"./telemetry\");\n    let second: Telemetry;\n\n    beforeEach(() => {\n      jest.isolateModules(() => {\n        // eslint-disable-next-line @typescript-eslint/no-require-imports\n        second = require(\"./telemetry\");\n      });\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"go\",\n        sendUsageTelemetry: true,\n      });\n      initSentryWithCapturingTransport();\n    });\n\n    it(\"observes the captured decision and targets, the started command and its language from the other copy\", async () => {\n      // the project opts out; only the decision captured by the first copy\n      // lets the second one emit\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        language: \"go\",\n        sendUsageTelemetry: false,\n      });\n      setUsageTelemetryEnabled(true);\n      setProjectTargetAttributes({ target_opentofu: \">=1.7.0\" });\n      await startCommandTelemetry(\"deploy\");\n      await second.startCommandTelemetry(\"synth\");\n      await second.sendTelemetry(\"synth\", { language: \"go\" });\n      await second.sendTelemetry(\"deploy\", { error: true, errorType: \"Usage\" });\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const items = parseMetricItems(envelopeBodies);\n      expect(items.map((i) => [i.name, attributeValues(i).command])).toEqual([\n        [\"cli.command.invoked\", \"deploy\"],\n        [\"cli.command.error\", \"deploy\"],\n      ]);\n      expect(attributeValues(items[1])).toMatchObject({\n        language: \"go\",\n        package_manager: \"go\",\n        target_opentofu: \">=1.7.0\",\n      });\n      expect(items[1].attributes).not.toHaveProperty(\"target_terraform\");\n    });\n  });\n\n  describe(\"sendTelemetry gating\", () => {\n    it.each([\n      { env: undefined, captured: undefined, flag: undefined, emits: true },\n      { env: undefined, captured: undefined, flag: true, emits: true },\n      { env: undefined, captured: undefined, flag: false, emits: false },\n      // convert chdirs into a throwaway project that opts out\n      { env: undefined, captured: true, flag: false, emits: true },\n      { env: undefined, captured: false, flag: true, emits: false },\n      { env: \"1\", captured: undefined, flag: true, emits: false },\n      { env: \"1\", captured: true, flag: true, emits: false },\n    ])(\n      \"CHECKPOINT_DISABLE=$env, captured=$captured, flag=$flag -> emits $emits\",\n      async ({ env, captured, flag, emits }) => {\n        if (flag !== undefined) {\n          fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n            sendUsageTelemetry: flag,\n          });\n        }\n        initSentryWithCapturingTransport();\n        setUsageTelemetryEnabled(captured);\n        if (env !== undefined) {\n          process.env.CHECKPOINT_DISABLE = env;\n        }\n\n        await startCommandTelemetry(\"convert\");\n        await sendTelemetry(\"convert\", {});\n        await Sentry.flush(2000);\n\n        const items = parseMetricItems(envelopeBodies);\n        expect(items.some((i) => i.name === \"cli.command.invoked\")).toBe(emits);\n        expect(items.some((i) => i.name === \"cli.command.completed\")).toBe(\n          emits,\n        );\n        if (!emits) {\n          expect(items).toHaveLength(0);\n        }\n      },\n    );\n  });\n\n  describe(\"cli.error from the Errors factories\", () => {\n    afterEach(() => {\n      Errors.setScope(\"unknown\");\n    });\n\n    // the scope is read when the error is built, not when the factory is\n    // created: a factory-time binding reports every error as \"unknown\"\n    it(\"counts constructed errors by type with the command set at call time\", async () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        sendUsageTelemetry: true,\n      });\n      initSentryWithCapturingTransport();\n\n      Errors.setScope(\"deploy\");\n      Errors.Usage(\"no stacks selected\", undefined, { stackName: \"secret\" });\n      Errors.External(\"terraform exited with code 1\");\n      expect(await Sentry.flush(2000)).toBe(true);\n\n      const errors = parseMetricItems(envelopeBodies).filter(\n        (i) => i.name === \"cli.error\",\n      );\n      expect(errors).toHaveLength(2);\n      expect(errors.map((e) => e.attributes.type.value)).toEqual([\n        \"Usage\",\n        \"External\",\n      ]);\n      for (const error of errors) {\n        expect(error.attributes.command.value).toBe(\"deploy\");\n        expect(error.attributes).not.toHaveProperty(\"message\");\n        expect(error.attributes).not.toHaveProperty(\"stackName\");\n      }\n      expect(JSON.stringify(errors)).not.toContain(\"secret\");\n      expect(JSON.stringify(errors)).not.toContain(\"no stacks selected\");\n    });\n  });\n\n  describe(\"binary attributes\", () => {\n    async function invokedAttributes(versionOutput: string) {\n      seedTerraformCliProbeForTests(Promise.resolve(versionOutput));\n      initSentryWithCapturingTransport();\n      await startCommandTelemetry(\"synth\");\n      expect(await Sentry.flush(2000)).toBe(true);\n      return attributeValues(parseMetricItems(envelopeBodies)[0]);\n    }\n\n    it.each([\n      [\"Terraform v1.10.0-alpha20250101\", \"terraform\", \"1.10.0\"],\n      [\n        \"OpenTofu v1.2.3-LEAK-HOST.corp.example.com+LEAK-BUILD/Users/x\",\n        \"opentofu\",\n        \"1.2.3\",\n      ],\n    ])(\n      \"reduces the probed version of %p to its release\",\n      async (versionOutput, binary, release) => {\n        expect(await invokedAttributes(versionOutput)).toMatchObject({\n          binary,\n          binary_version: release,\n        });\n        expect(envelopeBodies.join(\"\\n\")).not.toContain(\"LEAK\");\n      },\n    );\n\n    it(\"sends no version for an unrecognised product: a wrapper's output has no product version line\", async () => {\n      const attributes = await invokedAttributes(\n        \"connected to 10.0.0.1 as LEAK-USER (wrapper 3.4.5)\\nTerraform v1.9.0\\n\",\n      );\n      expect(attributes.binary).toBe(\"unknown\");\n      expect(attributes).not.toHaveProperty(\"binary_version\");\n      expect(envelopeBodies.join(\"\\n\")).not.toContain(\"LEAK-USER\");\n    });\n  });\n\n  describe(\"getProjectTargetAttributes\", () => {\n    it(\"reads declared targets and the validation flag\", () => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), {\n        targetVersions: { opentofu: \"~1.8\" },\n        validateInstalledBinary: true,\n      });\n      expect(getProjectTargetAttributes(workdir)).toEqual({\n        targets_declared: true,\n        validate_installed_binary: true,\n        target_opentofu: \">=1.8.0 <1.9.0-0\",\n      });\n    });\n\n    it.each([\n      [{}],\n      [{ targetVersions: \"nope\" }],\n      [{ targetVersions: [] }],\n      [undefined],\n    ])(\"falls back to the defaults for a cdktf.json of %j\", (config) => {\n      if (config) {\n        fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), config);\n      }\n      expect(getProjectTargetAttributes(workdir)).toEqual({\n        targets_declared: false,\n        validate_installed_binary: false,\n        ...DEFAULT_TARGET_VERSIONS_AS_ATTRIBUTES,\n      });\n    });\n  });\n\n  describe(\"getUsageTelemetryConsent\", () => {\n    it.each([\n      // init templates render the flag as a string; a boolean-only check\n      // would opt every freshly init'ed project out\n      [{ sendUsageTelemetry: \"true\" }, true],\n      [{ sendUsageTelemetry: \"false\" }, false],\n      [{}, undefined],\n      // malformed is unset, not an opt-out\n      [{ sendUsageTelemetry: \"yes\" }, undefined],\n    ])(\"reads %j as %p\", (config, expected) => {\n      fs.writeJsonSync(path.join(workdir, \"cdktf.json\"), config);\n      expect(getUsageTelemetryConsent(workdir)).toBe(expected);\n    });\n\n    it(\"returns undefined when no cdktf.json exists\", () => {\n      expect(getUsageTelemetryConsent(workdir)).toBeUndefined();\n    });\n  });\n});\n"]}