@odigos/aws-cdk 0.0.13 → 0.0.14

package/README.md

@@ -1,12 +1,24 @@
-# Odigos CDK constructs for AWS Lambda
+# Odigos CDK constructs for AWS
 
-Instrument AWS Lambda functions with the Odigos OpenTelemetry layer, from your own CDK app.
+Instrument AWS Lambda functions and ECS Fargate services with OpenTelemetry, from your own CDK app.
 
 ```bash
 npm install @odigos/aws-cdk        # TypeScript / JavaScript
 pip install odigos-aws-cdk         # Python
 ```
 
+| | Lambda | ECS Fargate |
+|---|---|---|
+| Construct | `OdigosLambdaInstrumentation` | `OdigosFargateInstrumentation` |
+| Mechanism | a layer, plus an exec wrapper or loader variable | agents staged into a shared task volume by a run-to-completion container |
+| Languages | python, nodejs, java, ruby | java, python, nodejs, dotnet, php, ruby |
+| Where telemetry goes | a collector in the same Lambda sandbox, which forwards | your destination, from the application process |
+| Language detection | from the function's declared runtime | none — you state the language |
+
+Both write `ODIGOS_IAC` and never the connector's ownership marker: instrumented by Odigos, owned by you.
+
+# AWS Lambda
+
 ```ts
 import { OdigosLambdaInstrumentation } from '@odigos/aws-cdk';
 
@@ -224,18 +236,206 @@ Pick one per function. Discovery-only (manual) mode is the combination that work
 reports, your stack owns the configuration. That is what `ODIGOS_IAC` expresses — instrumented by Odigos,
 owned by you — and it is why these constructs never write the connector's ownership marker.
 
-## API
+# ECS Fargate
+
+```ts
+import { OdigosFargateInstrumentation, OdigosFargateLanguage } from '@odigos/aws-cdk';
+
+const odigos = new OdigosFargateInstrumentation(this, 'Odigos', {
+  destination: { httpEndpoint: 'https://otlp.example.com:4318' },
+});
+
+odigos.instrument({
+  container: apiContainer,          // the ecs.ContainerDefinition to instrument
+  language: OdigosFargateLanguage.JAVA,
+  service: apiService,              // read OTEL_SERVICE_NAME off the ECS service
+});
+```
+
+```python
+from odigos_aws_cdk import OdigosFargateInstrumentation, OdigosFargateLanguage
+
+odigos = OdigosFargateInstrumentation(self, "Odigos",
+    destination={"http_endpoint": "https://otlp.example.com:4318"},
+)
+odigos.instrument(
+    container=api_container,
+    language=OdigosFargateLanguage.JAVA,
+    service=api_service,
+)
+```
+
+## What it does to the task definition
+
+Four moves, which are one mechanism and only work together:
+
+1. a bare-name task volume, `odigos-agent` — on Fargate an ephemeral-storage bind mount scoped to the task
+   (there is no tmpfs);
+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 your container, which `DependsOn` the staging container
+   with condition `SUCCESS` — legal only 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 your
+   container.
+
+Marker presence alone is a false green here. A container can carry a complete, correct activation
+environment while the staging container is gone — the application then starts, finds nothing at
+`/var/odigos`, and exports nothing while reporting as instrumented. That is why all four are one construct.
+
+## Where the telemetry goes
+
+Straight to your destination, from inside the application process. **This is the substantive difference
+from Lambda**, where the SDK hands batches to a collector in the same sandbox and the export happens after
+the response has already been returned. A Fargate task has no such collector, so a slow or unreachable
+destination is felt by the application's own exporter.
+
+## Naming the service
+
+`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 and not the container name. A different value is reported
+as instrumentation drift rather than treated as a naming preference, so there is no default: pass `service`
+to read the name off an `ecs.FargateService`, or `serviceName` when the service is defined elsewhere.
+
+The service's physical name has to be one you set. A name CloudFormation generates is a `Ref` to the
+service, and the task definition that service runs cannot reference it — CloudFormation rejects the cycle
+at deploy time — so a generated name throws at synth pointing you at `serviceName`.
+
+## Languages, and stating them
+
+| | Activated through | Needs `runtimeVersion` |
+|---|---|---|
+| `JAVA` | `JAVA_TOOL_OPTIONS` | no |
+| `PYTHON` | `PYTHONPATH` | no |
+| `NODEJS` | `NODE_OPTIONS` | no |
+| `DOTNET` | `CORECLR_*` / `DOTNET_*` (glibc only) | no |
+| `PHP` | `PHP_INI_SCAN_DIR` | **yes** — major.minor, e.g. `"8.3"` |
+| `RUBY` | `RUBYOPT` | **yes** — major.minor, e.g. `"3.3"` |
+
+There is no aspect and no detection, and unlike Lambda that is not a matter of taste. A function declares
+its runtime; a container declares an image. A language guessed from an image would silently mis-instrument
+whatever it got wrong — a Java agent staged 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.
+
+php and ruby need `runtimeVersion` because their agents are laid down per runtime version in the bundle,
+and the version selects the path their activation variable points at. It must be exactly `major.minor`;
+anything else names a directory that does not exist, and the container starts with no agent loaded.
+
+**Go cannot be instrumented on Fargate at all.** Its only zero-code instrumentation is eBPF, and Fargate
+forbids the privileged containers and host PID an eBPF agent needs. Use the OpenTelemetry Go SDK.
+
+## Loader variables your container already sets
+
+The construct reads the value your container was created with and **appends** to it, joined by the
+separator the language's own pattern specifies — a space for `JAVA_TOOL_OPTIONS` and `NODE_OPTIONS`, a
+colon for `PYTHONPATH`:
+
+```ts
+taskDefinition.addContainer('App', {
+  image,
+  environment: { JAVA_TOOL_OPTIONS: '-Xmx512m' },
+});
+// becomes: -Xmx512m -javaagent:/var/odigos/java/javaagent.jar
+```
+
+Pass `existingLoaderValue` when the value is not visible at synth — set by an `environmentFiles` entry,
+baked into the image's own `ENV`, or supplied through `secrets`.
+
+`PHP_INI_SCAN_DIR` and `RUBYOPT` are the exception: Odigos compares them **exactly**, so they are set
+outright and a value already there is reported as a synth warning rather than merged. Fold what your
+application needs into the value Odigos sets.
+
+## Transport
+
+Each language's agent has a preferred transport, and giving the destination **both** endpoints lets each
+one take it:
+
+```ts
+destination: {
+  endpoint: 'otlp.example.com:4317',                  // OTLP/gRPC, bare host:port
+  httpEndpoint: 'https://otlp.example.com:4318',      // OTLP/HTTP, scheme-qualified
+}
+```
+
+Every agent in the bundle prefers `http/protobuf`. java, python, nodejs and dotnet honour
+`OTEL_EXPORTER_OTLP_PROTOCOL` and fall back to gRPC when that is all the destination offers; **php and
+ruby cannot** — their community SDKs are `http/protobuf`-only, so instrumenting one against a gRPC-only
+destination throws at synth rather than deploying a task that exports nothing.
+
+Endpoint and protocol are one decision, and are compared as one. Pairing an endpoint with the other
+protocol fails at runtime as a connection reset that points nowhere near the cause, so an endpoint on the
+other protocol's standard port (4317 with `http/protobuf`, 4318 with `grpc`) is a synth warning.
+
+Unlike Lambda, `destination.headers` is rendered into `OTEL_EXPORTER_OTLP_HEADERS` on the container. The
+connector does not set or compare that variable when it instruments a Fargate task itself, so it is
+neither reconciled nor reported as drift — it is here because a task with no collector of its own has
+nowhere else to hold a credential. Same exposure caveat as Lambda: `ecs:DescribeTaskDefinition` and the
+console can read it.
+
+## Signals
+
+Same defaults as Lambda — traces on, metrics and logs opt-in — and the same requirement that they match
+what Odigos has configured for the destination. All three `OTEL_*_EXPORTER` variables are written
+explicitly here, unlike Lambda where an enabled signal's variable is left unset, because the connector's
+Fargate check compares all three by value.
+
+## A task definition with more than one application
+
+Six applications in six languages in one task definition is a real shape. Call `instrument()` once per
+container; there is **one** staging container for the whole task definition, and its command is built
+lazily from the union of every instrumented container's agents, in ascending directory order — which is
+exactly what the connector compares it against.
+
+```ts
+odigos.instrumentAll([
+  { container: apiContainer,    language: OdigosFargateLanguage.JAVA,   service: svc },
+  { container: workerContainer, language: OdigosFargateLanguage.PYTHON, service: svc },
+]);
+```
+
+AWS caps a task definition at 10 containers and the staging container needs one of them; a definition
+already at the limit fails at synth rather than on `RegisterTaskDefinition`.
+
+## The agents image
+
+The staging container pulls `registry.odigos.io/odigos-fargate-agents` at this package's release tag — a
+multi-arch manifest list, so amd64 and Graviton tasks both get a matching image. **It is pulled by your
+task's execution role at every task start**, so a task in a private subnet with no NAT and no registry
+endpoint cannot pull it. Mirror it into a registry your tasks can reach and pass `agentsImage`:
+
+```ts
+agentsImage: '111122223333.dkr.ecr.eu-west-1.amazonaws.com/odigos-fargate-agents:v0.0.13',
+```
+
+A mirror has to be the same bundle — the activation environment names exact paths inside it. The bundle is
+Linux-only and glibc-based: a Windows task definition throws at synth, and musl (Alpine) images have no
+.NET native profiler in it.
+
+## Do not also instrument these services with the connector
+
+Same rule as Lambda, with ECS's own cost. The connector instruments a live service by registering a new
+task-definition revision and updating the service to it. A service instrumented here *and* enabled as an
+automatic-mode source is owned by both: each `cdk deploy` reasserts your stack's definition, each
+reconcile reasserts the connector's, and every round trip registers a revision and rolls the service.
+Discovery-only (manual) mode is the combination that works.
+
+# API
 
 | Export | |
 |---|---|
-| `OdigosLambdaInstrumentation` | the construct; `instrument(fn)`, `instrumentAll(fns)` |
+| `OdigosLambdaInstrumentation` | the Lambda construct; `instrument(fn)`, `instrumentAll(fns)` |
 | `OdigosInstrumentationAspect` | applies it to every function in a scope |
-| `OdigosDestination` | where the collector exports; exactly one of `endpoint` / `httpEndpoint` |
+| `OdigosFargateInstrumentation` | the Fargate construct; `instrument(target)`, `instrumentAll(targets)` |
+| `OdigosFargateTarget` | one container to instrument: `container`, `language`, `service` / `serviceName`, `runtimeVersion`, `existingLoaderValue` |
+| `OdigosFargateLanguage` | `JAVA` \| `PYTHON` \| `NODEJS` \| `DOTNET` \| `PHP` \| `RUBY` |
+| `OdigosDestination` | where telemetry goes; exactly one endpoint on Lambda, either or both on Fargate |
 | `OdigosLayerSource` | `ODIGOS_PUBLIC` \| `IN_ACCOUNT` |
 | `OdigosInstrumentationMode` | `HANDLER` \| `WEB_SERVER` |
 | `OdigosJavaHandlerDistro` | the four Java wrappers |
-| `renderCollectorConfig` | the collector config renderer, if you want to inspect what gets set |
+| `renderCollectorConfig` | the Lambda collector config renderer, if you want to inspect what gets set |
+| `sidecarCommand`, `evaluateAppendPattern` | the Fargate staging command and loader-value rendering |
 | `LAYER_ARNS`, `ODIGOS_VERSION` | the baked layer table and the release it came from |
+| `FARGATE_AGENTS_IMAGE`, `FARGATE_DISTROS_VERSION` | the agents image this build stages, and the distros release its recipes mirror |
 
 ## License
 

package/lib/fargate-recipes.d.ts

@@ -0,0 +1,108 @@
+import { OdigosDestination, OdigosFargateLanguage } from './types';
+/** `OTEL_EXPORTER_OTLP_PROTOCOL` values. Endpoint and protocol are always decided together. */
+export declare const OTLP_PROTOCOL_GRPC = "grpc";
+export declare const OTLP_PROTOCOL_HTTP = "http/protobuf";
+/**
+ * An append-style loader variable — `JAVA_TOOL_OPTIONS`, `NODE_OPTIONS`, `PYTHONPATH` — kept as its
+ * pattern rather than a finished value, because the value depends on what the container already carries.
+ */
+export interface FargateAppendEnvVar {
+    /** Variable name. */
+    readonly name: string;
+    /** The distro's ReplacePattern, placeholders unresolved. */
+    readonly pattern: string;
+}
+/**
+ * Resolves an append pattern for a given pre-existing value.
+ *
+ * Port of `distro.EvaluateReplacePattern`, INCLUDING the empty-original case: with nothing to join to,
+ * the placeholder and its adjacent delimiter are stripped, so the result never opens with a stray space
+ * or colon. `PYTHONPATH=":/var/odigos/python"` would put the current working directory on `sys.path`
+ * ahead of the agent, which is a different program than the one intended.
+ */
+export declare function evaluateAppendPattern(pattern: string, originalValue: string): string;
+/**
+ * The delimiter a pattern joins the container's own value to ours with: the character immediately after
+ * the original-value placeholder.
+ *
+ * DERIVED from the pattern rather than declared, because the pattern is the authority — it comes from the
+ * upstream distro, differs by language (a space for `JAVA_TOOL_OPTIONS`/`NODE_OPTIONS`, a colon for
+ * `PYTHONPATH`) and can change on somebody else's release. Assuming one would be silently destructive in
+ * a way nothing here would catch: a space-joined `PYTHONPATH` is one unusable path rather than two, and
+ * the process still starts.
+ */
+export declare function appendSeparator(pattern: string): string;
+/** One language's staging and activation, with every platform-supplied parameter already rendered. */
+export interface FargateRecipe {
+    /** Canonical language key, and the value recorded in the `ODIGOS_IAC` marker's `lang`. */
+    readonly language: string;
+    /** Directories under the agents image the staging container copies into the shared volume. */
+    readonly agentDirs: string[];
+    /** Activation variables set outright. */
+    readonly staticEnv: {
+        [key: string]: string;
+    };
+    /** Activation variables our fragment is appended to. */
+    readonly appendEnv: FargateAppendEnvVar[];
+    /** The transport this agent prefers. */
+    readonly otlpProtocol: string;
+    /** Whether the agent can speak only `otlpProtocol` and cannot be switched to the other transport. */
+    readonly protocolFixed: boolean;
+}
+/** The canonical connector language key for an enum member. The enum's values ARE those keys. */
+export declare function languageKeyOf(language: OdigosFargateLanguage): string;
+/**
+ * The recipe for a language, with the runtime version rendered into the agents' paths where the language
+ * needs it.
+ *
+ * @param runtimeVersion the application's runtime `major.minor`. Required for php and ruby, whose agent
+ * files are laid down per version, and ignored by every other language.
+ */
+export declare function recipeFor(language: OdigosFargateLanguage, runtimeVersion?: string): FargateRecipe;
+/**
+ * The staging container's command: create the shared directory, then copy each language's agent
+ * directory out of the image into it, then exit 0.
+ *
+ * ORDER AND SPELLING ARE THE CONTRACT. There is ONE staging container per task definition however many
+ * languages it holds, and the connector compares its command against the union of every instrumented
+ * container's agent directories in ascending order. A command that differs by a space is reported as
+ * drift on the whole task definition, so this is sorted and rendered exactly as `sidecarCommand` in the
+ * connector does it.
+ */
+export declare function sidecarCommand(agentDirs: string[]): string[];
+/**
+ * The resource attributes every span, metric and log from an instrumented task carries. `service.name` is
+ * set separately, through `OTEL_SERVICE_NAME`.
+ *
+ * The region may be an unresolved token on an environment-agnostic stack, which is fine here and unlike
+ * the Lambda layer lookup: this value is an environment variable, so the token resolves to a `Ref` to
+ * `AWS::Region` and CloudFormation fills in the real region at deploy time.
+ */
+export declare function fargateResourceAttributes(region: string): string;
+/** Where an instrumented container exports to, and over which transport. Always decided as a pair. */
+export interface FargateExportTarget {
+    /** `scheme://host:port`. */
+    readonly endpoint: string;
+    /** `grpc` or `http/protobuf`. */
+    readonly protocol: string;
+}
+/**
+ * Resolves the endpoint and protocol for one recipe against one destination.
+ *
+ * Port of `exportTargetFor`. A Fargate task has no node-local collector — unlike Lambda, where the SDK
+ * exports to a collector in the same sandbox — so the agent exports OTLP straight to the destination, and
+ * which transport it can use is a property of the agent as much as of the destination.
+ *
+ * Each agent's PREFERRED transport is taken when the destination offers it. When it does not, an agent
+ * whose community SDK pins the protocol (php, ruby) cannot be switched and throws; every other agent
+ * honours `OTEL_EXPORTER_OTLP_PROTOCOL` and falls back to whichever transport exists.
+ */
+export declare function exportTargetFor(recipe: FargateRecipe, dest: OdigosDestination): FargateExportTarget;
+/**
+ * A warning when an endpoint's port is the well-known port of the OTHER OTLP protocol, or "" when the
+ * pairing looks right — including a non-standard port, which cannot be judged.
+ *
+ * Worth a synth-time warning because the runtime symptom is a connection reset mid-export, which points
+ * nowhere near the cause: an HTTP request against an HTTP/2 gRPC listener, or the reverse.
+ */
+export declare function portProtocolMismatch(endpoint: string, protocol: string): string;

package/lib/fargate-recipes.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTLP_PROTOCOL_HTTP = exports.OTLP_PROTOCOL_GRPC = void 0;
+exports.evaluateAppendPattern = evaluateAppendPattern;
+exports.appendSeparator = appendSeparator;
+exports.languageKeyOf = languageKeyOf;
+exports.recipeFor = recipeFor;
+exports.sidecarCommand = sidecarCommand;
+exports.fargateResourceAttributes = fargateResourceAttributes;
+exports.exportTargetFor = exportTargetFor;
+exports.portProtocolMismatch = portProtocolMismatch;
+const fargate_1 = require("./generated/fargate");
+/**
+ * How a language's agent is staged into an ECS Fargate task and activated in a container.
+ *
+ * A PORT of `recipeFor` / `applyInstrumentation` in the connector's ECS instrumentor
+ * (connectors/providers/aws/pkg/workload/instrumentor/ecs_recipes.go, ecs_inject.go). The data lives in
+ * ../../artifacts.json and reaches here through the generated module; the decisions live here.
+ *
+ * Equivalence with the connector is not cosmetic. Its conformance observer rebuilds each container's
+ * desired activation environment and compares it against what the container carries, component by
+ * component, so anything rendered differently here is reported to the customer as instrumentation drift
+ * on a stack that is in fact deployed exactly as they wrote it.
+ */
+/** The distro placeholder for the container's own pre-Odigos value of an append-style loader variable. */
+const ORIGINAL_ENV_VALUE_PLACEHOLDER = '{{ORIGINAL_ENV_VALUE}}';
+/** The distro placeholder for the shared volume's mount path. */
+const AGENTS_DIR_PLACEHOLDER = '{{ODIGOS_AGENTS_DIR}}';
+/**
+ * The distro parameter for the application's runtime `major.minor`, as a Go text/template action —
+ * verbatim from the distro yaml so ../../artifacts.json can be diffed against it by eye. Only php and
+ * ruby carry it: their agents are laid down per runtime version.
+ */
+const RUNTIME_VERSION_PLACEHOLDER = '{{.RUNTIME_VERSION_MAJOR_MINOR}}';
+/** `OTEL_EXPORTER_OTLP_PROTOCOL` values. Endpoint and protocol are always decided together. */
+exports.OTLP_PROTOCOL_GRPC = 'grpc';
+exports.OTLP_PROTOCOL_HTTP = 'http/protobuf';
+/** Standard OTLP receiver ports, used only to warn about an endpoint paired with the other protocol. */
+const OTLP_DEFAULT_GRPC_PORT = '4317';
+const OTLP_DEFAULT_HTTP_PORT = '4318';
+/**
+ * Resolves an append pattern for a given pre-existing value.
+ *
+ * Port of `distro.EvaluateReplacePattern`, INCLUDING the empty-original case: with nothing to join to,
+ * the placeholder and its adjacent delimiter are stripped, so the result never opens with a stray space
+ * or colon. `PYTHONPATH=":/var/odigos/python"` would put the current working directory on `sys.path`
+ * ahead of the agent, which is a different program than the one intended.
+ */
+function evaluateAppendPattern(pattern, originalValue) {
+    const withDir = pattern.split(AGENTS_DIR_PLACEHOLDER).join(fargate_1.FARGATE_AGENTS_DIR);
+    if (originalValue.trim() === '') {
+        return withDir.split(ORIGINAL_ENV_VALUE_PLACEHOLDER).join('').replace(/^[ :]+/, '');
+    }
+    return withDir.split(ORIGINAL_ENV_VALUE_PLACEHOLDER).join(originalValue);
+}
+/**
+ * The delimiter a pattern joins the container's own value to ours with: the character immediately after
+ * the original-value placeholder.
+ *
+ * DERIVED from the pattern rather than declared, because the pattern is the authority — it comes from the
+ * upstream distro, differs by language (a space for `JAVA_TOOL_OPTIONS`/`NODE_OPTIONS`, a colon for
+ * `PYTHONPATH`) and can change on somebody else's release. Assuming one would be silently destructive in
+ * a way nothing here would catch: a space-joined `PYTHONPATH` is one unusable path rather than two, and
+ * the process still starts.
+ */
+function appendSeparator(pattern) {
+    const i = pattern.indexOf(ORIGINAL_ENV_VALUE_PLACEHOLDER);
+    if (i < 0) {
+        return '';
+    }
+    const rest = pattern.slice(i + ORIGINAL_ENV_VALUE_PLACEHOLDER.length);
+    return rest === '' ? '' : rest.charAt(0);
+}
+/** The canonical connector language key for an enum member. The enum's values ARE those keys. */
+function languageKeyOf(language) {
+    return language;
+}
+/**
+ * The recipe for a language, with the runtime version rendered into the agents' paths where the language
+ * needs it.
+ *
+ * @param runtimeVersion the application's runtime `major.minor`. Required for php and ruby, whose agent
+ * files are laid down per version, and ignored by every other language.
+ */
+function recipeFor(language, runtimeVersion) {
+    const key = languageKeyOf(language);
+    const spec = fargate_1.FARGATE_LANGUAGES[key];
+    if (!spec) {
+        // Unreachable through the enum; reachable if the generated table and the enum ever disagree.
+        throw new Error(`Odigos: no ECS Fargate agent recipe for language "${key}".`);
+    }
+    if (spec.requiresRuntimeVersion && !runtimeVersion) {
+        throw new Error(`Odigos: the ${key} agent's files are laid down per runtime version, so instrumenting a ${key} ` +
+            'container needs `runtimeVersion` set to the application\'s major.minor (for example "8.3"). ' +
+            'The value selects the agent path the activation environment points at, so a wrong or missing ' +
+            'one leaves the container with an agent that is never loaded.');
+    }
+    // Rejected here rather than passed through: a "8.3.4" or "php8.3" would be rendered straight into
+    // PHP_INI_SCAN_DIR / RUBYOPT as a path that does not exist in the bundle, and the container would start
+    // with no agent loaded and no error anywhere near the cause.
+    if (runtimeVersion && !/^\d+\.\d+$/.test(runtimeVersion)) {
+        throw new Error(`Odigos: runtimeVersion "${runtimeVersion}" must be exactly major.minor (for example "8.3") — it ` +
+            'names a directory in the agents bundle, not a full version.');
+    }
+    const staticEnv = {};
+    for (const [k, v] of Object.entries(spec.staticEnv)) {
+        staticEnv[k] = runtimeVersion ? v.split(RUNTIME_VERSION_PLACEHOLDER).join(runtimeVersion) : v;
+    }
+    return {
+        language: key,
+        agentDirs: spec.agentDirs,
+        staticEnv,
+        appendEnv: spec.appendEnv.map((a) => ({ name: a.name, pattern: a.pattern })),
+        otlpProtocol: spec.otlpProtocol,
+        protocolFixed: spec.protocolFixed,
+    };
+}
+/**
+ * The staging container's command: create the shared directory, then copy each language's agent
+ * directory out of the image into it, then exit 0.
+ *
+ * ORDER AND SPELLING ARE THE CONTRACT. There is ONE staging container per task definition however many
+ * languages it holds, and the connector compares its command against the union of every instrumented
+ * container's agent directories in ascending order. A command that differs by a space is reported as
+ * drift on the whole task definition, so this is sorted and rendered exactly as `sidecarCommand` in the
+ * connector does it.
+ */
+function sidecarCommand(agentDirs) {
+    const dirs = [...new Set(agentDirs)].sort();
+    let script = `mkdir -p ${fargate_1.FARGATE_AGENTS_DIR}`;
+    for (const d of dirs) {
+        script += ` && cp -r ${fargate_1.FARGATE_IMAGE_AGENTS_DIR}/${d} ${fargate_1.FARGATE_AGENTS_DIR}/${d}`;
+    }
+    return ['sh', '-c', script];
+}
+/**
+ * The resource attributes every span, metric and log from an instrumented task carries. `service.name` is
+ * set separately, through `OTEL_SERVICE_NAME`.
+ *
+ * The region may be an unresolved token on an environment-agnostic stack, which is fine here and unlike
+ * the Lambda layer lookup: this value is an environment variable, so the token resolves to a `Ref` to
+ * `AWS::Region` and CloudFormation fills in the real region at deploy time.
+ */
+function fargateResourceAttributes(region) {
+    const attrs = 'cloud.provider=aws,cloud.platform=aws_ecs';
+    return region ? `${attrs},cloud.region=${region}` : attrs;
+}
+/**
+ * Turns a destination's OTLP/gRPC target (`host:port`) into the URL the OpenTelemetry SDK env accepts,
+ * taking the scheme from the destination's TLS setting. A value that is already a URL passes through.
+ */
+function grpcEndpointURL(endpoint, insecure) {
+    if (endpoint === '') {
+        return '';
+    }
+    if (endpoint.includes('://')) {
+        return endpoint;
+    }
+    return `${insecure === true ? 'http' : 'https'}://${endpoint}`;
+}
+/**
+ * Resolves the endpoint and protocol for one recipe against one destination.
+ *
+ * Port of `exportTargetFor`. A Fargate task has no node-local collector — unlike Lambda, where the SDK
+ * exports to a collector in the same sandbox — so the agent exports OTLP straight to the destination, and
+ * which transport it can use is a property of the agent as much as of the destination.
+ *
+ * Each agent's PREFERRED transport is taken when the destination offers it. When it does not, an agent
+ * whose community SDK pins the protocol (php, ruby) cannot be switched and throws; every other agent
+ * honours `OTEL_EXPORTER_OTLP_PROTOCOL` and falls back to whichever transport exists.
+ */
+function exportTargetFor(recipe, dest) {
+    const grpcURL = grpcEndpointURL(dest.endpoint ?? '', dest.insecure);
+    const httpURL = dest.httpEndpoint ?? '';
+    if (recipe.otlpProtocol === exports.OTLP_PROTOCOL_HTTP && httpURL !== '') {
+        return { endpoint: httpURL, protocol: exports.OTLP_PROTOCOL_HTTP };
+    }
+    if (recipe.otlpProtocol === exports.OTLP_PROTOCOL_GRPC && grpcURL !== '') {
+        return { endpoint: grpcURL, protocol: exports.OTLP_PROTOCOL_GRPC };
+    }
+    if (recipe.protocolFixed) {
+        throw new Error(`Odigos: the ${recipe.language} agent exports OTLP over ${recipe.otlpProtocol} only — its community ` +
+            'SDK cannot be switched to the other transport — but the destination configures no ' +
+            `${recipe.otlpProtocol === exports.OTLP_PROTOCOL_HTTP ? '`httpEndpoint`' : '`endpoint`'}. ` +
+            'Configure one, or leave this container uninstrumented.');
+    }
+    if (httpURL !== '') {
+        return { endpoint: httpURL, protocol: exports.OTLP_PROTOCOL_HTTP };
+    }
+    if (grpcURL !== '') {
+        return { endpoint: grpcURL, protocol: exports.OTLP_PROTOCOL_GRPC };
+    }
+    throw new Error('Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP), so an ' +
+        'instrumented Fargate task would have nowhere to export. Unlike Lambda, a Fargate task has no ' +
+        'in-sandbox collector to buffer for it — the agent exports to this destination directly.');
+}
+/** The port of a `scheme://host:port[/path]` endpoint, or "" when it names none. */
+function endpointPort(endpoint) {
+    let rest = endpoint;
+    const scheme = rest.indexOf('://');
+    if (scheme >= 0) {
+        rest = rest.slice(scheme + 3);
+    }
+    const pathStart = rest.search(/[/?]/);
+    if (pathStart >= 0) {
+        rest = rest.slice(0, pathStart);
+    }
+    const colon = rest.lastIndexOf(':');
+    return colon < 0 ? '' : rest.slice(colon + 1);
+}
+/**
+ * A warning when an endpoint's port is the well-known port of the OTHER OTLP protocol, or "" when the
+ * pairing looks right — including a non-standard port, which cannot be judged.
+ *
+ * Worth a synth-time warning because the runtime symptom is a connection reset mid-export, which points
+ * nowhere near the cause: an HTTP request against an HTTP/2 gRPC listener, or the reverse.
+ */
+function portProtocolMismatch(endpoint, protocol) {
+    const port = endpointPort(endpoint);
+    if (protocol === exports.OTLP_PROTOCOL_HTTP && port === OTLP_DEFAULT_GRPC_PORT) {
+        return (`endpoint ${endpoint} is on ${OTLP_DEFAULT_GRPC_PORT}, the standard OTLP/gRPC port, but this agent ` +
+            `exports over ${exports.OTLP_PROTOCOL_HTTP}; exports will fail as a connection reset. Point it at the ` +
+            `OTLP/HTTP port (${OTLP_DEFAULT_HTTP_PORT}).`);
+    }
+    if (protocol === exports.OTLP_PROTOCOL_GRPC && port === OTLP_DEFAULT_HTTP_PORT) {
+        return (`endpoint ${endpoint} is on ${OTLP_DEFAULT_HTTP_PORT}, the standard OTLP/HTTP port, but this agent ` +
+            `exports over gRPC; exports will fail. Point it at the OTLP/gRPC port (${OTLP_DEFAULT_GRPC_PORT}).`);
+    }
+    return '';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-recipes.js","sourceRoot":"","sources":["../src/fargate-recipes.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  FARGATE_AGENTS_DIR,\n  FARGATE_IMAGE_AGENTS_DIR,\n  FARGATE_LANGUAGES,\n} from './generated/fargate';\nimport { OdigosDestination, OdigosFargateLanguage } from './types';\n\n/**\n * How a language's agent is staged into an ECS Fargate task and activated in a container.\n *\n * A PORT of `recipeFor` / `applyInstrumentation` in the connector's ECS instrumentor\n * (connectors/providers/aws/pkg/workload/instrumentor/ecs_recipes.go, ecs_inject.go). The data lives in\n * ../../artifacts.json and reaches here through the generated module; the decisions live here.\n *\n * Equivalence with the connector is not cosmetic. Its conformance observer rebuilds each container's\n * desired activation environment and compares it against what the container carries, component by\n * component, so anything rendered differently here is reported to the customer as instrumentation drift\n * on a stack that is in fact deployed exactly as they wrote it.\n */\n\n/** The distro placeholder for the container's own pre-Odigos value of an append-style loader variable. */\nconst ORIGINAL_ENV_VALUE_PLACEHOLDER = '{{ORIGINAL_ENV_VALUE}}';\n\n/** The distro placeholder for the shared volume's mount path. */\nconst AGENTS_DIR_PLACEHOLDER = '{{ODIGOS_AGENTS_DIR}}';\n\n/**\n * The distro parameter for the application's runtime `major.minor`, as a Go text/template action —\n * verbatim from the distro yaml so ../../artifacts.json can be diffed against it by eye. Only php and\n * ruby carry it: their agents are laid down per runtime version.\n */\nconst RUNTIME_VERSION_PLACEHOLDER = '{{.RUNTIME_VERSION_MAJOR_MINOR}}';\n\n/** `OTEL_EXPORTER_OTLP_PROTOCOL` values. Endpoint and protocol are always decided together. */\nexport const OTLP_PROTOCOL_GRPC = 'grpc';\nexport const OTLP_PROTOCOL_HTTP = 'http/protobuf';\n\n/** Standard OTLP receiver ports, used only to warn about an endpoint paired with the other protocol. */\nconst OTLP_DEFAULT_GRPC_PORT = '4317';\nconst OTLP_DEFAULT_HTTP_PORT = '4318';\n\n/**\n * An append-style loader variable — `JAVA_TOOL_OPTIONS`, `NODE_OPTIONS`, `PYTHONPATH` — kept as its\n * pattern rather than a finished value, because the value depends on what the container already carries.\n */\nexport interface FargateAppendEnvVar {\n  /** Variable name. */\n  readonly name: string;\n  /** The distro's ReplacePattern, placeholders unresolved. */\n  readonly pattern: string;\n}\n\n/**\n * Resolves an append pattern for a given pre-existing value.\n *\n * Port of `distro.EvaluateReplacePattern`, INCLUDING the empty-original case: with nothing to join to,\n * the placeholder and its adjacent delimiter are stripped, so the result never opens with a stray space\n * or colon. `PYTHONPATH=\":/var/odigos/python\"` would put the current working directory on `sys.path`\n * ahead of the agent, which is a different program than the one intended.\n */\nexport function evaluateAppendPattern(pattern: string, originalValue: string): string {\n  const withDir = pattern.split(AGENTS_DIR_PLACEHOLDER).join(FARGATE_AGENTS_DIR);\n  if (originalValue.trim() === '') {\n    return withDir.split(ORIGINAL_ENV_VALUE_PLACEHOLDER).join('').replace(/^[ :]+/, '');\n  }\n  return withDir.split(ORIGINAL_ENV_VALUE_PLACEHOLDER).join(originalValue);\n}\n\n/**\n * The delimiter a pattern joins the container's own value to ours with: the character immediately after\n * the original-value placeholder.\n *\n * DERIVED from the pattern rather than declared, because the pattern is the authority — it comes from the\n * upstream distro, differs by language (a space for `JAVA_TOOL_OPTIONS`/`NODE_OPTIONS`, a colon for\n * `PYTHONPATH`) and can change on somebody else's release. Assuming one would be silently destructive in\n * a way nothing here would catch: a space-joined `PYTHONPATH` is one unusable path rather than two, and\n * the process still starts.\n */\nexport function appendSeparator(pattern: string): string {\n  const i = pattern.indexOf(ORIGINAL_ENV_VALUE_PLACEHOLDER);\n  if (i < 0) {\n    return '';\n  }\n  const rest = pattern.slice(i + ORIGINAL_ENV_VALUE_PLACEHOLDER.length);\n  return rest === '' ? '' : rest.charAt(0);\n}\n\n/** One language's staging and activation, with every platform-supplied parameter already rendered. */\nexport interface FargateRecipe {\n  /** Canonical language key, and the value recorded in the `ODIGOS_IAC` marker's `lang`. */\n  readonly language: string;\n  /** Directories under the agents image the staging container copies into the shared volume. */\n  readonly agentDirs: string[];\n  /** Activation variables set outright. */\n  readonly staticEnv: { [key: string]: string };\n  /** Activation variables our fragment is appended to. */\n  readonly appendEnv: FargateAppendEnvVar[];\n  /** The transport this agent prefers. */\n  readonly otlpProtocol: string;\n  /** Whether the agent can speak only `otlpProtocol` and cannot be switched to the other transport. */\n  readonly protocolFixed: boolean;\n}\n\n/** The canonical connector language key for an enum member. The enum's values ARE those keys. */\nexport function languageKeyOf(language: OdigosFargateLanguage): string {\n  return language;\n}\n\n/**\n * The recipe for a language, with the runtime version rendered into the agents' paths where the language\n * needs it.\n *\n * @param runtimeVersion the application's runtime `major.minor`. Required for php and ruby, whose agent\n * files are laid down per version, and ignored by every other language.\n */\nexport function recipeFor(language: OdigosFargateLanguage, runtimeVersion?: string): FargateRecipe {\n  const key = languageKeyOf(language);\n  const spec = FARGATE_LANGUAGES[key];\n  if (!spec) {\n    // Unreachable through the enum; reachable if the generated table and the enum ever disagree.\n    throw new Error(`Odigos: no ECS Fargate agent recipe for language \"${key}\".`);\n  }\n  if (spec.requiresRuntimeVersion && !runtimeVersion) {\n    throw new Error(\n      `Odigos: the ${key} agent's files are laid down per runtime version, so instrumenting a ${key} ` +\n        'container needs `runtimeVersion` set to the application\\'s major.minor (for example \"8.3\"). ' +\n        'The value selects the agent path the activation environment points at, so a wrong or missing ' +\n        'one leaves the container with an agent that is never loaded.',\n    );\n  }\n  // Rejected here rather than passed through: a \"8.3.4\" or \"php8.3\" would be rendered straight into\n  // PHP_INI_SCAN_DIR / RUBYOPT as a path that does not exist in the bundle, and the container would start\n  // with no agent loaded and no error anywhere near the cause.\n  if (runtimeVersion && !/^\\d+\\.\\d+$/.test(runtimeVersion)) {\n    throw new Error(\n      `Odigos: runtimeVersion \"${runtimeVersion}\" must be exactly major.minor (for example \"8.3\") — it ` +\n        'names a directory in the agents bundle, not a full version.',\n    );\n  }\n\n  const staticEnv: { [key: string]: string } = {};\n  for (const [k, v] of Object.entries(spec.staticEnv)) {\n    staticEnv[k] = runtimeVersion ? v.split(RUNTIME_VERSION_PLACEHOLDER).join(runtimeVersion) : v;\n  }\n\n  return {\n    language: key,\n    agentDirs: spec.agentDirs,\n    staticEnv,\n    appendEnv: spec.appendEnv.map((a) => ({ name: a.name, pattern: a.pattern })),\n    otlpProtocol: spec.otlpProtocol,\n    protocolFixed: spec.protocolFixed,\n  };\n}\n\n/**\n * The staging container's command: create the shared directory, then copy each language's agent\n * directory out of the image into it, then exit 0.\n *\n * ORDER AND SPELLING ARE THE CONTRACT. There is ONE staging container per task definition however many\n * languages it holds, and the connector compares its command against the union of every instrumented\n * container's agent directories in ascending order. A command that differs by a space is reported as\n * drift on the whole task definition, so this is sorted and rendered exactly as `sidecarCommand` in the\n * connector does it.\n */\nexport function sidecarCommand(agentDirs: string[]): string[] {\n  const dirs = [...new Set(agentDirs)].sort();\n  let script = `mkdir -p ${FARGATE_AGENTS_DIR}`;\n  for (const d of dirs) {\n    script += ` && cp -r ${FARGATE_IMAGE_AGENTS_DIR}/${d} ${FARGATE_AGENTS_DIR}/${d}`;\n  }\n  return ['sh', '-c', script];\n}\n\n/**\n * The resource attributes every span, metric and log from an instrumented task carries. `service.name` is\n * set separately, through `OTEL_SERVICE_NAME`.\n *\n * The region may be an unresolved token on an environment-agnostic stack, which is fine here and unlike\n * the Lambda layer lookup: this value is an environment variable, so the token resolves to a `Ref` to\n * `AWS::Region` and CloudFormation fills in the real region at deploy time.\n */\nexport function fargateResourceAttributes(region: string): string {\n  const attrs = 'cloud.provider=aws,cloud.platform=aws_ecs';\n  return region ? `${attrs},cloud.region=${region}` : attrs;\n}\n\n/** Where an instrumented container exports to, and over which transport. Always decided as a pair. */\nexport interface FargateExportTarget {\n  /** `scheme://host:port`. */\n  readonly endpoint: string;\n  /** `grpc` or `http/protobuf`. */\n  readonly protocol: string;\n}\n\n/**\n * Turns a destination's OTLP/gRPC target (`host:port`) into the URL the OpenTelemetry SDK env accepts,\n * taking the scheme from the destination's TLS setting. A value that is already a URL passes through.\n */\nfunction grpcEndpointURL(endpoint: string, insecure?: boolean): string {\n  if (endpoint === '') {\n    return '';\n  }\n  if (endpoint.includes('://')) {\n    return endpoint;\n  }\n  return `${insecure === true ? 'http' : 'https'}://${endpoint}`;\n}\n\n/**\n * Resolves the endpoint and protocol for one recipe against one destination.\n *\n * Port of `exportTargetFor`. A Fargate task has no node-local collector — unlike Lambda, where the SDK\n * exports to a collector in the same sandbox — so the agent exports OTLP straight to the destination, and\n * which transport it can use is a property of the agent as much as of the destination.\n *\n * Each agent's PREFERRED transport is taken when the destination offers it. When it does not, an agent\n * whose community SDK pins the protocol (php, ruby) cannot be switched and throws; every other agent\n * honours `OTEL_EXPORTER_OTLP_PROTOCOL` and falls back to whichever transport exists.\n */\nexport function exportTargetFor(recipe: FargateRecipe, dest: OdigosDestination): FargateExportTarget {\n  const grpcURL = grpcEndpointURL(dest.endpoint ?? '', dest.insecure);\n  const httpURL = dest.httpEndpoint ?? '';\n\n  if (recipe.otlpProtocol === OTLP_PROTOCOL_HTTP && httpURL !== '') {\n    return { endpoint: httpURL, protocol: OTLP_PROTOCOL_HTTP };\n  }\n  if (recipe.otlpProtocol === OTLP_PROTOCOL_GRPC && grpcURL !== '') {\n    return { endpoint: grpcURL, protocol: OTLP_PROTOCOL_GRPC };\n  }\n  if (recipe.protocolFixed) {\n    throw new Error(\n      `Odigos: the ${recipe.language} agent exports OTLP over ${recipe.otlpProtocol} only — its community ` +\n        'SDK cannot be switched to the other transport — but the destination configures no ' +\n        `${recipe.otlpProtocol === OTLP_PROTOCOL_HTTP ? '`httpEndpoint`' : '`endpoint`'}. ` +\n        'Configure one, or leave this container uninstrumented.',\n    );\n  }\n  if (httpURL !== '') {\n    return { endpoint: httpURL, protocol: OTLP_PROTOCOL_HTTP };\n  }\n  if (grpcURL !== '') {\n    return { endpoint: grpcURL, protocol: OTLP_PROTOCOL_GRPC };\n  }\n  throw new Error(\n    'Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP), so an ' +\n      'instrumented Fargate task would have nowhere to export. Unlike Lambda, a Fargate task has no ' +\n      'in-sandbox collector to buffer for it — the agent exports to this destination directly.',\n  );\n}\n\n/** The port of a `scheme://host:port[/path]` endpoint, or \"\" when it names none. */\nfunction endpointPort(endpoint: string): string {\n  let rest = endpoint;\n  const scheme = rest.indexOf('://');\n  if (scheme >= 0) {\n    rest = rest.slice(scheme + 3);\n  }\n  const pathStart = rest.search(/[/?]/);\n  if (pathStart >= 0) {\n    rest = rest.slice(0, pathStart);\n  }\n  const colon = rest.lastIndexOf(':');\n  return colon < 0 ? '' : rest.slice(colon + 1);\n}\n\n/**\n * A warning when an endpoint's port is the well-known port of the OTHER OTLP protocol, or \"\" when the\n * pairing looks right — including a non-standard port, which cannot be judged.\n *\n * Worth a synth-time warning because the runtime symptom is a connection reset mid-export, which points\n * nowhere near the cause: an HTTP request against an HTTP/2 gRPC listener, or the reverse.\n */\nexport function portProtocolMismatch(endpoint: string, protocol: string): string {\n  const port = endpointPort(endpoint);\n  if (protocol === OTLP_PROTOCOL_HTTP && port === OTLP_DEFAULT_GRPC_PORT) {\n    return (\n      `endpoint ${endpoint} is on ${OTLP_DEFAULT_GRPC_PORT}, the standard OTLP/gRPC port, but this agent ` +\n      `exports over ${OTLP_PROTOCOL_HTTP}; exports will fail as a connection reset. Point it at the ` +\n      `OTLP/HTTP port (${OTLP_DEFAULT_HTTP_PORT}).`\n    );\n  }\n  if (protocol === OTLP_PROTOCOL_GRPC && port === OTLP_DEFAULT_HTTP_PORT) {\n    return (\n      `endpoint ${endpoint} is on ${OTLP_DEFAULT_HTTP_PORT}, the standard OTLP/HTTP port, but this agent ` +\n      `exports over gRPC; exports will fail. Point it at the OTLP/gRPC port (${OTLP_DEFAULT_GRPC_PORT}).`\n    );\n  }\n  return '';\n}\n"]}