@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

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

@@ -0,0 +1,252 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricAlert = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * 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 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 {
+    /**
+     * 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
+     *
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
+     *
+     * @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) {
+        // Ensure schemas are registered before calling super
+        MetricAlert.ensureSchemasRegistered();
+        // Call the parent constructor with the props
+        super(scope, id, props);
+        this.props = props;
+        // 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",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Metric Alert",
+        });
+        // 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";
+    }
+    /**
+     * 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,
+            },
+        };
+    }
+    // =============================================================================
+    // 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;
+    }
+    /**
+     * 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.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 {};