@odigos/aws-cdk 0.0.10 → 0.0.11

package/lib/instrumentation.js

@@ -18,36 +18,52 @@ const ENV_SERVICE_NAME = 'OTEL_SERVICE_NAME';
 /** Raises in-function OpenTelemetry verbosity into the function's CloudWatch log group. */
 const ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL';
 /**
- * Marker recording that this function was instrumented by IaC, and by which version.
+ * `ODIGOS_MANAGED` — the connector's OWNERSHIP MARKER, written only when `recordOwnershipMarker` is set.
  *
- * Deliberately NOT `ODIGOS_MANAGED`. That variable is the connector's OWNERSHIP PROOF: a function
- * carrying it is one the connector believes it instrumented, whose environment it will converge on every
- * reconcile and strip on rollback — using a snapshot of "the customer's original values" that a CDK
- * deployment never wrote. Setting it here would hand the connector a function it does not own, with a
- * snapshot describing a state that never existed.
+ * The connector derives ownership from this variable alone: `store.OdigosInstrumented` checks for its
+ * presence, and a function without it is reported `Absent` — "awaiting your deployment" — before any other
+ * component is compared, however completely the rest is applied. So a manual-mode (IaC) function that is
+ * meant to show up as instrumented in Odigos has to carry it, and nothing else can stand in for it.
+ */
+const ENV_ODIGOS_MANAGED = 'ODIGOS_MANAGED';
+/**
+ * Schema version of the marker payload. Must match `managedManifestVersion` 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;
+/**
+ * Marker recording that this function was instrumented by IaC, and by which version.
  *
- * This variable is informational only. Nothing reads it.
+ * Distinct from `ODIGOS_MANAGED`, and not a substitute for it: this one is informational and nothing reads
+ * it, while that one is the connector's ownership proof (see `recordOwnershipMarker`). The connector
+ * ignores variables it does not expect, so this is never reported as drift.
  */
 const ENV_IAC_MARKER = 'ODIGOS_IAC';
 /**
  * The service a function reports as, when the caller has not named one.
  *
- * NOT `fn.functionName`. For a function whose physical name CloudFormation generates, that property is a
- * `Ref` to the function itself — putting it in the function's own environment makes the resource depend
- * on its own creation, and CloudFormation rejects the template with a dependency cycle. Every
- * instrumented function would fail to deploy, at deploy time rather than synth time.
+ * READ FROM THE L1, NOT FROM `fn.functionName`. The L2 property is a cross-environment-aware token that
+ * resolves to a `Ref` to the function itself even when the stack set `functionName` explicitly — so the
+ * obvious `Stack.of(fn).resolve(fn.functionName)` never yields a literal, and every function silently fell
+ * back to its construct id. `CfnFunction.functionName` is the raw template value: the literal the stack
+ * passed, or undefined when CloudFormation generates the name.
  *
- * So: use the physical name when the caller set one explicitly (`resolve` yields a literal string for a
- * known physical name, and a `Ref` object otherwise), and otherwise fall back to the construct id, which
- * is what the function is called in the code and needs no reference at all.
+ * Why the fallback is the construct id rather than the generated name: a generated name is a `Ref` to the
+ * function, and putting that in the function's own environment makes the resource depend on its own
+ * creation — CloudFormation rejects the template with a dependency cycle, at deploy time.
  *
- * The connector reports the real AWS function name for the functions IT instruments. A function with a
- * generated physical name therefore reports differently under the two paths — pass `serviceName`
- * explicitly if that matters.
+ * This matters beyond cosmetics. The connector compares `OTEL_SERVICE_NAME` against the workload's name in
+ * Odigos, which is the real AWS function name, so a function reporting its construct id is reported as
+ * drifted on the service-name component. Naming the function in your stack is now enough to line the two
+ * up; a function whose name CloudFormation generates still needs `serviceName` passed explicitly.
  */
 function defaultServiceName(fn) {
-    const resolved = aws_cdk_lib_1.Stack.of(fn).resolve(fn.functionName);
-    return typeof resolved === 'string' ? resolved : fn.node.id;
+    const cfn = fn.node.defaultChild;
+    const resolved = cfn === undefined ? undefined : aws_cdk_lib_1.Stack.of(fn).resolve(cfn.functionName);
+    if (typeof resolved === 'string' && resolved !== '' && !aws_cdk_lib_1.Token.isUnresolved(resolved)) {
+        return resolved;
+    }
+    return fn.node.id;
 }
 /**
  * Instruments AWS Lambda functions with the Odigos OpenTelemetry layer.
@@ -88,6 +104,20 @@ class OdigosLambdaInstrumentation extends constructs_1.Construct {
         // Rendered once. It depends only on the destination, and rendering it per function would make an
         // accidental difference between two functions possible.
         this.collectorConfig = (0, collector_config_1.renderCollectorConfig)(props.destination);
+        // A warning rather than an error, because a collector CAN be reached over gRPC on a non-standard port —
+        // but the overwhelmingly likelier reading of `endpoint: "host:4318"` is an OTLP/HTTP endpoint passed to
+        // the gRPC exporter, which builds, starts, and then never delivers a batch. Silent for the caller who
+        // meant it; loud for the one who did not.
+        if (props.destination.endpoint?.endsWith(':4318')) {
+            aws_cdk_lib_1.Annotations.of(this).addWarningV2('@odigos/aws-cdk:probableHttpEndpoint', `Odigos: destination endpoint "${props.destination.endpoint}" is on 4318, the OTLP/HTTP port, but ` +
+                '`endpoint` configures the gRPC exporter (conventionally 4317). If that is an OTLP/HTTP collector, ' +
+                'pass it as `httpEndpoint: "http://host:4318"` instead — the gRPC exporter will export nothing to it.');
+        }
+        if (props.destination.httpEndpoint?.endsWith(':4317')) {
+            aws_cdk_lib_1.Annotations.of(this).addWarningV2('@odigos/aws-cdk:probableGrpcEndpoint', `Odigos: destination httpEndpoint "${props.destination.httpEndpoint}" is on 4317, the OTLP/gRPC port, ` +
+                'but `httpEndpoint` configures the HTTP exporter (conventionally 4318). If that is a gRPC collector, ' +
+                'pass it as `endpoint: "host:4317"` instead.');
+        }
         for (const fn of props.functions ?? []) {
             this.instrument(fn);
         }
@@ -116,7 +146,9 @@ class OdigosLambdaInstrumentation extends constructs_1.Construct {
         const architecture = fn.architecture.name;
         const layer = this.options.layerVersion ?? this.resolver.resolve(language, architecture);
         fn.addLayers(layer);
-        for (const [name, value] of Object.entries(this.environmentFor(fn, language))) {
+        // The ARN, not the construct: the marker has to name the exact layer version the function carries, and
+        // in IN_ACCOUNT mode that is a nested-stack output reference resolved at deploy time.
+        for (const [name, value] of Object.entries(this.environmentFor(fn, language, layer.layerVersionArn))) {
             fn.addEnvironment(name, value);
         }
     }
@@ -134,7 +166,7 @@ class OdigosLambdaInstrumentation extends constructs_1.Construct {
      * on localhost rather than blocking the invocation on the remote destination, and an enabled signal's
      * `OTEL_*_EXPORTER` stays unset because `otlp` is already the SDK default.
      */
-    environmentFor(fn, language) {
+    environmentFor(fn, language, layerArn) {
         const { destination, mode, debug, serviceName, javaHandlerDistro, existingLoaderValue } = this.options;
         const webServer = mode === types_1.OdigosInstrumentationMode.WEB_SERVER;
         const env = {
@@ -165,12 +197,48 @@ class OdigosLambdaInstrumentation extends constructs_1.Construct {
                 env[name] = value;
             }
         }
+        // LAST, because the marker's snapshot describes the keys above: it is built from what this function is
+        // actually getting, not from a fixed list.
+        if (this.options.recordOwnershipMarker) {
+            env[ENV_ODIGOS_MANAGED] = this.ownershipMarker(env, layerArn, language, webServer);
+        }
         return env;
     }
+    /**
+     * The `ODIGOS_MANAGED` payload: the layer this function carries, plus the snapshot the connector restores
+     * from if it ever rolls the function back.
+     *
+     * WHY `prevEnv` IS NOT OPTIONAL HERE. The connector's rollback iterates exactly this map — a null entry
+     * means "delete on rollback", a string means "restore this value verbatim" — and then removes the recorded
+     * layer. A marker without it would therefore strip the LAYER while leaving `AWS_LAMBDA_EXEC_WRAPPER`
+     * pointing at `/opt/otel-handler`, a script that is no longer mounted: the function then fails at its next
+     * cold start. Recording every key this construct sets makes rollback strip the whole set together.
+     *
+     * The values are null rather than the customer's prior values because a CDK stack cannot read an
+     * environment variable back — with one exception that matters, the web-server loader variable, whose prior
+     * value the caller has already had to pass as `existingLoaderValue` for exactly the same reason.
+     */
+    ownershipMarker(env, layerArn, language, webServer) {
+        const prevEnv = {};
+        for (const name of Object.keys(env)) {
+            // Not itself, and not the informational IaC marker: rollback deletes ODIGOS_MANAGED unconditionally,
+            // and ODIGOS_IAC records where the function came from, which stays true after an uninstrument.
+            if (name !== ENV_IAC_MARKER) {
+                prevEnv[name] = null;
+            }
+        }
+        const loaderKey = webServer ? (0, runtime_1.webServerLoaderKey)(language) : undefined;
+        if (loaderKey !== undefined) {
+            // Restore the caller's own loader value rather than deleting the variable: ours was appended to it, so
+            // deleting the key would take the customer's flags — the ones their app needs to boot — with it.
+            prevEnv[loaderKey] = this.options.existingLoaderValue ?? null;
+        }
+        return JSON.stringify({ v: MARKER_VERSION, layer: layerArn, prevEnv });
+    }
 }
 exports.OdigosLambdaInstrumentation = OdigosLambdaInstrumentation;
 _a = JSII_RTTI_SYMBOL_1;
-OdigosLambdaInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosLambdaInstrumentation", version: "0.0.10" };
+OdigosLambdaInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosLambdaInstrumentation", version: "0.0.11" };
 /**
  * Applies Odigos instrumentation to every `lambda.Function` in a scope.
  *
@@ -208,5 +276,5 @@ class OdigosInstrumentationAspect {
 }
 exports.OdigosInstrumentationAspect = OdigosInstrumentationAspect;
 _b = JSII_RTTI_SYMBOL_1;
-OdigosInstrumentationAspect[_b] = { fqn: "@odigos/aws-cdk.OdigosInstrumentationAspect", version: "0.0.10" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instrumentation.js","sourceRoot":"","sources":["../src/instrumentation.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, IAspect, Stack } from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { Construct, IConstruct } from 'constructs';\nimport {\n  ENV_COLLECTOR_CONFIG_URI,\n  ENV_LOGS_EXPORTER,\n  ENV_METRICS_EXPORTER,\n  ENV_TRACES_EXPORTER,\n  exporterOverrideFor,\n  renderCollectorConfig,\n  signalEnabled,\n} from './collector-config';\nimport { ODIGOS_VERSION } from './generated/layers';\nimport { OdigosLayerResolver } from './layer-resolver';\nimport { execWrapperFor, languageFromRuntime, webServerEnv } from './runtime';\nimport {\n  OdigosDestination,\n  OdigosInstrumentationMode,\n  OdigosJavaHandlerDistro,\n  OdigosLayerSource,\n} from './types';\n\n/** `AWS_LAMBDA_EXEC_WRAPPER` — the layer's entry point in handler mode. */\nconst ENV_EXEC_WRAPPER = 'AWS_LAMBDA_EXEC_WRAPPER';\n/** Service name reported on every span, metric and log record. */\nconst ENV_SERVICE_NAME = 'OTEL_SERVICE_NAME';\n/** Raises in-function OpenTelemetry verbosity into the function's CloudWatch log group. */\nconst ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL';\n\n/**\n * Marker recording that this function was instrumented by IaC, and by which version.\n *\n * Deliberately NOT `ODIGOS_MANAGED`. That variable is the connector's OWNERSHIP PROOF: a function\n * carrying it is one the connector believes it instrumented, whose environment it will converge on every\n * reconcile and strip on rollback — using a snapshot of \"the customer's original values\" that a CDK\n * deployment never wrote. Setting it here would hand the connector a function it does not own, with a\n * snapshot describing a state that never existed.\n *\n * This variable is informational only. Nothing reads it.\n */\nconst ENV_IAC_MARKER = 'ODIGOS_IAC';\n\n/**\n * The service a function reports as, when the caller has not named one.\n *\n * NOT `fn.functionName`. For a function whose physical name CloudFormation generates, that property is a\n * `Ref` to the function itself — putting it in the function's own environment makes the resource depend\n * on its own creation, and CloudFormation rejects the template with a dependency cycle. Every\n * instrumented function would fail to deploy, at deploy time rather than synth time.\n *\n * So: use the physical name when the caller set one explicitly (`resolve` yields a literal string for a\n * known physical name, and a `Ref` object otherwise), and otherwise fall back to the construct id, which\n * is what the function is called in the code and needs no reference at all.\n *\n * The connector reports the real AWS function name for the functions IT instruments. A function with a\n * generated physical name therefore reports differently under the two paths — pass `serviceName`\n * explicitly if that matters.\n */\nfunction defaultServiceName(fn: lambda.Function): string {\n  const resolved = Stack.of(fn).resolve(fn.functionName);\n  return typeof resolved === 'string' ? resolved : fn.node.id;\n}\n\n/**\n * Options shared by the construct and the aspect.\n */\nexport interface OdigosInstrumentationOptions {\n  /**\n   * Where the in-Lambda collector exports to.\n   */\n  readonly destination: OdigosDestination;\n\n  /**\n   * Where the Odigos layer comes from.\n   *\n   * @default OdigosLayerSource.ODIGOS_PUBLIC\n   */\n  readonly layerSource?: OdigosLayerSource;\n\n  /**\n   * Handler mode or web-server (Lambda Web Adapter) mode.\n   *\n   * There is no auto-detection, and that is deliberate rather than an omission: detecting the web adapter\n   * means inspecting the function's other layers, which at synth time are frequently unresolved tokens.\n   * A detector that is right most of the time would silently break the functions it got wrong.\n   *\n   * @default OdigosInstrumentationMode.HANDLER\n   */\n  readonly mode?: OdigosInstrumentationMode;\n\n  /**\n   * Which of the Java layer's four wrapper scripts to use. Ignored for other languages.\n   *\n   * @default OdigosJavaHandlerDistro.OTEL_HANDLER\n   */\n  readonly javaHandlerDistro?: OdigosJavaHandlerDistro;\n\n  /**\n   * `OTEL_SERVICE_NAME` for every function this instruments.\n   *\n   * Usually wrong to set when instrumenting more than one function — they would all report as the same\n   * service.\n   *\n   * Left unset, a function reports as its explicitly-set physical name if it has one, and otherwise as\n   * its construct id. It deliberately does not default to the generated physical name: that value is a\n   * `Ref` to the function itself, and a function referencing itself in its own environment is a\n   * CloudFormation dependency cycle.\n   *\n   * @default - the function's physical name if explicitly set, otherwise its construct id\n   */\n  readonly serviceName?: string;\n\n  /**\n   * Raise in-function OpenTelemetry verbosity (`OTEL_LOG_LEVEL=debug`).\n   *\n   * The layer, SDK and collector then emit span and OTLP-export diagnostics into the function's CloudWatch\n   * log group. Useful while wiring up a destination, expensive to leave on.\n   *\n   * Has no effect in web-server mode, matching the connector, which never sets a log level there.\n   *\n   * @default false\n   */\n  readonly debug?: boolean;\n\n  /**\n   * Attach this layer instead of resolving one. Overrides `layerSource` entirely.\n   *\n   * The escape hatch for a layer mirrored into a private registry or an internal account. The layer must\n   * have the same contents as the Odigos one — the environment set here assumes its exact script layout.\n   *\n   * @default - resolved from layerSource\n   */\n  readonly layerVersion?: lambda.ILayerVersion;\n\n  /**\n   * The value the function already needs in its language loader variable (`NODE_OPTIONS`,\n   * `JAVA_TOOL_OPTIONS` or `PYTHONPATH`), which the Odigos loader is joined to rather than replacing.\n   *\n   * Only used in web-server mode. It has to be passed explicitly because CDK's `lambda.Function` exposes\n   * no way to read back an environment variable set elsewhere in the app — an omitted value here is\n   * silently overwritten, which for `NODE_OPTIONS` can mean losing a flag the app needs to boot.\n   *\n   * @default - the loader variable is set to the Odigos value alone\n   */\n  readonly existingLoaderValue?: string;\n\n  /**\n   * Skip functions whose runtime has no OpenTelemetry Lambda layer instead of throwing.\n   *\n   * `dotnet*` and `provided.*` (Go, custom runtimes) have no language layer upstream. Explicitly\n   * instrumenting one is a mistake worth failing on; sweeping a whole stack with the aspect and hitting\n   * one is not, which is why the aspect defaults this to `true` and the construct to `false`.\n   *\n   * @default false\n   */\n  readonly skipUnsupportedRuntimes?: boolean;\n}\n\n/**\n * Props for {@link OdigosLambdaInstrumentation}.\n */\nexport interface OdigosLambdaInstrumentationProps extends OdigosInstrumentationOptions {\n  /**\n   * Functions to instrument on construction. More can be added with `instrument()`.\n   *\n   * @default - none\n   */\n  readonly functions?: lambda.Function[];\n}\n\n/**\n * Instruments AWS Lambda functions with the Odigos OpenTelemetry layer.\n *\n * ```ts\n * const odigos = new OdigosLambdaInstrumentation(this, 'Odigos', {\n *   destination: { endpoint: 'otlp.example.com:4317' },\n *   functions: [apiFn, workerFn],\n * });\n * odigos.instrument(anotherFn);\n * ```\n *\n * What it does to each function: attaches the layer for the function's language and architecture, sets\n * `AWS_LAMBDA_EXEC_WRAPPER` so the layer loads the SDK, sets `OTEL_SERVICE_NAME`, and hands the in-Lambda\n * collector its entire configuration inline through `OPENTELEMETRY_COLLECTOR_CONFIG_URI`.\n *\n * The function's SDK exports to the collector on localhost, not to your destination. The collector\n * forwards after the handler has already returned, so a slow destination costs billed duration rather\n * than caller latency.\n *\n * ## Do not also instrument these functions with the connector\n *\n * The Odigos AWS connector instruments live functions by mutating them, and reconciles them back to its\n * own desired state on every pass. A function instrumented here and also enabled as a connector source\n * ends up owned by both: each `cdk deploy` reasserts the CDK's environment, each reconcile reasserts the\n * connector's, and every round trip publishes a new function version.\n *\n * Choose one per function. This construct never sets the connector's `ODIGOS_MANAGED` ownership marker,\n * so an IaC-instrumented function is not one the connector will roll back — but it will happily take it\n * over if you enable it as a source.\n */\nexport class OdigosLambdaInstrumentation extends Construct {\n  private readonly options: OdigosInstrumentationOptions;\n  private readonly resolver: OdigosLayerResolver;\n  private readonly collectorConfig: string;\n  private readonly instrumented = new Set<string>();\n\n  constructor(scope: Construct, id: string, props: OdigosLambdaInstrumentationProps) {\n    super(scope, id);\n\n    this.options = props;\n    this.resolver = new OdigosLayerResolver(this, props.layerSource ?? OdigosLayerSource.ODIGOS_PUBLIC);\n\n    // Rendered once. It depends only on the destination, and rendering it per function would make an\n    // accidental difference between two functions possible.\n    this.collectorConfig = renderCollectorConfig(props.destination);\n\n    for (const fn of props.functions ?? []) {\n      this.instrument(fn);\n    }\n  }\n\n  /**\n   * Instruments one function. Idempotent — instrumenting the same function twice is a no-op rather than a\n   * doubled loader value.\n   */\n  public instrument(fn: lambda.Function): void {\n    const key = fn.node.path;\n    if (this.instrumented.has(key)) {\n      return;\n    }\n\n    const runtimeName = fn.runtime.name;\n    const language = languageFromRuntime(runtimeName);\n    if (!language) {\n      const message =\n        `Odigos: runtime \"${runtimeName}\" has no OpenTelemetry Lambda layer ` +\n        '(upstream publishes layers for python, nodejs, java and ruby only), so this function cannot be instrumented.';\n      if (this.options.skipUnsupportedRuntimes) {\n        Annotations.of(fn).addWarningV2('@odigos/aws-cdk:unsupportedRuntime', `${message} Skipping.`);\n        return;\n      }\n      throw new Error(`${message} Set skipUnsupportedRuntimes: true to skip it instead.`);\n    }\n\n    this.instrumented.add(key);\n\n    const architecture = fn.architecture.name;\n    const layer = this.options.layerVersion ?? this.resolver.resolve(language, architecture);\n    fn.addLayers(layer);\n\n    for (const [name, value] of Object.entries(this.environmentFor(fn, language))) {\n      fn.addEnvironment(name, value);\n    }\n  }\n\n  /** Instruments every function in the list. */\n  public instrumentAll(functions: lambda.Function[]): void {\n    for (const fn of functions) {\n      this.instrument(fn);\n    }\n  }\n\n  /**\n   * The environment applied to one function.\n   *\n   * Mirrors `applyHandlerEnv` / `applyWebServerEnv` in the connector, including what is deliberately NOT\n   * set: `OTEL_EXPORTER_OTLP_ENDPOINT` stays unset so the SDK keeps exporting to the in-Lambda collector\n   * on localhost rather than blocking the invocation on the remote destination, and an enabled signal's\n   * `OTEL_*_EXPORTER` stays unset because `otlp` is already the SDK default.\n   */\n  private environmentFor(fn: lambda.Function, language: string): { [key: string]: string } {\n    const { destination, mode, debug, serviceName, javaHandlerDistro, existingLoaderValue } = this.options;\n    const webServer = mode === OdigosInstrumentationMode.WEB_SERVER;\n\n    const env: { [key: string]: string } = {\n      [ENV_SERVICE_NAME]: serviceName ?? defaultServiceName(fn),\n      [ENV_COLLECTOR_CONFIG_URI]: this.collectorConfig,\n      [ENV_IAC_MARKER]: JSON.stringify({ v: 1, source: 'cdk', version: ODIGOS_VERSION || 'unreleased' }),\n    };\n\n    if (webServer) {\n      // No exec wrapper: the Lambda Web Adapter owns it, and overwriting it stops the function serving.\n      Object.assign(env, webServerEnv(language, existingLoaderValue));\n    } else {\n      env[ENV_EXEC_WRAPPER] = execWrapperFor(language, javaHandlerDistro);\n      if (debug) {\n        env[ENV_OTEL_LOG_LEVEL] = 'debug';\n      }\n    }\n\n    // Suppress the signals the destination does not accept. A signal with no collector pipeline is refused\n    // at the receiver on every batch, so telling the SDK not to produce it is the half that stops the\n    // error loop; the pipeline being absent is the half that stops the export.\n    const overrides: Array<[string, string | undefined]> = [\n      [ENV_TRACES_EXPORTER, exporterOverrideFor(signalEnabled(destination.traces))],\n      [ENV_METRICS_EXPORTER, exporterOverrideFor(signalEnabled(destination.metrics))],\n      [ENV_LOGS_EXPORTER, exporterOverrideFor(signalEnabled(destination.logs))],\n    ];\n    for (const [name, value] of overrides) {\n      if (value !== undefined) {\n        env[name] = value;\n      }\n    }\n\n    return env;\n  }\n}\n\n/**\n * Props for {@link OdigosInstrumentationAspect}.\n */\nexport interface OdigosInstrumentationAspectProps extends OdigosInstrumentationOptions {}\n\n/**\n * Applies Odigos instrumentation to every `lambda.Function` in a scope.\n *\n * ```ts\n * Aspects.of(stack).add(new OdigosInstrumentationAspect(stack, {\n *   destination: { endpoint: 'otlp.example.com:4317' },\n * }));\n * ```\n *\n * `skipUnsupportedRuntimes` defaults to `true` here, unlike the construct: an aspect visits every function\n * in the scope, including ones whose runtime has no OpenTelemetry layer, and failing the whole synth\n * because a stack happens to contain one Go function is not useful. Each skip is reported as a synth\n * warning, so it is visible rather than silent.\n *\n * The aspect instruments what exists in the tree when it runs. A function added by a later aspect is not\n * visited; use the construct directly for those.\n */\nexport class OdigosInstrumentationAspect implements IAspect {\n  private readonly instrumentation: OdigosLambdaInstrumentation;\n\n  /**\n   * @param scope where the shared layer constructs are created. Usually the same scope the aspect is\n   * applied to. It is a separate argument from the visited nodes because the layer (and, in `IN_ACCOUNT`\n   * mode, the nested SAR application) is created once and shared by every function the aspect visits.\n   */\n  constructor(scope: Construct, props: OdigosInstrumentationAspectProps) {\n    this.instrumentation = new OdigosLambdaInstrumentation(scope, 'OdigosInstrumentationAspect', {\n      skipUnsupportedRuntimes: true,\n      ...props,\n    });\n  }\n\n  public visit(node: IConstruct): void {\n    if (node instanceof lambda.Function) {\n      this.instrumentation.instrument(node);\n    }\n  }\n}\n"]}
+OdigosInstrumentationAspect[_b] = { fqn: "@odigos/aws-cdk.OdigosInstrumentationAspect", version: "0.0.11" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instrumentation.js","sourceRoot":"","sources":["../src/instrumentation.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, IAspect, Stack, Token } from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport { Construct, IConstruct } from 'constructs';\nimport {\n  ENV_COLLECTOR_CONFIG_URI,\n  ENV_LOGS_EXPORTER,\n  ENV_METRICS_EXPORTER,\n  ENV_TRACES_EXPORTER,\n  exporterOverrideFor,\n  renderCollectorConfig,\n  signalEnabled,\n} from './collector-config';\nimport { ODIGOS_VERSION } from './generated/layers';\nimport { OdigosLayerResolver } from './layer-resolver';\nimport { execWrapperFor, languageFromRuntime, webServerEnv, webServerLoaderKey } from './runtime';\nimport {\n  OdigosDestination,\n  OdigosInstrumentationMode,\n  OdigosJavaHandlerDistro,\n  OdigosLayerSource,\n} from './types';\n\n/** `AWS_LAMBDA_EXEC_WRAPPER` — the layer's entry point in handler mode. */\nconst ENV_EXEC_WRAPPER = 'AWS_LAMBDA_EXEC_WRAPPER';\n/** Service name reported on every span, metric and log record. */\nconst ENV_SERVICE_NAME = 'OTEL_SERVICE_NAME';\n/** Raises in-function OpenTelemetry verbosity into the function's CloudWatch log group. */\nconst ENV_OTEL_LOG_LEVEL = 'OTEL_LOG_LEVEL';\n\n/**\n * `ODIGOS_MANAGED` — the connector's OWNERSHIP MARKER, written only when `recordOwnershipMarker` is set.\n *\n * The connector derives ownership from this variable alone: `store.OdigosInstrumented` checks for its\n * presence, and a function without it is reported `Absent` — \"awaiting your deployment\" — before any other\n * component is compared, however completely the rest is applied. So a manual-mode (IaC) function that is\n * meant to show up as instrumented in Odigos has to carry it, and nothing else can stand in for it.\n */\nconst ENV_ODIGOS_MANAGED = 'ODIGOS_MANAGED';\n\n/**\n * Schema version of the marker payload. Must match `managedManifestVersion` 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 * Marker recording that this function was instrumented by IaC, and by which version.\n *\n * Distinct from `ODIGOS_MANAGED`, and not a substitute for it: this one is informational and nothing reads\n * it, while that one is the connector's ownership proof (see `recordOwnershipMarker`). The connector\n * ignores variables it does not expect, so this is never reported as drift.\n */\nconst ENV_IAC_MARKER = 'ODIGOS_IAC';\n\n/**\n * The service a function reports as, when the caller has not named one.\n *\n * READ FROM THE L1, NOT FROM `fn.functionName`. The L2 property is a cross-environment-aware token that\n * resolves to a `Ref` to the function itself even when the stack set `functionName` explicitly — so the\n * obvious `Stack.of(fn).resolve(fn.functionName)` never yields a literal, and every function silently fell\n * back to its construct id. `CfnFunction.functionName` is the raw template value: the literal the stack\n * passed, or undefined when CloudFormation generates the name.\n *\n * Why the fallback is the construct id rather than the generated name: a generated name is a `Ref` to the\n * function, and putting that in the function's own environment makes the resource depend on its own\n * creation — CloudFormation rejects the template with a dependency cycle, at deploy time.\n *\n * This matters beyond cosmetics. The connector compares `OTEL_SERVICE_NAME` against the workload's name in\n * Odigos, which is the real AWS function name, so a function reporting its construct id is reported as\n * drifted on the service-name component. Naming the function in your stack is now enough to line the two\n * up; a function whose name CloudFormation generates still needs `serviceName` passed explicitly.\n */\nfunction defaultServiceName(fn: lambda.Function): string {\n  const cfn = fn.node.defaultChild as lambda.CfnFunction | undefined;\n  const resolved = cfn === undefined ? undefined : Stack.of(fn).resolve(cfn.functionName);\n  if (typeof resolved === 'string' && resolved !== '' && !Token.isUnresolved(resolved)) {\n    return resolved;\n  }\n  return fn.node.id;\n}\n\n/**\n * Options shared by the construct and the aspect.\n */\nexport interface OdigosInstrumentationOptions {\n  /**\n   * Where the in-Lambda collector exports to.\n   */\n  readonly destination: OdigosDestination;\n\n  /**\n   * Where the Odigos layer comes from.\n   *\n   * @default OdigosLayerSource.ODIGOS_PUBLIC\n   */\n  readonly layerSource?: OdigosLayerSource;\n\n  /**\n   * Handler mode or web-server (Lambda Web Adapter) mode.\n   *\n   * There is no auto-detection, and that is deliberate rather than an omission: detecting the web adapter\n   * means inspecting the function's other layers, which at synth time are frequently unresolved tokens.\n   * A detector that is right most of the time would silently break the functions it got wrong.\n   *\n   * @default OdigosInstrumentationMode.HANDLER\n   */\n  readonly mode?: OdigosInstrumentationMode;\n\n  /**\n   * Which of the Java layer's four wrapper scripts to use. Ignored for other languages.\n   *\n   * @default OdigosJavaHandlerDistro.OTEL_HANDLER\n   */\n  readonly javaHandlerDistro?: OdigosJavaHandlerDistro;\n\n  /**\n   * `OTEL_SERVICE_NAME` for every function this instruments.\n   *\n   * Usually wrong to set when instrumenting more than one function — they would all report as the same\n   * service.\n   *\n   * Left unset, a function reports as its explicitly-set physical name if it has one, and otherwise as\n   * its construct id. It deliberately does not default to the generated physical name: that value is a\n   * `Ref` to the function itself, and a function referencing itself in its own environment is a\n   * CloudFormation dependency cycle.\n   *\n   * @default - the function's physical name if explicitly set, otherwise its construct id\n   */\n  readonly serviceName?: string;\n\n  /**\n   * Raise in-function OpenTelemetry verbosity (`OTEL_LOG_LEVEL=debug`).\n   *\n   * The layer, SDK and collector then emit span and OTLP-export diagnostics into the function's CloudWatch\n   * log group. Useful while wiring up a destination, expensive to leave on.\n   *\n   * Has no effect in web-server mode, matching the connector, which never sets a log level there.\n   *\n   * @default false\n   */\n  readonly debug?: boolean;\n\n  /**\n   * Attach this layer instead of resolving one. Overrides `layerSource` entirely.\n   *\n   * The escape hatch for a layer mirrored into a private registry or an internal account. The layer must\n   * have the same contents as the Odigos one — the environment set here assumes its exact script layout.\n   *\n   * @default - resolved from layerSource\n   */\n  readonly layerVersion?: lambda.ILayerVersion;\n\n  /**\n   * The value the function already needs in its language loader variable (`NODE_OPTIONS`,\n   * `JAVA_TOOL_OPTIONS` or `PYTHONPATH`), which the Odigos loader is joined to rather than replacing.\n   *\n   * Only used in web-server mode. It has to be passed explicitly because CDK's `lambda.Function` exposes\n   * no way to read back an environment variable set elsewhere in the app — an omitted value here is\n   * silently overwritten, which for `NODE_OPTIONS` can mean losing a flag the app needs to boot.\n   *\n   * @default - the loader variable is set to the Odigos value alone\n   */\n  readonly existingLoaderValue?: string;\n\n  /**\n   * Write `ODIGOS_MANAGED`, the marker that makes the Odigos connector recognise this function as\n   * instrumented.\n   *\n   * WITHOUT IT THE FUNCTION IS REPORTED AS UNINSTRUMENTED. The connector derives ownership from this\n   * variable alone: no marker means `Absent` — \"awaiting your deployment\" — even though the layer is\n   * attached, the wrapper is set and the collector is configured. Set this to `true` for a function that\n   * Odigos discovers in MANUAL (IaC) mode, which is the mode a workload is in unless you explicitly hand\n   * instrumentation to the connector.\n   *\n   * Leave it `false` (the default) for a function you have enabled as an AUTOMATIC-mode connector source.\n   * There, the connector instruments the function itself and owns this variable, including the `prevEnv`\n   * snapshot it restores on rollback; two writers of one ownership record is the one combination that\n   * genuinely misbehaves.\n   *\n   * The marker records the exact layer ARN this construct attached, which is also what the connector reads\n   * back to decide which layer version the function is supposed to carry — so a version you pinned is\n   * respected rather than reported as drift. It works in every layer mode, including `IN_ACCOUNT`, where the\n   * ARN is a deploy-time reference your own code cannot obtain.\n   *\n   * @default false\n   */\n  readonly recordOwnershipMarker?: boolean;\n\n  /**\n   * Skip functions whose runtime has no OpenTelemetry Lambda layer instead of throwing.\n   *\n   * `dotnet*` and `provided.*` (Go, custom runtimes) have no language layer upstream. Explicitly\n   * instrumenting one is a mistake worth failing on; sweeping a whole stack with the aspect and hitting\n   * one is not, which is why the aspect defaults this to `true` and the construct to `false`.\n   *\n   * @default false\n   */\n  readonly skipUnsupportedRuntimes?: boolean;\n}\n\n/**\n * Props for {@link OdigosLambdaInstrumentation}.\n */\nexport interface OdigosLambdaInstrumentationProps extends OdigosInstrumentationOptions {\n  /**\n   * Functions to instrument on construction. More can be added with `instrument()`.\n   *\n   * @default - none\n   */\n  readonly functions?: lambda.Function[];\n}\n\n/**\n * Instruments AWS Lambda functions with the Odigos OpenTelemetry layer.\n *\n * ```ts\n * const odigos = new OdigosLambdaInstrumentation(this, 'Odigos', {\n *   destination: { endpoint: 'otlp.example.com:4317' },\n *   functions: [apiFn, workerFn],\n * });\n * odigos.instrument(anotherFn);\n * ```\n *\n * What it does to each function: attaches the layer for the function's language and architecture, sets\n * `AWS_LAMBDA_EXEC_WRAPPER` so the layer loads the SDK, sets `OTEL_SERVICE_NAME`, and hands the in-Lambda\n * collector its entire configuration inline through `OPENTELEMETRY_COLLECTOR_CONFIG_URI`.\n *\n * The function's SDK exports to the collector on localhost, not to your destination. The collector\n * forwards after the handler has already returned, so a slow destination costs billed duration rather\n * than caller latency.\n *\n * ## Do not also instrument these functions with the connector\n *\n * The Odigos AWS connector instruments live functions by mutating them, and reconciles them back to its\n * own desired state on every pass. A function instrumented here and also enabled as a connector source\n * ends up owned by both: each `cdk deploy` reasserts the CDK's environment, each reconcile reasserts the\n * connector's, and every round trip publishes a new function version.\n *\n * Choose one per function. This construct never sets the connector's `ODIGOS_MANAGED` ownership marker,\n * so an IaC-instrumented function is not one the connector will roll back — but it will happily take it\n * over if you enable it as a source.\n */\nexport class OdigosLambdaInstrumentation extends Construct {\n  private readonly options: OdigosInstrumentationOptions;\n  private readonly resolver: OdigosLayerResolver;\n  private readonly collectorConfig: string;\n  private readonly instrumented = new Set<string>();\n\n  constructor(scope: Construct, id: string, props: OdigosLambdaInstrumentationProps) {\n    super(scope, id);\n\n    this.options = props;\n    this.resolver = new OdigosLayerResolver(this, props.layerSource ?? OdigosLayerSource.ODIGOS_PUBLIC);\n\n    // Rendered once. It depends only on the destination, and rendering it per function would make an\n    // accidental difference between two functions possible.\n    this.collectorConfig = renderCollectorConfig(props.destination);\n\n    // A warning rather than an error, because a collector CAN be reached over gRPC on a non-standard port —\n    // but the overwhelmingly likelier reading of `endpoint: \"host:4318\"` is an OTLP/HTTP endpoint passed to\n    // the gRPC exporter, which builds, starts, and then never delivers a batch. Silent for the caller who\n    // meant it; loud for the one who did not.\n    if (props.destination.endpoint?.endsWith(':4318')) {\n      Annotations.of(this).addWarningV2(\n        '@odigos/aws-cdk:probableHttpEndpoint',\n        `Odigos: destination endpoint \"${props.destination.endpoint}\" is on 4318, the OTLP/HTTP port, but ` +\n          '`endpoint` configures the gRPC exporter (conventionally 4317). If that is an OTLP/HTTP collector, ' +\n          'pass it as `httpEndpoint: \"http://host:4318\"` instead — the gRPC exporter will export nothing to it.',\n      );\n    }\n    if (props.destination.httpEndpoint?.endsWith(':4317')) {\n      Annotations.of(this).addWarningV2(\n        '@odigos/aws-cdk:probableGrpcEndpoint',\n        `Odigos: destination httpEndpoint \"${props.destination.httpEndpoint}\" is on 4317, the OTLP/gRPC port, ` +\n          'but `httpEndpoint` configures the HTTP exporter (conventionally 4318). If that is a gRPC collector, ' +\n          'pass it as `endpoint: \"host:4317\"` instead.',\n      );\n    }\n\n    for (const fn of props.functions ?? []) {\n      this.instrument(fn);\n    }\n  }\n\n  /**\n   * Instruments one function. Idempotent — instrumenting the same function twice is a no-op rather than a\n   * doubled loader value.\n   */\n  public instrument(fn: lambda.Function): void {\n    const key = fn.node.path;\n    if (this.instrumented.has(key)) {\n      return;\n    }\n\n    const runtimeName = fn.runtime.name;\n    const language = languageFromRuntime(runtimeName);\n    if (!language) {\n      const message =\n        `Odigos: runtime \"${runtimeName}\" has no OpenTelemetry Lambda layer ` +\n        '(upstream publishes layers for python, nodejs, java and ruby only), so this function cannot be instrumented.';\n      if (this.options.skipUnsupportedRuntimes) {\n        Annotations.of(fn).addWarningV2('@odigos/aws-cdk:unsupportedRuntime', `${message} Skipping.`);\n        return;\n      }\n      throw new Error(`${message} Set skipUnsupportedRuntimes: true to skip it instead.`);\n    }\n\n    this.instrumented.add(key);\n\n    const architecture = fn.architecture.name;\n    const layer = this.options.layerVersion ?? this.resolver.resolve(language, architecture);\n    fn.addLayers(layer);\n\n    // The ARN, not the construct: the marker has to name the exact layer version the function carries, and\n    // in IN_ACCOUNT mode that is a nested-stack output reference resolved at deploy time.\n    for (const [name, value] of Object.entries(this.environmentFor(fn, language, layer.layerVersionArn))) {\n      fn.addEnvironment(name, value);\n    }\n  }\n\n  /** Instruments every function in the list. */\n  public instrumentAll(functions: lambda.Function[]): void {\n    for (const fn of functions) {\n      this.instrument(fn);\n    }\n  }\n\n  /**\n   * The environment applied to one function.\n   *\n   * Mirrors `applyHandlerEnv` / `applyWebServerEnv` in the connector, including what is deliberately NOT\n   * set: `OTEL_EXPORTER_OTLP_ENDPOINT` stays unset so the SDK keeps exporting to the in-Lambda collector\n   * on localhost rather than blocking the invocation on the remote destination, and an enabled signal's\n   * `OTEL_*_EXPORTER` stays unset because `otlp` is already the SDK default.\n   */\n  private environmentFor(fn: lambda.Function, language: string, layerArn: string): { [key: string]: string } {\n    const { destination, mode, debug, serviceName, javaHandlerDistro, existingLoaderValue } = this.options;\n    const webServer = mode === OdigosInstrumentationMode.WEB_SERVER;\n\n    const env: { [key: string]: string } = {\n      [ENV_SERVICE_NAME]: serviceName ?? defaultServiceName(fn),\n      [ENV_COLLECTOR_CONFIG_URI]: this.collectorConfig,\n      [ENV_IAC_MARKER]: JSON.stringify({ v: 1, source: 'cdk', version: ODIGOS_VERSION || 'unreleased' }),\n    };\n\n    if (webServer) {\n      // No exec wrapper: the Lambda Web Adapter owns it, and overwriting it stops the function serving.\n      Object.assign(env, webServerEnv(language, existingLoaderValue));\n    } else {\n      env[ENV_EXEC_WRAPPER] = execWrapperFor(language, javaHandlerDistro);\n      if (debug) {\n        env[ENV_OTEL_LOG_LEVEL] = 'debug';\n      }\n    }\n\n    // Suppress the signals the destination does not accept. A signal with no collector pipeline is refused\n    // at the receiver on every batch, so telling the SDK not to produce it is the half that stops the\n    // error loop; the pipeline being absent is the half that stops the export.\n    const overrides: Array<[string, string | undefined]> = [\n      [ENV_TRACES_EXPORTER, exporterOverrideFor(signalEnabled(destination.traces))],\n      [ENV_METRICS_EXPORTER, exporterOverrideFor(signalEnabled(destination.metrics))],\n      [ENV_LOGS_EXPORTER, exporterOverrideFor(signalEnabled(destination.logs))],\n    ];\n    for (const [name, value] of overrides) {\n      if (value !== undefined) {\n        env[name] = value;\n      }\n    }\n\n    // LAST, because the marker's snapshot describes the keys above: it is built from what this function is\n    // actually getting, not from a fixed list.\n    if (this.options.recordOwnershipMarker) {\n      env[ENV_ODIGOS_MANAGED] = this.ownershipMarker(env, layerArn, language, webServer);\n    }\n\n    return env;\n  }\n\n  /**\n   * The `ODIGOS_MANAGED` payload: the layer this function carries, plus the snapshot the connector restores\n   * from if it ever rolls the function back.\n   *\n   * WHY `prevEnv` IS NOT OPTIONAL HERE. The connector's rollback iterates exactly this map — a null entry\n   * means \"delete on rollback\", a string means \"restore this value verbatim\" — and then removes the recorded\n   * layer. A marker without it would therefore strip the LAYER while leaving `AWS_LAMBDA_EXEC_WRAPPER`\n   * pointing at `/opt/otel-handler`, a script that is no longer mounted: the function then fails at its next\n   * cold start. Recording every key this construct sets makes rollback strip the whole set together.\n   *\n   * The values are null rather than the customer's prior values because a CDK stack cannot read an\n   * environment variable back — with one exception that matters, the web-server loader variable, whose prior\n   * value the caller has already had to pass as `existingLoaderValue` for exactly the same reason.\n   */\n  private ownershipMarker(\n    env: { [key: string]: string },\n    layerArn: string,\n    language: string,\n    webServer: boolean,\n  ): string {\n    const prevEnv: { [key: string]: string | null } = {};\n    for (const name of Object.keys(env)) {\n      // Not itself, and not the informational IaC marker: rollback deletes ODIGOS_MANAGED unconditionally,\n      // and ODIGOS_IAC records where the function came from, which stays true after an uninstrument.\n      if (name !== ENV_IAC_MARKER) {\n        prevEnv[name] = null;\n      }\n    }\n    const loaderKey = webServer ? webServerLoaderKey(language) : undefined;\n    if (loaderKey !== undefined) {\n      // Restore the caller's own loader value rather than deleting the variable: ours was appended to it, so\n      // deleting the key would take the customer's flags — the ones their app needs to boot — with it.\n      prevEnv[loaderKey] = this.options.existingLoaderValue ?? null;\n    }\n    return JSON.stringify({ v: MARKER_VERSION, layer: layerArn, prevEnv });\n  }\n}\n\n/**\n * Props for {@link OdigosInstrumentationAspect}.\n */\nexport interface OdigosInstrumentationAspectProps extends OdigosInstrumentationOptions {}\n\n/**\n * Applies Odigos instrumentation to every `lambda.Function` in a scope.\n *\n * ```ts\n * Aspects.of(stack).add(new OdigosInstrumentationAspect(stack, {\n *   destination: { endpoint: 'otlp.example.com:4317' },\n * }));\n * ```\n *\n * `skipUnsupportedRuntimes` defaults to `true` here, unlike the construct: an aspect visits every function\n * in the scope, including ones whose runtime has no OpenTelemetry layer, and failing the whole synth\n * because a stack happens to contain one Go function is not useful. Each skip is reported as a synth\n * warning, so it is visible rather than silent.\n *\n * The aspect instruments what exists in the tree when it runs. A function added by a later aspect is not\n * visited; use the construct directly for those.\n */\nexport class OdigosInstrumentationAspect implements IAspect {\n  private readonly instrumentation: OdigosLambdaInstrumentation;\n\n  /**\n   * @param scope where the shared layer constructs are created. Usually the same scope the aspect is\n   * applied to. It is a separate argument from the visited nodes because the layer (and, in `IN_ACCOUNT`\n   * mode, the nested SAR application) is created once and shared by every function the aspect visits.\n   */\n  constructor(scope: Construct, props: OdigosInstrumentationAspectProps) {\n    this.instrumentation = new OdigosLambdaInstrumentation(scope, 'OdigosInstrumentationAspect', {\n      skipUnsupportedRuntimes: true,\n      ...props,\n    });\n  }\n\n  public visit(node: IConstruct): void {\n    if (node instanceof lambda.Function) {\n      this.instrumentation.instrument(node);\n    }\n  }\n}\n"]}

package/lib/runtime.d.ts

@@ -32,6 +32,15 @@ export interface EnvVars {
  * `addLoaderValue` in the connector.
  */
 export declare function addLoaderValue(existing: string | undefined, value: string, separator: string): string;
+/**
+ * The loader variable a language activates through in web-server mode (`NODE_OPTIONS`,
+ * `JAVA_TOOL_OPTIONS`, `PYTHONPATH`), or undefined for a language with no verified web-server loader.
+ *
+ * Exists so a caller that needs to name the variable — the ownership marker's rollback snapshot, which has
+ * to record the caller's own prior value for it — does not have to guess it from the key order of
+ * `webServerEnv`.
+ */
+export declare function webServerLoaderKey(language: string): string | undefined;
 /**
  * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.
  *

package/lib/runtime.js

@@ -4,6 +4,7 @@ exports.languageFromRuntime = languageFromRuntime;
 exports.execWrapperFor = execWrapperFor;
 exports.layerNameFor = layerNameFor;
 exports.addLoaderValue = addLoaderValue;
+exports.webServerLoaderKey = webServerLoaderKey;
 exports.webServerEnv = webServerEnv;
 const layers_1 = require("./generated/layers");
 const types_1 = require("./types");
@@ -87,6 +88,17 @@ function addLoaderValue(existing, value, separator) {
     }
     return separator === ':' ? `${value}${separator}${existing}` : `${existing}${separator}${value}`;
 }
+/**
+ * The loader variable a language activates through in web-server mode (`NODE_OPTIONS`,
+ * `JAVA_TOOL_OPTIONS`, `PYTHONPATH`), or undefined for a language with no verified web-server loader.
+ *
+ * Exists so a caller that needs to name the variable — the ownership marker's rollback snapshot, which has
+ * to record the caller's own prior value for it — does not have to guess it from the key order of
+ * `webServerEnv`.
+ */
+function webServerLoaderKey(language) {
+    return layers_1.LANGUAGES[language]?.webServer?.envKey;
+}
 /**
  * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.
  *
@@ -116,4 +128,4 @@ function webServerEnv(language, existingLoaderValue) {
     }
     return env;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { LANGUAGES } from './generated/layers';\nimport { OdigosInstrumentationMode, OdigosJavaHandlerDistro } from './types';\n\n/**\n * Runtime -> language, and language -> the exact env the layer expects.\n *\n * Mirrors `LanguageFromRuntime`, `execWrapperForLanguage` and `webServerLoader` in the connector's\n * instrumentor. The data lives in ../../artifacts.json and reaches here through the generated module; the\n * decisions live here.\n */\n\n/** Runtime prefixes that map to an OTel layer language. Prefix-matched, so `java8.al2` resolves to java. */\nconst LANGUAGE_PREFIXES: Array<[string, string]> = [\n  ['python', 'python'],\n  ['nodejs', 'nodejs'],\n  ['java', 'java'],\n  ['ruby', 'ruby'],\n];\n\n/**\n * Resolves a Lambda runtime identifier (`python3.12`, `java21`, `nodejs22.x`) to the OTel layer language.\n *\n * Returns `undefined` for runtimes with no OpenTelemetry Lambda language layer — `dotnet*`, `provided.*`\n * (Go and custom runtimes). The caller refuses to instrument rather than attaching a layer that does\n * nothing, because a layer plus an exec wrapper that does not exist in it fails the function at cold start.\n */\nexport function languageFromRuntime(runtimeName: string): string | undefined {\n  for (const [prefix, language] of LANGUAGE_PREFIXES) {\n    if (runtimeName.startsWith(prefix)) {\n      return language;\n    }\n  }\n  return undefined;\n}\n\n/** Maps the Java distro enum to the wrapper script path the layer ships. */\nconst JAVA_DISTRO_WRAPPERS: { [key: string]: string } = {\n  [OdigosJavaHandlerDistro.OTEL_HANDLER]: '/opt/otel-handler',\n  [OdigosJavaHandlerDistro.OTEL_PROXY_HANDLER]: '/opt/otel-proxy-handler',\n  [OdigosJavaHandlerDistro.OTEL_SQS_HANDLER]: '/opt/otel-sqs-handler',\n  [OdigosJavaHandlerDistro.OTEL_STREAM_HANDLER]: '/opt/otel-stream-handler',\n};\n\n/**\n * The `AWS_LAMBDA_EXEC_WRAPPER` value for a language.\n *\n * The wrapper script is LANGUAGE-SPECIFIC: Python ships `/opt/otel-instrument`; Node.js, Java and Ruby\n * ship `/opt/otel-handler`. Setting the wrong one makes the layer bootstrap fail at cold start with\n * `/opt/otel-instrument: does not exist` and the function errors out — which is why this is never a\n * hardcoded constant at a call site.\n *\n * `distro` is only consulted for Java, whose layer ships four wrappers, one per handler interface.\n */\nexport function execWrapperFor(language: string, distro?: OdigosJavaHandlerDistro): string {\n  if (language === 'java') {\n    return JAVA_DISTRO_WRAPPERS[distro ?? OdigosJavaHandlerDistro.OTEL_HANDLER];\n  }\n  const spec = LANGUAGES[language];\n  if (!spec) {\n    throw new Error(`Odigos: no OpenTelemetry Lambda layer for language \"${language}\"`);\n  }\n  return spec.execWrapper;\n}\n\n/** Layer name for a language/architecture — `odigos-otel-python-arm64`. */\nexport function layerNameFor(language: string, architecture: string): string {\n  const spec = LANGUAGES[language];\n  if (!spec) {\n    throw new Error(`Odigos: unknown language \"${language}\"`);\n  }\n  return `${spec.layerName}-${architecture}`;\n}\n\n/** Environment variables to set on a function, as a plain map. */\nexport interface EnvVars {\n  readonly [key: string]: string;\n}\n\n/**\n * Idempotently adds our loader value to a value the function already carries.\n *\n * `PYTHONPATH` is PREPENDED, so the layer's packages and its `sitecustomize` are found first; the\n * `*_OPTIONS` variables are appended, so the customer's own flags keep precedence. Mirrors\n * `addLoaderValue` in the connector.\n */\nexport function addLoaderValue(existing: string | undefined, value: string, separator: string): string {\n  if (!existing) {\n    return value;\n  }\n  if (existing.includes(value)) {\n    return existing;\n  }\n  return separator === ':' ? `${value}${separator}${existing}` : `${existing}${separator}${value}`;\n}\n\n/**\n * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.\n *\n * Web-adapter functions run a web server rather than a Lambda handler, and the adapter owns\n * `AWS_LAMBDA_EXEC_WRAPPER` — so instrumentation is loaded through the language's own loader variable and\n * the wrapper is left alone. Handler-mode instrumentation applied to one of these overwrites the\n * adapter's wrapper and the function stops serving.\n *\n * @param existingLoaderValue the value the function already needs in its loader variable, which ours is\n * joined to. CDK's `lambda.Function` exposes no way to read back an environment variable set elsewhere in\n * the app, so a value that must be preserved has to be passed in explicitly.\n */\nexport function webServerEnv(\n  language: string,\n  existingLoaderValue?: string,\n): { [key: string]: string } {\n  const spec = LANGUAGES[language];\n  const loader = spec?.webServer;\n  if (!loader) {\n    throw new Error(\n      `Odigos: ${OdigosInstrumentationMode.WEB_SERVER} mode is not supported for ${language} — ` +\n        'there is no verified web-server loader for it. Use HANDLER mode, or leave the function uninstrumented.',\n    );\n  }\n  const env: { [key: string]: string } = {\n    [loader.envKey]: addLoaderValue(existingLoaderValue, loader.value, loader.separator),\n  };\n  // Python must be pinned to the HTTP OTLP exporter — the only one bundled in its layer. Other languages\n  // export correctly with their defaults, so nothing extra is written for them.\n  for (const [k, v] of Object.entries(loader.extraEnv)) {\n    env[k] = v;\n  }\n  return env;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { LANGUAGES } from './generated/layers';\nimport { OdigosInstrumentationMode, OdigosJavaHandlerDistro } from './types';\n\n/**\n * Runtime -> language, and language -> the exact env the layer expects.\n *\n * Mirrors `LanguageFromRuntime`, `execWrapperForLanguage` and `webServerLoader` in the connector's\n * instrumentor. The data lives in ../../artifacts.json and reaches here through the generated module; the\n * decisions live here.\n */\n\n/** Runtime prefixes that map to an OTel layer language. Prefix-matched, so `java8.al2` resolves to java. */\nconst LANGUAGE_PREFIXES: Array<[string, string]> = [\n  ['python', 'python'],\n  ['nodejs', 'nodejs'],\n  ['java', 'java'],\n  ['ruby', 'ruby'],\n];\n\n/**\n * Resolves a Lambda runtime identifier (`python3.12`, `java21`, `nodejs22.x`) to the OTel layer language.\n *\n * Returns `undefined` for runtimes with no OpenTelemetry Lambda language layer — `dotnet*`, `provided.*`\n * (Go and custom runtimes). The caller refuses to instrument rather than attaching a layer that does\n * nothing, because a layer plus an exec wrapper that does not exist in it fails the function at cold start.\n */\nexport function languageFromRuntime(runtimeName: string): string | undefined {\n  for (const [prefix, language] of LANGUAGE_PREFIXES) {\n    if (runtimeName.startsWith(prefix)) {\n      return language;\n    }\n  }\n  return undefined;\n}\n\n/** Maps the Java distro enum to the wrapper script path the layer ships. */\nconst JAVA_DISTRO_WRAPPERS: { [key: string]: string } = {\n  [OdigosJavaHandlerDistro.OTEL_HANDLER]: '/opt/otel-handler',\n  [OdigosJavaHandlerDistro.OTEL_PROXY_HANDLER]: '/opt/otel-proxy-handler',\n  [OdigosJavaHandlerDistro.OTEL_SQS_HANDLER]: '/opt/otel-sqs-handler',\n  [OdigosJavaHandlerDistro.OTEL_STREAM_HANDLER]: '/opt/otel-stream-handler',\n};\n\n/**\n * The `AWS_LAMBDA_EXEC_WRAPPER` value for a language.\n *\n * The wrapper script is LANGUAGE-SPECIFIC: Python ships `/opt/otel-instrument`; Node.js, Java and Ruby\n * ship `/opt/otel-handler`. Setting the wrong one makes the layer bootstrap fail at cold start with\n * `/opt/otel-instrument: does not exist` and the function errors out — which is why this is never a\n * hardcoded constant at a call site.\n *\n * `distro` is only consulted for Java, whose layer ships four wrappers, one per handler interface.\n */\nexport function execWrapperFor(language: string, distro?: OdigosJavaHandlerDistro): string {\n  if (language === 'java') {\n    return JAVA_DISTRO_WRAPPERS[distro ?? OdigosJavaHandlerDistro.OTEL_HANDLER];\n  }\n  const spec = LANGUAGES[language];\n  if (!spec) {\n    throw new Error(`Odigos: no OpenTelemetry Lambda layer for language \"${language}\"`);\n  }\n  return spec.execWrapper;\n}\n\n/** Layer name for a language/architecture — `odigos-otel-python-arm64`. */\nexport function layerNameFor(language: string, architecture: string): string {\n  const spec = LANGUAGES[language];\n  if (!spec) {\n    throw new Error(`Odigos: unknown language \"${language}\"`);\n  }\n  return `${spec.layerName}-${architecture}`;\n}\n\n/** Environment variables to set on a function, as a plain map. */\nexport interface EnvVars {\n  readonly [key: string]: string;\n}\n\n/**\n * Idempotently adds our loader value to a value the function already carries.\n *\n * `PYTHONPATH` is PREPENDED, so the layer's packages and its `sitecustomize` are found first; the\n * `*_OPTIONS` variables are appended, so the customer's own flags keep precedence. Mirrors\n * `addLoaderValue` in the connector.\n */\nexport function addLoaderValue(existing: string | undefined, value: string, separator: string): string {\n  if (!existing) {\n    return value;\n  }\n  if (existing.includes(value)) {\n    return existing;\n  }\n  return separator === ':' ? `${value}${separator}${existing}` : `${existing}${separator}${value}`;\n}\n\n/**\n * The loader variable a language activates through in web-server mode (`NODE_OPTIONS`,\n * `JAVA_TOOL_OPTIONS`, `PYTHONPATH`), or undefined for a language with no verified web-server loader.\n *\n * Exists so a caller that needs to name the variable — the ownership marker's rollback snapshot, which has\n * to record the caller's own prior value for it — does not have to guess it from the key order of\n * `webServerEnv`.\n */\nexport function webServerLoaderKey(language: string): string | undefined {\n  return LANGUAGES[language]?.webServer?.envKey;\n}\n\n/**\n * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.\n *\n * Web-adapter functions run a web server rather than a Lambda handler, and the adapter owns\n * `AWS_LAMBDA_EXEC_WRAPPER` — so instrumentation is loaded through the language's own loader variable and\n * the wrapper is left alone. Handler-mode instrumentation applied to one of these overwrites the\n * adapter's wrapper and the function stops serving.\n *\n * @param existingLoaderValue the value the function already needs in its loader variable, which ours is\n * joined to. CDK's `lambda.Function` exposes no way to read back an environment variable set elsewhere in\n * the app, so a value that must be preserved has to be passed in explicitly.\n */\nexport function webServerEnv(\n  language: string,\n  existingLoaderValue?: string,\n): { [key: string]: string } {\n  const spec = LANGUAGES[language];\n  const loader = spec?.webServer;\n  if (!loader) {\n    throw new Error(\n      `Odigos: ${OdigosInstrumentationMode.WEB_SERVER} mode is not supported for ${language} — ` +\n        'there is no verified web-server loader for it. Use HANDLER mode, or leave the function uninstrumented.',\n    );\n  }\n  const env: { [key: string]: string } = {\n    [loader.envKey]: addLoaderValue(existingLoaderValue, loader.value, loader.separator),\n  };\n  // Python must be pinned to the HTTP OTLP exporter — the only one bundled in its layer. Other languages\n  // export correctly with their defaults, so nothing extra is written for them.\n  for (const [k, v] of Object.entries(loader.extraEnv)) {\n    env[k] = v;\n  }\n  return env;\n}\n"]}