@odigos/aws-cdk 0.0.0

package/lib/layer-resolver.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdigosLayerResolver = void 0;
+exports.odigosLayerName = odigosLayerName;
+exports.functionScopeId = functionScopeId;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const sam = require("aws-cdk-lib/aws-sam");
+const layers_1 = require("./generated/layers");
+const runtime_1 = require("./runtime");
+const types_1 = require("./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.
+ */
+class OdigosLayerResolver {
+    constructor(scope, source) {
+        this.scope = scope;
+        this.source = source;
+        this.cache = new Map();
+    }
+    resolve(language, architecture) {
+        const key = `${language}/${architecture}`;
+        const cached = this.cache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const layer = this.source === types_1.OdigosLayerSource.IN_ACCOUNT
+            ? this.fromSar(language, architecture)
+            : this.fromPublicArn(language, architecture);
+        this.cache.set(key, layer);
+        return layer;
+    }
+    /**
+     * 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.
+     */
+    fromPublicArn(language, architecture) {
+        const stack = aws_cdk_lib_1.Stack.of(this.scope);
+        const region = stack.region;
+        // An environment-agnostic stack has a token for its region, so there is no table lookup to do. This
+        // is worth catching explicitly: the alternative message would be about a region literally named
+        // "${Token[AWS.Region.6]}", which sends people looking in the wrong place entirely.
+        if (aws_cdk_lib_1.Token.isUnresolved(region)) {
+            throw new Error('Odigos: OdigosLayerSource.ODIGOS_PUBLIC needs a concrete region to look up the layer ARN, but ' +
+                'this stack is environment-agnostic. Set `env: { region: "..." }` on the stack, or use ' +
+                'OdigosLayerSource.IN_ACCOUNT, which resolves the layer at deploy time and works anywhere.');
+        }
+        const arn = layers_1.LAYER_ARNS[`${region}/${language}/${architecture}`];
+        if (!arn) {
+            const known = new Set(Object.keys(layers_1.LAYER_ARNS).map((k) => k.split('/')[0]));
+            throw new Error(`Odigos: no public ${language}/${architecture} layer published in ${region} ` +
+                `(@odigos/aws-cdk ${layers_1.ODIGOS_VERSION || 'unreleased'}). ` +
+                (known.size === 0
+                    ? 'This build of the package has an empty layer table — it was built before the first release.'
+                    : `Published regions: ${[...known].sort().join(', ')}.`) +
+                ' Use OdigosLayerSource.IN_ACCOUNT to deploy the layer into your own account instead.');
+        }
+        return lambda.LayerVersion.fromLayerVersionArn(this.scope, `OdigosLayer${this.constructSuffix(language, architecture)}`, arn);
+    }
+    /**
+     * 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.
+     */
+    fromSar(language, architecture) {
+        const applicationId = layers_1.SAR_APPLICATIONS[`${language}/${architecture}`];
+        if (!applicationId) {
+            throw new Error(`Odigos: no SAR application published for ${language}/${architecture} ` +
+                `(@odigos/aws-cdk ${layers_1.ODIGOS_VERSION || 'unreleased'}).`);
+        }
+        if (!layers_1.SAR_SEMANTIC_VERSION) {
+            throw new Error('Odigos: this build of @odigos/aws-cdk has no SAR semantic version baked in, so the application ' +
+                'could only be deployed unpinned. Use a released version of the package.');
+        }
+        // CfnApplication is a SAM resource, so the stack needs the Serverless transform. addTransform is
+        // idempotent, so declaring it here is safe whether or not the app already uses SAM elsewhere.
+        aws_cdk_lib_1.Stack.of(this.scope).addTransform('AWS::Serverless-2016-10-31');
+        const suffix = this.constructSuffix(language, architecture);
+        const app = new sam.CfnApplication(this.scope, `OdigosLayerApp${suffix}`, {
+            location: {
+                applicationId,
+                semanticVersion: layers_1.SAR_SEMANTIC_VERSION,
+            },
+        });
+        return lambda.LayerVersion.fromLayerVersionArn(this.scope, `OdigosLayer${suffix}`, app.getAtt('Outputs.LayerVersionArn').toString());
+    }
+    /** `Python_X8664` — a construct-id-safe suffix that keeps ids stable and readable in the template. */
+    constructSuffix(language, architecture) {
+        const titled = language.charAt(0).toUpperCase() + language.slice(1);
+        return `${titled}${architecture.replace(/[^a-zA-Z0-9]/g, '')}`;
+    }
+}
+exports.OdigosLayerResolver = OdigosLayerResolver;
+/**
+ * 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.
+ */
+function odigosLayerName(language, architecture) {
+    return (0, runtime_1.layerNameFor)(language, architecture);
+}
+/** Stable, human-readable construct id fragment for a function. Exported for the aspect. */
+function functionScopeId(fn) {
+    return aws_cdk_lib_1.Names.nodeUniqueId(fn.node);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-resolver.js","sourceRoot":"","sources":["../src/layer-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import { Names, Stack, Token } from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as sam from 'aws-cdk-lib/aws-sam';\nimport { Construct } from 'constructs';\nimport { LAYER_ARNS, ODIGOS_VERSION, SAR_APPLICATIONS, SAR_SEMANTIC_VERSION } from './generated/layers';\nimport { layerNameFor } from './runtime';\nimport { OdigosLayerSource } from './types';\n\n/**\n * Resolves the Odigos layer for a (language, architecture) to an `ILayerVersion`, and caches it so N\n * functions of the same language and architecture share one layer construct — and, in `IN_ACCOUNT` mode,\n * one nested SAR application rather than N copies of the same layer.\n */\nexport class OdigosLayerResolver {\n  private readonly cache = new Map<string, lambda.ILayerVersion>();\n\n  constructor(\n    private readonly scope: Construct,\n    private readonly source: OdigosLayerSource,\n  ) {}\n\n  public resolve(language: string, architecture: string): lambda.ILayerVersion {\n    const key = `${language}/${architecture}`;\n    const cached = this.cache.get(key);\n    if (cached) {\n      return cached;\n    }\n    const layer =\n      this.source === OdigosLayerSource.IN_ACCOUNT\n        ? this.fromSar(language, architecture)\n        : this.fromPublicArn(language, architecture);\n    this.cache.set(key, layer);\n    return layer;\n  }\n\n  /**\n   * The public layer version Odigos published in this stack's region, resolved from the table baked into\n   * this package at build time.\n   *\n   * A region with no entry throws rather than falling back to another region's ARN, which would not\n   * resolve, or to no layer, which would leave the function reporting healthy and exporting nothing.\n   */\n  private fromPublicArn(language: string, architecture: string): lambda.ILayerVersion {\n    const stack = Stack.of(this.scope);\n    const region = stack.region;\n\n    // An environment-agnostic stack has a token for its region, so there is no table lookup to do. This\n    // is worth catching explicitly: the alternative message would be about a region literally named\n    // \"${Token[AWS.Region.6]}\", which sends people looking in the wrong place entirely.\n    if (Token.isUnresolved(region)) {\n      throw new Error(\n        'Odigos: OdigosLayerSource.ODIGOS_PUBLIC needs a concrete region to look up the layer ARN, but ' +\n          'this stack is environment-agnostic. Set `env: { region: \"...\" }` on the stack, or use ' +\n          'OdigosLayerSource.IN_ACCOUNT, which resolves the layer at deploy time and works anywhere.',\n      );\n    }\n\n    const arn = LAYER_ARNS[`${region}/${language}/${architecture}`];\n    if (!arn) {\n      const known = new Set(Object.keys(LAYER_ARNS).map((k) => k.split('/')[0]));\n      throw new Error(\n        `Odigos: no public ${language}/${architecture} layer published in ${region} ` +\n          `(@odigos/aws-cdk ${ODIGOS_VERSION || 'unreleased'}). ` +\n          (known.size === 0\n            ? 'This build of the package has an empty layer table — it was built before the first release.'\n            : `Published regions: ${[...known].sort().join(', ')}.`) +\n          ' Use OdigosLayerSource.IN_ACCOUNT to deploy the layer into your own account instead.',\n      );\n    }\n\n    return lambda.LayerVersion.fromLayerVersionArn(\n      this.scope,\n      `OdigosLayer${this.constructSuffix(language, architecture)}`,\n      arn,\n    );\n  }\n\n  /**\n   * Deploys the Odigos SAR application into this account as a nested stack and attaches the layer it\n   * creates.\n   *\n   * Pinning `semanticVersion` is what makes this reproducible: a SAR application version is immutable, so\n   * the pinned version resolves to the same layer bytes forever. Leaving it unpinned would let a later\n   * `cdk deploy` of unchanged code pick up a different layer.\n   */\n  private fromSar(language: string, architecture: string): lambda.ILayerVersion {\n    const applicationId = SAR_APPLICATIONS[`${language}/${architecture}`];\n    if (!applicationId) {\n      throw new Error(\n        `Odigos: no SAR application published for ${language}/${architecture} ` +\n          `(@odigos/aws-cdk ${ODIGOS_VERSION || 'unreleased'}).`,\n      );\n    }\n    if (!SAR_SEMANTIC_VERSION) {\n      throw new Error(\n        'Odigos: this build of @odigos/aws-cdk has no SAR semantic version baked in, so the application ' +\n          'could only be deployed unpinned. Use a released version of the package.',\n      );\n    }\n\n    // CfnApplication is a SAM resource, so the stack needs the Serverless transform. addTransform is\n    // idempotent, so declaring it here is safe whether or not the app already uses SAM elsewhere.\n    Stack.of(this.scope).addTransform('AWS::Serverless-2016-10-31');\n\n    const suffix = this.constructSuffix(language, architecture);\n    const app = new sam.CfnApplication(this.scope, `OdigosLayerApp${suffix}`, {\n      location: {\n        applicationId,\n        semanticVersion: SAR_SEMANTIC_VERSION,\n      },\n    });\n\n    return lambda.LayerVersion.fromLayerVersionArn(\n      this.scope,\n      `OdigosLayer${suffix}`,\n      app.getAtt('Outputs.LayerVersionArn').toString(),\n    );\n  }\n\n  /** `Python_X8664` — a construct-id-safe suffix that keeps ids stable and readable in the template. */\n  private constructSuffix(language: string, architecture: string): string {\n    const titled = language.charAt(0).toUpperCase() + language.slice(1);\n    return `${titled}${architecture.replace(/[^a-zA-Z0-9]/g, '')}`;\n  }\n}\n\n/**\n * The layer name this package attaches, exposed so a stack can assert on it or build an allowlist.\n *\n * Deliberately identical to the name the connector publishes into an account\n * (`store.OdigosLayerNamePrefix` + language + \"-\" + architecture). That is what lets a function\n * instrumented here and later enabled as a connector source converge: the connector sees the same layer\n * NAME, swaps its own version in rather than attaching a second OpenTelemetry layer, and recognises the\n * layer as one it may manage.\n */\nexport function odigosLayerName(language: string, architecture: string): string {\n  return layerNameFor(language, architecture);\n}\n\n/** Stable, human-readable construct id fragment for a function. Exported for the aspect. */\nexport function functionScopeId(fn: Construct): string {\n  return Names.nodeUniqueId(fn.node);\n}\n"]}

package/lib/runtime.d.ts

@@ -0,0 +1,49 @@
+import { OdigosJavaHandlerDistro } from './types';
+/**
+ * Resolves a Lambda runtime identifier (`python3.12`, `java21`, `nodejs22.x`) to the OTel layer language.
+ *
+ * Returns `undefined` for runtimes with no OpenTelemetry Lambda language layer — `dotnet*`, `provided.*`
+ * (Go and custom runtimes). The caller refuses to instrument rather than attaching a layer that does
+ * nothing, because a layer plus an exec wrapper that does not exist in it fails the function at cold start.
+ */
+export declare function languageFromRuntime(runtimeName: string): string | undefined;
+/**
+ * The `AWS_LAMBDA_EXEC_WRAPPER` value for a language.
+ *
+ * The wrapper script is LANGUAGE-SPECIFIC: Python ships `/opt/otel-instrument`; Node.js, Java and Ruby
+ * ship `/opt/otel-handler`. Setting the wrong one makes the layer bootstrap fail at cold start with
+ * `/opt/otel-instrument: does not exist` and the function errors out — which is why this is never a
+ * hardcoded constant at a call site.
+ *
+ * `distro` is only consulted for Java, whose layer ships four wrappers, one per handler interface.
+ */
+export declare function execWrapperFor(language: string, distro?: OdigosJavaHandlerDistro): string;
+/** Layer name for a language/architecture — `odigos-otel-python-arm64`. */
+export declare function layerNameFor(language: string, architecture: string): string;
+/** Environment variables to set on a function, as a plain map. */
+export interface EnvVars {
+    readonly [key: string]: string;
+}
+/**
+ * Idempotently adds our loader value to a value the function already carries.
+ *
+ * `PYTHONPATH` is PREPENDED, so the layer's packages and its `sitecustomize` are found first; the
+ * `*_OPTIONS` variables are appended, so the customer's own flags keep precedence. Mirrors
+ * `addLoaderValue` in the connector.
+ */
+export declare function addLoaderValue(existing: string | undefined, value: string, separator: string): string;
+/**
+ * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.
+ *
+ * Web-adapter functions run a web server rather than a Lambda handler, and the adapter owns
+ * `AWS_LAMBDA_EXEC_WRAPPER` — so instrumentation is loaded through the language's own loader variable and
+ * the wrapper is left alone. Handler-mode instrumentation applied to one of these overwrites the
+ * adapter's wrapper and the function stops serving.
+ *
+ * @param existingLoaderValue the value the function already needs in its loader variable, which ours is
+ * joined to. CDK's `lambda.Function` exposes no way to read back an environment variable set elsewhere in
+ * the app, so a value that must be preserved has to be passed in explicitly.
+ */
+export declare function webServerEnv(language: string, existingLoaderValue?: string): {
+    [key: string]: string;
+};

package/lib/runtime.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languageFromRuntime = languageFromRuntime;
+exports.execWrapperFor = execWrapperFor;
+exports.layerNameFor = layerNameFor;
+exports.addLoaderValue = addLoaderValue;
+exports.webServerEnv = webServerEnv;
+const layers_1 = require("./generated/layers");
+const types_1 = require("./types");
+/**
+ * Runtime -> language, and language -> the exact env the layer expects.
+ *
+ * Mirrors `LanguageFromRuntime`, `execWrapperForLanguage` and `webServerLoader` in the connector's
+ * instrumentor. The data lives in ../../artifacts.json and reaches here through the generated module; the
+ * decisions live here.
+ */
+/** Runtime prefixes that map to an OTel layer language. Prefix-matched, so `java8.al2` resolves to java. */
+const LANGUAGE_PREFIXES = [
+    ['python', 'python'],
+    ['nodejs', 'nodejs'],
+    ['java', 'java'],
+    ['ruby', 'ruby'],
+];
+/**
+ * Resolves a Lambda runtime identifier (`python3.12`, `java21`, `nodejs22.x`) to the OTel layer language.
+ *
+ * Returns `undefined` for runtimes with no OpenTelemetry Lambda language layer — `dotnet*`, `provided.*`
+ * (Go and custom runtimes). The caller refuses to instrument rather than attaching a layer that does
+ * nothing, because a layer plus an exec wrapper that does not exist in it fails the function at cold start.
+ */
+function languageFromRuntime(runtimeName) {
+    for (const [prefix, language] of LANGUAGE_PREFIXES) {
+        if (runtimeName.startsWith(prefix)) {
+            return language;
+        }
+    }
+    return undefined;
+}
+/** Maps the Java distro enum to the wrapper script path the layer ships. */
+const JAVA_DISTRO_WRAPPERS = {
+    [types_1.OdigosJavaHandlerDistro.OTEL_HANDLER]: '/opt/otel-handler',
+    [types_1.OdigosJavaHandlerDistro.OTEL_PROXY_HANDLER]: '/opt/otel-proxy-handler',
+    [types_1.OdigosJavaHandlerDistro.OTEL_SQS_HANDLER]: '/opt/otel-sqs-handler',
+    [types_1.OdigosJavaHandlerDistro.OTEL_STREAM_HANDLER]: '/opt/otel-stream-handler',
+};
+/**
+ * The `AWS_LAMBDA_EXEC_WRAPPER` value for a language.
+ *
+ * The wrapper script is LANGUAGE-SPECIFIC: Python ships `/opt/otel-instrument`; Node.js, Java and Ruby
+ * ship `/opt/otel-handler`. Setting the wrong one makes the layer bootstrap fail at cold start with
+ * `/opt/otel-instrument: does not exist` and the function errors out — which is why this is never a
+ * hardcoded constant at a call site.
+ *
+ * `distro` is only consulted for Java, whose layer ships four wrappers, one per handler interface.
+ */
+function execWrapperFor(language, distro) {
+    if (language === 'java') {
+        return JAVA_DISTRO_WRAPPERS[distro ?? types_1.OdigosJavaHandlerDistro.OTEL_HANDLER];
+    }
+    const spec = layers_1.LANGUAGES[language];
+    if (!spec) {
+        throw new Error(`Odigos: no OpenTelemetry Lambda layer for language "${language}"`);
+    }
+    return spec.execWrapper;
+}
+/** Layer name for a language/architecture — `odigos-otel-python-arm64`. */
+function layerNameFor(language, architecture) {
+    const spec = layers_1.LANGUAGES[language];
+    if (!spec) {
+        throw new Error(`Odigos: unknown language "${language}"`);
+    }
+    return `${spec.layerName}-${architecture}`;
+}
+/**
+ * Idempotently adds our loader value to a value the function already carries.
+ *
+ * `PYTHONPATH` is PREPENDED, so the layer's packages and its `sitecustomize` are found first; the
+ * `*_OPTIONS` variables are appended, so the customer's own flags keep precedence. Mirrors
+ * `addLoaderValue` in the connector.
+ */
+function addLoaderValue(existing, value, separator) {
+    if (!existing) {
+        return value;
+    }
+    if (existing.includes(value)) {
+        return existing;
+    }
+    return separator === ':' ? `${value}${separator}${existing}` : `${existing}${separator}${value}`;
+}
+/**
+ * The environment that loads the language agent in web-server (AWS Lambda Web Adapter) mode.
+ *
+ * Web-adapter functions run a web server rather than a Lambda handler, and the adapter owns
+ * `AWS_LAMBDA_EXEC_WRAPPER` — so instrumentation is loaded through the language's own loader variable and
+ * the wrapper is left alone. Handler-mode instrumentation applied to one of these overwrites the
+ * adapter's wrapper and the function stops serving.
+ *
+ * @param existingLoaderValue the value the function already needs in its loader variable, which ours is
+ * joined to. CDK's `lambda.Function` exposes no way to read back an environment variable set elsewhere in
+ * the app, so a value that must be preserved has to be passed in explicitly.
+ */
+function webServerEnv(language, existingLoaderValue) {
+    const spec = layers_1.LANGUAGES[language];
+    const loader = spec?.webServer;
+    if (!loader) {
+        throw new Error(`Odigos: ${types_1.OdigosInstrumentationMode.WEB_SERVER} mode is not supported for ${language} — ` +
+            'there is no verified web-server loader for it. Use HANDLER mode, or leave the function uninstrumented.');
+    }
+    const env = {
+        [loader.envKey]: addLoaderValue(existingLoaderValue, loader.value, loader.separator),
+    };
+    // Python must be pinned to the HTTP OTLP exporter — the only one bundled in its layer. Other languages
+    // export correctly with their defaults, so nothing extra is written for them.
+    for (const [k, v] of Object.entries(loader.extraEnv)) {
+        env[k] = v;
+    }
+    return env;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":";;AA0BA,kDAOC;AAoBD,wCASC;AAGD,oCAMC;AAcD,wCAQC;AAcD,oCAqBC;AAhID,+CAA+C;AAC/C,mCAA6E;AAE7E;;;;;;GAMG;AAEH,4GAA4G;AAC5G,MAAM,iBAAiB,GAA4B;IACjD,CAAC,QAAQ,EAAE,QAAQ,CAAC;IACpB,CAAC,QAAQ,EAAE,QAAQ,CAAC;IACpB,CAAC,MAAM,EAAE,MAAM,CAAC;IAChB,CAAC,MAAM,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;GAMG;AACH,SAAgB,mBAAmB,CAAC,WAAmB;IACrD,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,iBAAiB,EAAE,CAAC;QACnD,IAAI,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACnC,OAAO,QAAQ,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,4EAA4E;AAC5E,MAAM,oBAAoB,GAA8B;IACtD,CAAC,+BAAuB,CAAC,YAAY,CAAC,EAAE,mBAAmB;IAC3D,CAAC,+BAAuB,CAAC,kBAAkB,CAAC,EAAE,yBAAyB;IACvE,CAAC,+BAAuB,CAAC,gBAAgB,CAAC,EAAE,uBAAuB;IACnE,CAAC,+BAAuB,CAAC,mBAAmB,CAAC,EAAE,0BAA0B;CAC1E,CAAC;AAEF;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAAC,QAAgB,EAAE,MAAgC;IAC/E,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;QACxB,OAAO,oBAAoB,CAAC,MAAM,IAAI,+BAAuB,CAAC,YAAY,CAAC,CAAC;IAC9E,CAAC;IACD,MAAM,IAAI,GAAG,kBAAS,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,uDAAuD,QAAQ,GAAG,CAAC,CAAC;IACtF,CAAC;IACD,OAAO,IAAI,CAAC,WAAW,CAAC;AAC1B,CAAC;AAED,2EAA2E;AAC3E,SAAgB,YAAY,CAAC,QAAgB,EAAE,YAAoB;IACjE,MAAM,IAAI,GAAG,kBAAS,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,6BAA6B,QAAQ,GAAG,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,GAAG,IAAI,CAAC,SAAS,IAAI,YAAY,EAAE,CAAC;AAC7C,CAAC;AAOD;;;;;;GAMG;AACH,SAAgB,cAAc,CAAC,QAA4B,EAAE,KAAa,EAAE,SAAiB;IAC3F,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,SAAS,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,EAAE,CAAC;AACnG,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAC1B,QAAgB,EAChB,mBAA4B;IAE5B,MAAM,IAAI,GAAG,kBAAS,CAAC,QAAQ,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,IAAI,EAAE,SAAS,CAAC;IAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CACb,WAAW,iCAAyB,CAAC,UAAU,8BAA8B,QAAQ,KAAK;YACxF,wGAAwG,CAC3G,CAAC;IACJ,CAAC;IACD,MAAM,GAAG,GAA8B;QACrC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,mBAAmB,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC;KACrF,CAAC;IACF,uGAAuG;IACvG,8EAA8E;IAC9E,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrD,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACb,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","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"]}