pangea 0.0.45 → 0.0.46

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

@@ -1,139 +0,0 @@
-# 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
-        # Metric transformation configuration
-        class MetricTransformation < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          attribute :name, Resources::Types::String
-          attribute :namespace, Resources::Types::String
-          attribute :value, Resources::Types::String
-          attribute :default_value, Resources::Types::Float.optional.default(nil)
-          attribute :dimensions, Resources::Types::Hash.default({}.freeze)
-          attribute :unit, Resources::Types::String.optional.default(nil).enum(
-            'None', 'Seconds', 'Microseconds', 'Milliseconds', 'Bytes', 'Kilobytes', 
-            'Megabytes', 'Gigabytes', 'Terabytes', 'Bits', 'Kilobits', 'Megabits', 
-            'Gigabits', 'Terabits', 'Percent', 'Count', 'Bytes/Second', 
-            'Kilobytes/Second', 'Megabytes/Second', 'Gigabytes/Second', 
-            'Terabytes/Second', 'Bits/Second', 'Kilobits/Second', 'Megabits/Second', 
-            'Gigabits/Second', 'Terabits/Second', 'Count/Second', nil
-          )
-          
-          def to_h
-            hash = {
-              name: name,
-              namespace: namespace,
-              value: value
-            }
-            
-            hash[:default_value] = default_value if default_value
-            hash[:dimensions] = dimensions if dimensions.any?
-            hash[:unit] = unit if unit
-            
-            hash.compact
-          end
-        end
-        
-        # CloudWatch Log Metric Filter resource attributes with validation
-        class CloudWatchLogMetricFilterAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          # Required attributes
-          attribute :name, Resources::Types::String
-          attribute :log_group_name, Resources::Types::String
-          attribute :pattern, Resources::Types::String
-          attribute :metric_transformation, MetricTransformation
-          
-          # Validate filter pattern and metric configuration
-          def self.new(attributes)
-            attrs = attributes.is_a?(Hash) ? attributes : {}
-            
-            # Validate name format
-            if attrs[:name] && !attrs[:name].match?(/^[\.\-_#A-Za-z0-9]+$/)
-              raise Dry::Struct::Error, "name must contain only alphanumeric characters, periods, hyphens, underscores, and hash"
-            end
-            
-            # Validate pattern is not empty
-            if attrs[:pattern] && attrs[:pattern].strip.empty?
-              raise Dry::Struct::Error, "pattern cannot be empty"
-            end
-            
-            # Convert metric_transformation to MetricTransformation if needed
-            if attrs[:metric_transformation] && !attrs[:metric_transformation].is_a?(MetricTransformation)
-              attrs[:metric_transformation] = MetricTransformation.new(attrs[:metric_transformation])
-            end
-            
-            # Validate metric value syntax
-            if attrs[:metric_transformation]
-              value = attrs[:metric_transformation][:value] || attrs[:metric_transformation].value
-              if value && !value.match?(/^\$?[\w\.\[\]]+$/)
-                raise Dry::Struct::Error, "metric_transformation.value must be a valid metric value expression"
-              end
-            end
-            
-            super(attrs)
-          end
-          
-          # Computed properties
-          def pattern_type
-            case pattern
-            when /^\[/ then :space_delimited
-            when /\{.*\}/ then :json
-            when /\w+\s*=\s*/ then :key_value
-            else :text
-            end
-          end
-          
-          def extracts_numeric_value?
-            metric_transformation.value.start_with?('$')
-          end
-          
-          def has_dimensions?
-            metric_transformation.dimensions.any?
-          end
-          
-          def has_default_value?
-            !metric_transformation.default_value.nil?
-          end
-          
-          def metric_namespace
-            metric_transformation.namespace
-          end
-          
-          def metric_name
-            metric_transformation.name
-          end
-          
-          def to_h
-            {
-              name: name,
-              log_group_name: log_group_name,
-              pattern: pattern,
-              metric_transformation: metric_transformation.to_h
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_cloudwatch_log_resource_policy/resource.rb

@@ -1,82 +0,0 @@
-# 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 'pangea/resources/base'
-require 'pangea/resources/reference'
-
-module Pangea
-  module Resources
-    module AWS
-      # Type-safe resource function for AWS CloudWatch Log Resource Policy
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] Resource attributes following AWS provider schema
-      # @return [Pangea::Resources::Reference] Resource reference for chaining
-      # 
-      # @see https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/cloudwatch_log_resource_policy
-      #
-      # @example Basic log resource policy for cross-service access
-      #   aws_cloudwatch_log_resource_policy(:api_gateway_policy, {
-      #     policy_name: "ApiGatewayLogsResourcePolicy",
-      #     policy_document: jsonencode({
-      #       Version: "2012-10-17",
-      #       Statement: [{
-      #         Effect: "Allow",
-      #         Principal: { Service: "apigateway.amazonaws.com" },
-      #         Action: "logs:CreateLogStream",
-      #         Resource: "arn:aws:logs:*:*:*"
-      #       }]
-      #     })
-      #   })
-      #
-      # @example Route53 resolver query logging policy
-      #   aws_cloudwatch_log_resource_policy(:route53_resolver, {
-      #     policy_name: "Route53ResolverQueryLogging",
-      #     policy_document: policy_doc_ref.json
-      #   })
-      def aws_cloudwatch_log_resource_policy(name, attributes)
-        transformed = Base.transform_attributes(attributes, {
-          policy_name: {
-            description: "Name of the resource policy",
-            type: :string,
-            required: true
-          },
-          policy_document: {
-            description: "JSON policy document specifying permissions",
-            type: :string,
-            required: true
-          }
-        })
-
-        resource_block = resource(:aws_cloudwatch_log_resource_policy, name, transformed)
-        
-        Reference.new(
-          type: :aws_cloudwatch_log_resource_policy,
-          name: name,
-          attributes: {
-            id: "#{resource_block}.id",
-            policy_name: "#{resource_block}.policy_name",
-            policy_document: "#{resource_block}.policy_document"
-          },
-          resource: resource_block
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,260 +0,0 @@
-# AWS CloudWatch Log Stream Implementation
-
-## Overview
-
-This implementation provides type-safe AWS CloudWatch Log Stream resources with intelligent stream type detection and enterprise logging organization patterns.
-
-## Architecture
-
-### Type System
-- **`CloudWatchLogStreamAttributes`**: dry-struct validation with CloudWatch-specific constraints
-- **Name Validation**: AWS log stream naming pattern enforcement (more restrictive than log groups)
-- **Stream Type Detection**: Automatic detection of Lambda, ECS, and application streams
-- **Hierarchy Analysis**: Log group path decomposition for organizational insights
-
-### Key Features
-
-#### 1. Enhanced Name Validation
-- Stricter character set validation than log groups
-- Supports colons (`:`) in addition to log group valid characters
-- Prevents colon at start/end and consecutive colons
-- Maintains forward slash path validation
-
-#### 2. Intelligent Stream Type Detection
-- **Lambda Detection**: Identifies Lambda-generated stream patterns (`[version]` notation)
-- **ECS Detection**: Recognizes ECS service stream patterns (`ecs/` prefix)
-- **Application Streams**: Default category for custom application streams
-
-#### 3. Log Group Integration
-- Validates log group name using same rules as log group resource
-- Provides hierarchy analysis for organizational insights
-- Supports referencing existing log groups
-
-#### 4. Organizational Intelligence
-- Stream type classification for monitoring patterns
-- Hierarchy decomposition for structured analysis
-- Naming pattern recognition for automated tooling
-
-## Implementation Details
-
-### Validation Logic
-
-#### Log Stream Name Validation
-```ruby
-# Extended character set including colons
-name.match?(/\A[a-zA-Z0-9._\-:\/]+\z/)
-
-# Colon restrictions
-name.start_with?(':')  # Forbidden
-name.end_with?(':')    # Forbidden
-name.include?('::')    # Forbidden consecutive colons
-
-# Path validation (inherited from log groups)
-name.include?('//')    # Forbidden consecutive slashes
-```
-
-#### Log Group Name Validation
-```ruby
-# Same validation as log group resource
-log_group_name.match?(/\A[a-zA-Z0-9._\-\/]+\z/)
-log_group_name.length <= 512
-!log_group_name.empty?
-```
-
-### Stream Type Detection Algorithm
-
-```ruby
-def stream_type
-  return 'lambda' if is_lambda_stream?
-  return 'ecs' if is_ecs_stream?
-  'application'
-end
-
-def is_lambda_stream?
-  name.include?('[') && name.include?(']')  # Lambda version notation
-end
-
-def is_ecs_stream?
-  name.start_with?('ecs/')  # ECS service prefix
-end
-```
-
-### Hierarchy Analysis
-
-```ruby
-def log_group_hierarchy
-  log_group_name.split('/').reject(&:empty?)
-end
-
-# Example: "/aws/lambda/function-name" => ["aws", "lambda", "function-name"]
-# Example: "/application/web-servers" => ["application", "web-servers"]
-```
-
-### Computed Properties
-
-1. **`is_lambda_stream?`**: Boolean indicating Lambda-generated stream pattern
-2. **`is_ecs_stream?`**: Boolean indicating ECS-generated stream pattern  
-3. **`is_application_stream?`**: Boolean indicating custom application stream
-4. **`stream_type`**: String classification (`lambda`, `ecs`, `application`)
-5. **`log_group_hierarchy`**: Array of log group path components
-
-### Terraform Resource Mapping
-
-```ruby
-resource(:aws_cloudwatch_log_stream, name) do
-  name_attr log_stream_attrs.name              # Required
-  log_group_name log_stream_attrs.log_group_name  # Required
-end
-```
-
-### Resource Reference Outputs
-
-```ruby
-outputs: {
-  arn: "${aws_cloudwatch_log_stream.#{name}.arn}",
-  name: "${aws_cloudwatch_log_stream.#{name}.name}",
-  log_group_name: "${aws_cloudwatch_log_stream.#{name}.log_group_name}"
-}
-```
-
-## Enterprise Patterns
-
-### 1. Multi-Instance Application Streams
-- Consistent naming patterns across instances
-- Instance ID integration for debugging
-- Separate streams for different log types per instance
-
-### 2. Microservices Stream Organization
-- Service-based stream grouping
-- Instance replica stream management
-- Performance and application log separation
-
-### 3. AWS Service Integration Streams
-- Lambda execution stream patterns
-- ECS task-based stream organization
-- Load balancer and database log streams
-
-### 4. Time-Based Stream Management
-- Date-based stream naming for rotation
-- Session-based stream identification
-- Automatic timestamp integration
-
-## Stream Naming Conventions
-
-### Lambda Stream Patterns
-```ruby
-# AWS Lambda automatic pattern
-"YYYY/MM/DD/[$LATEST]xxxxxxxxx"
-"YYYY/MM/DD/[version]xxxxxxxxx"
-
-# Custom Lambda stream
-"scheduled-execution/YYYY/MM/DD"
-```
-
-### ECS Stream Patterns  
-```ruby
-# ECS service pattern
-"ecs/service-name/task-revision/container"
-"ecs/service-name/instance-id"
-
-# Custom ECS pattern
-"ecs/web-service/#{task_definition_revision}/task-#{task_id}"
-```
-
-### Application Stream Patterns
-```ruby
-# Instance-based
-"#{instance_id}/#{log_type}"
-"server-01/application"
-"worker-03/errors"
-
-# Service-based
-"#{service}/#{environment}/#{component}"
-"api/production/access-logs"
-"worker/staging/processing"
-
-# Time-based
-"#{service}/#{date}/#{session}"
-"user-service/2023-12-01/session-abc123"
-```
-
-## Stream Type Detection Benefits
-
-### 1. Monitoring Automation
-- Automatic metric creation based on stream type
-- Type-specific log parsing and analysis
-- Service-aware alerting configuration
-
-### 2. Cost Analysis
-- Stream type cost attribution
-- Service-specific usage analysis
-- Lambda vs ECS vs application cost breakdown
-
-### 3. Operational Intelligence
-- Stream lifecycle management
-- Type-specific retention policies
-- Service-aware log aggregation
-
-### 4. Security and Compliance
-- Stream type access controls
-- Service-specific audit requirements
-- Type-based encryption policies
-
-## Validation Error Messages
-
-The implementation provides clear error messages for validation failures:
-
-- Character set violations with supported characters
-- Colon usage restrictions with examples
-- Length constraints with AWS limits
-- Log group name validation with pattern requirements
-
-## Integration Patterns
-
-### 1. Reference-Based Integration
-```ruby
-# Reference existing log group
-log_stream = aws_cloudwatch_log_stream(:app_stream, {
-  name: "instance-001/application",
-  log_group_name: app_log_group.name  # Reference
-})
-```
-
-### 2. Dynamic Stream Creation
-```ruby
-# Generate streams based on infrastructure
-instances.each_with_index do |instance, index|
-  aws_cloudwatch_log_stream(:"instance_#{index}", {
-    name: "#{instance.id}/application",
-    log_group_name: "/application/#{service_name}"
-  })
-end
-```
-
-### 3. Service Discovery Integration
-```ruby
-# Create streams for service discovery
-services.each do |service|
-  aws_cloudwatch_log_stream(:"#{service}_stream", {
-    name: "#{service}/#{environment}/main",
-    log_group_name: "/services/#{service}"
-  })
-end
-```
-
-## Testing Considerations
-
-The implementation supports testing through:
-- Deterministic stream type detection
-- Predictable hierarchy analysis  
-- Clear validation rules with specific error messages
-- Type safety through dry-struct validation
-- Computed properties for testing stream classification
-
-## Best Practices Encoded
-
-1. **Naming Consistency**: Enforced naming patterns across stream types
-2. **Type Detection**: Automatic classification for operational tooling
-3. **Hierarchy Analysis**: Path decomposition for organizational insights
-4. **Integration Support**: Reference-based log group integration
-5. **Validation Clarity**: Clear error messages for troubleshooting

data/lib/pangea/resources/aws_cloudwatch_log_stream/resource.rb

@@ -1,90 +0,0 @@
-# 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 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_cloudwatch_log_stream/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS CloudWatch Log Stream with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] CloudWatch Log Stream attributes
-      # @option attributes [String] :name The name of the log stream
-      # @option attributes [String] :log_group_name The name of the log group
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      #
-      # @example Basic log stream
-      #   log_stream = aws_cloudwatch_log_stream(:app_stream, {
-      #     name: "application-instance-001",
-      #     log_group_name: log_group.name
-      #   })
-      #
-      # @example Lambda log stream
-      #   lambda_stream = aws_cloudwatch_log_stream(:lambda_stream, {
-      #     name: "2023/12/01/[$LATEST]abcd1234567890",
-      #     log_group_name: "/aws/lambda/my-function"
-      #   })
-      #
-      # @example ECS task log stream
-      #   ecs_stream = aws_cloudwatch_log_stream(:ecs_task_stream, {
-      #     name: "ecs/web-service/task-id-12345",
-      #     log_group_name: "/ecs/web-service"
-      #   })
-      #
-      # @example Application log stream with timestamp
-      #   app_stream = aws_cloudwatch_log_stream(:timestamped_stream, {
-      #     name: "server-01/#{Time.now.strftime('%Y/%m/%d')}/session-#{SecureRandom.hex(4)}",
-      #     log_group_name: "/application/web-servers"
-      #   })
-      def aws_cloudwatch_log_stream(name, attributes = {})
-        # Validate attributes using dry-struct
-        log_stream_attrs = Types::Types::CloudWatchLogStreamAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_cloudwatch_log_stream, name) do
-          name log_stream_attrs.name
-          log_group_name log_stream_attrs.log_group_name
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_cloudwatch_log_stream',
-          name: name,
-          resource_attributes: log_stream_attrs.to_h,
-          outputs: {
-            arn: "${aws_cloudwatch_log_stream.#{name}.arn}",
-            name: "${aws_cloudwatch_log_stream.#{name}.name}",
-            log_group_name: "${aws_cloudwatch_log_stream.#{name}.log_group_name}"
-          },
-          computed_properties: {
-            is_lambda_stream: log_stream_attrs.is_lambda_stream?,
-            is_ecs_stream: log_stream_attrs.is_ecs_stream?,
-            is_application_stream: log_stream_attrs.is_application_stream?,
-            stream_type: log_stream_attrs.stream_type,
-            log_group_hierarchy: log_stream_attrs.log_group_hierarchy
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)

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

@@ -1,130 +0,0 @@
-# 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
-        # CloudWatch Log Stream resource attributes with validation
-        class CloudWatchLogStreamAttributes < Dry::Struct
-          transform_keys(&:to_sym)
-          
-          # Required attributes
-          attribute :name, Resources::Types::String
-          attribute :log_group_name, Resources::Types::String
-          
-          # Validate log stream name pattern
-          def self.new(attributes)
-            attrs = attributes.is_a?(Hash) ? attributes : {}
-            
-            if attrs[:name]
-              # CloudWatch log stream name validation
-              name = attrs[:name]
-              
-              # Must not be empty
-              if name.empty?
-                raise Dry::Struct::Error, "Log stream name cannot be empty"
-              end
-              
-              # Length constraints
-              if name.length > 512
-                raise Dry::Struct::Error, "Log stream name cannot exceed 512 characters"
-              end
-              
-              # Character validation - more restrictive than log groups
-              # Allows letters, numbers, periods, underscores, hyphens, colons, and forward slashes
-              unless name.match?(/\A[a-zA-Z0-9._\-:\/]+\z/)
-                raise Dry::Struct::Error, "Log stream name can only contain alphanumeric characters, periods, underscores, hyphens, colons, and forward slashes"
-              end
-              
-              # Cannot start with a colon
-              if name.start_with?(':')
-                raise Dry::Struct::Error, "Log stream name cannot start with a colon"
-              end
-              
-              # Cannot end with a colon
-              if name.end_with?(':')
-                raise Dry::Struct::Error, "Log stream name cannot end with a colon"
-              end
-              
-              # Cannot contain consecutive colons
-              if name.include?('::')
-                raise Dry::Struct::Error, "Log stream name cannot contain consecutive colons"
-              end
-              
-              # Cannot contain consecutive forward slashes
-              if name.include?('//')
-                raise Dry::Struct::Error, "Log stream name cannot contain consecutive forward slashes"
-              end
-            end
-            
-            if attrs[:log_group_name]
-              # Log group name validation (same as log group resource)
-              log_group_name = attrs[:log_group_name]
-              
-              if log_group_name.empty?
-                raise Dry::Struct::Error, "Log group name cannot be empty"
-              end
-              
-              if log_group_name.length > 512
-                raise Dry::Struct::Error, "Log group name cannot exceed 512 characters"
-              end
-              
-              unless log_group_name.match?(/\A[a-zA-Z0-9._\-\/]+\z/)
-                raise Dry::Struct::Error, "Log group name can only contain alphanumeric characters, periods, underscores, hyphens, and forward slashes"
-              end
-            end
-            
-            super(attrs)
-          end
-          
-          # Computed properties
-          def is_lambda_stream?
-            name.include?('[') && name.include?(']')
-          end
-          
-          def is_ecs_stream?
-            name.start_with?('ecs/')
-          end
-          
-          def is_application_stream?
-            !is_lambda_stream? && !is_ecs_stream?
-          end
-          
-          def stream_type
-            return 'lambda' if is_lambda_stream?
-            return 'ecs' if is_ecs_stream?
-            'application'
-          end
-          
-          def log_group_hierarchy
-            log_group_name.split('/').reject(&:empty?)
-          end
-          
-          def to_h
-            {
-              name: name,
-              log_group_name: log_group_name
-            }
-          end
-        end
-      end
-    end
-  end
-end