@odigos/aws-cdk 0.0.0

package/README.md

@@ -0,0 +1,191 @@
+# Odigos CDK constructs for AWS Lambda
+
+Instrument AWS Lambda functions with the Odigos OpenTelemetry layer, from your own CDK app.
+
+```bash
+npm install @odigos/aws-cdk        # TypeScript / JavaScript
+pip install odigos-aws-cdk         # Python
+```
+
+```ts
+import { OdigosLambdaInstrumentation } from '@odigos/aws-cdk';
+
+new OdigosLambdaInstrumentation(this, 'Odigos', {
+  destination: { endpoint: 'otlp.example.com:4317' },
+  functions: [apiFn, workerFn],
+});
+```
+
+```python
+from odigos_aws_cdk import OdigosLambdaInstrumentation
+
+OdigosLambdaInstrumentation(self, "Odigos",
+    destination={"endpoint": "otlp.example.com:4317"},
+    functions=[api_fn, worker_fn],
+)
+```
+
+That attaches the layer for each function's language and architecture, sets the exec wrapper that loads
+the OpenTelemetry SDK, and hands the in-Lambda collector its whole configuration.
+
+## How the telemetry actually leaves the function
+
+Your function's SDK **does not** export to your destination. It exports to an OpenTelemetry collector
+running inside the same Lambda sandbox, on localhost. The collector forwards to your destination *after*
+the handler has already returned its response.
+
+That indirection is the whole point. A slow or unreachable destination costs billed duration, not caller
+latency — and the collector's `decouple` processor is what holds the sandbox open until the export queue
+drains, so a low-traffic function does not lose its telemetry to the freeze.
+
+Consequently `OTEL_EXPORTER_OTLP_ENDPOINT` is deliberately never set. If you set it yourself you put the
+export back on the invocation's critical path.
+
+## Choosing a layer source
+
+```ts
+new OdigosLambdaInstrumentation(this, 'Odigos', {
+  destination: { endpoint: 'otlp.example.com:4317' },
+  functions: [fn],
+  layerSource: OdigosLayerSource.IN_ACCOUNT,
+});
+```
+
+| | `ODIGOS_PUBLIC` (default) | `IN_ACCOUNT` |
+|---|---|---|
+| What it synthesizes | a layer ARN | an `AWS::Serverless::Application` (nested stack) per language/arch |
+| Layer owner | the Odigos AWS account | **your** account, created by your stack |
+| Resolution | synth time, from a table baked into this package | deploy time, from the Serverless Application Repository |
+| Environment-agnostic stacks | not supported — needs a concrete region | works |
+| Deploy speed | unchanged | slower on first deploy |
+
+Both install identical bytes. `IN_ACCOUNT` exists for organisations whose policy forbids attaching a
+Lambda layer owned by another AWS account. It needs the deploying principal to be allowed
+`serverlessrepo:CreateCloudFormationTemplate` and `serverlessrepo:GetApplication`.
+
+If you mirror the layer somewhere yourself, pass `layerVersion` and neither path is used.
+
+## Versioning
+
+**The package version is the layer version.** `@odigos/aws-cdk@0.2.0` resolves to the layer built and
+published by Odigos release `v0.2.0`, and pins the SAR application to semantic version `0.2.0` — which is
+immutable, so it means the same bytes forever.
+
+Nothing resolves at deploy time in the default path, so upgrading the layer is `npm update` and a
+`cdk diff` that shows the change. An instrumentation layer moving on its own, under a deployment that
+changed nothing, is not a property you want.
+
+## Handler mode vs. web-server mode
+
+`OdigosInstrumentationMode.HANDLER` (the default) is for a normal Lambda handler. It sets
+`AWS_LAMBDA_EXEC_WRAPPER`.
+
+`OdigosInstrumentationMode.WEB_SERVER` is for a function running a web server behind the
+[AWS Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter). The adapter owns the exec
+wrapper, so this mode does not touch it and loads instrumentation through the language's own loader
+variable instead.
+
+```ts
+new OdigosLambdaInstrumentation(this, 'Odigos', {
+  destination: { endpoint: 'otlp.example.com:4317' },
+  functions: [webFn],
+  mode: OdigosInstrumentationMode.WEB_SERVER,
+  // NODE_OPTIONS the function already needs — ours is appended, not substituted.
+  existingLoaderValue: '--max-old-space-size=2048',
+});
+```
+
+There is no auto-detection, deliberately. Detecting the adapter means inspecting the function's other
+layers, which at synth time are frequently unresolved tokens; a detector that was right most of the time
+would silently break the functions it got wrong. **Applying `HANDLER` to a web-adapter function
+overwrites the adapter's wrapper and the function stops serving.**
+
+`existingLoaderValue` has to be passed explicitly because CDK's `lambda.Function` exposes no way to read
+back an environment variable set elsewhere in your app. Omit it and the loader variable is set to the
+Odigos value alone — for `NODE_OPTIONS` that can mean losing a flag your app needs to boot.
+
+Ruby has no verified web-server loader and is rejected at synth in this mode.
+
+## Java handler interfaces
+
+The Java layer ships four wrapper scripts, one per handler interface, and this is a correctness switch
+rather than a detail level:
+
+```ts
+javaHandlerDistro: OdigosJavaHandlerDistro.OTEL_STREAM_HANDLER
+```
+
+| Distro | For |
+|---|---|
+| `OTEL_HANDLER` (default) | `RequestHandler` |
+| `OTEL_PROXY_HANDLER` | API Gateway proxy events (enriched) |
+| `OTEL_SQS_HANDLER` | SQS events (enriched) |
+| `OTEL_STREAM_HANDLER` | `RequestStreamHandler` |
+
+`OTEL_HANDLER` installs a `RequestHandler` implementation. A `RequestStreamHandler` function has a
+different signature entirely, so wrapping it with the default **breaks the invocation** — it does not
+merely produce thinner spans.
+
+## Signals
+
+```ts
+destination: {
+  endpoint: 'otlp.example.com:4317',
+  metrics: false,   // traces and logs stay on
+}
+```
+
+A disabled signal gets no collector pipeline **and** the SDK is told not to produce it. Both halves
+matter: a signal with no pipeline is refused at the receiver on every batch, so suppressing it at the
+source is what stops the error loop.
+
+Turning all three off throws at synth — a collector with no pipeline fails to start, which would leave
+the function instrumented and silent.
+
+## Instrumenting a whole stack
+
+```ts
+Aspects.of(stack).add(new OdigosInstrumentationAspect(stack, {
+  destination: { endpoint: 'otlp.example.com:4317' },
+}));
+```
+
+`skipUnsupportedRuntimes` defaults to `true` for the aspect: it visits every function in the scope,
+including ones whose runtime has no OpenTelemetry Lambda layer (`dotnet*`, `provided.*` for Go and custom
+runtimes). Each skip is a synth warning rather than a silent no-op. The construct defaults it to `false`,
+because explicitly asking to instrument a Go function is a mistake worth failing on.
+
+## Credentials in `headers`
+
+`destination.headers` is rendered into `OPENTELEMETRY_COLLECTOR_CONFIG_URI`, which is a plain Lambda
+environment variable — readable by anyone with `lambda:GetFunctionConfiguration` and visible in the
+console. For a long-lived credential, prefer a destination that authenticates by network position, or
+terminate at a collector you control.
+
+## Do not also instrument these functions with the Odigos 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* 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.
+
+Pick one per function. These constructs never set the connector's `ODIGOS_MANAGED` ownership marker — so
+an IaC-instrumented function is not one the connector will roll back — but the connector will take it
+over if you enable it as a source.
+
+## API
+
+| Export | |
+|---|---|
+| `OdigosLambdaInstrumentation` | the construct; `instrument(fn)`, `instrumentAll(fns)` |
+| `OdigosInstrumentationAspect` | applies it to every function in a scope |
+| `OdigosDestination` | where the collector exports; exactly one of `endpoint` / `httpEndpoint` |
+| `OdigosLayerSource` | `ODIGOS_PUBLIC` \| `IN_ACCOUNT` |
+| `OdigosInstrumentationMode` | `HANDLER` \| `WEB_SERVER` |
+| `OdigosJavaHandlerDistro` | the four Java wrappers |
+| `renderCollectorConfig` | the collector config renderer, if you want to inspect what gets set |
+| `LAYER_ARNS`, `ODIGOS_VERSION` | the baked layer table and the release it came from |
+
+## License
+
+Apache-2.0.

package/lib/collector-config.d.ts

@@ -0,0 +1,68 @@
+import { OdigosDestination } from './types';
+/**
+ * Renders the in-Lambda collector's complete configuration as an inline
+ * `OPENTELEMETRY_COLLECTOR_CONFIG_URI` value.
+ *
+ * This is a PORT of `renderCollectorConfig` in the connector
+ * (connectors/providers/aws/pkg/workload/instrumentor/collector_config.go) and is deliberately
+ * byte-for-byte compatible with it. That equivalence is not cosmetic: a function instrumented here and
+ * later enabled as a connector source is compared against the connector's rendering to decide whether it
+ * needs converging. A stray space would make every reconcile see drift and churn a new function version
+ * forever.
+ *
+ * WHY THE WHOLE DOCUMENT, RATHER THAN A FEW VARIABLES. The layer ships a baked
+ * /opt/collector-config/config.yaml, but that file is ONE document shared by every function, so it can
+ * only reach a destination through env indirection — `${env:SOMETHING}`. That made three things
+ * impossible at once:
+ *
+ *   - AUTH. A credential is a headers map, not a scalar. A baked file can substitute a value but cannot
+ *     conditionally grow a `headers:` block, so an authenticated destination was unreachable.
+ *   - OTLP/HTTP DESTINATIONS. The baked file hardcodes a gRPC `otlp` exporter. An otlphttp-only
+ *     destination resolves with an empty gRPC endpoint, and the collector does not degrade — it fails to
+ *     build the pipeline and exits, so the function is instrumented, looks healthy, and exports nothing.
+ *   - PER-SIGNAL PIPELINES. The baked file declares all three pipelines unconditionally, so a signal the
+ *     destination does not accept is received and then fails on export rather than never being built.
+ *
+ * FLOW STYLE IS LOAD-BEARING. The document is emitted on a single line because it has to survive as an
+ * environment variable value. In a YAML flow mapping a colon must be followed by a space, or the parser
+ * reads `a:b` as the plain scalar `"a:b"` rather than a mapping. Written without the spaces the collector
+ * accepts the variable, reports the URI it read, and then fails to start with a bare
+ * `otelcol state is Closed` — no parse error, no mention of the config. Every `: ` below earns its place.
+ */
+/**
+ * The collector layer's own config-source variable — upstream's name, not ours. Pointed at a `yaml:` URI
+ * it carries the entire configuration inline, so no second variable is needed to hold it.
+ *
+ * Upstream also reads the older `OPENTELEMETRY_COLLECTOR_CONFIG_FILE` and logs a deprecation warning for
+ * it; this is the current name.
+ */
+export declare const ENV_COLLECTOR_CONFIG_URI = "OPENTELEMETRY_COLLECTOR_CONFIG_URI";
+/** Value an unsupported signal's `OTEL_*_EXPORTER` is set to. */
+export declare const EXPORTER_NONE = "none";
+/** The three `OTEL_*_EXPORTER` variables, in the order the connector writes them. */
+export declare const ENV_TRACES_EXPORTER = "OTEL_TRACES_EXPORTER";
+export declare const ENV_METRICS_EXPORTER = "OTEL_METRICS_EXPORTER";
+export declare const ENV_LOGS_EXPORTER = "OTEL_LOGS_EXPORTER";
+/** Whether a signal is enabled, defaulting to on. */
+export declare function signalEnabled(value: boolean | undefined): boolean;
+/**
+ * Picks the exporter by the transport the destination configured. A destination carries a gRPC endpoint
+ * (type `otlp`) or an OTLP/HTTP one (type `otlphttp`); the two are different collector components with
+ * different endpoint grammars, so this is a genuine branch.
+ */
+export declare function exporterNameFor(dest: OdigosDestination): string;
+/**
+ * Returns the value a signal's `OTEL_*_EXPORTER` must hold: `none` to suppress a signal the destination
+ * does not accept, or `undefined` meaning the variable must be ABSENT because the SDK's own default is
+ * already what we want.
+ *
+ * Only the "none" side is written, because `otlp` is already every OpenTelemetry SDK's default for all
+ * three signals — setting it would restate the default in three variables on every function.
+ */
+export declare function exporterOverrideFor(supported: boolean): string | undefined;
+/**
+ * Renders the complete collector configuration for one destination.
+ *
+ * @throws if the destination names neither transport, both transports, or no signals at all.
+ */
+export declare function renderCollectorConfig(dest: OdigosDestination): string;

package/lib/collector-config.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_LOGS_EXPORTER = exports.ENV_METRICS_EXPORTER = exports.ENV_TRACES_EXPORTER = exports.EXPORTER_NONE = exports.ENV_COLLECTOR_CONFIG_URI = void 0;
+exports.signalEnabled = signalEnabled;
+exports.exporterNameFor = exporterNameFor;
+exports.exporterOverrideFor = exporterOverrideFor;
+exports.renderCollectorConfig = renderCollectorConfig;
+/**
+ * Renders the in-Lambda collector's complete configuration as an inline
+ * `OPENTELEMETRY_COLLECTOR_CONFIG_URI` value.
+ *
+ * This is a PORT of `renderCollectorConfig` in the connector
+ * (connectors/providers/aws/pkg/workload/instrumentor/collector_config.go) and is deliberately
+ * byte-for-byte compatible with it. That equivalence is not cosmetic: a function instrumented here and
+ * later enabled as a connector source is compared against the connector's rendering to decide whether it
+ * needs converging. A stray space would make every reconcile see drift and churn a new function version
+ * forever.
+ *
+ * WHY THE WHOLE DOCUMENT, RATHER THAN A FEW VARIABLES. The layer ships a baked
+ * /opt/collector-config/config.yaml, but that file is ONE document shared by every function, so it can
+ * only reach a destination through env indirection — `${env:SOMETHING}`. That made three things
+ * impossible at once:
+ *
+ *   - AUTH. A credential is a headers map, not a scalar. A baked file can substitute a value but cannot
+ *     conditionally grow a `headers:` block, so an authenticated destination was unreachable.
+ *   - OTLP/HTTP DESTINATIONS. The baked file hardcodes a gRPC `otlp` exporter. An otlphttp-only
+ *     destination resolves with an empty gRPC endpoint, and the collector does not degrade — it fails to
+ *     build the pipeline and exits, so the function is instrumented, looks healthy, and exports nothing.
+ *   - PER-SIGNAL PIPELINES. The baked file declares all three pipelines unconditionally, so a signal the
+ *     destination does not accept is received and then fails on export rather than never being built.
+ *
+ * FLOW STYLE IS LOAD-BEARING. The document is emitted on a single line because it has to survive as an
+ * environment variable value. In a YAML flow mapping a colon must be followed by a space, or the parser
+ * reads `a:b` as the plain scalar `"a:b"` rather than a mapping. Written without the spaces the collector
+ * accepts the variable, reports the URI it read, and then fails to start with a bare
+ * `otelcol state is Closed` — no parse error, no mention of the config. Every `: ` below earns its place.
+ */
+/**
+ * The collector layer's own config-source variable — upstream's name, not ours. Pointed at a `yaml:` URI
+ * it carries the entire configuration inline, so no second variable is needed to hold it.
+ *
+ * Upstream also reads the older `OPENTELEMETRY_COLLECTOR_CONFIG_FILE` and logs a deprecation warning for
+ * it; this is the current name.
+ */
+exports.ENV_COLLECTOR_CONFIG_URI = 'OPENTELEMETRY_COLLECTOR_CONFIG_URI';
+/**
+ * The confmap provider that reads a configuration out of the URI itself. The collector registers
+ * env/file/yaml/http/https/s3 providers; `yaml:` is the only one that needs no second variable and no
+ * network read on a cold start.
+ */
+const COLLECTOR_CONFIG_SCHEME = 'yaml:';
+/**
+ * Mirrors the baked config's processor set, and the ORDER is the contract:
+ *
+ *   - `memory_limiter` first, so an export backlog is shed before it is charged to the same memory budget
+ *     the customer's handler allocates from. Percentages, not `limit_mib`, because one layer serves
+ *     functions from 128MB to 10GB.
+ *   - `decouple` LAST. Lambda freezes the sandbox once the handler returns and every extension has called
+ *     /next; a frozen sandbox runs no timers, so a batch sitting behind its timeout is flushed on a later
+ *     invocation or dropped when the sandbox is reaped. `decouple` acknowledges the receive path
+ *     immediately and tracks in-flight exports, which is what lets the extension hold /next open until the
+ *     queue drains — after the caller already has its response.
+ */
+const COLLECTOR_PROCESSORS = '{memory_limiter: {check_interval: 1s, limit_percentage: 50, spike_limit_percentage: 20}, ' +
+    'batch: {send_batch_size: 512, timeout: 200ms}, decouple: null}';
+/** Value an unsupported signal's `OTEL_*_EXPORTER` is set to. */
+exports.EXPORTER_NONE = 'none';
+/** The three `OTEL_*_EXPORTER` variables, in the order the connector writes them. */
+exports.ENV_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER';
+exports.ENV_METRICS_EXPORTER = 'OTEL_METRICS_EXPORTER';
+exports.ENV_LOGS_EXPORTER = 'OTEL_LOGS_EXPORTER';
+/** Whether a signal is enabled, defaulting to on. */
+function signalEnabled(value) {
+    return value !== false;
+}
+/**
+ * Renders a double-quoted YAML scalar.
+ *
+ * Quoting unconditionally is what keeps a value such as a bare `host:4317` from being re-read as a nested
+ * mapping in flow context. `JSON.stringify` is the TypeScript equivalent of the connector's
+ * `strconv.Quote` for the vocabulary that matters here (`\"` and `\\`); both produce the same output for
+ * the ASCII endpoints, header names and credentials this ever sees.
+ */
+function yamlString(s) {
+    return JSON.stringify(s);
+}
+/**
+ * Picks the exporter by the transport the destination configured. A destination carries a gRPC endpoint
+ * (type `otlp`) or an OTLP/HTTP one (type `otlphttp`); the two are different collector components with
+ * different endpoint grammars, so this is a genuine branch.
+ */
+function exporterNameFor(dest) {
+    return dest.endpoint ? 'otlp' : 'otlphttp';
+}
+/**
+ * Emits the destination's per-request headers — in practice its credential. Empty when the destination
+ * needs none, so no header block is written at all rather than an empty one.
+ *
+ * Keys are sorted so the rendered config is byte-identical across synths. The string is compared against
+ * the live function's environment to decide whether an update is needed, and map order would otherwise
+ * make every deploy look like a change.
+ */
+function renderHeaders(headers) {
+    if (!headers) {
+        return '';
+    }
+    const keys = Object.keys(headers).sort();
+    if (keys.length === 0) {
+        return '';
+    }
+    const rendered = keys.map((k) => `${yamlString(k)}: ${yamlString(headers[k])}`).join(', ');
+    return `, headers: {${rendered}}`;
+}
+function renderExporter(dest) {
+    let out;
+    if (dest.endpoint) {
+        // tls.insecure applies to the gRPC exporter only; the HTTP exporter takes the scheme from the URL.
+        out = `{otlp: {endpoint: ${yamlString(dest.endpoint)}, tls: {insecure: ${dest.insecure === true}}`;
+    }
+    else if (dest.httpEndpoint) {
+        out = `{otlphttp: {endpoint: ${yamlString(dest.httpEndpoint)}`;
+    }
+    else {
+        // Reached when a destination carries neither transport. Failing here is the whole point: the
+        // alternative is a collector that exits on startup while the function is reported healthy.
+        throw new Error('Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP), ' +
+            'so the in-Lambda collector would have nowhere to export.');
+    }
+    return `${out}${renderHeaders(dest.headers)}}}`;
+}
+/**
+ * Builds a pipeline only for the signals the destination accepts. A signal with no pipeline is refused at
+ * the receiver, which is the behaviour we want: the SDK is told not to produce it either (see
+ * `exporterOverrideFor`), and the two together mean an unaccepted signal is never generated, never
+ * exported, and never a per-batch error against a backend that does not implement it.
+ */
+function renderPipelines(dest, exporterName) {
+    const parts = [];
+    const signals = [
+        ['traces', signalEnabled(dest.traces)],
+        ['metrics', signalEnabled(dest.metrics)],
+        ['logs', signalEnabled(dest.logs)],
+    ];
+    for (const [name, enabled] of signals) {
+        if (!enabled) {
+            continue;
+        }
+        parts.push(`${name}: {receivers: [otlp], processors: [memory_limiter, batch, decouple], exporters: [${exporterName}]}`);
+    }
+    return parts.length === 0 ? '' : `{${parts.join(', ')}}`;
+}
+/**
+ * Returns the value a signal's `OTEL_*_EXPORTER` must hold: `none` to suppress a signal the destination
+ * does not accept, or `undefined` meaning the variable must be ABSENT because the SDK's own default is
+ * already what we want.
+ *
+ * Only the "none" side is written, because `otlp` is already every OpenTelemetry SDK's default for all
+ * three signals — setting it would restate the default in three variables on every function.
+ */
+function exporterOverrideFor(supported) {
+    return supported ? undefined : exports.EXPORTER_NONE;
+}
+/**
+ * Renders the complete collector configuration for one destination.
+ *
+ * @throws if the destination names neither transport, both transports, or no signals at all.
+ */
+function renderCollectorConfig(dest) {
+    if (dest.endpoint && dest.httpEndpoint) {
+        throw new Error('Odigos destination sets both `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP); ' +
+            'they select different collector exporters, so exactly one must be set.');
+    }
+    const exporter = renderExporter(dest);
+    const pipelines = renderPipelines(dest, exporterNameFor(dest));
+    if (pipelines === '') {
+        throw new Error('Odigos destination accepts no telemetry signals (traces, metrics and logs are all false), ' +
+            'so the collector would have no pipeline to build and would fail to start.');
+    }
+    return (COLLECTOR_CONFIG_SCHEME +
+        '{receivers: {otlp: {protocols: ' +
+        // Bound to localhost: the receiver exists only for the in-process SDK. Binding it wider would expose
+        // an unauthenticated OTLP endpoint on the sandbox's network interface.
+        '{grpc: {endpoint: "localhost:4317"}, http: {endpoint: "localhost:4318"}}}}, ' +
+        'processors: ' +
+        COLLECTOR_PROCESSORS +
+        ', exporters: ' +
+        exporter +
+        ', service: {telemetry: {metrics: {level: none}}, pipelines: ' +
+        pipelines +
+        '}}');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collector-config.js","sourceRoot":"","sources":["../src/collector-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdigosDestination } from './types';\n\n/**\n * Renders the in-Lambda collector's complete configuration as an inline\n * `OPENTELEMETRY_COLLECTOR_CONFIG_URI` value.\n *\n * This is a PORT of `renderCollectorConfig` in the connector\n * (connectors/providers/aws/pkg/workload/instrumentor/collector_config.go) and is deliberately\n * byte-for-byte compatible with it. That equivalence is not cosmetic: a function instrumented here and\n * later enabled as a connector source is compared against the connector's rendering to decide whether it\n * needs converging. A stray space would make every reconcile see drift and churn a new function version\n * forever.\n *\n * WHY THE WHOLE DOCUMENT, RATHER THAN A FEW VARIABLES. The layer ships a baked\n * /opt/collector-config/config.yaml, but that file is ONE document shared by every function, so it can\n * only reach a destination through env indirection — `${env:SOMETHING}`. That made three things\n * impossible at once:\n *\n *   - AUTH. A credential is a headers map, not a scalar. A baked file can substitute a value but cannot\n *     conditionally grow a `headers:` block, so an authenticated destination was unreachable.\n *   - OTLP/HTTP DESTINATIONS. The baked file hardcodes a gRPC `otlp` exporter. An otlphttp-only\n *     destination resolves with an empty gRPC endpoint, and the collector does not degrade — it fails to\n *     build the pipeline and exits, so the function is instrumented, looks healthy, and exports nothing.\n *   - PER-SIGNAL PIPELINES. The baked file declares all three pipelines unconditionally, so a signal the\n *     destination does not accept is received and then fails on export rather than never being built.\n *\n * FLOW STYLE IS LOAD-BEARING. The document is emitted on a single line because it has to survive as an\n * environment variable value. In a YAML flow mapping a colon must be followed by a space, or the parser\n * reads `a:b` as the plain scalar `\"a:b\"` rather than a mapping. Written without the spaces the collector\n * accepts the variable, reports the URI it read, and then fails to start with a bare\n * `otelcol state is Closed` — no parse error, no mention of the config. Every `: ` below earns its place.\n */\n\n/**\n * The collector layer's own config-source variable — upstream's name, not ours. Pointed at a `yaml:` URI\n * it carries the entire configuration inline, so no second variable is needed to hold it.\n *\n * Upstream also reads the older `OPENTELEMETRY_COLLECTOR_CONFIG_FILE` and logs a deprecation warning for\n * it; this is the current name.\n */\nexport const ENV_COLLECTOR_CONFIG_URI = 'OPENTELEMETRY_COLLECTOR_CONFIG_URI';\n\n/**\n * The confmap provider that reads a configuration out of the URI itself. The collector registers\n * env/file/yaml/http/https/s3 providers; `yaml:` is the only one that needs no second variable and no\n * network read on a cold start.\n */\nconst COLLECTOR_CONFIG_SCHEME = 'yaml:';\n\n/**\n * Mirrors the baked config's processor set, and the ORDER is the contract:\n *\n *   - `memory_limiter` first, so an export backlog is shed before it is charged to the same memory budget\n *     the customer's handler allocates from. Percentages, not `limit_mib`, because one layer serves\n *     functions from 128MB to 10GB.\n *   - `decouple` LAST. Lambda freezes the sandbox once the handler returns and every extension has called\n *     /next; a frozen sandbox runs no timers, so a batch sitting behind its timeout is flushed on a later\n *     invocation or dropped when the sandbox is reaped. `decouple` acknowledges the receive path\n *     immediately and tracks in-flight exports, which is what lets the extension hold /next open until the\n *     queue drains — after the caller already has its response.\n */\nconst COLLECTOR_PROCESSORS =\n  '{memory_limiter: {check_interval: 1s, limit_percentage: 50, spike_limit_percentage: 20}, ' +\n  'batch: {send_batch_size: 512, timeout: 200ms}, decouple: null}';\n\n/** Value an unsupported signal's `OTEL_*_EXPORTER` is set to. */\nexport const EXPORTER_NONE = 'none';\n\n/** The three `OTEL_*_EXPORTER` variables, in the order the connector writes them. */\nexport const ENV_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER';\nexport const ENV_METRICS_EXPORTER = 'OTEL_METRICS_EXPORTER';\nexport const ENV_LOGS_EXPORTER = 'OTEL_LOGS_EXPORTER';\n\n/** Whether a signal is enabled, defaulting to on. */\nexport function signalEnabled(value: boolean | undefined): boolean {\n  return value !== false;\n}\n\n/**\n * Renders a double-quoted YAML scalar.\n *\n * Quoting unconditionally is what keeps a value such as a bare `host:4317` from being re-read as a nested\n * mapping in flow context. `JSON.stringify` is the TypeScript equivalent of the connector's\n * `strconv.Quote` for the vocabulary that matters here (`\\\"` and `\\\\`); both produce the same output for\n * the ASCII endpoints, header names and credentials this ever sees.\n */\nfunction yamlString(s: string): string {\n  return JSON.stringify(s);\n}\n\n/**\n * Picks the exporter by the transport the destination configured. A destination carries a gRPC endpoint\n * (type `otlp`) or an OTLP/HTTP one (type `otlphttp`); the two are different collector components with\n * different endpoint grammars, so this is a genuine branch.\n */\nexport function exporterNameFor(dest: OdigosDestination): string {\n  return dest.endpoint ? 'otlp' : 'otlphttp';\n}\n\n/**\n * Emits the destination's per-request headers — in practice its credential. Empty when the destination\n * needs none, so no header block is written at all rather than an empty one.\n *\n * Keys are sorted so the rendered config is byte-identical across synths. The string is compared against\n * the live function's environment to decide whether an update is needed, and map order would otherwise\n * make every deploy look like a change.\n */\nfunction renderHeaders(headers?: { [key: string]: string }): string {\n  if (!headers) {\n    return '';\n  }\n  const keys = Object.keys(headers).sort();\n  if (keys.length === 0) {\n    return '';\n  }\n  const rendered = keys.map((k) => `${yamlString(k)}: ${yamlString(headers[k])}`).join(', ');\n  return `, headers: {${rendered}}`;\n}\n\nfunction renderExporter(dest: OdigosDestination): string {\n  let out: string;\n  if (dest.endpoint) {\n    // tls.insecure applies to the gRPC exporter only; the HTTP exporter takes the scheme from the URL.\n    out = `{otlp: {endpoint: ${yamlString(dest.endpoint)}, tls: {insecure: ${dest.insecure === true}}`;\n  } else if (dest.httpEndpoint) {\n    out = `{otlphttp: {endpoint: ${yamlString(dest.httpEndpoint)}`;\n  } else {\n    // Reached when a destination carries neither transport. Failing here is the whole point: the\n    // alternative is a collector that exits on startup while the function is reported healthy.\n    throw new Error(\n      'Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP), ' +\n        'so the in-Lambda collector would have nowhere to export.',\n    );\n  }\n  return `${out}${renderHeaders(dest.headers)}}}`;\n}\n\n/**\n * Builds a pipeline only for the signals the destination accepts. A signal with no pipeline is refused at\n * the receiver, which is the behaviour we want: the SDK is told not to produce it either (see\n * `exporterOverrideFor`), and the two together mean an unaccepted signal is never generated, never\n * exported, and never a per-batch error against a backend that does not implement it.\n */\nfunction renderPipelines(dest: OdigosDestination, exporterName: string): string {\n  const parts: string[] = [];\n  const signals: Array<[string, boolean]> = [\n    ['traces', signalEnabled(dest.traces)],\n    ['metrics', signalEnabled(dest.metrics)],\n    ['logs', signalEnabled(dest.logs)],\n  ];\n  for (const [name, enabled] of signals) {\n    if (!enabled) {\n      continue;\n    }\n    parts.push(\n      `${name}: {receivers: [otlp], processors: [memory_limiter, batch, decouple], exporters: [${exporterName}]}`,\n    );\n  }\n  return parts.length === 0 ? '' : `{${parts.join(', ')}}`;\n}\n\n/**\n * Returns the value a signal's `OTEL_*_EXPORTER` must hold: `none` to suppress a signal the destination\n * does not accept, or `undefined` meaning the variable must be ABSENT because the SDK's own default is\n * already what we want.\n *\n * Only the \"none\" side is written, because `otlp` is already every OpenTelemetry SDK's default for all\n * three signals — setting it would restate the default in three variables on every function.\n */\nexport function exporterOverrideFor(supported: boolean): string | undefined {\n  return supported ? undefined : EXPORTER_NONE;\n}\n\n/**\n * Renders the complete collector configuration for one destination.\n *\n * @throws if the destination names neither transport, both transports, or no signals at all.\n */\nexport function renderCollectorConfig(dest: OdigosDestination): string {\n  if (dest.endpoint && dest.httpEndpoint) {\n    throw new Error(\n      'Odigos destination sets both `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP); ' +\n        'they select different collector exporters, so exactly one must be set.',\n    );\n  }\n\n  const exporter = renderExporter(dest);\n  const pipelines = renderPipelines(dest, exporterNameFor(dest));\n  if (pipelines === '') {\n    throw new Error(\n      'Odigos destination accepts no telemetry signals (traces, metrics and logs are all false), ' +\n        'so the collector would have no pipeline to build and would fail to start.',\n    );\n  }\n\n  return (\n    COLLECTOR_CONFIG_SCHEME +\n    '{receivers: {otlp: {protocols: ' +\n    // Bound to localhost: the receiver exists only for the in-process SDK. Binding it wider would expose\n    // an unauthenticated OTLP endpoint on the sandbox's network interface.\n    '{grpc: {endpoint: \"localhost:4317\"}, http: {endpoint: \"localhost:4318\"}}}}, ' +\n    'processors: ' +\n    COLLECTOR_PROCESSORS +\n    ', exporters: ' +\n    exporter +\n    ', service: {telemetry: {metrics: {level: none}}, pipelines: ' +\n    pipelines +\n    '}}'\n  );\n}\n"]}

package/lib/generated/layers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Produced by cdk/scripts/generate-layers.ts from artifacts.json and manifest/layers.json.
+ * Run `npm run generate` (or `npm run build`) to refresh it.
+ *
+ * Odigos artifact version: (unreleased)
+ */
+/** Release this table was generated from. Empty before the first release. */
+export declare const ODIGOS_VERSION = "";
+/** SAR semantic version matching ODIGOS_VERSION (no leading "v"). */
+export declare const SAR_SEMANTIC_VERSION = "";
+/** Public layer ARNs, keyed "<region>/<language>/<architecture>". */
+export declare const LAYER_ARNS: {
+    [key: string]: string;
+};
+/** SAR application ids, keyed "<language>/<architecture>". */
+export declare const SAR_APPLICATIONS: {
+    [key: string]: string;
+};
+/** Loader configuration for web-server (Lambda Web Adapter) mode. */
+export interface GeneratedWebServerLoader {
+    readonly envKey: string;
+    readonly separator: string;
+    readonly prepend: boolean;
+    readonly value: string;
+    readonly extraEnv: {
+        [key: string]: string;
+    };
+}
+/** Static per-language facts, mirrored from the connector's instrumentor. */
+export interface GeneratedLanguageSpec {
+    readonly layerName: string;
+    readonly execWrapper: string;
+    readonly compatibleRuntimes: string[];
+    readonly handlerDistros?: {
+        [key: string]: string;
+    };
+    readonly webServer: GeneratedWebServerLoader | null;
+}
+export declare const LANGUAGES: {
+    [language: string]: GeneratedLanguageSpec;
+};
+/** Architectures every language is built for. */
+export declare const ARCHITECTURES: string[];

package/lib/generated/layers.js

@@ -0,0 +1,101 @@
+"use strict";
+/* eslint-disable */
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Produced by cdk/scripts/generate-layers.ts from artifacts.json and manifest/layers.json.
+ * Run `npm run generate` (or `npm run build`) to refresh it.
+ *
+ * Odigos artifact version: (unreleased)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARCHITECTURES = exports.LANGUAGES = exports.SAR_APPLICATIONS = exports.LAYER_ARNS = exports.SAR_SEMANTIC_VERSION = exports.ODIGOS_VERSION = void 0;
+/** Release this table was generated from. Empty before the first release. */
+exports.ODIGOS_VERSION = "";
+/** SAR semantic version matching ODIGOS_VERSION (no leading "v"). */
+exports.SAR_SEMANTIC_VERSION = "";
+/** Public layer ARNs, keyed "<region>/<language>/<architecture>". */
+exports.LAYER_ARNS = {};
+/** SAR application ids, keyed "<language>/<architecture>". */
+exports.SAR_APPLICATIONS = {};
+exports.LANGUAGES = {
+    "python": {
+        "layerName": "odigos-otel-python",
+        "execWrapper": "/opt/otel-instrument",
+        "compatibleRuntimes": [
+            "python3.9",
+            "python3.10",
+            "python3.11",
+            "python3.12",
+            "python3.13",
+            "python3.14"
+        ],
+        "webServer": {
+            "envKey": "PYTHONPATH",
+            "separator": ":",
+            "prepend": true,
+            "value": "/opt/python:/opt/python/opentelemetry/instrumentation/auto_instrumentation:/var/task:/var/task/site-packages",
+            "extraEnv": {
+                "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf"
+            }
+        }
+    },
+    "nodejs": {
+        "layerName": "odigos-otel-nodejs",
+        "execWrapper": "/opt/otel-handler",
+        "compatibleRuntimes": [
+            "nodejs18.x",
+            "nodejs20.x",
+            "nodejs22.x",
+            "nodejs24.x"
+        ],
+        "webServer": {
+            "envKey": "NODE_OPTIONS",
+            "separator": " ",
+            "prepend": false,
+            "value": "--import /opt/init.mjs",
+            "extraEnv": {}
+        }
+    },
+    "java": {
+        "layerName": "odigos-otel-java",
+        "execWrapper": "/opt/otel-handler",
+        "compatibleRuntimes": [
+            "java8.al2",
+            "java11",
+            "java17",
+            "java21",
+            "java25"
+        ],
+        "handlerDistros": {
+            "otel-handler": "/opt/otel-handler",
+            "otel-proxy-handler": "/opt/otel-proxy-handler",
+            "otel-sqs-handler": "/opt/otel-sqs-handler",
+            "otel-stream-handler": "/opt/otel-stream-handler"
+        },
+        "webServer": {
+            "envKey": "JAVA_TOOL_OPTIONS",
+            "separator": " ",
+            "prepend": false,
+            "value": "-javaagent:/opt/opentelemetry-javaagent.jar",
+            "extraEnv": {}
+        }
+    },
+    "ruby": {
+        "layerName": "odigos-otel-ruby",
+        "execWrapper": "/opt/otel-handler",
+        "compatibleRuntimes": [
+            "ruby3.2",
+            "ruby3.3",
+            "ruby3.4",
+            "ruby4.0"
+        ],
+        "webServer": null
+    }
+};
+/** Architectures every language is built for. */
+exports.ARCHITECTURES = [
+    "x86_64",
+    "arm64"
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './instrumentation';
+export { odigosLayerName } from './layer-resolver';
+export { languageFromRuntime, execWrapperFor, layerNameFor } from './runtime';
+export { renderCollectorConfig, ENV_COLLECTOR_CONFIG_URI, ENV_TRACES_EXPORTER, ENV_METRICS_EXPORTER, ENV_LOGS_EXPORTER, } from './collector-config';
+export { ODIGOS_VERSION, LAYER_ARNS, SAR_APPLICATIONS, SAR_SEMANTIC_VERSION } from './generated/layers';