@rio-cloud/cdk-v2-constructs 4.13.2 → 4.14.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [4.14.0](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/compare/commits?targetBranch=refs%2Ftags%2Fv4.13.1&sourceBranch=refs%2Ftags%2Fv4.14.0) (2023-07-20)
+
+
+### Features
+
+* added DatadogDashboard construct ([e87ca30](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/commits/e87ca3030ae8d9558832cd114aacc2460acefee6))
+* added RioPagingNotification ([d8e023d](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/commits/d8e023d1502697c4e0e055a517368630fd4aed66))
+* **watchfulv2,datadogv2:** ready to release ([c69ca6b](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/commits/c69ca6b7fea331eb18da1e6ea0db4c55da394e95))
+
+
+### Bug Fixes
+
+* :bug: Fixed issue related to wrong service name set in case of lambda functions ([2bfd814](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/commits/2bfd814e0108e2a2b6ef1680a0841368bf26a4ba))
+
 ### [4.13.2](https://collaboration.msi.audi.com/stash/projects/RIODEV/repos/cdk-v2-constructs/compare/commits?targetBranch=refs%2Ftags%2Fv4.13.1&sourceBranch=refs%2Ftags%2Fv4.13.2) (2023-07-06)
 
 

package/lib/datadog/datadog-log-index-monitoring.d.ts

@@ -21,12 +21,12 @@ export interface DatadogLogIndexMonitoringProps {
     /**
      * This value should be used if there is no log message within 24 hours or missing historical data.
      * Without setting this value it will lead to an empty result and therefore trigger an alert.
-     * @default - false
+     * @defaultValue - false
      */
     readonly sparseLogging?: boolean;
     /**
      * The Datadog organization, e.g., 'EU' or 'LATAM'
-     * @default - 'EU'
+     * @defaultValue - 'EU'
      */
     readonly organization?: DatadogOrganization;
 }

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

@@ -137,4 +137,4 @@ function datadogLogsSearchWithIndexFilterDeepLink(indexName, organization) {
 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 { 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   * @default - false\n   */\n  readonly sparseLogging?: boolean;\n\n  /**\n   * The Datadog organization, e.g., 'EU' or 'LATAM'\n   * @default - '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    new DatadogLogDailyQuotaMonitor(this, 'DatadogLogDailyQuotaMonitor', props);\n    new DatadogLogsAnomalyMonitor(this, 'DatadogLogAlertAnomalyMonitor', props);\n    new DatadogLogDailyQuotaReachedMonitor(this, 'DatadogLogDailyQuotaReachedV2Monitor', props);\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":";;;;;AAAA,2CAAuC;AACvC,uDAAqE;AAyDrE;;;;;;;;;GASG;AACH,MAAa,yBAA0B,SAAQ,sBAAS;IACtD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAqC;QAC7E,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,2BAA2B,CAAC,IAAI,EAAE,6BAA6B,EAAE,KAAK,CAAC,CAAC;QAC5E,IAAI,yBAAyB,CAAC,IAAI,EAAE,+BAA+B,EAAE,KAAK,CAAC,CAAC;QAC5E,IAAI,kCAAkC,CAAC,IAAI,EAAE,sCAAsC,EAAE,KAAK,CAAC,CAAC;QAE5F,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;YACtB,QAAQ,EAAE,GAAa,EAAE;gBACvB,MAAM,MAAM,GAAG,EAAE,CAAC;gBAClB,IAAI,KAAK,CAAC,aAAa,CAAC,yBAAyB,GAAG,CAAC,IAAI,KAAK,CAAC,aAAa,CAAC,yBAAyB,GAAG,GAAG,EAAE;oBAC5G,MAAM,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;iBAC1F;gBACD,IAAI,KAAK,CAAC,aAAa,CAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,CAAC,aAAa,CAAC,uBAAuB,GAAG,GAAG,EAAE;oBACxG,MAAM,CAAC,IAAI,CAAC,yEAAyE,CAAC,CAAC;iBACxF;gBACD,IAAI,KAAK,CAAC,aAAa,CAAC,uBAAuB,GAAG,KAAK,CAAC,aAAa,CAAC,yBAAyB,EAAE;oBAC/F,MAAM,CAAC,IAAI,CAAC,iGAAiG,CAAC,CAAC;iBAChH;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;;AAvBH,8DAwBC;;;AAED,MAAM,uBAAuB,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,IAAI,SAAS,SAAS,CAAC;AAC9E,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,CAAC,YAAY,SAAS,EAAE,CAAC,CAAC;AAEpE,MAAM,2BAA4B,SAAQ,gCAAc;IACtD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAqC;QAC7E,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,oBAAoB,GAAG,OAAS,CAAC,CAAC;QAC1F,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,yBAAyB,GAAG,GAAG,CAAC,CAAC,CAAC;QAC9G,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,uBAAuB,GAAG,GAAG,CAAC,CAAC,CAAC;QAE1G,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,UAAU,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;YAC7B,OAAO,EAAE;gBACP,IAAI,EAAE,GAAG,uBAAuB,CAAC,KAAK,CAAC,SAAS,CAAC,4BAA4B;gBAC7E,IAAI,EAAE,cAAc;gBACpB,KAAK,EAAE,yGAAyG,KAAK,CAAC,SAAS,mBAAmB,cAAc,EAAE;gBAClK,OAAO,EAAE,mCAAmC,wCAAwC,CAClF,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,CACpC,8BAA8B,uCAAuC,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE;gBAC5F,OAAO,EAAE;oBACP,UAAU,EAAE;wBACV,QAAQ,EAAE,cAAc;wBACxB,OAAO,EAAE,gBAAgB;qBAC1B;oBACD,YAAY,EAAE,KAAK;oBACnB,cAAc,EAAE,CAAC,KAAK,CAAC,aAAa;oBACpC,iBAAiB,EAAE,EAAE,GAAG,EAAE;iBAC3B;gBACD,IAAI,EAAE;oBACJ,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;iBAC/B;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,yBAA0B,SAAQ,gCAAc;IACpD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAqC;QAC7E,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,UAAU,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;YAC7B,OAAO,EAAE;gBACP,IAAI,EAAE,GAAG,uBAAuB,CAAC,KAAK,CAAC,SAAS,CAAC,6CAA6C;gBAC9F,IAAI,EAAE,cAAc;gBACpB,KAAK,EAAE,mHAAmH,KAAK,CAAC,SAAS,qKAAqK;gBAC9S,OAAO,EAAE,yCAAyC,wCAAwC,CACxF,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,CACpC,EAAE;gBACH,OAAO,EAAE;oBACP,YAAY,EAAE,KAAK;oBACnB,cAAc,EAAE,CAAC,KAAK,CAAC,aAAa;oBACpC,iBAAiB,EAAE;wBACjB,cAAc,EAAE,UAAU;wBAC1B,eAAe,EAAE,UAAU;qBAC5B;iBACF;gBACD,IAAI,EAAE;oBACJ,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;iBAC/B;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,kCAAmC,SAAQ,gCAAc;IAC7D,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAqC;QAC7E,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,UAAU,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;YAC7B,OAAO,EAAE;gBACP,IAAI,EAAE,GAAG,uBAAuB,CAAC,KAAK,CAAC,SAAS,CAAC,qBAAqB;gBACtE,IAAI,EAAE,gBAAgB;gBACtB,KAAK,EAAE,wCAAwC,KAAK,CAAC,SAAS,wDAAwD;gBACtH,OAAO,EAAE,0FAA0F,uCAAuC,CAAC,KAAK,CAAC,YAAY,CAAC,uEAAuE;gBACrO,OAAO,EAAE;oBACP,SAAS,EAAE,EAAE;oBACb,UAAU,EAAE;wBACV,QAAQ,EAAE,CAAC;qBACZ;iBACF;gBACD,IAAI,EAAE;oBACJ,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;iBAC/B;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AAID,SAAgB,wBAAwB,CAAC,YAA6C;IACpF,QAAQ,YAAY,IAAI,IAAI,EAAE;QAC5B,KAAK,IAAI;YACP,OAAO,KAAK,CAAC;QACf,KAAK,OAAO;YACV,OAAO,YAAY,CAAC;QACtB,KAAK,cAAc;YACjB,OAAO,iBAAiB,CAAC;KAC5B;AACH,CAAC;AATD,4DASC;AAED,SAAS,wCAAwC,CAAC,SAAiB,EAAE,YAA6C;IAChH,OAAO,WAAW,wBAAwB,CAAC,YAAY,CAAC,4BAA4B,SAAS,EAAE,CAAC;AAClG,CAAC;AAED,SAAS,uCAAuC,CAAC,YAA6C;IAC5F,OAAO,WAAW,wBAAwB,CAAC,YAAY,CAAC,sCAAsC,CAAC;AACjG,CAAC","sourcesContent":["import { 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 */\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\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-dashboard.d.ts

@@ -0,0 +1,28 @@
+import { Construct } from 'constructs';
+export interface DatadogDashboardProps {
+    /**
+     * The Dashboard definition as exported from Datadog:
+     * ```ts
+     * import dashboardDefinition from './dashboard.json';
+     *
+     * new DatadogDashboard(this, 'SampleDashboard', { dashboardDefinition })
+     * ```
+     *
+     * References to {@link [DatadogMonitor](./datadog-monitor.ts)} will not be resolved at the moment.
+     *
+     * @alpha
+     */
+    readonly dashboardDefinition: object;
+}
+/**
+ * Wrapper around Datadog's CloudFormation `Datadog::Monitors::Dashboard` with some RIO defaults applied.
+ *
+ * To use this the Datadog resources have to be {@link https://docs.datadoghq.com/integrations/guide/amazon_cloudformation/
+ * |enabled in the CloudFormation registry} of the corresponding AWS account. Usually this is done
+ * automatically by the Datadog Integrations (account module AND ServiceCatalog) provided by CLAID.
+ *
+ * @alpha
+ */
+export declare class DatadogDashboard extends Construct {
+    constructor(scope: Construct, id: string, props: DatadogDashboardProps);
+}

package/lib/datadogv2/datadog-dashboard.js

@@ -0,0 +1,31 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatadogDashboard = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+/**
+ * Wrapper around Datadog's CloudFormation `Datadog::Monitors::Dashboard` with some RIO defaults applied.
+ *
+ * To use this the Datadog resources have to be {@link https://docs.datadoghq.com/integrations/guide/amazon_cloudformation/
+ * |enabled in the CloudFormation registry} of the corresponding AWS account. Usually this is done
+ * automatically by the Datadog Integrations (account module AND ServiceCatalog) provided by CLAID.
+ *
+ * @alpha
+ */
+class DatadogDashboard extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        new cdk.CfnResource(scope, id + 'Dashboard', {
+            type: 'Datadog::Dashboards::Dashboard',
+            properties: {
+                DashboardDefinition: JSON.stringify(props.dashboardDefinition),
+            },
+        });
+    }
+}
+exports.DatadogDashboard = DatadogDashboard;
+_a = JSII_RTTI_SYMBOL_1;
+DatadogDashboard[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.datadogv2.DatadogDashboard", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/datadogv2/datadog-log-index-monitoring.d.ts

@@ -0,0 +1,61 @@
+import { Construct } from 'constructs';
+import { INotification } from './datadog-notification';
+export interface DatadogLogIndexMonitoringProps {
+    /**
+     * The name of your service in Datadog. Can be used to query the monitors.
+     */
+    readonly serviceName: string;
+    /**
+     * The name of the Datadog index.
+     */
+    readonly indexName: string;
+    /**
+     * The integration to use for alerting.
+     */
+    readonly notification?: INotification;
+    /**
+     * The daily log quota settings.
+     */
+    readonly dailyLogQuota: DatadogLogQuotaProps;
+    /**
+     * This value should be used if there is no log message within 24 hours or missing historical data.
+     * Without setting this value it will lead to an empty result and therefore trigger an alert.
+     * @defaultValue - false
+     */
+    readonly sparseLogging?: boolean;
+    /**
+     * The Datadog organization, e.g., 'EU' or 'LATAM'
+     * @defaultValue - 'EU'
+     */
+    readonly organization?: DatadogOrganization;
+}
+export interface DatadogLogQuotaProps {
+    /**
+     * The daily log quota for the team-specific index in million events.
+     */
+    readonly valueInMillionEvents: number;
+    /**
+     * The warning threshold for the daily log quota monitor in percent.
+     */
+    readonly warningThresholdInPercent: number;
+    /**
+     * The alarm threshold for the daily log quota monitor in percent.
+     * The value must be between 0 and 100 and greater than or equal to the warning threshold.
+     */
+    readonly alertThresholdInPercent: number;
+}
+/**
+ * Basic monitoring and alerting for a Datadog logs index.
+ * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/
+ * and consists of the following three monitors.
+ *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.
+ *   2. An anomaly monitor that detects log amount spikes.
+ *   3. An event alert that fires when you hit the daily log quota.
+ *
+ * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.
+ */
+export declare class DatadogLogIndexMonitoring extends Construct {
+    constructor(scope: Construct, id: string, props: DatadogLogIndexMonitoringProps);
+}
+export declare type DatadogOrganization = 'EU' | 'LATAM' | 'Landing Zone';
+export declare function getOrganizationUrlPrefix(organization: DatadogOrganization | undefined): string;

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

@@ -0,0 +1,115 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrganizationUrlPrefix = exports.DatadogLogIndexMonitoring = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constructs_1 = require("constructs");
+const datadog_monitor_1 = require("./datadog-monitor");
+/**
+ * Basic monitoring and alerting for a Datadog logs index.
+ * It follows the Datadog guide at https://docs.datadoghq.com/logs/guide/logs-monitors-on-volumes/
+ * and consists of the following three monitors.
+ *   1. A metric alert that fires when you reach a certain threshold of your daily log quota.
+ *   2. An anomaly monitor that detects log amount spikes.
+ *   3. An event alert that fires when you hit the daily log quota.
+ *
+ * A datadog log index is team specific and thus the monitor needs to be deployed just once per index/team.
+ */
+class DatadogLogIndexMonitoring extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const logQuotaInEvents = Math.floor(props.dailyLogQuota.valueInMillionEvents * 1000000);
+        const warningThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.warningThresholdInPercent / 100));
+        const alertThreshold = Math.floor(logQuotaInEvents * (props.dailyLogQuota.alertThresholdInPercent / 100));
+        new datadog_monitor_1.DatadogMonitor(this, 'DatadogLogDailyQuotaMonitor', {
+            serviceName: props.serviceName,
+            monitorType: datadog_monitor_1.DatadogMonitorQueryAlertType.METRIC_ALERT,
+            name: `${commonMonitorNamePrefix(props.indexName)}: Log quota almost reached`,
+            notification: props.notification,
+            priority: 3,
+            query: `sum(last_1d):sum:datadog.estimated_usage.logs.ingested_events{datadog_is_excluded:false,datadog_index:${props.indexName}}.as_count() >= ${alertThreshold}`,
+            message: `Inspect your log volume at ${datadogLogsSearchWithIndexFilterDeepLink(props.indexName, props.organization)} or adapt the log quota at ${datadogLogsIndexesConfigurationDeepLink(props.organization)}`,
+            extraTags: [...commonTags(props.indexName)],
+            optionOverrides: {
+                thresholds: {
+                    critical: alertThreshold,
+                    warning: warningThreshold,
+                },
+                includeTags: false,
+                notifyNoData: !props.sparseLogging,
+                noDataTimeframe: 24 * 60,
+            },
+        });
+        new datadog_monitor_1.DatadogMonitor(this, 'DatadogLogAlertAnomalyMonitor', {
+            serviceName: props.serviceName,
+            monitorType: datadog_monitor_1.DatadogMonitorQueryAlertType.METRIC_ALERT,
+            priority: 4,
+            name: `${commonMonitorNamePrefix(props.indexName)}: Log amount is rising to unexpected levels`,
+            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`,
+            message: `Logs are getting out of control: ${datadogLogsSearchWithIndexFilterDeepLink(props.indexName, props.organization)}`,
+            extraTags: [...commonTags(props.indexName)],
+            optionOverrides: {
+                includeTags: false,
+                notifyNoData: !props.sparseLogging,
+                thresholdWindows: {
+                    triggerWindow: 'last_15m',
+                    recoveryWindow: 'last_15m',
+                },
+            },
+        });
+        new datadog_monitor_1.DatadogMonitor(this, 'DatadogLogDailyQuotaReachedMonitor', {
+            serviceName: props.serviceName,
+            name: `${commonMonitorNamePrefix(props.indexName)}: Log quota reached`,
+            notification: props.notification,
+            priority: 2,
+            monitorType: datadog_monitor_1.DatadogMonitorQueryAlertType.EVENT_V_2_ALERT,
+            query: `events("source:datadog datadog_index:${props.indexName} Daily quota reached").rollup("count").last("12h") > 0`,
+            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.`,
+            extraTags: [...commonTags(props.indexName)],
+            optionOverrides: {
+                timeoutH: 24,
+                thresholds: {
+                    critical: 0,
+                },
+            },
+        });
+        this.node.addValidation({
+            validate: () => {
+                const result = [];
+                if (props.dailyLogQuota.warningThresholdInPercent < 0 || props.dailyLogQuota.warningThresholdInPercent > 100) {
+                    result.push('Invalid [warningThresholdInPercent]: expecting a number between 0 and 100');
+                }
+                if (props.dailyLogQuota.alertThresholdInPercent < 0 || props.dailyLogQuota.alertThresholdInPercent > 100) {
+                    result.push('Invalid [alertThresholdInPercent]: expecting a number between 0 and 100');
+                }
+                if (props.dailyLogQuota.alertThresholdInPercent < props.dailyLogQuota.warningThresholdInPercent) {
+                    result.push('Invalid [alertThresholdInPercent]: must be greater than or equal to [warningThresholdInPercent]');
+                }
+                return result;
+            },
+        });
+    }
+}
+exports.DatadogLogIndexMonitoring = DatadogLogIndexMonitoring;
+_a = JSII_RTTI_SYMBOL_1;
+DatadogLogIndexMonitoring[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.datadogv2.DatadogLogIndexMonitoring", version: "0.0.0" };
+const commonMonitorNamePrefix = (indexName) => `'${indexName}' index`;
+const commonTags = (indexName) => [`logIndex:${indexName}`];
+function getOrganizationUrlPrefix(organization) {
+    switch (organization ?? 'EU') {
+        case 'EU':
+            return 'app';
+        case 'LATAM':
+            return 'rio-brazil';
+        case 'Landing Zone':
+            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"]}

package/lib/datadogv2/datadog-monitor.d.ts

@@ -0,0 +1,234 @@
+import { Construct } from 'constructs';
+import { INotification } from './datadog-notification';
+/**
+ * Well known monitor types supported by Datadog.
+ *
+ * @see https://docs.datadoghq.com/monitors/types/
+ */
+export declare enum DatadogMonitorQueryAlertType {
+    AUDIT_ALERT = "audit alert",
+    COMPOSITE = "composite",
+    EVENT_ALERT = "event alert",
+    EVENT_V_2_ALERT = "event-v2 alert",
+    LOG_ALERT = "log alert",
+    METRIC_ALERT = "metric alert",
+    PROCESS_ALERT = "process alert",
+    QUERY_ALERT = "query alert",
+    SERVICE_CHECK = "service check",
+    SYNTHETICS_ALERT = "synthetics alert",
+    TRACE_ANALYTICS_ALERT = "trace-analytics alert",
+    SLO_ALERT = "slo alert",
+    RUM_ALERT = "rum alert",
+    CI_PIPELINES_ALERT = "ci-pipelines alert",
+    ERROR_TRACKING_ALERT = "error-tracking alert",
+    CI_TESTS_ALERT = "ci-tests alert"
+}
+/**
+ * Properties of {@link DatadogMonitor}
+ */
+export interface DatadogMonitorProps {
+    /**
+     * A name suffix to be appended to the monitors name.
+     *
+     * The monitor name is concatenated form `<TeamName> <serviceName property> <name property>`
+     */
+    readonly name: string;
+    /**
+     * The name of the service to which the monitor belongs.
+     *
+     * Used to generate the monitor name as well a apply the `service` tag.
+     */
+    readonly serviceName: string;
+    /**
+     * The monitors type
+     *
+     * @see https://docs.datadoghq.com/monitors/types/
+     */
+    readonly monitorType: DatadogMonitorQueryAlertType;
+    /**
+     * The monitors search query
+     *
+     * @see https://docs.datadoghq.com/monitors/configuration/#define-the-search-query
+     */
+    readonly query: string;
+    /**
+     * The message pattern for the monitor
+     *
+     * @see https://docs.datadoghq.com/monitors/configuration/#message
+     */
+    readonly message: string;
+    /**
+     * To explicitly disable notifications use {@link NoNotification}.
+     *
+     * @defaultValue {@link DefaultSlackNotification}
+     *
+     * @see https://docs.datadoghq.com/monitors/notify
+     */
+    readonly notification?: INotification;
+    /**
+     * The alert priority of the monitor
+     *
+     * @defaultValue 4
+     */
+    readonly priority?: number;
+    /**
+     * Specific options to override the default monitor options.
+     */
+    readonly optionOverrides?: CfnDatadogMonitorOptions;
+    /**
+     * Tags to be appended to the monitor in addition to the RIO default tags
+     */
+    readonly extraTags?: string[];
+}
+/**
+ * Well known renotification settings supported by Datadog.
+ *
+ * @see https://docs.datadoghq.com/monitors/notify/#renotify
+ */
+export declare enum RenotifyStatuses {
+    ALERT = "alert",
+    NO_DATA = "no data",
+    WARN = "warn"
+}
+/**
+ * Options to override for Datadog monitors in case more specific settings are required.
+ *
+ * {@link https://github.com/DataDog/datadog-cloudformation-resources/blob/master/datadog-monitors-monitor-handler/datadog-monitors-monitor.json}
+ */
+export interface CfnDatadogMonitorOptions {
+    /**
+     * Whether or not to include a sample of the logs
+     */
+    readonly enableLogsSample?: boolean;
+    /**
+     * Message to include with a re-notification when renotify_interval is set
+     */
+    readonly escalationMessage?: string;
+    /**
+     * Time in seconds to delay evaluation
+     *
+     * @defaultValue 900
+     */
+    readonly evaluationDelay?: number;
+    /**
+     * Whether or not to include triggering tags into notification title'
+     *
+     * @defaultValue true
+     */
+    readonly includeTags?: boolean;
+    /**
+     * Whether or not changes to this monitor should be restricted to the creator or admins
+     */
+    readonly locked?: boolean;
+    /**
+     * Number of locations allowed to fail before triggering alert
+     */
+    readonly minLocationFailed?: number;
+    /**
+     * Time in seconds to allow a host to start reporting data before starting the evaluation of monitor results
+     */
+    readonly newHostDelay?: number;
+    /**
+     * Number of minutes data stopped reporting before notifying
+     */
+    readonly noDataTimeframe?: number;
+    /**
+     * Whether or not to notify tagged users when changes are made to the monitor
+     */
+    readonly notifyAudit?: boolean;
+    /**
+     * Whether or not to notify when data stops reporting
+     *
+     * @defaultValue false
+     */
+    readonly notifyNoData?: boolean;
+    /**
+     * Number of minutes after the last notification before the monitor re-notifies on the current status
+     */
+    readonly renotifyInterval?: number;
+    /**
+     * Whether or not the monitor requires a full window of data before it is evaluated
+     *
+     * @defaultValue false
+     */
+    readonly requireFullWindow?: boolean;
+    /**
+     * ID of the corresponding synthetics check
+     */
+    readonly syntheticsCheckID?: number;
+    readonly thresholds?: CfnDatadogMonitorThresholds;
+    readonly thresholdWindows?: CfnDatadogMonitorThresholdWindows;
+    /**
+     * Number of hours of the monitor not reporting data before it automatically resolves
+     */
+    readonly timeoutH?: number;
+    /**
+     * The number of times re-notification messages should be sent on the current status at the provided re-notification interval.
+     */
+    readonly renotifyOccurrences?: number;
+    /**
+     * The types of monitor statuses for which re-notification messages are sent.
+     */
+    readonly renotifyStatuses?: RenotifyStatuses;
+    /**
+     * How long the test should be in failure before alerting (integer, number of seconds, max 7200).
+     */
+    readonly minFailureDuration?: number;
+    /**
+     * Time (in seconds) to skip evaluations for new groups. For example, this option can be used to skip evaluations for new hosts while they initialize. Must be a non negative integer.
+     */
+    readonly newGroupDelay?: number;
+    /**
+     * List of requests that can be used in the monitor query.
+     */
+    readonly variables?: object[];
+}
+export interface CfnDatadogMonitorThresholds {
+    /**
+     *Threshold value for triggering an alert
+     */
+    readonly critical?: number;
+    /**
+     *Threshold value for recovering from an alert state
+     */
+    readonly criticalRecovery?: number;
+    /**
+     *Threshold value for recovering from an alert state
+     */
+    readonly ok?: number;
+    /**
+     *Threshold value for triggering a warning
+     */
+    readonly warning?: number;
+    /**
+     * Threshold value for recovering from a warning state
+     */
+    readonly warningRecovery?: number;
+}
+export interface CfnDatadogMonitorThresholdWindows {
+    /**
+     * How long a metric must be anomalous before triggering an alert
+     */
+    readonly triggerWindow?: string;
+    /**
+     * How long an anomalous metric must be normal before recovering from an alert state
+     */
+    readonly recoveryWindow?: string;
+}
+/**
+ * Wrapper around Datadog's CloudFormation `Datadog::Monitors::Monitor` with some RIO defaults applied.
+ *
+ * To use this the Datadog resources have to be {@link https://docs.datadoghq.com/integrations/guide/amazon_cloudformation/
+ * |enabled in the CloudFormation registry} of the corresponding AWS account. Usually this is done
+ * automatically by the Datadog Integrations (account module AND ServiceCatalog) provided by CLAID.
+ */
+export declare class DatadogMonitor extends Construct {
+    /**
+     * Default priority of a monitor
+     */
+    static readonly DEFAULT_PRIORITY = 4;
+    readonly name: string;
+    readonly priority: number;
+    constructor(scope: Construct, id: string, props: DatadogMonitorProps);
+    private concatenateMessage;
+}