@cdktn/commons 0.25.0-pre.53 → 0.25.0-pre.55

package/build/telemetry.js

@@ -0,0 +1,721 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTH_ORIGINS = exports.PACKAGE_MANAGERS = exports.COMMAND_ERROR_TYPES = void 0;
+exports.getUsageTelemetryConsent = getUsageTelemetryConsent;
+exports.normalizePackageManager = normalizePackageManager;
+exports.setUsageTelemetryEnabled = setUsageTelemetryEnabled;
+exports.hasCapturedUsageTelemetryDecision = hasCapturedUsageTelemetryDecision;
+exports.isUsageTelemetryEnabled = isUsageTelemetryEnabled;
+exports.getProjectTargetAttributes = getProjectTargetAttributes;
+exports.setProjectTargetAttributes = setProjectTargetAttributes;
+exports.sendErrorTelemetry = sendErrorTelemetry;
+exports.flushTelemetry = flushTelemetry;
+exports.startCommandTelemetry = startCommandTelemetry;
+exports.resetCommandTelemetry = resetCommandTelemetry;
+exports.sendTelemetry = sendTelemetry;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const config_1 = require("./config");
+const Sentry = __importStar(require("@sentry/node"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const semver = __importStar(require("semver"));
+const ci_info_1 = __importDefault(require("ci-info"));
+const logging_1 = require("./logging");
+const config_2 = require("./config");
+const gradle_1 = require("./gradle");
+const node_package_manager_1 = require("./node-package-manager");
+const process_state_1 = require("./process-state");
+const terraform_module_1 = require("./terraform-module");
+const terraform_1 = require("./terraform");
+exports.COMMAND_ERROR_TYPES = [
+    "Usage",
+    "External",
+    "Internal",
+    "unexpected",
+];
+// Never throws: telemetry also runs outside a project. Raw, because commons
+// cannot import cli-core's typed config.
+function readRawCdktfJson(projectPath) {
+    try {
+        return JSON.parse(fs.readFileSync(path.resolve(projectPath, "cdktf.json"), "utf8"));
+    }
+    catch (_a) {
+        return {};
+    }
+}
+// undefined: unset, malformed, or no readable cdktf.json
+function getUsageTelemetryConsent(projectPath = process.cwd()) {
+    const cdktfJson = readRawCdktfJson(projectPath);
+    if (!("sendUsageTelemetry" in cdktfJson)) {
+        return undefined;
+    }
+    return (0, config_1.normalizeConsentFlag)("sendUsageTelemetry", cdktfJson.sendUsageTelemetry);
+}
+// Shared by both bundle copies: the handlers' copy captures the decision and
+// starts the run, the entrypoint's copy counts the failure.
+const state = (0, process_state_1.processState)("cdktn.commandTelemetry", () => ({}));
+exports.PACKAGE_MANAGERS = [
+    "npm",
+    "pnpm",
+    "yarn",
+    "yarn-berry",
+    "pip",
+    "pipenv",
+    "maven",
+    "gradle",
+    "nuget",
+    "go",
+];
+// Only members of the closed set become an attribute: a `packageManager`
+// field carries a version and a hash, and a detector may grow new values.
+function normalizePackageManager(value) {
+    return exports.PACKAGE_MANAGERS.find((name) => name === value);
+}
+// The package manager `provider add` would drive, decided the way cli-core's
+// PackageManager.forLanguage does. undefined outside a supported project.
+function detectPackageManager(projectPath, cdktfJson) {
+    try {
+        switch (cdktfJson.language) {
+            case config_2.Language.TYPESCRIPT:
+                return normalizePackageManager((0, node_package_manager_1.detectNodePackageManager)(projectPath));
+            case config_2.Language.PYTHON:
+                if (typeof cdktfJson.app !== "string") {
+                    return undefined;
+                }
+                return cdktfJson.app.includes("pipenv") ? "pipenv" : "pip";
+            case config_2.Language.JAVA:
+                return (0, gradle_1.isGradleProject)(projectPath) ? "gradle" : "maven";
+            case config_2.Language.CSHARP:
+                return "nuget";
+            case config_2.Language.GO:
+                return "go";
+            default:
+                return undefined;
+        }
+    }
+    catch (err) {
+        logging_1.logger.debug(`Could not detect the package manager: ${err}`);
+        return undefined;
+    }
+}
+// Free-text payload fields are validated before they become attributes so a
+// misconfigured or hand-edited value never carries arbitrary text.
+const CONSTRAINT_PART = /^(=|!=|>=|<=|>|<|~>)?\s*(\d+(?:\.\d+){0,2})$/;
+const RELEASE_VERSION = /^\d+\.\d+\.\d+/;
+// Terraform's built-in backend kinds; anything else is sent as "other"
+const BACKEND_KINDS = [
+    "local",
+    "remote",
+    "cloud",
+    "s3",
+    "gcs",
+    "azurerm",
+    "http",
+    "consul",
+    "kubernetes",
+    "pg",
+    "oss",
+    "cos",
+    "etcdv3",
+    "artifactory",
+    "swift",
+    "manta",
+];
+function normalizeBackendKind(backend) {
+    if (typeof backend !== "string") {
+        return "unknown";
+    }
+    return BACKEND_KINDS.includes(backend) ? backend : "other";
+}
+// Terraform resource type grammar; the stack-level override keys (stack,
+// backend, output, local, terraform_remote_state) are identifiers too.
+const RESOURCE_TYPE = /^[a-z][a-z0-9_]*$/;
+// MAJOR.MINOR.PATCH only: prerelease and build identifiers are free text
+// (a wrapper's version line or a locally built library can carry anything).
+function releaseVersion(value) {
+    var _a;
+    return (_a = RELEASE_VERSION.exec(value !== null && value !== void 0 ? value : "")) === null || _a === void 0 ? void 0 : _a[0];
+}
+// Normalized so spacing variants collapse into one value. Hyphen ranges are
+// written " - ", so a hyphen right after a digit is always a prerelease:
+// free text (see releaseVersion), which rejects the range.
+function semverRangeOrInvalid(value) {
+    const range = value.length <= 64 ? semver.validRange(value) : null;
+    return range && !/\d[-+]/.test(value) ? range : "invalid";
+}
+// Re-joined as "~> 5.0, != 5.1.0" so spacing variants are one value. The
+// constraint is user-authored, so a prerelease identifier or an over-long
+// value rejects it whole.
+function normalizeProviderConstraint(value) {
+    if (value.length > 64) {
+        return "invalid";
+    }
+    const parts = [];
+    for (const part of value.split(",")) {
+        const match = CONSTRAINT_PART.exec(part.trim());
+        if (!match) {
+            return "invalid";
+        }
+        const [, operator, version] = match;
+        parts.push(operator ? `${operator} ${version}` : version);
+    }
+    return parts.join(", ");
+}
+function setUsageTelemetryEnabled(enabled) {
+    state.usageTelemetryEnabled = enabled;
+}
+// Once captured, the decision stands for the process; reporting is not
+// initialized a second time.
+function hasCapturedUsageTelemetryDecision() {
+    return state.usageTelemetryEnabled !== undefined;
+}
+// Precedence: CHECKPOINT_DISABLE > the decision captured at command start >
+// `sendUsageTelemetry` in cdktf.json > enabled.
+function isUsageTelemetryEnabled(projectPath = process.cwd()) {
+    if (process.env.CHECKPOINT_DISABLE) {
+        return false;
+    }
+    if (state.usageTelemetryEnabled !== undefined) {
+        return state.usageTelemetryEnabled;
+    }
+    return getUsageTelemetryConsent(projectPath) !== false;
+}
+// Falls back to the CLI defaults, so every metric carries the ranges the
+// command validated against.
+function getProjectTargetAttributes(projectPath = process.cwd()) {
+    const cdktfJson = readRawCdktfJson(projectPath);
+    const declared = cdktfJson.targetVersions &&
+        typeof cdktfJson.targetVersions === "object" &&
+        !Array.isArray(cdktfJson.targetVersions)
+        ? cdktfJson.targetVersions
+        : undefined;
+    const targets = declared !== null && declared !== void 0 ? declared : config_2.DEFAULT_TARGET_VERSIONS;
+    const attributes = {
+        targets_declared: declared !== undefined,
+        validate_installed_binary: cdktfJson.validateInstalledBinary === true,
+    };
+    if (typeof targets.terraform === "string") {
+        attributes.target_terraform = semverRangeOrInvalid(targets.terraform);
+    }
+    if (typeof targets.opentofu === "string") {
+        attributes.target_opentofu = semverRangeOrInvalid(targets.opentofu);
+    }
+    return attributes;
+}
+function setProjectTargetAttributes(attributes) {
+    state.projectTargetAttributes = attributes;
+}
+async function getBinaryAttributes() {
+    const cli = await (0, terraform_1.terraformCli)();
+    const attributes = { binary: cli.name };
+    // an unrecognised product's version is the first version-like token of
+    // its output, which can be anything (a wrapper's "connected to 10.0.0.1")
+    const release = cli.name === "terraform" || cli.name === "opentofu"
+        ? releaseVersion(cli.version)
+        : undefined;
+    if (release) {
+        attributes.binary_version = release;
+    }
+    return attributes;
+}
+// By type and command only: message and context can carry paths and user
+// input.
+function sendErrorTelemetry(type, command) {
+    try {
+        if (!isUsageTelemetryEnabled()) {
+            return;
+        }
+        Sentry.metrics.count("cli.error", 1, { attributes: { type, command } });
+    }
+    catch (err) {
+        logging_1.logger.debug(`Could not send error telemetry: ${err}`);
+    }
+}
+// Call before an explicit process.exit(): Sentry buffers asynchronously and
+// a hard exit drops the buffer.
+async function flushTelemetry(timeoutMs = 4000) {
+    try {
+        await Sentry.flush(timeoutMs);
+    }
+    catch (err) {
+        logging_1.logger.debug(`Could not flush telemetry: ${err}`);
+    }
+}
+const PUBLIC_PROVIDER_REGISTRIES = [
+    "registry.terraform.io",
+    "registry.opentofu.org",
+];
+const PROVIDER_SEGMENT = /^[a-z0-9][a-z0-9_-]*$/;
+const PROVIDER_HOST = /^(localhost|[a-z0-9-]+(\.[a-z0-9-]+)+)(:\d+)?$/;
+// Registry identities are bounded so an over-long hand-written source cannot
+// carry free text through the segment grammar.
+function withinIdentityLimits(segments) {
+    return (segments.every((segment) => segment.length <= 64) &&
+        segments.join("/").length <= 128);
+}
+// Only a public-registry `namespace/type` is sent (`aws`, `hashicorp/aws@~>5`
+// and `registry.terraform.io/hashicorp/aws` are one); other hosts become
+// "private-registry", paths and malformed input "other".
+function normalizeProviderSource(source) {
+    const segments = source.trim().toLowerCase().split("@")[0].split("/");
+    if (segments.length === 3) {
+        const host = segments.shift();
+        if (!PUBLIC_PROVIDER_REGISTRIES.includes(host)) {
+            return PROVIDER_HOST.test(host) ? "private-registry" : "other";
+        }
+    }
+    if (segments.length === 1) {
+        segments.unshift("hashicorp");
+    }
+    return segments.length === 2 &&
+        segments.every((s) => PROVIDER_SEGMENT.test(s)) &&
+        withinIdentityLimits(segments)
+        ? segments.join("/")
+        : "other";
+}
+// Comparison key for generated-vs-prebuilt, never sent: public sources
+// normalize, anything else stays raw so two unrelated private sources (both
+// "private-registry" on the metric) never match each other.
+function providerIdentity(source) {
+    const normalized = normalizeProviderSource(source);
+    return normalized === "private-registry" || normalized === "other"
+        ? source.trim().toLowerCase().split("@")[0]
+        : normalized;
+}
+// From `terraformProviders` in cdktf.json (`"aws@~>5.0"` strings or
+// `{ name, source }` objects); a stack provider not listed there is prebuilt.
+function getGeneratedProviderSources(projectPath = process.cwd()) {
+    const entries = readRawCdktfJson(projectPath).terraformProviders;
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    return entries.flatMap((entry) => {
+        var _a;
+        if (typeof entry === "string") {
+            return [providerIdentity(entry)];
+        }
+        const source = (_a = entry === null || entry === void 0 ? void 0 : entry.source) !== null && _a !== void 0 ? _a : entry === null || entry === void 0 ? void 0 : entry.name;
+        return typeof source === "string" ? [providerIdentity(source)] : [];
+    });
+}
+function classifyProviderBinding(source, generatedSources) {
+    return generatedSources.includes(providerIdentity(source))
+        ? "generated"
+        : "prebuilt";
+}
+// Public registry addresses are `namespace/name/provider` with plain segments;
+// a dot, colon or `~` in a segment marks a hostname, bucket or home path that
+// go-getter would resolve instead.
+const REGISTRY_SEGMENT = /^[a-z0-9][a-z0-9_-]*$/;
+// Forced getters, URLs and well-known object-store or forge hosts.
+const REMOTE_SOURCE = /^(?:git|hg|s3|gcs)::|^git@|:\/\/|^github\.com\/|^bitbucket\.org\/|amazonaws\.com\/|googleapis\.com\//i;
+// Only public registry sources are sent as-is; anything else could carry a
+// path, hostname, bucket or organization and is reduced to its kind.
+function classifyModuleSource(source) {
+    const trimmed = source.trim();
+    if ((0, config_2.isLocalModule)(trimmed) || path.isAbsolute(trimmed)) {
+        return "local";
+    }
+    if (REMOTE_SOURCE.test(trimmed)) {
+        return "git";
+    }
+    if (!(0, terraform_module_1.isRegistryModule)(trimmed)) {
+        return "other";
+    }
+    const segments = trimmed.toLowerCase().split("/");
+    if (segments.length === 4) {
+        return "private-registry";
+    }
+    return segments.every((segment) => REGISTRY_SEGMENT.test(segment)) &&
+        withinIdentityLimits(segments)
+        ? segments.join("/")
+        : "other";
+}
+/** What triggered a synth other than the command itself. */
+exports.SYNTH_ORIGINS = ["watch"];
+// Scalar payload fields forwarded as attributes, per command, each with the
+// type (and where enumerable, the values) it must have. Anything not listed
+// here, of the wrong type or off the value set stays out of the metric.
+const SCALAR_ATTRIBUTES = {
+    synth: {
+        synthOrigin: {
+            attribute: "synth_origin",
+            type: "string",
+            values: exports.SYNTH_ORIGINS,
+        },
+    },
+    init: {
+        // reduced to a built-in template name or "remote" by templateTelemetryName
+        template: { attribute: "template", type: "string" },
+        isRemote: { attribute: "is_remote", type: "boolean" },
+    },
+    convert: {
+        numberOfModules: { attribute: "module_count", type: "number" },
+        numberOfProviders: { attribute: "provider_count", type: "number" },
+        convertedLines: { attribute: "converted_lines", type: "number" },
+    },
+};
+function scalarAttributeValue(value, spec) {
+    if (typeof value !== spec.type) {
+        return undefined;
+    }
+    if (spec.type === "number" && !Number.isFinite(value)) {
+        return undefined;
+    }
+    if (spec.values && !spec.values.includes(value)) {
+        return undefined;
+    }
+    return value;
+}
+// `overrides: { aws_s3_bucket: ["tags", "region"] }` gives { aws_s3_bucket: 2 }
+function groupSizes(group) {
+    const sizes = {};
+    if (group && typeof group === "object" && !Array.isArray(group)) {
+        for (const [key, entries] of Object.entries(group)) {
+            sizes[key] = Array.isArray(entries) ? entries.length : 0;
+        }
+    }
+    return sizes;
+}
+function sum(sizes) {
+    return Object.values(sizes).reduce((total, size) => total + size, 0);
+}
+// Override keys are provider schema names, except module overrides which
+// carry the module source and are reduced to its kind.
+function overrideResourceType(key) {
+    const resourceType = key.startsWith("module.")
+        ? `module.${classifyModuleSource(key.slice("module.".length))}`
+        : key;
+    return resourceType.length <= 64 &&
+        (RESOURCE_TYPE.test(resourceType) || resourceType.startsWith("module."))
+        ? resourceType
+        : "other";
+}
+// Distinct identities reported per metric and run. A project's size must not
+// decide how many events one run sends, so the rest folds into one event.
+const MAX_STACK_GROUPS = 8;
+const MAX_STACK_PROVIDERS = 32;
+const MAX_STACK_OVERRIDE_TYPES = 32;
+const MAX_BINDING_SOURCES = 32;
+// What an aggregated metric adds to the command attributes, with the type
+// each must have; anything else stays out of the metric.
+const AGGREGATE_ATTRIBUTES = {
+    "cli.stack": {
+        backend: "string",
+        cloud: "boolean",
+        library_version: "string",
+        override_count: "number",
+        import_count: "number",
+        moved_count: "number",
+        truncated: "boolean",
+    },
+    "cli.stack.provider": {
+        provider: "string",
+        version_constraint: "string",
+        binding: "string",
+        truncated: "boolean",
+    },
+    "cli.stack.override": {
+        resource_type: "string",
+        override_count: "number",
+        truncated: "boolean",
+    },
+    "cli.get.provider": { provider: "string", truncated: "boolean" },
+    "cli.get.module": { module: "string", truncated: "boolean" },
+    "cli.init.provider": { provider: "string", truncated: "boolean" },
+};
+function addSums(target, sums) {
+    var _a;
+    for (const [name, count] of Object.entries(sums)) {
+        target[name] = ((_a = target[name]) !== null && _a !== void 0 ? _a : 0) + count;
+    }
+}
+// The identity must hold normalised values only: grouping on a raw source
+// would send one event per distinct private host. A member (a stack) that
+// reaches a group twice is counted once.
+function countInto(groups, member, identity, sums = {}) {
+    const key = JSON.stringify(identity);
+    let group = groups.get(key);
+    if (!group) {
+        group = { identity, sums: {}, value: 0 };
+        groups.set(key, group);
+    }
+    if (group.lastMember !== member) {
+        group.lastMember = member;
+        group.value += 1;
+    }
+    addSums(group.sums, sums);
+}
+// One counter per group, the most counted first (ties by identity, so the
+// kept set is stable); the groups past `limit` fold into one event without
+// identity, which keeps the metric's total.
+function emitGroups(metric, limit, groups, attributes) {
+    const sorted = [...groups.entries()]
+        .sort(([keyA, a], [keyB, b]) => b.value - a.value || (keyA < keyB ? -1 : 1))
+        .map(([, group]) => group);
+    const emitted = sorted.slice(0, limit);
+    const folded = sorted.slice(limit);
+    if (folded.length > 0) {
+        const residual = {
+            identity: { truncated: true },
+            sums: {},
+            value: 0,
+        };
+        for (const group of folded) {
+            residual.value += group.value;
+            addSums(residual.sums, group.sums);
+        }
+        emitted.push(residual);
+    }
+    const allowed = AGGREGATE_ATTRIBUTES[metric];
+    for (const group of emitted) {
+        const own = {};
+        for (const [name, raw] of Object.entries({
+            ...group.identity,
+            ...group.sums,
+        })) {
+            const value = name in allowed
+                ? scalarAttributeValue(raw, { type: allowed[name] })
+                : undefined;
+            if (value !== undefined) {
+                own[name] = value;
+            }
+        }
+        Sentry.metrics.count(metric, group.value, {
+            attributes: { ...attributes, ...own },
+        });
+    }
+}
+// counts and allow-listed kinds only, never names or ids
+function sendStackTelemetry(stackMetadata, requiredProviders, attributes) {
+    var _a;
+    const generatedSources = (_a = state.generatedProviderSources) !== null && _a !== void 0 ? _a : getGeneratedProviderSources();
+    const stacks = new Map();
+    const overrides = new Map();
+    const providers = new Map();
+    stackMetadata.forEach((entry, index) => {
+        // a null or non-object entry is not a stack: counting one would inflate
+        // the stack count with metadata the library never wrote
+        if (!entry || typeof entry !== "object") {
+            return;
+        }
+        const metadata = entry;
+        const overrideSizes = groupSizes(metadata.overrides);
+        const stack = {
+            backend: normalizeBackendKind(metadata.backend),
+            cloud: typeof metadata.cloud === "string",
+        };
+        const libraryVersion = releaseVersion(metadata.version);
+        if (libraryVersion) {
+            stack.library_version = libraryVersion;
+        }
+        countInto(stacks, index, stack, {
+            override_count: sum(overrideSizes),
+            import_count: sum(groupSizes(metadata.imports)),
+            moved_count: sum(groupSizes(metadata.moved)),
+        });
+        for (const [key, count] of Object.entries(overrideSizes)) {
+            countInto(overrides, index, { resource_type: overrideResourceType(key) }, { override_count: count });
+        }
+        const required = requiredProviders[index];
+        if (!required || typeof required !== "object") {
+            return;
+        }
+        for (const [type, constraint] of Object.entries(required)) {
+            const source = typeof (constraint === null || constraint === void 0 ? void 0 : constraint.source) === "string" ? constraint.source : type;
+            const provider = {
+                provider: normalizeProviderSource(source),
+            };
+            if (typeof (constraint === null || constraint === void 0 ? void 0 : constraint.version) === "string") {
+                provider.version_constraint = normalizeProviderConstraint(constraint.version);
+            }
+            provider.binding = classifyProviderBinding(source, generatedSources);
+            countInto(providers, index, provider);
+        }
+    });
+    emitGroups("cli.stack", MAX_STACK_GROUPS, stacks, attributes);
+    emitGroups("cli.stack.provider", MAX_STACK_PROVIDERS, providers, attributes);
+    emitGroups("cli.stack.override", MAX_STACK_OVERRIDE_TYPES, overrides, attributes);
+}
+function sendSourceTelemetry(metric, attribute, sources, normalize, attributes) {
+    const groups = new Map();
+    sources.forEach((source, index) => countInto(groups, index, { [attribute]: normalize(source) }));
+    emitGroups(metric, MAX_BINDING_SOURCES, groups, attributes);
+}
+// targets: one `{ type, source }` per generated binding
+function targetSources(targets, type) {
+    return targets
+        .filter((target) => (target === null || target === void 0 ? void 0 : target.type) === type)
+        .map((target) => target.source);
+}
+async function commandAttributes(command, language) {
+    var _a;
+    const ci = ci_info_1.default.isCI ? ci_info_1.default.name || "unknown" : false;
+    const attributes = {
+        command,
+        ci: ci === false ? false : ci,
+        os: process.platform,
+        arch: process.arch,
+        ...((_a = state.projectTargetAttributes) !== null && _a !== void 0 ? _a : getProjectTargetAttributes()),
+        ...(await getBinaryAttributes()),
+    };
+    if (config_2.LANGUAGES.includes(language)) {
+        attributes.language = language;
+    }
+    if (state.packageManager !== undefined) {
+        attributes.package_manager = state.packageManager;
+    }
+    return attributes;
+}
+// Counts the attempt, whatever its outcome. Runs after consent is captured
+// and Sentry initialized; later calls in the same process are no-ops.
+async function startCommandTelemetry(command, projectPath = process.cwd()) {
+    if (state.startedCommand !== undefined) {
+        return;
+    }
+    state.startedCommand = command;
+    const cdktfJson = readRawCdktfJson(projectPath);
+    state.language = cdktfJson.language;
+    state.packageManager = detectPackageManager(projectPath, cdktfJson);
+    state.generatedProviderSources = getGeneratedProviderSources(projectPath);
+    try {
+        if (!isUsageTelemetryEnabled()) {
+            return;
+        }
+        const attributes = await commandAttributes(command, state.language);
+        Sentry.metrics.count("cli.command.invoked", 1, { attributes });
+    }
+    catch (err) {
+        logging_1.logger.debug(`Could not send telemetry data: ${err}`);
+    }
+}
+/** Forgets the started run; tests run many commands in one process. */
+function resetCommandTelemetry() {
+    state.startedCommand = undefined;
+    state.language = undefined;
+    state.packageManager = undefined;
+    state.generatedProviderSources = undefined;
+    state.stackMetricsSent = undefined;
+}
+// Payload fields reach the attributes only through the allow-lists above.
+// A no-op when usage telemetry is disabled or Sentry is not initialized;
+// `payload.error` counts the run as cli.command.error instead.
+async function sendTelemetry(command, payload) {
+    var _a, _b;
+    try {
+        if (!isUsageTelemetryEnabled()) {
+            return;
+        }
+        const attributes = await commandAttributes(command, (_a = payload.language) !== null && _a !== void 0 ? _a : state.language);
+        for (const [key, spec] of Object.entries((_b = SCALAR_ATTRIBUTES[command]) !== null && _b !== void 0 ? _b : {})) {
+            const value = scalarAttributeValue(payload[key], spec);
+            if (value !== undefined) {
+                attributes[spec.attribute] = value;
+            }
+        }
+        if (payload.error) {
+            attributes.error_type = exports.COMMAND_ERROR_TYPES.includes(payload.errorType)
+                ? payload.errorType
+                : "unexpected";
+            Sentry.metrics.count("cli.command.error", 1, { attributes });
+            return;
+        }
+        const generated = command === "get" && Array.isArray(payload.targets)
+            ? {
+                providers: targetSources(payload.targets, "provider"),
+                modules: targetSources(payload.targets, "module"),
+            }
+            : undefined;
+        const addedProviders = command === "init" && Array.isArray(payload.addedProviders)
+            ? payload.addedProviders
+            : undefined;
+        if (generated) {
+            attributes.provider_count = generated.providers.length;
+            attributes.module_count = generated.modules.length;
+        }
+        if (addedProviders) {
+            attributes.provider_count = addedProviders.length;
+        }
+        // The run's outcome goes first: nothing in the per-source and stack
+        // metrics below can then cost the run its command metric.
+        const nested = state.startedCommand !== undefined && state.startedCommand !== command;
+        // a run that failed, with or without a failed stack, is not completed: the
+        // failure thrown next is counted as cli.command.error by the entrypoint's
+        // reporter
+        const failedStackCount = typeof payload.failedStackCount === "number"
+            ? payload.failedStackCount
+            : 0;
+        if (failedStackCount > 0) {
+            Sentry.metrics.count("cli.stack.failed", failedStackCount, {
+                attributes,
+            });
+        }
+        else if (!nested && payload.runFailed !== true) {
+            Sentry.metrics.count("cli.command.completed", 1, { attributes });
+        }
+        if (typeof payload.totalTime === "number") {
+            Sentry.metrics.distribution("cli.synth.duration", payload.totalTime, {
+                unit: "millisecond",
+                attributes,
+            });
+        }
+        if (generated) {
+            sendSourceTelemetry("cli.get.provider", "provider", generated.providers, normalizeProviderSource, attributes);
+            sendSourceTelemetry("cli.get.module", "module", generated.modules, classifyModuleSource, attributes);
+        }
+        if (addedProviders) {
+            sendSourceTelemetry("cli.init.provider", "provider", addedProviders, normalizeProviderSource, attributes);
+        }
+        // A synth nested in another command describes every stack of the app;
+        // the command reports the stacks it selected, under its own name.
+        if (Array.isArray(payload.stackMetadata) &&
+            !state.stackMetricsSent &&
+            !(nested && command === "synth")) {
+            state.stackMetricsSent = true;
+            sendStackTelemetry(payload.stackMetadata, Array.isArray(payload.requiredProviders)
+                ? payload.requiredProviders
+                : [], attributes);
+        }
+    }
+    catch (err) {
+        logging_1.logger.debug(`Could not send telemetry data: ${err}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { normalizeConsentFlag } from \"./config\";\nimport * as Sentry from \"@sentry/node\";\nimport * as path from \"path\";\nimport * as fs from \"fs-extra\";\nimport * as semver from \"semver\";\nimport ciInfo from \"ci-info\";\nimport { logger } from \"./logging\";\nimport {\n  DEFAULT_TARGET_VERSIONS,\n  Language,\n  LANGUAGES,\n  isLocalModule,\n} from \"./config\";\nimport { isGradleProject } from \"./gradle\";\nimport { detectNodePackageManager } from \"./node-package-manager\";\nimport { processState } from \"./process-state\";\nimport { isRegistryModule } from \"./terraform-module\";\nimport { terraformCli } from \"./terraform\";\n\ntype AttributeValue = string | number | boolean;\ntype Attributes = Record<string, AttributeValue>;\n\nexport const COMMAND_ERROR_TYPES = [\n  \"Usage\",\n  \"External\",\n  \"Internal\",\n  \"unexpected\",\n] as const;\nexport type CommandErrorType = (typeof COMMAND_ERROR_TYPES)[number];\n\n// Never throws: telemetry also runs outside a project. Raw, because commons\n// cannot import cli-core's typed config.\nfunction readRawCdktfJson(projectPath: string): Record<string, any> {\n  try {\n    return JSON.parse(\n      fs.readFileSync(path.resolve(projectPath, \"cdktf.json\"), \"utf8\"),\n    );\n  } catch {\n    return {};\n  }\n}\n\n// undefined: unset, malformed, or no readable cdktf.json\nexport function getUsageTelemetryConsent(\n  projectPath = process.cwd(),\n): boolean | undefined {\n  const cdktfJson = readRawCdktfJson(projectPath);\n  if (!(\"sendUsageTelemetry\" in cdktfJson)) {\n    return undefined;\n  }\n  return normalizeConsentFlag(\n    \"sendUsageTelemetry\",\n    cdktfJson.sendUsageTelemetry,\n  );\n}\n\ntype CommandTelemetryState = {\n  // Captured by initializErrorReporting (cli-core) while still in the user's\n  // cwd: `convert` chdirs into a throwaway project before emitting, so\n  // re-reading cdktf.json at emission time would consult the wrong project.\n  usageTelemetryEnabled?: boolean;\n  // The command this run was started as; set once by startCommandTelemetry so\n  // the operations a command drives (a deploy's synth, the get of init or\n  // provider add) never count as runs.\n  startedCommand?: string;\n  // The raw `language` of the project the run started in, so every metric of\n  // the run (the error metric has no payload) carries the one `invoked` did.\n  language?: unknown;\n  // detected in the project the run started in, for the same reason\n  packageManager?: PackageManager;\n  // captured with the consent decision, for the same reason\n  projectTargetAttributes?: Attributes;\n  // Captured at start like `language`: the bindings the started project\n  // generates, whatever directory the run is in when it reports its stacks.\n  generatedProviderSources?: string[];\n  // A run reports its stacks once: a watch session redeploys the same app\n  // for hours and would repeat them on every file change.\n  stackMetricsSent?: boolean;\n};\n\n// Shared by both bundle copies: the handlers' copy captures the decision and\n// starts the run, the entrypoint's copy counts the failure.\nconst state = processState<CommandTelemetryState>(\n  \"cdktn.commandTelemetry\",\n  () => ({}),\n);\n\nexport const PACKAGE_MANAGERS = [\n  \"npm\",\n  \"pnpm\",\n  \"yarn\",\n  \"yarn-berry\",\n  \"pip\",\n  \"pipenv\",\n  \"maven\",\n  \"gradle\",\n  \"nuget\",\n  \"go\",\n] as const;\nexport type PackageManager = (typeof PACKAGE_MANAGERS)[number];\n\n// Only members of the closed set become an attribute: a `packageManager`\n// field carries a version and a hash, and a detector may grow new values.\nexport function normalizePackageManager(\n  value: unknown,\n): PackageManager | undefined {\n  return PACKAGE_MANAGERS.find((name) => name === value);\n}\n\n// The package manager `provider add` would drive, decided the way cli-core's\n// PackageManager.forLanguage does. undefined outside a supported project.\nfunction detectPackageManager(\n  projectPath: string,\n  cdktfJson: Record<string, any>,\n): PackageManager | undefined {\n  try {\n    switch (cdktfJson.language) {\n      case Language.TYPESCRIPT:\n        return normalizePackageManager(detectNodePackageManager(projectPath));\n      case Language.PYTHON:\n        if (typeof cdktfJson.app !== \"string\") {\n          return undefined;\n        }\n        return cdktfJson.app.includes(\"pipenv\") ? \"pipenv\" : \"pip\";\n      case Language.JAVA:\n        return isGradleProject(projectPath) ? \"gradle\" : \"maven\";\n      case Language.CSHARP:\n        return \"nuget\";\n      case Language.GO:\n        return \"go\";\n      default:\n        return undefined;\n    }\n  } catch (err) {\n    logger.debug(`Could not detect the package manager: ${err}`);\n    return undefined;\n  }\n}\n\n// Free-text payload fields are validated before they become attributes so a\n// misconfigured or hand-edited value never carries arbitrary text.\nconst CONSTRAINT_PART = /^(=|!=|>=|<=|>|<|~>)?\\s*(\\d+(?:\\.\\d+){0,2})$/;\nconst RELEASE_VERSION = /^\\d+\\.\\d+\\.\\d+/;\n\n// Terraform's built-in backend kinds; anything else is sent as \"other\"\nconst BACKEND_KINDS = [\n  \"local\",\n  \"remote\",\n  \"cloud\",\n  \"s3\",\n  \"gcs\",\n  \"azurerm\",\n  \"http\",\n  \"consul\",\n  \"kubernetes\",\n  \"pg\",\n  \"oss\",\n  \"cos\",\n  \"etcdv3\",\n  \"artifactory\",\n  \"swift\",\n  \"manta\",\n];\n\nfunction normalizeBackendKind(backend: unknown): string {\n  if (typeof backend !== \"string\") {\n    return \"unknown\";\n  }\n  return BACKEND_KINDS.includes(backend) ? backend : \"other\";\n}\n\n// Terraform resource type grammar; the stack-level override keys (stack,\n// backend, output, local, terraform_remote_state) are identifiers too.\nconst RESOURCE_TYPE = /^[a-z][a-z0-9_]*$/;\n\n// MAJOR.MINOR.PATCH only: prerelease and build identifiers are free text\n// (a wrapper's version line or a locally built library can carry anything).\nfunction releaseVersion(value: string | undefined): string | undefined {\n  return RELEASE_VERSION.exec(value ?? \"\")?.[0];\n}\n\n// Normalized so spacing variants collapse into one value. Hyphen ranges are\n// written \" - \", so a hyphen right after a digit is always a prerelease:\n// free text (see releaseVersion), which rejects the range.\nfunction semverRangeOrInvalid(value: string): string {\n  const range = value.length <= 64 ? semver.validRange(value) : null;\n  return range && !/\\d[-+]/.test(value) ? range : \"invalid\";\n}\n\n// Re-joined as \"~> 5.0, != 5.1.0\" so spacing variants are one value. The\n// constraint is user-authored, so a prerelease identifier or an over-long\n// value rejects it whole.\nfunction normalizeProviderConstraint(value: string): string {\n  if (value.length > 64) {\n    return \"invalid\";\n  }\n  const parts: string[] = [];\n  for (const part of value.split(\",\")) {\n    const match = CONSTRAINT_PART.exec(part.trim());\n    if (!match) {\n      return \"invalid\";\n    }\n    const [, operator, version] = match;\n    parts.push(operator ? `${operator} ${version}` : version);\n  }\n  return parts.join(\", \");\n}\n\nexport function setUsageTelemetryEnabled(enabled: boolean | undefined): void {\n  state.usageTelemetryEnabled = enabled;\n}\n\n// Once captured, the decision stands for the process; reporting is not\n// initialized a second time.\nexport function hasCapturedUsageTelemetryDecision(): boolean {\n  return state.usageTelemetryEnabled !== undefined;\n}\n\n// Precedence: CHECKPOINT_DISABLE > the decision captured at command start >\n// `sendUsageTelemetry` in cdktf.json > enabled.\nexport function isUsageTelemetryEnabled(projectPath = process.cwd()): boolean {\n  if (process.env.CHECKPOINT_DISABLE) {\n    return false;\n  }\n  if (state.usageTelemetryEnabled !== undefined) {\n    return state.usageTelemetryEnabled;\n  }\n  return getUsageTelemetryConsent(projectPath) !== false;\n}\n\n// Falls back to the CLI defaults, so every metric carries the ranges the\n// command validated against.\nexport function getProjectTargetAttributes(\n  projectPath = process.cwd(),\n): Attributes {\n  const cdktfJson = readRawCdktfJson(projectPath);\n  const declared =\n    cdktfJson.targetVersions &&\n    typeof cdktfJson.targetVersions === \"object\" &&\n    !Array.isArray(cdktfJson.targetVersions)\n      ? cdktfJson.targetVersions\n      : undefined;\n  const targets: Record<string, unknown> = declared ?? DEFAULT_TARGET_VERSIONS;\n  const attributes: Attributes = {\n    targets_declared: declared !== undefined,\n    validate_installed_binary: cdktfJson.validateInstalledBinary === true,\n  };\n  if (typeof targets.terraform === \"string\") {\n    attributes.target_terraform = semverRangeOrInvalid(targets.terraform);\n  }\n  if (typeof targets.opentofu === \"string\") {\n    attributes.target_opentofu = semverRangeOrInvalid(targets.opentofu);\n  }\n  return attributes;\n}\n\nexport function setProjectTargetAttributes(\n  attributes: Attributes | undefined,\n): void {\n  state.projectTargetAttributes = attributes;\n}\n\nasync function getBinaryAttributes(): Promise<Attributes> {\n  const cli = await terraformCli();\n  const attributes: Attributes = { binary: cli.name };\n  // an unrecognised product's version is the first version-like token of\n  // its output, which can be anything (a wrapper's \"connected to 10.0.0.1\")\n  const release =\n    cli.name === \"terraform\" || cli.name === \"opentofu\"\n      ? releaseVersion(cli.version)\n      : undefined;\n  if (release) {\n    attributes.binary_version = release;\n  }\n  return attributes;\n}\n\n// By type and command only: message and context can carry paths and user\n// input.\nexport function sendErrorTelemetry(type: string, command: string): void {\n  try {\n    if (!isUsageTelemetryEnabled()) {\n      return;\n    }\n    Sentry.metrics.count(\"cli.error\", 1, { attributes: { type, command } });\n  } catch (err) {\n    logger.debug(`Could not send error telemetry: ${err}`);\n  }\n}\n\n// Call before an explicit process.exit(): Sentry buffers asynchronously and\n// a hard exit drops the buffer.\nexport async function flushTelemetry(timeoutMs = 4000): Promise<void> {\n  try {\n    await Sentry.flush(timeoutMs);\n  } catch (err) {\n    logger.debug(`Could not flush telemetry: ${err}`);\n  }\n}\n\nconst PUBLIC_PROVIDER_REGISTRIES = [\n  \"registry.terraform.io\",\n  \"registry.opentofu.org\",\n];\nconst PROVIDER_SEGMENT = /^[a-z0-9][a-z0-9_-]*$/;\nconst PROVIDER_HOST = /^(localhost|[a-z0-9-]+(\\.[a-z0-9-]+)+)(:\\d+)?$/;\n\n// Registry identities are bounded so an over-long hand-written source cannot\n// carry free text through the segment grammar.\nfunction withinIdentityLimits(segments: string[]): boolean {\n  return (\n    segments.every((segment) => segment.length <= 64) &&\n    segments.join(\"/\").length <= 128\n  );\n}\n\n// Only a public-registry `namespace/type` is sent (`aws`, `hashicorp/aws@~>5`\n// and `registry.terraform.io/hashicorp/aws` are one); other hosts become\n// \"private-registry\", paths and malformed input \"other\".\nfunction normalizeProviderSource(source: string): string {\n  const segments = source.trim().toLowerCase().split(\"@\")[0].split(\"/\");\n  if (segments.length === 3) {\n    const host = segments.shift()!;\n    if (!PUBLIC_PROVIDER_REGISTRIES.includes(host)) {\n      return PROVIDER_HOST.test(host) ? \"private-registry\" : \"other\";\n    }\n  }\n  if (segments.length === 1) {\n    segments.unshift(\"hashicorp\");\n  }\n  return segments.length === 2 &&\n    segments.every((s) => PROVIDER_SEGMENT.test(s)) &&\n    withinIdentityLimits(segments)\n    ? segments.join(\"/\")\n    : \"other\";\n}\n\n// Comparison key for generated-vs-prebuilt, never sent: public sources\n// normalize, anything else stays raw so two unrelated private sources (both\n// \"private-registry\" on the metric) never match each other.\nfunction providerIdentity(source: string): string {\n  const normalized = normalizeProviderSource(source);\n  return normalized === \"private-registry\" || normalized === \"other\"\n    ? source.trim().toLowerCase().split(\"@\")[0]\n    : normalized;\n}\n\n// From `terraformProviders` in cdktf.json (`\"aws@~>5.0\"` strings or\n// `{ name, source }` objects); a stack provider not listed there is prebuilt.\nfunction getGeneratedProviderSources(projectPath = process.cwd()): string[] {\n  const entries = readRawCdktfJson(projectPath).terraformProviders;\n  if (!Array.isArray(entries)) {\n    return [];\n  }\n  return entries.flatMap((entry) => {\n    if (typeof entry === \"string\") {\n      return [providerIdentity(entry)];\n    }\n    const source = entry?.source ?? entry?.name;\n    return typeof source === \"string\" ? [providerIdentity(source)] : [];\n  });\n}\n\nfunction classifyProviderBinding(\n  source: string,\n  generatedSources: string[],\n): \"generated\" | \"prebuilt\" {\n  return generatedSources.includes(providerIdentity(source))\n    ? \"generated\"\n    : \"prebuilt\";\n}\n\n// Public registry addresses are `namespace/name/provider` with plain segments;\n// a dot, colon or `~` in a segment marks a hostname, bucket or home path that\n// go-getter would resolve instead.\nconst REGISTRY_SEGMENT = /^[a-z0-9][a-z0-9_-]*$/;\n\n// Forced getters, URLs and well-known object-store or forge hosts.\nconst REMOTE_SOURCE =\n  /^(?:git|hg|s3|gcs)::|^git@|:\\/\\/|^github\\.com\\/|^bitbucket\\.org\\/|amazonaws\\.com\\/|googleapis\\.com\\//i;\n\n// Only public registry sources are sent as-is; anything else could carry a\n// path, hostname, bucket or organization and is reduced to its kind.\nfunction classifyModuleSource(source: string): string {\n  const trimmed = source.trim();\n  if (isLocalModule(trimmed) || path.isAbsolute(trimmed)) {\n    return \"local\";\n  }\n  if (REMOTE_SOURCE.test(trimmed)) {\n    return \"git\";\n  }\n  if (!isRegistryModule(trimmed)) {\n    return \"other\";\n  }\n  const segments = trimmed.toLowerCase().split(\"/\");\n  if (segments.length === 4) {\n    return \"private-registry\";\n  }\n  return segments.every((segment) => REGISTRY_SEGMENT.test(segment)) &&\n    withinIdentityLimits(segments)\n    ? segments.join(\"/\")\n    : \"other\";\n}\n\n/** What triggered a synth other than the command itself. */\nexport const SYNTH_ORIGINS = [\"watch\"] as const;\nexport type SynthOrigin = (typeof SYNTH_ORIGINS)[number];\n\ntype ScalarAttribute = {\n  attribute: string;\n  type: \"string\" | \"number\" | \"boolean\";\n  /** Enumerated values; a value outside the set is dropped. */\n  values?: readonly string[];\n};\n\n// Scalar payload fields forwarded as attributes, per command, each with the\n// type (and where enumerable, the values) it must have. Anything not listed\n// here, of the wrong type or off the value set stays out of the metric.\nconst SCALAR_ATTRIBUTES: Record<string, Record<string, ScalarAttribute>> = {\n  synth: {\n    synthOrigin: {\n      attribute: \"synth_origin\",\n      type: \"string\",\n      values: SYNTH_ORIGINS,\n    },\n  },\n  init: {\n    // reduced to a built-in template name or \"remote\" by templateTelemetryName\n    template: { attribute: \"template\", type: \"string\" },\n    isRemote: { attribute: \"is_remote\", type: \"boolean\" },\n  },\n  convert: {\n    numberOfModules: { attribute: \"module_count\", type: \"number\" },\n    numberOfProviders: { attribute: \"provider_count\", type: \"number\" },\n    convertedLines: { attribute: \"converted_lines\", type: \"number\" },\n  },\n};\n\nfunction scalarAttributeValue(\n  value: unknown,\n  spec: Pick<ScalarAttribute, \"type\" | \"values\">,\n): AttributeValue | undefined {\n  if (typeof value !== spec.type) {\n    return undefined;\n  }\n  if (spec.type === \"number\" && !Number.isFinite(value)) {\n    return undefined;\n  }\n  if (spec.values && !spec.values.includes(value as string)) {\n    return undefined;\n  }\n  return value as AttributeValue;\n}\n\n// `overrides: { aws_s3_bucket: [\"tags\", \"region\"] }` gives { aws_s3_bucket: 2 }\nfunction groupSizes(group: unknown): Record<string, number> {\n  const sizes: Record<string, number> = {};\n  if (group && typeof group === \"object\" && !Array.isArray(group)) {\n    for (const [key, entries] of Object.entries(group)) {\n      sizes[key] = Array.isArray(entries) ? entries.length : 0;\n    }\n  }\n  return sizes;\n}\n\nfunction sum(sizes: Record<string, number>): number {\n  return Object.values(sizes).reduce((total, size) => total + size, 0);\n}\n\n// Override keys are provider schema names, except module overrides which\n// carry the module source and are reduced to its kind.\nfunction overrideResourceType(key: string): string {\n  const resourceType = key.startsWith(\"module.\")\n    ? `module.${classifyModuleSource(key.slice(\"module.\".length))}`\n    : key;\n  return resourceType.length <= 64 &&\n    (RESOURCE_TYPE.test(resourceType) || resourceType.startsWith(\"module.\"))\n    ? resourceType\n    : \"other\";\n}\n\n// Distinct identities reported per metric and run. A project's size must not\n// decide how many events one run sends, so the rest folds into one event.\nconst MAX_STACK_GROUPS = 8;\nconst MAX_STACK_PROVIDERS = 32;\nconst MAX_STACK_OVERRIDE_TYPES = 32;\nconst MAX_BINDING_SOURCES = 32;\n\n// What an aggregated metric adds to the command attributes, with the type\n// each must have; anything else stays out of the metric.\nconst AGGREGATE_ATTRIBUTES: Record<\n  string,\n  Record<string, ScalarAttribute[\"type\"]>\n> = {\n  \"cli.stack\": {\n    backend: \"string\",\n    cloud: \"boolean\",\n    library_version: \"string\",\n    override_count: \"number\",\n    import_count: \"number\",\n    moved_count: \"number\",\n    truncated: \"boolean\",\n  },\n  \"cli.stack.provider\": {\n    provider: \"string\",\n    version_constraint: \"string\",\n    binding: \"string\",\n    truncated: \"boolean\",\n  },\n  \"cli.stack.override\": {\n    resource_type: \"string\",\n    override_count: \"number\",\n    truncated: \"boolean\",\n  },\n  \"cli.get.provider\": { provider: \"string\", truncated: \"boolean\" },\n  \"cli.get.module\": { module: \"string\", truncated: \"boolean\" },\n  \"cli.init.provider\": { provider: \"string\", truncated: \"boolean\" },\n};\n\ntype MetricGroup = {\n  identity: Attributes;\n  sums: Record<string, number>;\n  value: number;\n  lastMember?: number;\n};\ntype MetricGroups = Map<string, MetricGroup>;\n\nfunction addSums(target: Record<string, number>, sums: Record<string, number>) {\n  for (const [name, count] of Object.entries(sums)) {\n    target[name] = (target[name] ?? 0) + count;\n  }\n}\n\n// The identity must hold normalised values only: grouping on a raw source\n// would send one event per distinct private host. A member (a stack) that\n// reaches a group twice is counted once.\nfunction countInto(\n  groups: MetricGroups,\n  member: number,\n  identity: Attributes,\n  sums: Record<string, number> = {},\n): void {\n  const key = JSON.stringify(identity);\n  let group = groups.get(key);\n  if (!group) {\n    group = { identity, sums: {}, value: 0 };\n    groups.set(key, group);\n  }\n  if (group.lastMember !== member) {\n    group.lastMember = member;\n    group.value += 1;\n  }\n  addSums(group.sums, sums);\n}\n\n// One counter per group, the most counted first (ties by identity, so the\n// kept set is stable); the groups past `limit` fold into one event without\n// identity, which keeps the metric's total.\nfunction emitGroups(\n  metric: string,\n  limit: number,\n  groups: MetricGroups,\n  attributes: Attributes,\n): void {\n  const sorted = [...groups.entries()]\n    .sort(([keyA, a], [keyB, b]) => b.value - a.value || (keyA < keyB ? -1 : 1))\n    .map(([, group]) => group);\n  const emitted = sorted.slice(0, limit);\n  const folded = sorted.slice(limit);\n  if (folded.length > 0) {\n    const residual: MetricGroup = {\n      identity: { truncated: true },\n      sums: {},\n      value: 0,\n    };\n    for (const group of folded) {\n      residual.value += group.value;\n      addSums(residual.sums, group.sums);\n    }\n    emitted.push(residual);\n  }\n  const allowed = AGGREGATE_ATTRIBUTES[metric];\n  for (const group of emitted) {\n    const own: Attributes = {};\n    for (const [name, raw] of Object.entries({\n      ...group.identity,\n      ...group.sums,\n    })) {\n      const value =\n        name in allowed\n          ? scalarAttributeValue(raw, { type: allowed[name] })\n          : undefined;\n      if (value !== undefined) {\n        own[name] = value;\n      }\n    }\n    Sentry.metrics.count(metric, group.value, {\n      attributes: { ...attributes, ...own },\n    });\n  }\n}\n\n// counts and allow-listed kinds only, never names or ids\nfunction sendStackTelemetry(\n  stackMetadata: unknown[],\n  requiredProviders: unknown[],\n  attributes: Attributes,\n): void {\n  const generatedSources =\n    state.generatedProviderSources ?? getGeneratedProviderSources();\n  const stacks: MetricGroups = new Map();\n  const overrides: MetricGroups = new Map();\n  const providers: MetricGroups = new Map();\n  stackMetadata.forEach((entry, index) => {\n    // a null or non-object entry is not a stack: counting one would inflate\n    // the stack count with metadata the library never wrote\n    if (!entry || typeof entry !== \"object\") {\n      return;\n    }\n    const metadata = entry as Record<string, any>;\n    const overrideSizes = groupSizes(metadata.overrides);\n    const stack: Attributes = {\n      backend: normalizeBackendKind(metadata.backend),\n      cloud: typeof metadata.cloud === \"string\",\n    };\n    const libraryVersion = releaseVersion(metadata.version);\n    if (libraryVersion) {\n      stack.library_version = libraryVersion;\n    }\n    countInto(stacks, index, stack, {\n      override_count: sum(overrideSizes),\n      import_count: sum(groupSizes(metadata.imports)),\n      moved_count: sum(groupSizes(metadata.moved)),\n    });\n\n    for (const [key, count] of Object.entries(overrideSizes)) {\n      countInto(\n        overrides,\n        index,\n        { resource_type: overrideResourceType(key) },\n        { override_count: count },\n      );\n    }\n\n    const required = requiredProviders[index];\n    if (!required || typeof required !== \"object\") {\n      return;\n    }\n    for (const [type, constraint] of Object.entries(\n      required as Record<string, any>,\n    )) {\n      const source =\n        typeof constraint?.source === \"string\" ? constraint.source : type;\n      const provider: Attributes = {\n        provider: normalizeProviderSource(source),\n      };\n      if (typeof constraint?.version === \"string\") {\n        provider.version_constraint = normalizeProviderConstraint(\n          constraint.version,\n        );\n      }\n      provider.binding = classifyProviderBinding(source, generatedSources);\n      countInto(providers, index, provider);\n    }\n  });\n  emitGroups(\"cli.stack\", MAX_STACK_GROUPS, stacks, attributes);\n  emitGroups(\"cli.stack.provider\", MAX_STACK_PROVIDERS, providers, attributes);\n  emitGroups(\n    \"cli.stack.override\",\n    MAX_STACK_OVERRIDE_TYPES,\n    overrides,\n    attributes,\n  );\n}\n\nfunction sendSourceTelemetry(\n  metric: string,\n  attribute: string,\n  sources: string[],\n  normalize: (source: string) => string,\n  attributes: Attributes,\n): void {\n  const groups: MetricGroups = new Map();\n  sources.forEach((source, index) =>\n    countInto(groups, index, { [attribute]: normalize(source) }),\n  );\n  emitGroups(metric, MAX_BINDING_SOURCES, groups, attributes);\n}\n\n// targets: one `{ type, source }` per generated binding\nfunction targetSources(targets: any[], type: string): string[] {\n  return targets\n    .filter((target) => target?.type === type)\n    .map((target) => target.source);\n}\n\nasync function commandAttributes(\n  command: string,\n  language: unknown,\n): Promise<Attributes> {\n  const ci: string | false = ciInfo.isCI ? ciInfo.name || \"unknown\" : false;\n  const attributes: Attributes = {\n    command,\n    ci: ci === false ? false : ci,\n    os: process.platform,\n    arch: process.arch,\n    ...(state.projectTargetAttributes ?? getProjectTargetAttributes()),\n    ...(await getBinaryAttributes()),\n  };\n  if (LANGUAGES.includes(language as any)) {\n    attributes.language = language as string;\n  }\n  if (state.packageManager !== undefined) {\n    attributes.package_manager = state.packageManager;\n  }\n  return attributes;\n}\n\n// Counts the attempt, whatever its outcome. Runs after consent is captured\n// and Sentry initialized; later calls in the same process are no-ops.\nexport async function startCommandTelemetry(\n  command: string,\n  projectPath = process.cwd(),\n): Promise<void> {\n  if (state.startedCommand !== undefined) {\n    return;\n  }\n  state.startedCommand = command;\n  const cdktfJson = readRawCdktfJson(projectPath);\n  state.language = cdktfJson.language;\n  state.packageManager = detectPackageManager(projectPath, cdktfJson);\n  state.generatedProviderSources = getGeneratedProviderSources(projectPath);\n  try {\n    if (!isUsageTelemetryEnabled()) {\n      return;\n    }\n    const attributes = await commandAttributes(command, state.language);\n    Sentry.metrics.count(\"cli.command.invoked\", 1, { attributes });\n  } catch (err) {\n    logger.debug(`Could not send telemetry data: ${err}`);\n  }\n}\n\n/** Forgets the started run; tests run many commands in one process. */\nexport function resetCommandTelemetry(): void {\n  state.startedCommand = undefined;\n  state.language = undefined;\n  state.packageManager = undefined;\n  state.generatedProviderSources = undefined;\n  state.stackMetricsSent = undefined;\n}\n\n// Payload fields reach the attributes only through the allow-lists above.\n// A no-op when usage telemetry is disabled or Sentry is not initialized;\n// `payload.error` counts the run as cli.command.error instead.\nexport async function sendTelemetry(\n  command: string,\n  payload: Record<string, any>,\n): Promise<void> {\n  try {\n    if (!isUsageTelemetryEnabled()) {\n      return;\n    }\n\n    const attributes = await commandAttributes(\n      command,\n      payload.language ?? state.language,\n    );\n    for (const [key, spec] of Object.entries(\n      SCALAR_ATTRIBUTES[command] ?? {},\n    )) {\n      const value = scalarAttributeValue(payload[key], spec);\n      if (value !== undefined) {\n        attributes[spec.attribute] = value;\n      }\n    }\n\n    if (payload.error) {\n      attributes.error_type = COMMAND_ERROR_TYPES.includes(payload.errorType)\n        ? payload.errorType\n        : \"unexpected\";\n      Sentry.metrics.count(\"cli.command.error\", 1, { attributes });\n      return;\n    }\n\n    const generated =\n      command === \"get\" && Array.isArray(payload.targets)\n        ? {\n            providers: targetSources(payload.targets, \"provider\"),\n            modules: targetSources(payload.targets, \"module\"),\n          }\n        : undefined;\n    const addedProviders: string[] | undefined =\n      command === \"init\" && Array.isArray(payload.addedProviders)\n        ? payload.addedProviders\n        : undefined;\n    if (generated) {\n      attributes.provider_count = generated.providers.length;\n      attributes.module_count = generated.modules.length;\n    }\n    if (addedProviders) {\n      attributes.provider_count = addedProviders.length;\n    }\n\n    // The run's outcome goes first: nothing in the per-source and stack\n    // metrics below can then cost the run its command metric.\n    const nested =\n      state.startedCommand !== undefined && state.startedCommand !== command;\n    // a run that failed, with or without a failed stack, is not completed: the\n    // failure thrown next is counted as cli.command.error by the entrypoint's\n    // reporter\n    const failedStackCount =\n      typeof payload.failedStackCount === \"number\"\n        ? payload.failedStackCount\n        : 0;\n    if (failedStackCount > 0) {\n      Sentry.metrics.count(\"cli.stack.failed\", failedStackCount, {\n        attributes,\n      });\n    } else if (!nested && payload.runFailed !== true) {\n      Sentry.metrics.count(\"cli.command.completed\", 1, { attributes });\n    }\n    if (typeof payload.totalTime === \"number\") {\n      Sentry.metrics.distribution(\"cli.synth.duration\", payload.totalTime, {\n        unit: \"millisecond\",\n        attributes,\n      });\n    }\n\n    if (generated) {\n      sendSourceTelemetry(\n        \"cli.get.provider\",\n        \"provider\",\n        generated.providers,\n        normalizeProviderSource,\n        attributes,\n      );\n      sendSourceTelemetry(\n        \"cli.get.module\",\n        \"module\",\n        generated.modules,\n        classifyModuleSource,\n        attributes,\n      );\n    }\n    if (addedProviders) {\n      sendSourceTelemetry(\n        \"cli.init.provider\",\n        \"provider\",\n        addedProviders,\n        normalizeProviderSource,\n        attributes,\n      );\n    }\n    // A synth nested in another command describes every stack of the app;\n    // the command reports the stacks it selected, under its own name.\n    if (\n      Array.isArray(payload.stackMetadata) &&\n      !state.stackMetricsSent &&\n      !(nested && command === \"synth\")\n    ) {\n      state.stackMetricsSent = true;\n      sendStackTelemetry(\n        payload.stackMetadata,\n        Array.isArray(payload.requiredProviders)\n          ? payload.requiredProviders\n          : [],\n        attributes,\n      );\n    }\n  } catch (err) {\n    logger.debug(`Could not send telemetry data: ${err}`);\n  }\n}\n"]}