@rio-cloud/cdk-v2-constructs 6.6.0 → 6.7.0

package/lib/datadog/datadog-log-index-monitoring.js

@@ -1,7 +1,8 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrganizationUrlPrefix = exports.DatadogLogIndexMonitoring = void 0;
+exports.DatadogLogIndexMonitoring = void 0;
+exports.getOrganizationUrlPrefix = getOrganizationUrlPrefix;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const constructs_1 = require("constructs");
@@ -133,11 +134,10 @@ function getOrganizationUrlPrefix(organization) {
             return 'rio-landingzone';
     }
 }
-exports.getOrganizationUrlPrefix = getOrganizationUrlPrefix;
 function datadogLogsSearchWithIndexFilterDeepLink(indexName, organization) {
     return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;
 }
 function datadogLogsIndexesConfigurationDeepLink(organization) {
     return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-log-index-monitoring.js","sourceRoot":"","sources":["../../src/datadog/datadog-log-index-monitoring.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { DatadogMonitor, DatadogAlertType } from './datadog-monitor';\n\nexport interface DatadogLogIndexMonitoringProps {\n\n  /**\n   * The name of your service in Datadog. Can be used to query the monitors.\n   */\n  readonly serviceName: string;\n\n  /**\n   * The name of the Datadog index.\n   */\n  readonly indexName: string;\n\n  /**\n   * The integration to use for alerting.\n   * For OpsGenie, you need to install and configure the 'opsgenie-integration' account module.\n   */\n  readonly alertType: DatadogAlertType;\n\n  /**\n   * The daily log quota settings.\n   */\n  readonly dailyLogQuota: DatadogLogQuotaProps;\n\n  /**\n   * This value should be used if there is no log message within 24 hours or missing historical data.\n   * Without setting this value it will lead to an empty result and therefore trigger an alert.\n   * @defaultValue - false\n   */\n  readonly sparseLogging?: boolean;\n\n  /**\n   * The Datadog organization, e.g., 'EU' or 'LATAM'\n   * @defaultValue - 'EU'\n   */\n  readonly organization?: DatadogOrganization;\n}\n\nexport interface DatadogLogQuotaProps {\n  /**\n   * The daily log quota for the team-specific index in million events.\n   */\n  readonly valueInMillionEvents: number;\n\n  /**\n   * The warning threshold for the daily log quota monitor in percent.\n   */\n  readonly warningThresholdInPercent: number;\n\n  /**\n   * The alarm threshold for the daily log quota monitor in percent.\n   * The value must be between 0 and 100 and greater than or equal to the warning threshold.\n   */\n  readonly alertThresholdInPercent: number;\n}\n\n/**\n * Basic monitoring and alerting for a Datadog logs index.\n * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/\n * and consists of the following three monitors.\n *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.\n *   2. An anomaly monitor that detects log amount spikes.\n *   3. An event alert that fires when you hit the daily log quota.\n *\n * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.\n * @deprecated Please use datadogv2 DatadogLogIndexMonitoring instead\n */\nexport class DatadogLogIndexMonitoring extends Construct {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id);\n\n    new DatadogLogDailyQuotaMonitor(this, 'DatadogLogDailyQuotaMonitor', props);\n    new DatadogLogsAnomalyMonitor(this, 'DatadogLogAlertAnomalyMonitor', props);\n    new DatadogLogDailyQuotaReachedMonitor(this, 'DatadogLogDailyQuotaReachedV2Monitor', props);\n    Annotations.of(scope).addDeprecation('@rio-cloud/cdk-v2-constructs.DatadogLogIndexMonitoring', 'DatadogLogIndexMonitoring deprecated! Please use datadogv2 DatadogLogIndexMonitoring instead');\n\n    this.node.addValidation({\n      validate: (): string[] => {\n        const result = [];\n        if (props.dailyLogQuota.warningThresholdInPercent < 0 || props.dailyLogQuota.warningThresholdInPercent > 100) {\n          result.push('Invalid [warningThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < 0 || props.dailyLogQuota.alertThresholdInPercent > 100) {\n          result.push('Invalid [alertThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < props.dailyLogQuota.warningThresholdInPercent) {\n          result.push('Invalid [alertThresholdInPercent]: must be greater than or equal to [warningThresholdInPercent]');\n        }\n        return result;\n      },\n    });\n  }\n}\n\nconst commonMonitorNamePrefix = (indexName: string) => `'${indexName}' index`;\nconst commonTags = (indexName: string) => [`logIndex:${indexName}`];\n\nclass DatadogLogDailyQuotaMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    const logQuotaInEvents = Math.floor(props.dailyLogQuota.valueInMillionEvents * 1_000_000);\n    const warningThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.warningThresholdInPercent / 100));\n    const alertThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.alertThresholdInPercent / 100));\n\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log quota almost reached`,\n        type: 'metric alert',\n        query: `sum(last_1d):sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count() >= ${alertThreshold}`,\n        message: `[P3] Inspect your log volume at ${datadogLogsSearchWithIndexFilterDeepLink(\n          props.indexName, props.organization,\n        )} or adapt the log quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}`,\n        options: {\n          thresholds: {\n            critical: alertThreshold,\n            warning: warningThreshold,\n          },\n          include_tags: false,\n          notify_no_data: !props.sparseLogging,\n          no_data_timeframe: 24 * 60, // 1 day\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nclass DatadogLogsAnomalyMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log amount is rising to unexpected levels`,\n        type: 'metric alert',\n        query: `avg(last_4h):anomalies(sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count(), 'robust', 2, direction='above', alert_window='last_15m', interval=60, count_default_zero='true', seasonality='weekly', timezone='europe/berlin') >= 1`,\n        message: `[P4] Logs are getting out of control: ${datadogLogsSearchWithIndexFilterDeepLink(\n          props.indexName, props.organization,\n        )}`,\n        options: {\n          include_tags: false,\n          notify_no_data: !props.sparseLogging,\n          threshold_windows: {\n            trigger_window: 'last_15m',\n            recovery_window: 'last_15m',\n          },\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nclass DatadogLogDailyQuotaReachedMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log quota reached`,\n        type: 'event-v2 alert',\n        query: `events(\"source:datadog datadog_index:${props.indexName} Daily quota reached\").rollup(\"count\").last(\"12h\") > 0`,\n        message: `[P2] The log quote for the index has been reached. If you do not increase the quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}, no new logs will be indexed until the quota is reset at 2:00pm UTC.`,\n        options: {\n          timeout_h: 24,\n          thresholds: {\n            critical: 0,\n          },\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nexport type DatadogOrganization = 'EU' | 'LATAM' | 'Landing Zone';\n\nexport function getOrganizationUrlPrefix(organization: DatadogOrganization | undefined): string {\n  switch (organization ?? 'EU') {\n    case 'EU':\n      return 'app';\n    case 'LATAM':\n      return 'rio-brazil';\n    case 'Landing Zone':\n      return 'rio-landingzone';\n  }\n}\n\nfunction datadogLogsSearchWithIndexFilterDeepLink(indexName: string, organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;\n}\n\nfunction datadogLogsIndexesConfigurationDeepLink(organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-log-index-monitoring.js","sourceRoot":"","sources":["../../src/datadog/datadog-log-index-monitoring.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { DatadogMonitor, DatadogAlertType } from './datadog-monitor';\n\nexport interface DatadogLogIndexMonitoringProps {\n\n  /**\n   * The name of your service in Datadog. Can be used to query the monitors.\n   */\n  readonly serviceName: string;\n\n  /**\n   * The name of the Datadog index.\n   */\n  readonly indexName: string;\n\n  /**\n   * The integration to use for alerting.\n   * For OpsGenie, you need to install and configure the 'opsgenie-integration' account module.\n   */\n  readonly alertType: DatadogAlertType;\n\n  /**\n   * The daily log quota settings.\n   */\n  readonly dailyLogQuota: DatadogLogQuotaProps;\n\n  /**\n   * This value should be used if there is no log message within 24 hours or missing historical data.\n   * Without setting this value it will lead to an empty result and therefore trigger an alert.\n   * @defaultValue - false\n   */\n  readonly sparseLogging?: boolean;\n\n  /**\n   * The Datadog organization, e.g., 'EU' or 'LATAM'\n   * @defaultValue - 'EU'\n   */\n  readonly organization?: DatadogOrganization;\n}\n\nexport interface DatadogLogQuotaProps {\n  /**\n   * The daily log quota for the team-specific index in million events.\n   */\n  readonly valueInMillionEvents: number;\n\n  /**\n   * The warning threshold for the daily log quota monitor in percent.\n   */\n  readonly warningThresholdInPercent: number;\n\n  /**\n   * The alarm threshold for the daily log quota monitor in percent.\n   * The value must be between 0 and 100 and greater than or equal to the warning threshold.\n   */\n  readonly alertThresholdInPercent: number;\n}\n\n/**\n * Basic monitoring and alerting for a Datadog logs index.\n * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/\n * and consists of the following three monitors.\n *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.\n *   2. An anomaly monitor that detects log amount spikes.\n *   3. An event alert that fires when you hit the daily log quota.\n *\n * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.\n * @deprecated Please use datadogv2 DatadogLogIndexMonitoring instead\n */\nexport class DatadogLogIndexMonitoring extends Construct {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id);\n\n    new DatadogLogDailyQuotaMonitor(this, 'DatadogLogDailyQuotaMonitor', props);\n    new DatadogLogsAnomalyMonitor(this, 'DatadogLogAlertAnomalyMonitor', props);\n    new DatadogLogDailyQuotaReachedMonitor(this, 'DatadogLogDailyQuotaReachedV2Monitor', props);\n    Annotations.of(scope).addDeprecation('@rio-cloud/cdk-v2-constructs.DatadogLogIndexMonitoring', 'DatadogLogIndexMonitoring deprecated! Please use datadogv2 DatadogLogIndexMonitoring instead');\n\n    this.node.addValidation({\n      validate: (): string[] => {\n        const result = [];\n        if (props.dailyLogQuota.warningThresholdInPercent < 0 || props.dailyLogQuota.warningThresholdInPercent > 100) {\n          result.push('Invalid [warningThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < 0 || props.dailyLogQuota.alertThresholdInPercent > 100) {\n          result.push('Invalid [alertThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < props.dailyLogQuota.warningThresholdInPercent) {\n          result.push('Invalid [alertThresholdInPercent]: must be greater than or equal to [warningThresholdInPercent]');\n        }\n        return result;\n      },\n    });\n  }\n}\n\nconst commonMonitorNamePrefix = (indexName: string) => `'${indexName}' index`;\nconst commonTags = (indexName: string) => [`logIndex:${indexName}`];\n\nclass DatadogLogDailyQuotaMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    const logQuotaInEvents = Math.floor(props.dailyLogQuota.valueInMillionEvents * 1_000_000);\n    const warningThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.warningThresholdInPercent / 100));\n    const alertThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.alertThresholdInPercent / 100));\n\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log quota almost reached`,\n        type: 'metric alert',\n        query: `sum(last_1d):sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count() >= ${alertThreshold}`,\n        message: `[P3] Inspect your log volume at ${datadogLogsSearchWithIndexFilterDeepLink(\n          props.indexName, props.organization,\n        )} or adapt the log quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}`,\n        options: {\n          thresholds: {\n            critical: alertThreshold,\n            warning: warningThreshold,\n          },\n          include_tags: false,\n          notify_no_data: !props.sparseLogging,\n          no_data_timeframe: 24 * 60, // 1 day\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nclass DatadogLogsAnomalyMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log amount is rising to unexpected levels`,\n        type: 'metric alert',\n        query: `avg(last_4h):anomalies(sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count(), 'robust', 2, direction='above', alert_window='last_15m', interval=60, count_default_zero='true', seasonality='weekly', timezone='europe/berlin') >= 1`,\n        message: `[P4] Logs are getting out of control: ${datadogLogsSearchWithIndexFilterDeepLink(\n          props.indexName, props.organization,\n        )}`,\n        options: {\n          include_tags: false,\n          notify_no_data: !props.sparseLogging,\n          threshold_windows: {\n            trigger_window: 'last_15m',\n            recovery_window: 'last_15m',\n          },\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nclass DatadogLogDailyQuotaReachedMonitor extends DatadogMonitor {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id, {\n      serviceName: props.serviceName,\n      alertTypes: [props.alertType],\n      monitor: {\n        name: `${commonMonitorNamePrefix(props.indexName)}: Log quota reached`,\n        type: 'event-v2 alert',\n        query: `events(\"source:datadog datadog_index:${props.indexName} Daily quota reached\").rollup(\"count\").last(\"12h\") > 0`,\n        message: `[P2] The log quote for the index has been reached. If you do not increase the quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}, no new logs will be indexed until the quota is reset at 2:00pm UTC.`,\n        options: {\n          timeout_h: 24,\n          thresholds: {\n            critical: 0,\n          },\n        },\n        tags: [\n          ...commonTags(props.indexName),\n        ],\n      },\n    });\n  }\n}\n\nexport type DatadogOrganization = 'EU' | 'LATAM' | 'Landing Zone';\n\nexport function getOrganizationUrlPrefix(organization: DatadogOrganization | undefined): string {\n  switch (organization ?? 'EU') {\n    case 'EU':\n      return 'app';\n    case 'LATAM':\n      return 'rio-brazil';\n    case 'Landing Zone':\n      return 'rio-landingzone';\n  }\n}\n\nfunction datadogLogsSearchWithIndexFilterDeepLink(indexName: string, organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;\n}\n\nfunction datadogLogsIndexesConfigurationDeepLink(organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;\n}\n"]}

package/lib/datadogv2/datadog-lambda-instrumentation.d.ts

@@ -0,0 +1,72 @@
+import * as logs from 'aws-cdk-lib/aws-logs';
+import * as secrets from 'aws-cdk-lib/aws-secretsmanager';
+import { Construct } from 'constructs';
+import * as dd from 'datadog-cdk-constructs-v2';
+/**
+ * Props for the DatadogLambdaInstrumentation construct. Copied over from original Datadog construct.
+ *
+ * @see dd.DatadogProps
+ */
+export interface DatadogLambdaInstrumentationProps {
+    readonly service: string;
+    /**
+     * Whether to enable enhanced metrics for the Lambda functions.
+     *
+     * @defaultValue false
+    */
+    readonly enableEnhancedMetrics?: boolean;
+    readonly nodeLayerVersion?: number;
+    readonly extensionLayerVersion?: number;
+    readonly addLayers?: boolean;
+    readonly forwarderArn?: string;
+    readonly flushMetricsToLogs?: boolean;
+    readonly site?: string;
+    readonly apiKey?: string;
+    readonly apiKeySecretArn?: string;
+    readonly apiKeySecret?: secrets.ISecret;
+    readonly apiKmsKey?: string;
+    readonly enableDatadogTracing?: boolean;
+    readonly enableDatadogASM?: boolean;
+    readonly enableMergeXrayTraces?: boolean;
+    readonly injectLogContext?: boolean;
+    readonly logLevel?: string;
+    readonly enableDatadogLogs?: boolean;
+    readonly captureLambdaPayload?: boolean;
+    readonly env?: string;
+    readonly version?: string;
+    readonly tags?: string;
+    readonly createForwarderPermissions?: boolean;
+    readonly sourceCodeIntegration?: boolean;
+    readonly enableColdStartTracing?: boolean;
+    readonly minColdStartTraceDuration?: number;
+    readonly coldStartTraceSkipLibs?: string;
+    readonly enableProfiling?: boolean;
+    readonly encodeAuthorizerContext?: boolean;
+    readonly decodeAuthorizerContext?: boolean;
+    readonly apmFlushDeadline?: string | number;
+    readonly redirectHandler?: boolean;
+    readonly grantSecretReadAccess?: boolean;
+    readonly useLayersFromAccount?: string;
+}
+/**
+ * Wrapper construct for Datadog's Lambda instrumentation. This construct will create a Datadog construct with the provided props and add the Lambda functions to it.
+ * Per default, it will disable all additional features, that cause Datadog charging for Serverless Functions features. So just change it, if you need the advanced features.
+ *
+ * Additionally some defaults from the datadog-integration account module are applied:
+ * - the secret for the API key is read from the secret manager `/rio/config/datadog-integration/api-key`
+ * - the site is read from the parameter store `/rio/config/datadog-integration/site`
+ *
+ * To use it, install Datadog CDK Constructs package:
+ * ```bash
+ * npm i -D datadog-cdk-constructs-v2
+ * ```
+ */
+export declare class DatadogLambdaInstrumentation extends Construct {
+    private delegate;
+    private datadogSecret;
+    private enhancedMetricsEnabled;
+    constructor(scope: Construct, id: string, props: DatadogLambdaInstrumentationProps);
+    addLambdaFunctions(lambdaFunctions: dd.LambdaFunction[], construct?: Construct): void;
+    addGitCommitMetadata(lambdaFunctions: dd.LambdaFunction[], gitCommitSha?: string, gitRepoUrl?: string): void;
+    addForwarderToNonLambdaLogGroups(logGroups: logs.ILogGroup[]): void;
+}

package/lib/datadogv2/datadog-lambda-instrumentation.js

@@ -0,0 +1,82 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatadogLambdaInstrumentation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
+const constructs_1 = require("constructs");
+// eslint-disable-next-line import/no-extraneous-dependencies
+const dd = require("datadog-cdk-constructs-v2");
+/**
+ * Wrapper construct for Datadog's Lambda instrumentation. This construct will create a Datadog construct with the provided props and add the Lambda functions to it.
+ * Per default, it will disable all additional features, that cause Datadog charging for Serverless Functions features. So just change it, if you need the advanced features.
+ *
+ * Additionally some defaults from the datadog-integration account module are applied:
+ * - the secret for the API key is read from the secret manager `/rio/config/datadog-integration/api-key`
+ * - the site is read from the parameter store `/rio/config/datadog-integration/site`
+ *
+ * To use it, install Datadog CDK Constructs package:
+ * ```bash
+ * npm i -D datadog-cdk-constructs-v2
+ * ```
+ */
+class DatadogLambdaInstrumentation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { account, region } = aws_cdk_lib_1.Stack.of(scope);
+        this.datadogSecret = aws_secretsmanager_1.Secret.fromSecretPartialArn(this, 'DatadogApiKeySecret', `arn:aws:secretsmanager:${region}:${account}:secret:/rio/config/datadog-integration/api-key`);
+        const site = getOrCreateParameter(this, 'Site', '/rio/config/datadog-integration/site').stringValue;
+        const finalProps = {
+            env: 'prod',
+            apiKeySecretArn: this.datadogSecret.secretArn,
+            site,
+            enableDatadogLogs: true,
+            injectLogContext: true,
+            enableDatadogTracing: false,
+            enableColdStartTracing: false,
+            enableDatadogASM: false,
+            enableMergeXrayTraces: false,
+            enableProfiling: false,
+            sourceCodeIntegration: getSourceCodeIntegrationDefault(this.node),
+            ...props,
+        };
+        dd.validateProps(finalProps);
+        dd.checkForMultipleApiKeys(finalProps);
+        this.delegate = new dd.Datadog(this, 'Datadog', finalProps);
+        this.enhancedMetricsEnabled = props.enableEnhancedMetrics ?? false;
+    }
+    addLambdaFunctions(lambdaFunctions, construct) {
+        for (const lambdaFunction of lambdaFunctions) {
+            this.datadogSecret.grantRead(lambdaFunction);
+            lambdaFunction.addEnvironment('DD_ENHANCED_METRICS', `${this.enhancedMetricsEnabled}`);
+        }
+        this.delegate.addLambdaFunctions(lambdaFunctions, construct);
+    }
+    addGitCommitMetadata(lambdaFunctions, gitCommitSha, gitRepoUrl) {
+        this.delegate.addGitCommitMetadata(lambdaFunctions, gitCommitSha, gitRepoUrl);
+    }
+    addForwarderToNonLambdaLogGroups(logGroups) {
+        this.delegate.addForwarderToNonLambdaLogGroups(logGroups);
+    }
+}
+exports.DatadogLambdaInstrumentation = DatadogLambdaInstrumentation;
+_a = JSII_RTTI_SYMBOL_1;
+DatadogLambdaInstrumentation[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.datadogv2.DatadogLambdaInstrumentation", version: "0.0.0" };
+;
+/**
+ * @param node - The node to check for the context value
+ * @returns true as a default if not disabled via context
+ */
+const getSourceCodeIntegrationDefault = (node) => {
+    const value = node.tryGetContext('@rio-cloud/cdk-v2-constructs:enableSourceCodeIntegration');
+    const isDisabled = value === 'false' || value === false;
+    return !isDisabled;
+};
+const getOrCreateParameter = (scope, id, name) => {
+    const parameterId = `DatadogConfig${id}`;
+    const stack = aws_cdk_lib_1.Stack.of(scope);
+    return stack.node.tryFindChild(parameterId) || aws_ssm_1.StringParameter.fromStringParameterName(stack, parameterId, name);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-lambda-instrumentation.js","sourceRoot":"","sources":["../../src/datadogv2/datadog-lambda-instrumentation.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack } from 'aws-cdk-lib';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport { Secret, ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport * as secrets from 'aws-cdk-lib/aws-secretsmanager';\nimport { StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { Construct, Node } from 'constructs';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as dd from 'datadog-cdk-constructs-v2';\n\n/**\n * Props for the DatadogLambdaInstrumentation construct. Copied over from original Datadog construct.\n *\n * @see dd.DatadogProps\n */\n// this interface is intentionally not extending the original DatadogProps, to that the dependency needs to be bundled as well.\nexport interface DatadogLambdaInstrumentationProps {\n  readonly service: string;\n\n  /**\n   * Whether to enable enhanced metrics for the Lambda functions.\n   *\n   * @defaultValue false\n  */\n  readonly enableEnhancedMetrics?: boolean;\n  readonly nodeLayerVersion?: number;\n  readonly extensionLayerVersion?: number;\n  readonly addLayers?: boolean;\n  readonly forwarderArn?: string;\n  readonly flushMetricsToLogs?: boolean;\n  readonly site?: string;\n  readonly apiKey?: string;\n  readonly apiKeySecretArn?: string;\n  readonly apiKeySecret?: secrets.ISecret;\n  readonly apiKmsKey?: string;\n  readonly enableDatadogTracing?: boolean;\n  readonly enableDatadogASM?: boolean;\n  readonly enableMergeXrayTraces?: boolean;\n  readonly injectLogContext?: boolean;\n  readonly logLevel?: string;\n  readonly enableDatadogLogs?: boolean;\n  readonly captureLambdaPayload?: boolean;\n  readonly env?: string;\n  readonly version?: string;\n  readonly tags?: string;\n  readonly createForwarderPermissions?: boolean;\n  readonly sourceCodeIntegration?: boolean;\n  readonly enableColdStartTracing?: boolean;\n  readonly minColdStartTraceDuration?: number;\n  readonly coldStartTraceSkipLibs?: string;\n  readonly enableProfiling?: boolean;\n  readonly encodeAuthorizerContext?: boolean;\n  readonly decodeAuthorizerContext?: boolean;\n  readonly apmFlushDeadline?: string | number;\n  readonly redirectHandler?: boolean;\n  readonly grantSecretReadAccess?: boolean;\n  readonly useLayersFromAccount?: string;\n}\n\n/**\n * Wrapper construct for Datadog's Lambda instrumentation. This construct will create a Datadog construct with the provided props and add the Lambda functions to it.\n * Per default, it will disable all additional features, that cause Datadog charging for Serverless Functions features. So just change it, if you need the advanced features.\n *\n * Additionally some defaults from the datadog-integration account module are applied:\n * - the secret for the API key is read from the secret manager `/rio/config/datadog-integration/api-key`\n * - the site is read from the parameter store `/rio/config/datadog-integration/site`\n *\n * To use it, install Datadog CDK Constructs package:\n * ```bash\n * npm i -D datadog-cdk-constructs-v2\n * ```\n */\nexport class DatadogLambdaInstrumentation extends Construct {\n  private delegate: dd.Datadog;\n  private datadogSecret: ISecret;\n  private enhancedMetricsEnabled: boolean;\n  constructor(scope: Construct, id: string, props: DatadogLambdaInstrumentationProps) {\n    super(scope, id);\n\n    const { account, region } = Stack.of(scope);\n    this.datadogSecret = Secret.fromSecretPartialArn(\n      this,\n      'DatadogApiKeySecret',\n      `arn:aws:secretsmanager:${region}:${account}:secret:/rio/config/datadog-integration/api-key`,\n    );\n    const site = getOrCreateParameter(this, 'Site', '/rio/config/datadog-integration/site').stringValue;\n\n    const finalProps = {\n      env: 'prod',\n      apiKeySecretArn: this.datadogSecret.secretArn,\n      site,\n      enableDatadogLogs: true,\n      injectLogContext: true,\n      enableDatadogTracing: false,\n      enableColdStartTracing: false,\n      enableDatadogASM: false,\n      enableMergeXrayTraces: false,\n      enableProfiling: false,\n      sourceCodeIntegration: getSourceCodeIntegrationDefault(this.node),\n      ...props,\n    };\n\n    dd.validateProps(finalProps);\n    dd.checkForMultipleApiKeys(finalProps);\n\n    this.delegate = new dd.Datadog(this, 'Datadog', finalProps);\n    this.enhancedMetricsEnabled = props.enableEnhancedMetrics ?? false;\n  }\n\n  addLambdaFunctions(lambdaFunctions: dd.LambdaFunction[], construct?: Construct): void {\n    for (const lambdaFunction of lambdaFunctions) {\n      this.datadogSecret.grantRead(lambdaFunction);\n      lambdaFunction.addEnvironment('DD_ENHANCED_METRICS', `${this.enhancedMetricsEnabled}`);\n    }\n    this.delegate.addLambdaFunctions(lambdaFunctions, construct);\n  }\n  addGitCommitMetadata(lambdaFunctions: dd.LambdaFunction[], gitCommitSha?: string, gitRepoUrl?: string): void {\n    this.delegate.addGitCommitMetadata(lambdaFunctions, gitCommitSha, gitRepoUrl);\n  }\n  addForwarderToNonLambdaLogGroups(logGroups: logs.ILogGroup[]): void {\n    this.delegate.addForwarderToNonLambdaLogGroups(logGroups);\n  }\n};\n\n/**\n * @param node - The node to check for the context value\n * @returns true as a default if not disabled via context\n */\nconst getSourceCodeIntegrationDefault = (node: Node): boolean => {\n  const value = node.tryGetContext('@rio-cloud/cdk-v2-constructs:enableSourceCodeIntegration');\n\n  const isDisabled = value === 'false' || value === false;\n\n  return !isDisabled;\n};\n\nconst getOrCreateParameter = (scope: Construct, id: string, name: string) => {\n  const parameterId = `DatadogConfig${id}`;\n  const stack = Stack.of(scope);\n  return stack.node.tryFindChild(parameterId) as StringParameter || StringParameter.fromStringParameterName(stack, parameterId, name);\n};\n"]}

package/lib/datadogv2/datadog-log-index-monitoring.js

@@ -1,7 +1,8 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrganizationUrlPrefix = exports.DatadogLogIndexMonitoring = void 0;
+exports.DatadogLogIndexMonitoring = void 0;
+exports.getOrganizationUrlPrefix = getOrganizationUrlPrefix;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const constructs_1 = require("constructs");
 const datadog_monitor_1 = require("./datadog-monitor");
@@ -105,11 +106,10 @@ function getOrganizationUrlPrefix(organization) {
             return 'rio-landingzone';
     }
 }
-exports.getOrganizationUrlPrefix = getOrganizationUrlPrefix;
 function datadogLogsSearchWithIndexFilterDeepLink(indexName, organization) {
     return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;
 }
 function datadogLogsIndexesConfigurationDeepLink(organization) {
     return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-log-index-monitoring.js","sourceRoot":"","sources":["../../src/datadogv2/datadog-log-index-monitoring.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { DatadogMonitor, DatadogMonitorQueryAlertType } from './datadog-monitor';\nimport { INotification } from './datadog-notification';\n\nexport interface DatadogLogIndexMonitoringProps {\n\n  /**\n   * The name of your service in Datadog. Can be used to query the monitors.\n   */\n  readonly serviceName: string;\n\n  /**\n   * The name of the Datadog index.\n   */\n  readonly indexName: string;\n\n  /**\n   * The integration to use for alerting.\n   */\n  readonly notification?: INotification;\n\n  /**\n   * The daily log quota settings.\n   */\n  readonly dailyLogQuota: DatadogLogQuotaProps;\n\n  /**\n   * This value should be used if there is no log message within 24 hours or missing historical data.\n   * Without setting this value it will lead to an empty result and therefore trigger an alert.\n   * @defaultValue - false\n   */\n  readonly sparseLogging?: boolean;\n\n  /**\n   * The Datadog organization, e.g., 'EU' or 'LATAM'\n   * @defaultValue - 'EU'\n   */\n  readonly organization?: DatadogOrganization;\n}\n\nexport interface DatadogLogQuotaProps {\n  /**\n   * The daily log quota for the team-specific index in million events.\n   */\n  readonly valueInMillionEvents: number;\n\n  /**\n   * The warning threshold for the daily log quota monitor in percent.\n   */\n  readonly warningThresholdInPercent: number;\n\n  /**\n   * The alarm threshold for the daily log quota monitor in percent.\n   * The value must be between 0 and 100 and greater than or equal to the warning threshold.\n   */\n  readonly alertThresholdInPercent: number;\n}\n\n/**\n * Basic monitoring and alerting for a Datadog logs index.\n * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/\n * and consists of the following three monitors.\n *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.\n *   2. An anomaly monitor that detects log amount spikes.\n *   3. An event alert that fires when you hit the daily log quota.\n *\n * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.\n */\nexport class DatadogLogIndexMonitoring extends Construct {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id);\n\n    const logQuotaInEvents = Math.floor(props.dailyLogQuota.valueInMillionEvents * 1_000_000);\n    const warningThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.warningThresholdInPercent / 100));\n    const alertThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.alertThresholdInPercent / 100));\n\n    new DatadogMonitor(this, 'DatadogLogDailyQuotaMonitor', {\n      serviceName: props.serviceName,\n      monitorType: DatadogMonitorQueryAlertType.METRIC_ALERT,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log quota almost reached`,\n      notification: props.notification,\n      priority: 3,\n      query: `sum(last_1d):sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count() >= ${alertThreshold}`,\n      message: `Inspect your log volume at ${datadogLogsSearchWithIndexFilterDeepLink(\n        props.indexName, props.organization,\n      )} or adapt the log quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        thresholds: {\n          critical: alertThreshold,\n          warning: warningThreshold,\n        },\n        includeTags: false,\n        notifyNoData: !props.sparseLogging,\n        noDataTimeframe: 24 * 60, // 1 day\n      },\n    });\n\n    new DatadogMonitor(this, 'DatadogLogAlertAnomalyMonitor', {\n      serviceName: props.serviceName,\n      monitorType: DatadogMonitorQueryAlertType.METRIC_ALERT,\n      priority: 4,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log amount is rising to unexpected levels`,\n      query: `avg(last_4h):anomalies(sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count(), 'robust', 2, direction='above', alert_window='last_15m', interval=60, count_default_zero='true', seasonality='weekly', timezone='europe/berlin') >= 1`,\n      message: `Logs are getting out of control: ${datadogLogsSearchWithIndexFilterDeepLink(\n        props.indexName, props.organization,\n      )}`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        includeTags: false,\n        notifyNoData: !props.sparseLogging,\n        thresholdWindows: {\n          triggerWindow: 'last_15m',\n          recoveryWindow: 'last_15m',\n        },\n      },\n    });\n\n    new DatadogMonitor(this, 'DatadogLogDailyQuotaReachedMonitor', {\n      serviceName: props.serviceName,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log quota reached`,\n      notification: props.notification,\n      priority: 2,\n      monitorType: DatadogMonitorQueryAlertType.EVENT_V_2_ALERT,\n      query: `events(\"source:datadog datadog_index:${props.indexName} Daily quota reached\").rollup(\"count\").last(\"12h\") > 0`,\n      message: `The log quote for the index has been reached. If you do not increase the quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}, no new logs will be indexed until the quota is reset at 2:00pm UTC.`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        timeoutH: 24,\n        thresholds: {\n          critical: 0,\n        },\n      },\n    });\n\n    this.node.addValidation({\n      validate: (): string[] => {\n        const result = [];\n        if (props.dailyLogQuota.warningThresholdInPercent < 0 || props.dailyLogQuota.warningThresholdInPercent > 100) {\n          result.push('Invalid [warningThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < 0 || props.dailyLogQuota.alertThresholdInPercent > 100) {\n          result.push('Invalid [alertThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < props.dailyLogQuota.warningThresholdInPercent) {\n          result.push('Invalid [alertThresholdInPercent]: must be greater than or equal to [warningThresholdInPercent]');\n        }\n        return result;\n      },\n    });\n  }\n}\n\nconst commonMonitorNamePrefix = (indexName: string) => `'${indexName}' index`;\nconst commonTags = (indexName: string) => [`logIndex:${indexName}`];\n\nexport type DatadogOrganization = 'EU' | 'LATAM' | 'Landing Zone';\n\nexport function getOrganizationUrlPrefix(organization: DatadogOrganization | undefined): string {\n  switch (organization ?? 'EU') {\n    case 'EU':\n      return 'app';\n    case 'LATAM':\n      return 'rio-brazil';\n    case 'Landing Zone':\n      return 'rio-landingzone';\n  }\n}\n\nfunction datadogLogsSearchWithIndexFilterDeepLink(indexName: string, organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;\n}\n\nfunction datadogLogsIndexesConfigurationDeepLink(organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog-log-index-monitoring.js","sourceRoot":"","sources":["../../src/datadogv2/datadog-log-index-monitoring.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { DatadogMonitor, DatadogMonitorQueryAlertType } from './datadog-monitor';\nimport { INotification } from './datadog-notification';\n\nexport interface DatadogLogIndexMonitoringProps {\n\n  /**\n   * The name of your service in Datadog. Can be used to query the monitors.\n   */\n  readonly serviceName: string;\n\n  /**\n   * The name of the Datadog index.\n   */\n  readonly indexName: string;\n\n  /**\n   * The integration to use for alerting.\n   */\n  readonly notification?: INotification;\n\n  /**\n   * The daily log quota settings.\n   */\n  readonly dailyLogQuota: DatadogLogQuotaProps;\n\n  /**\n   * This value should be used if there is no log message within 24 hours or missing historical data.\n   * Without setting this value it will lead to an empty result and therefore trigger an alert.\n   * @defaultValue - false\n   */\n  readonly sparseLogging?: boolean;\n\n  /**\n   * The Datadog organization, e.g., 'EU' or 'LATAM'\n   * @defaultValue - 'EU'\n   */\n  readonly organization?: DatadogOrganization;\n}\n\nexport interface DatadogLogQuotaProps {\n  /**\n   * The daily log quota for the team-specific index in million events.\n   */\n  readonly valueInMillionEvents: number;\n\n  /**\n   * The warning threshold for the daily log quota monitor in percent.\n   */\n  readonly warningThresholdInPercent: number;\n\n  /**\n   * The alarm threshold for the daily log quota monitor in percent.\n   * The value must be between 0 and 100 and greater than or equal to the warning threshold.\n   */\n  readonly alertThresholdInPercent: number;\n}\n\n/**\n * Basic monitoring and alerting for a Datadog logs index.\n * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/\n * and consists of the following three monitors.\n *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.\n *   2. An anomaly monitor that detects log amount spikes.\n *   3. An event alert that fires when you hit the daily log quota.\n *\n * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.\n */\nexport class DatadogLogIndexMonitoring extends Construct {\n  constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps) {\n    super(scope, id);\n\n    const logQuotaInEvents = Math.floor(props.dailyLogQuota.valueInMillionEvents * 1_000_000);\n    const warningThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.warningThresholdInPercent / 100));\n    const alertThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.alertThresholdInPercent / 100));\n\n    new DatadogMonitor(this, 'DatadogLogDailyQuotaMonitor', {\n      serviceName: props.serviceName,\n      monitorType: DatadogMonitorQueryAlertType.METRIC_ALERT,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log quota almost reached`,\n      notification: props.notification,\n      priority: 3,\n      query: `sum(last_1d):sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count() >= ${alertThreshold}`,\n      message: `Inspect your log volume at ${datadogLogsSearchWithIndexFilterDeepLink(\n        props.indexName, props.organization,\n      )} or adapt the log quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        thresholds: {\n          critical: alertThreshold,\n          warning: warningThreshold,\n        },\n        includeTags: false,\n        notifyNoData: !props.sparseLogging,\n        noDataTimeframe: 24 * 60, // 1 day\n      },\n    });\n\n    new DatadogMonitor(this, 'DatadogLogAlertAnomalyMonitor', {\n      serviceName: props.serviceName,\n      monitorType: DatadogMonitorQueryAlertType.METRIC_ALERT,\n      priority: 4,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log amount is rising to unexpected levels`,\n      query: `avg(last_4h):anomalies(sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count(), 'robust', 2, direction='above', alert_window='last_15m', interval=60, count_default_zero='true', seasonality='weekly', timezone='europe/berlin') >= 1`,\n      message: `Logs are getting out of control: ${datadogLogsSearchWithIndexFilterDeepLink(\n        props.indexName, props.organization,\n      )}`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        includeTags: false,\n        notifyNoData: !props.sparseLogging,\n        thresholdWindows: {\n          triggerWindow: 'last_15m',\n          recoveryWindow: 'last_15m',\n        },\n      },\n    });\n\n    new DatadogMonitor(this, 'DatadogLogDailyQuotaReachedMonitor', {\n      serviceName: props.serviceName,\n      name: `${commonMonitorNamePrefix(props.indexName)}: Log quota reached`,\n      notification: props.notification,\n      priority: 2,\n      monitorType: DatadogMonitorQueryAlertType.EVENT_V_2_ALERT,\n      query: `events(\"source:datadog datadog_index:${props.indexName} Daily quota reached\").rollup(\"count\").last(\"12h\") > 0`,\n      message: `The log quote for the index has been reached. If you do not increase the quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}, no new logs will be indexed until the quota is reset at 2:00pm UTC.`,\n      extraTags: [...commonTags(props.indexName)],\n      optionOverrides: {\n        timeoutH: 24,\n        thresholds: {\n          critical: 0,\n        },\n      },\n    });\n\n    this.node.addValidation({\n      validate: (): string[] => {\n        const result = [];\n        if (props.dailyLogQuota.warningThresholdInPercent < 0 || props.dailyLogQuota.warningThresholdInPercent > 100) {\n          result.push('Invalid [warningThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < 0 || props.dailyLogQuota.alertThresholdInPercent > 100) {\n          result.push('Invalid [alertThresholdInPercent]: expecting a number between 0 and 100');\n        }\n        if (props.dailyLogQuota.alertThresholdInPercent < props.dailyLogQuota.warningThresholdInPercent) {\n          result.push('Invalid [alertThresholdInPercent]: must be greater than or equal to [warningThresholdInPercent]');\n        }\n        return result;\n      },\n    });\n  }\n}\n\nconst commonMonitorNamePrefix = (indexName: string) => `'${indexName}' index`;\nconst commonTags = (indexName: string) => [`logIndex:${indexName}`];\n\nexport type DatadogOrganization = 'EU' | 'LATAM' | 'Landing Zone';\n\nexport function getOrganizationUrlPrefix(organization: DatadogOrganization | undefined): string {\n  switch (organization ?? 'EU') {\n    case 'EU':\n      return 'app';\n    case 'LATAM':\n      return 'rio-brazil';\n    case 'Landing Zone':\n      return 'rio-landingzone';\n  }\n}\n\nfunction datadogLogsSearchWithIndexFilterDeepLink(indexName: string, organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs?index=${indexName}`;\n}\n\nfunction datadogLogsIndexesConfigurationDeepLink(organization: DatadogOrganization | undefined) {\n  return `https://${getOrganizationUrlPrefix(organization)}.datadoghq.eu/logs/pipelines/indexes`;\n}\n"]}

package/lib/datadogv2/index.d.ts

@@ -2,3 +2,4 @@ export * from './datadog-dashboard';
 export * from './datadog-log-index-monitoring';
 export * from './datadog-monitor';
 export * from './datadog-notification';
+export * from './datadog-lambda-instrumentation';

package/lib/datadogv2/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./datadog-dashboard"), exports);
 __exportStar(require("./datadog-log-index-monitoring"), exports);
 __exportStar(require("./datadog-monitor"), exports);
 __exportStar(require("./datadog-notification"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWRvZ3YyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBb0M7QUFDcEMsaUVBQStDO0FBQy9DLG9EQUFrQztBQUNsQyx5REFBdUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGFkb2ctZGFzaGJvYXJkJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YWRvZy1sb2ctaW5kZXgtbW9uaXRvcmluZyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGFkb2ctbW9uaXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2RhdGFkb2ctbm90aWZpY2F0aW9uJzsiXX0=
+__exportStar(require("./datadog-lambda-instrumentation"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWRvZ3YyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBb0M7QUFDcEMsaUVBQStDO0FBQy9DLG9EQUFrQztBQUNsQyx5REFBdUM7QUFDdkMsbUVBQWlEIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRhZG9nLWRhc2hib2FyZCc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGFkb2ctbG9nLWluZGV4LW1vbml0b3JpbmcnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhZG9nLW1vbml0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhZG9nLW5vdGlmaWNhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2RhdGFkb2ctbGFtYmRhLWluc3RydW1lbnRhdGlvbic7Il19

package/lib/fargate/datadog.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureLoggingAndMonitoringAreReadyBeforeServiceStarts = exports.setupLogging = exports.addFireLensLogRouter = exports.addFirelensConfigUploadFromS3Permissions = exports.addDatadogSidecar = exports.getFargateDockerLabels = exports.getFargateContainerEnvironmentVariables = exports.DataDog = void 0;
+exports.DataDog = void 0;
+exports.getFargateContainerEnvironmentVariables = getFargateContainerEnvironmentVariables;
+exports.getFargateDockerLabels = getFargateDockerLabels;
+exports.addDatadogSidecar = addDatadogSidecar;
+exports.addFirelensConfigUploadFromS3Permissions = addFirelensConfigUploadFromS3Permissions;
+exports.addFireLensLogRouter = addFireLensLogRouter;
+exports.setupLogging = setupLogging;
+exports.ensureLoggingAndMonitoringAreReadyBeforeServiceStarts = ensureLoggingAndMonitoringAreReadyBeforeServiceStarts;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const ecs = require("aws-cdk-lib/aws-ecs");
 const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
@@ -91,7 +98,6 @@ function getFargateContainerEnvironmentVariables(props) {
         DD_TRACE_SAMPLE_RATE: '1.0', // see https://ddtrace.readthedocs.io/en/stable/configuration.html
     };
 }
-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 = {
@@ -112,7 +118,6 @@ function getFargateDockerLabels(props) {
         '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', {
@@ -160,7 +165,6 @@ function addDatadogSidecar(props) {
     });
     return datadogSidecar;
 }
-exports.addDatadogSidecar = addDatadogSidecar;
 function addFirelensConfigUploadFromS3Permissions(props) {
     props.taskDefinition.addToTaskRolePolicy(new iam.PolicyStatement({
         resources: [props.firelensConfigBucketArn, `${props.firelensConfigBucketArn}/*`],
@@ -168,7 +172,6 @@ function addFirelensConfigUploadFromS3Permissions(props) {
         effect: iam.Effect.ALLOW,
     }));
 }
-exports.addFirelensConfigUploadFromS3Permissions = addFirelensConfigUploadFromS3Permissions;
 function getTagsEnvironmentVariableValue(props) {
     const separator = determineSeparator(props.containerType);
     const tags = {
@@ -216,12 +219,14 @@ function addFireLensLogRouter(props) {
             streamPrefix: 'firelens-log-router',
             mode: aws_ecs_1.AwsLogDriverMode.NON_BLOCKING,
         }),
+        healthCheck: {
+            command: ['CMD-SHELL', 'curl --fail --silent http://127.0.0.1:2020/api/v1/health || exit 1'],
+        },
         environment: {
             aws_fluent_bit_init_s3_1: fluentBitS3ConfigFile,
         },
     });
 }
-exports.addFireLensLogRouter = addFireLensLogRouter;
 function setupLogging(props) {
     let logGroupName;
     let logGroupId;
@@ -298,7 +303,6 @@ function setupLogging(props) {
             });
     }
 }
-exports.setupLogging = setupLogging;
 function ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService) {
     rioFargateService.serviceContainerDefinition.addContainerDependencies({
         container: rioFargateService.datadogSideCarContainerDefinition,
@@ -317,5 +321,4 @@ function ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService
         }
     }
 }
-exports.ensureLoggingAndMonitoringAreReadyBeforeServiceStarts = ensureLoggingAndMonitoringAreReadyBeforeServiceStarts;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog.js","sourceRoot":"","sources":["../../src/fargate/datadog.ts"],"names":[],"mappings":";;;AAAA,6CAA8D;AAC9D,2CAA2C;AAC3C,iDAAuD;AACvD,2CAA2C;AAC3C,iDAAiD;AACjD,6CAA6C;AAG7C,+DAA8E;AAE9E;;GAEG;AACH,MAAa,OAAO;IAEX,MAAM,CAAC,uCAAuC,CACnD,KAAgB,EAChB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,WAAmB,EACnB,QAAgB,EAChB,cAAsB,EACtB,cAAkD;QAElD,OAAO,uCAAuC,CAAC;YAC7C,KAAK;YACL,KAAK;YACL,WAAW;YACX,OAAO;YACP,WAAW;YACX,QAAQ;YACR,cAAc;YACd,cAAc;SACf,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,sBAAsB,CAAC,KAAa,EAAE,WAAmB,EAAE,OAAe;QACtF,OAAO,sBAAsB,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;IACjE,CAAC;IAEM,MAAM,CAAC,iBAAiB,CAC7B,KAAgB,EAChB,cAAkC,EAClC,WAAmB,EACnB,QAAgB,EAChB,cAAsB,EACtB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,sBAA4C,EAC5C,WAAmB,EACnB,kBAAsC,EACtC,uBAAiC,EACjC,GAAW,EACX,cAAsB,EACtB,SAAkB,EAClB,YAAoB,EACpB,cAAkD;QAGlD,OAAO,iBAAiB,CAAC;YACvB,KAAK;YACL,cAAc;YACd,WAAW;YACX,QAAQ;YACR,cAAc;YACd,KAAK;YACL,WAAW;YACX,OAAO;YACP,sBAAsB;YACtB,WAAW;YACX,kBAAkB;YAClB,uBAAuB;YACvB,GAAG;YACH,cAAc;YACd,SAAS;YACT,YAAY;YACZ,cAAc;SACf,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,oBAAoB,CAChC,cAAkC,EAClC,GAAW,EACX,cAAsB,EACtB,sBAA8B,EAC9B,uBAA+B,EAC/B,WAAmB;QAEnB,OAAO,oBAAoB,CAAC,EAAE,cAAc,EAAE,GAAG,EAAE,cAAc,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,EAAE,CAAC,CAAC;IACrI,CAAC;IAEM,MAAM,CAAC,YAAY,CACxB,KAAgB,EAChB,WAAmB,EACnB,QAAgB,EAChB,cAAsB,EACtB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,sBAA4C,EAC5C,kBAAsC,EACtC,WAAmB,EACnB,aAA4C,EAC5C,cAAkD;QAGlD,OAAO,YAAY,CAAC;YAClB,KAAK;YACL,WAAW;YACX,QAAQ;YACR,cAAc;YACd,KAAK;YACL,WAAW;YACX,OAAO;YACP,sBAAsB;YACtB,kBAAkB;YAClB,WAAW;YACX,aAAa;YACb,cAAc;SACf,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,qDAAqD,CAAC,iBAAoC;QACtG,qDAAqD,CAAC,iBAAiB,CAAC,CAAC;IAC3E,CAAC;CACF;AAlHD,0BAkHC;AAED,SAAgB,uCAAuC,CAAC,KASvD;IAEC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE7D,OAAO;QACL,2GAA2G;QAC3G,MAAM,EAAE,KAAK,CAAC,KAAK;QACnB,UAAU,EAAE,KAAK,CAAC,WAAW;QAC7B,UAAU,EAAE,KAAK,CAAC,OAAO;QACzB,oGAAoG;QACpG,iBAAiB,EAAE,MAAM;QACzB,kBAAkB,EAAE,4CAA4C,CAAC,KAAK,CAAC,WAAW,CAAC;QACnF,OAAO,EAAE,+BAA+B,CAAC;YACvC,GAAG,KAAK;YACR,aAAa,EAAE,SAAS;YACxB,SAAS;YACT,MAAM;SACP,CAAC;QACF,oBAAoB,EAAE,KAAK,EAAE,kEAAkE;KAChG,CAAC;AACJ,CAAC;AA7BD,0FA6BC;AAED,kHAAkH;AAClH,SAAS,4CAA4C,CAAC,WAAmB;IAEvE,MAAM,cAAc,GAAG;QACrB,UAAU,EAAE,GAAG,WAAW,SAAS;QACnC,cAAc,EAAE,GAAG,WAAW,UAAU;QACxC,OAAO,EAAE,GAAG,WAAW,QAAQ;QAC/B,OAAO,EAAE,GAAG,WAAW,SAAS;QAChC,OAAO,EAAE,GAAG,WAAW,QAAQ;KAChC,CAAC;IAEF,OAAO,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;SACxC,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED,SAAgB,sBAAsB,CAAC,KAA4D;IACjG,OAAO;QACL,wBAAwB,EAAE,KAAK,CAAC,KAAK;QACrC,4BAA4B,EAAE,KAAK,CAAC,WAAW;QAC/C,4BAA4B,EAAE,KAAK,CAAC,OAAO;KAC5C,CAAC;AACJ,CAAC;AAND,wDAMC;AAED,SAAgB,iBAAiB,CAAC,KAkBjC;IAEC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7D,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC,YAAY,CAAC,eAAe,EAAE;QACxE,KAAK,EAAE,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,gCAAgC,KAAK,CAAC,YAAY,EAAE,CAAC;QAC5F,OAAO,EAAE,YAAY,CAAC,EAAE,GAAG,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC;QACrE,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,WAAW,EAAE;YACX,2GAA2G;YAC3G,MAAM,EAAE,KAAK,CAAC,KAAK;YACnB,UAAU,EAAE,KAAK,CAAC,WAAW;YAC7B,UAAU,EAAE,KAAK,CAAC,OAAO;YACzB,6EAA6E;YAC7E,cAAc,EAAE,MAAM;YACtB,uBAAuB,EAAE,KAAK,CAAC,uBAAuB;iBACnD,GAAG,CAAC,CAAC,sBAAsB,EAAE,EAAE,CAAC,OAAO,sBAAsB,EAAE,CAAC;iBAChE,IAAI,CAAC,GAAG,CAAC;YACZ,mBAAmB;YACnB,OAAO,EAAE,KAAK,CAAC,WAAW;YAC1B,OAAO,EAAE,+BAA+B,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC;YAC3G,WAAW,EAAE,MAAM;YACnB,0BAA0B,EAAE,KAAK;YACjC,+BAA+B,EAAE,OAAO;SACzC;QACD,wGAAwG;QACxG,WAAW,EAAE;YACX,WAAW,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAChC,QAAQ,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9B,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC5B,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;SACpC;QACD,OAAO,EAAE;YACP,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,KAAK,CAAC,sBAAsB,CAAC;SACtE;QACD,SAAS,EAAE,KAAK,CAAC,SAAS;KAC3B,CAAC,CAAC;IAEH,cAAc,CAAC,eAAe,CAAC;QAC7B,aAAa,EAAE,IAAI;QACnB,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG;KAC3B,CAAC,CAAC;IAEH,cAAc,CAAC,eAAe,CAAC;QAC7B,aAAa,EAAE,IAAI;QACnB,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG;KAC3B,CAAC,CAAC;IAEH,OAAO,cAAc,CAAC;AACxB,CAAC;AApED,8CAoEC;AAED,SAAgB,wCAAwC,CAAC,KAGxD;IACC,KAAK,CAAC,cAAc,CAAC,mBAAmB,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC;QAC/D,SAAS,EAAE,CAAC,KAAK,CAAC,uBAAuB,EAAE,GAAG,KAAK,CAAC,uBAAuB,IAAI,CAAC;QAChF,OAAO,EAAE,CAAC,SAAS,CAAC;QACpB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK;KACzB,CAAC,CAAC,CAAC;AACN,CAAC;AATD,4FASC;AAED,SAAS,+BAA+B,CAAC,KAWxC;IAEC,MAAM,SAAS,GAAG,kBAAkB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IAE1D,MAAM,IAAI,GAAG;QACX,kBAAkB;QAClB,gEAAgE;QAChE,8FAA8F;QAC9F,GAAG,EAAE,KAAK,CAAC,KAAK;QAChB,OAAO,EAAE,KAAK,CAAC,WAAW;QAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,8BAA8B;QAC9B,UAAU,EAAE,KAAK,CAAC,SAAS;QAC3B,YAAY,EAAE,KAAK,CAAC,WAAW;QAC/B,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,IAAI,EAAE,KAAK,CAAC,QAAQ;QACpB,eAAe,EAAE,KAAK,CAAC,cAAc;KACtC,CAAC;IACF,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC;SACxD,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;SACxC,IAAI,CAAC,SAAS,CAAC,CAAC;AACrB,CAAC;AAED,SAAS,kBAAkB,CAAC,aAA2D;IACrF,IAAI,aAAa,KAAK,iBAAiB,EAAE,CAAC;QACxC,OAAO,GAAG,CAAC;IACb,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,CAAC;IACb,CAAC;AACH,CAAC;AAED,SAAgB,oBAAoB,CAAC,KAOpC;IACC,MAAM,qBAAqB,GAAG,KAAK,CAAC,uBAAuB,GAAG,KAAK,CAAC,sBAAsB,CAAC;IAC3F,OAAO,KAAK,CAAC,cAAc,CAAC,oBAAoB,CAAC,qBAAqB,EAAE;QACtE,KAAK,EAAE,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,iEAAiE,CAAC;QACzG,cAAc,EAAE;YACd,IAAI,EAAE,GAAG,CAAC,qBAAqB,CAAC,SAAS;YACzC,OAAO,EAAE;gBACP,oBAAoB,EAAE,IAAI;aAC3B;SACF;QACD,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,OAAO,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;YAC9B,QAAQ,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,EAAE,2BAA2B,EAAE;gBAC7E,YAAY,EAAE,GAAG,KAAK,CAAC,WAAW,sBAAsB;aACzD,CAAC;YACF,YAAY,EAAE,qBAAqB;YACnC,IAAI,EAAE,0BAAgB,CAAC,YAAY;SACpC,CAAC;QACF,WAAW,EAAE;YACX,wBAAwB,EAAE,qBAAqB;SAChD;KACF,CAAC,CAAC;AACL,CAAC;AA9BD,oDA8BC;AAED,SAAgB,YAAY,CAAC,KAa5B;IAEC,IAAI,YAAoB,CAAC;IACzB,IAAI,UAAkB,CAAC;IACvB,IAAI,sBAAsB,CAAC;IAE3B,QAAQ,KAAK,CAAC,aAAa,EAAE,CAAC;QAE5B,KAAK,SAAS;YACZ,UAAU,GAAG,oBAAoB,CAAC;YAClC,YAAY,GAAG,KAAK,CAAC,WAAW,CAAC;YACjC,sBAAsB,GAAG,SAAS,CAAC;YACnC,MAAM;QAER,KAAK,iBAAiB;YACpB,UAAU,GAAG,2BAA2B,CAAC;YACzC,YAAY,GAAG,GAAG,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YAC7D,sBAAsB,GAAG,gBAAgB,CAAC;YAC1C,MAAM;IACV,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE7D,QAAQ,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAEjC,KAAK,wCAAkB,CAAC,aAAa;YACnC,8LAA8L;YAC9L,+DAA+D;YAC/D,OAAO,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC;gBAC7B,kFAAkF;gBAClF,OAAO,EAAE;oBACP,IAAI,EAAE,SAAS;oBACf,KAAK,EAAE,GAAG;oBACV,IAAI,EAAE,oBAAoB,KAAK,CAAC,WAAW,EAAE;oBAC7C,GAAG,EAAE,IAAI;oBACT,MAAM,EAAE,KAAK,CAAC,sBAAsB,CAAC,WAAW;oBAChD,QAAQ,EAAE,MAAM;oBAChB,UAAU,EAAE,YAAY;oBACxB,SAAS,EAAE,aAAa;oBACxB,cAAc,EAAE,KAAK;oBACrB,OAAO,EAAE,+BAA+B,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC;oBACtG,QAAQ,EAAE,KAAK;iBAChB;aACF,CAAC,CAAC;QAEL,KAAK,wCAAkB,CAAC,gBAAgB,CAAC;QACzC,KAAK,wCAAkB,CAAC,wBAAwB;YAC9C,MAAM,2BAA2B,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC7E,YAAY;gBACZ,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;aACvC,CAAC,CAAC;YACH,kBAAI,CAAC,EAAE,CAAC,2BAA2B,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;YACvE,MAAM,+BAA+B,GAAG,KAAK,CAAC,kBAAkB,KAAK,wCAAkB,CAAC,wBAAwB,CAAC,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC,mDAAmD,CAAC;YAC1M,MAAM,qBAAqB,GAAG,gBAAE,CAAC,WAAW,CAAC,+BAA+B,CAAC,CAAC;YAC9E,MAAM,aAAa,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,EAAE,yBAAyB,sBAAsB,EAAE,EAAE;gBAC7G,MAAM,EAAE,uBAAuB;gBAC/B,YAAY,EAAE,qBAAqB;gBACnC,SAAS,EAAE,QAAQ,MAAM,gBAAgB;gBACzC,SAAS,EAAE,2BAA2B,CAAC,WAAW;aACnD,CAAC,CAAC;YACH,MAAM,qBAAqB,GAAG,IAAI,IAAI,CAAC,qBAAqB,CAC1D,KAAK,CAAC,KAAK,EACX,iCAAiC,sBAAsB,EAAE,EACzD;gBACE,cAAc,EAAE,qBAAqB;gBACrC,aAAa,EAAE,EAAE;gBACjB,YAAY,EAAE,2BAA2B,CAAC,YAAY;aACvD,CACF,CAAC;YACF,qBAAqB,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;YACnD,OAAO,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;gBAC5B,YAAY,EAAE,KAAK,CAAC,aAAa;gBACjC,QAAQ,EAAE,2BAA2B;gBACrC,IAAI,EAAE,GAAG,CAAC,gBAAgB,CAAC,YAAY;gBACvC,aAAa,EAAE,kBAAI,CAAC,SAAS,CAAC,EAAE,CAAC;aAClC,CAAC,CAAC;QAEL,KAAK,wCAAkB,CAAC,IAAI;YAC1B,MAAM,wBAAwB,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC1E,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;aACvC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;gBAC5B,YAAY,EAAE,KAAK,CAAC,aAAa;gBACjC,QAAQ,EAAE,wBAAwB;gBAClC,IAAI,EAAE,GAAG,CAAC,gBAAgB,CAAC,YAAY;gBACvC,aAAa,EAAE,kBAAI,CAAC,SAAS,CAAC,EAAE,CAAC;aAClC,CAAC,CAAC;IACP,CAAC;AACH,CAAC;AArGD,oCAqGC;AAED,SAAgB,qDAAqD,CAAC,iBAAoC;IAExG,iBAAiB,CAAC,0BAA0B,CAAC,wBAAwB,CAAC;QACpE,SAAS,EAAE,iBAAiB,CAAC,iCAAiC;QAC9D,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,OAAO;KACpD,CAAC,CAAC;IAEH,IAAI,iBAAiB,CAAC,4BAA4B,EAAE,CAAC;QACnD,iBAAiB,CAAC,0BAA0B,CAAC,wBAAwB,CAAC;YACpE,SAAS,EAAE,iBAAiB,CAAC,4BAA4B;YACzD,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,KAAK;SAClD,CAAC,CAAC;QAEH,IAAI,iBAAiB,CAAC,iCAAiC,CAAC,eAAe,EAAE,SAAS,KAAK,aAAa,EAAE,CAAC;YACrG,iBAAiB,CAAC,iCAAiC,CAAC,wBAAwB,CAAC;gBAC3E,SAAS,EAAE,iBAAiB,CAAC,4BAA4B;gBACzD,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,KAAK;aAClD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC;AApBD,sHAoBC","sourcesContent":["import { Duration, Fn, Size, Stack, Tags } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport { AwsLogDriverMode } from 'aws-cdk-lib/aws-ecs';\nimport * as iam from 'aws-cdk-lib/aws-iam';\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    firelensConfigFilePath: string,\n    firelensConfigBucketArn: string,\n    serviceName: string,\n  ): ecs.ContainerDefinition {\n    return addFireLensLogRouter({ taskDefinition, cpu, memoryLimitMiB, firelensConfigFilePath, firelensConfigBucketArn, serviceName });\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_CLOUD_PROVIDER_METADATA: 'aws',\n      DD_REMOTE_CONFIGURATION_ENABLED: '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\nexport function addFirelensConfigUploadFromS3Permissions(props: {\n  taskDefinition: ecs.TaskDefinition;\n  firelensConfigBucketArn: string;\n}) {\n  props.taskDefinition.addToTaskRolePolicy(new iam.PolicyStatement({\n    resources: [props.firelensConfigBucketArn, `${props.firelensConfigBucketArn}/*`],\n    actions: ['s3:Get*'],\n    effect: iam.Effect.ALLOW,\n  }));\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  firelensConfigBucketArn: string;\n  firelensConfigFilePath: string;\n  serviceName: string;\n}): ecs.ContainerDefinition {\n  const fluentBitS3ConfigFile = props.firelensConfigBucketArn + props.firelensConfigFilePath;\n  return props.taskDefinition.addFirelensLogRouter('firelens-log-router', {\n    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:init-latest'),\n    firelensConfig: {\n      type: ecs.FirelensLogRouterType.FLUENTBIT,\n      options: {\n        enableECSLogMetadata: true,\n      },\n    },\n    cpu: props.cpu,\n    memoryLimitMiB: props.memoryLimitMiB,\n    logging: ecs.LogDrivers.awsLogs({\n      logGroup: new logs.LogGroup(props.taskDefinition, 'FirelensLogRouterLogGroup', {\n        logGroupName: `${props.serviceName}-firelens-log-router`,\n      }),\n      streamPrefix: 'firelens-log-router',\n      mode: AwsLogDriverMode.NON_BLOCKING,\n    }),\n    environment: {\n      aws_fluent_bit_init_s3_1: fluentBitS3ConfigFile,\n    },\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    case DataDogLoggingMode.DATADOG_FORWARDER_LAMBDA:\n      const logGroupForForwardingLambda = new logs.LogGroup(props.scope, logGroupId, {\n        logGroupName,\n        retention: logs.RetentionDays.ONE_WEEK,\n      });\n      Tags.of(logGroupForForwardingLambda).add('service', props.serviceName);\n      const logForwarderLambdaArnOutputName = props.datadogLoggingMode === DataDogLoggingMode.DATADOG_FORWARDER_LAMBDA ? 'datadog-forwarder-ForwarderArn' : 'custom-resource-datadog-logforwarder-function-arn';\n      const logForwarderLambdaArn = Fn.importValue(logForwarderLambdaArnOutputName);\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.addDependency(cfnPermission);\n      return ecs.LogDrivers.awsLogs({\n        streamPrefix: props.containerType,\n        logGroup: logGroupForForwardingLambda,\n        mode: ecs.AwsLogDriverMode.NON_BLOCKING,\n        maxBufferSize: Size.mebibytes(25),\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        mode: ecs.AwsLogDriverMode.NON_BLOCKING,\n        maxBufferSize: Size.mebibytes(25),\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog.js","sourceRoot":"","sources":["../../src/fargate/datadog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, Fn, Size, Stack, Tags } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport { AwsLogDriverMode } from 'aws-cdk-lib/aws-ecs';\nimport * as iam from 'aws-cdk-lib/aws-iam';\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    firelensConfigFilePath: string,\n    firelensConfigBucketArn: string,\n    serviceName: string,\n  ): ecs.ContainerDefinition {\n    return addFireLensLogRouter({ taskDefinition, cpu, memoryLimitMiB, firelensConfigFilePath, firelensConfigBucketArn, serviceName });\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_CLOUD_PROVIDER_METADATA: 'aws',\n      DD_REMOTE_CONFIGURATION_ENABLED: '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\nexport function addFirelensConfigUploadFromS3Permissions(props: {\n  taskDefinition: ecs.TaskDefinition;\n  firelensConfigBucketArn: string;\n}) {\n  props.taskDefinition.addToTaskRolePolicy(new iam.PolicyStatement({\n    resources: [props.firelensConfigBucketArn, `${props.firelensConfigBucketArn}/*`],\n    actions: ['s3:Get*'],\n    effect: iam.Effect.ALLOW,\n  }));\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  firelensConfigBucketArn: string;\n  firelensConfigFilePath: string;\n  serviceName: string;\n}): ecs.ContainerDefinition {\n  const fluentBitS3ConfigFile = props.firelensConfigBucketArn + props.firelensConfigFilePath;\n  return props.taskDefinition.addFirelensLogRouter('firelens-log-router', {\n    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:init-latest'),\n    firelensConfig: {\n      type: ecs.FirelensLogRouterType.FLUENTBIT,\n      options: {\n        enableECSLogMetadata: true,\n      },\n    },\n    cpu: props.cpu,\n    memoryLimitMiB: props.memoryLimitMiB,\n    logging: ecs.LogDrivers.awsLogs({\n      logGroup: new logs.LogGroup(props.taskDefinition, 'FirelensLogRouterLogGroup', {\n        logGroupName: `${props.serviceName}-firelens-log-router`,\n      }),\n      streamPrefix: 'firelens-log-router',\n      mode: AwsLogDriverMode.NON_BLOCKING,\n    }),\n    healthCheck: {\n      command: ['CMD-SHELL', 'curl --fail --silent http://127.0.0.1:2020/api/v1/health || exit 1'],\n    },\n    environment: {\n      aws_fluent_bit_init_s3_1: fluentBitS3ConfigFile,\n    },\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    case DataDogLoggingMode.DATADOG_FORWARDER_LAMBDA:\n      const logGroupForForwardingLambda = new logs.LogGroup(props.scope, logGroupId, {\n        logGroupName,\n        retention: logs.RetentionDays.ONE_WEEK,\n      });\n      Tags.of(logGroupForForwardingLambda).add('service', props.serviceName);\n      const logForwarderLambdaArnOutputName = props.datadogLoggingMode === DataDogLoggingMode.DATADOG_FORWARDER_LAMBDA ? 'datadog-forwarder-ForwarderArn' : 'custom-resource-datadog-logforwarder-function-arn';\n      const logForwarderLambdaArn = Fn.importValue(logForwarderLambdaArnOutputName);\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.addDependency(cfnPermission);\n      return ecs.LogDrivers.awsLogs({\n        streamPrefix: props.containerType,\n        logGroup: logGroupForForwardingLambda,\n        mode: ecs.AwsLogDriverMode.NON_BLOCKING,\n        maxBufferSize: Size.mebibytes(25),\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        mode: ecs.AwsLogDriverMode.NON_BLOCKING,\n        maxBufferSize: Size.mebibytes(25),\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"]}

package/lib/kafka/kafka-topic.d.ts

@@ -58,6 +58,8 @@ export interface KafkaAclStatement {
      * Attention: Only use Deletion policy if you know what you are doing!
      * This is only necessary for KStream and allows the application to delete messages and the topic.<br>
      * If you just want to "delete" a message on a log compacted topic, you should not set this permission and send a tombstone message instead.
+     *
+     * @jsii ignore
      */
     readonly delete?: string[];
 }