@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/azure-metricalert/lib/metric-alert.js

@@ -3,126 +3,250 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricAlert = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
-const monitor_metric_alert_1 = require("@cdktf/provider-azurerm/lib/monitor-metric-alert");
+/**
+ * Unified Azure Metric Alert implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Metric Alerts
+ * that automatically handles version management, schema validation, and property
+ * transformation across all supported API versions.
+ *
+ * Supported API Versions:
+ * - 2018-03-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - Support for both static and dynamic threshold criteria
+ */
 const cdktf = require("cdktf");
-const constructs_1 = require("constructs");
-const moment = require("moment");
-const model = require("../model");
-class MetricAlert extends constructs_1.Construct {
+const metric_alert_schemas_1 = require("./metric-alert-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+/**
+ * Unified Azure Metric Alert implementation
+ *
+ * This class provides a single, version-aware implementation that automatically handles version
+ * resolution, schema validation, and property transformation while maintaining full JSII compliance.
+ *
+ * Metric Alerts monitor Azure resource metrics and trigger notifications when thresholds are breached.
+ * They support both static thresholds and dynamic thresholds based on machine learning.
+ *
+ * @example
+ * // Static threshold alert for VM CPU:
+ * const cpuAlert = new MetricAlert(this, "high-cpu", {
+ *   name: "vm-high-cpu-alert",
+ *   resourceGroupId: resourceGroup.id,
+ *   severity: 2,
+ *   scopes: [virtualMachine.id],
+ *   criteria: {
+ *     type: "StaticThreshold",
+ *     metricName: "Percentage CPU",
+ *     operator: "GreaterThan",
+ *     threshold: 80,
+ *     timeAggregation: "Average"
+ *   },
+ *   actions: [{
+ *     actionGroupId: actionGroup.id
+ *   }]
+ * });
+ *
+ * @example
+ * // Dynamic threshold alert with machine learning:
+ * const dynamicAlert = new MetricAlert(this, "dynamic-cpu", {
+ *   name: "vm-dynamic-cpu-alert",
+ *   resourceGroupId: resourceGroup.id,
+ *   severity: 2,
+ *   scopes: [resourceGroup.id],
+ *   targetResourceType: "Microsoft.Compute/virtualMachines",
+ *   targetResourceRegion: "eastus",
+ *   criteria: {
+ *     type: "DynamicThreshold",
+ *     metricName: "Percentage CPU",
+ *     operator: "GreaterThan",
+ *     alertSensitivity: "Medium",
+ *     failingPeriods: {
+ *       numberOfEvaluationPeriods: 4,
+ *       minFailingPeriodsToAlert: 3
+ *     },
+ *     timeAggregation: "Average"
+ *   },
+ *   actions: [{
+ *     actionGroupId: actionGroup.id
+ *   }]
+ * });
+ *
+ * @stability stable
+ */
+class MetricAlert extends azapi_resource_1.AzapiResource {
     /**
-     * Represents a Metric Alert in Azure Monitor, which is used to automatically monitor metrics across Azure services and trigger actions when certain conditions are met.
-     *
-     * This class encapsulates the configuration and management of a Metric Alert, allowing users to define alert rules based on the metrics from their Azure resources. Metric Alerts can help in proactively managing the health, performance, and availability of Azure services.
-     *
-     * Properties:
-     * - `name`: The name of the Metric Alert, which must be unique within the resource group.
-     * - `description`: Optional. A description of what the Metric Alert monitors and potential impact or remediation.
-     * - `enabled`: Indicates whether the alert rule is enabled. Disabled rules will not fire.
-     * - `autoMitigate`: Specifies whether the alert should attempt auto-mitigation actions when triggered.
-     * - `frequency`: The frequency of evaluation for the alert rule, determining how often the rule is checked.
-     * - `severity`: The severity level assigned to the alert. This helps in categorizing the urgency of the alert.
-     * - `targetResourceType`: Specifies the type of Azure resource the alert rule applies to, necessary for scoping the alert.
-     * - `targetResourceLocation`: Specifies the location of the target resource, required when the alert rule covers resources in multiple locations.
-     * - `windowSize`: The period over which data is collected for analysis, which must be greater than the frequency of evaluation.
-     * - `tags`: User-defined tags to help organize and identify resources within Azure.
-     * - `criteria`: The conditions that trigger the alert. This can be static or dynamic, based on the behavior of the monitored metric over time.
-     * - `dynamicCriteria`: Advanced configurations for criteria that dynamically adjust thresholds based on historical data.
-     * - `scopes`: The specific resources that the Metric Alert is scoped to monitor.
-     * - `resourceGroup`: The Azure Resource Group in which this Metric Alert is defined.
-     *
-     * Example usage:
-     * ```typescript
-     * const cpuAlertProps: IMetricAlertProps = {
-     *   name: 'High CPU Usage Alert',
-     *   resourceGroup: resourceGroupInstance,
-     *   scopes: [vm.id],
-     *   criteria: [
-     *     {
-     *       metricName: 'Percentage CPU',
-     *       operator: 'GreaterThan',
-     *       threshold: 80,
-     *       aggregation: 'Average'
-     *     }
-     *   ],
-     *   frequency: 'PT1M',
-     *   windowSize: 'PT5M',
-     *   severity: 3,
-     *   enabled: true
-     * };
+     * Ensures that Metric Alert schemas are registered with the ApiVersionManager
+     * This is called once during the first MetricAlert instantiation
+     */
+    static ensureSchemasRegistered() {
+        if (MetricAlert.schemasRegistered) {
+            return;
+        }
+        const apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            // Register all Metric Alert versions
+            apiVersionManager.registerResourceType(metric_alert_schemas_1.METRIC_ALERT_TYPE, metric_alert_schemas_1.ALL_METRIC_ALERT_VERSIONS);
+            MetricAlert.schemasRegistered = true;
+            console.log(`Registered ${metric_alert_schemas_1.ALL_METRIC_ALERT_VERSIONS.length} API versions for ${metric_alert_schemas_1.METRIC_ALERT_TYPE}`);
+        }
+        catch (error) {
+            console.warn(`Failed to register Metric Alert schemas: ${error}. ` +
+                `This may indicate the schemas are already registered or there's a configuration issue.`);
+            MetricAlert.schemasRegistered = true;
+        }
+    }
+    /**
+     * Creates a new Azure Metric Alert using the AzapiResource framework
      *
-     * const cpuAlert = new MetricAlert(this, 'cpuUsageAlert', cpuAlertProps);
-     * ```
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
      *
-     * This configuration defines a Metric Alert that monitors CPU usage across specified virtual machines, triggering an alert if the CPU usage exceeds 80% over a 5-minute window, evaluated every minute.
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Metric Alert
      */
     constructor(scope, id, props) {
-        super(scope, id);
+        // Ensure schemas are registered before calling super
+        MetricAlert.ensureSchemasRegistered();
+        // Call the parent constructor with the props
+        super(scope, id, props);
         this.props = props;
-        // Setup default values
-        this.props.enabled = props.enabled ?? true;
-        this.props.automitigate = props.automitigate ?? true;
-        this.props.frequency = props.frequency ?? "PT5M";
-        this.props.severity = props.severity ?? 3;
-        this.props.windowSize = props.windowSize ?? props.frequency ?? "PT5M";
-        // Properties validation
-        this.ValidatePropsFrequency();
-        this.ValidatePropsWindowSize();
-        this.ValidatePropsWindowSizeGreaterThanFrequency();
-        // Create Metric Alert
-        const metricAlert = new monitor_metric_alert_1.MonitorMetricAlert(this, "metricAlert", {
-            name: props.name,
-            resourceGroupName: props.resourceGroup.name,
-            scopes: props.scopes,
-            description: props.description,
-            targetResourceType: props.targetResourceType,
-            targetResourceLocation: props.targetResourceLocation,
-            action: cdktf.listMapper(model.monitorMetricAlertActionToTerraform, true)(this.props.action),
-            tags: props.tags,
-            enabled: this.props.enabled,
-            autoMitigate: this.props.automitigate,
-            frequency: this.props.frequency,
-            severity: this.props.severity,
-            windowSize: this.props.windowSize,
-            criteria: cdktf.listMapper(model.monitorMetricAlertCriteriaToTerraform, true)(this.props.criteria),
-            dynamicCriteria: cdktf.listMapper(model.monitorMetricAlertDynamicCriteriaToTerraform, true)(this.props.dynamicCriteria),
+        // Extract properties from the AZAPI resource outputs using Terraform interpolation
+        this.id = `\${${this.terraformResource.fqn}.id}`;
+        // Create Terraform outputs for easy access and referencing from other resources
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Metric Alert",
         });
-        // Output properties
-        this.id = metricAlert.id;
-        const cdktfTerraformOutputMetricAlertId = new cdktf.TerraformOutput(this, "id", {
-            value: metricAlert.id,
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Metric Alert",
         });
-        cdktfTerraformOutputMetricAlertId.overrideLogicalId("id");
+        // Override logical IDs
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the most recent stable version as the default
+     */
+    defaultVersion() {
+        return "2018-03-01";
     }
-    ValidatePropsFrequency() {
-        const frequencyOptions = ["PT1M", "PT5M", "PT15M", "PT30M", "PT1H"];
-        if (!frequencyOptions.includes(this.props.frequency ?? "NotSet")) {
-            throw new Error(`frequency must be one of ${frequencyOptions}`);
+    /**
+     * Gets the Azure resource type for Metric Alerts
+     */
+    resourceType() {
+        return metric_alert_schemas_1.METRIC_ALERT_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        // Transform criteria based on type
+        let transformedCriteria;
+        if (typedProps.criteria.type === "StaticThreshold") {
+            transformedCriteria = {
+                "odata.type": "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
+                allOf: [
+                    {
+                        criterionType: "StaticThresholdCriterion",
+                        name: "metric1",
+                        metricName: typedProps.criteria.metricName,
+                        metricNamespace: typedProps.criteria.metricNamespace,
+                        operator: typedProps.criteria.operator,
+                        threshold: typedProps.criteria.threshold,
+                        timeAggregation: typedProps.criteria.timeAggregation,
+                        dimensions: typedProps.criteria.dimensions || [],
+                    },
+                ],
+            };
+        }
+        else {
+            transformedCriteria = {
+                "odata.type": "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
+                allOf: [
+                    {
+                        criterionType: "DynamicThresholdCriterion",
+                        name: "metric1",
+                        metricName: typedProps.criteria.metricName,
+                        metricNamespace: typedProps.criteria.metricNamespace,
+                        operator: typedProps.criteria.operator,
+                        alertSensitivity: typedProps.criteria.alertSensitivity,
+                        failingPeriods: typedProps.criteria.failingPeriods,
+                        timeAggregation: typedProps.criteria.timeAggregation,
+                        dimensions: typedProps.criteria.dimensions || [],
+                        ignoreDataBefore: typedProps.criteria.ignoreDataBefore,
+                    },
+                ],
+            };
         }
+        return {
+            location: "global",
+            tags: typedProps.tags || {},
+            properties: {
+                description: typedProps.description,
+                severity: typedProps.severity,
+                enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,
+                scopes: typedProps.scopes,
+                evaluationFrequency: typedProps.evaluationFrequency || "PT5M",
+                windowSize: typedProps.windowSize || "PT15M",
+                targetResourceType: typedProps.targetResourceType,
+                targetResourceRegion: typedProps.targetResourceRegion,
+                criteria: transformedCriteria,
+                actions: typedProps.actions || [],
+                autoMitigate: typedProps.autoMitigate !== undefined
+                    ? typedProps.autoMitigate
+                    : true,
+            },
+        };
     }
-    ValidatePropsWindowSize() {
-        const windowSizeOptions = [
-            "PT1M",
-            "PT5M",
-            "PT15M",
-            "PT30M",
-            "PT1H",
-            "PT6H",
-            "PT12H",
-            "P1D",
-        ];
-        if (!windowSizeOptions.includes(this.props.windowSize ?? "NotSet")) {
-            throw new Error(`windowSize must be one of ${windowSizeOptions}`);
+    // =============================================================================
+    // PUBLIC METHODS FOR METRIC ALERT OPERATIONS
+    // =============================================================================
+    /**
+     * Add a tag to the Metric Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    addTag(key, value) {
+        if (!this.props.tags) {
+            this.props.tags = {};
         }
+        this.props.tags[key] = value;
     }
-    ValidatePropsWindowSizeGreaterThanFrequency() {
-        const f = moment.duration(this.props.frequency);
-        const w = moment.duration(this.props.windowSize);
-        if (w < f) {
-            throw new Error("windowSize must be greater than frequency");
+    /**
+     * Remove a tag from the Metric Alert
+     * Note: This modifies the construct props but requires a new deployment to take effect
+     */
+    removeTag(key) {
+        if (this.props.tags && this.props.tags[key]) {
+            delete this.props.tags[key];
         }
     }
 }
 exports.MetricAlert = MetricAlert;
 _a = JSII_RTTI_SYMBOL_1;
-MetricAlert[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_metricalert.MetricAlert", version: "0.0.3-pre.7" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-alert.js","sourceRoot":"","sources":["../../../src/azure-metricalert/lib/metric-alert.ts"],"names":[],"mappings":"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","sourcesContent":["import { MonitorMetricAlert } from \"@cdktf/provider-azurerm/lib/monitor-metric-alert\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as moment from \"moment\";\nimport * as model from \"../model\";\n\nexport class MetricAlert extends Construct {\n  readonly props: model.IMetricAlertProps;\n  public readonly id: string;\n\n  /**\n   * Represents a Metric Alert in Azure Monitor, which is used to automatically monitor metrics across Azure services and trigger actions when certain conditions are met.\n   *\n   * This class encapsulates the configuration and management of a Metric Alert, allowing users to define alert rules based on the metrics from their Azure resources. Metric Alerts can help in proactively managing the health, performance, and availability of Azure services.\n   *\n   * Properties:\n   * - `name`: The name of the Metric Alert, which must be unique within the resource group.\n   * - `description`: Optional. A description of what the Metric Alert monitors and potential impact or remediation.\n   * - `enabled`: Indicates whether the alert rule is enabled. Disabled rules will not fire.\n   * - `autoMitigate`: Specifies whether the alert should attempt auto-mitigation actions when triggered.\n   * - `frequency`: The frequency of evaluation for the alert rule, determining how often the rule is checked.\n   * - `severity`: The severity level assigned to the alert. This helps in categorizing the urgency of the alert.\n   * - `targetResourceType`: Specifies the type of Azure resource the alert rule applies to, necessary for scoping the alert.\n   * - `targetResourceLocation`: Specifies the location of the target resource, required when the alert rule covers resources in multiple locations.\n   * - `windowSize`: The period over which data is collected for analysis, which must be greater than the frequency of evaluation.\n   * - `tags`: User-defined tags to help organize and identify resources within Azure.\n   * - `criteria`: The conditions that trigger the alert. This can be static or dynamic, based on the behavior of the monitored metric over time.\n   * - `dynamicCriteria`: Advanced configurations for criteria that dynamically adjust thresholds based on historical data.\n   * - `scopes`: The specific resources that the Metric Alert is scoped to monitor.\n   * - `resourceGroup`: The Azure Resource Group in which this Metric Alert is defined.\n   *\n   * Example usage:\n   * ```typescript\n   * const cpuAlertProps: IMetricAlertProps = {\n   *   name: 'High CPU Usage Alert',\n   *   resourceGroup: resourceGroupInstance,\n   *   scopes: [vm.id],\n   *   criteria: [\n   *     {\n   *       metricName: 'Percentage CPU',\n   *       operator: 'GreaterThan',\n   *       threshold: 80,\n   *       aggregation: 'Average'\n   *     }\n   *   ],\n   *   frequency: 'PT1M',\n   *   windowSize: 'PT5M',\n   *   severity: 3,\n   *   enabled: true\n   * };\n   *\n   * const cpuAlert = new MetricAlert(this, 'cpuUsageAlert', cpuAlertProps);\n   * ```\n   *\n   * This configuration defines a Metric Alert that monitors CPU usage across specified virtual machines, triggering an alert if the CPU usage exceeds 80% over a 5-minute window, evaluated every minute.\n   */\n  constructor(scope: Construct, id: string, props: model.IMetricAlertProps) {\n    super(scope, id);\n\n    this.props = props;\n\n    // Setup default values\n    this.props.enabled = props.enabled ?? true;\n    this.props.automitigate = props.automitigate ?? true;\n    this.props.frequency = props.frequency ?? \"PT5M\";\n    this.props.severity = props.severity ?? 3;\n    this.props.windowSize = props.windowSize ?? props.frequency ?? \"PT5M\";\n\n    // Properties validation\n    this.ValidatePropsFrequency();\n    this.ValidatePropsWindowSize();\n    this.ValidatePropsWindowSizeGreaterThanFrequency();\n\n    // Create Metric Alert\n    const metricAlert = new MonitorMetricAlert(this, \"metricAlert\", {\n      name: props.name,\n      resourceGroupName: props.resourceGroup.name,\n      scopes: props.scopes,\n      description: props.description,\n      targetResourceType: props.targetResourceType,\n      targetResourceLocation: props.targetResourceLocation,\n      action: cdktf.listMapper(\n        model.monitorMetricAlertActionToTerraform,\n        true,\n      )(this.props.action),\n      tags: props.tags,\n      enabled: this.props.enabled,\n      autoMitigate: this.props.automitigate,\n      frequency: this.props.frequency,\n      severity: this.props.severity,\n      windowSize: this.props.windowSize,\n      criteria: cdktf.listMapper(\n        model.monitorMetricAlertCriteriaToTerraform,\n        true,\n      )(this.props.criteria),\n      dynamicCriteria: cdktf.listMapper(\n        model.monitorMetricAlertDynamicCriteriaToTerraform,\n        true,\n      )(this.props.dynamicCriteria),\n    });\n\n    // Output properties\n    this.id = metricAlert.id;\n    const cdktfTerraformOutputMetricAlertId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: metricAlert.id,\n      },\n    );\n    cdktfTerraformOutputMetricAlertId.overrideLogicalId(\"id\");\n  }\n\n  private ValidatePropsFrequency() {\n    const frequencyOptions = [\"PT1M\", \"PT5M\", \"PT15M\", \"PT30M\", \"PT1H\"];\n    if (!frequencyOptions.includes(this.props.frequency ?? \"NotSet\")) {\n      throw new Error(`frequency must be one of ${frequencyOptions}`);\n    }\n  }\n\n  private ValidatePropsWindowSize() {\n    const windowSizeOptions = [\n      \"PT1M\",\n      \"PT5M\",\n      \"PT15M\",\n      \"PT30M\",\n      \"PT1H\",\n      \"PT6H\",\n      \"PT12H\",\n      \"P1D\",\n    ];\n    if (!windowSizeOptions.includes(this.props.windowSize ?? \"NotSet\")) {\n      throw new Error(`windowSize must be one of ${windowSizeOptions}`);\n    }\n  }\n\n  private ValidatePropsWindowSizeGreaterThanFrequency() {\n    const f = moment.duration(this.props.frequency);\n    const w = moment.duration(this.props.windowSize);\n    if (w < f) {\n      throw new Error(\"windowSize must be greater than frequency\");\n    }\n  }\n}\n"]}
+MetricAlert[_a] = { fqn: "@microsoft/terraform-cdk-constructs.MetricAlert", version: "1.2.0" };
+/**
+ * Static initialization flag to ensure schemas are registered only once
+ */
+MetricAlert.schemasRegistered = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-alert.js","sourceRoot":"","sources":["../../../src/azure-metricalert/lib/metric-alert.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Metric Alert implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Metric Alerts\n * that automatically handles version management, schema validation, and property\n * transformation across all supported API versions.\n *\n * Supported API Versions:\n * - 2018-03-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full JSII compliance for multi-language support\n * - Support for both static and dynamic threshold criteria\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_METRIC_ALERT_VERSIONS,\n  METRIC_ALERT_TYPE,\n} from \"./metric-alert-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Metric dimension for filtering\n */\nexport interface MetricDimension {\n  /**\n   * The dimension name\n   */\n  readonly name: string;\n\n  /**\n   * The operator (Include or Exclude)\n   */\n  readonly operator: \"Include\" | \"Exclude\";\n\n  /**\n   * The dimension values\n   */\n  readonly values: string[];\n}\n\n/**\n * Static threshold criteria configuration\n */\nexport interface StaticThresholdCriteria {\n  /**\n   * The criteria type\n   */\n  readonly type: \"StaticThreshold\";\n\n  /**\n   * The metric name\n   */\n  readonly metricName: string;\n\n  /**\n   * The metric namespace (optional)\n   */\n  readonly metricNamespace?: string;\n\n  /**\n   * The comparison operator\n   */\n  readonly operator:\n    | \"GreaterThan\"\n    | \"LessThan\"\n    | \"GreaterOrEqual\"\n    | \"LessOrEqual\"\n    | \"Equals\";\n\n  /**\n   * The threshold value\n   */\n  readonly threshold: number;\n\n  /**\n   * The time aggregation method\n   */\n  readonly timeAggregation:\n    | \"Average\"\n    | \"Count\"\n    | \"Minimum\"\n    | \"Maximum\"\n    | \"Total\";\n\n  /**\n   * Metric dimensions for filtering (optional)\n   */\n  readonly dimensions?: MetricDimension[];\n}\n\n/**\n * Metric alert failing periods configuration\n */\nexport interface MetricAlertFailingPeriods {\n  /**\n   * Number of evaluation periods\n   */\n  readonly numberOfEvaluationPeriods: number;\n\n  /**\n   * Minimum failing periods to trigger alert\n   */\n  readonly minFailingPeriodsToAlert: number;\n}\n\n/**\n * Dynamic threshold criteria configuration\n */\nexport interface DynamicThresholdCriteria {\n  /**\n   * The criteria type\n   */\n  readonly type: \"DynamicThreshold\";\n\n  /**\n   * The metric name\n   */\n  readonly metricName: string;\n\n  /**\n   * The metric namespace (optional)\n   */\n  readonly metricNamespace?: string;\n\n  /**\n   * The comparison operator\n   */\n  readonly operator: \"GreaterThan\" | \"LessThan\" | \"GreaterOrLessThan\";\n\n  /**\n   * The alert sensitivity (Low, Medium, High)\n   */\n  readonly alertSensitivity: \"Low\" | \"Medium\" | \"High\";\n\n  /**\n   * Failing periods configuration\n   */\n  readonly failingPeriods: MetricAlertFailingPeriods;\n\n  /**\n   * The time aggregation method\n   */\n  readonly timeAggregation:\n    | \"Average\"\n    | \"Count\"\n    | \"Minimum\"\n    | \"Maximum\"\n    | \"Total\";\n\n  /**\n   * Metric dimensions for filtering (optional)\n   */\n  readonly dimensions?: MetricDimension[];\n\n  /**\n   * Ignore data before this date (ISO 8601 format)\n   */\n  readonly ignoreDataBefore?: string;\n}\n\n/**\n * Metric alert action configuration\n */\nexport interface MetricAlertAction {\n  /**\n   * The action group resource ID\n   */\n  readonly actionGroupId: string;\n\n  /**\n   * Webhook properties (optional)\n   */\n  readonly webHookProperties?: { [key: string]: string };\n}\n\n/**\n * Properties for the unified Azure Metric Alert\n *\n * Extends AzapiResourceProps with Metric Alert specific properties\n */\nexport interface MetricAlertProps extends AzapiResourceProps {\n  /**\n   * Description of the alert rule\n   */\n  readonly description?: string;\n\n  /**\n   * Alert severity (0=Critical, 1=Error, 2=Warning, 3=Informational, 4=Verbose)\n   * @example 2\n   */\n  readonly severity: 0 | 1 | 2 | 3 | 4;\n\n  /**\n   * Whether the alert rule is enabled\n   * @defaultValue true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Resource IDs that this alert is scoped to\n   * @example [\"/subscriptions/.../resourceGroups/.../providers/Microsoft.Compute/virtualMachines/myVM\"]\n   */\n  readonly scopes: string[];\n\n  /**\n   * How often the alert is evaluated (ISO 8601 duration)\n   * @defaultValue \"PT5M\"\n   * @example \"PT1M\", \"PT5M\", \"PT15M\"\n   */\n  readonly evaluationFrequency?: string;\n\n  /**\n   * Time window for aggregation (ISO 8601 duration)\n   * @defaultValue \"PT15M\"\n   * @example \"PT5M\", \"PT15M\", \"PT30M\", \"PT1H\"\n   */\n  readonly windowSize?: string;\n\n  /**\n   * Resource type of the target (for multi-resource alerts)\n   * @example \"Microsoft.Compute/virtualMachines\"\n   */\n  readonly targetResourceType?: string;\n\n  /**\n   * Region of the target resource (for multi-resource alerts)\n   * @example \"eastus\"\n   */\n  readonly targetResourceRegion?: string;\n\n  /**\n   * Alert criteria (static or dynamic threshold)\n   */\n  readonly criteria: StaticThresholdCriteria | DynamicThresholdCriteria;\n\n  /**\n   * Action groups to notify\n   */\n  readonly actions?: MetricAlertAction[];\n\n  /**\n   * Auto-resolve alerts when condition is no longer met\n   * @defaultValue true\n   */\n  readonly autoMitigate?: boolean;\n\n  /**\n   * Resource group ID where the metric alert will be created\n   */\n  readonly resourceGroupId?: string;\n}\n\n/**\n * Metric Alert properties for the request body\n */\nexport interface MetricAlertBodyProperties {\n  readonly description?: string;\n  readonly severity: number;\n  readonly enabled: boolean;\n  readonly scopes: string[];\n  readonly evaluationFrequency: string;\n  readonly windowSize: string;\n  readonly targetResourceType?: string;\n  readonly targetResourceRegion?: string;\n  readonly criteria: any;\n  readonly actions?: MetricAlertAction[];\n  readonly autoMitigate: boolean;\n}\n\n/**\n * The resource body interface for Azure Metric Alert API calls\n */\nexport interface MetricAlertBody {\n  readonly location: string;\n  readonly tags?: { [key: string]: string };\n  readonly properties: MetricAlertBodyProperties;\n}\n\n/**\n * Unified Azure Metric Alert implementation\n *\n * This class provides a single, version-aware implementation that automatically handles version\n * resolution, schema validation, and property transformation while maintaining full JSII compliance.\n *\n * Metric Alerts monitor Azure resource metrics and trigger notifications when thresholds are breached.\n * They support both static thresholds and dynamic thresholds based on machine learning.\n *\n * @example\n * // Static threshold alert for VM CPU:\n * const cpuAlert = new MetricAlert(this, \"high-cpu\", {\n *   name: \"vm-high-cpu-alert\",\n *   resourceGroupId: resourceGroup.id,\n *   severity: 2,\n *   scopes: [virtualMachine.id],\n *   criteria: {\n *     type: \"StaticThreshold\",\n *     metricName: \"Percentage CPU\",\n *     operator: \"GreaterThan\",\n *     threshold: 80,\n *     timeAggregation: \"Average\"\n *   },\n *   actions: [{\n *     actionGroupId: actionGroup.id\n *   }]\n * });\n *\n * @example\n * // Dynamic threshold alert with machine learning:\n * const dynamicAlert = new MetricAlert(this, \"dynamic-cpu\", {\n *   name: \"vm-dynamic-cpu-alert\",\n *   resourceGroupId: resourceGroup.id,\n *   severity: 2,\n *   scopes: [resourceGroup.id],\n *   targetResourceType: \"Microsoft.Compute/virtualMachines\",\n *   targetResourceRegion: \"eastus\",\n *   criteria: {\n *     type: \"DynamicThreshold\",\n *     metricName: \"Percentage CPU\",\n *     operator: \"GreaterThan\",\n *     alertSensitivity: \"Medium\",\n *     failingPeriods: {\n *       numberOfEvaluationPeriods: 4,\n *       minFailingPeriodsToAlert: 3\n *     },\n *     timeAggregation: \"Average\"\n *   },\n *   actions: [{\n *     actionGroupId: actionGroup.id\n *   }]\n * });\n *\n * @stability stable\n */\nexport class MetricAlert extends AzapiResource {\n  /**\n   * Static initialization flag to ensure schemas are registered only once\n   */\n  private static schemasRegistered = false;\n\n  /**\n   * Ensures that Metric Alert schemas are registered with the ApiVersionManager\n   * This is called once during the first MetricAlert instantiation\n   */\n  private static ensureSchemasRegistered(): void {\n    if (MetricAlert.schemasRegistered) {\n      return;\n    }\n\n    const apiVersionManager = ApiVersionManager.instance();\n\n    try {\n      // Register all Metric Alert versions\n      apiVersionManager.registerResourceType(\n        METRIC_ALERT_TYPE,\n        ALL_METRIC_ALERT_VERSIONS,\n      );\n\n      MetricAlert.schemasRegistered = true;\n\n      console.log(\n        `Registered ${ALL_METRIC_ALERT_VERSIONS.length} API versions for ${METRIC_ALERT_TYPE}`,\n      );\n    } catch (error) {\n      console.warn(\n        `Failed to register Metric Alert schemas: ${error}. ` +\n          `This may indicate the schemas are already registered or there's a configuration issue.`,\n      );\n      MetricAlert.schemasRegistered = true;\n    }\n  }\n\n  /**\n   * The input properties for this Metric Alert instance\n   */\n  public readonly props: MetricAlertProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n\n  // Public properties\n  public readonly id: string;\n\n  /**\n   * Creates a new Azure Metric Alert using the AzapiResource framework\n   *\n   * The constructor automatically handles version resolution, schema registration,\n   * validation, and resource creation.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Metric Alert\n   */\n  constructor(scope: Construct, id: string, props: MetricAlertProps) {\n    // Ensure schemas are registered before calling super\n    MetricAlert.ensureSchemasRegistered();\n\n    // Call the parent constructor with the props\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n    this.id = `\\${${this.terraformResource.fqn}.id}`;\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Metric Alert\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Metric Alert\",\n    });\n\n    // Override logical IDs\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   * Returns the most recent stable version as the default\n   */\n  protected defaultVersion(): string {\n    return \"2018-03-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Metric Alerts\n   */\n  protected resourceType(): string {\n    return METRIC_ALERT_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   * Uses the framework's schema resolution to get the appropriate schema\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   * Transforms the input properties into the JSON format expected by Azure REST API\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as MetricAlertProps;\n\n    // Transform criteria based on type\n    let transformedCriteria: any;\n    if (typedProps.criteria.type === \"StaticThreshold\") {\n      transformedCriteria = {\n        \"odata.type\":\n          \"Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria\",\n        allOf: [\n          {\n            criterionType: \"StaticThresholdCriterion\",\n            name: \"metric1\",\n            metricName: typedProps.criteria.metricName,\n            metricNamespace: typedProps.criteria.metricNamespace,\n            operator: typedProps.criteria.operator,\n            threshold: typedProps.criteria.threshold,\n            timeAggregation: typedProps.criteria.timeAggregation,\n            dimensions: typedProps.criteria.dimensions || [],\n          },\n        ],\n      };\n    } else {\n      transformedCriteria = {\n        \"odata.type\":\n          \"Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria\",\n        allOf: [\n          {\n            criterionType: \"DynamicThresholdCriterion\",\n            name: \"metric1\",\n            metricName: typedProps.criteria.metricName,\n            metricNamespace: typedProps.criteria.metricNamespace,\n            operator: typedProps.criteria.operator,\n            alertSensitivity: typedProps.criteria.alertSensitivity,\n            failingPeriods: typedProps.criteria.failingPeriods,\n            timeAggregation: typedProps.criteria.timeAggregation,\n            dimensions: typedProps.criteria.dimensions || [],\n            ignoreDataBefore: typedProps.criteria.ignoreDataBefore,\n          },\n        ],\n      };\n    }\n\n    return {\n      location: \"global\",\n      tags: typedProps.tags || {},\n      properties: {\n        description: typedProps.description,\n        severity: typedProps.severity,\n        enabled: typedProps.enabled !== undefined ? typedProps.enabled : true,\n        scopes: typedProps.scopes,\n        evaluationFrequency: typedProps.evaluationFrequency || \"PT5M\",\n        windowSize: typedProps.windowSize || \"PT15M\",\n        targetResourceType: typedProps.targetResourceType,\n        targetResourceRegion: typedProps.targetResourceRegion,\n        criteria: transformedCriteria,\n        actions: typedProps.actions || [],\n        autoMitigate:\n          typedProps.autoMitigate !== undefined\n            ? typedProps.autoMitigate\n            : true,\n      },\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR METRIC ALERT OPERATIONS\n  // =============================================================================\n\n  /**\n   * Add a tag to the Metric Alert\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public addTag(key: string, value: string): void {\n    if (!this.props.tags) {\n      (this.props as any).tags = {};\n    }\n    this.props.tags![key] = value;\n  }\n\n  /**\n   * Remove a tag from the Metric Alert\n   * Note: This modifies the construct props but requires a new deployment to take effect\n   */\n  public removeTag(key: string): void {\n    if (this.props.tags && this.props.tags[key]) {\n      delete this.props.tags[key];\n    }\n  }\n}\n"]}

package/lib/azure-metricalert/test/metric-alert.integ.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration test for Azure Metric Alert construct
+ *
+ * This test demonstrates basic usage of the MetricAlert construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-metricalert/test/metric-alert.integ.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Integration test for Azure Metric Alert construct
+ *
+ * This test demonstrates basic usage of the MetricAlert construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_actiongroup_1 = require("../../azure-actiongroup");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const azure_storageaccount_1 = require("../../azure-storageaccount");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const metric_alert_1 = require("../lib/metric-alert");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("metric-alert-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating MetricAlert usage
+ */
+class MetricAlertExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Generate unique names
+        const rgName = this.generateResourceName("Microsoft.Resources/resourceGroups", "metricalert");
+        const storageName = this.generateResourceName("Microsoft.Storage/storageAccounts", "alert");
+        // Create resource group
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "rg", {
+            name: rgName,
+            location: "eastus",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        // Create action group for alert notifications
+        const actionGroup = new azure_actiongroup_1.ActionGroup(this, "actiongroup", {
+            name: "actiongroup-example",
+            resourceGroupId: resourceGroup.id,
+            apiVersion: "2021-09-01",
+            groupShortName: "Example",
+            enabled: true,
+            emailReceivers: [
+                {
+                    name: "email-example",
+                    emailAddress: "test@example.com",
+                    useCommonAlertSchema: true,
+                },
+            ],
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+        // Create storage account to monitor
+        const storageAccount = new azure_storageaccount_1.StorageAccount(this, "storage", {
+            name: storageName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: { name: "Standard_LRS" },
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+        // Create metric alert with static threshold monitoring storage account
+        new metric_alert_1.MetricAlert(this, "metricalert", {
+            name: "metricalert-example",
+            resourceGroupId: resourceGroup.id,
+            apiVersion: "2018-03-01",
+            description: "Alert when storage account availability is low",
+            severity: 2,
+            enabled: true,
+            scopes: [storageAccount.id],
+            evaluationFrequency: "PT5M",
+            windowSize: "PT15M",
+            criteria: {
+                type: "StaticThreshold",
+                metricName: "Availability",
+                metricNamespace: "Microsoft.Storage/storageAccounts",
+                operator: "LessThan",
+                threshold: 99,
+                timeAggregation: "Average",
+            },
+            actions: [
+                {
+                    actionGroupId: actionGroup.id,
+                },
+            ],
+            autoMitigate: true,
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+    }
+}
+describe("MetricAlert Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup metric alert resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new MetricAlertExampleStack(app, "test-metricalert");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-alert.integ.js","sourceRoot":"","sources":["../../../src/azure-metricalert/test/metric-alert.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Metric Alert construct\n *\n * This test demonstrates basic usage of the MetricAlert construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Run with: npm run integration:nostream\n */\n\nimport { Testing } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport \"cdktf/lib/testing/adapters/jest\";\nimport { ActionGroup } from \"../../azure-actiongroup\";\nimport { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { StorageAccount } from \"../../azure-storageaccount\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { MetricAlert } from \"../lib/metric-alert\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"metric-alert-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating MetricAlert usage\n */\nclass MetricAlertExampleStack extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id, {\n      testRunOptions: {\n        maxAgeHours: testMetadata.maxAgeHours,\n        autoCleanup: testMetadata.autoCleanup,\n        cleanupPolicy: testMetadata.cleanupPolicy,\n      },\n    });\n\n    // Configure AZAPI provider\n    new AzapiProvider(this, \"azapi\", {});\n\n    // Generate unique names\n    const rgName = this.generateResourceName(\n      \"Microsoft.Resources/resourceGroups\",\n      \"metricalert\",\n    );\n    const storageName = this.generateResourceName(\n      \"Microsoft.Storage/storageAccounts\",\n      \"alert\",\n    );\n\n    // Create resource group\n    const resourceGroup = new ResourceGroup(this, \"rg\", {\n      name: rgName,\n      location: \"eastus\",\n      tags: {\n        ...this.systemTags(),\n      },\n    });\n\n    // Create action group for alert notifications\n    const actionGroup = new ActionGroup(this, \"actiongroup\", {\n      name: \"actiongroup-example\",\n      resourceGroupId: resourceGroup.id,\n      apiVersion: \"2021-09-01\",\n      groupShortName: \"Example\",\n      enabled: true,\n      emailReceivers: [\n        {\n          name: \"email-example\",\n          emailAddress: \"test@example.com\",\n          useCommonAlertSchema: true,\n        },\n      ],\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n    });\n\n    // Create storage account to monitor\n    const storageAccount = new StorageAccount(this, \"storage\", {\n      name: storageName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      sku: { name: \"Standard_LRS\" },\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n    });\n\n    // Create metric alert with static threshold monitoring storage account\n    new MetricAlert(this, \"metricalert\", {\n      name: \"metricalert-example\",\n      resourceGroupId: resourceGroup.id,\n      apiVersion: \"2018-03-01\",\n      description: \"Alert when storage account availability is low\",\n      severity: 2,\n      enabled: true,\n      scopes: [storageAccount.id],\n      evaluationFrequency: \"PT5M\",\n      windowSize: \"PT15M\",\n      criteria: {\n        type: \"StaticThreshold\",\n        metricName: \"Availability\",\n        metricNamespace: \"Microsoft.Storage/storageAccounts\",\n        operator: \"LessThan\",\n        threshold: 99,\n        timeAggregation: \"Average\",\n      },\n      actions: [\n        {\n          actionGroupId: actionGroup.id,\n        },\n      ],\n      autoMitigate: true,\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n    });\n  }\n}\n\ndescribe(\"MetricAlert Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup metric alert resources\", () => {\n    const app = Testing.app();\n    const stack = new MetricAlertExampleStack(app, \"test-metricalert\");\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources\n    // 2. Run terraform plan to check idempotency (no changes expected)\n    // 3. Run terraform destroy to cleanup resources\n    TerraformApplyCheckAndDestroy(synthesized, { verifyCleanup: true });\n  }, 600000); // 10 minute timeout for deployment and cleanup\n});\n"]}

package/lib/azure-metricalert/test/metric-alert.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive tests for the MetricAlert implementation
+ *
+ * This test suite validates the MetricAlert class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * static and dynamic threshold configurations, dimension filtering, multi-resource alerts,
+ * property transformation, and resource creation.
+ */
+export {};