@odigos/aws-cdk 0.0.13 → 0.0.14

package/lib/fargate.js

@@ -0,0 +1,400 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdigosFargateInstrumentation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const constructs_1 = require("constructs");
+const collector_config_1 = require("./collector-config");
+const fargate_1 = require("./generated/fargate");
+const layers_1 = require("./generated/layers");
+const fargate_recipes_1 = require("./fargate-recipes");
+/** Service name reported on every span, metric and log record. */
+const ENV_SERVICE_NAME = 'OTEL_SERVICE_NAME';
+/** Resource attributes added to every record: cloud provider, platform and region. */
+const ENV_RESOURCE_ATTRIBUTES = 'OTEL_RESOURCE_ATTRIBUTES';
+/** Where the agent exports OTLP. On Fargate this is the real destination, not a localhost collector. */
+const ENV_OTLP_ENDPOINT = 'OTEL_EXPORTER_OTLP_ENDPOINT';
+/** The transport for the endpoint above. The two are one decision. */
+const ENV_OTLP_PROTOCOL = 'OTEL_EXPORTER_OTLP_PROTOCOL';
+/** Per-request headers, in practice the destination's credential. */
+const ENV_OTLP_HEADERS = 'OTEL_EXPORTER_OTLP_HEADERS';
+/** Raises agent verbosity into the container's log stream. */
+const ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL';
+/** The three per-signal exporter switches. */
+const ENV_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER';
+const ENV_METRICS_EXPORTER = 'OTEL_METRICS_EXPORTER';
+const ENV_LOGS_EXPORTER = 'OTEL_LOGS_EXPORTER';
+/** Value a supported signal's exporter is set to. */
+const EXPORTER_OTLP = 'otlp';
+/**
+ * Schema version of the marker payload. Must match `api.IaCMarkerVersion` in the connector — it is what
+ * tells the connector how to read the rest of the object, so a bumped version there is a change here.
+ */
+const MARKER_VERSION = 1;
+/**
+ * `ODIGOS_IAC` — the marker recording that this container was instrumented by Odigos IaC tooling, by
+ * which package version, and for which language.
+ *
+ * It is PER CONTAINER, and it is the only thing that makes Odigos report a container as instrumented
+ * rather than "awaiting your deployment" — however completely the rest of the wiring is applied. A task
+ * definition holding two applications needs it on both.
+ *
+ * The `lang` field is the load-bearing one here (where Lambda's is `layer`). The connector's conformance
+ * check reconstructs the container's expected activation environment from the recorded language, so it is
+ * what makes "is this container correctly instrumented" answerable at all — and it is cross-checked
+ * against the language the connector resolves independently, which is how an image swapped underneath the
+ * instrumentation is caught.
+ *
+ * It is NOT `ODIGOS_MANAGED`, and this construct never writes that one. That is the connector's own
+ * record of a mutation IT performed, whose payload is the snapshot it restores from on rollback. A CDK
+ * stack has no such snapshot to offer, because nothing was mutated — the container definition below IS
+ * the container's definition. Writing it by hand would claim a rollback nobody recorded, and the
+ * connector would then judge the container against values that do not exist.
+ */
+const ENV_IAC_MARKER = 'ODIGOS_IAC';
+/** Construct id of the staging container inside the task definition's scope. */
+const SIDECAR_CONSTRUCT_ID = 'OdigosAgent';
+/**
+ * Memory reservation for the staging container on an EC2-only task definition, where ECS requires every
+ * container to declare its own if the task does not. Never set on a Fargate task definition — see the
+ * call site.
+ */
+const SIDECAR_EC2_MEMORY_MIB = 64;
+/**
+ * Instruments ECS Fargate containers with the Odigos OpenTelemetry agents.
+ *
+ * ```ts
+ * const odigos = new OdigosFargateInstrumentation(this, 'Odigos', {
+ *   destination: { httpEndpoint: 'https://otlp.example.com:4318' },
+ * });
+ * odigos.instrument({
+ *   container: apiContainer,
+ *   language: OdigosFargateLanguage.JAVA,
+ *   service: apiService,
+ * });
+ * ```
+ *
+ * ## What it does to the task definition
+ *
+ * Four moves, which are one mechanism and only work together — the ECS adaptation of the Odikos
+ * init-container mount method:
+ *
+ *  1. a bare-name task volume (`odigos-agent`), which on Fargate is an ephemeral-storage bind mount
+ *     scoped to the task;
+ *  2. a NON-ESSENTIAL `odigos-agent` container that copies the language agents out of the agents bundle
+ *     into that volume and exits 0;
+ *  3. the volume mounted read-only at `/var/odigos` in each instrumented container, which depends on the
+ *     staging container with condition `SUCCESS` — only valid against a non-essential container, which is
+ *     why (2) is non-essential;
+ *  4. the language's activation environment, the OTLP export environment, and the `ODIGOS_IAC` marker on
+ *     each instrumented container.
+ *
+ * There is ONE staging container per task definition however many languages the task holds; its command
+ * is the union of every instrumented container's agent directories, and it is built lazily so containers
+ * instrumented later are included.
+ *
+ * ## Where the telemetry goes
+ *
+ * Straight to your destination, from inside the application process. This is the substantive difference
+ * from Lambda: there is no collector in the task to hand a batch to, so a slow or unreachable destination
+ * is felt by the application's own exporter rather than absorbed after a response has been returned.
+ *
+ * ## What it deliberately does NOT do
+ *
+ * There is no aspect that sweeps a scope, as there is for Lambda. An aspect there works because a
+ * function DECLARES its runtime; a container declares an image, and a language guessed from an image name
+ * would silently mis-instrument the ones it got wrong — staging a Java agent into a Python container
+ * leaves it uninstrumented, and a `JAVA_TOOL_OPTIONS` on a JVM-less image is simply ignored, so nothing
+ * fails loudly enough to notice.
+ *
+ * ## Do not also instrument these services with the connector
+ *
+ * The connector instruments live services by registering a new task-definition revision and updating the
+ * service to it, reconciling to its own desired state on every pass. A service instrumented here and also
+ * enabled as a connector source ends up owned by both: each `cdk deploy` reasserts the stack's
+ * definition, each reconcile reasserts the connector's, and every round trip registers a revision and
+ * rolls the service. Choose one per service.
+ */
+class OdigosFargateInstrumentation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.taskDefinitions = new Map();
+        this.instrumented = new Set();
+        this.options = props;
+        const image = props.agentsImage ?? fargate_1.FARGATE_AGENTS_IMAGE;
+        if (!image) {
+            // Empty only in a checkout built before the first release. Failing here is the point: the
+            // alternative is a task definition whose staging container names a tag that does not exist, which
+            // surfaces as a task that will not start, at deploy time, in a place that says nothing about why.
+            throw new Error('Odigos: this build of @odigos/aws-cdk has no Fargate agents image baked in — it was built ' +
+                'before the first release. Use a released version of the package, or pass `agentsImage` ' +
+                'explicitly.');
+        }
+        this.agentsImage = image;
+        for (const target of props.targets ?? []) {
+            this.instrument(target);
+        }
+    }
+    /**
+     * Instruments one container. Idempotent — instrumenting the same container twice is a no-op rather than
+     * a doubled loader value.
+     */
+    instrument(target) {
+        const container = target.container;
+        const key = container.node.path;
+        if (this.instrumented.has(key)) {
+            return;
+        }
+        const taskDefinition = container.taskDefinition;
+        const recipe = (0, fargate_recipes_1.recipeFor)(target.language, target.runtimeVersion);
+        const serviceName = this.resolveServiceName(target);
+        this.checkTaskDefinition(taskDefinition, container);
+        this.instrumented.add(key);
+        const state = this.taskDefinitionState(taskDefinition);
+        for (const dir of recipe.agentDirs) {
+            state.agentDirs.add(dir);
+        }
+        // Read-only: the agents are only read here, and the staging container owns the writes.
+        container.addMountPoints({
+            sourceVolume: fargate_1.FARGATE_VOLUME_NAME,
+            containerPath: fargate_1.FARGATE_AGENTS_DIR,
+            readOnly: true,
+        });
+        // SUCCESS, not START: the agent files have to be on disk before the application process begins, and
+        // the staging container exits as soon as they are.
+        container.addContainerDependencies({
+            container: state.sidecar,
+            condition: ecs.ContainerDependencyCondition.SUCCESS,
+        });
+        for (const [name, value] of Object.entries(this.environmentFor(target, recipe, serviceName))) {
+            container.addEnvironment(name, value);
+        }
+    }
+    /** Instruments every target in the list. */
+    instrumentAll(targets) {
+        for (const target of targets) {
+            this.instrument(target);
+        }
+    }
+    /**
+     * The task definition's staging container and volume, created once and shared by every container in it.
+     *
+     * The command is a lazy list rather than a literal because the union it renders is not known until
+     * synthesis: a task definition holding a Java and a Python application is instrumented by two
+     * `instrument()` calls, and the single staging container has to stage both. The connector compares this
+     * command against exactly that union, so a stale one is reported as drift on the whole task definition
+     * and leaves one of the containers with no agent on disk.
+     */
+    taskDefinitionState(taskDefinition) {
+        const key = taskDefinition.node.path;
+        const existing = this.taskDefinitions.get(key);
+        if (existing) {
+            return existing;
+        }
+        // A bare-name volume — no host, docker or EFS configuration — is a Fargate ephemeral-storage bind
+        // mount scoped to the task, which is exactly the shared staging area needed and the only kind Fargate
+        // offers (there is no tmpfs).
+        taskDefinition.addVolume({ name: fargate_1.FARGATE_VOLUME_NAME });
+        const agentDirs = new Set();
+        const sidecar = taskDefinition.addContainer(SIDECAR_CONSTRUCT_ID, {
+            containerName: fargate_1.FARGATE_SIDECAR_CONTAINER_NAME,
+            image: ecs.ContainerImage.fromRegistry(this.agentsImage),
+            // Non-essential is not a preference: it is what makes the SUCCESS dependency above legal, and it is
+            // what stops a copier that has finished its job from failing the whole task by exiting.
+            essential: false,
+            command: aws_cdk_lib_1.Lazy.list({ produce: () => (0, fargate_recipes_1.sidecarCommand)([...agentDirs]) }),
+            // Fargate allocates memory at the task level, so the staging container declares none there — which
+            // keeps the rendered container byte-identical to what the connector writes. An EC2-only task
+            // definition without task-level memory requires every container to declare its own, so one is set
+            // for that case alone. A soft reservation, and generous: the container is busybox running `cp`.
+            memoryReservationMiB: taskDefinition.isFargateCompatible ? undefined : SIDECAR_EC2_MEMORY_MIB,
+        });
+        // Writable here — this is the container that puts the files there. `readOnly` is required by CDK's
+        // MountPoint struct where the connector simply omits it; false is what an omitted value means, and the
+        // connector's task-level check compares the staging container's image, essentiality and command, not
+        // its mounts, so spelling out the default is not drift.
+        sidecar.addMountPoints({
+            sourceVolume: fargate_1.FARGATE_VOLUME_NAME,
+            containerPath: fargate_1.FARGATE_AGENTS_DIR,
+            readOnly: false,
+        });
+        // Registered here, with the staging container, so it is added once per task definition however many
+        // containers are instrumented in it — and counted at synth, so containers added after this call are
+        // included. AWS rejects a RegisterTaskDefinition over the limit, which would otherwise surface as a
+        // deploy failure about a container count with nothing to say about which container is the extra one.
+        taskDefinition.node.addValidation({
+            validate: () => {
+                const containers = taskDefinition.node.children.filter((c) => c instanceof ecs.ContainerDefinition);
+                return containers.length > fargate_1.FARGATE_MAX_CONTAINERS
+                    ? [
+                        `Odigos: task definition ${taskDefinition.node.id} would have ${containers.length} ` +
+                            `containers, over the AWS maximum of ${fargate_1.FARGATE_MAX_CONTAINERS}. One of them is the ` +
+                            'odigos-agent staging container this instrumentation adds.',
+                    ]
+                    : [];
+            },
+        });
+        const state = { sidecar, agentDirs };
+        this.taskDefinitions.set(key, state);
+        return state;
+    }
+    /**
+     * `OTEL_SERVICE_NAME` for a target, and the one value a caller cannot be allowed to leave to a default.
+     *
+     * The connector compares it against the workload's name in Odigos, which is the ECS SERVICE name, so
+     * guessing — the task definition family, the container name, the construct id — would produce a stack
+     * that deploys cleanly and then reports as drifted on a component nothing in the stack makes visible.
+     *
+     * Read from the L1, not from `service.serviceName`: the L2 property is a token that resolves to a `Ref`
+     * to the service even when the stack set the name explicitly, and a `Ref` here is worse than useless —
+     * the task definition would reference the service that references it, which CloudFormation rejects as a
+     * dependency cycle at deploy time.
+     */
+    resolveServiceName(target) {
+        if (target.serviceName) {
+            return target.serviceName;
+        }
+        if (!target.service) {
+            throw new Error(`Odigos: instrumenting container "${target.container.containerName}" needs a service name. ` +
+                'OTEL_SERVICE_NAME must equal the workload\'s name in Odigos, which for a Fargate workload is ' +
+                'the ECS SERVICE name — not the task definition family. Pass `service` to read it off the ' +
+                'service, or `serviceName` when the service lives outside this stack.');
+        }
+        const cfn = target.service.node.defaultChild;
+        const resolved = cfn === undefined ? undefined : aws_cdk_lib_1.Stack.of(target.service).resolve(cfn.serviceName);
+        if (typeof resolved === 'string' && resolved !== '' && !aws_cdk_lib_1.Token.isUnresolved(resolved)) {
+            return resolved;
+        }
+        throw new Error(`Odigos: the service for container "${target.container.containerName}" has no explicit physical ` +
+            'name, so CloudFormation generates one — and a generated name is a `Ref` to the service, which ' +
+            'cannot go into the task definition that service runs (CloudFormation rejects the cycle). Set ' +
+            '`serviceName` on the ECS service, or pass `serviceName` here to state the name Odigos knows ' +
+            'the workload by.');
+    }
+    /**
+     * Checks the task definition can carry the staged-agent method at all, and warns about the things that
+     * are legal but almost certainly a mistake.
+     */
+    checkTaskDefinition(taskDefinition, container) {
+        if (!taskDefinition.isFargateCompatible) {
+            // Not fatal — the mechanism is a volume and a copier, which work on the EC2 launch type too. But
+            // the connector discovers and judges `aws.fargate-task` workloads, so an EC2-only task definition
+            // is instrumented here and invisible there.
+            aws_cdk_lib_1.Annotations.of(container).addWarningV2('@odigos/aws-cdk:notFargateCompatible', `Odigos: task definition ${taskDefinition.node.id} is not Fargate-compatible. The staging ` +
+                'container and shared volume will still work on the EC2 launch type, but Odigos discovers ' +
+                'these as `aws.fargate-task` workloads and will not report on an EC2-only task.');
+        }
+        const cfn = taskDefinition.node.defaultChild;
+        const platform = cfn?.runtimePlatform;
+        const osFamily = platform?.operatingSystemFamily;
+        if (typeof osFamily === 'string' && !aws_cdk_lib_1.Token.isUnresolved(osFamily) && !osFamily.startsWith('LINUX')) {
+            throw new Error(`Odigos: task definition ${taskDefinition.node.id} declares operatingSystemFamily ` +
+                `"${osFamily}". The Odigos Fargate agents bundle is Linux-only and glibc-based, so a Windows ` +
+                'task definition cannot be instrumented at all.');
+        }
+    }
+    /**
+     * The environment applied to one instrumented container.
+     *
+     * Mirrors `instrumentContainer` in the connector, including the ORDER of decisions: the agent's own
+     * activation variables first, then identity, then export, then the marker. Every variable here has a
+     * counterpart in the connector's `containerDiff`, which is what a customer's conformance report is
+     * built from — so one that is absent, or spelled differently, is reported as a named broken component
+     * rather than passing quietly.
+     */
+    environmentFor(target, recipe, serviceName) {
+        const { destination, debug } = this.options;
+        const container = target.container;
+        const env = {};
+        for (const [k, v] of Object.entries(recipe.staticEnv)) {
+            // These are set outright, not merged — PHP_INI_SCAN_DIR and RUBYOPT are compared exactly, so there
+            // is no room to fold a container's own value in. Silently discarding one is the failure worth
+            // naming: RUBYOPT commonly carries flags an application needs to boot.
+            const existing = containerEnvValue(container, k);
+            if (existing !== undefined && existing !== v) {
+                aws_cdk_lib_1.Annotations.of(container).addWarningV2('@odigos/aws-cdk:staticEnvOverwritten', `Odigos: container "${container.containerName}" already sets ${k}="${existing}", which the ` +
+                    `${recipe.language} agent's activation replaces with "${v}". Odigos compares this variable ` +
+                    'exactly, so it cannot merge the two — fold what your application needs into the value ' +
+                    'Odigos sets, or leave this container uninstrumented.');
+            }
+            env[k] = v;
+        }
+        for (const append of recipe.appendEnv) {
+            // Rebuilt from the container's ORIGINAL value so ours is joined rather than assigned over it — and
+            // so that a re-synth never accumulates our fragment twice. The separator comes from the pattern,
+            // not from an assumption: a space for the *_OPTIONS variables, a colon for PYTHONPATH.
+            const existing = target.existingLoaderValue ?? containerEnvValue(container, append.name) ?? '';
+            env[append.name] = (0, fargate_recipes_1.evaluateAppendPattern)(append.pattern, existing);
+        }
+        env[ENV_SERVICE_NAME] = serviceName;
+        env[ENV_RESOURCE_ATTRIBUTES] = (0, fargate_recipes_1.fargateResourceAttributes)(aws_cdk_lib_1.Stack.of(container).region);
+        const exportTarget = (0, fargate_recipes_1.exportTargetFor)(recipe, destination);
+        env[ENV_OTLP_ENDPOINT] = exportTarget.endpoint;
+        env[ENV_OTLP_PROTOCOL] = exportTarget.protocol;
+        const mismatch = (0, fargate_recipes_1.portProtocolMismatch)(exportTarget.endpoint, exportTarget.protocol);
+        if (mismatch) {
+            aws_cdk_lib_1.Annotations.of(container).addWarningV2('@odigos/aws-cdk:portProtocolMismatch', `Odigos: ${mismatch}`);
+        }
+        // All three are written explicitly, unlike Lambda, where an enabled signal's variable is left unset
+        // because `otlp` is already the SDK default. The connector's Fargate check compares all three by
+        // value, so an omitted one reads as drift on the export component.
+        const enabled = (0, collector_config_1.resolvedSignals)(destination);
+        if (!enabled.traces && !enabled.metrics && !enabled.logs) {
+            throw new Error('Odigos destination accepts no telemetry signals, so the agent would be loaded and produce ' +
+                'nothing. Note that metrics and logs are OFF by default — with `traces: false` the destination ' +
+                'has nothing left unless you also pass `metrics: true` or `logs: true`.');
+        }
+        env[ENV_TRACES_EXPORTER] = enabled.traces ? EXPORTER_OTLP : collector_config_1.EXPORTER_NONE;
+        env[ENV_METRICS_EXPORTER] = enabled.metrics ? EXPORTER_OTLP : collector_config_1.EXPORTER_NONE;
+        env[ENV_LOGS_EXPORTER] = enabled.logs ? EXPORTER_OTLP : collector_config_1.EXPORTER_NONE;
+        const headers = renderOtlpHeaders(destination.headers);
+        if (headers) {
+            env[ENV_OTLP_HEADERS] = headers;
+        }
+        if (debug) {
+            env[ENV_OTEL_LOG_LEVEL] = 'debug';
+        }
+        env[ENV_IAC_MARKER] = JSON.stringify({
+            v: MARKER_VERSION,
+            source: 'cdk',
+            version: layers_1.ODIGOS_VERSION || 'unreleased',
+            lang: (0, fargate_recipes_1.languageKeyOf)(target.language),
+        });
+        return env;
+    }
+}
+exports.OdigosFargateInstrumentation = OdigosFargateInstrumentation;
+_a = JSII_RTTI_SYMBOL_1;
+OdigosFargateInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosFargateInstrumentation", version: "0.0.14" };
+/**
+ * The value the container was created with for an environment variable, or undefined.
+ *
+ * `ContainerDefinition` keeps its environment private and offers `addEnvironment` but no reader, so this
+ * reaches for the field. That is a contained hack with a specific alternative: without it, appending to a
+ * loader variable would mean ASSIGNING over it, and a container whose `NODE_OPTIONS` carries a flag its
+ * application needs to boot would stop booting the moment it was instrumented. `existingLoaderValue` on
+ * the target is the documented escape hatch if this ever stops working; a shape that is not a plain object
+ * degrades to "nothing there", which is the same answer as an uninstrumented container.
+ */
+function containerEnvValue(container, name) {
+    const env = container.environment;
+    if (!env || typeof env !== 'object') {
+        return undefined;
+    }
+    const value = env[name];
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Renders `OTEL_EXPORTER_OTLP_HEADERS` — a comma-separated `key=value` list, keys sorted so the rendered
+ * value is byte-stable across synths and an unchanged destination never looks like a change.
+ */
+function renderOtlpHeaders(headers) {
+    if (!headers) {
+        return '';
+    }
+    const keys = Object.keys(headers).sort();
+    return keys.map((k) => `${k}=${headers[k]}`).join(',');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate.js","sourceRoot":"","sources":["../src/fargate.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, Lazy, Stack, Token } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport { Construct } from 'constructs';\nimport { EXPORTER_NONE, resolvedSignals } from './collector-config';\nimport {\n  FARGATE_AGENTS_DIR,\n  FARGATE_AGENTS_IMAGE,\n  FARGATE_MAX_CONTAINERS,\n  FARGATE_SIDECAR_CONTAINER_NAME,\n  FARGATE_VOLUME_NAME,\n} from './generated/fargate';\nimport { ODIGOS_VERSION } from './generated/layers';\nimport {\n  FargateRecipe,\n  evaluateAppendPattern,\n  exportTargetFor,\n  fargateResourceAttributes,\n  languageKeyOf,\n  portProtocolMismatch,\n  recipeFor,\n  sidecarCommand,\n} from './fargate-recipes';\nimport { OdigosDestination, OdigosFargateLanguage } from './types';\n\n/** Service name reported on every span, metric and log record. */\nconst ENV_SERVICE_NAME = 'OTEL_SERVICE_NAME';\n/** Resource attributes added to every record: cloud provider, platform and region. */\nconst ENV_RESOURCE_ATTRIBUTES = 'OTEL_RESOURCE_ATTRIBUTES';\n/** Where the agent exports OTLP. On Fargate this is the real destination, not a localhost collector. */\nconst ENV_OTLP_ENDPOINT = 'OTEL_EXPORTER_OTLP_ENDPOINT';\n/** The transport for the endpoint above. The two are one decision. */\nconst ENV_OTLP_PROTOCOL = 'OTEL_EXPORTER_OTLP_PROTOCOL';\n/** Per-request headers, in practice the destination's credential. */\nconst ENV_OTLP_HEADERS = 'OTEL_EXPORTER_OTLP_HEADERS';\n/** Raises agent verbosity into the container's log stream. */\nconst ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL';\n/** The three per-signal exporter switches. */\nconst ENV_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER';\nconst ENV_METRICS_EXPORTER = 'OTEL_METRICS_EXPORTER';\nconst ENV_LOGS_EXPORTER = 'OTEL_LOGS_EXPORTER';\n/** Value a supported signal's exporter is set to. */\nconst EXPORTER_OTLP = 'otlp';\n\n/**\n * Schema version of the marker payload. Must match `api.IaCMarkerVersion` in the connector — it is what\n * tells the connector how to read the rest of the object, so a bumped version there is a change here.\n */\nconst MARKER_VERSION = 1;\n\n/**\n * `ODIGOS_IAC` — the marker recording that this container was instrumented by Odigos IaC tooling, by\n * which package version, and for which language.\n *\n * It is PER CONTAINER, and it is the only thing that makes Odigos report a container as instrumented\n * rather than \"awaiting your deployment\" — however completely the rest of the wiring is applied. A task\n * definition holding two applications needs it on both.\n *\n * The `lang` field is the load-bearing one here (where Lambda's is `layer`). The connector's conformance\n * check reconstructs the container's expected activation environment from the recorded language, so it is\n * what makes \"is this container correctly instrumented\" answerable at all — and it is cross-checked\n * against the language the connector resolves independently, which is how an image swapped underneath the\n * instrumentation is caught.\n *\n * It is NOT `ODIGOS_MANAGED`, and this construct never writes that one. That is the connector's own\n * record of a mutation IT performed, whose payload is the snapshot it restores from on rollback. A CDK\n * stack has no such snapshot to offer, because nothing was mutated — the container definition below IS\n * the container's definition. Writing it by hand would claim a rollback nobody recorded, and the\n * connector would then judge the container against values that do not exist.\n */\nconst ENV_IAC_MARKER = 'ODIGOS_IAC';\n\n/** Construct id of the staging container inside the task definition's scope. */\nconst SIDECAR_CONSTRUCT_ID = 'OdigosAgent';\n\n/**\n * Memory reservation for the staging container on an EC2-only task definition, where ECS requires every\n * container to declare its own if the task does not. Never set on a Fargate task definition — see the\n * call site.\n */\nconst SIDECAR_EC2_MEMORY_MIB = 64;\n\n/**\n * Options shared by every container this construct instruments.\n */\nexport interface OdigosFargateInstrumentationOptions {\n  /**\n   * Where the instrumented containers export telemetry to.\n   *\n   * Unlike Lambda, BOTH transports may be set and often should be: a Fargate task has no collector of its\n   * own, so each language's agent exports to this destination itself and takes the transport it prefers.\n   * php and ruby can only speak OTLP/HTTP at all.\n   */\n  readonly destination: OdigosDestination;\n\n  /**\n   * The agents bundle the staging container copies the language agents out of.\n   *\n   * Defaults to the multi-arch image this package's release published, at that release's immutable tag.\n   * Override it to mirror the image into a registry your tasks can reach — the image is pulled by YOUR\n   * task's execution role at every task start, so a task in a private subnet with no NAT and no\n   * interface endpoint cannot pull the default.\n   *\n   * A mirror must be the same bundle: the activation environment set below names exact paths inside it.\n   *\n   * @default - the released `registry.odigos.io/odigos-fargate-agents` image for this package version\n   */\n  readonly agentsImage?: string;\n\n  /**\n   * Raise agent verbosity (`OTEL_LOG_LEVEL=debug`) on every instrumented container.\n   *\n   * Useful while wiring up a destination, expensive to leave on — and it is compared: the connector\n   * expects the variable ABSENT unless debug telemetry is enabled for the connector too, so leaving this\n   * on can itself be reported as drift.\n   *\n   * @default false\n   */\n  readonly debug?: boolean;\n}\n\n/**\n * One container to instrument.\n */\nexport interface OdigosFargateTarget {\n  /**\n   * The application container. Its task definition is taken from it, so the staging container, the shared\n   * volume and the startup dependency are added to the right one automatically.\n   */\n  readonly container: ecs.ContainerDefinition;\n\n  /**\n   * The language whose agent to stage and activate.\n   *\n   * Stated rather than detected — a container declares an image, not a runtime, and resolving a language\n   * from an image means pulling it.\n   */\n  readonly language: OdigosFargateLanguage;\n\n  /**\n   * `OTEL_SERVICE_NAME` for this container.\n   *\n   * THIS MUST MATCH THE WORKLOAD'S NAME IN ODIGOS, which for a Fargate workload is the ECS SERVICE name —\n   * not the task definition family and not the container name. A different value is reported as\n   * instrumentation drift rather than treated as a naming preference.\n   *\n   * Pass `service` instead to read it off the service, or set this when the service is defined elsewhere\n   * (a different stack, Terraform, the console). One of the two is required.\n   *\n   * @default - taken from `service`\n   */\n  readonly serviceName?: string;\n\n  /**\n   * The ECS service that runs this task definition, used only to read its name.\n   *\n   * Its physical name has to be one your stack SET, not one CloudFormation generates: a generated name is\n   * a `Ref` to the service, and a service's own task definition referencing it is a dependency cycle\n   * CloudFormation rejects at deploy time. A generated name throws at synth pointing at `serviceName`.\n   *\n   * @default - `serviceName` must be given instead\n   */\n  readonly service?: ecs.BaseService;\n\n  /**\n   * The application's runtime version as `major.minor` — for example `\"8.3\"`.\n   *\n   * Required for php and ruby, whose agents are laid down per runtime version in the bundle, and the\n   * version selects the path their activation variables point at. Ignored by every other language.\n   *\n   * @default - none; required for php and ruby\n   */\n  readonly runtimeVersion?: string;\n\n  /**\n   * The value this container already needs in its loader variable (`JAVA_TOOL_OPTIONS`, `NODE_OPTIONS` or\n   * `PYTHONPATH`), which the Odigos fragment is joined to rather than replacing.\n   *\n   * Only needed as an OVERRIDE. The construct reads the value the container was created with and appends\n   * to it, so a container that sets its own `JAVA_TOOL_OPTIONS` in `addContainer` keeps it. Pass this when\n   * the value is not visible at synth — set by an `environmentFiles` entry, injected by the image's own\n   * `ENV`, or supplied through `secrets`.\n   *\n   * @default - read from the container's own environment\n   */\n  readonly existingLoaderValue?: string;\n}\n\n/**\n * Props for {@link OdigosFargateInstrumentation}.\n */\nexport interface OdigosFargateInstrumentationProps extends OdigosFargateInstrumentationOptions {\n  /**\n   * Containers to instrument on construction. More can be added with `instrument()`.\n   *\n   * @default - none\n   */\n  readonly targets?: OdigosFargateTarget[];\n}\n\n/** Per-task-definition state: the staging container, and what it has been asked to stage. */\ninterface TaskDefinitionState {\n  readonly sidecar: ecs.ContainerDefinition;\n  readonly agentDirs: Set<string>;\n}\n\n/**\n * Instruments ECS Fargate containers with the Odigos OpenTelemetry agents.\n *\n * ```ts\n * const odigos = new OdigosFargateInstrumentation(this, 'Odigos', {\n *   destination: { httpEndpoint: 'https://otlp.example.com:4318' },\n * });\n * odigos.instrument({\n *   container: apiContainer,\n *   language: OdigosFargateLanguage.JAVA,\n *   service: apiService,\n * });\n * ```\n *\n * ## What it does to the task definition\n *\n * Four moves, which are one mechanism and only work together — the ECS adaptation of the Odikos\n * init-container mount method:\n *\n *  1. a bare-name task volume (`odigos-agent`), which on Fargate is an ephemeral-storage bind mount\n *     scoped to the task;\n *  2. a NON-ESSENTIAL `odigos-agent` container that copies the language agents out of the agents bundle\n *     into that volume and exits 0;\n *  3. the volume mounted read-only at `/var/odigos` in each instrumented container, which depends on the\n *     staging container with condition `SUCCESS` — only valid against a non-essential container, which is\n *     why (2) is non-essential;\n *  4. the language's activation environment, the OTLP export environment, and the `ODIGOS_IAC` marker on\n *     each instrumented container.\n *\n * There is ONE staging container per task definition however many languages the task holds; its command\n * is the union of every instrumented container's agent directories, and it is built lazily so containers\n * instrumented later are included.\n *\n * ## Where the telemetry goes\n *\n * Straight to your destination, from inside the application process. This is the substantive difference\n * from Lambda: there is no collector in the task to hand a batch to, so a slow or unreachable destination\n * is felt by the application's own exporter rather than absorbed after a response has been returned.\n *\n * ## What it deliberately does NOT do\n *\n * There is no aspect that sweeps a scope, as there is for Lambda. An aspect there works because a\n * function DECLARES its runtime; a container declares an image, and a language guessed from an image name\n * would silently mis-instrument the ones it got wrong — staging a Java agent into a Python container\n * leaves it uninstrumented, and a `JAVA_TOOL_OPTIONS` on a JVM-less image is simply ignored, so nothing\n * fails loudly enough to notice.\n *\n * ## Do not also instrument these services with the connector\n *\n * The connector instruments live services by registering a new task-definition revision and updating the\n * service to it, reconciling to its own desired state on every pass. A service instrumented here and also\n * enabled as a connector source ends up owned by both: each `cdk deploy` reasserts the stack's\n * definition, each reconcile reasserts the connector's, and every round trip registers a revision and\n * rolls the service. Choose one per service.\n */\nexport class OdigosFargateInstrumentation extends Construct {\n  private readonly options: OdigosFargateInstrumentationOptions;\n  private readonly agentsImage: string;\n  private readonly taskDefinitions = new Map<string, TaskDefinitionState>();\n  private readonly instrumented = new Set<string>();\n\n  constructor(scope: Construct, id: string, props: OdigosFargateInstrumentationProps) {\n    super(scope, id);\n    this.options = props;\n\n    const image = props.agentsImage ?? FARGATE_AGENTS_IMAGE;\n    if (!image) {\n      // Empty only in a checkout built before the first release. Failing here is the point: the\n      // alternative is a task definition whose staging container names a tag that does not exist, which\n      // surfaces as a task that will not start, at deploy time, in a place that says nothing about why.\n      throw new Error(\n        'Odigos: this build of @odigos/aws-cdk has no Fargate agents image baked in — it was built ' +\n          'before the first release. Use a released version of the package, or pass `agentsImage` ' +\n          'explicitly.',\n      );\n    }\n    this.agentsImage = image;\n\n    for (const target of props.targets ?? []) {\n      this.instrument(target);\n    }\n  }\n\n  /**\n   * Instruments one container. Idempotent — instrumenting the same container twice is a no-op rather than\n   * a doubled loader value.\n   */\n  public instrument(target: OdigosFargateTarget): void {\n    const container = target.container;\n    const key = container.node.path;\n    if (this.instrumented.has(key)) {\n      return;\n    }\n\n    const taskDefinition = container.taskDefinition;\n    const recipe = recipeFor(target.language, target.runtimeVersion);\n    const serviceName = this.resolveServiceName(target);\n\n    this.checkTaskDefinition(taskDefinition, container);\n    this.instrumented.add(key);\n\n    const state = this.taskDefinitionState(taskDefinition);\n    for (const dir of recipe.agentDirs) {\n      state.agentDirs.add(dir);\n    }\n\n    // Read-only: the agents are only read here, and the staging container owns the writes.\n    container.addMountPoints({\n      sourceVolume: FARGATE_VOLUME_NAME,\n      containerPath: FARGATE_AGENTS_DIR,\n      readOnly: true,\n    });\n    // SUCCESS, not START: the agent files have to be on disk before the application process begins, and\n    // the staging container exits as soon as they are.\n    container.addContainerDependencies({\n      container: state.sidecar,\n      condition: ecs.ContainerDependencyCondition.SUCCESS,\n    });\n\n    for (const [name, value] of Object.entries(this.environmentFor(target, recipe, serviceName))) {\n      container.addEnvironment(name, value);\n    }\n  }\n\n  /** Instruments every target in the list. */\n  public instrumentAll(targets: OdigosFargateTarget[]): void {\n    for (const target of targets) {\n      this.instrument(target);\n    }\n  }\n\n  /**\n   * The task definition's staging container and volume, created once and shared by every container in it.\n   *\n   * The command is a lazy list rather than a literal because the union it renders is not known until\n   * synthesis: a task definition holding a Java and a Python application is instrumented by two\n   * `instrument()` calls, and the single staging container has to stage both. The connector compares this\n   * command against exactly that union, so a stale one is reported as drift on the whole task definition\n   * and leaves one of the containers with no agent on disk.\n   */\n  private taskDefinitionState(taskDefinition: ecs.TaskDefinition): TaskDefinitionState {\n    const key = taskDefinition.node.path;\n    const existing = this.taskDefinitions.get(key);\n    if (existing) {\n      return existing;\n    }\n\n    // A bare-name volume — no host, docker or EFS configuration — is a Fargate ephemeral-storage bind\n    // mount scoped to the task, which is exactly the shared staging area needed and the only kind Fargate\n    // offers (there is no tmpfs).\n    taskDefinition.addVolume({ name: FARGATE_VOLUME_NAME });\n\n    const agentDirs = new Set<string>();\n    const sidecar = taskDefinition.addContainer(SIDECAR_CONSTRUCT_ID, {\n      containerName: FARGATE_SIDECAR_CONTAINER_NAME,\n      image: ecs.ContainerImage.fromRegistry(this.agentsImage),\n      // Non-essential is not a preference: it is what makes the SUCCESS dependency above legal, and it is\n      // what stops a copier that has finished its job from failing the whole task by exiting.\n      essential: false,\n      command: Lazy.list({ produce: () => sidecarCommand([...agentDirs]) }),\n      // Fargate allocates memory at the task level, so the staging container declares none there — which\n      // keeps the rendered container byte-identical to what the connector writes. An EC2-only task\n      // definition without task-level memory requires every container to declare its own, so one is set\n      // for that case alone. A soft reservation, and generous: the container is busybox running `cp`.\n      memoryReservationMiB: taskDefinition.isFargateCompatible ? undefined : SIDECAR_EC2_MEMORY_MIB,\n    });\n    // Writable here — this is the container that puts the files there. `readOnly` is required by CDK's\n    // MountPoint struct where the connector simply omits it; false is what an omitted value means, and the\n    // connector's task-level check compares the staging container's image, essentiality and command, not\n    // its mounts, so spelling out the default is not drift.\n    sidecar.addMountPoints({\n      sourceVolume: FARGATE_VOLUME_NAME,\n      containerPath: FARGATE_AGENTS_DIR,\n      readOnly: false,\n    });\n\n    // Registered here, with the staging container, so it is added once per task definition however many\n    // containers are instrumented in it — and counted at synth, so containers added after this call are\n    // included. AWS rejects a RegisterTaskDefinition over the limit, which would otherwise surface as a\n    // deploy failure about a container count with nothing to say about which container is the extra one.\n    taskDefinition.node.addValidation({\n      validate: () => {\n        const containers = taskDefinition.node.children.filter((c) => c instanceof ecs.ContainerDefinition);\n        return containers.length > FARGATE_MAX_CONTAINERS\n          ? [\n            `Odigos: task definition ${taskDefinition.node.id} would have ${containers.length} ` +\n                `containers, over the AWS maximum of ${FARGATE_MAX_CONTAINERS}. One of them is the ` +\n                'odigos-agent staging container this instrumentation adds.',\n          ]\n          : [];\n      },\n    });\n\n    const state: TaskDefinitionState = { sidecar, agentDirs };\n    this.taskDefinitions.set(key, state);\n    return state;\n  }\n\n  /**\n   * `OTEL_SERVICE_NAME` for a target, and the one value a caller cannot be allowed to leave to a default.\n   *\n   * The connector compares it against the workload's name in Odigos, which is the ECS SERVICE name, so\n   * guessing — the task definition family, the container name, the construct id — would produce a stack\n   * that deploys cleanly and then reports as drifted on a component nothing in the stack makes visible.\n   *\n   * Read from the L1, not from `service.serviceName`: the L2 property is a token that resolves to a `Ref`\n   * to the service even when the stack set the name explicitly, and a `Ref` here is worse than useless —\n   * the task definition would reference the service that references it, which CloudFormation rejects as a\n   * dependency cycle at deploy time.\n   */\n  private resolveServiceName(target: OdigosFargateTarget): string {\n    if (target.serviceName) {\n      return target.serviceName;\n    }\n    if (!target.service) {\n      throw new Error(\n        `Odigos: instrumenting container \"${target.container.containerName}\" needs a service name. ` +\n          'OTEL_SERVICE_NAME must equal the workload\\'s name in Odigos, which for a Fargate workload is ' +\n          'the ECS SERVICE name — not the task definition family. Pass `service` to read it off the ' +\n          'service, or `serviceName` when the service lives outside this stack.',\n      );\n    }\n    const cfn = target.service.node.defaultChild as ecs.CfnService | undefined;\n    const resolved = cfn === undefined ? undefined : Stack.of(target.service).resolve(cfn.serviceName);\n    if (typeof resolved === 'string' && resolved !== '' && !Token.isUnresolved(resolved)) {\n      return resolved;\n    }\n    throw new Error(\n      `Odigos: the service for container \"${target.container.containerName}\" has no explicit physical ` +\n        'name, so CloudFormation generates one — and a generated name is a `Ref` to the service, which ' +\n        'cannot go into the task definition that service runs (CloudFormation rejects the cycle). Set ' +\n        '`serviceName` on the ECS service, or pass `serviceName` here to state the name Odigos knows ' +\n        'the workload by.',\n    );\n  }\n\n  /**\n   * Checks the task definition can carry the staged-agent method at all, and warns about the things that\n   * are legal but almost certainly a mistake.\n   */\n  private checkTaskDefinition(taskDefinition: ecs.TaskDefinition, container: ecs.ContainerDefinition): void {\n    if (!taskDefinition.isFargateCompatible) {\n      // Not fatal — the mechanism is a volume and a copier, which work on the EC2 launch type too. But\n      // the connector discovers and judges `aws.fargate-task` workloads, so an EC2-only task definition\n      // is instrumented here and invisible there.\n      Annotations.of(container).addWarningV2(\n        '@odigos/aws-cdk:notFargateCompatible',\n        `Odigos: task definition ${taskDefinition.node.id} is not Fargate-compatible. The staging ` +\n          'container and shared volume will still work on the EC2 launch type, but Odigos discovers ' +\n          'these as `aws.fargate-task` workloads and will not report on an EC2-only task.',\n      );\n    }\n\n    const cfn = taskDefinition.node.defaultChild as ecs.CfnTaskDefinition | undefined;\n    const platform = cfn?.runtimePlatform as ecs.CfnTaskDefinition.RuntimePlatformProperty | undefined;\n    const osFamily = platform?.operatingSystemFamily;\n    if (typeof osFamily === 'string' && !Token.isUnresolved(osFamily) && !osFamily.startsWith('LINUX')) {\n      throw new Error(\n        `Odigos: task definition ${taskDefinition.node.id} declares operatingSystemFamily ` +\n          `\"${osFamily}\". The Odigos Fargate agents bundle is Linux-only and glibc-based, so a Windows ` +\n          'task definition cannot be instrumented at all.',\n      );\n    }\n\n  }\n\n  /**\n   * The environment applied to one instrumented container.\n   *\n   * Mirrors `instrumentContainer` in the connector, including the ORDER of decisions: the agent's own\n   * activation variables first, then identity, then export, then the marker. Every variable here has a\n   * counterpart in the connector's `containerDiff`, which is what a customer's conformance report is\n   * built from — so one that is absent, or spelled differently, is reported as a named broken component\n   * rather than passing quietly.\n   */\n  private environmentFor(\n    target: OdigosFargateTarget,\n    recipe: FargateRecipe,\n    serviceName: string,\n  ): { [key: string]: string } {\n    const { destination, debug } = this.options;\n    const container = target.container;\n    const env: { [key: string]: string } = {};\n\n    for (const [k, v] of Object.entries(recipe.staticEnv)) {\n      // These are set outright, not merged — PHP_INI_SCAN_DIR and RUBYOPT are compared exactly, so there\n      // is no room to fold a container's own value in. Silently discarding one is the failure worth\n      // naming: RUBYOPT commonly carries flags an application needs to boot.\n      const existing = containerEnvValue(container, k);\n      if (existing !== undefined && existing !== v) {\n        Annotations.of(container).addWarningV2(\n          '@odigos/aws-cdk:staticEnvOverwritten',\n          `Odigos: container \"${container.containerName}\" already sets ${k}=\"${existing}\", which the ` +\n            `${recipe.language} agent's activation replaces with \"${v}\". Odigos compares this variable ` +\n            'exactly, so it cannot merge the two — fold what your application needs into the value ' +\n            'Odigos sets, or leave this container uninstrumented.',\n        );\n      }\n      env[k] = v;\n    }\n\n    for (const append of recipe.appendEnv) {\n      // Rebuilt from the container's ORIGINAL value so ours is joined rather than assigned over it — and\n      // so that a re-synth never accumulates our fragment twice. The separator comes from the pattern,\n      // not from an assumption: a space for the *_OPTIONS variables, a colon for PYTHONPATH.\n      const existing = target.existingLoaderValue ?? containerEnvValue(container, append.name) ?? '';\n      env[append.name] = evaluateAppendPattern(append.pattern, existing);\n    }\n\n    env[ENV_SERVICE_NAME] = serviceName;\n    env[ENV_RESOURCE_ATTRIBUTES] = fargateResourceAttributes(Stack.of(container).region);\n\n    const exportTarget = exportTargetFor(recipe, destination);\n    env[ENV_OTLP_ENDPOINT] = exportTarget.endpoint;\n    env[ENV_OTLP_PROTOCOL] = exportTarget.protocol;\n    const mismatch = portProtocolMismatch(exportTarget.endpoint, exportTarget.protocol);\n    if (mismatch) {\n      Annotations.of(container).addWarningV2('@odigos/aws-cdk:portProtocolMismatch', `Odigos: ${mismatch}`);\n    }\n\n    // All three are written explicitly, unlike Lambda, where an enabled signal's variable is left unset\n    // because `otlp` is already the SDK default. The connector's Fargate check compares all three by\n    // value, so an omitted one reads as drift on the export component.\n    const enabled = resolvedSignals(destination);\n    if (!enabled.traces && !enabled.metrics && !enabled.logs) {\n      throw new Error(\n        'Odigos destination accepts no telemetry signals, so the agent would be loaded and produce ' +\n          'nothing. Note that metrics and logs are OFF by default — with `traces: false` the destination ' +\n          'has nothing left unless you also pass `metrics: true` or `logs: true`.',\n      );\n    }\n    env[ENV_TRACES_EXPORTER] = enabled.traces ? EXPORTER_OTLP : EXPORTER_NONE;\n    env[ENV_METRICS_EXPORTER] = enabled.metrics ? EXPORTER_OTLP : EXPORTER_NONE;\n    env[ENV_LOGS_EXPORTER] = enabled.logs ? EXPORTER_OTLP : EXPORTER_NONE;\n\n    const headers = renderOtlpHeaders(destination.headers);\n    if (headers) {\n      env[ENV_OTLP_HEADERS] = headers;\n    }\n\n    if (debug) {\n      env[ENV_OTEL_LOG_LEVEL] = 'debug';\n    }\n\n    env[ENV_IAC_MARKER] = JSON.stringify({\n      v: MARKER_VERSION,\n      source: 'cdk',\n      version: ODIGOS_VERSION || 'unreleased',\n      lang: languageKeyOf(target.language),\n    });\n\n    return env;\n  }\n}\n\n/**\n * The value the container was created with for an environment variable, or undefined.\n *\n * `ContainerDefinition` keeps its environment private and offers `addEnvironment` but no reader, so this\n * reaches for the field. That is a contained hack with a specific alternative: without it, appending to a\n * loader variable would mean ASSIGNING over it, and a container whose `NODE_OPTIONS` carries a flag its\n * application needs to boot would stop booting the moment it was instrumented. `existingLoaderValue` on\n * the target is the documented escape hatch if this ever stops working; a shape that is not a plain object\n * degrades to \"nothing there\", which is the same answer as an uninstrumented container.\n */\nfunction containerEnvValue(container: ecs.ContainerDefinition, name: string): string | undefined {\n  const env = (container as unknown as { environment?: { [key: string]: string } }).environment;\n  if (!env || typeof env !== 'object') {\n    return undefined;\n  }\n  const value = env[name];\n  return typeof value === 'string' ? value : undefined;\n}\n\n/**\n * Renders `OTEL_EXPORTER_OTLP_HEADERS` — a comma-separated `key=value` list, keys sorted so the rendered\n * value is byte-stable across synths and an unchanged destination never looks like a change.\n */\nfunction renderOtlpHeaders(headers?: { [key: string]: string }): string {\n  if (!headers) {\n    return '';\n  }\n  const keys = Object.keys(headers).sort();\n  return keys.map((k) => `${k}=${headers[k]}`).join(',');\n}\n"]}

package/lib/generated/fargate.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Produced by cdk/scripts/generate.ts from artifacts.json and manifest/layers.json.
+ * Run `npm run generate` (or `npm run build`) to refresh it.
+ *
+ * Odigos artifact version: v0.0.14
+ */
+/**
+ * The multi-arch agents bundle the staging container copies from, at the tag this package's release
+ * published. Empty before the first release.
+ */
+export declare const FARGATE_AGENTS_IMAGE = "registry.odigos.io/odigos-fargate-agents:v0.0.14";
+/** Shared task-volume mount path the language agents are staged into, in every container. */
+export declare const FARGATE_AGENTS_DIR = "/var/odigos";
+/** Where the agents bundle holds the agent files; the staging container copies from here to there. */
+export declare const FARGATE_IMAGE_AGENTS_DIR = "/instrumentations";
+/** Container name of the run-to-completion staging container. Matched exactly by the connector. */
+export declare const FARGATE_SIDECAR_CONTAINER_NAME = "odigos-agent";
+/** Name of the shared task volume the agents are staged into. */
+export declare const FARGATE_VOLUME_NAME = "odigos-agent";
+/** AWS's cap on containers per task definition — the staging container needs one of them. */
+export declare const FARGATE_MAX_CONTAINERS = 10;
+/** Odigos distros module version the recipes below were mirrored from. */
+export declare const FARGATE_DISTROS_VERSION = "v1.33.0-pre4";
+/** An append-style loader variable, carrying the distro's own ReplacePattern. */
+export interface GeneratedAppendEnvVar {
+    readonly name: string;
+    readonly pattern: string;
+}
+/** How one language's agent is staged and activated. Mirrored from the OSS Odigos community distros. */
+export interface GeneratedFargateRecipe {
+    readonly agentDirs: string[];
+    readonly staticEnv: {
+        [key: string]: string;
+    };
+    readonly appendEnv: GeneratedAppendEnvVar[];
+    readonly otlpProtocol: string;
+    readonly protocolFixed: boolean;
+    readonly requiresRuntimeVersion: boolean;
+}
+export declare const FARGATE_LANGUAGES: {
+    [language: string]: GeneratedFargateRecipe;
+};