@liflig/cdk 3.12.1 → 3.13.0

package/assets/open-telemetry/otel-collector-task-metrics-config.yaml

@@ -0,0 +1,310 @@
+## Validate using https://www.otelbin.io/#distro=adot%7E&distroVersion=v0.43.1%7E .
+##
+## Original copyright is Apache 2.0 to AWS (aws-observability on GitHub).
+## https://github.com/aws-observability/aws-otel-collector/blob/14833d4af543da709c77cf9dc6827351dbd529b1/config/ecs/container-insights/otel-task-metrics-config.yaml
+##
+## This is a modified version of `./etc/ecs/container-insights/otel-task-metrics-config.yaml`
+## where we add `resource_to_telemetry_conversion` so the otel resource `service.name`
+## can be added to the metric. This is useful because you can filter in metrics based on service,
+## instead of grouping e.g. all services' memory usage under the same metric.
+##
+## Search for `# THIS IS WHAT LIFLIG ADDED` to find our modifications.
+##
+##
+## @see https://aws-otel.github.io/docs/setup/ecs/config-through-ssm
+extensions:
+  health_check:
+
+## These ports are also set in `taskDefinition.defaultContainer` as
+## `OTEL_EXPORTER_OTLP_ENDPOINT` and so on.
+## Changes must happen in both places.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+  awsxray:
+    endpoint: 0.0.0.0:2000
+    transport: udp
+  awsecscontainermetrics:
+
+processors:
+  batch/traces:
+    timeout: 1s
+    send_batch_size: 50
+  batch/metrics:
+    timeout: 60s
+  filter:
+    metrics:
+      include:
+        match_type: strict
+        metric_names:
+          - ecs.task.memory.reserved
+          - ecs.task.memory.utilized
+          - ecs.task.cpu.reserved
+          - ecs.task.cpu.utilized
+          - ecs.task.network.rate.rx
+          - ecs.task.network.rate.tx
+          - ecs.task.storage.read_bytes
+          - ecs.task.storage.write_bytes
+          - container.duration
+  metricstransform:
+    transforms:
+      - include: ecs.task.memory.utilized
+        action: update
+        new_name: MemoryUtilized
+      - include: ecs.task.memory.reserved
+        action: update
+        new_name: MemoryReserved
+      - include: ecs.task.cpu.utilized
+        action: update
+        new_name: CpuUtilized
+      - include: ecs.task.cpu.reserved
+        action: update
+        new_name: CpuReserved
+      - include: ecs.task.network.rate.rx
+        action: update
+        new_name: NetworkRxBytes
+      - include: ecs.task.network.rate.tx
+        action: update
+        new_name: NetworkTxBytes
+      - include: ecs.task.storage.read_bytes
+        action: update
+        new_name: StorageReadBytes
+      - include: ecs.task.storage.write_bytes
+        action: update
+        new_name: StorageWriteBytes
+  ## THIS IS WHAT LIFLIG ADDED
+  filter/application:
+    error_mode: ignore
+    metrics:
+      metric:
+        - 'resource.attributes["http.target"] == "/health"'
+        - 'resource.attributes["net.peer.name"] == "169.254.170.2"' # EC2 Metadata Endpoint
+  filter/traces:
+    error_mode: ignore
+    traces:
+      span:
+        - 'attributes["http.route"] == "health"'
+        - 'attributes["http.url"] == "/health"'
+        - 'name == "GET health"'
+  attributes/application:
+    actions:
+      # Http adds lots of high cardinality, which xray creates 1 metric per. Expensive.
+      - key: http.url
+        action: delete
+      - key: http.target
+        action: delete
+      - key: http.client_ip
+        action: delete
+      - key: http.response_content_length
+        action: delete
+      - key: http.request_content_length
+        action: delete
+      - key: net.host.name
+        action: delete
+      - key: net.sock.peer.addr
+        action: delete
+      - key: net.sock.peer.port
+        action: delete
+      - key: net.sock.host.addr
+        action: delete
+      - key: net.sock.host.port
+        action: delete
+      - key: user_agent.original
+        action: delete
+  resource/application:
+    attributes:
+      - key: cloud.provider
+        action: delete
+      - key: host.arch
+        action: delete
+      - key: aws.ecs.container.image.id
+        action: delete
+      - key: aws.ecs.task.arn
+        action: delete
+      - key: aws.log.stream.names
+        action: delete
+      - key: aws.log.stream.arns
+        action: delete
+      - key: cloud.platform
+        action: delete
+      - key: container.name
+        action: delete
+      - key: process.executable.path
+        action: delete
+      - key: process.runtime.version
+        action: delete
+      - key: telemetry.auto.version
+        action: delete
+      - key: telemetry.sdk.name
+        action: delete
+      - key: container.id
+        action: delete
+      - key: container.image.tag
+        action: delete
+      - key: process.runtime.name
+        action: delete
+      - key: service.namespace
+        action: delete
+      - key: telemetry.sdk.version
+        action: delete
+      - key: aws.ecs.task.family
+        action: delete
+      - key: aws.ecs.task.revision
+        action: delete
+      - key: aws.log.group.arns
+        action: delete
+      - key: container.image.name
+        action: delete
+      - key: os.description
+        action: delete
+      - key: os.type
+        action: delete
+      - key: process.runtime.description
+        action: delete
+      - key: version
+        action: delete
+      - key: aws.ecs.launchtype
+        action: delete
+      - key: aws.log.group.names
+        action: delete
+      - key: host.name
+        action: delete
+      - key: process.pid
+        action: delete
+      - key: telemetry.sdk.language
+        action: delete
+      - key: aws.ecs.container.arn
+        action: delete
+      - key: service.version
+        action: delete
+      - key: process.command_args
+        action: delete
+      - key: service
+        action: delete
+  ## END OF LIFLIG CHANGES
+  resource:
+    attributes:
+      - key: ClusterName
+        from_attribute: aws.ecs.cluster.name
+        action: insert
+      - key: aws.ecs.cluster.name
+        action: delete
+      - key: ServiceName
+        from_attribute: aws.ecs.service.name
+        action: insert
+      - key: aws.ecs.service.name
+        action: delete
+      ## THIS IS WHAT LIFLIG ADDED (bunch of sporadic removals)
+      - key: aws.ecs.task.id
+        action: delete
+      - key: TaskDefinitionFamily
+        from_attribute: aws.ecs.task.family
+        action: insert
+      - key: aws.ecs.task.family
+        action: delete
+      - key: aws.ecs.task.arn
+        action: delete
+      - key: aws.ecs.docker.name
+        action: delete
+      - key: aws.ecs.task.version
+        action: delete
+      - key: aws.ecs.task.pull_started_at
+        action: delete
+      - key: aws.ecs.task.pull_stopped_at
+        action: delete
+      - key: AvailabilityZone
+        from_attribute: cloud.zone
+        action: insert
+      - key: cloud.zone
+        action: delete
+      - key: aws.ecs.task.launch_type
+        action: delete
+      - key: Region
+        from_attribute: cloud.region
+        action: insert
+      - key: cloud.region
+        action: delete
+      - key: AccountId
+        from_attribute: cloud.account.id
+        action: insert
+      - key: cloud.account.id
+        action: delete
+      - key: container.id
+        action: delete
+      - key: container.name
+        action: delete
+      - key: container.image.name
+        action: delete
+      - key: aws.ecs.container.image.id
+        action: delete
+      - key: aws.ecs.container.exit_code
+        action: delete
+      - key: aws.ecs.container.created_at
+        action: delete
+      - key: aws.ecs.container.started_at
+        action: delete
+      - key: aws.ecs.container.finished_at
+        action: delete
+      - key: container.image.tag
+        action: delete
+      ## END OF LIFLIG CHANGES
+
+exporters:
+  awsxray:
+    ## THIS IS WHAT LIFLIG ADDED
+    indexed_attributes: ["otel.resource.service.name"] # Max 50 attributes
+    ## END OF LIFLIG CHANGES
+  awsemf/application:
+    namespace: ECS/AWSOTel/Application
+    log_group_name: '/aws/ecs/application/metrics'
+    ## THIS IS WHAT LIFLIG ADDED
+    ## Config docs at https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/awsemfexporter/README.md
+    ## log retention is days to keep the emf metric logs.
+    log_retention: 365
+    resource_to_telemetry_conversion:
+      enabled: true
+    dimension_rollup_option: NoDimensionRollup
+    ## No rollup means we keep all the dimensions on the metric, instead of merging similar metrics to one in CloudWatch
+    ## END OF LIFLIG CHANGES
+  awsemf/performance:
+    namespace: ECS/ContainerInsights
+    log_group_name: '/aws/ecs/containerinsights/{ClusterName}/performance'
+    log_stream_name: '{TaskId}'
+    resource_to_telemetry_conversion:
+      enabled: true
+    dimension_rollup_option: NoDimensionRollup
+    metric_declarations:
+      - dimensions: [ [ ClusterName ], [ ClusterName, TaskDefinitionFamily ] ]
+        metric_name_selectors:
+          - MemoryUtilized
+          - MemoryReserved
+          - CpuUtilized
+          - CpuReserved
+          - NetworkRxBytes
+          - NetworkTxBytes
+          - StorageReadBytes
+          - StorageWriteBytes
+      - metric_name_selectors: [container.*]
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp,awsxray]
+      ## THIS IS WHAT LIFLIG ADDED
+      processors: [filter/traces, batch/traces]
+      exporters: [awsxray]
+    metrics/application:
+      receivers: [otlp]
+      processors: [filter/application, resource/application, attributes/application, batch/metrics]
+      exporters: [awsemf/application]
+      ## END OF LIFLIG CHANGES
+    metrics/performance:
+      receivers: [awsecscontainermetrics ]
+      processors: [filter, metricstransform, resource]
+      exporters: [ awsemf/performance ]
+
+  extensions: [health_check]

package/lib/ecs/index.d.ts

@@ -1,6 +1,8 @@
 export { Cluster } from "./cluster";
 export { FargateService } from "./fargate-service";
 export { ListenerRule } from "./listener-rule";
+export { OpenTelemetryCollectors } from "./open-telemetry";
 export type { ClusterProps } from "./cluster";
 export type { FargateServiceProps } from "./fargate-service";
 export type { ListenerRuleProps } from "./listener-rule";
+export type { OpenTelemetryCollectorsProps } from "./open-telemetry";

package/lib/ecs/index.js

@@ -1,4 +1,5 @@
 export { Cluster } from "./cluster";
 export { FargateService } from "./fargate-service";
 export { ListenerRule } from "./listener-rule";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQ2xELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENsdXN0ZXIgfSBmcm9tIFwiLi9jbHVzdGVyXCJcbmV4cG9ydCB7IEZhcmdhdGVTZXJ2aWNlIH0gZnJvbSBcIi4vZmFyZ2F0ZS1zZXJ2aWNlXCJcbmV4cG9ydCB7IExpc3RlbmVyUnVsZSB9IGZyb20gXCIuL2xpc3RlbmVyLXJ1bGVcIlxuZXhwb3J0IHR5cGUgeyBDbHVzdGVyUHJvcHMgfSBmcm9tIFwiLi9jbHVzdGVyXCJcbmV4cG9ydCB0eXBlIHsgRmFyZ2F0ZVNlcnZpY2VQcm9wcyB9IGZyb20gXCIuL2ZhcmdhdGUtc2VydmljZVwiXG5leHBvcnQgdHlwZSB7IExpc3RlbmVyUnVsZVByb3BzIH0gZnJvbSBcIi4vbGlzdGVuZXItcnVsZVwiXG4iXX0=
+export { OpenTelemetryCollectors } from "./open-telemetry";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQ2xELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENsdXN0ZXIgfSBmcm9tIFwiLi9jbHVzdGVyXCJcbmV4cG9ydCB7IEZhcmdhdGVTZXJ2aWNlIH0gZnJvbSBcIi4vZmFyZ2F0ZS1zZXJ2aWNlXCJcbmV4cG9ydCB7IExpc3RlbmVyUnVsZSB9IGZyb20gXCIuL2xpc3RlbmVyLXJ1bGVcIlxuZXhwb3J0IHsgT3BlblRlbGVtZXRyeUNvbGxlY3RvcnMgfSBmcm9tIFwiLi9vcGVuLXRlbGVtZXRyeVwiXG5leHBvcnQgdHlwZSB7IENsdXN0ZXJQcm9wcyB9IGZyb20gXCIuL2NsdXN0ZXJcIlxuZXhwb3J0IHR5cGUgeyBGYXJnYXRlU2VydmljZVByb3BzIH0gZnJvbSBcIi4vZmFyZ2F0ZS1zZXJ2aWNlXCJcbmV4cG9ydCB0eXBlIHsgTGlzdGVuZXJSdWxlUHJvcHMgfSBmcm9tIFwiLi9saXN0ZW5lci1ydWxlXCJcbmV4cG9ydCB0eXBlIHsgT3BlblRlbGVtZXRyeUNvbGxlY3RvcnNQcm9wcyB9IGZyb20gXCIuL29wZW4tdGVsZW1ldHJ5XCJcbiJdfQ==

package/lib/ecs/open-telemetry.d.ts

@@ -0,0 +1,98 @@
+import * as constructs from "constructs";
+import * as ecs from "aws-cdk-lib/aws-ecs";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { FargateService } from "./fargate-service";
+export interface OpenTelemetryCollectorsProps {
+    service: FargateService;
+    /** @default 6 months **/
+    logRetention?: RetentionDays;
+    /** @default "amazon/aws-otel-collector:v0.43.1" */
+    dockerImage?: string;
+    /** Should be kept as `undefined` unless you know what you are doing.
+     * This is the YAML config for the OpenTelemetry collector sidecar.
+     *
+     * An example of a config can be found at https://github.com/aws-observability/aws-otel-collector/blob/0ae198c7e7b8c43bcc8715f54e52c879c04407b6/config/ecs/container-insights/otel-task-metrics-config.yaml
+     *
+     * @default a file in `assets` tuned to work for aws and strips known high-cardinality metrics (like those containing IP addresses and ports)
+     */
+    awsOtelConfig?: string;
+    /** Overrides for the sidecar container.
+     * You do not need to specify this.
+     *
+     * Defaults:
+     * - cpu: 32 units
+     * - memory reservation: 24 MiB
+     * - memory limit: 256 MiB
+     */
+    containerProps?: SidecarContainerProps;
+}
+/**
+ * Methods to enable collection of Open Telemetry (otel) data of a {@link FargateService}
+ * using a docker container with an otel agent.
+ *
+ *
+ * An example of a Java auto-instrumentation agent in Docker can be found
+ * [in liflig-rest-baseline Dockerfile](https://github.com/capralifecycle/liflig-rest-service-baseline/blob/a29b5a472c982aa7ce04d09d0e7cfdc92a6cc977/docker/Dockerfile#L9-L29).
+ *
+ * The agent must be configured to output metrics to a collector.
+ * That collector is what this construct provides.
+ * Usually, the agent is specified in the Dockerfile or as a dependency/library,
+ * and configured in the Dockerfile or in the application source code.
+ *
+ * Use this construct on a {@link FargateService} by constructing a new instance of {@link OpenTelemetryCollectors}
+ * and calling the {@link addOpenTelemetryCollectorSidecar} method on it.
+ *
+ * ```ts
+ * const service = FargateService(...);
+ *
+ * new OpenTelemetryCollectors(this, "OtelSidecar").addOpenTelemetryCollectorSidecar(service)
+ * ```
+ *
+ * The sidecar exposes these ports to your service:
+ * - udp 2000 : AWS XRay
+ * - tcp 4317 : OpenTelemetry collection GRPC
+ * - tcp 4318 : OpenTelemetry collection HTTP
+ *
+ * ---
+ *
+ * You can also disable the OpenTelemetry instrumentation agent
+ * for Java-based services,
+ * by setting the appropriate environment variable with {@link disableOpenTelemetryJavaAgent}:
+ * ```ts
+ * const service = FargateService(...);
+ *
+ * OpenTelemetryCollectors.disableOpenTelemetryJavaAgent(service)
+ * ```
+ *
+ * @see OpenTelemetryCollectors.addOpenTelemetryCollectorSidecar
+ */
+export declare class OpenTelemetryCollectors extends constructs.Construct {
+    private readonly props;
+    constructor(scope: constructs.Construct, id: string, props: OpenTelemetryCollectorsProps);
+    /**
+     * The OpenTelemetry Java agent may run by default in the Docker image.
+     * This method will tell the agent to disable itself.
+     *
+     * You might want to do this to avoid overhead or error logs from failed
+     * connection attempts to the otel collector.
+     */
+    disableOpenTelemetryJavaAgent(): void;
+    /**
+     * The OpenTelemetry Java agent may run by default in the Docker image.
+     * This method will tell the agent to disable itself.
+     *
+     * You might want to do this to avoid overhead or error logs from failed
+     * connection attempts to the otel collector.
+     * @param service
+     */
+    static disableOpenTelemetryJavaAgent(service: FargateService): void;
+    /**
+     * Adds a sidecar with an AWS Distro OpenTelemetry Collector.
+     * https://aws-otel.github.io/docs/setup/ecs
+     *
+     * You also need to add either the Java SDK for OTel or a Java agent,
+     * to capture telemetry and send to this collector.
+     */
+    addOpenTelemetryCollectorSidecar(): void;
+}
+export type SidecarContainerProps = Pick<ecs.ContainerDefinitionProps, "cpu" | "memoryReservationMiB" | "memoryLimitMiB">;

package/lib/ecs/open-telemetry.js

@@ -0,0 +1,211 @@
+import * as constructs from "constructs";
+import * as ecs from "aws-cdk-lib/aws-ecs";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as logs from "aws-cdk-lib/aws-logs";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { RemovalPolicy } from "aws-cdk-lib";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import * as path from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Methods to enable collection of Open Telemetry (otel) data of a {@link FargateService}
+ * using a docker container with an otel agent.
+ *
+ *
+ * An example of a Java auto-instrumentation agent in Docker can be found
+ * [in liflig-rest-baseline Dockerfile](https://github.com/capralifecycle/liflig-rest-service-baseline/blob/a29b5a472c982aa7ce04d09d0e7cfdc92a6cc977/docker/Dockerfile#L9-L29).
+ *
+ * The agent must be configured to output metrics to a collector.
+ * That collector is what this construct provides.
+ * Usually, the agent is specified in the Dockerfile or as a dependency/library,
+ * and configured in the Dockerfile or in the application source code.
+ *
+ * Use this construct on a {@link FargateService} by constructing a new instance of {@link OpenTelemetryCollectors}
+ * and calling the {@link addOpenTelemetryCollectorSidecar} method on it.
+ *
+ * ```ts
+ * const service = FargateService(...);
+ *
+ * new OpenTelemetryCollectors(this, "OtelSidecar").addOpenTelemetryCollectorSidecar(service)
+ * ```
+ *
+ * The sidecar exposes these ports to your service:
+ * - udp 2000 : AWS XRay
+ * - tcp 4317 : OpenTelemetry collection GRPC
+ * - tcp 4318 : OpenTelemetry collection HTTP
+ *
+ * ---
+ *
+ * You can also disable the OpenTelemetry instrumentation agent
+ * for Java-based services,
+ * by setting the appropriate environment variable with {@link disableOpenTelemetryJavaAgent}:
+ * ```ts
+ * const service = FargateService(...);
+ *
+ * OpenTelemetryCollectors.disableOpenTelemetryJavaAgent(service)
+ * ```
+ *
+ * @see OpenTelemetryCollectors.addOpenTelemetryCollectorSidecar
+ */
+export class OpenTelemetryCollectors extends constructs.Construct {
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+    }
+    /**
+     * The OpenTelemetry Java agent may run by default in the Docker image.
+     * This method will tell the agent to disable itself.
+     *
+     * You might want to do this to avoid overhead or error logs from failed
+     * connection attempts to the otel collector.
+     */
+    disableOpenTelemetryJavaAgent() {
+        OpenTelemetryCollectors.disableOpenTelemetryJavaAgent(this.props.service);
+    }
+    /**
+     * The OpenTelemetry Java agent may run by default in the Docker image.
+     * This method will tell the agent to disable itself.
+     *
+     * You might want to do this to avoid overhead or error logs from failed
+     * connection attempts to the otel collector.
+     * @param service
+     */
+    static disableOpenTelemetryJavaAgent(service) {
+        service.taskDefinition.defaultContainer?.addEnvironment("OTEL_JAVAAGENT_ENABLED", "false");
+    }
+    /**
+     * Adds a sidecar with an AWS Distro OpenTelemetry Collector.
+     * https://aws-otel.github.io/docs/setup/ecs
+     *
+     * You also need to add either the Java SDK for OTel or a Java agent,
+     * to capture telemetry and send to this collector.
+     */
+    addOpenTelemetryCollectorSidecar() {
+        new OpenTelemetryPolicies(this, "OpenTelemetryPolicies", {
+            taskDefinition: this.props.service.taskDefinition,
+        });
+        this.props.service.taskDefinition.addExtension(new OpenTelemetryCollectorSidecar(this, this.props.logRetention, this.props.dockerImage, this.props.awsOtelConfig, this.props.containerProps));
+    }
+}
+/**
+ * Adds a sidecar with an AWS Distro OpenTelemetry Collector.
+ * https://aws-otel.github.io/docs/setup/ecs
+ *
+ * You also need to add either the Java SDK for OTel or a Java agent,
+ * to capture telemetry and send to this collector.
+ */
+class OpenTelemetryCollectorSidecar {
+    construct;
+    logRetention;
+    dockerImage;
+    awsOtelConfig;
+    containerProps;
+    constructor(construct, logRetention, dockerImage, awsOtelConfig, containerProps) {
+        this.construct = construct;
+        this.logRetention = logRetention;
+        this.dockerImage = dockerImage;
+        this.awsOtelConfig = awsOtelConfig;
+        this.containerProps = containerProps;
+    }
+    extend(taskDefinition) {
+        if (taskDefinition.networkMode !== ecs.NetworkMode.AWS_VPC) {
+            throw new Error("Task NetworkMode must be AWS_VPC: " + taskDefinition.networkMode);
+        }
+        const commands = {
+            metricsAndTraces: "--config=/etc/ecs/ecs-default-config.yaml",
+            metricsAndTracesAndContainerResources: "--config=/etc/ecs/container-insights/otel-task-metrics-config.yaml",
+        };
+        const logGroup = new logs.LogGroup(this.construct, "CollectorLogGroup", {
+            retention: this.logRetention ?? RetentionDays.SIX_MONTHS,
+            removalPolicy: RemovalPolicy.DESTROY,
+        });
+        const sidecarImage = this.dockerImage ?? "amazon/aws-otel-collector:v0.43.1";
+        const sidecar = taskDefinition.addContainer("aws-opentelemetry-collector", {
+            cpu: this.containerProps?.cpu ?? 32,
+            memoryReservationMiB: this.containerProps?.memoryReservationMiB ?? 24,
+            memoryLimitMiB: this.containerProps?.memoryLimitMiB ?? 256,
+            image: ecs.ContainerImage.fromRegistry(sidecarImage),
+            command: [commands.metricsAndTracesAndContainerResources], // This is not used when the AOT_CONFIG_CONTENT is set!
+            environment: {
+                // You can alternatively create an SSM parameter with the config, and pass it to the `secrets` option
+                AOT_CONFIG_CONTENT: this.awsOtelConfig ?? awsOtelCustomConfigYaml,
+            },
+            logging: ecs.LogDrivers.awsLogs({
+                logGroup: logGroup,
+                streamPrefix: "ecs",
+            }),
+        });
+        // A dependency should be added to all containers that export metrics.
+        // We are currently assuming that this is only the default container
+        taskDefinition.defaultContainer?.addContainerDependencies({
+            container: sidecar,
+            condition: ecs.ContainerDependencyCondition.START,
+        });
+        /*
+         * aws-otel-collector exposes these ports, and more:
+         * - udp 2000 : AWS XRay
+         * - tcp 4317 : OpenTelemetry collection GRPC
+         * - tcp 4318 : OpenTelemetry collection HTTP
+         *
+         * These are defined in the yaml config for the collector.
+         */
+        taskDefinition.defaultContainer?.addEnvironment("AWS_XRAY_DAEMON_ADDRESS", "http://localhost:2000");
+        taskDefinition.defaultContainer?.addEnvironment("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317");
+        taskDefinition.defaultContainer?.addEnvironment("OTEL_JAVAAGENT_ENABLED", "true");
+        if (!taskDefinition.isFargateCompatible) {
+            // This extension is made for the FargateService, so this is a requirement.
+            throw new Error("This task definition can not be ran on fargate! " +
+                taskDefinition.node.id);
+        }
+    }
+}
+/**
+ * Grants the sidecar permissions to create logs, metrics and XRay traces by extending the task roles.
+ */
+class OpenTelemetryPolicies extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const awsDistroOpenTelemetryPolicyStatement = new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            resources: ["*"],
+            actions: [
+                "logs:PutLogEvents",
+                "logs:CreateLogGroup",
+                "logs:CreateLogStream",
+                "logs:DescribeLogStreams",
+                "logs:DescribeLogGroups",
+                "logs:PutRetentionPolicy",
+                "xray:PutTraceSegments",
+                "xray:PutTelemetryRecords",
+                "xray:GetSamplingRules",
+                "xray:GetSamplingTargets",
+                "xray:GetSamplingStatisticSummaries",
+                "cloudwatch:PutMetricData",
+                "ec2:DescribeVolumes",
+                "ec2:DescribeTags",
+                "ssm:GetParameters",
+            ],
+        });
+        props.taskDefinition.addToTaskRolePolicy(awsDistroOpenTelemetryPolicyStatement);
+        props.taskDefinition.addToExecutionRolePolicy(awsDistroOpenTelemetryPolicyStatement);
+        props.taskDefinition.executionRole?.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName("CloudWatchLogsFullAccess"));
+        props.taskDefinition.executionRole?.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName("AmazonSSMReadOnlyAccess"));
+    }
+}
+/**
+ * This is a modified version of `./etc/ecs/container-insights/otel-task-metrics-config.yaml`
+ * where we add `resource_to_telemetry_conversion` so the otel resource `service.name`
+ * can be added to the metric. This is useful because you can filter in metrics based on service,
+ * instead of grouping e.g. all services' memory usage under the same metric.
+ *
+ * @see https://aws-otel.github.io/docs/setup/ecs/config-through-ssm
+ * @see https://aws-otel.github.io/docs/getting-started/cloudwatch-metrics#cloudwatch-emf-exporter-awsemf
+ */
+const awsOtelCustomConfigYaml = readFileSync(path.resolve(__dirname, "..", "..", "assets", "open-telemetry", "otel-collector-task-metrics-config.yaml"), "utf-8")
+    .split("\n")
+    .filter((line) => !/^\s*##/.test(line)) // Skip comments starting with ##
+    .join("\n");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"open-telemetry.js","sourceRoot":"","sources":["../../src/ecs/open-telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecs from \"aws-cdk-lib/aws-ecs\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport { RetentionDays } from \"aws-cdk-lib/aws-logs\"\nimport { RemovalPolicy } from \"aws-cdk-lib\"\nimport { FargateService } from \"./fargate-service\"\nimport { readFileSync } from \"fs\"\nimport { fileURLToPath } from \"url\"\nimport * as path from \"path\"\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n\nexport interface OpenTelemetryCollectorsProps {\n  service: FargateService\n\n  /** @default 6 months **/\n  logRetention?: RetentionDays\n\n  /** @default \"amazon/aws-otel-collector:v0.43.1\" */\n  dockerImage?: string\n\n  /** Should be kept as `undefined` unless you know what you are doing.\n   * This is the YAML config for the OpenTelemetry collector sidecar.\n   *\n   * An example of a config can be found at https://github.com/aws-observability/aws-otel-collector/blob/0ae198c7e7b8c43bcc8715f54e52c879c04407b6/config/ecs/container-insights/otel-task-metrics-config.yaml\n   *\n   * @default a file in `assets` tuned to work for aws and strips known high-cardinality metrics (like those containing IP addresses and ports)\n   */\n  awsOtelConfig?: string\n\n  /** Overrides for the sidecar container.\n   * You do not need to specify this.\n   *\n   * Defaults:\n   * - cpu: 32 units\n   * - memory reservation: 24 MiB\n   * - memory limit: 256 MiB\n   */\n  containerProps?: SidecarContainerProps\n}\n\n/**\n * Methods to enable collection of Open Telemetry (otel) data of a {@link FargateService}\n * using a docker container with an otel agent.\n *\n *\n * An example of a Java auto-instrumentation agent in Docker can be found\n * [in liflig-rest-baseline Dockerfile](https://github.com/capralifecycle/liflig-rest-service-baseline/blob/a29b5a472c982aa7ce04d09d0e7cfdc92a6cc977/docker/Dockerfile#L9-L29).\n *\n * The agent must be configured to output metrics to a collector.\n * That collector is what this construct provides.\n * Usually, the agent is specified in the Dockerfile or as a dependency/library,\n * and configured in the Dockerfile or in the application source code.\n *\n * Use this construct on a {@link FargateService} by constructing a new instance of {@link OpenTelemetryCollectors}\n * and calling the {@link addOpenTelemetryCollectorSidecar} method on it.\n *\n * ```ts\n * const service = FargateService(...);\n *\n * new OpenTelemetryCollectors(this, \"OtelSidecar\").addOpenTelemetryCollectorSidecar(service)\n * ```\n *\n * The sidecar exposes these ports to your service:\n * - udp 2000 : AWS XRay\n * - tcp 4317 : OpenTelemetry collection GRPC\n * - tcp 4318 : OpenTelemetry collection HTTP\n *\n * ---\n *\n * You can also disable the OpenTelemetry instrumentation agent\n * for Java-based services,\n * by setting the appropriate environment variable with {@link disableOpenTelemetryJavaAgent}:\n * ```ts\n * const service = FargateService(...);\n *\n * OpenTelemetryCollectors.disableOpenTelemetryJavaAgent(service)\n * ```\n *\n * @see OpenTelemetryCollectors.addOpenTelemetryCollectorSidecar\n */\nexport class OpenTelemetryCollectors extends constructs.Construct {\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    private readonly props: OpenTelemetryCollectorsProps,\n  ) {\n    super(scope, id)\n  }\n\n  /**\n   * The OpenTelemetry Java agent may run by default in the Docker image.\n   * This method will tell the agent to disable itself.\n   *\n   * You might want to do this to avoid overhead or error logs from failed\n   * connection attempts to the otel collector.\n   */\n  public disableOpenTelemetryJavaAgent() {\n    OpenTelemetryCollectors.disableOpenTelemetryJavaAgent(this.props.service)\n  }\n\n  /**\n   * The OpenTelemetry Java agent may run by default in the Docker image.\n   * This method will tell the agent to disable itself.\n   *\n   * You might want to do this to avoid overhead or error logs from failed\n   * connection attempts to the otel collector.\n   * @param service\n   */\n  public static disableOpenTelemetryJavaAgent(service: FargateService) {\n    service.taskDefinition.defaultContainer?.addEnvironment(\n      \"OTEL_JAVAAGENT_ENABLED\",\n      \"false\",\n    )\n  }\n\n  /**\n   * Adds a sidecar with an AWS Distro OpenTelemetry Collector.\n   * https://aws-otel.github.io/docs/setup/ecs\n   *\n   * You also need to add either the Java SDK for OTel or a Java agent,\n   * to capture telemetry and send to this collector.\n   */\n  public addOpenTelemetryCollectorSidecar() {\n    new OpenTelemetryPolicies(this, \"OpenTelemetryPolicies\", {\n      taskDefinition: this.props.service.taskDefinition,\n    })\n\n    this.props.service.taskDefinition.addExtension(\n      new OpenTelemetryCollectorSidecar(\n        this,\n        this.props.logRetention,\n        this.props.dockerImage,\n        this.props.awsOtelConfig,\n        this.props.containerProps,\n      ),\n    )\n  }\n}\n\nexport type SidecarContainerProps = Pick<\n  ecs.ContainerDefinitionProps,\n  \"cpu\" | \"memoryReservationMiB\" | \"memoryLimitMiB\"\n>\n\n/**\n * Adds a sidecar with an AWS Distro OpenTelemetry Collector.\n * https://aws-otel.github.io/docs/setup/ecs\n *\n * You also need to add either the Java SDK for OTel or a Java agent,\n * to capture telemetry and send to this collector.\n */\nclass OpenTelemetryCollectorSidecar implements ecs.ITaskDefinitionExtension {\n  constructor(\n    private readonly construct: constructs.Construct,\n    private readonly logRetention?: RetentionDays,\n    private readonly dockerImage?: string,\n    private readonly awsOtelConfig?: string,\n    private readonly containerProps?: SidecarContainerProps,\n  ) {}\n\n  extend(taskDefinition: ecs.TaskDefinition): void {\n    if (taskDefinition.networkMode !== ecs.NetworkMode.AWS_VPC) {\n      throw new Error(\n        \"Task NetworkMode must be AWS_VPC: \" + taskDefinition.networkMode,\n      )\n    }\n\n    const commands = {\n      metricsAndTraces: \"--config=/etc/ecs/ecs-default-config.yaml\",\n      metricsAndTracesAndContainerResources:\n        \"--config=/etc/ecs/container-insights/otel-task-metrics-config.yaml\",\n    }\n\n    const logGroup = new logs.LogGroup(this.construct, \"CollectorLogGroup\", {\n      retention: this.logRetention ?? RetentionDays.SIX_MONTHS,\n      removalPolicy: RemovalPolicy.DESTROY,\n    })\n\n    const sidecarImage = this.dockerImage ?? \"amazon/aws-otel-collector:v0.43.1\"\n    const sidecar = taskDefinition.addContainer(\"aws-opentelemetry-collector\", {\n      cpu: this.containerProps?.cpu ?? 32,\n      memoryReservationMiB: this.containerProps?.memoryReservationMiB ?? 24,\n      memoryLimitMiB: this.containerProps?.memoryLimitMiB ?? 256,\n      image: ecs.ContainerImage.fromRegistry(sidecarImage),\n      command: [commands.metricsAndTracesAndContainerResources], // This is not used when the AOT_CONFIG_CONTENT is set!\n      environment: {\n        // You can alternatively create an SSM parameter with the config, and pass it to the `secrets` option\n        AOT_CONFIG_CONTENT: this.awsOtelConfig ?? awsOtelCustomConfigYaml,\n      },\n      logging: ecs.LogDrivers.awsLogs({\n        logGroup: logGroup,\n        streamPrefix: \"ecs\",\n      }),\n    })\n\n    // A dependency should be added to all containers that export metrics.\n    // We are currently assuming that this is only the default container\n    taskDefinition.defaultContainer?.addContainerDependencies({\n      container: sidecar,\n      condition: ecs.ContainerDependencyCondition.START,\n    })\n\n    /*\n     * aws-otel-collector exposes these ports, and more:\n     * - udp 2000 : AWS XRay\n     * - tcp 4317 : OpenTelemetry collection GRPC\n     * - tcp 4318 : OpenTelemetry collection HTTP\n     *\n     * These are defined in the yaml config for the collector.\n     */\n    taskDefinition.defaultContainer?.addEnvironment(\n      \"AWS_XRAY_DAEMON_ADDRESS\",\n      \"http://localhost:2000\",\n    )\n    taskDefinition.defaultContainer?.addEnvironment(\n      \"OTEL_EXPORTER_OTLP_ENDPOINT\",\n      \"http://localhost:4317\",\n    )\n    taskDefinition.defaultContainer?.addEnvironment(\n      \"OTEL_JAVAAGENT_ENABLED\",\n      \"true\",\n    )\n\n    if (!taskDefinition.isFargateCompatible) {\n      // This extension is made for the FargateService, so this is a requirement.\n      throw new Error(\n        \"This task definition can not be ran on fargate! \" +\n          taskDefinition.node.id,\n      )\n    }\n  }\n}\n\ninterface OpenTelemetryPoliciesProps {\n  taskDefinition: ecs.TaskDefinition\n}\n\n/**\n * Grants the sidecar permissions to create logs, metrics and XRay traces by extending the task roles.\n */\nclass OpenTelemetryPolicies extends constructs.Construct {\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: OpenTelemetryPoliciesProps,\n  ) {\n    super(scope, id)\n\n    const awsDistroOpenTelemetryPolicyStatement = new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      resources: [\"*\"],\n      actions: [\n        \"logs:PutLogEvents\",\n        \"logs:CreateLogGroup\",\n        \"logs:CreateLogStream\",\n        \"logs:DescribeLogStreams\",\n        \"logs:DescribeLogGroups\",\n        \"logs:PutRetentionPolicy\",\n        \"xray:PutTraceSegments\",\n        \"xray:PutTelemetryRecords\",\n        \"xray:GetSamplingRules\",\n        \"xray:GetSamplingTargets\",\n        \"xray:GetSamplingStatisticSummaries\",\n        \"cloudwatch:PutMetricData\",\n        \"ec2:DescribeVolumes\",\n        \"ec2:DescribeTags\",\n        \"ssm:GetParameters\",\n      ],\n    })\n\n    props.taskDefinition.addToTaskRolePolicy(\n      awsDistroOpenTelemetryPolicyStatement,\n    )\n\n    props.taskDefinition.addToExecutionRolePolicy(\n      awsDistroOpenTelemetryPolicyStatement,\n    )\n    props.taskDefinition.executionRole?.addManagedPolicy(\n      iam.ManagedPolicy.fromAwsManagedPolicyName(\"CloudWatchLogsFullAccess\"),\n    )\n    props.taskDefinition.executionRole?.addManagedPolicy(\n      iam.ManagedPolicy.fromAwsManagedPolicyName(\"AmazonSSMReadOnlyAccess\"),\n    )\n  }\n}\n\n/**\n * This is a modified version of `./etc/ecs/container-insights/otel-task-metrics-config.yaml`\n * where we add `resource_to_telemetry_conversion` so the otel resource `service.name`\n * can be added to the metric. This is useful because you can filter in metrics based on service,\n * instead of grouping e.g. all services' memory usage under the same metric.\n *\n * @see https://aws-otel.github.io/docs/setup/ecs/config-through-ssm\n * @see https://aws-otel.github.io/docs/getting-started/cloudwatch-metrics#cloudwatch-emf-exporter-awsemf\n */\nconst awsOtelCustomConfigYaml = readFileSync(\n  path.resolve(\n    __dirname,\n    \"..\",\n    \"..\",\n    \"assets\",\n    \"open-telemetry\",\n    \"otel-collector-task-metrics-config.yaml\",\n  ),\n  \"utf-8\",\n)\n  .split(\"\\n\")\n  .filter((line) => !/^\\s*##/.test(line)) // Skip comments starting with ##\n  .join(\"\\n\")\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liflig/cdk",
-  "version": "3.12.1",
+  "version": "3.13.0",
   "description": "CDK library for Liflig",
   "type": "module",
   "repository": {
@@ -55,7 +55,7 @@
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
     "@eslint/eslintrc": "3.3.1",
-    "@eslint/js": "9.31.0",
+    "@eslint/js": "9.32.0",
     "@types/aws-lambda": "8.10.152",
     "@types/jest": "30.0.0",
     "@types/node": "24.1.0",
@@ -65,7 +65,7 @@
     "aws-cdk-lib": "2.207.0",
     "constructs": "10.4.2",
     "esbuild": "0.25.8",
-    "eslint": "9.31.0",
+    "eslint": "9.32.0",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-prettier": "5.5.3",
     "husky": "9.1.7",
@@ -75,7 +75,7 @@
     "semantic-release": "24.2.7",
     "ts-jest": "29.4.0",
     "tsx": "4.20.3",
-    "typedoc": "0.28.7",
+    "typedoc": "0.28.8",
     "typescript": "5.8.3"
   },
   "dependencies": {