@odigos/aws-cdk 0.0.12 → 0.0.14

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"]}

package/lib/fargate.d.ts

@@ -0,0 +1,218 @@
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import { Construct } from 'constructs';
+import { OdigosDestination, OdigosFargateLanguage } from './types';
+/**
+ * Options shared by every container this construct instruments.
+ */
+export interface OdigosFargateInstrumentationOptions {
+    /**
+     * Where the instrumented containers export telemetry to.
+     *
+     * Unlike Lambda, BOTH transports may be set and often should be: a Fargate task has no collector of its
+     * own, so each language's agent exports to this destination itself and takes the transport it prefers.
+     * php and ruby can only speak OTLP/HTTP at all.
+     */
+    readonly destination: OdigosDestination;
+    /**
+     * The agents bundle the staging container copies the language agents out of.
+     *
+     * Defaults to the multi-arch image this package's release published, at that release's immutable tag.
+     * Override it to mirror the image into a registry your tasks can reach — the image is pulled by YOUR
+     * task's execution role at every task start, so a task in a private subnet with no NAT and no
+     * interface endpoint cannot pull the default.
+     *
+     * A mirror must be the same bundle: the activation environment set below names exact paths inside it.
+     *
+     * @default - the released `registry.odigos.io/odigos-fargate-agents` image for this package version
+     */
+    readonly agentsImage?: string;
+    /**
+     * Raise agent verbosity (`OTEL_LOG_LEVEL=debug`) on every instrumented container.
+     *
+     * Useful while wiring up a destination, expensive to leave on — and it is compared: the connector
+     * expects the variable ABSENT unless debug telemetry is enabled for the connector too, so leaving this
+     * on can itself be reported as drift.
+     *
+     * @default false
+     */
+    readonly debug?: boolean;
+}
+/**
+ * One container to instrument.
+ */
+export interface OdigosFargateTarget {
+    /**
+     * The application container. Its task definition is taken from it, so the staging container, the shared
+     * volume and the startup dependency are added to the right one automatically.
+     */
+    readonly container: ecs.ContainerDefinition;
+    /**
+     * The language whose agent to stage and activate.
+     *
+     * Stated rather than detected — a container declares an image, not a runtime, and resolving a language
+     * from an image means pulling it.
+     */
+    readonly language: OdigosFargateLanguage;
+    /**
+     * `OTEL_SERVICE_NAME` for this container.
+     *
+     * THIS MUST MATCH 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.
+     *
+     * Pass `service` instead to read it off the service, or set this when the service is defined elsewhere
+     * (a different stack, Terraform, the console). One of the two is required.
+     *
+     * @default - taken from `service`
+     */
+    readonly serviceName?: string;
+    /**
+     * The ECS service that runs this task definition, used only to read its name.
+     *
+     * Its physical name has to be one your stack SET, not one CloudFormation generates: a generated name is
+     * a `Ref` to the service, and a service's own task definition referencing it is a dependency cycle
+     * CloudFormation rejects at deploy time. A generated name throws at synth pointing at `serviceName`.
+     *
+     * @default - `serviceName` must be given instead
+     */
+    readonly service?: ecs.BaseService;
+    /**
+     * The application's runtime version as `major.minor` — for example `"8.3"`.
+     *
+     * Required for php and ruby, whose agents are laid down per runtime version in the bundle, and the
+     * version selects the path their activation variables point at. Ignored by every other language.
+     *
+     * @default - none; required for php and ruby
+     */
+    readonly runtimeVersion?: string;
+    /**
+     * The value this container already needs in its loader variable (`JAVA_TOOL_OPTIONS`, `NODE_OPTIONS` or
+     * `PYTHONPATH`), which the Odigos fragment is joined to rather than replacing.
+     *
+     * Only needed as an OVERRIDE. The construct reads the value the container was created with and appends
+     * to it, so a container that sets its own `JAVA_TOOL_OPTIONS` in `addContainer` keeps it. Pass this when
+     * the value is not visible at synth — set by an `environmentFiles` entry, injected by the image's own
+     * `ENV`, or supplied through `secrets`.
+     *
+     * @default - read from the container's own environment
+     */
+    readonly existingLoaderValue?: string;
+}
+/**
+ * Props for {@link OdigosFargateInstrumentation}.
+ */
+export interface OdigosFargateInstrumentationProps extends OdigosFargateInstrumentationOptions {
+    /**
+     * Containers to instrument on construction. More can be added with `instrument()`.
+     *
+     * @default - none
+     */
+    readonly targets?: OdigosFargateTarget[];
+}
+/**
+ * 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.
+ */
+export declare class OdigosFargateInstrumentation extends Construct {
+    private readonly options;
+    private readonly agentsImage;
+    private readonly taskDefinitions;
+    private readonly instrumented;
+    constructor(scope: Construct, id: string, props: OdigosFargateInstrumentationProps);
+    /**
+     * Instruments one container. Idempotent — instrumenting the same container twice is a no-op rather than
+     * a doubled loader value.
+     */
+    instrument(target: OdigosFargateTarget): void;
+    /** Instruments every target in the list. */
+    instrumentAll(targets: OdigosFargateTarget[]): void;
+    /**
+     * 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.
+     */
+    private taskDefinitionState;
+    /**
+     * `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.
+     */
+    private resolveServiceName;
+    /**
+     * 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.
+     */
+    private checkTaskDefinition;
+    /**
+     * 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.
+     */
+    private environmentFor;
+}