@odigos/aws-cdk 0.0.0

package/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAR_SEMANTIC_VERSION = exports.SAR_APPLICATIONS = exports.LAYER_ARNS = exports.ODIGOS_VERSION = exports.ENV_LOGS_EXPORTER = exports.ENV_METRICS_EXPORTER = exports.ENV_TRACES_EXPORTER = exports.ENV_COLLECTOR_CONFIG_URI = exports.renderCollectorConfig = exports.layerNameFor = exports.execWrapperFor = exports.languageFromRuntime = exports.odigosLayerName = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./instrumentation"), exports);
+var layer_resolver_1 = require("./layer-resolver");
+Object.defineProperty(exports, "odigosLayerName", { enumerable: true, get: function () { return layer_resolver_1.odigosLayerName; } });
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "languageFromRuntime", { enumerable: true, get: function () { return runtime_1.languageFromRuntime; } });
+Object.defineProperty(exports, "execWrapperFor", { enumerable: true, get: function () { return runtime_1.execWrapperFor; } });
+Object.defineProperty(exports, "layerNameFor", { enumerable: true, get: function () { return runtime_1.layerNameFor; } });
+var collector_config_1 = require("./collector-config");
+Object.defineProperty(exports, "renderCollectorConfig", { enumerable: true, get: function () { return collector_config_1.renderCollectorConfig; } });
+Object.defineProperty(exports, "ENV_COLLECTOR_CONFIG_URI", { enumerable: true, get: function () { return collector_config_1.ENV_COLLECTOR_CONFIG_URI; } });
+Object.defineProperty(exports, "ENV_TRACES_EXPORTER", { enumerable: true, get: function () { return collector_config_1.ENV_TRACES_EXPORTER; } });
+Object.defineProperty(exports, "ENV_METRICS_EXPORTER", { enumerable: true, get: function () { return collector_config_1.ENV_METRICS_EXPORTER; } });
+Object.defineProperty(exports, "ENV_LOGS_EXPORTER", { enumerable: true, get: function () { return collector_config_1.ENV_LOGS_EXPORTER; } });
+var layers_1 = require("./generated/layers");
+Object.defineProperty(exports, "ODIGOS_VERSION", { enumerable: true, get: function () { return layers_1.ODIGOS_VERSION; } });
+Object.defineProperty(exports, "LAYER_ARNS", { enumerable: true, get: function () { return layers_1.LAYER_ARNS; } });
+Object.defineProperty(exports, "SAR_APPLICATIONS", { enumerable: true, get: function () { return layers_1.SAR_APPLICATIONS; } });
+Object.defineProperty(exports, "SAR_SEMANTIC_VERSION", { enumerable: true, get: function () { return layers_1.SAR_SEMANTIC_VERSION; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsb0RBQWtDO0FBQ2xDLG1EQUFtRDtBQUExQyxpSEFBQSxlQUFlLE9BQUE7QUFDeEIscUNBQThFO0FBQXJFLDhHQUFBLG1CQUFtQixPQUFBO0FBQUUseUdBQUEsY0FBYyxPQUFBO0FBQUUsdUdBQUEsWUFBWSxPQUFBO0FBQzFELHVEQU00QjtBQUwxQix5SEFBQSxxQkFBcUIsT0FBQTtBQUNyQiw0SEFBQSx3QkFBd0IsT0FBQTtBQUN4Qix1SEFBQSxtQkFBbUIsT0FBQTtBQUNuQix3SEFBQSxvQkFBb0IsT0FBQTtBQUNwQixxSEFBQSxpQkFBaUIsT0FBQTtBQUVuQiw2Q0FBd0c7QUFBL0Ysd0dBQUEsY0FBYyxPQUFBO0FBQUUsb0dBQUEsVUFBVSxPQUFBO0FBQUUsMEdBQUEsZ0JBQWdCLE9BQUE7QUFBRSw4R0FBQSxvQkFBb0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnN0cnVtZW50YXRpb24nO1xuZXhwb3J0IHsgb2RpZ29zTGF5ZXJOYW1lIH0gZnJvbSAnLi9sYXllci1yZXNvbHZlcic7XG5leHBvcnQgeyBsYW5ndWFnZUZyb21SdW50aW1lLCBleGVjV3JhcHBlckZvciwgbGF5ZXJOYW1lRm9yIH0gZnJvbSAnLi9ydW50aW1lJztcbmV4cG9ydCB7XG4gIHJlbmRlckNvbGxlY3RvckNvbmZpZyxcbiAgRU5WX0NPTExFQ1RPUl9DT05GSUdfVVJJLFxuICBFTlZfVFJBQ0VTX0VYUE9SVEVSLFxuICBFTlZfTUVUUklDU19FWFBPUlRFUixcbiAgRU5WX0xPR1NfRVhQT1JURVIsXG59IGZyb20gJy4vY29sbGVjdG9yLWNvbmZpZyc7XG5leHBvcnQgeyBPRElHT1NfVkVSU0lPTiwgTEFZRVJfQVJOUywgU0FSX0FQUExJQ0FUSU9OUywgU0FSX1NFTUFOVElDX1ZFUlNJT04gfSBmcm9tICcuL2dlbmVyYXRlZC9sYXllcnMnO1xuIl19

package/lib/instrumentation.d.ts

@@ -0,0 +1,186 @@
+import { IAspect } from 'aws-cdk-lib';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct, IConstruct } from 'constructs';
+import { OdigosDestination, OdigosInstrumentationMode, OdigosJavaHandlerDistro, OdigosLayerSource } from './types';
+/**
+ * Options shared by the construct and the aspect.
+ */
+export interface OdigosInstrumentationOptions {
+    /**
+     * Where the in-Lambda collector exports to.
+     */
+    readonly destination: OdigosDestination;
+    /**
+     * Where the Odigos layer comes from.
+     *
+     * @default OdigosLayerSource.ODIGOS_PUBLIC
+     */
+    readonly layerSource?: OdigosLayerSource;
+    /**
+     * Handler mode or web-server (Lambda Web Adapter) mode.
+     *
+     * There is no auto-detection, and that is deliberate rather than an omission: detecting the web adapter
+     * means inspecting the function's other layers, which at synth time are frequently unresolved tokens.
+     * A detector that is right most of the time would silently break the functions it got wrong.
+     *
+     * @default OdigosInstrumentationMode.HANDLER
+     */
+    readonly mode?: OdigosInstrumentationMode;
+    /**
+     * Which of the Java layer's four wrapper scripts to use. Ignored for other languages.
+     *
+     * @default OdigosJavaHandlerDistro.OTEL_HANDLER
+     */
+    readonly javaHandlerDistro?: OdigosJavaHandlerDistro;
+    /**
+     * `OTEL_SERVICE_NAME` for every function this instruments.
+     *
+     * Usually wrong to set when instrumenting more than one function — they would all report as the same
+     * service.
+     *
+     * Left unset, a function reports as its explicitly-set physical name if it has one, and otherwise as
+     * its construct id. It deliberately does not default to the generated physical name: that value is a
+     * `Ref` to the function itself, and a function referencing itself in its own environment is a
+     * CloudFormation dependency cycle.
+     *
+     * @default - the function's physical name if explicitly set, otherwise its construct id
+     */
+    readonly serviceName?: string;
+    /**
+     * Raise in-function OpenTelemetry verbosity (`OTEL_LOG_LEVEL=debug`).
+     *
+     * The layer, SDK and collector then emit span and OTLP-export diagnostics into the function's CloudWatch
+     * log group. Useful while wiring up a destination, expensive to leave on.
+     *
+     * Has no effect in web-server mode, matching the connector, which never sets a log level there.
+     *
+     * @default false
+     */
+    readonly debug?: boolean;
+    /**
+     * Attach this layer instead of resolving one. Overrides `layerSource` entirely.
+     *
+     * The escape hatch for a layer mirrored into a private registry or an internal account. The layer must
+     * have the same contents as the Odigos one — the environment set here assumes its exact script layout.
+     *
+     * @default - resolved from layerSource
+     */
+    readonly layerVersion?: lambda.ILayerVersion;
+    /**
+     * The value the function already needs in its language loader variable (`NODE_OPTIONS`,
+     * `JAVA_TOOL_OPTIONS` or `PYTHONPATH`), which the Odigos loader is joined to rather than replacing.
+     *
+     * Only used in web-server mode. It has to be passed explicitly because CDK's `lambda.Function` exposes
+     * no way to read back an environment variable set elsewhere in the app — an omitted value here is
+     * silently overwritten, which for `NODE_OPTIONS` can mean losing a flag the app needs to boot.
+     *
+     * @default - the loader variable is set to the Odigos value alone
+     */
+    readonly existingLoaderValue?: string;
+    /**
+     * Skip functions whose runtime has no OpenTelemetry Lambda layer instead of throwing.
+     *
+     * `dotnet*` and `provided.*` (Go, custom runtimes) have no language layer upstream. Explicitly
+     * instrumenting one is a mistake worth failing on; sweeping a whole stack with the aspect and hitting
+     * one is not, which is why the aspect defaults this to `true` and the construct to `false`.
+     *
+     * @default false
+     */
+    readonly skipUnsupportedRuntimes?: boolean;
+}
+/**
+ * Props for {@link OdigosLambdaInstrumentation}.
+ */
+export interface OdigosLambdaInstrumentationProps extends OdigosInstrumentationOptions {
+    /**
+     * Functions to instrument on construction. More can be added with `instrument()`.
+     *
+     * @default - none
+     */
+    readonly functions?: lambda.Function[];
+}
+/**
+ * Instruments AWS Lambda functions with the Odigos OpenTelemetry layer.
+ *
+ * ```ts
+ * const odigos = new OdigosLambdaInstrumentation(this, 'Odigos', {
+ *   destination: { endpoint: 'otlp.example.com:4317' },
+ *   functions: [apiFn, workerFn],
+ * });
+ * odigos.instrument(anotherFn);
+ * ```
+ *
+ * What it does to each function: attaches the layer for the function's language and architecture, sets
+ * `AWS_LAMBDA_EXEC_WRAPPER` so the layer loads the SDK, sets `OTEL_SERVICE_NAME`, and hands the in-Lambda
+ * collector its entire configuration inline through `OPENTELEMETRY_COLLECTOR_CONFIG_URI`.
+ *
+ * The function's SDK exports to the collector on localhost, not to your destination. The collector
+ * forwards after the handler has already returned, so a slow destination costs billed duration rather
+ * than caller latency.
+ *
+ * ## Do not also instrument these functions with the connector
+ *
+ * The Odigos AWS connector instruments live functions by mutating them, and reconciles them back to its
+ * own desired state on every pass. A function instrumented here and also enabled as a connector source
+ * ends up owned by both: each `cdk deploy` reasserts the CDK's environment, each reconcile reasserts the
+ * connector's, and every round trip publishes a new function version.
+ *
+ * Choose one per function. This construct never sets the connector's `ODIGOS_MANAGED` ownership marker,
+ * so an IaC-instrumented function is not one the connector will roll back — but it will happily take it
+ * over if you enable it as a source.
+ */
+export declare class OdigosLambdaInstrumentation extends Construct {
+    private readonly options;
+    private readonly resolver;
+    private readonly collectorConfig;
+    private readonly instrumented;
+    constructor(scope: Construct, id: string, props: OdigosLambdaInstrumentationProps);
+    /**
+     * Instruments one function. Idempotent — instrumenting the same function twice is a no-op rather than a
+     * doubled loader value.
+     */
+    instrument(fn: lambda.Function): void;
+    /** Instruments every function in the list. */
+    instrumentAll(functions: lambda.Function[]): void;
+    /**
+     * The environment applied to one function.
+     *
+     * Mirrors `applyHandlerEnv` / `applyWebServerEnv` in the connector, including what is deliberately NOT
+     * set: `OTEL_EXPORTER_OTLP_ENDPOINT` stays unset so the SDK keeps exporting to the in-Lambda collector
+     * 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.
+     */
+    private environmentFor;
+}
+/**
+ * Props for {@link OdigosInstrumentationAspect}.
+ */
+export interface OdigosInstrumentationAspectProps extends OdigosInstrumentationOptions {
+}
+/**
+ * Applies Odigos instrumentation to every `lambda.Function` in a scope.
+ *
+ * ```ts
+ * Aspects.of(stack).add(new OdigosInstrumentationAspect(stack, {
+ *   destination: { endpoint: 'otlp.example.com:4317' },
+ * }));
+ * ```
+ *
+ * `skipUnsupportedRuntimes` defaults to `true` here, unlike the construct: an aspect visits every function
+ * in the scope, including ones whose runtime has no OpenTelemetry layer, and failing the whole synth
+ * because a stack happens to contain one Go function is not useful. Each skip is reported as a synth
+ * warning, so it is visible rather than silent.
+ *
+ * The aspect instruments what exists in the tree when it runs. A function added by a later aspect is not
+ * visited; use the construct directly for those.
+ */
+export declare class OdigosInstrumentationAspect implements IAspect {
+    private readonly instrumentation;
+    /**
+     * @param scope where the shared layer constructs are created. Usually the same scope the aspect is
+     * applied to. It is a separate argument from the visited nodes because the layer (and, in `IN_ACCOUNT`
+     * mode, the nested SAR application) is created once and shared by every function the aspect visits.
+     */
+    constructor(scope: Construct, props: OdigosInstrumentationAspectProps);
+    visit(node: IConstruct): void;
+}

package/lib/instrumentation.js

@@ -0,0 +1,212 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdigosInstrumentationAspect = exports.OdigosLambdaInstrumentation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+const collector_config_1 = require("./collector-config");
+const layers_1 = require("./generated/layers");
+const layer_resolver_1 = require("./layer-resolver");
+const runtime_1 = require("./runtime");
+const types_1 = require("./types");
+/** `AWS_LAMBDA_EXEC_WRAPPER` — the layer's entry point in handler mode. */
+const ENV_EXEC_WRAPPER = 'AWS_LAMBDA_EXEC_WRAPPER';
+/** Service name reported on every span, metric and log record. */
+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.
+ *
+ * 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.
+ *
+ * This variable is informational only. Nothing reads it.
+ */
+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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+function defaultServiceName(fn) {
+    const resolved = aws_cdk_lib_1.Stack.of(fn).resolve(fn.functionName);
+    return typeof resolved === 'string' ? resolved : fn.node.id;
+}
+/**
+ * Instruments AWS Lambda functions with the Odigos OpenTelemetry layer.
+ *
+ * ```ts
+ * const odigos = new OdigosLambdaInstrumentation(this, 'Odigos', {
+ *   destination: { endpoint: 'otlp.example.com:4317' },
+ *   functions: [apiFn, workerFn],
+ * });
+ * odigos.instrument(anotherFn);
+ * ```
+ *
+ * What it does to each function: attaches the layer for the function's language and architecture, sets
+ * `AWS_LAMBDA_EXEC_WRAPPER` so the layer loads the SDK, sets `OTEL_SERVICE_NAME`, and hands the in-Lambda
+ * collector its entire configuration inline through `OPENTELEMETRY_COLLECTOR_CONFIG_URI`.
+ *
+ * The function's SDK exports to the collector on localhost, not to your destination. The collector
+ * forwards after the handler has already returned, so a slow destination costs billed duration rather
+ * than caller latency.
+ *
+ * ## Do not also instrument these functions with the connector
+ *
+ * The Odigos AWS connector instruments live functions by mutating them, and reconciles them back to its
+ * own desired state on every pass. A function instrumented here and also enabled as a connector source
+ * ends up owned by both: each `cdk deploy` reasserts the CDK's environment, each reconcile reasserts the
+ * connector's, and every round trip publishes a new function version.
+ *
+ * Choose one per function. This construct never sets the connector's `ODIGOS_MANAGED` ownership marker,
+ * so an IaC-instrumented function is not one the connector will roll back — but it will happily take it
+ * over if you enable it as a source.
+ */
+class OdigosLambdaInstrumentation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.instrumented = new Set();
+        this.options = props;
+        this.resolver = new layer_resolver_1.OdigosLayerResolver(this, props.layerSource ?? types_1.OdigosLayerSource.ODIGOS_PUBLIC);
+        // 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);
+        for (const fn of props.functions ?? []) {
+            this.instrument(fn);
+        }
+    }
+    /**
+     * Instruments one function. Idempotent — instrumenting the same function twice is a no-op rather than a
+     * doubled loader value.
+     */
+    instrument(fn) {
+        const key = fn.node.path;
+        if (this.instrumented.has(key)) {
+            return;
+        }
+        const runtimeName = fn.runtime.name;
+        const language = (0, runtime_1.languageFromRuntime)(runtimeName);
+        if (!language) {
+            const message = `Odigos: runtime "${runtimeName}" has no OpenTelemetry Lambda layer ` +
+                '(upstream publishes layers for python, nodejs, java and ruby only), so this function cannot be instrumented.';
+            if (this.options.skipUnsupportedRuntimes) {
+                aws_cdk_lib_1.Annotations.of(fn).addWarningV2('@odigos/aws-cdk:unsupportedRuntime', `${message} Skipping.`);
+                return;
+            }
+            throw new Error(`${message} Set skipUnsupportedRuntimes: true to skip it instead.`);
+        }
+        this.instrumented.add(key);
+        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))) {
+            fn.addEnvironment(name, value);
+        }
+    }
+    /** Instruments every function in the list. */
+    instrumentAll(functions) {
+        for (const fn of functions) {
+            this.instrument(fn);
+        }
+    }
+    /**
+     * The environment applied to one function.
+     *
+     * Mirrors `applyHandlerEnv` / `applyWebServerEnv` in the connector, including what is deliberately NOT
+     * set: `OTEL_EXPORTER_OTLP_ENDPOINT` stays unset so the SDK keeps exporting to the in-Lambda collector
+     * 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) {
+        const { destination, mode, debug, serviceName, javaHandlerDistro, existingLoaderValue } = this.options;
+        const webServer = mode === types_1.OdigosInstrumentationMode.WEB_SERVER;
+        const env = {
+            [ENV_SERVICE_NAME]: serviceName ?? defaultServiceName(fn),
+            [collector_config_1.ENV_COLLECTOR_CONFIG_URI]: this.collectorConfig,
+            [ENV_IAC_MARKER]: JSON.stringify({ v: 1, source: 'cdk', version: layers_1.ODIGOS_VERSION || 'unreleased' }),
+        };
+        if (webServer) {
+            // No exec wrapper: the Lambda Web Adapter owns it, and overwriting it stops the function serving.
+            Object.assign(env, (0, runtime_1.webServerEnv)(language, existingLoaderValue));
+        }
+        else {
+            env[ENV_EXEC_WRAPPER] = (0, runtime_1.execWrapperFor)(language, javaHandlerDistro);
+            if (debug) {
+                env[ENV_OTEL_LOG_LEVEL] = 'debug';
+            }
+        }
+        // Suppress the signals the destination does not accept. A signal with no collector pipeline is refused
+        // at the receiver on every batch, so telling the SDK not to produce it is the half that stops the
+        // error loop; the pipeline being absent is the half that stops the export.
+        const overrides = [
+            [collector_config_1.ENV_TRACES_EXPORTER, (0, collector_config_1.exporterOverrideFor)((0, collector_config_1.signalEnabled)(destination.traces))],
+            [collector_config_1.ENV_METRICS_EXPORTER, (0, collector_config_1.exporterOverrideFor)((0, collector_config_1.signalEnabled)(destination.metrics))],
+            [collector_config_1.ENV_LOGS_EXPORTER, (0, collector_config_1.exporterOverrideFor)((0, collector_config_1.signalEnabled)(destination.logs))],
+        ];
+        for (const [name, value] of overrides) {
+            if (value !== undefined) {
+                env[name] = value;
+            }
+        }
+        return env;
+    }
+}
+exports.OdigosLambdaInstrumentation = OdigosLambdaInstrumentation;
+_a = JSII_RTTI_SYMBOL_1;
+OdigosLambdaInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosLambdaInstrumentation", version: "0.0.0" };
+/**
+ * Applies Odigos instrumentation to every `lambda.Function` in a scope.
+ *
+ * ```ts
+ * Aspects.of(stack).add(new OdigosInstrumentationAspect(stack, {
+ *   destination: { endpoint: 'otlp.example.com:4317' },
+ * }));
+ * ```
+ *
+ * `skipUnsupportedRuntimes` defaults to `true` here, unlike the construct: an aspect visits every function
+ * in the scope, including ones whose runtime has no OpenTelemetry layer, and failing the whole synth
+ * because a stack happens to contain one Go function is not useful. Each skip is reported as a synth
+ * warning, so it is visible rather than silent.
+ *
+ * The aspect instruments what exists in the tree when it runs. A function added by a later aspect is not
+ * visited; use the construct directly for those.
+ */
+class OdigosInstrumentationAspect {
+    /**
+     * @param scope where the shared layer constructs are created. Usually the same scope the aspect is
+     * applied to. It is a separate argument from the visited nodes because the layer (and, in `IN_ACCOUNT`
+     * mode, the nested SAR application) is created once and shared by every function the aspect visits.
+     */
+    constructor(scope, props) {
+        this.instrumentation = new OdigosLambdaInstrumentation(scope, 'OdigosInstrumentationAspect', {
+            skipUnsupportedRuntimes: true,
+            ...props,
+        });
+    }
+    visit(node) {
+        if (node instanceof lambda.Function) {
+            this.instrumentation.instrument(node);
+        }
+    }
+}
+exports.OdigosInstrumentationAspect = OdigosInstrumentationAspect;
+_b = JSII_RTTI_SYMBOL_1;
+OdigosInstrumentationAspect[_b] = { fqn: "@odigos/aws-cdk.OdigosInstrumentationAspect", version: "0.0.0" };
+//# 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"]}

package/lib/layer-resolver.d.ts

@@ -0,0 +1,46 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+import { OdigosLayerSource } from './types';
+/**
+ * Resolves the Odigos layer for a (language, architecture) to an `ILayerVersion`, and caches it so N
+ * functions of the same language and architecture share one layer construct — and, in `IN_ACCOUNT` mode,
+ * one nested SAR application rather than N copies of the same layer.
+ */
+export declare class OdigosLayerResolver {
+    private readonly scope;
+    private readonly source;
+    private readonly cache;
+    constructor(scope: Construct, source: OdigosLayerSource);
+    resolve(language: string, architecture: string): lambda.ILayerVersion;
+    /**
+     * The public layer version Odigos published in this stack's region, resolved from the table baked into
+     * this package at build time.
+     *
+     * A region with no entry throws rather than falling back to another region's ARN, which would not
+     * resolve, or to no layer, which would leave the function reporting healthy and exporting nothing.
+     */
+    private fromPublicArn;
+    /**
+     * Deploys the Odigos SAR application into this account as a nested stack and attaches the layer it
+     * creates.
+     *
+     * Pinning `semanticVersion` is what makes this reproducible: a SAR application version is immutable, so
+     * the pinned version resolves to the same layer bytes forever. Leaving it unpinned would let a later
+     * `cdk deploy` of unchanged code pick up a different layer.
+     */
+    private fromSar;
+    /** `Python_X8664` — a construct-id-safe suffix that keeps ids stable and readable in the template. */
+    private constructSuffix;
+}
+/**
+ * The layer name this package attaches, exposed so a stack can assert on it or build an allowlist.
+ *
+ * Deliberately identical to the name the connector publishes into an account
+ * (`store.OdigosLayerNamePrefix` + language + "-" + architecture). That is what lets a function
+ * instrumented here and later enabled as a connector source converge: the connector sees the same layer
+ * NAME, swaps its own version in rather than attaching a second OpenTelemetry layer, and recognises the
+ * layer as one it may manage.
+ */
+export declare function odigosLayerName(language: string, architecture: string): string;
+/** Stable, human-readable construct id fragment for a function. Exported for the aspect. */
+export declare function functionScopeId(fn: Construct): string;