@odigos/aws-cdk 0.0.12 → 0.0.14

package/lib/types.d.ts

@@ -81,6 +81,44 @@ export declare enum OdigosJavaHandlerDistro {
     /** `/opt/otel-stream-handler` — a `RequestStreamHandler` function. */
     OTEL_STREAM_HANDLER = "OTEL_STREAM_HANDLER"
 }
+/**
+ * The language whose OpenTelemetry agent is staged into an ECS Fargate container.
+ *
+ * There is no auto-detection, and unlike Lambda that is not a choice: a Lambda function declares its
+ * runtime as a property CloudFormation can be asked for, while a Fargate container declares an image.
+ * Resolving a language from an image means pulling it and reading its config, which is deploy-time I/O a
+ * synth cannot do — and the connector, which CAN do it, still accepts a runtime override for the cases it
+ * gets wrong. So the language is stated.
+ *
+ * The MEMBER VALUES are the connector's canonical language keys rather than a restatement of the member
+ * names, because these values are load-bearing twice over: they are what the `ODIGOS_IAC` marker records
+ * as `lang`, which is what the connector's conformance check rebuilds the container's expected activation
+ * environment from, and they name the agent directory the staging container copies.
+ *
+ * Go is absent by platform design, not omission. Its only zero-code instrumentation is eBPF, and Fargate
+ * forbids the privileged containers and host PID an eBPF agent needs — no override enables it. Instrument
+ * a Go application with the OpenTelemetry Go SDK instead.
+ */
+export declare enum OdigosFargateLanguage {
+    /** JVM applications — Java, Kotlin, Scala. Activated through `JAVA_TOOL_OPTIONS`. */
+    JAVA = "java",
+    /** Python. Activated through `PYTHONPATH`. */
+    PYTHON = "python",
+    /** Node.js. Activated through `NODE_OPTIONS`. */
+    NODEJS = "nodejs",
+    /** .NET, glibc only — the bundle ships no musl (Alpine) native profiler. */
+    DOTNET = "dotnet",
+    /**
+     * PHP. Needs `runtimeVersion` (major.minor): its agent is laid down per runtime version, and the
+     * version selects the path `PHP_INI_SCAN_DIR` points at.
+     */
+    PHP = "php",
+    /**
+     * Ruby. Needs `runtimeVersion` (major.minor), for the same reason as PHP — the version selects the path
+     * `RUBYOPT` requires.
+     */
+    RUBY = "ruby"
+}
 /**
  * Where the in-Lambda collector exports telemetry to.
  *
@@ -88,10 +126,26 @@ export declare enum OdigosJavaHandlerDistro {
  * collector components with different endpoint grammars — `host:port` versus a scheme-qualified URL — so
  * this is a genuine branch and not a formatting difference. Setting neither, or both, throws at synth.
  *
+ * ON ECS FARGATE, WHERE THE SAME STRUCT IS REUSED, BOTH MAY BE SET AND OFTEN SHOULD BE. There is no
+ * collector in the task, so the language agent exports to this destination itself, and which transport it
+ * can use is a property of the agent: the php and ruby community SDKs speak OTLP/HTTP only, so a task
+ * holding one of those alongside a gRPC-only destination cannot be instrumented at all. Giving both
+ * endpoints lets each language take the transport it prefers. One struct rather than two so a stack that
+ * instruments Lambda functions and Fargate services describes its destination once.
+ *
  * NOTE ON THE DATA PATH. The function's SDK does not export here. It exports to the collector running
  * inside the same Lambda sandbox on localhost, and the collector forwards to this destination after the
  * handler has already returned its response. That indirection is the point: a slow or unreachable
  * destination costs billed duration, not caller latency.
+ *
+ * THIS MUST DESCRIBE THE SAME DESTINATION ODIGOS HAS CONFIGURED, SIGNAL FOR SIGNAL. The connector renders
+ * this same configuration from its own destination record and compares the whole rendered document against
+ * what the function carries, so any difference — the endpoint, the credential, or which of the three signals
+ * is enabled — is reported as instrumentation drift on the workload rather than being reconciled. The
+ * asymmetry to watch is the signals: `traces` is on here and `metrics`/`logs` are off, while a destination in
+ * Odigos commonly has more than one enabled. A stack that leaves the defaults against such a destination
+ * reports as drifted for a reason nothing in the stack makes visible, so read the enabled signals off the
+ * destination in Odigos and state them here.
  */
 export interface OdigosDestination {
     /**
@@ -125,6 +179,12 @@ export interface OdigosDestination {
      * long-lived credential prefer a destination that authenticates by network position, or terminate at a
      * collector you control.
      *
+     * On ECS Fargate they are rendered into `OTEL_EXPORTER_OTLP_HEADERS` on the instrumented container,
+     * with the same exposure — `ecs:DescribeTaskDefinition` and the console. Note that the connector does
+     * NOT set that variable when it instruments a Fargate task itself, and does not compare it, so this is
+     * neither reconciled nor reported as drift either way: it is here because an authenticated destination
+     * is otherwise unreachable from a task, which has no collector of its own to hold the credential.
+     *
      * @default - no headers
      */
     readonly headers?: {

package/lib/types.js

@@ -9,7 +9,7 @@
  * the instrumented function's next cold start.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OdigosJavaHandlerDistro = exports.OdigosInstrumentationMode = exports.OdigosLayerSource = void 0;
+exports.OdigosFargateLanguage = exports.OdigosJavaHandlerDistro = exports.OdigosInstrumentationMode = exports.OdigosLayerSource = void 0;
 /**
  * Where the Odigos layer attached to a function comes from.
  */
@@ -87,4 +87,43 @@ var OdigosJavaHandlerDistro;
     /** `/opt/otel-stream-handler` — a `RequestStreamHandler` function. */
     OdigosJavaHandlerDistro["OTEL_STREAM_HANDLER"] = "OTEL_STREAM_HANDLER";
 })(OdigosJavaHandlerDistro || (exports.OdigosJavaHandlerDistro = OdigosJavaHandlerDistro = {}));
-//# 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,sEAAsE;IACtE,wDAA6B,CAAA;IAC7B,iFAAiF;IACjF,oEAAyC,CAAA;IACzC,iEAAiE;IACjE,gEAAqC,CAAA;IACrC,sEAAsE;IACtE,sEAA2C,CAAA;AAC7C,CAAC,EATW,uBAAuB,uCAAvB,uBAAuB,QASlC","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 owns `AWS_LAMBDA_EXEC_WRAPPER`, so this mode does not touch it. Instrumentation is loaded\n   * through the language's own loader variable instead — `JAVA_TOOL_OPTIONS`, `NODE_OPTIONS` or\n   * `PYTHONPATH` — appended to (never replacing) whatever the function already sets.\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. The default. */\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 * 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 * 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 */\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   * Disable TLS verification on the gRPC exporter.\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 rendered into `OPENTELEMETRY_COLLECTOR_CONFIG_URI`, 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   * @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`). 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"]}
+/**
+ * The language whose OpenTelemetry agent is staged into an ECS Fargate container.
+ *
+ * There is no auto-detection, and unlike Lambda that is not a choice: a Lambda function declares its
+ * runtime as a property CloudFormation can be asked for, while a Fargate container declares an image.
+ * Resolving a language from an image means pulling it and reading its config, which is deploy-time I/O a
+ * synth cannot do — and the connector, which CAN do it, still accepts a runtime override for the cases it
+ * gets wrong. So the language is stated.
+ *
+ * The MEMBER VALUES are the connector's canonical language keys rather than a restatement of the member
+ * names, because these values are load-bearing twice over: they are what the `ODIGOS_IAC` marker records
+ * as `lang`, which is what the connector's conformance check rebuilds the container's expected activation
+ * environment from, and they name the agent directory the staging container copies.
+ *
+ * Go is absent by platform design, not omission. Its only zero-code instrumentation is eBPF, and Fargate
+ * forbids the privileged containers and host PID an eBPF agent needs — no override enables it. Instrument
+ * a Go application with the OpenTelemetry Go SDK instead.
+ */
+var OdigosFargateLanguage;
+(function (OdigosFargateLanguage) {
+    /** JVM applications — Java, Kotlin, Scala. Activated through `JAVA_TOOL_OPTIONS`. */
+    OdigosFargateLanguage["JAVA"] = "java";
+    /** Python. Activated through `PYTHONPATH`. */
+    OdigosFargateLanguage["PYTHON"] = "python";
+    /** Node.js. Activated through `NODE_OPTIONS`. */
+    OdigosFargateLanguage["NODEJS"] = "nodejs";
+    /** .NET, glibc only — the bundle ships no musl (Alpine) native profiler. */
+    OdigosFargateLanguage["DOTNET"] = "dotnet";
+    /**
+     * PHP. Needs `runtimeVersion` (major.minor): its agent is laid down per runtime version, and the
+     * version selects the path `PHP_INI_SCAN_DIR` points at.
+     */
+    OdigosFargateLanguage["PHP"] = "php";
+    /**
+     * Ruby. Needs `runtimeVersion` (major.minor), for the same reason as PHP — the version selects the path
+     * `RUBYOPT` requires.
+     */
+    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,sEAAsE;IACtE,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 owns `AWS_LAMBDA_EXEC_WRAPPER`, so this mode does not touch it. Instrumentation is loaded\n   * through the language's own loader variable instead — `JAVA_TOOL_OPTIONS`, `NODE_OPTIONS` or\n   * `PYTHONPATH` — appended to (never replacing) whatever the function already sets.\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. The default. */\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   * Disable TLS verification on the gRPC exporter.\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 rendered into `OPENTELEMETRY_COLLECTOR_CONFIG_URI`, 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. Note that the connector does\n   * NOT set that variable when it instruments a Fargate task itself, and does not compare it, so this is\n   * neither reconciled nor reported as drift either way: it is here because an authenticated destination\n   * is otherwise unreachable from a task, which has no collector of its own to hold the credential.\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`). 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"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odigos/aws-cdk",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "CDK constructs that instrument AWS Lambda functions with the Odigos OpenTelemetry layer",
   "license": "Apache-2.0",
   "author": {
@@ -57,7 +57,7 @@
     ]
   },
   "scripts": {
-    "generate": "ts-node --project tsconfig.dev.json scripts/generate-layers.ts",
+    "generate": "ts-node --project tsconfig.dev.json scripts/generate.ts",
     "build": "npm run generate && jsii --silence-warnings=reserved-word",
     "watch": "jsii -w",
     "package": "jsii-pacmak",