pangea 0.0.42 → 0.0.45

data/lib/pangea/resources/aws_budgets_budget/types.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Budget time unit types
+        BudgetTimeUnit = String.enum('DAILY', 'MONTHLY', 'QUARTERLY', 'ANNUALLY')
+        
+        # Budget type enumeration
+        BudgetType = String.enum('USAGE', 'COST', 'RI_UTILIZATION', 'RI_COVERAGE', 'SAVINGS_PLANS_UTILIZATION', 'SAVINGS_PLANS_COVERAGE')
+        
+        # Cost currency types
+        BudgetCurrency = String.enum('USD', 'EUR', 'GBP', 'JPY', 'CNY', 'CAD', 'AUD', 'BRL', 'INR')
+        
+        # Budget comparison operator
+        BudgetComparisonOperator = String.enum('GREATER_THAN', 'LESS_THAN', 'EQUAL_TO')
+        
+        # Threshold type for budget notifications
+        BudgetThresholdType = String.enum('PERCENTAGE', 'ABSOLUTE_VALUE')
+        
+        # Budget notification type
+        BudgetNotificationType = String.enum('ACTUAL', 'FORECASTED')
+        
+        # Budget subscriber protocol
+        BudgetSubscriberProtocol = String.enum('EMAIL', 'SNS')
+        
+        # Cost dimension key types for budget filters
+        CostDimensionKey = String.enum(
+          'AZ', 'INSTANCE_TYPE', 'LINKED_ACCOUNT', 'OPERATION', 'PURCHASE_TYPE', 
+          'REGION', 'SERVICE', 'USAGE_TYPE', 'USAGE_TYPE_GROUP', 'RECORD_TYPE', 
+          'OPERATING_SYSTEM', 'TENANCY', 'SCOPE', 'PLATFORM', 'SUBSCRIPTION_ID',
+          'LEGAL_ENTITY_NAME', 'DEPLOYMENT_OPTION', 'DATABASE_ENGINE',
+          'CACHE_ENGINE', 'INSTANCE_TYPE_FAMILY', 'BILLING_ENTITY', 'RESERVATION_ID',
+          'RESOURCE_ID', 'RIGHTSIZING_TYPE', 'SAVINGS_PLANS_TYPE', 'SAVINGS_PLAN_ARN',
+          'PAYMENT_OPTION', 'AGREEMENT_END_DATE_TIME_AFTER', 'AGREEMENT_END_DATE_TIME_BEFORE'
+        )
+        
+        # Budget spend definition
+        BudgetSpend = Hash.schema(
+          amount: String.constrained(format: /\A\d+(\.\d{1,2})?\z/).constructor { |value|
+            amount_float = value.to_f
+            if amount_float <= 0
+              raise Dry::Types::ConstraintError, "Budget amount must be positive"
+            end
+            if amount_float > 1000000000 # 1 billion limit
+              raise Dry::Types::ConstraintError, "Budget amount cannot exceed 1 billion"
+            end
+            value
+          },
+          unit: BudgetCurrency
+        )
+        
+        # Time period for budget
+        BudgetTimePeriod = Hash.schema(
+          start?: String.constrained(format: /\A\d{4}-\d{2}-\d{2}\z/).optional,
+          end?: String.constrained(format: /\A\d{4}-\d{2}-\d{2}\z/).optional
+        ).constructor { |value|
+          if value[:start] && value[:end]
+            start_date = Date.parse(value[:start])
+            end_date = Date.parse(value[:end])
+            
+            if end_date <= start_date
+              raise Dry::Types::ConstraintError, "Budget end date must be after start date"
+            end
+            
+            # AWS requires at least 3 months difference for quarterly and annual budgets
+            months_diff = (end_date.year - start_date.year) * 12 + end_date.month - start_date.month
+            if months_diff < 1
+              raise Dry::Types::ConstraintError, "Budget must span at least 1 month"
+            end
+          end
+          
+          value
+        rescue Date::Error
+          raise Dry::Types::ConstraintError, "Budget time period dates must be in YYYY-MM-DD format"
+        end
+        
+        # Cost filter for budget
+        BudgetCostFilter = Hash.schema(
+          dimension_key: CostDimensionKey,
+          values: Array.of(String).constrained(min_size: 1, max_size: 1000),
+          match_options?: Array.of(String.enum('EQUALS', 'ABSENT', 'STARTS_WITH', 'ENDS_WITH', 'CONTAINS', 'CASE_SENSITIVE', 'CASE_INSENSITIVE')).optional
+        )
+        
+        # Tag filter for budget costs
+        BudgetTagFilter = Hash.schema(
+          key: String.constrained(min_size: 1, max_size: 128),
+          values?: Array.of(String).constrained(max_size: 1000).optional,
+          match_options?: Array.of(String.enum('EQUALS', 'ABSENT', 'STARTS_WITH', 'ENDS_WITH', 'CONTAINS', 'CASE_SENSITIVE', 'CASE_INSENSITIVE')).optional
+        )
+        
+        # Cost filters for budget
+        BudgetCostFilters = Hash.schema(
+          and?: Array.of(
+            Hash.schema(
+              dimensions?: Hash.map(CostDimensionKey, Array.of(String)).optional,
+              tags?: Hash.map(String, Array.of(String)).optional,
+              cost_categories?: Hash.map(String, Array.of(String)).optional
+            )
+          ).optional,
+          dimensions?: Hash.map(CostDimensionKey, Array.of(String)).optional,
+          tags?: Hash.map(String, Array.of(String)).optional,
+          cost_categories?: Hash.map(String, Array.of(String)).optional,
+          not?: Hash.schema(
+            dimensions?: Hash.map(CostDimensionKey, Array.of(String)).optional,
+            tags?: Hash.map(String, Array.of(String)).optional,
+            cost_categories?: Hash.map(String, Array.of(String)).optional
+          ).optional
+        )
+        
+        # Budget notification subscriber
+        BudgetSubscriber = Hash.schema(
+          subscription_type: BudgetSubscriberProtocol,
+          address: String.constructor { |value, context|
+            protocol = context[:subscription_type] rescue nil
+            
+            case protocol
+            when 'EMAIL'
+              unless value.match?(/\A[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\z/)
+                raise Dry::Types::ConstraintError, "Email address format is invalid"
+              end
+            when 'SNS'
+              unless value.match?(/\Aarn:aws:sns:[a-z0-9-]+:\d{12}:[a-zA-Z0-9-_]+\z/)
+                raise Dry::Types::ConstraintError, "SNS topic ARN format is invalid"
+              end
+            end
+            
+            value
+          }
+        )
+        
+        # Budget notification configuration
+        BudgetNotification = Hash.schema(
+          notification_type: BudgetNotificationType,
+          comparison_operator: BudgetComparisonOperator,
+          threshold: Numeric.constructor { |value|
+            if value <= 0
+              raise Dry::Types::ConstraintError, "Budget notification threshold must be positive"
+            end
+            if value > 1000000
+              raise Dry::Types::ConstraintError, "Budget notification threshold cannot exceed 1,000,000"
+            end
+            value
+          },
+          threshold_type?: BudgetThresholdType.default('PERCENTAGE').optional,
+          subscribers?: Array.of(BudgetSubscriber).constrained(max_size: 11).optional
+        )
+        
+        # Planned budget limits for cost budgets
+        BudgetPlannedBudgetLimits = Hash.map(
+          String.constrained(format: /\A\d{4}-\d{2}-\d{2}\z/), # Date in YYYY-MM-DD format
+          BudgetSpend
+        ).constructor { |value|
+          # Validate that all dates are valid and in chronological order
+          dates = value.keys.sort
+          dates.each_cons(2) do |prev_date, curr_date|
+            prev_parsed = Date.parse(prev_date)
+            curr_parsed = Date.parse(curr_date)
+            
+            if curr_parsed <= prev_parsed
+              raise Dry::Types::ConstraintError, "Planned budget limit dates must be in chronological order"
+            end
+          end
+          
+          value
+        rescue Date::Error
+          raise Dry::Types::ConstraintError, "Planned budget limit dates must be in YYYY-MM-DD format"
+        end
+        
+        # Auto-adjust data configuration
+        BudgetAutoAdjustData = Hash.schema(
+          auto_adjust_type: String.enum('HISTORICAL', 'FORECAST'),
+          historical_options?: Hash.schema(
+            budget_adjustment_period: Integer.constrained(gteq: 1, lteq: 60),
+            lookback_available_periods?: Integer.constrained(gteq: 1, lteq: 60).optional
+          ).optional
+        ).constructor { |value|
+          if value[:auto_adjust_type] == 'HISTORICAL' && !value[:historical_options]
+            raise Dry::Types::ConstraintError, "Historical auto-adjust type requires historical_options"
+          end
+          value
+        end
+        
+        # Budget resource attributes with comprehensive validation
+        class BudgetAttributes < Dry::Struct
+          transform_keys(&:to_sym)
+          
+          attribute :budget_name, String.constrained(format: /\A[a-zA-Z0-9_\-. ]{1,100}\z/).constructor { |value|
+            # Remove leading/trailing whitespace and validate
+            cleaned = value.strip
+            if cleaned.empty?
+              raise Dry::Struct::Error, "Budget name cannot be empty"
+            end
+            if cleaned != value
+              raise Dry::Struct::Error, "Budget name cannot have leading or trailing whitespace"
+            end
+            cleaned
+          }
+          
+          attribute :budget_type, BudgetType
+          attribute :time_unit, BudgetTimeUnit
+          
+          # Main budget limit
+          attribute :limit_amount, String.constrained(format: /\A\d+(\.\d{1,2})?\z/).constructor { |value|
+            amount_float = value.to_f
+            if amount_float <= 0
+              raise Dry::Struct::Error, "Budget limit amount must be positive"
+            end
+            value
+          }
+          
+          attribute :limit_unit, BudgetCurrency
+          
+          # Optional attributes
+          attribute :time_period?, BudgetTimePeriod.optional
+          attribute :cost_filters?, BudgetCostFilters.optional
+          attribute :planned_budget_limits?, BudgetPlannedBudgetLimits.optional
+          attribute :auto_adjust_data?, BudgetAutoAdjustData.optional
+          attribute :notifications?, Array.of(BudgetNotification).constrained(max_size: 5).optional
+          attribute :tags?, AwsTags.optional
+          
+          # Computed properties for budget analysis
+          def monthly_budget_estimate
+            amount = limit_amount.to_f
+            
+            case time_unit
+            when 'DAILY' then amount * 30
+            when 'MONTHLY' then amount
+            when 'QUARTERLY' then amount / 3
+            when 'ANNUALLY' then amount / 12
+            else amount
+            end
+          end
+          
+          def annual_budget_estimate
+            amount = limit_amount.to_f
+            
+            case time_unit
+            when 'DAILY' then amount * 365
+            when 'MONTHLY' then amount * 12
+            when 'QUARTERLY' then amount * 4
+            when 'ANNUALLY' then amount
+            else amount
+            end
+          end
+          
+          def has_cost_tracking?
+            budget_type == 'COST'
+          end
+          
+          def has_usage_tracking?
+            budget_type == 'USAGE'
+          end
+          
+          def has_ri_tracking?
+            ['RI_UTILIZATION', 'RI_COVERAGE'].include?(budget_type)
+          end
+          
+          def has_savings_plans_tracking?
+            ['SAVINGS_PLANS_UTILIZATION', 'SAVINGS_PLANS_COVERAGE'].include?(budget_type)
+          end
+          
+          def notification_count
+            notifications&.length || 0
+          end
+          
+          def has_email_notifications?
+            return false unless notifications
+            notifications.any? { |n| n[:subscribers]&.any? { |s| s[:subscription_type] == 'EMAIL' } }
+          end
+          
+          def has_sns_notifications?
+            return false unless notifications
+            notifications.any? { |n| n[:subscribers]&.any? { |s| s[:subscription_type] == 'SNS' } }
+          end
+          
+          def cost_optimization_score
+            score = 0
+            
+            # Base points for having a budget
+            score += 20
+            
+            # Points for notifications
+            score += 15 if notification_count > 0
+            score += 10 if has_email_notifications?
+            score += 10 if has_sns_notifications?
+            
+            # Points for cost filtering
+            score += 15 if cost_filters
+            
+            # Points for planned limits
+            score += 10 if planned_budget_limits
+            
+            # Points for auto-adjustment
+            score += 20 if auto_adjust_data
+            
+            # Deduct points for overly broad budgets
+            score -= 5 if !cost_filters && budget_type == 'COST'
+            
+            [score, 100].min
+          end
+          
+          # Financial governance assessment
+          def governance_compliance_level
+            if cost_optimization_score >= 80
+              'EXCELLENT'
+            elsif cost_optimization_score >= 60
+              'GOOD'  
+            elsif cost_optimization_score >= 40
+              'BASIC'
+            else
+              'POOR'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_budgets_budget_action/CLAUDE.md

@@ -0,0 +1,357 @@
+# AWS Budgets Budget Action - Automated Cost Control and Governance
+
+## Resource Overview
+
+The `aws_budgets_budget_action` resource enables sophisticated automated responses to budget threshold breaches, providing comprehensive cost control with built-in risk assessment, governance compliance, and progressive escalation capabilities. This resource transforms passive budget monitoring into active cost management with intelligent automation safeguards.
+
+## Automated Cost Control Architecture
+
+### Action Types and Strategic Applications
+
+**IAM Policy Actions (APPLY_IAM_POLICY)**:
+- **Preventive Cost Control**: Restrict access to expensive services before costs escalate
+- **Granular Permission Management**: Target specific roles, groups, or users
+- **Service-Level Controls**: Block access to costly instance types or regions
+- **Development Environment Restrictions**: Limit non-production resource creation
+
+**Service Control Policy Actions (APPLY_SCP_POLICY)**:  
+- **Organization-Wide Governance**: Apply cost controls across multiple AWS accounts
+- **Compliance Enforcement**: Ensure adherence to cost management policies
+- **Emergency Cost Containment**: Rapid organization-wide service restrictions
+- **Account Segmentation**: Different policies for development, staging, and production
+
+**Systems Manager Document Actions (RUN_SSM_DOCUMENTS)**:
+- **Resource State Management**: Stop, start, or modify AWS resources
+- **Automated Scaling**: Reduce instance sizes or terminate unused resources  
+- **Service Optimization**: Automatically optimize database or compute configurations
+- **Emergency Response**: Immediate resource shutdown for cost containment
+
+### Risk Assessment and Safety Framework
+
+**Automation Risk Scoring Algorithm**:
+```ruby
+def automation_risk_score
+  score = 0
+  
+  # Base automation risk
+  score += 30 if automatic?
+  
+  # Action type risk weighting
+  score += case action_type
+    when 'APPLY_IAM_POLICY' then 25      # Medium risk
+    when 'APPLY_SCP_POLICY' then 40      # High risk - affects entire org
+    when 'RUN_SSM_DOCUMENTS' then 35     # Medium-high risk - changes resources
+  end
+  
+  # Threshold risk assessment
+  score += 10 if action_threshold < 90   # Aggressive thresholds increase risk
+  score -= 5 if action_threshold > 120   # Conservative thresholds reduce risk
+  
+  # Target scope risk
+  score += [target_count * 2, 20].min   # More targets = higher risk (capped)
+  
+  # Risk mitigation factors
+  score -= 10 if has_notifications?      # Notifications reduce risk
+  score -= 5 if manual_approval?         # Manual approval reduces risk
+  
+  [score, 100].min
+end
+```
+
+**Risk Levels and Governance**:
+- **CRITICAL (80+ points)**: Requires extensive safeguards and manual oversight
+- **HIGH (60-79 points)**: Needs approval workflows and comprehensive monitoring
+- **MEDIUM (40-59 points)**: Standard automation with notification requirements
+- **LOW (20-39 points)**: Safe for full automation with basic notifications
+- **MINIMAL (0-19 points)**: Low-impact actions suitable for automatic execution
+
+## Progressive Cost Control Strategies
+
+### Multi-Tier Escalation Framework
+
+**Tier 1 - Early Warning (70-80% threshold)**:
+```ruby
+early_warning = aws_budgets_budget_action(:tier1_warning, {
+  action_threshold: 75.0,
+  approval_model: "AUTOMATIC",
+  action_type: "RUN_SSM_DOCUMENTS",
+  definition: {
+    ssm_action_definition: {
+      ssm_action_type: "STOP_EC2_INSTANCES",
+      instance_ids: development_instances # Stop non-critical resources first
+    }
+  }
+})
+```
+
+**Tier 2 - Service Restrictions (85-95% threshold)**:
+```ruby
+service_restriction = aws_budgets_budget_action(:tier2_restriction, {
+  action_threshold: 90.0,
+  approval_model: "AUTOMATIC",
+  action_type: "APPLY_IAM_POLICY",
+  definition: {
+    iam_action_definition: {
+      policy_arn: "arn:aws:iam::account:policy/RestrictExpensiveServices",
+      roles: ["arn:aws:iam::account:role/DeveloperRole"]
+    }
+  }
+})
+```
+
+**Tier 3 - Emergency Controls (95-100% threshold)**:
+```ruby
+emergency_control = aws_budgets_budget_action(:tier3_emergency, {
+  action_threshold: 100.0,
+  approval_model: "MANUAL", # Critical actions require approval
+  action_type: "APPLY_SCP_POLICY",
+  definition: {
+    scp_action_definition: {
+      policy_id: "p-emergency-cost-control",
+      target_ids: ["ou-development", "ou-testing"]
+    }
+  }
+})
+```
+
+## Advanced Governance Patterns
+
+### Environment-Based Action Strategies
+
+**Development Environment Automation**:
+```ruby
+dev_automation = aws_budgets_budget_action(:dev_cost_control, {
+  approval_model: "AUTOMATIC",     # Safe for full automation
+  action_threshold: 100.0,         # Allow full budget utilization
+  action_type: "RUN_SSM_DOCUMENTS",
+  definition: {
+    ssm_action_definition: {
+      ssm_action_type: "STOP_EC2_INSTANCES",
+      instance_ids: dev_instance_list
+    }
+  },
+  risk_level: "LOW"               # Development has minimal business impact
+})
+```
+
+**Production Environment Safeguards**:
+```ruby
+prod_safeguards = aws_budgets_budget_action(:prod_cost_control, {
+  approval_model: "MANUAL",        # Require human oversight
+  action_threshold: 95.0,          # Conservative threshold
+  action_type: "APPLY_IAM_POLICY", # Less disruptive than resource changes
+  subscribers: [
+    { subscription_type: "EMAIL", address: "production-team@company.com" },
+    { subscription_type: "SNS", address: production_alerts_topic }
+  ],
+  risk_level: "HIGH"              # Production changes need careful review
+})
+```
+
+### Cost Center and Department Controls
+
+**Department-Specific Actions**:
+```ruby
+departments = {
+  "engineering" => {
+    budget: "Engineering-Department-Budget",
+    policy: "EngineeringCostRestrictions",
+    threshold: 95.0,
+    approval: "AUTOMATIC"
+  },
+  "marketing" => {
+    budget: "Marketing-Department-Budget", 
+    policy: "MarketingCostRestrictions",
+    threshold: 90.0,
+    approval: "MANUAL" # Marketing spend needs more oversight
+  }
+}
+
+departments.each do |dept, config|
+  aws_budgets_budget_action(:"#{dept}_cost_action", {
+    budget_name: config[:budget],
+    action_type: "APPLY_IAM_POLICY",
+    approval_model: config[:approval],
+    action_threshold: config[:threshold],
+    definition: {
+      iam_action_definition: {
+        policy_arn: "arn:aws:iam::account:policy/#{config[:policy]}",
+        roles: ["arn:aws:iam::account:role/#{dept.capitalize}Role"]
+      }
+    }
+  })
+end
+```
+
+## Integration with AWS Cost Management Ecosystem
+
+### Cost Explorer Integration
+
+Budget actions complement Cost Explorer analytics by providing automated responses to identified cost anomalies:
+
+```ruby
+# Action triggered by Cost Explorer insights
+explorer_action = aws_budgets_budget_action(:explorer_response, {
+  budget_name: "Cost-Explorer-Insights-Budget",
+  action_type: "APPLY_IAM_POLICY",
+  notification_type: "FORECASTED", # Proactive based on forecasting
+  action_threshold: 110.0,         # Act on projected overruns
+  definition: {
+    iam_action_definition: {
+      policy_arn: "arn:aws:iam::account:policy/RestrictAnomalousServices"
+    }
+  }
+})
+```
+
+### Reserved Instance and Savings Plans Optimization
+
+```ruby
+# RI utilization optimization action
+ri_optimization_action = aws_budgets_budget_action(:ri_optimization, {
+  budget_name: "RI-Utilization-Budget",
+  action_type: "RUN_SSM_DOCUMENTS",
+  notification_type: "ACTUAL",
+  action_threshold: 75.0, # Below 75% RI utilization triggers action
+  definition: {
+    ssm_action_definition: {
+      ssm_action_type: "START_EC2_INSTANCES", # Start additional instances to improve RI utilization
+      parameters: [
+        { name: "InstanceType", value: "reserved_instance_type" },
+        { name: "OptimizeFor", value: "ReservedInstanceUtilization" }
+      ]
+    }
+  }
+})
+```
+
+### Multi-Account Organization Controls
+
+```ruby
+# Organization-wide emergency cost controls
+org_emergency_controls = aws_budgets_budget_action(:org_emergency, {
+  budget_name: "Organization-Master-Budget",
+  action_type: "APPLY_SCP_POLICY",
+  approval_model: "MANUAL", # Organization-wide changes need approval
+  action_threshold: 100.0,
+  definition: {
+    scp_action_definition: {
+      policy_id: "p-emergency-spend-controls",
+      target_ids: [
+        "ou-development-accounts",    # Development organizational unit
+        "ou-testing-accounts",        # Testing organizational unit
+        "123456789012",               # Specific account ID
+        "234567890123"                # Another specific account
+      ]
+    }
+  },
+  subscribers: [
+    { subscription_type: "EMAIL", address: "cloud-governance@company.com" },
+    { subscription_type: "SNS", address: "arn:aws:sns:us-east-1:account:org-alerts" }
+  ]
+})
+```
+
+## Compliance and Audit Framework
+
+### Governance Compliance Scoring
+
+The resource automatically calculates governance compliance based on:
+
+1. **Manual Approval for High-Risk Actions** (25 points)
+2. **Comprehensive Notification System** (25 points)
+3. **Reasonable Threshold Configuration** (20 points) 
+4. **Risk Mitigation Safeguards** (15 points)
+5. **Documentation and Tagging** (15 points)
+
+**Compliance Levels**:
+- **EXCELLENT (90-100%)**: Full governance framework with all safeguards
+- **GOOD (70-89%)**: Strong governance with minor improvements needed
+- **ADEQUATE (50-69%)**: Basic governance requirements met
+- **POOR (0-49%)**: Significant governance gaps requiring attention
+
+### Audit Trail and Monitoring
+
+```ruby
+# Comprehensive audit configuration
+audit_compliant_action = aws_budgets_budget_action(:audit_compliant, {
+  # ... action configuration
+  subscribers: [
+    { subscription_type: "EMAIL", address: "audit-team@company.com" },
+    { subscription_type: "SNS", address: "arn:aws:sns:us-east-1:account:audit-trail" }
+  ],
+  tags: {
+    AuditRequired: "true",
+    ComplianceLevel: "high",
+    ReviewFrequency: "monthly",
+    DataClassification: "internal",
+    BusinessCriticality: "high"
+  }
+})
+```
+
+## Advanced Use Cases
+
+### AI/ML Cost Optimization Integration
+
+```ruby
+# ML-driven cost optimization actions
+ml_cost_optimization = aws_budgets_budget_action(:ml_optimization, {
+  budget_name: "ML-Training-Budget",
+  action_type: "RUN_SSM_DOCUMENTS", 
+  approval_model: "AUTOMATIC",
+  action_threshold: 90.0,
+  definition: {
+    ssm_action_definition: {
+      ssm_action_type: "STOP_EC2_INSTANCES",
+      parameters: [
+        { name: "InstanceFilter", value: "ml-training-*" },
+        { name: "PreserveCheckpoints", value: "true" },
+        { name: "NotificationChannel", value: "ml-team-slack" }
+      ]
+    }
+  }
+})
+```
+
+### Disaster Recovery Cost Controls
+
+```ruby
+# DR environment cost management
+dr_cost_controls = aws_budgets_budget_action(:dr_cost_management, {
+  budget_name: "Disaster-Recovery-Budget",
+  action_type: "APPLY_SCP_POLICY",
+  approval_model: "AUTOMATIC", # DR resources can be scaled down automatically
+  action_threshold: 120.0,     # Higher threshold due to DR criticality
+  definition: {
+    scp_action_definition: {
+      policy_id: "p-dr-cost-optimization",
+      target_ids: ["ou-disaster-recovery"]
+    }
+  }
+})
+```
+
+### Development Lifecycle Cost Management
+
+```ruby
+# Feature branch cost controls
+feature_branch_controls = aws_budgets_budget_action(:feature_branch_cleanup, {
+  budget_name: "Feature-Development-Budget",
+  action_type: "RUN_SSM_DOCUMENTS",
+  approval_model: "AUTOMATIC",
+  action_threshold: 85.0,
+  definition: {
+    ssm_action_definition: {
+      ssm_action_type: "STOP_EC2_INSTANCES",
+      parameters: [
+        { name: "TagFilter", value: "Environment:feature-*" },
+        { name: "AgeFilter", value: "older-than-7-days" },
+        { name: "PreservePersistentData", value: "true" }
+      ]
+    }
+  }
+})
+```
+
+This resource enables intelligent, risk-aware automated cost controls that maintain business continuity while enforcing financial discipline across complex AWS environments.