@liflig/cdk 3.12.0 → 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/build-artifacts/index.d.ts

@@ -24,7 +24,7 @@ interface Props {
     /**
      * The lifecycle rules to apply to images stored in the ECR repository.
      *
-     * @default - Expire images after 180 days
+     * @default - Expire untagged images after 10 days and any image older than 180 days
      */
     ecrRepositoryLifecycleRules?: ecr.LifecycleRule[];
     /**

package/lib/build-artifacts/index.js

@@ -90,6 +90,10 @@ export class BuildArtifacts extends constructs.Construct {
         const ecrRepo = new ecr.Repository(this, "EcrRepository", {
             repositoryName: ecrRepositoryName,
             lifecycleRules: props.ecrRepositoryLifecycleRules || [
+                {
+                    maxImageAge: cdk.Duration.days(10),
+                    tagStatus: ecr.TagStatus.UNTAGGED,
+                },
                 {
                     maxImageAge: cdk.Duration.days(180),
                     tagStatus: ecr.TagStatus.ANY,
@@ -181,4 +185,4 @@ export class BuildArtifacts extends constructs.Construct {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/build-artifacts/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport {\n  GithubActionsRole,\n  Props as GithubActionsRoleProps,\n} from \"./github-actions-role\"\n\ninterface Props {\n  /**\n   * The name to use for the S3 Bucket.\n   *\n   * NOTE: Should include both account and region so that it will\n   * not conflict with other accounts/regions.\n   */\n  bucketName: string\n  /**\n   * The name to use for the ECR Repository.\n   */\n  ecrRepositoryName: string\n  /**\n   * Create a role that can be assumed by Liflig Jenkins.\n   *\n   * @deprecated\n   * @default - no role will be created\n   */\n  ciRoleName?: string\n  /**\n   * The lifecycle rules to apply to images stored in the ECR repository.\n   *\n   * @default - Expire images after 180 days\n   */\n  ecrRepositoryLifecycleRules?: ecr.LifecycleRule[]\n  /**\n   * ID of AWS accounts that will be granted permission to read from\n   * the artifact repos.\n   */\n  targetAccountIds?: string[]\n  /**\n   * Configuration for creating IAM roles that can be assumed\n   * by GitHub Actions in specific GitHub repositories.\n   *\n   * @default - no roles are created.\n   */\n  githubActions?: Omit<\n    GithubActionsRoleProps,\n    \"trustedOwners\" | \"trustedBranch\" | \"oidcProvider\" | \"roleName\"\n  > & {\n    /**\n     * A list of trusted GitHub repository owners.\n     *\n     * @default [\"capralifecycle\"]\n     */\n    trustedOwners?: string[]\n    /**\n     * The name of the role to create.\n     *\n     * @default \"github-actions-role\"\n     */\n    roleName?: string\n    /**\n     * The name of the default branch in all repositories.\n     *\n     * @default \"master\"\n     */\n    defaultBranch?: string\n    /**\n     * Configuration for a limited role that can be used on non-default\n     * branches with less IAM permissions than the main role.\n     *\n     * @default - a limited role is created.\n     */\n    limitedRoleConfiguration?: {\n      /**\n       * Whether to create the role or not.\n       *\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * The name of the role to create.\n       *\n       * @default \"github-actions-limited-role\"\n       */\n      roleName?: string\n    }\n  }\n}\n\n/**\n * Utility functions for generating IAM statements.\n */\nconst policyStatements = {\n  allowPipelineVariables: (scope: constructs.Construct, prefix?: string) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:parameter/liflig-cdk/*/pipeline-variables/${prefix ?? \"*\"}`,\n      ],\n    }),\n  denyProdPipelines: (scope: constructs.Construct, bucket: s3.IBucket) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"s3:*\"],\n      resources: [\n        bucket.arnForObjects(\"pipelines/*-prod/*\"),\n        bucket.arnForObjects(\"pipelines/*-prod-*/*\"),\n      ],\n    }),\n  denyProdPipelineVariables: (scope: constructs.Construct) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${\n          cdk.Stack.of(scope).account\n        }:parameter/liflig-cdk/*/pipeline-variables/prod*`,\n      ],\n    }),\n}\n\n/**\n * Utility function for validating the construct properties.\n */\nexport const validateProps = (props: Props) => {\n  let valid = true\n  if (\n    props.githubActions?.defaultBranch &&\n    !props.githubActions.defaultBranch.match(/^[a-zA-Z0-9-]+$/)\n  ) {\n    console.error(\n      `Default branch ${props.githubActions.defaultBranch} contains invalid characters`,\n    )\n    valid = false\n  }\n  return valid\n}\n\n/**\n * Create various artifacts used as part of Continuous Integration (CI).\n *\n * This includes artifact repositories such as S3 bucket and ECR\n * repository, as well as IAM role(s) that grant the CI server write\n * access to these repositories.\n *\n * TODO: How can we cleanup stuff that goes into this S3 Bucket and\n *  ECR Repository? Can we ever reliably cleanup? We probably need\n *  some strategy for how we put stuff here to be able to do it.\n *\n * @experimental\n */\nexport class BuildArtifacts extends constructs.Construct {\n  public readonly bucketName: string | undefined\n  public readonly ecrRepositoryArn: string\n  public readonly ecrRepositoryName: string\n  public readonly role?: iam.Role\n  public readonly limitedRole?: iam.Role\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    if (!validateProps(props)) {\n      throw new Error(\"Invalid props were supplied\")\n    }\n\n    this.bucketName = props.bucketName\n    this.ecrRepositoryName = props.ecrRepositoryName\n    this.ecrRepositoryArn = cdk.Arn.format(\n      {\n        service: \"ecr\",\n        resource: \"repository\",\n        resourceName: this.ecrRepositoryName,\n      },\n      cdk.Stack.of(this),\n    )\n\n    const ecrRepositoryName = props.ecrRepositoryName\n\n    const bucket = new s3.Bucket(this, \"S3Bucket\", {\n      bucketName: props.bucketName,\n      encryption: s3.BucketEncryption.S3_MANAGED,\n      eventBridgeEnabled: true,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n      versioned: true,\n      lifecycleRules: [\n        {\n          noncurrentVersionExpiration: cdk.Duration.days(10),\n        },\n      ],\n    })\n\n    const ecrRepo = new ecr.Repository(this, \"EcrRepository\", {\n      repositoryName: ecrRepositoryName,\n      lifecycleRules: props.ecrRepositoryLifecycleRules || [\n        {\n          maxImageAge: cdk.Duration.days(180),\n          tagStatus: ecr.TagStatus.ANY,\n        },\n      ],\n    })\n\n    // Allow a target to read from the repos. As any specific roles need\n    // to exist before we can grant access, we delegate that responsibility\n    // to the target account.\n    for (const targetAccountId of props.targetAccountIds || []) {\n      bucket.grantRead(new iam.AccountPrincipal(targetAccountId))\n      ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId))\n    }\n\n    if (props.githubActions) {\n      const trustedOwners = props.githubActions.trustedOwners ?? [\n        \"capralifecycle\",\n      ]\n      // NOTE: There's an L2 construct that predates the official CloudFormation resource,\n      // and it is therefore implemented as a custom resource.\n      // We use the L1 CloudFormation resource instead because:\n      // 1) it's simpler\n      // 2) there's a chance the L2 construct will be deprecated in the future in favor\n      // of the official CloudFormation resource.\n      const cfnOidcProvider = new iam.CfnOIDCProvider(\n        this,\n        \"OpenIdConnectProvider\",\n        {\n          url: \"https://token.actions.githubusercontent.com\",\n          clientIdList: [\"sts.amazonaws.com\"],\n          // NOTE: The thumbprint isn't actually used, but the AWS API still requires us to supply it.\n          // More details here: https://web.archive.org/web/20240122155758/https://github.com/aws-actions/configure-aws-credentials/issues/357#issuecomment-1626357333\n          thumbprintList: [\"1c58a3a8518e8759bf075b76b750d4f2df264fcd\"],\n        },\n      )\n      const oidcProvider =\n        iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n          this,\n          \"Provider\",\n          cfnOidcProvider.ref,\n        )\n      const createLimitedRole =\n        props.githubActions.limitedRoleConfiguration?.enabled ?? true\n      const role = new GithubActionsRole(this, \"GithubActionsRole\", {\n        oidcProvider,\n        trustedOwners,\n        roleName: props.githubActions.roleName ?? \"github-actions-role\",\n        trustedBranch: createLimitedRole\n          ? (props.githubActions.defaultBranch ?? \"master\")\n          : // NOTE: If the limited role is disabled, only one role will be created\n            // and that role then needs to be assumable from all branches.\n            \"*\",\n        repositories: props.githubActions.repositories,\n      })\n      this.role = role.role\n      this.role.addToPolicy(policyStatements.allowPipelineVariables(this))\n      bucket.grantPut(this.role)\n      ecrRepo.grantPullPush(this.role)\n      if (createLimitedRole) {\n        const limitedRole = new GithubActionsRole(\n          this,\n          \"GithubActionsLimitedRole\",\n          {\n            oidcProvider,\n            trustedOwners,\n            roleName:\n              props.githubActions.limitedRoleConfiguration?.roleName ??\n              \"github-actions-limited-role\",\n            // NOTE: The limited role can be assumed from all branches.\n            trustedBranch: \"*\",\n            repositories: props.githubActions.repositories,\n          },\n        )\n        this.limitedRole = limitedRole.role\n        this.limitedRole.addToPolicy(\n          policyStatements.allowPipelineVariables(this, \"dev*\"),\n        )\n        this.limitedRole.addToPolicy(\n          policyStatements.denyProdPipelines(scope, bucket),\n        )\n        bucket.grantPut(this.limitedRole)\n        ecrRepo.grantPullPush(this.limitedRole)\n      }\n    }\n    if (props.ciRoleName) {\n      const legacyRoleForJenkins = new iam.Role(this, \"CiRole\", {\n        roleName: props.ciRoleName,\n        assumedBy: new iam.ArnPrincipal(\n          \"arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5\",\n        ),\n      })\n      legacyRoleForJenkins.addToPolicy(\n        policyStatements.allowPipelineVariables(this),\n      )\n      bucket.grantPut(legacyRoleForJenkins)\n      ecrRepo.grantPullPush(legacyRoleForJenkins)\n    }\n\n    new cdk.CfnOutput(this, \"EcrRepoUri\", {\n      value: ecrRepo.repositoryUri,\n    })\n\n    new cdk.CfnOutput(this, \"BucketName\", {\n      value: bucket.bucketName,\n    })\n\n    if (this.role) {\n      new cdk.CfnOutput(this, \"RoleArn\", {\n        value: this.role.roleArn,\n      })\n    }\n    if (this.limitedRole) {\n      new cdk.CfnOutput(this, \"LimitedRoleArn\", {\n        value: this.limitedRole.roleArn,\n      })\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/build-artifacts/index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as s3 from \"aws-cdk-lib/aws-s3\"\nimport * as cdk from \"aws-cdk-lib\"\nimport {\n  GithubActionsRole,\n  Props as GithubActionsRoleProps,\n} from \"./github-actions-role\"\n\ninterface Props {\n  /**\n   * The name to use for the S3 Bucket.\n   *\n   * NOTE: Should include both account and region so that it will\n   * not conflict with other accounts/regions.\n   */\n  bucketName: string\n  /**\n   * The name to use for the ECR Repository.\n   */\n  ecrRepositoryName: string\n  /**\n   * Create a role that can be assumed by Liflig Jenkins.\n   *\n   * @deprecated\n   * @default - no role will be created\n   */\n  ciRoleName?: string\n  /**\n   * The lifecycle rules to apply to images stored in the ECR repository.\n   *\n   * @default - Expire untagged images after 10 days and any image older than 180 days\n   */\n  ecrRepositoryLifecycleRules?: ecr.LifecycleRule[]\n  /**\n   * ID of AWS accounts that will be granted permission to read from\n   * the artifact repos.\n   */\n  targetAccountIds?: string[]\n  /**\n   * Configuration for creating IAM roles that can be assumed\n   * by GitHub Actions in specific GitHub repositories.\n   *\n   * @default - no roles are created.\n   */\n  githubActions?: Omit<\n    GithubActionsRoleProps,\n    \"trustedOwners\" | \"trustedBranch\" | \"oidcProvider\" | \"roleName\"\n  > & {\n    /**\n     * A list of trusted GitHub repository owners.\n     *\n     * @default [\"capralifecycle\"]\n     */\n    trustedOwners?: string[]\n    /**\n     * The name of the role to create.\n     *\n     * @default \"github-actions-role\"\n     */\n    roleName?: string\n    /**\n     * The name of the default branch in all repositories.\n     *\n     * @default \"master\"\n     */\n    defaultBranch?: string\n    /**\n     * Configuration for a limited role that can be used on non-default\n     * branches with less IAM permissions than the main role.\n     *\n     * @default - a limited role is created.\n     */\n    limitedRoleConfiguration?: {\n      /**\n       * Whether to create the role or not.\n       *\n       * @default true\n       */\n      enabled?: boolean\n      /**\n       * The name of the role to create.\n       *\n       * @default \"github-actions-limited-role\"\n       */\n      roleName?: string\n    }\n  }\n}\n\n/**\n * Utility functions for generating IAM statements.\n */\nconst policyStatements = {\n  allowPipelineVariables: (scope: constructs.Construct, prefix?: string) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${cdk.Stack.of(scope).account}:parameter/liflig-cdk/*/pipeline-variables/${prefix ?? \"*\"}`,\n      ],\n    }),\n  denyProdPipelines: (scope: constructs.Construct, bucket: s3.IBucket) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"s3:*\"],\n      resources: [\n        bucket.arnForObjects(\"pipelines/*-prod/*\"),\n        bucket.arnForObjects(\"pipelines/*-prod-*/*\"),\n      ],\n    }),\n  denyProdPipelineVariables: (scope: constructs.Construct) =>\n    new iam.PolicyStatement({\n      effect: iam.Effect.DENY,\n      actions: [\"ssm:PutParameter\"],\n      resources: [\n        `arn:aws:ssm:${cdk.Stack.of(scope).region}:${\n          cdk.Stack.of(scope).account\n        }:parameter/liflig-cdk/*/pipeline-variables/prod*`,\n      ],\n    }),\n}\n\n/**\n * Utility function for validating the construct properties.\n */\nexport const validateProps = (props: Props) => {\n  let valid = true\n  if (\n    props.githubActions?.defaultBranch &&\n    !props.githubActions.defaultBranch.match(/^[a-zA-Z0-9-]+$/)\n  ) {\n    console.error(\n      `Default branch ${props.githubActions.defaultBranch} contains invalid characters`,\n    )\n    valid = false\n  }\n  return valid\n}\n\n/**\n * Create various artifacts used as part of Continuous Integration (CI).\n *\n * This includes artifact repositories such as S3 bucket and ECR\n * repository, as well as IAM role(s) that grant the CI server write\n * access to these repositories.\n *\n * TODO: How can we cleanup stuff that goes into this S3 Bucket and\n *  ECR Repository? Can we ever reliably cleanup? We probably need\n *  some strategy for how we put stuff here to be able to do it.\n *\n * @experimental\n */\nexport class BuildArtifacts extends constructs.Construct {\n  public readonly bucketName: string | undefined\n  public readonly ecrRepositoryArn: string\n  public readonly ecrRepositoryName: string\n  public readonly role?: iam.Role\n  public readonly limitedRole?: iam.Role\n\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    if (!validateProps(props)) {\n      throw new Error(\"Invalid props were supplied\")\n    }\n\n    this.bucketName = props.bucketName\n    this.ecrRepositoryName = props.ecrRepositoryName\n    this.ecrRepositoryArn = cdk.Arn.format(\n      {\n        service: \"ecr\",\n        resource: \"repository\",\n        resourceName: this.ecrRepositoryName,\n      },\n      cdk.Stack.of(this),\n    )\n\n    const ecrRepositoryName = props.ecrRepositoryName\n\n    const bucket = new s3.Bucket(this, \"S3Bucket\", {\n      bucketName: props.bucketName,\n      encryption: s3.BucketEncryption.S3_MANAGED,\n      eventBridgeEnabled: true,\n      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n      versioned: true,\n      lifecycleRules: [\n        {\n          noncurrentVersionExpiration: cdk.Duration.days(10),\n        },\n      ],\n    })\n\n    const ecrRepo = new ecr.Repository(this, \"EcrRepository\", {\n      repositoryName: ecrRepositoryName,\n      lifecycleRules: props.ecrRepositoryLifecycleRules || [\n        {\n          maxImageAge: cdk.Duration.days(10),\n          tagStatus: ecr.TagStatus.UNTAGGED,\n        },\n        {\n          maxImageAge: cdk.Duration.days(180),\n          tagStatus: ecr.TagStatus.ANY,\n        },\n      ],\n    })\n\n    // Allow a target to read from the repos. As any specific roles need\n    // to exist before we can grant access, we delegate that responsibility\n    // to the target account.\n    for (const targetAccountId of props.targetAccountIds || []) {\n      bucket.grantRead(new iam.AccountPrincipal(targetAccountId))\n      ecrRepo.grantPull(new iam.AccountPrincipal(targetAccountId))\n    }\n\n    if (props.githubActions) {\n      const trustedOwners = props.githubActions.trustedOwners ?? [\n        \"capralifecycle\",\n      ]\n      // NOTE: There's an L2 construct that predates the official CloudFormation resource,\n      // and it is therefore implemented as a custom resource.\n      // We use the L1 CloudFormation resource instead because:\n      // 1) it's simpler\n      // 2) there's a chance the L2 construct will be deprecated in the future in favor\n      // of the official CloudFormation resource.\n      const cfnOidcProvider = new iam.CfnOIDCProvider(\n        this,\n        \"OpenIdConnectProvider\",\n        {\n          url: \"https://token.actions.githubusercontent.com\",\n          clientIdList: [\"sts.amazonaws.com\"],\n          // NOTE: The thumbprint isn't actually used, but the AWS API still requires us to supply it.\n          // More details here: https://web.archive.org/web/20240122155758/https://github.com/aws-actions/configure-aws-credentials/issues/357#issuecomment-1626357333\n          thumbprintList: [\"1c58a3a8518e8759bf075b76b750d4f2df264fcd\"],\n        },\n      )\n      const oidcProvider =\n        iam.OpenIdConnectProvider.fromOpenIdConnectProviderArn(\n          this,\n          \"Provider\",\n          cfnOidcProvider.ref,\n        )\n      const createLimitedRole =\n        props.githubActions.limitedRoleConfiguration?.enabled ?? true\n      const role = new GithubActionsRole(this, \"GithubActionsRole\", {\n        oidcProvider,\n        trustedOwners,\n        roleName: props.githubActions.roleName ?? \"github-actions-role\",\n        trustedBranch: createLimitedRole\n          ? (props.githubActions.defaultBranch ?? \"master\")\n          : // NOTE: If the limited role is disabled, only one role will be created\n            // and that role then needs to be assumable from all branches.\n            \"*\",\n        repositories: props.githubActions.repositories,\n      })\n      this.role = role.role\n      this.role.addToPolicy(policyStatements.allowPipelineVariables(this))\n      bucket.grantPut(this.role)\n      ecrRepo.grantPullPush(this.role)\n      if (createLimitedRole) {\n        const limitedRole = new GithubActionsRole(\n          this,\n          \"GithubActionsLimitedRole\",\n          {\n            oidcProvider,\n            trustedOwners,\n            roleName:\n              props.githubActions.limitedRoleConfiguration?.roleName ??\n              \"github-actions-limited-role\",\n            // NOTE: The limited role can be assumed from all branches.\n            trustedBranch: \"*\",\n            repositories: props.githubActions.repositories,\n          },\n        )\n        this.limitedRole = limitedRole.role\n        this.limitedRole.addToPolicy(\n          policyStatements.allowPipelineVariables(this, \"dev*\"),\n        )\n        this.limitedRole.addToPolicy(\n          policyStatements.denyProdPipelines(scope, bucket),\n        )\n        bucket.grantPut(this.limitedRole)\n        ecrRepo.grantPullPush(this.limitedRole)\n      }\n    }\n    if (props.ciRoleName) {\n      const legacyRoleForJenkins = new iam.Role(this, \"CiRole\", {\n        roleName: props.ciRoleName,\n        assumedBy: new iam.ArnPrincipal(\n          \"arn:aws:iam::923402097046:role/buildtools-jenkins-RoleJenkinsSlave-JQGYHR5WE6C5\",\n        ),\n      })\n      legacyRoleForJenkins.addToPolicy(\n        policyStatements.allowPipelineVariables(this),\n      )\n      bucket.grantPut(legacyRoleForJenkins)\n      ecrRepo.grantPullPush(legacyRoleForJenkins)\n    }\n\n    new cdk.CfnOutput(this, \"EcrRepoUri\", {\n      value: ecrRepo.repositoryUri,\n    })\n\n    new cdk.CfnOutput(this, \"BucketName\", {\n      value: bucket.bucketName,\n    })\n\n    if (this.role) {\n      new cdk.CfnOutput(this, \"RoleArn\", {\n        value: this.role.roleArn,\n      })\n    }\n    if (this.limitedRole) {\n      new cdk.CfnOutput(this, \"LimitedRoleArn\", {\n        value: this.limitedRole.roleArn,\n      })\n    }\n  }\n}\n"]}

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.0",
+  "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": {