@odigos/aws-cdk 0.0.21 → 0.0.22

package/lib/types.d.ts

@@ -119,6 +119,60 @@ export declare enum OdigosFargateLanguage {
      */
     RUBY = "ruby"
 }
+/**
+ * The language of an Amazon Bedrock AgentCore Runtime's application.
+ *
+ * Stated rather than detected. A container artifact declares an image, and even a code artifact's runtime
+ * says nothing about how the artifact was PREPARED — which is what this selects: the Odigos SDK profile
+ * bundled into the artifact. The values are the connector's canonical language keys, because they are
+ * written verbatim into `ODIGOS_AGENTCORE_PACKAGE` and the distro name the connector checks the runtime
+ * against.
+ *
+ * Only Python 3.12 and CommonJS Node.js 22 artifacts are qualified. Native ESM Node.js applications need
+ * explicit SDK initialization and are not covered by this recipe.
+ */
+export declare enum OdigosAgentCoreLanguage {
+    /** Python (3.12). */
+    PYTHON = "python",
+    /** Node.js (22, CommonJS). */
+    NODEJS = "nodejs"
+}
+/**
+ * The OpenTelemetry SDK profile the AgentCore artifact was prepared with.
+ *
+ * It must be the profile actually bundled into the artifact. The construct cannot see the artifact, so a
+ * mismatch is not caught at synth: the connector reports the runtime as non-conformant, and the runtime
+ * starts the bootstrap for a profile that is not on disk.
+ */
+export declare enum OdigosAgentCoreDistribution {
+    /** AWS Distro for OpenTelemetry — the connector's default profile for both languages. */
+    ADOT = "adot",
+    /** OpenLLMetry Bedrock instrumentation on the upstream OpenTelemetry SDK. */
+    OPENLLMETRY = "openllmetry"
+}
+/**
+ * How the AgentCore artifact carries its OpenTelemetry SDK, which decides the environment recipe.
+ *
+ * Mirrors the connector's delivery modes for a manually instrumented runtime. The construct cannot see the
+ * artifact, so this must say how it was actually prepared: the connector reads the mode back from
+ * `ODIGOS_AGENTCORE_PACKAGE` and compares the runtime against that recipe.
+ */
+export declare enum OdigosAgentCoreDelivery {
+    /**
+     * The artifact carries the Odigos package (`odigos-agentcore` / `@odigos/agentcore`) or the carrier
+     * bundle, whose dormant bootstrap this environment switches on. The bootstrap roots each invocation at
+     * the agent and links AgentCore's own service span.
+     */
+    PACKAGE = "package",
+    /**
+     * The artifact carries AWS Distro for OpenTelemetry only, started through its own launcher
+     * (`opentelemetry-instrument` for Python, `--require @aws/aws-distro-opentelemetry-node-autoinstrumentation/register`
+     * in `NODE_OPTIONS` for Node.js). No Odigos code runs: the bootstrap switches are removed and the X-Ray
+     * propagator is dropped. ADOT cannot root an invocation at the agent, so AgentCore's service span stays
+     * missing from the trace. Only `OdigosAgentCoreDistribution.ADOT` can be adopted.
+     */
+    ADOPT = "adopt"
+}
 /**
  * Where the in-Lambda collector exports telemetry to.
  *

package/lib/types.js

@@ -9,7 +9,7 @@
  * the instrumented function's next cold start.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OdigosFargateLanguage = exports.OdigosJavaHandlerDistro = exports.OdigosInstrumentationMode = exports.OdigosLayerSource = void 0;
+exports.OdigosAgentCoreDelivery = exports.OdigosAgentCoreDistribution = exports.OdigosAgentCoreLanguage = exports.OdigosFargateLanguage = exports.OdigosJavaHandlerDistro = exports.OdigosInstrumentationMode = exports.OdigosLayerSource = void 0;
 /**
  * Where the Odigos layer attached to a function comes from.
  */
@@ -126,4 +126,61 @@ var OdigosFargateLanguage;
      */
     OdigosFargateLanguage["RUBY"] = "ruby";
 })(OdigosFargateLanguage || (exports.OdigosFargateLanguage = OdigosFargateLanguage = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH;;GAEG;AACH,IAAY,iBAwBX;AAxBD,WAAY,iBAAiB;IAC3B;;;;;;;;;OASG;IACH,oDAA+B,CAAA;IAE/B;;;;;;;;;OASG;IACH,8CAAyB,CAAA;AAC3B,CAAC,EAxBW,iBAAiB,iCAAjB,iBAAiB,QAwB5B;AAED;;;;;GAKG;AACH,IAAY,yBAoBX;AApBD,WAAY,yBAAyB;IACnC;;;;;OAKG;IACH,gDAAmB,CAAA;IAEnB;;;;;;;;;OASG;IACH,sDAAyB,CAAA;AAC3B,CAAC,EApBW,yBAAyB,yCAAzB,yBAAyB,QAoBpC;AAED;;;;;;;;;;GAUG;AACH,IAAY,uBASX;AATD,WAAY,uBAAuB;IACjC,uGAAuG;IACvG,wDAA6B,CAAA;IAC7B,iFAAiF;IACjF,oEAAyC,CAAA;IACzC,iEAAiE;IACjE,gEAAqC,CAAA;IACrC,sEAAsE;IACtE,sEAA2C,CAAA;AAC7C,CAAC,EATW,uBAAuB,uCAAvB,uBAAuB,QASlC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,qBAmBX;AAnBD,WAAY,qBAAqB;IAC/B,qFAAqF;IACrF,sCAAa,CAAA;IACb,8CAA8C;IAC9C,0CAAiB,CAAA;IACjB,iDAAiD;IACjD,0CAAiB,CAAA;IACjB,4EAA4E;IAC5E,0CAAiB,CAAA;IACjB;;;OAGG;IACH,oCAAW,CAAA;IACX;;;OAGG;IACH,sCAAa,CAAA;AACf,CAAC,EAnBW,qBAAqB,qCAArB,qBAAqB,QAmBhC","sourcesContent":["/**\n * Public option types.\n *\n * Everything here is either a `readonly` struct or an enum. That is a jsii requirement — the package is\n * cross-compiled to Python, and jsii rejects union types, structural interfaces with methods, and\n * overloads — but it is also what keeps the API describable in a table, which matters more for\n * instrumentation options than for most libraries: a wrong value here does not fail at synth, it fails at\n * the instrumented function's next cold start.\n */\n\n/**\n * Where the Odigos layer attached to a function comes from.\n */\nexport enum OdigosLayerSource {\n  /**\n   * Reference the public Odigos layer version published in the stack's region.\n   *\n   * One line of synthesized template, no extra resources, and the layer is maintained by Odigos. The ARN\n   * is resolved at synth time from the manifest baked into this package, so there is no lookup, no custom\n   * resource and no deploy-time API call — and a `cdk diff` shows a layer change as an actual diff.\n   *\n   * The layer is owned by the Odigos AWS account. Organisations whose policy forbids attaching a Lambda\n   * layer owned by a foreign account want `IN_ACCOUNT` instead.\n   */\n  ODIGOS_PUBLIC = 'ODIGOS_PUBLIC',\n\n  /**\n   * Deploy the Odigos Serverless Application Repository application into this account and attach the\n   * layer it creates.\n   *\n   * Synthesizes an `AWS::Serverless::Application` (a nested stack) per language/architecture actually in\n   * use, and wires its `LayerVersionArn` output into the function. The layer ends up in the customer's own\n   * account, created by their own stack, from the same bytes as the public one.\n   *\n   * Costs a nested stack per language/architecture combination and makes the first deploy slower.\n   */\n  IN_ACCOUNT = 'IN_ACCOUNT',\n}\n\n/**\n * How a function is instrumented.\n *\n * The two modes are genuinely different mechanisms, not levels of detail, and applying the wrong one\n * breaks the function rather than degrading its telemetry.\n */\nexport enum OdigosInstrumentationMode {\n  /**\n   * Standard Lambda handler. Sets `AWS_LAMBDA_EXEC_WRAPPER` to the language's wrapper script, which the\n   * layer uses to load the OpenTelemetry SDK around the handler invocation.\n   *\n   * The default, and correct for any function whose entry point is a Lambda handler.\n   */\n  HANDLER = 'HANDLER',\n\n  /**\n   * A function running a web server behind the AWS Lambda Web Adapter.\n   *\n   * The adapter's existing wrapper is saved in `ODIGOS_LAMBDA_CONFIG.webWrapper`. This mode sets\n   * `/opt/odigos-webserver`, which loads the language agent and then invokes the saved wrapper.\n   * Define the adapter wrapper before applying instrumentation. Existing loader options are preserved.\n   *\n   * Setting `HANDLER` on a web-adapter function overwrites the adapter's wrapper and the function stops\n   * serving. Ruby has no verified web-server loader and is rejected at synth in this mode.\n   */\n  WEB_SERVER = 'WEB_SERVER',\n}\n\n/**\n * Which of the Java layer's four wrapper scripts to use.\n *\n * Only consulted for Java: every other language's layer ships exactly one wrapper, so an override there\n * would be a choice between one option.\n *\n * Picking the wrong one is not a matter of richer or poorer spans. `OTEL_HANDLER` installs\n * `TracingRequestWrapper`, which implements `RequestHandler`; a function implementing\n * `RequestStreamHandler` has a different signature entirely, so wrapping it that way breaks the\n * invocation.\n */\nexport enum OdigosJavaHandlerDistro {\n  /** `/opt/otel-handler` — a `RequestHandler` function when explicitly selecting this legacy adapter. */\n  OTEL_HANDLER = 'OTEL_HANDLER',\n  /** `/opt/otel-proxy-handler` — enriched wrapper for API Gateway proxy events. */\n  OTEL_PROXY_HANDLER = 'OTEL_PROXY_HANDLER',\n  /** `/opt/otel-sqs-handler` — enriched wrapper for SQS events. */\n  OTEL_SQS_HANDLER = 'OTEL_SQS_HANDLER',\n  /** `/opt/otel-stream-handler` — a `RequestStreamHandler` function. */\n  OTEL_STREAM_HANDLER = 'OTEL_STREAM_HANDLER',\n}\n\n/**\n * The language whose OpenTelemetry agent is staged into an ECS Fargate container.\n *\n * There is no auto-detection, and unlike Lambda that is not a choice: a Lambda function declares its\n * runtime as a property CloudFormation can be asked for, while a Fargate container declares an image.\n * Resolving a language from an image means pulling it and reading its config, which is deploy-time I/O a\n * synth cannot do — and the connector, which CAN do it, still accepts a runtime override for the cases it\n * gets wrong. So the language is stated.\n *\n * The MEMBER VALUES are the connector's canonical language keys rather than a restatement of the member\n * names, because these values are load-bearing twice over: they are what the `ODIGOS_IAC` marker records\n * as `lang`, which is what the connector's conformance check rebuilds the container's expected activation\n * environment from, and they name the agent directory the staging container copies.\n *\n * Go is absent by platform design, not omission. Its only zero-code instrumentation is eBPF, and Fargate\n * forbids the privileged containers and host PID an eBPF agent needs — no override enables it. Instrument\n * a Go application with the OpenTelemetry Go SDK instead.\n */\nexport enum OdigosFargateLanguage {\n  /** JVM applications — Java, Kotlin, Scala. Activated through `JAVA_TOOL_OPTIONS`. */\n  JAVA = 'java',\n  /** Python. Activated through `PYTHONPATH`. */\n  PYTHON = 'python',\n  /** Node.js. Activated through `NODE_OPTIONS`. */\n  NODEJS = 'nodejs',\n  /** .NET, glibc only — the bundle ships no musl (Alpine) native profiler. */\n  DOTNET = 'dotnet',\n  /**\n   * PHP. Needs `runtimeVersion` (major.minor): its agent is laid down per runtime version, and the\n   * version selects the path `PHP_INI_SCAN_DIR` points at.\n   */\n  PHP = 'php',\n  /**\n   * Ruby. Needs `runtimeVersion` (major.minor), for the same reason as PHP — the version selects the path\n   * `RUBYOPT` requires.\n   */\n  RUBY = 'ruby',\n}\n\n/**\n * Where the in-Lambda collector exports telemetry to.\n *\n * Exactly one of `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP) must be set. They are different\n * collector components with different endpoint grammars — `host:port` versus a scheme-qualified URL — so\n * this is a genuine branch and not a formatting difference. Setting neither, or both, throws at synth.\n *\n * ON ECS FARGATE, WHERE THE SAME STRUCT IS REUSED, BOTH MAY BE SET AND OFTEN SHOULD BE. There is no\n * collector in the task, so the language agent exports to this destination itself, and which transport it\n * can use is a property of the agent: the php and ruby community SDKs speak OTLP/HTTP only, so a task\n * holding one of those alongside a gRPC-only destination cannot be instrumented at all. Giving both\n * endpoints lets each language take the transport it prefers. One struct rather than two so a stack that\n * instruments Lambda functions and Fargate services describes its destination once.\n *\n * NOTE ON THE DATA PATH. The function's SDK does not export here. It exports to the collector running\n * inside the same Lambda sandbox on localhost, and the collector forwards to this destination after the\n * handler has already returned its response. That indirection is the point: a slow or unreachable\n * destination costs billed duration, not caller latency.\n *\n * THIS MUST DESCRIBE THE SAME DESTINATION ODIGOS HAS CONFIGURED, SIGNAL FOR SIGNAL. The connector renders\n * this same configuration from its own destination record and compares the whole rendered document against\n * what the function carries, so any difference — the endpoint, the credential, or which of the three signals\n * is enabled — is reported as instrumentation drift on the workload rather than being reconciled. The\n * asymmetry to watch is the signals: `traces` is on here and `metrics`/`logs` are off, while a destination in\n * Odigos commonly has more than one enabled. A stack that leaves the defaults against such a destination\n * reports as drifted for a reason nothing in the stack makes visible, so read the enabled signals off the\n * destination in Odigos and state them here.\n */\nexport interface OdigosDestination {\n  /**\n   * OTLP/gRPC destination as `host:port`, e.g. `otlp.example.com:4317`.\n   *\n   * No scheme. A URL here produces a collector that fails to build its exporter and exits, leaving the\n   * function instrumented and silent.\n   *\n   * @default - none; `httpEndpoint` must be set instead\n   */\n  readonly endpoint?: string;\n\n  /**\n   * OTLP/HTTP destination as a full URL, e.g. `https://otlp.example.com:4318`.\n   *\n   * @default - none; `endpoint` must be set instead\n   */\n  readonly httpEndpoint?: string;\n\n  /**\n   * Connect to the gRPC exporter without TLS (plaintext).\n   *\n   * Applies to `endpoint` only — the HTTP exporter takes its transport from the URL scheme.\n   *\n   * @default false\n   */\n  readonly insecure?: boolean;\n\n  /**\n   * Per-request headers, in practice the destination's credential.\n   *\n   * These are included in compact `ODIGOS_LAMBDA_CONFIG`, which is a plain Lambda environment\n   * variable: readable by anyone with `lambda:GetFunctionConfiguration` and visible in the console. For a\n   * long-lived credential prefer a destination that authenticates by network position, or terminate at a\n   * collector you control.\n   *\n   * On ECS Fargate they are rendered into `OTEL_EXPORTER_OTLP_HEADERS` on the instrumented container,\n   * with the same exposure — `ecs:DescribeTaskDefinition` and the console. Values are URL-encoded by the construct; pass raw header values. The connector compares the\n   * headers together with the endpoint and protocol against the selected destination.\n   *\n   * @default - no headers\n   */\n  readonly headers?: { [key: string]: string };\n\n  /**\n   * Send traces.\n   *\n   * A signal that is off gets no collector pipeline AND the SDK is told not to produce it\n   * (`OTEL_TRACES_EXPORTER=none` in the startup process). Both halves matter: a signal with no pipeline is refused at the\n   * receiver on every batch, so suppressing it at the source is what stops the error loop.\n   *\n   * Turning this off without turning on `metrics` or `logs` leaves the destination with no signal at all,\n   * which throws at synth — a collector with no pipeline fails to start.\n   *\n   * @default true\n   */\n  readonly traces?: boolean;\n\n  /**\n   * Send metrics. OFF unless you turn it on.\n   *\n   * Opt-in rather than on-by-default because the cost of a signal the destination does not implement is\n   * paid by the function: every batch is refused and the in-Lambda collector retries it on an exponential\n   * backoff, inside billed duration. Traces are what nearly every destination accepts; metrics are a\n   * choice about the destination, so they are made explicitly.\n   *\n   * @default false\n   */\n  readonly metrics?: boolean;\n\n  /**\n   * Send logs. OFF unless you turn it on.\n   *\n   * Opt-in for the same reason as `metrics`. Note that a Lambda function's stdout already reaches\n   * CloudWatch Logs regardless of this setting; this controls only what the OpenTelemetry SDK emits to\n   * the in-Lambda collector and the collector forwards to your destination.\n   *\n   * @default false\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Retains profiling intent. Current language bundles do not generate OTLP profiles;\n   * enabling this emits a warning and does not activate a profiler.\n   * @default false\n   */\n  readonly profiles?: boolean;\n}\n"]}
+/**
+ * The language of an Amazon Bedrock AgentCore Runtime's application.
+ *
+ * Stated rather than detected. A container artifact declares an image, and even a code artifact's runtime
+ * says nothing about how the artifact was PREPARED — which is what this selects: the Odigos SDK profile
+ * bundled into the artifact. The values are the connector's canonical language keys, because they are
+ * written verbatim into `ODIGOS_AGENTCORE_PACKAGE` and the distro name the connector checks the runtime
+ * against.
+ *
+ * Only Python 3.12 and CommonJS Node.js 22 artifacts are qualified. Native ESM Node.js applications need
+ * explicit SDK initialization and are not covered by this recipe.
+ */
+var OdigosAgentCoreLanguage;
+(function (OdigosAgentCoreLanguage) {
+    /** Python (3.12). */
+    OdigosAgentCoreLanguage["PYTHON"] = "python";
+    /** Node.js (22, CommonJS). */
+    OdigosAgentCoreLanguage["NODEJS"] = "nodejs";
+})(OdigosAgentCoreLanguage || (exports.OdigosAgentCoreLanguage = OdigosAgentCoreLanguage = {}));
+/**
+ * The OpenTelemetry SDK profile the AgentCore artifact was prepared with.
+ *
+ * It must be the profile actually bundled into the artifact. The construct cannot see the artifact, so a
+ * mismatch is not caught at synth: the connector reports the runtime as non-conformant, and the runtime
+ * starts the bootstrap for a profile that is not on disk.
+ */
+var OdigosAgentCoreDistribution;
+(function (OdigosAgentCoreDistribution) {
+    /** AWS Distro for OpenTelemetry — the connector's default profile for both languages. */
+    OdigosAgentCoreDistribution["ADOT"] = "adot";
+    /** OpenLLMetry Bedrock instrumentation on the upstream OpenTelemetry SDK. */
+    OdigosAgentCoreDistribution["OPENLLMETRY"] = "openllmetry";
+})(OdigosAgentCoreDistribution || (exports.OdigosAgentCoreDistribution = OdigosAgentCoreDistribution = {}));
+/**
+ * How the AgentCore artifact carries its OpenTelemetry SDK, which decides the environment recipe.
+ *
+ * Mirrors the connector's delivery modes for a manually instrumented runtime. The construct cannot see the
+ * artifact, so this must say how it was actually prepared: the connector reads the mode back from
+ * `ODIGOS_AGENTCORE_PACKAGE` and compares the runtime against that recipe.
+ */
+var OdigosAgentCoreDelivery;
+(function (OdigosAgentCoreDelivery) {
+    /**
+     * The artifact carries the Odigos package (`odigos-agentcore` / `@odigos/agentcore`) or the carrier
+     * bundle, whose dormant bootstrap this environment switches on. The bootstrap roots each invocation at
+     * the agent and links AgentCore's own service span.
+     */
+    OdigosAgentCoreDelivery["PACKAGE"] = "package";
+    /**
+     * The artifact carries AWS Distro for OpenTelemetry only, started through its own launcher
+     * (`opentelemetry-instrument` for Python, `--require @aws/aws-distro-opentelemetry-node-autoinstrumentation/register`
+     * in `NODE_OPTIONS` for Node.js). No Odigos code runs: the bootstrap switches are removed and the X-Ray
+     * propagator is dropped. ADOT cannot root an invocation at the agent, so AgentCore's service span stays
+     * missing from the trace. Only `OdigosAgentCoreDistribution.ADOT` can be adopted.
+     */
+    OdigosAgentCoreDelivery["ADOPT"] = "adopt";
+})(OdigosAgentCoreDelivery || (exports.OdigosAgentCoreDelivery = OdigosAgentCoreDelivery = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH;;GAEG;AACH,IAAY,iBAwBX;AAxBD,WAAY,iBAAiB;IAC3B;;;;;;;;;OASG;IACH,oDAA+B,CAAA;IAE/B;;;;;;;;;OASG;IACH,8CAAyB,CAAA;AAC3B,CAAC,EAxBW,iBAAiB,iCAAjB,iBAAiB,QAwB5B;AAED;;;;;GAKG;AACH,IAAY,yBAoBX;AApBD,WAAY,yBAAyB;IACnC;;;;;OAKG;IACH,gDAAmB,CAAA;IAEnB;;;;;;;;;OASG;IACH,sDAAyB,CAAA;AAC3B,CAAC,EApBW,yBAAyB,yCAAzB,yBAAyB,QAoBpC;AAED;;;;;;;;;;GAUG;AACH,IAAY,uBASX;AATD,WAAY,uBAAuB;IACjC,uGAAuG;IACvG,wDAA6B,CAAA;IAC7B,iFAAiF;IACjF,oEAAyC,CAAA;IACzC,iEAAiE;IACjE,gEAAqC,CAAA;IACrC,sEAAsE;IACtE,sEAA2C,CAAA;AAC7C,CAAC,EATW,uBAAuB,uCAAvB,uBAAuB,QASlC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAY,qBAmBX;AAnBD,WAAY,qBAAqB;IAC/B,qFAAqF;IACrF,sCAAa,CAAA;IACb,8CAA8C;IAC9C,0CAAiB,CAAA;IACjB,iDAAiD;IACjD,0CAAiB,CAAA;IACjB,4EAA4E;IAC5E,0CAAiB,CAAA;IACjB;;;OAGG;IACH,oCAAW,CAAA;IACX;;;OAGG;IACH,sCAAa,CAAA;AACf,CAAC,EAnBW,qBAAqB,qCAArB,qBAAqB,QAmBhC;AAED;;;;;;;;;;;GAWG;AACH,IAAY,uBAKX;AALD,WAAY,uBAAuB;IACjC,qBAAqB;IACrB,4CAAiB,CAAA;IACjB,8BAA8B;IAC9B,4CAAiB,CAAA;AACnB,CAAC,EALW,uBAAuB,uCAAvB,uBAAuB,QAKlC;AAED;;;;;;GAMG;AACH,IAAY,2BAKX;AALD,WAAY,2BAA2B;IACrC,yFAAyF;IACzF,4CAAa,CAAA;IACb,6EAA6E;IAC7E,0DAA2B,CAAA;AAC7B,CAAC,EALW,2BAA2B,2CAA3B,2BAA2B,QAKtC;AAED;;;;;;GAMG;AACH,IAAY,uBAeX;AAfD,WAAY,uBAAuB;IACjC;;;;OAIG;IACH,8CAAmB,CAAA;IACnB;;;;;;OAMG;IACH,0CAAe,CAAA;AACjB,CAAC,EAfW,uBAAuB,uCAAvB,uBAAuB,QAelC","sourcesContent":["/**\n * Public option types.\n *\n * Everything here is either a `readonly` struct or an enum. That is a jsii requirement — the package is\n * cross-compiled to Python, and jsii rejects union types, structural interfaces with methods, and\n * overloads — but it is also what keeps the API describable in a table, which matters more for\n * instrumentation options than for most libraries: a wrong value here does not fail at synth, it fails at\n * the instrumented function's next cold start.\n */\n\n/**\n * Where the Odigos layer attached to a function comes from.\n */\nexport enum OdigosLayerSource {\n  /**\n   * Reference the public Odigos layer version published in the stack's region.\n   *\n   * One line of synthesized template, no extra resources, and the layer is maintained by Odigos. The ARN\n   * is resolved at synth time from the manifest baked into this package, so there is no lookup, no custom\n   * resource and no deploy-time API call — and a `cdk diff` shows a layer change as an actual diff.\n   *\n   * The layer is owned by the Odigos AWS account. Organisations whose policy forbids attaching a Lambda\n   * layer owned by a foreign account want `IN_ACCOUNT` instead.\n   */\n  ODIGOS_PUBLIC = 'ODIGOS_PUBLIC',\n\n  /**\n   * Deploy the Odigos Serverless Application Repository application into this account and attach the\n   * layer it creates.\n   *\n   * Synthesizes an `AWS::Serverless::Application` (a nested stack) per language/architecture actually in\n   * use, and wires its `LayerVersionArn` output into the function. The layer ends up in the customer's own\n   * account, created by their own stack, from the same bytes as the public one.\n   *\n   * Costs a nested stack per language/architecture combination and makes the first deploy slower.\n   */\n  IN_ACCOUNT = 'IN_ACCOUNT',\n}\n\n/**\n * How a function is instrumented.\n *\n * The two modes are genuinely different mechanisms, not levels of detail, and applying the wrong one\n * breaks the function rather than degrading its telemetry.\n */\nexport enum OdigosInstrumentationMode {\n  /**\n   * Standard Lambda handler. Sets `AWS_LAMBDA_EXEC_WRAPPER` to the language's wrapper script, which the\n   * layer uses to load the OpenTelemetry SDK around the handler invocation.\n   *\n   * The default, and correct for any function whose entry point is a Lambda handler.\n   */\n  HANDLER = 'HANDLER',\n\n  /**\n   * A function running a web server behind the AWS Lambda Web Adapter.\n   *\n   * The adapter's existing wrapper is saved in `ODIGOS_LAMBDA_CONFIG.webWrapper`. This mode sets\n   * `/opt/odigos-webserver`, which loads the language agent and then invokes the saved wrapper.\n   * Define the adapter wrapper before applying instrumentation. Existing loader options are preserved.\n   *\n   * Setting `HANDLER` on a web-adapter function overwrites the adapter's wrapper and the function stops\n   * serving. Ruby has no verified web-server loader and is rejected at synth in this mode.\n   */\n  WEB_SERVER = 'WEB_SERVER',\n}\n\n/**\n * Which of the Java layer's four wrapper scripts to use.\n *\n * Only consulted for Java: every other language's layer ships exactly one wrapper, so an override there\n * would be a choice between one option.\n *\n * Picking the wrong one is not a matter of richer or poorer spans. `OTEL_HANDLER` installs\n * `TracingRequestWrapper`, which implements `RequestHandler`; a function implementing\n * `RequestStreamHandler` has a different signature entirely, so wrapping it that way breaks the\n * invocation.\n */\nexport enum OdigosJavaHandlerDistro {\n  /** `/opt/otel-handler` — a `RequestHandler` function when explicitly selecting this legacy adapter. */\n  OTEL_HANDLER = 'OTEL_HANDLER',\n  /** `/opt/otel-proxy-handler` — enriched wrapper for API Gateway proxy events. */\n  OTEL_PROXY_HANDLER = 'OTEL_PROXY_HANDLER',\n  /** `/opt/otel-sqs-handler` — enriched wrapper for SQS events. */\n  OTEL_SQS_HANDLER = 'OTEL_SQS_HANDLER',\n  /** `/opt/otel-stream-handler` — a `RequestStreamHandler` function. */\n  OTEL_STREAM_HANDLER = 'OTEL_STREAM_HANDLER',\n}\n\n/**\n * The language whose OpenTelemetry agent is staged into an ECS Fargate container.\n *\n * There is no auto-detection, and unlike Lambda that is not a choice: a Lambda function declares its\n * runtime as a property CloudFormation can be asked for, while a Fargate container declares an image.\n * Resolving a language from an image means pulling it and reading its config, which is deploy-time I/O a\n * synth cannot do — and the connector, which CAN do it, still accepts a runtime override for the cases it\n * gets wrong. So the language is stated.\n *\n * The MEMBER VALUES are the connector's canonical language keys rather than a restatement of the member\n * names, because these values are load-bearing twice over: they are what the `ODIGOS_IAC` marker records\n * as `lang`, which is what the connector's conformance check rebuilds the container's expected activation\n * environment from, and they name the agent directory the staging container copies.\n *\n * Go is absent by platform design, not omission. Its only zero-code instrumentation is eBPF, and Fargate\n * forbids the privileged containers and host PID an eBPF agent needs — no override enables it. Instrument\n * a Go application with the OpenTelemetry Go SDK instead.\n */\nexport enum OdigosFargateLanguage {\n  /** JVM applications — Java, Kotlin, Scala. Activated through `JAVA_TOOL_OPTIONS`. */\n  JAVA = 'java',\n  /** Python. Activated through `PYTHONPATH`. */\n  PYTHON = 'python',\n  /** Node.js. Activated through `NODE_OPTIONS`. */\n  NODEJS = 'nodejs',\n  /** .NET, glibc only — the bundle ships no musl (Alpine) native profiler. */\n  DOTNET = 'dotnet',\n  /**\n   * PHP. Needs `runtimeVersion` (major.minor): its agent is laid down per runtime version, and the\n   * version selects the path `PHP_INI_SCAN_DIR` points at.\n   */\n  PHP = 'php',\n  /**\n   * Ruby. Needs `runtimeVersion` (major.minor), for the same reason as PHP — the version selects the path\n   * `RUBYOPT` requires.\n   */\n  RUBY = 'ruby',\n}\n\n/**\n * The language of an Amazon Bedrock AgentCore Runtime's application.\n *\n * Stated rather than detected. A container artifact declares an image, and even a code artifact's runtime\n * says nothing about how the artifact was PREPARED — which is what this selects: the Odigos SDK profile\n * bundled into the artifact. The values are the connector's canonical language keys, because they are\n * written verbatim into `ODIGOS_AGENTCORE_PACKAGE` and the distro name the connector checks the runtime\n * against.\n *\n * Only Python 3.12 and CommonJS Node.js 22 artifacts are qualified. Native ESM Node.js applications need\n * explicit SDK initialization and are not covered by this recipe.\n */\nexport enum OdigosAgentCoreLanguage {\n  /** Python (3.12). */\n  PYTHON = 'python',\n  /** Node.js (22, CommonJS). */\n  NODEJS = 'nodejs',\n}\n\n/**\n * The OpenTelemetry SDK profile the AgentCore artifact was prepared with.\n *\n * It must be the profile actually bundled into the artifact. The construct cannot see the artifact, so a\n * mismatch is not caught at synth: the connector reports the runtime as non-conformant, and the runtime\n * starts the bootstrap for a profile that is not on disk.\n */\nexport enum OdigosAgentCoreDistribution {\n  /** AWS Distro for OpenTelemetry — the connector's default profile for both languages. */\n  ADOT = 'adot',\n  /** OpenLLMetry Bedrock instrumentation on the upstream OpenTelemetry SDK. */\n  OPENLLMETRY = 'openllmetry',\n}\n\n/**\n * How the AgentCore artifact carries its OpenTelemetry SDK, which decides the environment recipe.\n *\n * Mirrors the connector's delivery modes for a manually instrumented runtime. The construct cannot see the\n * artifact, so this must say how it was actually prepared: the connector reads the mode back from\n * `ODIGOS_AGENTCORE_PACKAGE` and compares the runtime against that recipe.\n */\nexport enum OdigosAgentCoreDelivery {\n  /**\n   * The artifact carries the Odigos package (`odigos-agentcore` / `@odigos/agentcore`) or the carrier\n   * bundle, whose dormant bootstrap this environment switches on. The bootstrap roots each invocation at\n   * the agent and links AgentCore's own service span.\n   */\n  PACKAGE = 'package',\n  /**\n   * The artifact carries AWS Distro for OpenTelemetry only, started through its own launcher\n   * (`opentelemetry-instrument` for Python, `--require @aws/aws-distro-opentelemetry-node-autoinstrumentation/register`\n   * in `NODE_OPTIONS` for Node.js). No Odigos code runs: the bootstrap switches are removed and the X-Ray\n   * propagator is dropped. ADOT cannot root an invocation at the agent, so AgentCore's service span stays\n   * missing from the trace. Only `OdigosAgentCoreDistribution.ADOT` can be adopted.\n   */\n  ADOPT = 'adopt',\n}\n\n/**\n * Where the in-Lambda collector exports telemetry to.\n *\n * Exactly one of `endpoint` (OTLP/gRPC) and `httpEndpoint` (OTLP/HTTP) must be set. They are different\n * collector components with different endpoint grammars — `host:port` versus a scheme-qualified URL — so\n * this is a genuine branch and not a formatting difference. Setting neither, or both, throws at synth.\n *\n * ON ECS FARGATE, WHERE THE SAME STRUCT IS REUSED, BOTH MAY BE SET AND OFTEN SHOULD BE. There is no\n * collector in the task, so the language agent exports to this destination itself, and which transport it\n * can use is a property of the agent: the php and ruby community SDKs speak OTLP/HTTP only, so a task\n * holding one of those alongside a gRPC-only destination cannot be instrumented at all. Giving both\n * endpoints lets each language take the transport it prefers. One struct rather than two so a stack that\n * instruments Lambda functions and Fargate services describes its destination once.\n *\n * NOTE ON THE DATA PATH. The function's SDK does not export here. It exports to the collector running\n * inside the same Lambda sandbox on localhost, and the collector forwards to this destination after the\n * handler has already returned its response. That indirection is the point: a slow or unreachable\n * destination costs billed duration, not caller latency.\n *\n * THIS MUST DESCRIBE THE SAME DESTINATION ODIGOS HAS CONFIGURED, SIGNAL FOR SIGNAL. The connector renders\n * this same configuration from its own destination record and compares the whole rendered document against\n * what the function carries, so any difference — the endpoint, the credential, or which of the three signals\n * is enabled — is reported as instrumentation drift on the workload rather than being reconciled. The\n * asymmetry to watch is the signals: `traces` is on here and `metrics`/`logs` are off, while a destination in\n * Odigos commonly has more than one enabled. A stack that leaves the defaults against such a destination\n * reports as drifted for a reason nothing in the stack makes visible, so read the enabled signals off the\n * destination in Odigos and state them here.\n */\nexport interface OdigosDestination {\n  /**\n   * OTLP/gRPC destination as `host:port`, e.g. `otlp.example.com:4317`.\n   *\n   * No scheme. A URL here produces a collector that fails to build its exporter and exits, leaving the\n   * function instrumented and silent.\n   *\n   * @default - none; `httpEndpoint` must be set instead\n   */\n  readonly endpoint?: string;\n\n  /**\n   * OTLP/HTTP destination as a full URL, e.g. `https://otlp.example.com:4318`.\n   *\n   * @default - none; `endpoint` must be set instead\n   */\n  readonly httpEndpoint?: string;\n\n  /**\n   * Connect to the gRPC exporter without TLS (plaintext).\n   *\n   * Applies to `endpoint` only — the HTTP exporter takes its transport from the URL scheme.\n   *\n   * @default false\n   */\n  readonly insecure?: boolean;\n\n  /**\n   * Per-request headers, in practice the destination's credential.\n   *\n   * These are included in compact `ODIGOS_LAMBDA_CONFIG`, which is a plain Lambda environment\n   * variable: readable by anyone with `lambda:GetFunctionConfiguration` and visible in the console. For a\n   * long-lived credential prefer a destination that authenticates by network position, or terminate at a\n   * collector you control.\n   *\n   * On ECS Fargate they are rendered into `OTEL_EXPORTER_OTLP_HEADERS` on the instrumented container,\n   * with the same exposure — `ecs:DescribeTaskDefinition` and the console. Values are URL-encoded by the construct; pass raw header values. The connector compares the\n   * headers together with the endpoint and protocol against the selected destination.\n   *\n   * @default - no headers\n   */\n  readonly headers?: { [key: string]: string };\n\n  /**\n   * Send traces.\n   *\n   * A signal that is off gets no collector pipeline AND the SDK is told not to produce it\n   * (`OTEL_TRACES_EXPORTER=none` in the startup process). Both halves matter: a signal with no pipeline is refused at the\n   * receiver on every batch, so suppressing it at the source is what stops the error loop.\n   *\n   * Turning this off without turning on `metrics` or `logs` leaves the destination with no signal at all,\n   * which throws at synth — a collector with no pipeline fails to start.\n   *\n   * @default true\n   */\n  readonly traces?: boolean;\n\n  /**\n   * Send metrics. OFF unless you turn it on.\n   *\n   * Opt-in rather than on-by-default because the cost of a signal the destination does not implement is\n   * paid by the function: every batch is refused and the in-Lambda collector retries it on an exponential\n   * backoff, inside billed duration. Traces are what nearly every destination accepts; metrics are a\n   * choice about the destination, so they are made explicitly.\n   *\n   * @default false\n   */\n  readonly metrics?: boolean;\n\n  /**\n   * Send logs. OFF unless you turn it on.\n   *\n   * Opt-in for the same reason as `metrics`. Note that a Lambda function's stdout already reaches\n   * CloudWatch Logs regardless of this setting; this controls only what the OpenTelemetry SDK emits to\n   * the in-Lambda collector and the collector forwards to your destination.\n   *\n   * @default false\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Retains profiling intent. Current language bundles do not generate OTLP profiles;\n   * enabling this emits a warning and does not activate a profiler.\n   * @default false\n   */\n  readonly profiles?: boolean;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odigos/aws-cdk",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "CDK constructs that instrument AWS Lambda functions with the Odigos OpenTelemetry layer",
   "license": "Apache-2.0",
   "author": {