@microsoft/terraform-cdk-constructs 0.0.3-pre.10

package/lib/azure-queryrulealert/lib/query-rule-alert.d.ts

@@ -0,0 +1,175 @@
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { Construct } from "constructs";
+export interface BaseAzureQueryRuleAlertProps {
+    /**
+     * The name of the Monitor Scheduled Query Rule.
+     */
+    readonly name: string;
+    /**
+     * The name of the resource group in which the Monitor Scheduled Query Rule is created.
+     */
+    readonly resourceGroup: ResourceGroup;
+    /**
+     * The location of the Monitor Scheduled Query Rule.
+     */
+    readonly location: string;
+    /**
+     * Specifies the criteria operator.
+     * Possible values are Equal, GreaterThan, GreaterThanOrEqual, LessThan,and LessThanOrEqual.
+     */
+    readonly criteriaOperator: string;
+    /**
+     * The query to run on logs. The results returned by this query are used to populate the alert.
+     */
+    readonly criteriaQuery: string;
+    /**
+     * Specifies the criteria threshold value that activates the alert.
+     */
+    readonly criteriaThreshold: number;
+    /**
+     * The type of aggregation to apply to the data points in aggregation granularity.
+     * Possible values are Average, Count, Maximum, Minimum,and Total.
+     */
+    readonly criteriatimeAggregationMethod: string;
+    /**
+     * Name of the dimension for criteria.
+     */
+    readonly criteriaDimensionName?: string;
+    /**
+     * Operator for dimension values. Possible values are Exclude, and Include.
+     */
+    readonly criteriaDimensionOperator?: string;
+    /**
+     * List of dimension values. Use a wildcard * to collect all.
+     */
+    readonly criteriaDimensionValues?: string[];
+    /**
+     * Specifies the number of violations to trigger an alert.
+     * Should be smaller or equal to number_of_evaluation_periods.
+     * Possible value is integer between 1 and 6.
+     */
+    readonly criteriaFailMinimumFailingPeriodsToTriggerAlert?: number;
+    /**
+     * Specifies the number of evaluation periods.
+     * Possible value is integer between 1 and 6.
+     */
+    readonly criteriaFailNumberOfEvaluationPeriods?: number;
+    /**
+     * Specifies the column containing the metric measure number.
+     * criteriaMetricMeasureColumn is required if criteriatimeAggregationMethod is Average, Maximum, Minimum, or Total.
+     * And criteriaMetricMeasureColumn cannot be specified if criteriatimeAggregationMethod is Count.
+     */
+    readonly criteriaMetricMeasureColumn?: string;
+    /**
+     * How often the scheduled query rule is evaluated, represented in ISO 8601 duration format.
+     * Possible values are PT1M, PT5M, PT10M, PT15M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D.
+     */
+    readonly evaluationFrequency: string;
+    /**
+     * Severity of the alert. Should be an integer between 0 and 4. Value of 0 is severest.
+     */
+    readonly severity: number;
+    /**
+     * Specifies the period of time in ISO 8601 duration format on which the Scheduled Query Rule will be executed (bin size).
+     */
+    readonly windowDuration: string;
+    /**
+     * Specifies the action group IDs to trigger when the alert fires.
+     */
+    readonly actionActionGroupId?: string[];
+    /**
+     * Specifies the flag that indicates whether the alert should be automatically resolved or not.
+     * @default false
+     */
+    readonly autoMitigationEnabled?: boolean;
+    /**
+     * Specifies the flag which indicates whether this scheduled query rule check if storage is configured.
+     * @default false
+     */
+    readonly workspaceAlertsStorageEnabled?: boolean;
+    /**
+     * Specifies the description of the scheduled query rule.
+     */
+    readonly description?: string;
+    /**
+     * Specifies the display name of the alert rule.
+     */
+    readonly displayName?: string;
+    /**
+     * Specifies the flag which indicates whether this scheduled query rule is enabled.
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Mute actions for the chosen period of time in ISO 8601 duration format after the alert is fired.
+     * Possible values are PT5M, PT10M, PT15M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D and P2D.
+     */
+    readonly muteActionsAfterAlertDuration?: string;
+    /**
+     * Set this if the alert evaluation period is different from the query time range.
+     * If not specified, the value is window_duration*number_of_evaluation_periods.
+     * Possible values are PT5M, PT10M, PT15M, PT20M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D and P2D.
+     */
+    readonly queryTimeRangeOverride?: string;
+    /**
+     * Specifies the flag which indicates whether the provided query should be validated or not.
+     * @default true
+     */
+    readonly skipQueryValidation?: boolean;
+    /**
+     * A mapping of tags which should be assigned to the Monitor Scheduled Query Rule.
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+export interface AzureQueryRuleAlertProps extends BaseAzureQueryRuleAlertProps {
+    /**
+     * Specifies the list of resource IDs that this scheduled query rule is scoped to.
+     */
+    readonly scopes: string[];
+}
+export declare class QueryRuleAlert extends Construct {
+    readonly queryRuleAlertProps: AzureQueryRuleAlertProps;
+    id: string;
+    resourceGroup: ResourceGroup;
+    /**
+     * Represents an Azure Monitor Scheduled Query Rule Alert.
+     *
+     * This class is responsible for the creation and management of a Scheduled Query Rule Alert in Azure Monitor.
+     * Scheduled Query Rule Alerts execute specified queries at regular intervals over the data collected in Log Analytics
+     * Workspaces or Application Insights, and alert based on the results of these queries. These alerts can be used to monitor
+     * application health, infrastructure changes, or compliance with certain conditions.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Scheduled Query Rule Alert.
+     * @param props - The properties required to configure the Scheduled Query Rule Alert, as defined in the AzureQueryRuleAlertProps interface.
+     *                These include:
+     *                - `name`: The name of the Scheduled Query Rule.
+     *                - `resourceGroup`: The Azure Resource Group under which the alert will be created.
+     *                - `location`: The Azure region where the alert will be deployed.
+     *                - `criteriaQuery`: The query to execute. The results of this query determine whether an alert should be triggered.
+     *                - `evaluationFrequency`: How often the query should be run.
+     *                - `windowDuration`: The time period over which data is collected for each execution of the query.
+     *                - `severity`: The severity of the alert.
+     *                - `actionActionGroupId`: The action group to invoke when the alert criteria are met.
+     *                - `enabled`: Indicates whether the alert rule is enabled.
+     *
+     * Example usage:
+     * ```typescript
+     * new QueryRuleAlert(this, 'MyAlertRule', {
+     *   name: 'HighErrorRateAlert',
+     *   resourceGroup: myResourceGroup,
+     *   location: 'West US 2',
+     *   criteriaQuery: 'Heartbeat | summarize AggregatedValue = count() by bin(TimeGenerated, 5m)',
+     *   evaluationFrequency: 'PT5M',
+     *   windowDuration: 'PT1H',
+     *   severity: 3,
+     *   actionActionGroupId: ['/subscriptions/sub-id/resourceGroups/rg/providers/microsoft.insights/actionGroups/myActionGroup'],
+     *   enabled: true
+     * });
+     * ```
+     * This class sets up the alert rule and ensures it is ready to trigger actions based on the specified criteria and schedule.
+     */
+    constructor(scope: Construct, id: string, props: AzureQueryRuleAlertProps);
+}

package/lib/azure-queryrulealert/lib/query-rule-alert.js

@@ -0,0 +1,205 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRuleAlert = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const monitor_scheduled_query_rules_alert_v2_1 = require("@cdktf/provider-azurerm/lib/monitor-scheduled-query-rules-alert-v2");
+const cdktf = require("cdktf");
+const constructs_1 = require("constructs");
+const moment = require("moment");
+class QueryRuleAlert extends constructs_1.Construct {
+    /**
+     * Represents an Azure Monitor Scheduled Query Rule Alert.
+     *
+     * This class is responsible for the creation and management of a Scheduled Query Rule Alert in Azure Monitor.
+     * Scheduled Query Rule Alerts execute specified queries at regular intervals over the data collected in Log Analytics
+     * Workspaces or Application Insights, and alert based on the results of these queries. These alerts can be used to monitor
+     * application health, infrastructure changes, or compliance with certain conditions.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Scheduled Query Rule Alert.
+     * @param props - The properties required to configure the Scheduled Query Rule Alert, as defined in the AzureQueryRuleAlertProps interface.
+     *                These include:
+     *                - `name`: The name of the Scheduled Query Rule.
+     *                - `resourceGroup`: The Azure Resource Group under which the alert will be created.
+     *                - `location`: The Azure region where the alert will be deployed.
+     *                - `criteriaQuery`: The query to execute. The results of this query determine whether an alert should be triggered.
+     *                - `evaluationFrequency`: How often the query should be run.
+     *                - `windowDuration`: The time period over which data is collected for each execution of the query.
+     *                - `severity`: The severity of the alert.
+     *                - `actionActionGroupId`: The action group to invoke when the alert criteria are met.
+     *                - `enabled`: Indicates whether the alert rule is enabled.
+     *
+     * Example usage:
+     * ```typescript
+     * new QueryRuleAlert(this, 'MyAlertRule', {
+     *   name: 'HighErrorRateAlert',
+     *   resourceGroup: myResourceGroup,
+     *   location: 'West US 2',
+     *   criteriaQuery: 'Heartbeat | summarize AggregatedValue = count() by bin(TimeGenerated, 5m)',
+     *   evaluationFrequency: 'PT5M',
+     *   windowDuration: 'PT1H',
+     *   severity: 3,
+     *   actionActionGroupId: ['/subscriptions/sub-id/resourceGroups/rg/providers/microsoft.insights/actionGroups/myActionGroup'],
+     *   enabled: true
+     * });
+     * ```
+     * This class sets up the alert rule and ensures it is ready to trigger actions based on the specified criteria and schedule.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Properties validation
+        const evaluationFrequencyOption = [
+            "PT1M",
+            "PT5M",
+            "PT10M",
+            "PT15M",
+            "PT30M",
+            "PT45M",
+            "PT1H",
+            "PT2H",
+            "PT3H",
+            "PT4H",
+            "PT5H",
+            "PT6H",
+            "P1D",
+        ];
+        const windowDurationOption = [
+            "PT1M",
+            "PT5M",
+            "PT10M",
+            "PT15M",
+            "PT30M",
+            "PT45M",
+            "PT1H",
+            "PT2H",
+            "PT3H",
+            "PT4H",
+            "PT5H",
+            "PT6H",
+            "P1D",
+            "P2D",
+        ];
+        const muteActionsAfterAlertDurationOption = [
+            "PT5M",
+            "PT10M",
+            "PT15M",
+            "PT30M",
+            "PT45M",
+            "PT1H",
+            "PT2H",
+            "PT3H",
+            "PT4H",
+            "PT5H",
+            "PT6H",
+            "P1D",
+            "P2D",
+        ];
+        const queryTimeRangeOverrideOption = [
+            "PT5M",
+            "PT10M",
+            "PT15M",
+            "PT20M",
+            "PT30M",
+            "PT45M",
+            "PT1H",
+            "PT2H",
+            "PT3H",
+            "PT4H",
+            "PT5H",
+            "PT6H",
+            "P1D",
+            "P2D",
+        ];
+        // Validate evaluationFrequency
+        if (!evaluationFrequencyOption.includes(props.evaluationFrequency)) {
+            throw new Error("invalid evaluationFrequency");
+        }
+        // Validate windowDuration
+        if (!windowDurationOption.includes(props.windowDuration)) {
+            throw new Error("invalid windowDuration");
+        }
+        // Validate muteActionsAfterAlertDuration
+        if (props.muteActionsAfterAlertDuration &&
+            !muteActionsAfterAlertDurationOption.includes(props.muteActionsAfterAlertDuration)) {
+            throw new Error("invalid muteActionsAfterAlertDuration");
+        }
+        // Validate queryTimeRangeOverride
+        if (props.queryTimeRangeOverride &&
+            !queryTimeRangeOverrideOption.includes(props.queryTimeRangeOverride)) {
+            throw new Error("invalid queryTimeRangeOverride");
+        }
+        // The query look back which is windowDuration * numberOfEvaluationPeriods cannot exceed 48 hours.
+        if (props.criteriaFailNumberOfEvaluationPeriods) {
+            const windowDurationHours = moment
+                .duration(props.windowDuration)
+                .asHours();
+            const numberOfEvaluationPeriods = props.criteriaFailNumberOfEvaluationPeriods;
+            if (windowDurationHours * numberOfEvaluationPeriods > 48) {
+                throw new Error("queryTimeRangeOverride cannot exceed 48 hours");
+            }
+        }
+        this.queryRuleAlertProps = props;
+        this.resourceGroup = props.resourceGroup;
+        // Properties with default values
+        const defaults = {
+            autoMitigationEnabled: props.autoMitigationEnabled || false,
+            workspaceAlertsStorageEnabled: props.workspaceAlertsStorageEnabled || false,
+            enabled: props.enabled || true,
+            skipQueryValidation: props.skipQueryValidation || true,
+            metricMeasureColumn: props.criteriaMetricMeasureColumn || undefined,
+        };
+        const criteriaFailingPeriods = props.criteriaFailMinimumFailingPeriodsToTriggerAlert !== undefined &&
+            props.criteriaFailNumberOfEvaluationPeriods !== undefined
+            ? {
+                minimumFailingPeriodsToTriggerAlert: props.criteriaFailMinimumFailingPeriodsToTriggerAlert,
+                numberOfEvaluationPeriods: props.criteriaFailNumberOfEvaluationPeriods,
+            }
+            : undefined;
+        const dimension = props.criteriaDimensionName &&
+            props.criteriaDimensionOperator &&
+            props.criteriaDimensionValues
+            ? [
+                {
+                    name: props.criteriaDimensionName,
+                    operator: props.criteriaDimensionOperator,
+                    values: props.criteriaDimensionValues,
+                },
+            ]
+            : undefined;
+        const azurermMonitorQueryRuleAlert = new monitor_scheduled_query_rules_alert_v2_1.MonitorScheduledQueryRulesAlertV2(this, "queryrulealert", {
+            ...defaults,
+            name: props.name,
+            resourceGroupName: props.resourceGroup.name,
+            location: props.location,
+            scopes: props.scopes,
+            windowDuration: props.windowDuration,
+            evaluationFrequency: props.evaluationFrequency,
+            severity: props.severity,
+            criteria: [
+                {
+                    operator: props.criteriaOperator,
+                    query: props.criteriaQuery,
+                    threshold: props.criteriaThreshold,
+                    timeAggregationMethod: props.criteriatimeAggregationMethod,
+                    dimension: dimension,
+                    failingPeriods: criteriaFailingPeriods,
+                },
+            ],
+            action: props.actionActionGroupId
+                ? { actionGroups: props.actionActionGroupId }
+                : undefined,
+            tags: props.tags,
+        });
+        // Output
+        this.id = azurermMonitorQueryRuleAlert.id;
+        const cdktfTerraformOutputQueryRuleAlertId = new cdktf.TerraformOutput(this, "id", {
+            value: azurermMonitorQueryRuleAlert.id,
+        });
+        cdktfTerraformOutputQueryRuleAlertId.overrideLogicalId("query_rule_alert_id");
+    }
+}
+exports.QueryRuleAlert = QueryRuleAlert;
+_a = JSII_RTTI_SYMBOL_1;
+QueryRuleAlert[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_queryrulealert.QueryRuleAlert", version: "0.0.3-pre.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-rule-alert.js","sourceRoot":"","sources":["../../../src/azure-queryrulealert/lib/query-rule-alert.ts"],"names":[],"mappings":"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","sourcesContent":["import { MonitorScheduledQueryRulesAlertV2 } from \"@cdktf/provider-azurerm/lib/monitor-scheduled-query-rules-alert-v2\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as moment from \"moment\";\n\nexport interface BaseAzureQueryRuleAlertProps {\n  /**\n   * The name of the Monitor Scheduled Query Rule.\n   */\n  readonly name: string;\n  /**\n   * The name of the resource group in which the Monitor Scheduled Query Rule is created.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The location of the Monitor Scheduled Query Rule.\n   */\n  readonly location: string;\n  /**\n   * Specifies the criteria operator.\n   * Possible values are Equal, GreaterThan, GreaterThanOrEqual, LessThan,and LessThanOrEqual.\n   */\n  readonly criteriaOperator: string;\n  /**\n   * The query to run on logs. The results returned by this query are used to populate the alert.\n   */\n  readonly criteriaQuery: string;\n  /**\n   * Specifies the criteria threshold value that activates the alert.\n   */\n  readonly criteriaThreshold: number;\n  /**\n   * The type of aggregation to apply to the data points in aggregation granularity.\n   * Possible values are Average, Count, Maximum, Minimum,and Total.\n   */\n  readonly criteriatimeAggregationMethod: string;\n  /**\n   * Name of the dimension for criteria.\n   */\n  readonly criteriaDimensionName?: string;\n\n  /**\n   * Operator for dimension values. Possible values are Exclude, and Include.\n   */\n  readonly criteriaDimensionOperator?: string;\n\n  /**\n   * List of dimension values. Use a wildcard * to collect all.\n   */\n  readonly criteriaDimensionValues?: string[];\n\n  /**\n   * Specifies the number of violations to trigger an alert.\n   * Should be smaller or equal to number_of_evaluation_periods.\n   * Possible value is integer between 1 and 6.\n   */\n  readonly criteriaFailMinimumFailingPeriodsToTriggerAlert?: number;\n\n  /**\n   * Specifies the number of evaluation periods.\n   * Possible value is integer between 1 and 6.\n   */\n  readonly criteriaFailNumberOfEvaluationPeriods?: number;\n  /**\n   * Specifies the column containing the metric measure number.\n   * criteriaMetricMeasureColumn is required if criteriatimeAggregationMethod is Average, Maximum, Minimum, or Total.\n   * And criteriaMetricMeasureColumn cannot be specified if criteriatimeAggregationMethod is Count.\n   */\n  readonly criteriaMetricMeasureColumn?: string;\n  /**\n   * How often the scheduled query rule is evaluated, represented in ISO 8601 duration format.\n   * Possible values are PT1M, PT5M, PT10M, PT15M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D.\n   */\n  readonly evaluationFrequency: string;\n  /**\n   * Severity of the alert. Should be an integer between 0 and 4. Value of 0 is severest.\n   */\n  readonly severity: number;\n  /**\n   * Specifies the period of time in ISO 8601 duration format on which the Scheduled Query Rule will be executed (bin size).\n   */\n  readonly windowDuration: string;\n  /**\n   * Specifies the action group IDs to trigger when the alert fires.\n   */\n  readonly actionActionGroupId?: string[];\n  /**\n   * Specifies the flag that indicates whether the alert should be automatically resolved or not.\n   * @default false\n   */\n  readonly autoMitigationEnabled?: boolean;\n  /**\n   * Specifies the flag which indicates whether this scheduled query rule check if storage is configured.\n   * @default false\n   */\n  readonly workspaceAlertsStorageEnabled?: boolean;\n  /**\n   * Specifies the description of the scheduled query rule.\n   */\n  readonly description?: string;\n  /**\n   * Specifies the display name of the alert rule.\n   */\n  readonly displayName?: string;\n  /**\n   * Specifies the flag which indicates whether this scheduled query rule is enabled.\n   * @default true\n   */\n  readonly enabled?: boolean;\n  /**\n   * Mute actions for the chosen period of time in ISO 8601 duration format after the alert is fired.\n   * Possible values are PT5M, PT10M, PT15M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D and P2D.\n   */\n  readonly muteActionsAfterAlertDuration?: string;\n  /**\n   * Set this if the alert evaluation period is different from the query time range.\n   * If not specified, the value is window_duration*number_of_evaluation_periods.\n   * Possible values are PT5M, PT10M, PT15M, PT20M, PT30M, PT45M, PT1H, PT2H, PT3H, PT4H, PT5H, PT6H, P1D and P2D.\n   */\n  readonly queryTimeRangeOverride?: string;\n  /**\n   * Specifies the flag which indicates whether the provided query should be validated or not.\n   * @default true\n   */\n  readonly skipQueryValidation?: boolean;\n  /**\n   * A mapping of tags which should be assigned to the Monitor Scheduled Query Rule.\n   */\n  readonly tags?: { [key: string]: string };\n}\n\nexport interface AzureQueryRuleAlertProps extends BaseAzureQueryRuleAlertProps {\n  /**\n   * Specifies the list of resource IDs that this scheduled query rule is scoped to.\n   */\n  readonly scopes: string[];\n}\n\nexport class QueryRuleAlert extends Construct {\n  readonly queryRuleAlertProps: AzureQueryRuleAlertProps;\n  public id: string;\n  public resourceGroup: ResourceGroup;\n\n  /**\n   * Represents an Azure Monitor Scheduled Query Rule Alert.\n   *\n   * This class is responsible for the creation and management of a Scheduled Query Rule Alert in Azure Monitor.\n   * Scheduled Query Rule Alerts execute specified queries at regular intervals over the data collected in Log Analytics\n   * Workspaces or Application Insights, and alert based on the results of these queries. These alerts can be used to monitor\n   * application health, infrastructure changes, or compliance with certain conditions.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the Scheduled Query Rule Alert.\n   * @param props - The properties required to configure the Scheduled Query Rule Alert, as defined in the AzureQueryRuleAlertProps interface.\n   *                These include:\n   *                - `name`: The name of the Scheduled Query Rule.\n   *                - `resourceGroup`: The Azure Resource Group under which the alert will be created.\n   *                - `location`: The Azure region where the alert will be deployed.\n   *                - `criteriaQuery`: The query to execute. The results of this query determine whether an alert should be triggered.\n   *                - `evaluationFrequency`: How often the query should be run.\n   *                - `windowDuration`: The time period over which data is collected for each execution of the query.\n   *                - `severity`: The severity of the alert.\n   *                - `actionActionGroupId`: The action group to invoke when the alert criteria are met.\n   *                - `enabled`: Indicates whether the alert rule is enabled.\n   *\n   * Example usage:\n   * ```typescript\n   * new QueryRuleAlert(this, 'MyAlertRule', {\n   *   name: 'HighErrorRateAlert',\n   *   resourceGroup: myResourceGroup,\n   *   location: 'West US 2',\n   *   criteriaQuery: 'Heartbeat | summarize AggregatedValue = count() by bin(TimeGenerated, 5m)',\n   *   evaluationFrequency: 'PT5M',\n   *   windowDuration: 'PT1H',\n   *   severity: 3,\n   *   actionActionGroupId: ['/subscriptions/sub-id/resourceGroups/rg/providers/microsoft.insights/actionGroups/myActionGroup'],\n   *   enabled: true\n   * });\n   * ```\n   * This class sets up the alert rule and ensures it is ready to trigger actions based on the specified criteria and schedule.\n   */\n  constructor(scope: Construct, id: string, props: AzureQueryRuleAlertProps) {\n    super(scope, id);\n\n    // Properties validation\n    const evaluationFrequencyOption = [\n      \"PT1M\",\n      \"PT5M\",\n      \"PT10M\",\n      \"PT15M\",\n      \"PT30M\",\n      \"PT45M\",\n      \"PT1H\",\n      \"PT2H\",\n      \"PT3H\",\n      \"PT4H\",\n      \"PT5H\",\n      \"PT6H\",\n      \"P1D\",\n    ];\n    const windowDurationOption = [\n      \"PT1M\",\n      \"PT5M\",\n      \"PT10M\",\n      \"PT15M\",\n      \"PT30M\",\n      \"PT45M\",\n      \"PT1H\",\n      \"PT2H\",\n      \"PT3H\",\n      \"PT4H\",\n      \"PT5H\",\n      \"PT6H\",\n      \"P1D\",\n      \"P2D\",\n    ];\n    const muteActionsAfterAlertDurationOption = [\n      \"PT5M\",\n      \"PT10M\",\n      \"PT15M\",\n      \"PT30M\",\n      \"PT45M\",\n      \"PT1H\",\n      \"PT2H\",\n      \"PT3H\",\n      \"PT4H\",\n      \"PT5H\",\n      \"PT6H\",\n      \"P1D\",\n      \"P2D\",\n    ];\n    const queryTimeRangeOverrideOption = [\n      \"PT5M\",\n      \"PT10M\",\n      \"PT15M\",\n      \"PT20M\",\n      \"PT30M\",\n      \"PT45M\",\n      \"PT1H\",\n      \"PT2H\",\n      \"PT3H\",\n      \"PT4H\",\n      \"PT5H\",\n      \"PT6H\",\n      \"P1D\",\n      \"P2D\",\n    ];\n\n    // Validate evaluationFrequency\n    if (!evaluationFrequencyOption.includes(props.evaluationFrequency)) {\n      throw new Error(\"invalid evaluationFrequency\");\n    }\n    // Validate windowDuration\n    if (!windowDurationOption.includes(props.windowDuration)) {\n      throw new Error(\"invalid windowDuration\");\n    }\n    // Validate muteActionsAfterAlertDuration\n    if (\n      props.muteActionsAfterAlertDuration &&\n      !muteActionsAfterAlertDurationOption.includes(\n        props.muteActionsAfterAlertDuration,\n      )\n    ) {\n      throw new Error(\"invalid muteActionsAfterAlertDuration\");\n    }\n    // Validate queryTimeRangeOverride\n    if (\n      props.queryTimeRangeOverride &&\n      !queryTimeRangeOverrideOption.includes(props.queryTimeRangeOverride)\n    ) {\n      throw new Error(\"invalid queryTimeRangeOverride\");\n    }\n    // The query look back which is windowDuration * numberOfEvaluationPeriods cannot exceed 48 hours.\n    if (props.criteriaFailNumberOfEvaluationPeriods) {\n      const windowDurationHours = moment\n        .duration(props.windowDuration)\n        .asHours();\n      const numberOfEvaluationPeriods =\n        props.criteriaFailNumberOfEvaluationPeriods;\n      if (windowDurationHours * numberOfEvaluationPeriods > 48) {\n        throw new Error(\"queryTimeRangeOverride cannot exceed 48 hours\");\n      }\n    }\n\n    this.queryRuleAlertProps = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Properties with default values\n    const defaults = {\n      autoMitigationEnabled: props.autoMitigationEnabled || false,\n      workspaceAlertsStorageEnabled:\n        props.workspaceAlertsStorageEnabled || false,\n      enabled: props.enabled || true,\n      skipQueryValidation: props.skipQueryValidation || true,\n      metricMeasureColumn: props.criteriaMetricMeasureColumn || undefined,\n    };\n\n    const criteriaFailingPeriods =\n      props.criteriaFailMinimumFailingPeriodsToTriggerAlert !== undefined &&\n      props.criteriaFailNumberOfEvaluationPeriods !== undefined\n        ? {\n            minimumFailingPeriodsToTriggerAlert:\n              props.criteriaFailMinimumFailingPeriodsToTriggerAlert,\n            numberOfEvaluationPeriods:\n              props.criteriaFailNumberOfEvaluationPeriods,\n          }\n        : undefined;\n\n    const dimension =\n      props.criteriaDimensionName &&\n      props.criteriaDimensionOperator &&\n      props.criteriaDimensionValues\n        ? [\n            {\n              name: props.criteriaDimensionName,\n              operator: props.criteriaDimensionOperator,\n              values: props.criteriaDimensionValues,\n            },\n          ]\n        : undefined;\n\n    const azurermMonitorQueryRuleAlert = new MonitorScheduledQueryRulesAlertV2(\n      this,\n      \"queryrulealert\",\n      {\n        ...defaults,\n        name: props.name,\n        resourceGroupName: props.resourceGroup.name,\n        location: props.location,\n        scopes: props.scopes,\n        windowDuration: props.windowDuration,\n        evaluationFrequency: props.evaluationFrequency,\n        severity: props.severity,\n        criteria: [\n          {\n            operator: props.criteriaOperator,\n            query: props.criteriaQuery,\n            threshold: props.criteriaThreshold,\n            timeAggregationMethod: props.criteriatimeAggregationMethod,\n            dimension: dimension,\n            failingPeriods: criteriaFailingPeriods,\n          },\n        ],\n        action: props.actionActionGroupId\n          ? { actionGroups: props.actionActionGroupId }\n          : undefined,\n        tags: props.tags,\n      },\n    );\n\n    // Output\n    this.id = azurermMonitorQueryRuleAlert.id;\n    const cdktfTerraformOutputQueryRuleAlertId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: azurermMonitorQueryRuleAlert.id,\n      },\n    );\n    cdktfTerraformOutputQueryRuleAlertId.overrideLogicalId(\n      \"query_rule_alert_id\",\n    );\n  }\n}\n"]}

package/lib/azure-queryrulealert/test/AzureQueryRuleAlert.spec.d.ts

@@ -0,0 +1 @@
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-queryrulealert/test/AzureQueryRuleAlert.spec.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const ExampleAzureQueryRuleAlert_1 = require("./ExampleAzureQueryRuleAlert");
+const queryalert = require("../../azure-queryrulealert");
+const util = require("../../util/azureTenantIdHelpers");
+describe("Azure Query Rule Alert With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "test");
+        new provider_1.AzurermProvider(stack, "azureQueryRuleAlert", { features: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new queryalert.QueryRuleAlert(stack, "testAzureQueryRuleAlert", {
+            name: "alert test",
+            resourceGroup: rg,
+            location: "eastus",
+            criteriaOperator: "GreaterThan",
+            criteriaQuery: `
+AppExceptions 
+| where Message has "file can not be reloaded"
+`,
+            criteriaThreshold: 100,
+            criteriatimeAggregationMethod: "Count",
+            evaluationFrequency: "PT5M",
+            windowDuration: "PT30M",
+            scopes: ["/subscriptions/00000000-0000-0000-0000-000000000000"],
+            severity: 3,
+            criteriaFailMinimumFailingPeriodsToTriggerAlert: 1,
+            criteriaFailNumberOfEvaluationPeriods: 1,
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Query Rule Alert with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Linux Query Rule Alert Example", () => {
+    it("renders the Query Rule Alert and checks snapshot", () => {
+        // Need to remove the tenant_id from the snapshot as it will change wherever the test is run
+        const output = cdktf_1.Testing.synth(new ExampleAzureQueryRuleAlert_1.exampleAzureQueryRuleAlert(cdktf_1.Testing.app(), "testAzureQueryRuleAlert"));
+        const myObject = JSON.parse(output);
+        expect(util.removeTenantIdFromSnapshot(myObject)).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureQueryRuleAlert_1.exampleAzureQueryRuleAlert(cdktf_1.Testing.app(), "testAzureQueryRuleAlert"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureQueryRuleAlert_1.exampleAzureQueryRuleAlert(cdktf_1.Testing.app(), "testAzureQueryRuleAlert"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-queryrulealert/test/ExampleAzureQueryRuleAlert.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { BaseTestStack } from "../../testing";
+export declare class exampleAzureQueryRuleAlert extends BaseTestStack {
+    constructor(scope: Construct, id: string);
+}

package/lib/azure-queryrulealert/test/ExampleAzureQueryRuleAlert.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleAzureQueryRuleAlert = void 0;
+const log_analytics_workspace_1 = require("@cdktf/provider-azurerm/lib/log-analytics-workspace");
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const queryalert = require("../../azure-queryrulealert");
+const testing_1 = require("../../testing");
+const app = new cdktf_1.App();
+class exampleAzureQueryRuleAlert extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id);
+        new provider_1.AzurermProvider(this, "azureFeature", {
+            features: {
+                resourceGroup: {
+                    preventDeletionIfContainsResources: true,
+                },
+            },
+        });
+        const resourceGroup = new resource_group_1.ResourceGroup(this, "rg", {
+            location: "eastus",
+            name: `rg-${this.name}`,
+            tags: {
+                test: "test",
+            },
+        });
+        const logAnalyticsWorkspace = new log_analytics_workspace_1.LogAnalyticsWorkspace(this, "log_analytics", {
+            location: "eastus",
+            name: `la-${this.name}`,
+            resourceGroupName: resourceGroup.name,
+        });
+        // Query Rule Alert
+        const alert = new queryalert.QueryRuleAlert(this, "queryRuleAlert", {
+            name: `qra-${this.name}`,
+            resourceGroup: resourceGroup,
+            location: "eastus",
+            criteriaOperator: "GreaterThan",
+            criteriaQuery: `
+AppExceptions 
+| where Message has "file can not be reloaded"
+`,
+            criteriaThreshold: 100,
+            criteriatimeAggregationMethod: "Count",
+            evaluationFrequency: "PT5M",
+            windowDuration: "PT30M",
+            scopes: [logAnalyticsWorkspace.id],
+            severity: 4,
+            criteriaFailMinimumFailingPeriodsToTriggerAlert: 1,
+            criteriaFailNumberOfEvaluationPeriods: 1,
+        });
+        // Create Terraform Outputs for Function Apps
+        const cdktfTerraformOutputRG = new cdktf.TerraformOutput(this, "resource_group_name", {
+            value: resourceGroup.name,
+        });
+        const cdktfTerraformOutputAlertId = new cdktf.TerraformOutput(this, "query_rule_alert_id", {
+            value: alert.id,
+        });
+        cdktfTerraformOutputRG.overrideLogicalId("resource_group_name");
+        cdktfTerraformOutputAlertId.overrideLogicalId("query_rule_alert_id");
+    }
+}
+exports.exampleAzureQueryRuleAlert = exampleAzureQueryRuleAlert;
+new exampleAzureQueryRuleAlert(app, "testAzureQueryRuleAlert");
+app.synth();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-resourcegroup/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/azure-resourcegroup/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtcmVzb3VyY2Vncm91cC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbGliXCI7XG4iXX0=

package/lib/azure-resourcegroup/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./resource-group";

package/lib/azure-resourcegroup/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resource-group"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtcmVzb3VyY2Vncm91cC9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFpQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlLWdyb3VwXCI7XG4iXX0=