@odigos/aws-cdk 0.0.19 → 0.0.20

package/README.md

@@ -3,10 +3,18 @@
 Instrument AWS Lambda functions and ECS Fargate services with OpenTelemetry, from your own CDK app.
 
 ```bash
-npm install @odigos/aws-cdk        # TypeScript / JavaScript
-pip install odigos-aws-cdk         # Python
+npm install @odigos/aws-cdk@0.0.19
 ```
 
+The npm package is published. The corrections in this checkout need a new package release before
+customers receive them through npm. To use this checkout locally, run `npm ci`, `npm run build`, and
+`npm run package` in `cdk/`, then install `dist/js/aws-cdk@0.0.0.jsii.tgz` in the consuming app.
+
+The Python distribution is built by jsii but is not published on PyPI;
+`pip install odigos-aws-cdk` currently fails. Python examples below apply to a locally built wheel:
+run `npm ci`, `npm run build`, then `npm run package` from `cdk/`, and install the wheel under `dist/python/`.
+For customer installation until PyPI publishing is enabled, use the CloudFormation instructions instead.
+
 | | Lambda | ECS Fargate |
 |---|---|---|
 | Construct | `OdigosLambdaInstrumentation` | `OdigosFargateInstrumentation` |
@@ -15,7 +23,8 @@ pip install odigos-aws-cdk         # Python
 | Where telemetry goes | a collector in the same Lambda sandbox, which forwards | your destination, from the application process |
 | Language detection | from the function's declared runtime | none — you state the language |
 
-Both write `ODIGOS_IAC` and never the connector's ownership marker: instrumented by Odigos, owned by you.
+Lambda writes `odigos:iac=v1` and exact SDK/collector layer ARNs as function tags. Fargate writes an
+`ODIGOS_IAC` environment marker on each application container. Neither claims connector-managed ownership.
 
 # AWS Lambda
 
@@ -37,8 +46,13 @@ OdigosLambdaInstrumentation(self, "Odigos",
 )
 ```
 
-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.
+That attaches the matching layer(s), sets `AWS_LAMBDA_EXEC_WRAPPER`, and writes the readable version-2
+`ODIGOS_LAMBDA_CONFIG` JSON. The layer launcher builds SDK settings and collector pipelines at startup;
+customer SDK environment variables remain saved unchanged in AWS. Public and in-account layers must be
+from `v0.0.19` or newer to read this configuration; a custom `layerVersion` must have the same bootstrap.
+
+Apply instrumentation before creating published versions and aliases, then deploy the updated version and
+point all traffic-serving aliases at it. Updating `$LATEST` alone does not instrument older versions.
 
 ## How the telemetry actually leaves the function
 
@@ -87,8 +101,8 @@ If you mirror the layer somewhere yourself, pass `layerVersion` and neither path
 
 ## 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
+**The package version is the artifact release version.** `@odigos/aws-cdk@0.0.19` resolves to layers built and
+published by Odigos release `v0.0.19`, and pins the SAR application to semantic version `0.0.19` — 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
@@ -102,8 +116,9 @@ changed nothing, is not a property you want.
 
 `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.
+wrapper. This mode sets `AWS_LAMBDA_EXEC_WRAPPER=/opt/odigos-webserver`, records the previous wrapper in
+`ODIGOS_LAMBDA_CONFIG.webWrapper`, loads the agent through its language loader, then invokes the saved
+wrapper. Define the adapter's wrapper before applying instrumentation so it is preserved.
 
 ```ts
 new OdigosLambdaInstrumentation(this, 'Odigos', {
@@ -120,9 +135,9 @@ layers, which at synth time are frequently unresolved tokens; a detector that wa
 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.
+The launcher preserves and joins the function's existing loader value at startup. `existingLoaderValue`
+is an optional override: when supplied, CDK saves it unchanged as the customer's loader variable, and the
+launcher adds instrumentation in its child process. Omit it to preserve the loader already in the function.
 
 Ruby has no verified web-server loader and is rejected at synth in this mode.
 
@@ -137,14 +152,35 @@ javaHandlerDistro: OdigosJavaHandlerDistro.OTEL_STREAM_HANDLER
 
 | Distro | For |
 |---|---|
-| `OTEL_HANDLER` (default) | `RequestHandler` |
+| `OTEL_HANDLER` | `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.
+Java defaults to the full `java-lambda-otel-agent`, which supports handler and stream interfaces. The
+legacy `javaHandlerDistro` option explicitly selects a lightweight wrapper. `OTEL_HANDLER` implements
+`RequestHandler`; use `OTEL_STREAM_HANDLER` for `RequestStreamHandler` when selecting a lightweight wrapper.
+Prefer the equivalent `distro` IDs below. Do not set both options.
+
+## Distributions and ADOT
+
+Set `distro` to the exact connector catalog ID. A fixed distro must match every function on that construct.
+
+| Language | Default | Alternatives |
+|---|---|---|
+| Java | `java-lambda-otel-agent` | `java-lambda-otel-wrapper`, `java-lambda-otel-proxy-wrapper`, `java-lambda-otel-sqs-wrapper`, `java-lambda-otel-stream-wrapper`, `java-lambda-adot`, `java-lambda-adot-application-signals` |
+| Node.js | `nodejs-lambda-otel` | `nodejs-lambda-adot`, `nodejs-lambda-adot-application-signals` |
+| Python | `python-lambda-otel` | `python-lambda-adot`, `python-lambda-adot-application-signals` |
+| Ruby | `ruby-lambda-otel` | none |
+
+ADOT uses two architecture-matched layers: the language SDK and `adot-collector`. If mirroring the SDK
+with `layerVersion`, also supply `collectorLayerVersion` or let `layerSource` resolve the collector.
+ADOT supports Java 11/17/21, Node.js 18/20/22/24, and Python 3.10–3.13. ADOT and lightweight Java wrappers
+cannot use `WEB_SERVER` mode. Plain ADOT disables Application Signals. The Application Signals presets
+require traces **and** metrics, add `CloudWatchLambdaApplicationSignalsExecutionRolePolicy` to the Lambda
+role, and require one-time CloudWatch Application Signals account/region setup. For an immutable imported
+role, attach the policy separately. These presets also send enriched spans to Lambda's embedded AWS agent;
+Node.js/Python's AWS-derived service metrics do not become ordinary OTLP metrics at a custom destination.
 
 ## Signals
 
@@ -164,9 +200,8 @@ duration. Traces are what nearly every destination accepts; the other two are a
 destination, so they are made deliberately.
 
 A disabled signal gets no collector pipeline **and** the SDK is told not to produce it
-(`OTEL_METRICS_EXPORTER=none`). 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. An enabled signal's variable
-stays unset, because `otlp` is already the SDK default.
+(`OTEL_METRICS_EXPORTER=none`) inside the launcher's child process. Enabled signals explicitly select
+`otlp` there. Both halves matter: a signal with no pipeline would otherwise be refused on every batch.
 
 `traces: false` with neither of the others on throws at synth — a collector with no pipeline fails to
 start, which would leave the function instrumented and silent.
@@ -191,27 +226,19 @@ because explicitly asking to instrument a Go function is a mistake worth failing
 
 ## Credentials in `headers`
 
-`destination.headers` is rendered into `OPENTELEMETRY_COLLECTOR_CONFIG_URI`, which is a plain Lambda
+`destination.headers` is rendered into `ODIGOS_LAMBDA_CONFIG`, 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.
 
 ## How Odigos recognises the function
 
-These constructs write `ODIGOS_IAC` on every function they instrument, recording the layer ARN they attached
-and the package version that attached it. That variable is what Odigos reads to attribute the function to
-itself; without it a function reports as `Absent` — "awaiting your deployment" — however completely the layer,
-wrapper and collector configuration are applied. There is nothing to switch on.
-
-The recorded layer ARN matters beyond attribution: it is what the connector checks the function against, so a
-version you pinned is respected instead of being reported as drift the day Odigos publishes a newer one. It
-works in `IN_ACCOUNT` mode too, where the ARN is a deploy-time reference your own code has no way to obtain.
+Lambda attribution uses `odigos:iac=v1`, `odigos:sdk-layer`, and (for ADOT) `odigos:collector-layer`
+function tags. The recorded ARNs identify the exact attached layer versions, including SAR output tokens.
+There is no Lambda `ODIGOS_IAC` environment marker. Fargate uses its per-container environment marker.
 
-What these constructs never write is `ODIGOS_MANAGED`. That is the connector's own record of a mutation *it*
-performed, including the `prevEnv` snapshot it restores from on rollback, and it is written only when you hand
-a function to the connector by enabling it as an automatic-mode source. A CDK stack has no such snapshot to
-offer — nothing was mutated, your stack *is* the function's definition — so writing it would claim a rollback
-that was never recorded. Do not add it by hand.
+The connector's `odigos:managed` Lambda tag and `ODIGOS_MANAGED` Fargate marker describe mutations and
+rollback snapshots owned by the connector. Do not add them to an IaC-managed workload.
 
 ## Service names
 
@@ -233,8 +260,7 @@ source ends up owned by both: each `cdk deploy` reasserts the CDK's environment,
 the connector's, and every round trip publishes a new function version.
 
 Pick one per function. Discovery-only (manual) mode is the combination that works: Odigos watches and
-reports, your stack owns the configuration. That is what `ODIGOS_IAC` expresses — instrumented by Odigos,
-owned by you — and it is why these constructs never write the connector's ownership marker.
+reports, your stack owns the configuration. The IaC markers express that ownership.
 
 # ECS Fargate
 
@@ -338,8 +364,10 @@ taskDefinition.addContainer('App', {
 // becomes: -Xmx512m -javaagent:/var/odigos/java/javaagent.jar
 ```
 
-Pass `existingLoaderValue` when the value is not visible at synth — set by an `environmentFiles` entry,
-baked into the image's own `ENV`, or supplied through `secrets`.
+Pass `existingLoaderValue` when the value is not visible at synth — set by an `environmentFiles` entry
+or baked into the image's own `ENV`. Do not supply a generated instrumentation variable through ECS
+`secrets`: it conflicts with the ordinary environment setting and is rejected. Move loader options into
+ordinary application configuration before applying instrumentation.
 
 `PHP_INI_SCAN_DIR` and `RUBYOPT` are the exception: Odigos compares them **exactly**, so they are set
 outright and a value already there is reported as a synth warning rather than merged. Fold what your
@@ -366,18 +394,18 @@ Endpoint and protocol are one decision, and are compared as one. Pairing an endp
 protocol fails at runtime as a connection reset that points nowhere near the cause, so an endpoint on the
 other protocol's standard port (4317 with `http/protobuf`, 4318 with `grpc`) is a synth warning.
 
-Unlike Lambda, `destination.headers` is rendered into `OTEL_EXPORTER_OTLP_HEADERS` on the container. The
-connector does not set or compare that variable when it instruments a Fargate task itself, so it is
-neither reconciled nor reported as drift — it is here because a task with no collector of its own has
-nowhere else to hold a credential. Same exposure caveat as Lambda: `ecs:DescribeTaskDefinition` and the
-console can read it.
+On Fargate, `destination.headers` is rendered into `OTEL_EXPORTER_OTLP_HEADERS` as a sorted, URL-encoded
+header list matching the connector. Pass raw header values, such as `Bearer token`, and let the construct
+encode them. The connector compares the transport, endpoint and headers against the selected destination.
+`ecs:DescribeTaskDefinition` and the console can read these values; task revisions can retain them.
 
 ## Signals
 
 Same defaults as Lambda — traces on, metrics and logs opt-in — and the same requirement that they match
 what Odigos has configured for the destination. All three `OTEL_*_EXPORTER` variables are written
-explicitly here, unlike Lambda where an enabled signal's variable is left unset, because the connector's
-Fargate check compares all three by value.
+explicitly here. Lambda sets the same selectors inside the launcher rather than storing them in AWS.
+Ruby Fargate supports traces only; Ruby Lambda also supports function stdout/stderr logs, but no metrics.
+Unsupported Ruby signals and profiles generate synth warnings; they do not activate missing exporters.
 
 ## A task definition with more than one application
 
@@ -394,7 +422,11 @@ odigos.instrumentAll([
 ```
 
 AWS caps a task definition at 10 containers and the staging container needs one of them; a definition
-already at the limit fails at synth rather than on `RegisterTaskDefinition`.
+already at the limit fails at synth rather than on `RegisterTaskDefinition`. Several constructs can share
+the staging container only when they use the same agents image. Instrument each application container once.
+Existing manual `odigos-agent` containers/volumes and conflicting mounts are rejected; remove those manual
+resources before adopting the construct. Use Linux Fargate platform version `1.3.0` or newer (`LATEST` is
+recommended) so the `SUCCESS` startup dependency is supported.
 
 ## The agents image
 
@@ -404,7 +436,7 @@ task's execution role at every task start**, so a task in a private subnet with
 endpoint cannot pull it. Mirror it into a registry your tasks can reach and pass `agentsImage`:
 
 ```ts
-agentsImage: '111122223333.dkr.ecr.eu-west-1.amazonaws.com/odigos-fargate-agents:v0.0.13',
+agentsImage: '111122223333.dkr.ecr.eu-west-1.amazonaws.com/odigos-fargate-agents:v0.0.19',
 ```
 
 A mirror has to be the same bundle — the activation environment names exact paths inside it. The bundle is
@@ -426,6 +458,38 @@ automatic-mode source is owned by both: each `cdk deploy` reasserts your stack's
 reconcile reasserts the connector's, and every round trip registers a revision and rolls the service.
 Discovery-only (manual) mode is the combination that works.
 
+# Bill of materials and removal
+
+| Flow | Resources and configuration left by deployment |
+|---|---|
+| Lambda public/custom layer | Layer reference(s), wrapper and compact config environment variables, IaC layer tags, new published versions/aliases if your app creates them |
+| Lambda `IN_ACCOUNT` | The above plus one SAR nested stack/layer per artifact family and architecture; ADOT adds the shared collector application |
+| Application Signals | The above plus a managed-policy attachment on the Lambda role; account-wide discovery is configured separately |
+| Fargate | A task-definition revision with one non-essential copier, one shared volume, mounts/dependencies, activation/export environment and per-container IaC marker; an ECS deployment when the service references that revision |
+
+The constructs do not create a regional Collector, network routes, telemetry destination, or customer
+credentials. Provision and remove those using their separate guides. Registry access and destination
+reachability are deployment prerequisites.
+
+To uninstall instrumentation while keeping the application:
+
+1. Disable automatic connector ownership for the workload, then remove the instrumentation construct,
+   `instrument()` calls or aspect from your app. Restore any explicit loader override you no longer want.
+2. Run `cdk diff`, review removal of the instrumentation resources/settings, then run `cdk deploy`.
+   For Lambda, publish the uninstrumented version and move every serving alias to it. For Fargate,
+   ensure the service references the new task revision and wait for the rollout to finish.
+3. Verify the application is healthy and sends no new Odigos telemetry. Old published Lambda versions
+   and ECS revisions remain instrumented until retired; review all traffic and rollback references first.
+4. SAR layers use retention policies and can remain after stack removal. After no function or published
+   version references one, remove that exact retained layer version with
+   `aws lambda delete-layer-version --layer-name "<LAYER_NAME>" --version-number "<LAYER_VERSION>"`.
+   Never delete a shared layer still in use. Retire unused task revisions through your existing ECS lifecycle.
+5. Remove dedicated, unused role policy attachments and telemetry credentials after confirming no other
+   consumer needs them. Configurations retained in versions, task revisions and IaC history may still hold
+   headers. Account-wide Application Signals discovery and its service-linked role are separate resources.
+
+`cdk destroy` removes the entire application stack and is only appropriate when retiring that application.
+
 # API
 
 | Export | |
@@ -439,7 +503,7 @@ Discovery-only (manual) mode is the combination that works.
 | `OdigosLayerSource` | `ODIGOS_PUBLIC` \| `IN_ACCOUNT` |
 | `OdigosInstrumentationMode` | `HANDLER` \| `WEB_SERVER` |
 | `OdigosJavaHandlerDistro` | the four Java wrappers |
-| `renderCollectorConfig` | the Lambda collector config renderer, if you want to inspect what gets set |
+| `renderCollectorConfig` | legacy inline collector config renderer for validation; the compact launcher generates the deployed config |
 | `sidecarCommand`, `evaluateAppendPattern` | the Fargate staging command and loader-value rendering |
 | `LAYER_ARNS`, `ODIGOS_VERSION` | the baked layer table and the release it came from |
 | `FARGATE_AGENTS_IMAGE`, `FARGATE_DISTROS_VERSION` | the agents image this build stages, and the distros release its recipes mirror |

package/lib/collector-config.d.ts

@@ -92,6 +92,8 @@ export declare function signalActivation(language: string, dest: OdigosDestinati
  * @throws if the destination names neither transport, both transports, or no signals at all.
  */
 export declare function renderCollectorConfig(dest: OdigosDestination): string;
+/** Validate both transports before generating Lambda configuration or mutating an ECS task. */
+export declare function validateDestination(dest: OdigosDestination, allowBoth?: boolean): void;
 /** The Lambda Node layer registers only dns/http/net unless explicitly configured. */
 export declare function lambdaSignalActivation(language: string, dest: OdigosDestination): {
     [key: string]: string;

package/lib/collector-config.js

@@ -8,7 +8,9 @@ exports.exporterOverrideFor = exporterOverrideFor;
 exports.signalTransportOverrides = signalTransportOverrides;
 exports.signalActivation = signalActivation;
 exports.renderCollectorConfig = renderCollectorConfig;
+exports.validateDestination = validateDestination;
 exports.lambdaSignalActivation = lambdaSignalActivation;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
 /**
  * Renders the legacy in-Lambda collector configuration for validation and parity tests as an inline
  * `OPENTELEMETRY_COLLECTOR_CONFIG_URI` value.
@@ -207,22 +209,7 @@ function signalActivation(language, dest) {
  * @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.');
-    }
-    // The two fields have different endpoint GRAMMARS, and getting them wrong is the worst failure mode this
-    // package has: the collector accepts the configuration, fails to build its exporter, and exits — leaving
-    // the function instrumented, reporting healthy, and exporting nothing. Both checks are therefore synth
-    // errors rather than documentation.
-    if (dest.endpoint && dest.endpoint.includes('://')) {
-        throw new Error(`Odigos destination \`endpoint\` is "${dest.endpoint}", but the gRPC exporter takes host:port with ` +
-            'no scheme. Use `httpEndpoint` for a scheme-qualified OTLP/HTTP URL.');
-    }
-    if (dest.httpEndpoint && !/^https?:\/\//.test(dest.httpEndpoint)) {
-        throw new Error(`Odigos destination \`httpEndpoint\` is "${dest.httpEndpoint}", but the OTLP/HTTP exporter takes a ` +
-            'scheme-qualified URL (http:// or https://). Use `endpoint` for a bare gRPC host:port.');
-    }
+    validateDestination(dest);
     const exporter = renderExporter(dest);
     const pipelines = renderPipelines(dest, exporterNameFor(dest));
     if (pipelines === '') {
@@ -243,6 +230,42 @@ function renderCollectorConfig(dest) {
         pipelines +
         '}}');
 }
+/** Validate both transports before generating Lambda configuration or mutating an ECS task. */
+function validateDestination(dest, allowBoth = false) {
+    if (dest.endpoint && dest.httpEndpoint && !allowBoth) {
+        throw new Error('Odigos destination sets both `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP); exactly one must be set for Lambda.');
+    }
+    if (!dest.endpoint && !dest.httpEndpoint) {
+        throw new Error('Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP).');
+    }
+    if (dest.endpoint && !aws_cdk_lib_1.Token.isUnresolved(dest.endpoint)) {
+        if (dest.endpoint.includes('://')) {
+            throw new Error('Odigos destination `endpoint` takes host:port with no scheme. Use `httpEndpoint` for an HTTP URL.');
+        }
+        let url;
+        try {
+            url = new URL(`http://${dest.endpoint}`);
+        }
+        catch {
+            throw new Error('Odigos destination `endpoint` must be a valid gRPC host:port.');
+        }
+        if (!url.hostname || url.username || url.password || url.pathname !== '/' || url.search || url.hash || /\s/.test(dest.endpoint)) {
+            throw new Error('Odigos destination `endpoint` must be a bare gRPC host:port without credentials, paths or query parameters.');
+        }
+    }
+    if (dest.httpEndpoint && !aws_cdk_lib_1.Token.isUnresolved(dest.httpEndpoint)) {
+        let url;
+        try {
+            url = new URL(dest.httpEndpoint);
+        }
+        catch {
+            throw new Error('Odigos destination `httpEndpoint` requires a valid scheme-qualified URL (http:// or https://).');
+        }
+        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash || /\s/.test(dest.httpEndpoint)) {
+            throw new Error('Odigos destination `httpEndpoint` requires a scheme-qualified URL (http:// or https://) without embedded credentials or fragments.');
+        }
+    }
+}
 /** The Lambda Node layer registers only dns/http/net unless explicitly configured. */
 function lambdaSignalActivation(language, dest) {
     const env = signalActivation(language, dest);
@@ -252,4 +275,4 @@ function lambdaSignalActivation(language, dest) {
     }
     return env;
 }
-//# 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 legacy in-Lambda collector configuration for validation and parity tests 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/**\n * Whether a signal is enabled, given the caller's value and the signal's own default.\n *\n * The defaults are NOT uniform: traces are on, metrics and logs are off (see `SIGNAL_DEFAULTS`). So the\n * default has to travel with the signal rather than being folded into one \"unset means on\" rule.\n */\nexport function signalEnabled(value: boolean | undefined, defaultEnabled: boolean): boolean {\n  return value ?? defaultEnabled;\n}\n\n/**\n * Which signals a destination carries when the caller says nothing.\n *\n * TRACES ONLY. Metrics and logs are opt-in because the cost of having them on by default falls on people\n * who never asked for them: a destination that does not implement a signal refuses every batch of it, and\n * the in-Lambda collector then retries on an exponential backoff inside billed duration. Traces are what\n * almost every destination accepts and what almost everyone instruments for; the other two are a\n * deliberate choice about the destination, so they are made deliberately.\n *\n * Turning one on is `metrics: true`. Enabling a signal sets `OTEL_*_EXPORTER=otlp` explicitly.\n */\nexport const SIGNAL_DEFAULTS = { traces: true, metrics: false, logs: false };\n\n/** The three signals resolved against their defaults — the single place that pairing is decided. */\nexport function resolvedSignals(dest: OdigosDestination): { traces: boolean; metrics: boolean; logs: boolean } {\n  return {\n    traces: signalEnabled(dest.traces, SIGNAL_DEFAULTS.traces),\n    metrics: signalEnabled(dest.metrics, SIGNAL_DEFAULTS.metrics),\n    logs: signalEnabled(dest.logs, SIGNAL_DEFAULTS.logs),\n  };\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 enabled = resolvedSignals(dest);\n  const signals: Array<[string, boolean]> = [\n    ['traces', enabled.traces],\n    ['metrics', enabled.metrics],\n    ['logs', enabled.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/** Explicit exporter selectors mirror the base connector policy; SDK defaults vary. */\nexport function exporterOverrideFor(enabled: boolean): string {\n  return enabled ? 'otlp' : EXPORTER_NONE;\n}\n\n/** Per-signal transport overrides bypass the destination and must not coexist with it. */\nexport function signalTransportOverrides(): string[] {\n  return ['TRACES', 'METRICS', 'LOGS'].flatMap((signal) =>\n    ['ENDPOINT', 'PROTOCOL', 'HEADERS', 'INSECURE'].map((setting) => `OTEL_EXPORTER_OTLP_${signal}_${setting}`),\n  );\n}\n\n/** Language-specific SDK activation, shared by Lambda and Fargate. */\nexport function signalActivation(language: string, dest: OdigosDestination): { [key: string]: string } {\n  const enabled = resolvedSignals(dest);\n  const env: { [key: string]: string } = {\n    OTEL_SDK_DISABLED: 'false',\n    [ENV_TRACES_EXPORTER]: exporterOverrideFor(enabled.traces),\n    [ENV_METRICS_EXPORTER]: exporterOverrideFor(enabled.metrics),\n    [ENV_LOGS_EXPORTER]: exporterOverrideFor(enabled.logs),\n  };\n  if (language === 'python') {\n    env.OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED = String(enabled.logs);\n  }\n  return env;\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  // The two fields have different endpoint GRAMMARS, and getting them wrong is the worst failure mode this\n  // package has: the collector accepts the configuration, fails to build its exporter, and exits — leaving\n  // the function instrumented, reporting healthy, and exporting nothing. Both checks are therefore synth\n  // errors rather than documentation.\n  if (dest.endpoint && dest.endpoint.includes('://')) {\n    throw new Error(\n      `Odigos destination \\`endpoint\\` is \"${dest.endpoint}\", but the gRPC exporter takes host:port with ` +\n        'no scheme. Use `httpEndpoint` for a scheme-qualified OTLP/HTTP URL.',\n    );\n  }\n  if (dest.httpEndpoint && !/^https?:\\/\\//.test(dest.httpEndpoint)) {\n    throw new Error(\n      `Odigos destination \\`httpEndpoint\\` is \"${dest.httpEndpoint}\", but the OTLP/HTTP exporter takes a ` +\n        'scheme-qualified URL (http:// or https://). Use `endpoint` for a bare gRPC host:port.',\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, so the collector would have no pipeline to build ' +\n        'and would fail to start. Note that metrics and logs are OFF by default — with `traces: false` the ' +\n        'destination has nothing left unless you also pass `metrics: true` or `logs: true`.',\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\n/** The Lambda Node layer registers only dns/http/net unless explicitly configured. */\nexport function lambdaSignalActivation(language: string, dest: OdigosDestination): { [key: string]: string } {\n  const env = signalActivation(language, dest);\n  env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/protobuf';\n  if (language === 'nodejs') {\n    env.OTEL_NODE_ENABLED_INSTRUMENTATIONS = 'amqplib,bunyan,cassandra-driver,connect,dataloader,dns,express,fs,graphql,grpc,hapi,http,ioredis,kafkajs,knex,koa,memcached,mongodb,mongoose,mysql,mysql2,nestjs-core,net,pg,pino,redis,restify,socket.io,undici,winston';\n  }\n  return env;\n}\n"]}
+//# 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 { Token } from 'aws-cdk-lib';\nimport { OdigosDestination } from './types';\n\n/**\n * Renders the legacy in-Lambda collector configuration for validation and parity tests 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/**\n * Whether a signal is enabled, given the caller's value and the signal's own default.\n *\n * The defaults are NOT uniform: traces are on, metrics and logs are off (see `SIGNAL_DEFAULTS`). So the\n * default has to travel with the signal rather than being folded into one \"unset means on\" rule.\n */\nexport function signalEnabled(value: boolean | undefined, defaultEnabled: boolean): boolean {\n  return value ?? defaultEnabled;\n}\n\n/**\n * Which signals a destination carries when the caller says nothing.\n *\n * TRACES ONLY. Metrics and logs are opt-in because the cost of having them on by default falls on people\n * who never asked for them: a destination that does not implement a signal refuses every batch of it, and\n * the in-Lambda collector then retries on an exponential backoff inside billed duration. Traces are what\n * almost every destination accepts and what almost everyone instruments for; the other two are a\n * deliberate choice about the destination, so they are made deliberately.\n *\n * Turning one on is `metrics: true`. Enabling a signal sets `OTEL_*_EXPORTER=otlp` explicitly.\n */\nexport const SIGNAL_DEFAULTS = { traces: true, metrics: false, logs: false };\n\n/** The three signals resolved against their defaults — the single place that pairing is decided. */\nexport function resolvedSignals(dest: OdigosDestination): { traces: boolean; metrics: boolean; logs: boolean } {\n  return {\n    traces: signalEnabled(dest.traces, SIGNAL_DEFAULTS.traces),\n    metrics: signalEnabled(dest.metrics, SIGNAL_DEFAULTS.metrics),\n    logs: signalEnabled(dest.logs, SIGNAL_DEFAULTS.logs),\n  };\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 enabled = resolvedSignals(dest);\n  const signals: Array<[string, boolean]> = [\n    ['traces', enabled.traces],\n    ['metrics', enabled.metrics],\n    ['logs', enabled.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/** Explicit exporter selectors mirror the base connector policy; SDK defaults vary. */\nexport function exporterOverrideFor(enabled: boolean): string {\n  return enabled ? 'otlp' : EXPORTER_NONE;\n}\n\n/** Per-signal transport overrides bypass the destination and must not coexist with it. */\nexport function signalTransportOverrides(): string[] {\n  return ['TRACES', 'METRICS', 'LOGS'].flatMap((signal) =>\n    ['ENDPOINT', 'PROTOCOL', 'HEADERS', 'INSECURE'].map((setting) => `OTEL_EXPORTER_OTLP_${signal}_${setting}`),\n  );\n}\n\n/** Language-specific SDK activation, shared by Lambda and Fargate. */\nexport function signalActivation(language: string, dest: OdigosDestination): { [key: string]: string } {\n  const enabled = resolvedSignals(dest);\n  const env: { [key: string]: string } = {\n    OTEL_SDK_DISABLED: 'false',\n    [ENV_TRACES_EXPORTER]: exporterOverrideFor(enabled.traces),\n    [ENV_METRICS_EXPORTER]: exporterOverrideFor(enabled.metrics),\n    [ENV_LOGS_EXPORTER]: exporterOverrideFor(enabled.logs),\n  };\n  if (language === 'python') {\n    env.OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED = String(enabled.logs);\n  }\n  return env;\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  validateDestination(dest);\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, so the collector would have no pipeline to build ' +\n        'and would fail to start. Note that metrics and logs are OFF by default — with `traces: false` the ' +\n        'destination has nothing left unless you also pass `metrics: true` or `logs: true`.',\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\n/** Validate both transports before generating Lambda configuration or mutating an ECS task. */\nexport function validateDestination(dest: OdigosDestination, allowBoth = false): void {\n  if (dest.endpoint && dest.httpEndpoint && !allowBoth) {\n    throw new Error('Odigos destination sets both `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP); exactly one must be set for Lambda.');\n  }\n  if (!dest.endpoint && !dest.httpEndpoint) {\n    throw new Error('Odigos destination has neither `endpoint` (OTLP/gRPC) nor `httpEndpoint` (OTLP/HTTP).');\n  }\n  if (dest.endpoint && !Token.isUnresolved(dest.endpoint)) {\n    if (dest.endpoint.includes('://')) {\n      throw new Error('Odigos destination `endpoint` takes host:port with no scheme. Use `httpEndpoint` for an HTTP URL.');\n    }\n    let url: URL;\n    try { url = new URL(`http://${dest.endpoint}`); } catch {\n      throw new Error('Odigos destination `endpoint` must be a valid gRPC host:port.');\n    }\n    if (!url.hostname || url.username || url.password || url.pathname !== '/' || url.search || url.hash || /\\s/.test(dest.endpoint)) {\n      throw new Error('Odigos destination `endpoint` must be a bare gRPC host:port without credentials, paths or query parameters.');\n    }\n  }\n  if (dest.httpEndpoint && !Token.isUnresolved(dest.httpEndpoint)) {\n    let url: URL;\n    try { url = new URL(dest.httpEndpoint); } catch {\n      throw new Error('Odigos destination `httpEndpoint` requires a valid scheme-qualified URL (http:// or https://).');\n    }\n    if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password || url.hash || /\\s/.test(dest.httpEndpoint)) {\n      throw new Error('Odigos destination `httpEndpoint` requires a scheme-qualified URL (http:// or https://) without embedded credentials or fragments.');\n    }\n  }\n}\n\n/** The Lambda Node layer registers only dns/http/net unless explicitly configured. */\nexport function lambdaSignalActivation(language: string, dest: OdigosDestination): { [key: string]: string } {\n  const env = signalActivation(language, dest);\n  env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/protobuf';\n  if (language === 'nodejs') {\n    env.OTEL_NODE_ENABLED_INSTRUMENTATIONS = 'amqplib,bunyan,cassandra-driver,connect,dataloader,dns,express,fs,graphql,grpc,hapi,http,ioredis,kafkajs,knex,koa,memcached,mongodb,mongoose,mysql,mysql2,nestjs-core,net,pg,pino,redis,restify,socket.io,undici,winston';\n  }\n  return env;\n}\n"]}