@rio-cloud/cdk-v2-constructs 2.0.0 → 2.0.3

package/lib/fargate/datadog.js

@@ -1,225 +1,295 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataDog = void 0;
+exports.ensureLoggingAndMonitoringAreReadyBeforeServiceStarts = exports.setupLogging = exports.addFireLensLogRouter = exports.addDatadogSidecar = exports.getFargateDockerLabels = exports.getFargateContainerEnvironmentVariables = exports.DataDog = void 0;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const ecs = require("aws-cdk-lib/aws-ecs");
 const lambda = require("aws-cdk-lib/aws-lambda");
 const logs = require("aws-cdk-lib/aws-logs");
 const rio_fargate_service_1 = require("./rio-fargate-service");
+/**
+ * @deprecated Moved out static methods and imporoved signature. Use named import instead.
+ */
 class DataDog {
-    static getFargateContainerEnvironmentVariables(scope, stage, serviceName, version, accountName, teamName) {
-        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
-        return {
-            // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
-            DD_ENV: stage,
-            DD_SERVICE: serviceName,
-            DD_VERSION: version,
-            // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers
-            DD_LOGS_INJECTION: 'true',
-            DD_SERVICE_MAPPING: this.getApmServiceMappingEnvironmentVariableValue(serviceName),
-            DD_TAGS: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'service'),
-            DD_TRACE_SAMPLE_RATE: '1.0',
-        };
-    }
-    // we add all possible service mappings here even if not used in a particular service to get globally unique names
-    static getApmServiceMappingEnvironmentVariableValue(serviceName) {
-        const serviceMapping = {
-            'database': `${serviceName}-aurora`,
-            'java-aws-sdk': `${serviceName}-aws-sdk`,
-            'kafka': `${serviceName}-kafka`,
-            'mysql': `${serviceName}-aurora`,
-            'redis': `${serviceName}-redis`,
-        };
-        return Object.entries(serviceMapping)
-            .map(([key, value]) => `${key}:${value}`)
-            .join(',');
+    static getFargateContainerEnvironmentVariables(scope, stage, serviceName, version, accountName, teamName, teamIdentifier, additionalTags) {
+        return getFargateContainerEnvironmentVariables({
+            scope,
+            stage,
+            serviceName,
+            version,
+            accountName,
+            teamName,
+            teamIdentifier,
+            additionalTags,
+        });
     }
     static getFargateDockerLabels(stage, serviceName, version) {
-        return {
-            'com.datadoghq.tags.env': stage,
-            'com.datadoghq.tags.service': serviceName,
-            'com.datadoghq.tags.version': version,
-        };
+        return getFargateDockerLabels({ stage, serviceName, version });
     }
-    static addDatadogSidecar(scope, taskDefinition, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogSite, datadogLoggingMode, apmGetResourcesToIgnore, cpu, memoryLimitMiB, essential, containerTag) {
-        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
-        const datadogSidecar = taskDefinition.addContainer('datadog-agent', {
-            image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${containerTag}`),
-            logging: this.setupLogging(scope, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogLoggingMode, datadogSite, 'datadog-sidecar'),
+    static addDatadogSidecar(scope, taskDefinition, accountName, teamName, teamIdentifier, stage, serviceName, version, datadogApiKeyParameter, datadogSite, datadogLoggingMode, apmGetResourcesToIgnore, cpu, memoryLimitMiB, essential, containerTag, additionalTags) {
+        return addDatadogSidecar({
+            scope,
+            taskDefinition,
+            accountName,
+            teamName,
+            teamIdentifier,
+            stage,
+            serviceName,
+            version,
+            datadogApiKeyParameter,
+            datadogSite,
+            datadogLoggingMode,
+            apmGetResourcesToIgnore,
             cpu,
             memoryLimitMiB,
-            environment: {
-                // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
-                DD_ENV: stage,
-                DD_SERVICE: serviceName,
-                DD_VERSION: version,
-                // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux
-                DD_APM_ENABLED: 'true',
-                DD_APM_IGNORE_RESOURCES: apmGetResourcesToIgnore
-                    .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)
-                    .join(','),
-                // general settings
-                DD_SITE: datadogSite,
-                DD_TAGS: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'datadog-sidecar'),
-                ECS_FARGATE: 'true',
-                DD_COLLECT_GCE_TAGS: 'false',
-            },
-            // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172
-            healthCheck: {
-                startPeriod: aws_cdk_lib_1.Duration.minutes(2),
-                interval: aws_cdk_lib_1.Duration.seconds(30),
-                timeout: aws_cdk_lib_1.Duration.seconds(5),
-                retries: 2,
-                command: ['CMD-SHELL', '/probe.sh'],
-            },
-            secrets: {
-                DD_API_KEY: ecs.Secret.fromSsmParameter(datadogApiKeyParameter),
-            },
-            essential: essential,
-        });
-        datadogSidecar.addPortMappings({
-            containerPort: 8125,
-            protocol: ecs.Protocol.UDP,
+            essential,
+            containerTag,
+            additionalTags,
         });
-        datadogSidecar.addPortMappings({
-            containerPort: 8126,
-            protocol: ecs.Protocol.TCP,
-        });
-        return datadogSidecar;
     }
-    static getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, containerType) {
-        let separator;
-        switch (containerType) {
-            case 'service':
-                separator = ',';
-                break;
-            case 'datadog-sidecar':
-                separator = ' ';
-                break;
-            case 'fluent-bit':
-                separator = ',';
-                break;
-        }
-        const tags = {
-            // unified tagging
-            // overridden by dedicated settings (environment variables/tags)
-            // duplicated here to ensure they are used (and sometimes, not all three values are supported)
-            env: stage,
-            service: serviceName,
+    static addFireLensLogRouter(taskDefinition, cpu, memoryLimitMiB) {
+        return addFireLensLogRouter({ taskDefinition, cpu, memoryLimitMiB });
+    }
+    static setupLogging(scope, accountName, teamName, teamIdentifier, stage, serviceName, version, datadogApiKeyParameter, datadogLoggingMode, datadogSite, containerType, additionalTags) {
+        return setupLogging({
+            scope,
+            accountName,
+            teamName,
+            teamIdentifier,
+            stage,
+            serviceName,
             version,
-            // account/team specific parts
-            account_id: accountId,
-            account_name: accountName,
+            datadogApiKeyParameter,
+            datadogLoggingMode,
+            datadogSite,
+            containerType,
+            additionalTags,
+        });
+    }
+    static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService) {
+        ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService);
+    }
+}
+exports.DataDog = DataDog;
+function getFargateContainerEnvironmentVariables(props) {
+    const { account: accountId, region } = aws_cdk_lib_1.Stack.of(props.scope);
+    return {
+        // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
+        DD_ENV: props.stage,
+        DD_SERVICE: props.serviceName,
+        DD_VERSION: props.version,
+        // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers
+        DD_LOGS_INJECTION: 'true',
+        DD_SERVICE_MAPPING: getApmServiceMappingEnvironmentVariableValue(props.serviceName),
+        DD_TAGS: getTagsEnvironmentVariableValue({
+            ...props,
+            containerType: 'service',
+            accountId,
             region,
-            team: teamName,
-        };
-        return Object.entries(tags)
-            .map(([key, value]) => `${key}:${value}`)
-            .join(separator);
+        }),
+        DD_TRACE_SAMPLE_RATE: '1.0',
+    };
+}
+exports.getFargateContainerEnvironmentVariables = getFargateContainerEnvironmentVariables;
+// we add all possible service mappings here even if not used in a particular service to get globally unique names
+function getApmServiceMappingEnvironmentVariableValue(serviceName) {
+    const serviceMapping = {
+        'database': `${serviceName}-aurora`,
+        'java-aws-sdk': `${serviceName}-aws-sdk`,
+        'kafka': `${serviceName}-kafka`,
+        'mysql': `${serviceName}-aurora`,
+        'redis': `${serviceName}-redis`,
+    };
+    return Object.entries(serviceMapping)
+        .map(([key, value]) => `${key}:${value}`)
+        .join(',');
+}
+function getFargateDockerLabels(props) {
+    return {
+        'com.datadoghq.tags.env': props.stage,
+        'com.datadoghq.tags.service': props.serviceName,
+        'com.datadoghq.tags.version': props.version,
+    };
+}
+exports.getFargateDockerLabels = getFargateDockerLabels;
+function addDatadogSidecar(props) {
+    const { account: accountId, region } = aws_cdk_lib_1.Stack.of(props.scope);
+    const datadogSidecar = props.taskDefinition.addContainer('datadog-agent', {
+        image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${props.containerTag}`),
+        logging: setupLogging({ ...props, containerType: 'datadog-sidecar' }),
+        cpu: props.cpu,
+        memoryLimitMiB: props.memoryLimitMiB,
+        environment: {
+            // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
+            DD_ENV: props.stage,
+            DD_SERVICE: props.serviceName,
+            DD_VERSION: props.version,
+            // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux
+            DD_APM_ENABLED: 'true',
+            DD_APM_IGNORE_RESOURCES: props.apmGetResourcesToIgnore
+                .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)
+                .join(','),
+            // general settings
+            DD_SITE: props.datadogSite,
+            DD_TAGS: getTagsEnvironmentVariableValue({ ...props, accountId, region, containerType: 'datadog-sidecar' }),
+            ECS_FARGATE: 'true',
+            DD_COLLECT_GCE_TAGS: 'false',
+        },
+        // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172
+        healthCheck: {
+            startPeriod: aws_cdk_lib_1.Duration.minutes(2),
+            interval: aws_cdk_lib_1.Duration.seconds(30),
+            timeout: aws_cdk_lib_1.Duration.seconds(5),
+            retries: 2,
+            command: ['CMD-SHELL', '/probe.sh'],
+        },
+        secrets: {
+            DD_API_KEY: ecs.Secret.fromSsmParameter(props.datadogApiKeyParameter),
+        },
+        essential: props.essential,
+    });
+    datadogSidecar.addPortMappings({
+        containerPort: 8125,
+        protocol: ecs.Protocol.UDP,
+    });
+    datadogSidecar.addPortMappings({
+        containerPort: 8126,
+        protocol: ecs.Protocol.TCP,
+    });
+    return datadogSidecar;
+}
+exports.addDatadogSidecar = addDatadogSidecar;
+function getTagsEnvironmentVariableValue(props) {
+    const separator = determineSeparator(props.containerType);
+    const tags = {
+        // unified tagging
+        // overridden by dedicated settings (environment variables/tags)
+        // duplicated here to ensure they are used (and sometimes, not all three values are supported)
+        env: props.stage,
+        service: props.serviceName,
+        version: props.version,
+        // account/team specific parts
+        account_id: props.accountId,
+        account_name: props.accountName,
+        region: props.region,
+        team: props.teamName,
+        team_identifier: props.teamIdentifier,
+    };
+    return Object.entries({ ...tags, ...props.additionalTags })
+        .map(([key, value]) => `${key}:${value}`)
+        .join(separator);
+}
+function determineSeparator(containerType) {
+    if (containerType === 'datadog-sidecar') {
+        return ' ';
     }
-    static addFireLensLogRouter(taskDefinition, cpu, memoryLimitMiB) {
-        return taskDefinition.addFirelensLogRouter('firelens-log-router', {
-            image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),
-            firelensConfig: {
-                type: ecs.FirelensLogRouterType.FLUENTBIT,
-                options: {
-                    configFileType: ecs.FirelensConfigFileType.FILE,
-                    configFileValue: '/fluent-bit/configs/parse-json.conf',
-                    enableECSLogMetadata: true,
-                },
+    else {
+        return ',';
+    }
+}
+function addFireLensLogRouter(props) {
+    return props.taskDefinition.addFirelensLogRouter('firelens-log-router', {
+        image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),
+        firelensConfig: {
+            type: ecs.FirelensLogRouterType.FLUENTBIT,
+            options: {
+                configFileType: ecs.FirelensConfigFileType.FILE,
+                configFileValue: '/fluent-bit/configs/parse-json.conf',
+                enableECSLogMetadata: true,
             },
-            cpu,
-            memoryLimitMiB,
-        });
+        },
+        cpu: props.cpu,
+        memoryLimitMiB: props.memoryLimitMiB,
+    });
+}
+exports.addFireLensLogRouter = addFireLensLogRouter;
+function setupLogging(props) {
+    let logGroupName;
+    let logGroupId;
+    let containerTypeCamelCase;
+    switch (props.containerType) {
+        case 'service':
+            logGroupId = 'LogGroupForService';
+            logGroupName = props.serviceName;
+            containerTypeCamelCase = 'Service';
+            break;
+        case 'datadog-sidecar':
+            logGroupId = 'LogGroupForDatadogSidecar';
+            logGroupName = `${props.serviceName}-${props.containerType}`;
+            containerTypeCamelCase = 'DatadogSidecar';
+            break;
     }
-    static setupLogging(scope, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogLoggingMode, datadogSite, containerType) {
-        let logGroupName;
-        let logGroupId;
-        let containerTypeCamelCase;
-        switch (containerType) {
-            case 'service':
-                logGroupId = 'LogGroupForService';
-                logGroupName = serviceName;
-                containerTypeCamelCase = 'Service';
-                break;
-            case 'datadog-sidecar':
-                logGroupId = 'LogGroupForDatadogSidecar';
-                logGroupName = `${serviceName}-${containerType}`;
-                containerTypeCamelCase = 'DatadogSidecar';
-                break;
-        }
-        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
-        switch (datadogLoggingMode) {
-            case rio_fargate_service_1.DataDogLoggingMode.AWS_FIRE_LENS:
-                // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36
-                // Probably not, see https://github.com/aws/aws-cdk/issues/8174
-                return ecs.LogDrivers.firelens({
-                    // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters
-                    options: {
-                        Name: 'datadog',
-                        Match: '*',
-                        Host: `http-intake.logs.${datadogSite}`,
-                        TLS: 'on',
-                        apikey: datadogApiKeyParameter.stringValue,
-                        compress: 'gzip',
-                        dd_service: logGroupName,
-                        dd_source: 'rio-fargate',
-                        dd_message_key: 'log',
-                        dd_tags: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'fluent-bit'),
-                        provider: 'ecs',
-                    },
-                });
-            case rio_fargate_service_1.DataDogLoggingMode.FORWARDER_LAMBDA:
-                const logGroupForForwardingLambda = new logs.LogGroup(scope, logGroupId, {
-                    logGroupName,
-                    retention: logs.RetentionDays.ONE_WEEK,
-                });
-                const logForwarderLambdaArn = aws_cdk_lib_1.Fn.importValue('custom-resource-datadog-logforwarder-function-arn');
-                const cfnPermission = new lambda.CfnPermission(scope, `LogForwarderPermission${containerTypeCamelCase}`, {
-                    action: 'lambda:InvokeFunction',
-                    functionName: logForwarderLambdaArn,
-                    principal: `logs.${region}.amazonaws.com`,
-                    sourceArn: logGroupForForwardingLambda.logGroupArn,
-                });
-                const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(scope, `LogForwarderSubscriptionFilter${containerTypeCamelCase}`, {
-                    destinationArn: logForwarderLambdaArn,
-                    filterPattern: '',
-                    logGroupName: logGroupForForwardingLambda.logGroupName,
-                });
-                cfnSubscriptionFilter.addDependsOn(cfnPermission);
-                return ecs.LogDrivers.awsLogs({
-                    streamPrefix: containerType,
-                    logGroup: logGroupForForwardingLambda,
-                });
-            case rio_fargate_service_1.DataDogLoggingMode.NONE:
-                const logGroupInCloudwatchOnly = new logs.LogGroup(scope, logGroupId, {
-                    retention: logs.RetentionDays.ONE_WEEK,
-                });
-                return ecs.LogDrivers.awsLogs({
-                    streamPrefix: containerType,
-                    logGroup: logGroupInCloudwatchOnly,
-                });
-        }
+    const { account: accountId, region } = aws_cdk_lib_1.Stack.of(props.scope);
+    switch (props.datadogLoggingMode) {
+        case rio_fargate_service_1.DataDogLoggingMode.AWS_FIRE_LENS:
+            // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36
+            // Probably not, see https://github.com/aws/aws-cdk/issues/8174
+            return ecs.LogDrivers.firelens({
+                // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters
+                options: {
+                    Name: 'datadog',
+                    Match: '*',
+                    Host: `http-intake.logs.${props.datadogSite}`,
+                    TLS: 'on',
+                    apikey: props.datadogApiKeyParameter.stringValue,
+                    compress: 'gzip',
+                    dd_service: logGroupName,
+                    dd_source: 'rio-fargate',
+                    dd_message_key: 'log',
+                    dd_tags: getTagsEnvironmentVariableValue({ ...props, accountId, region, containerType: 'fluent-bit' }),
+                    provider: 'ecs',
+                },
+            });
+        case rio_fargate_service_1.DataDogLoggingMode.FORWARDER_LAMBDA:
+            const logGroupForForwardingLambda = new logs.LogGroup(props.scope, logGroupId, {
+                logGroupName,
+                retention: logs.RetentionDays.ONE_WEEK,
+            });
+            const logForwarderLambdaArn = aws_cdk_lib_1.Fn.importValue('custom-resource-datadog-logforwarder-function-arn');
+            const cfnPermission = new lambda.CfnPermission(props.scope, `LogForwarderPermission${containerTypeCamelCase}`, {
+                action: 'lambda:InvokeFunction',
+                functionName: logForwarderLambdaArn,
+                principal: `logs.${region}.amazonaws.com`,
+                sourceArn: logGroupForForwardingLambda.logGroupArn,
+            });
+            const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(props.scope, `LogForwarderSubscriptionFilter${containerTypeCamelCase}`, {
+                destinationArn: logForwarderLambdaArn,
+                filterPattern: '',
+                logGroupName: logGroupForForwardingLambda.logGroupName,
+            });
+            cfnSubscriptionFilter.addDependsOn(cfnPermission);
+            return ecs.LogDrivers.awsLogs({
+                streamPrefix: props.containerType,
+                logGroup: logGroupForForwardingLambda,
+            });
+        case rio_fargate_service_1.DataDogLoggingMode.NONE:
+            const logGroupInCloudwatchOnly = new logs.LogGroup(props.scope, logGroupId, {
+                retention: logs.RetentionDays.ONE_WEEK,
+            });
+            return ecs.LogDrivers.awsLogs({
+                streamPrefix: props.containerType,
+                logGroup: logGroupInCloudwatchOnly,
+            });
     }
-    static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService) {
-        var _a;
+}
+exports.setupLogging = setupLogging;
+function ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService) {
+    var _a;
+    rioFargateService.serviceContainerDefinition.addContainerDependencies({
+        container: rioFargateService.datadogSideCarContainerDefinition,
+        condition: ecs.ContainerDependencyCondition.HEALTHY,
+    });
+    if (rioFargateService.logRouterContainerDefinition) {
         rioFargateService.serviceContainerDefinition.addContainerDependencies({
-            container: rioFargateService.datadogSideCarContainerDefinition,
-            condition: ecs.ContainerDependencyCondition.HEALTHY,
+            container: rioFargateService.logRouterContainerDefinition,
+            condition: ecs.ContainerDependencyCondition.START,
         });
-        if (rioFargateService.logRouterContainerDefinition) {
-            rioFargateService.serviceContainerDefinition.addContainerDependencies({
+        if (((_a = rioFargateService.datadogSideCarContainerDefinition.logDriverConfig) === null || _a === void 0 ? void 0 : _a.logDriver) === 'awsfirelens') {
+            rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({
                 container: rioFargateService.logRouterContainerDefinition,
                 condition: ecs.ContainerDependencyCondition.START,
             });
-            if (((_a = rioFargateService.datadogSideCarContainerDefinition.logDriverConfig) === null || _a === void 0 ? void 0 : _a.logDriver) === 'awsfirelens') {
-                rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({
-                    container: rioFargateService.logRouterContainerDefinition,
-                    condition: ecs.ContainerDependencyCondition.START,
-                });
-            }
         }
     }
 }
-exports.DataDog = DataDog;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog.js","sourceRoot":"","sources":["../../src/fargate/datadog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, Duration, Fn } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\nimport { DataDogLoggingMode, RioFargateService } from './rio-fargate-service';\n\nexport class DataDog {\n\n  public static getFargateContainerEnvironmentVariables(\n    scope: Construct,\n    stage: string,\n    serviceName: string,\n    version: string,\n    accountName: string,\n    teamName: string,\n  ): { [key: string]: string } {\n\n    const { account: accountId, region } = Stack.of(scope);\n\n    return {\n      // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n      DD_ENV: stage,\n      DD_SERVICE: serviceName,\n      DD_VERSION: version,\n      // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers\n      DD_LOGS_INJECTION: 'true',\n      DD_SERVICE_MAPPING: this.getApmServiceMappingEnvironmentVariableValue(serviceName),\n      DD_TAGS: this.getTagsEnvironmentVariableValue(\n        accountId,\n        accountName,\n        region,\n        teamName,\n        stage,\n        serviceName,\n        version,\n        'service',\n      ),\n      DD_TRACE_SAMPLE_RATE: '1.0', // see https://ddtrace.readthedocs.io/en/stable/configuration.html\n    };\n  }\n\n  // we add all possible service mappings here even if not used in a particular service to get globally unique names\n  static getApmServiceMappingEnvironmentVariableValue(serviceName: string): string {\n\n    const serviceMapping = {\n      'database': `${serviceName}-aurora`,\n      'java-aws-sdk': `${serviceName}-aws-sdk`,\n      'kafka': `${serviceName}-kafka`,\n      'mysql': `${serviceName}-aurora`,\n      'redis': `${serviceName}-redis`,\n    };\n\n    return Object.entries(serviceMapping)\n      .map(([key, value]) => `${key}:${value}`)\n      .join(',');\n  }\n\n  public static getFargateDockerLabels(stage: string, serviceName: string, version: string): { [key: string]: string } {\n    return {\n      'com.datadoghq.tags.env': stage,\n      'com.datadoghq.tags.service': serviceName,\n      'com.datadoghq.tags.version': version,\n    };\n  }\n\n  public static addDatadogSidecar(\n    scope: Construct,\n    taskDefinition: ecs.TaskDefinition,\n    accountName: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogSite: string,\n    datadogLoggingMode: DataDogLoggingMode,\n    apmGetResourcesToIgnore: string[],\n    cpu: number,\n    memoryLimitMiB: number,\n    essential: boolean,\n    containerTag: string,\n  ): ecs.ContainerDefinition {\n\n    const { account: accountId, region } = Stack.of(scope);\n    const datadogSidecar = taskDefinition.addContainer('datadog-agent', {\n      image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${containerTag}`),\n      logging: this.setupLogging(\n        scope,\n        accountName,\n        teamName,\n        stage,\n        serviceName,\n        version,\n        datadogApiKeyParameter,\n        datadogLoggingMode,\n        datadogSite,\n        'datadog-sidecar',\n      ),\n      cpu,\n      memoryLimitMiB,\n      environment: {\n        // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n        DD_ENV: stage,\n        DD_SERVICE: serviceName,\n        DD_VERSION: version,\n        // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux\n        DD_APM_ENABLED: 'true',\n        DD_APM_IGNORE_RESOURCES: apmGetResourcesToIgnore\n          .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)\n          .join(','),\n        // general settings\n        DD_SITE: datadogSite,\n        DD_TAGS: this.getTagsEnvironmentVariableValue(\n          accountId,\n          accountName,\n          region,\n          teamName,\n          stage,\n          serviceName,\n          version,\n          'datadog-sidecar',\n        ),\n        ECS_FARGATE: 'true',\n        DD_COLLECT_GCE_TAGS: 'false',\n      },\n      // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172\n      healthCheck: {\n        startPeriod: Duration.minutes(2),\n        interval: Duration.seconds(30),\n        timeout: Duration.seconds(5),\n        retries: 2,\n        command: ['CMD-SHELL', '/probe.sh'],\n      },\n      secrets: {\n        DD_API_KEY: ecs.Secret.fromSsmParameter(datadogApiKeyParameter),\n      },\n      essential: essential,\n    });\n\n    datadogSidecar.addPortMappings({\n      containerPort: 8125,\n      protocol: ecs.Protocol.UDP,\n    });\n\n    datadogSidecar.addPortMappings({\n      containerPort: 8126,\n      protocol: ecs.Protocol.TCP,\n    });\n\n    return datadogSidecar;\n  }\n\n  static getTagsEnvironmentVariableValue(\n    accountId: string,\n    accountName: string,\n    region: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    containerType: 'service' | 'datadog-sidecar' | 'fluent-bit',\n  ): string {\n\n    let separator: string;\n\n    switch (containerType) {\n\n      case 'service':\n        separator = ',';\n        break;\n\n      case 'datadog-sidecar':\n        separator = ' ';\n        break;\n\n      case 'fluent-bit':\n        separator = ',';\n        break;\n    }\n\n    const tags = {\n      // unified tagging\n      // overridden by dedicated settings (environment variables/tags)\n      // duplicated here to ensure they are used (and sometimes, not all three values are supported)\n      env: stage,\n      service: serviceName,\n      version,\n      // account/team specific parts\n      account_id: accountId,\n      account_name: accountName,\n      region,\n      team: teamName,\n    };\n    return Object.entries(tags)\n      .map(([key, value]) => `${key}:${value}`)\n      .join(separator);\n  }\n\n  public static addFireLensLogRouter(\n    taskDefinition: ecs.TaskDefinition,\n    cpu: number,\n    memoryLimitMiB: number,\n  ): ecs.ContainerDefinition {\n\n    return taskDefinition.addFirelensLogRouter('firelens-log-router', {\n      image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),\n      firelensConfig: {\n        type: ecs.FirelensLogRouterType.FLUENTBIT,\n        options: {\n          configFileType: ecs.FirelensConfigFileType.FILE,\n          configFileValue: '/fluent-bit/configs/parse-json.conf',\n          enableECSLogMetadata: true,\n        },\n      },\n      cpu,\n      memoryLimitMiB,\n    });\n  }\n\n  public static setupLogging(\n    scope: Construct,\n    accountName: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogLoggingMode: DataDogLoggingMode,\n    datadogSite: string,\n    containerType: 'service' | 'datadog-sidecar',\n  ): ecs.LogDriver {\n\n    let logGroupName: string;\n    let logGroupId: string;\n    let containerTypeCamelCase;\n\n    switch (containerType) {\n\n      case 'service':\n        logGroupId = 'LogGroupForService';\n        logGroupName = serviceName;\n        containerTypeCamelCase = 'Service';\n        break;\n\n      case 'datadog-sidecar':\n        logGroupId = 'LogGroupForDatadogSidecar';\n        logGroupName = `${serviceName}-${containerType}`;\n        containerTypeCamelCase = 'DatadogSidecar';\n        break;\n    }\n\n    const { account: accountId, region } = Stack.of(scope);\n\n    switch (datadogLoggingMode) {\n\n      case DataDogLoggingMode.AWS_FIRE_LENS:\n        // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36\n        // Probably not, see https://github.com/aws/aws-cdk/issues/8174\n        return ecs.LogDrivers.firelens({\n          // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters\n          options: {\n            Name: 'datadog',\n            Match: '*',\n            Host: `http-intake.logs.${datadogSite}`,\n            TLS: 'on',\n            apikey: datadogApiKeyParameter.stringValue,\n            compress: 'gzip',\n            dd_service: logGroupName,\n            dd_source: 'rio-fargate',\n            dd_message_key: 'log',\n            dd_tags: this.getTagsEnvironmentVariableValue(\n              accountId,\n              accountName,\n              region,\n              teamName,\n              stage,\n              serviceName,\n              version,\n              'fluent-bit',\n            ),\n            provider: 'ecs',\n          },\n        });\n\n      case DataDogLoggingMode.FORWARDER_LAMBDA:\n        const logGroupForForwardingLambda = new logs.LogGroup(scope, logGroupId, {\n          logGroupName,\n          retention: logs.RetentionDays.ONE_WEEK,\n        });\n        const logForwarderLambdaArn = Fn.importValue('custom-resource-datadog-logforwarder-function-arn');\n        const cfnPermission = new lambda.CfnPermission(scope, `LogForwarderPermission${containerTypeCamelCase}`, {\n          action: 'lambda:InvokeFunction',\n          functionName: logForwarderLambdaArn,\n          principal: `logs.${region}.amazonaws.com`,\n          sourceArn: logGroupForForwardingLambda.logGroupArn,\n        });\n        const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(\n          scope,\n          `LogForwarderSubscriptionFilter${containerTypeCamelCase}`,\n          {\n            destinationArn: logForwarderLambdaArn,\n            filterPattern: '',\n            logGroupName: logGroupForForwardingLambda.logGroupName,\n          },\n        );\n        cfnSubscriptionFilter.addDependsOn(cfnPermission);\n        return ecs.LogDrivers.awsLogs({\n          streamPrefix: containerType,\n          logGroup: logGroupForForwardingLambda,\n        });\n\n      case DataDogLoggingMode.NONE:\n        const logGroupInCloudwatchOnly = new logs.LogGroup(scope, logGroupId, {\n          retention: logs.RetentionDays.ONE_WEEK,\n        });\n        return ecs.LogDrivers.awsLogs({\n          streamPrefix: containerType,\n          logGroup: logGroupInCloudwatchOnly,\n        });\n    }\n  }\n\n  public static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService: RioFargateService) {\n\n    rioFargateService.serviceContainerDefinition.addContainerDependencies({\n      container: rioFargateService.datadogSideCarContainerDefinition,\n      condition: ecs.ContainerDependencyCondition.HEALTHY,\n    });\n\n    if (rioFargateService.logRouterContainerDefinition) {\n      rioFargateService.serviceContainerDefinition.addContainerDependencies({\n        container: rioFargateService.logRouterContainerDefinition,\n        condition: ecs.ContainerDependencyCondition.START,\n      });\n\n      if (rioFargateService.datadogSideCarContainerDefinition.logDriverConfig?.logDriver === 'awsfirelens') {\n        rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({\n          container: rioFargateService.logRouterContainerDefinition,\n          condition: ecs.ContainerDependencyCondition.START,\n        });\n      }\n    }\n  }\n}\n\n"]}
+exports.ensureLoggingAndMonitoringAreReadyBeforeServiceStarts = ensureLoggingAndMonitoringAreReadyBeforeServiceStarts;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog.js","sourceRoot":"","sources":["../../src/fargate/datadog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, Duration, Fn } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\nimport { DataDogLoggingMode, RioFargateService } from './rio-fargate-service';\n\n/**\n * @deprecated Moved out static methods and imporoved signature. Use named import instead.\n */\nexport class DataDog {\n\n  public static getFargateContainerEnvironmentVariables(\n    scope: Construct,\n    stage: string,\n    serviceName: string,\n    version: string,\n    accountName: string,\n    teamName: string,\n    teamIdentifier: string,\n    additionalTags: { [k: string]: string} | undefined,\n  ): { [key: string]: string } {\n    return getFargateContainerEnvironmentVariables({\n      scope,\n      stage,\n      serviceName,\n      version,\n      accountName,\n      teamName,\n      teamIdentifier,\n      additionalTags,\n    });\n  }\n\n  public static getFargateDockerLabels(stage: string, serviceName: string, version: string): { [key: string]: string } {\n    return getFargateDockerLabels({ stage, serviceName, version });\n  }\n\n  public static addDatadogSidecar(\n    scope: Construct,\n    taskDefinition: ecs.TaskDefinition,\n    accountName: string,\n    teamName: string,\n    teamIdentifier: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogSite: string,\n    datadogLoggingMode: DataDogLoggingMode,\n    apmGetResourcesToIgnore: string[],\n    cpu: number,\n    memoryLimitMiB: number,\n    essential: boolean,\n    containerTag: string,\n    additionalTags: { [k: string]: string} | undefined,\n  ): ecs.ContainerDefinition {\n\n    return addDatadogSidecar({\n      scope,\n      taskDefinition,\n      accountName,\n      teamName,\n      teamIdentifier,\n      stage,\n      serviceName,\n      version,\n      datadogApiKeyParameter,\n      datadogSite,\n      datadogLoggingMode,\n      apmGetResourcesToIgnore,\n      cpu,\n      memoryLimitMiB,\n      essential,\n      containerTag,\n      additionalTags,\n    });\n  }\n\n  public static addFireLensLogRouter(\n    taskDefinition: ecs.TaskDefinition,\n    cpu: number,\n    memoryLimitMiB: number,\n  ): ecs.ContainerDefinition {\n    return addFireLensLogRouter({ taskDefinition, cpu, memoryLimitMiB });\n  }\n\n  public static setupLogging(\n    scope: Construct,\n    accountName: string,\n    teamName: string,\n    teamIdentifier: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogLoggingMode: DataDogLoggingMode,\n    datadogSite: string,\n    containerType: 'service' | 'datadog-sidecar',\n    additionalTags: { [k: string]: string} | undefined,\n  ): ecs.LogDriver {\n\n    return setupLogging({\n      scope,\n      accountName,\n      teamName,\n      teamIdentifier,\n      stage,\n      serviceName,\n      version,\n      datadogApiKeyParameter,\n      datadogLoggingMode,\n      datadogSite,\n      containerType,\n      additionalTags,\n    });\n  }\n\n  public static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService: RioFargateService) {\n    ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService);\n  }\n}\n\nexport function getFargateContainerEnvironmentVariables(props: {\n  scope: Construct;\n  stage: string;\n  serviceName: string;\n  version: string;\n  accountName: string;\n  teamName: string;\n  teamIdentifier: string;\n  additionalTags: { [k: string]: string} | undefined;\n}): { [key: string]: string } {\n\n  const { account: accountId, region } = Stack.of(props.scope);\n\n  return {\n    // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n    DD_ENV: props.stage,\n    DD_SERVICE: props.serviceName,\n    DD_VERSION: props.version,\n    // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers\n    DD_LOGS_INJECTION: 'true',\n    DD_SERVICE_MAPPING: getApmServiceMappingEnvironmentVariableValue(props.serviceName),\n    DD_TAGS: getTagsEnvironmentVariableValue({\n      ...props,\n      containerType: 'service',\n      accountId,\n      region,\n    }),\n    DD_TRACE_SAMPLE_RATE: '1.0', // see https://ddtrace.readthedocs.io/en/stable/configuration.html\n  };\n}\n\n// we add all possible service mappings here even if not used in a particular service to get globally unique names\nfunction getApmServiceMappingEnvironmentVariableValue(serviceName: string): string {\n\n  const serviceMapping = {\n    'database': `${serviceName}-aurora`,\n    'java-aws-sdk': `${serviceName}-aws-sdk`,\n    'kafka': `${serviceName}-kafka`,\n    'mysql': `${serviceName}-aurora`,\n    'redis': `${serviceName}-redis`,\n  };\n\n  return Object.entries(serviceMapping)\n    .map(([key, value]) => `${key}:${value}`)\n    .join(',');\n}\n\nexport function getFargateDockerLabels(props: {stage: string; serviceName: string; version: string}): { [key: string]: string } {\n  return {\n    'com.datadoghq.tags.env': props.stage,\n    'com.datadoghq.tags.service': props.serviceName,\n    'com.datadoghq.tags.version': props.version,\n  };\n}\n\nexport function addDatadogSidecar(props: {\n  scope: Construct;\n  taskDefinition: ecs.TaskDefinition;\n  accountName: string;\n  teamName: string;\n  teamIdentifier: string;\n  stage: string;\n  serviceName: string;\n  version: string;\n  datadogApiKeyParameter: ssm.IStringParameter;\n  datadogSite: string;\n  datadogLoggingMode: DataDogLoggingMode;\n  apmGetResourcesToIgnore: string[];\n  cpu: number;\n  memoryLimitMiB: number;\n  essential: boolean;\n  containerTag: string;\n  additionalTags: { [k: string]: string} | undefined;\n}): ecs.ContainerDefinition {\n\n  const { account: accountId, region } = Stack.of(props.scope);\n  const datadogSidecar = props.taskDefinition.addContainer('datadog-agent', {\n    image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${props.containerTag}`),\n    logging: setupLogging({ ...props, containerType: 'datadog-sidecar' }),\n    cpu: props.cpu,\n    memoryLimitMiB: props.memoryLimitMiB,\n    environment: {\n      // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n      DD_ENV: props.stage,\n      DD_SERVICE: props.serviceName,\n      DD_VERSION: props.version,\n      // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux\n      DD_APM_ENABLED: 'true',\n      DD_APM_IGNORE_RESOURCES: props.apmGetResourcesToIgnore\n        .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)\n        .join(','),\n      // general settings\n      DD_SITE: props.datadogSite,\n      DD_TAGS: getTagsEnvironmentVariableValue({ ...props, accountId, region, containerType: 'datadog-sidecar' }),\n      ECS_FARGATE: 'true',\n      DD_COLLECT_GCE_TAGS: 'false',\n    },\n    // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172\n    healthCheck: {\n      startPeriod: Duration.minutes(2),\n      interval: Duration.seconds(30),\n      timeout: Duration.seconds(5),\n      retries: 2,\n      command: ['CMD-SHELL', '/probe.sh'],\n    },\n    secrets: {\n      DD_API_KEY: ecs.Secret.fromSsmParameter(props.datadogApiKeyParameter),\n    },\n    essential: props.essential,\n  });\n\n  datadogSidecar.addPortMappings({\n    containerPort: 8125,\n    protocol: ecs.Protocol.UDP,\n  });\n\n  datadogSidecar.addPortMappings({\n    containerPort: 8126,\n    protocol: ecs.Protocol.TCP,\n  });\n\n  return datadogSidecar;\n}\n\nfunction getTagsEnvironmentVariableValue(props: {\n  accountId: string;\n  accountName: string;\n  region: string;\n  teamName: string;\n  teamIdentifier: string;\n  stage: string;\n  serviceName: string;\n  version: string;\n  containerType: 'service' | 'datadog-sidecar' | 'fluent-bit';\n  additionalTags: { [k: string]: string} | undefined;\n}): string {\n\n  const separator = determineSeparator(props.containerType);\n\n  const tags = {\n    // unified tagging\n    // overridden by dedicated settings (environment variables/tags)\n    // duplicated here to ensure they are used (and sometimes, not all three values are supported)\n    env: props.stage,\n    service: props.serviceName,\n    version: props.version,\n    // account/team specific parts\n    account_id: props.accountId,\n    account_name: props.accountName,\n    region: props.region,\n    team: props.teamName,\n    team_identifier: props.teamIdentifier,\n  };\n  return Object.entries({ ...tags, ...props.additionalTags })\n    .map(([key, value]) => `${key}:${value}`)\n    .join(separator);\n}\n\nfunction determineSeparator(containerType: 'service' | 'datadog-sidecar' | 'fluent-bit') {\n  if (containerType === 'datadog-sidecar') {\n    return ' ';\n  } else {\n    return ',';\n  }\n}\n\nexport function addFireLensLogRouter(props: {\n  taskDefinition: ecs.TaskDefinition;\n  cpu: number;\n  memoryLimitMiB: number;\n}): ecs.ContainerDefinition {\n\n  return props.taskDefinition.addFirelensLogRouter('firelens-log-router', {\n    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),\n    firelensConfig: {\n      type: ecs.FirelensLogRouterType.FLUENTBIT,\n      options: {\n        configFileType: ecs.FirelensConfigFileType.FILE,\n        configFileValue: '/fluent-bit/configs/parse-json.conf',\n        enableECSLogMetadata: true,\n      },\n    },\n    cpu: props.cpu,\n    memoryLimitMiB: props.memoryLimitMiB,\n  });\n}\n\nexport function setupLogging(props: {\n  scope: Construct;\n  accountName: string;\n  teamName: string;\n  teamIdentifier: string;\n  stage: string;\n  serviceName: string;\n  version: string;\n  datadogApiKeyParameter: ssm.IStringParameter;\n  datadogLoggingMode: DataDogLoggingMode;\n  datadogSite: string;\n  containerType: 'service' | 'datadog-sidecar';\n  additionalTags: { [k: string]: string} | undefined;\n}): ecs.LogDriver {\n\n  let logGroupName: string;\n  let logGroupId: string;\n  let containerTypeCamelCase;\n\n  switch (props.containerType) {\n\n    case 'service':\n      logGroupId = 'LogGroupForService';\n      logGroupName = props.serviceName;\n      containerTypeCamelCase = 'Service';\n      break;\n\n    case 'datadog-sidecar':\n      logGroupId = 'LogGroupForDatadogSidecar';\n      logGroupName = `${props.serviceName}-${props.containerType}`;\n      containerTypeCamelCase = 'DatadogSidecar';\n      break;\n  }\n\n  const { account: accountId, region } = Stack.of(props.scope);\n\n  switch (props.datadogLoggingMode) {\n\n    case DataDogLoggingMode.AWS_FIRE_LENS:\n      // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36\n      // Probably not, see https://github.com/aws/aws-cdk/issues/8174\n      return ecs.LogDrivers.firelens({\n        // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters\n        options: {\n          Name: 'datadog',\n          Match: '*',\n          Host: `http-intake.logs.${props.datadogSite}`,\n          TLS: 'on',\n          apikey: props.datadogApiKeyParameter.stringValue,\n          compress: 'gzip',\n          dd_service: logGroupName,\n          dd_source: 'rio-fargate',\n          dd_message_key: 'log',\n          dd_tags: getTagsEnvironmentVariableValue({ ...props, accountId, region, containerType: 'fluent-bit' }),\n          provider: 'ecs',\n        },\n      });\n\n    case DataDogLoggingMode.FORWARDER_LAMBDA:\n      const logGroupForForwardingLambda = new logs.LogGroup(props.scope, logGroupId, {\n        logGroupName,\n        retention: logs.RetentionDays.ONE_WEEK,\n      });\n      const logForwarderLambdaArn = Fn.importValue('custom-resource-datadog-logforwarder-function-arn');\n      const cfnPermission = new lambda.CfnPermission(props.scope, `LogForwarderPermission${containerTypeCamelCase}`, {\n        action: 'lambda:InvokeFunction',\n        functionName: logForwarderLambdaArn,\n        principal: `logs.${region}.amazonaws.com`,\n        sourceArn: logGroupForForwardingLambda.logGroupArn,\n      });\n      const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(\n        props.scope,\n        `LogForwarderSubscriptionFilter${containerTypeCamelCase}`,\n        {\n          destinationArn: logForwarderLambdaArn,\n          filterPattern: '',\n          logGroupName: logGroupForForwardingLambda.logGroupName,\n        },\n      );\n      cfnSubscriptionFilter.addDependsOn(cfnPermission);\n      return ecs.LogDrivers.awsLogs({\n        streamPrefix: props.containerType,\n        logGroup: logGroupForForwardingLambda,\n      });\n\n    case DataDogLoggingMode.NONE:\n      const logGroupInCloudwatchOnly = new logs.LogGroup(props.scope, logGroupId, {\n        retention: logs.RetentionDays.ONE_WEEK,\n      });\n      return ecs.LogDrivers.awsLogs({\n        streamPrefix: props.containerType,\n        logGroup: logGroupInCloudwatchOnly,\n      });\n  }\n}\n\nexport function ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService: RioFargateService): void {\n\n  rioFargateService.serviceContainerDefinition.addContainerDependencies({\n    container: rioFargateService.datadogSideCarContainerDefinition,\n    condition: ecs.ContainerDependencyCondition.HEALTHY,\n  });\n\n  if (rioFargateService.logRouterContainerDefinition) {\n    rioFargateService.serviceContainerDefinition.addContainerDependencies({\n      container: rioFargateService.logRouterContainerDefinition,\n      condition: ecs.ContainerDependencyCondition.START,\n    });\n\n    if (rioFargateService.datadogSideCarContainerDefinition.logDriverConfig?.logDriver === 'awsfirelens') {\n      rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({\n        container: rioFargateService.logRouterContainerDefinition,\n        condition: ecs.ContainerDependencyCondition.START,\n      });\n    }\n  }\n}\n"]}