cdk-factory 0.19.19__py3-none-any.whl → 0.21.1__py3-none-any.whl

cdk_factory/stack_library/route53/route53_stack.py

@@ -27,6 +27,7 @@ from cdk_factory.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
+
 logger = Logger(service="Route53Stack")
 
 
@@ -48,7 +49,8 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         self.hosted_zone = None
         self.certificate = None
         self.records = {}
-        self._distribution_cache = {}  # Cache for reusing distributions
+        self._local_cache = {}  # Cache for reusing distributions
+        self._missing_configurations = []
 
     def build(self, stack_config: StackConfig, deployment: DeploymentConfig, workload: WorkloadConfig) -> None:
         """Build the Route53 stack"""
@@ -119,7 +121,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         return certificate
 
     def _create_dns_records(self) -> None:
-        self._create_dns_records_old()
+        # self._create_dns_records_old()
         self._create_dns_records_new()
 
     
@@ -128,7 +130,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         # Create a unique cache key from distribution domain and ID
         cache_key = f"{distribution_domain}-{distribution_id}"
         
-        if cache_key not in self._distribution_cache:
+        if cache_key not in self._local_cache:
             # Create the distribution construct with a unique ID
             unique_id = f"CF-{distribution_domain.replace('.', '-').replace('*', 'wildcard')}-{hash(cache_key) % 10000}"
             distribution = cloudfront.Distribution.from_distribution_attributes(
@@ -136,104 +138,108 @@ class Route53Stack(IStack, StandardizedSsmMixin):
                 domain_name=distribution_domain,
                 distribution_id=distribution_id
             )
-            self._distribution_cache[cache_key] = distribution
+            self._local_cache[cache_key] = distribution
             logger.info(f"Created CloudFront distribution construct for {distribution_domain}")
         
-        return self._distribution_cache[cache_key]
+        return self._local_cache[cache_key]
+    
+    def _get_or_create_alb_target(self, record_name: str, target_value: str, load_balancer_zone_id: str, security_group_id: str, load_balancer_dns_name: str) -> targets.LoadBalancerTarget:
+        """Get or create a CloudFront distribution, reusing if already created"""
+        # Create a unique cache key from distribution domain and ID
+        cache_key = f"{record_name}-alb"
+        
+        if cache_key not in self._local_cache:
+            # Create the distribution construct with a unique ID
+            target = targets.LoadBalancerTarget(
+                elbv2.ApplicationLoadBalancer.from_application_load_balancer_attributes(
+                    self, f"ALB-{record_name}",
+                    load_balancer_arn=target_value,
+                    load_balancer_canonical_hosted_zone_id=load_balancer_zone_id,
+                    security_group_id=security_group_id,
+                    load_balancer_dns_name=load_balancer_dns_name,
+                    
+                )
+            )
+            self._local_cache[cache_key] = target
+            logger.info(f"Created ALB target construct for ALB-{record_name}")
+        
+        return self._local_cache[cache_key]
 
     def _create_dns_records_new(self) -> None:
         """Create DNS records based on configuration - generic implementation"""
         
-        missing_configurations = []
+        
 
         for record in self.route53_config.records:
-            record_name = record.get("name", "")
-            record_type = record.get("type", "")
+            t = record.get("type")
+            record_name = self._get_resolved_value(config=record, key="name", record_type=t)
+            record_type = self._get_resolved_value(config=record, key="type", record_type=t)
+            
             
-            if not record_name or not record_type:
-                message = f"Record missing name or type: {record}"
-                logger.warning(message)
-                missing_configurations.append(message)
-                continue
             
             # Handle alias records
             if "alias" in record:
                 alias_config = record["alias"]
-                target_type = alias_config.get("target_type", "")
-                target_value = alias_config.get("target_value", "")
-                hosted_zone_id = alias_config.get("hosted_zone_id", "")
                 
-                unique_id = f"{record_name}-{record_type}"
-                # Handle SSM parameter references in target_value                
-                target_value = self.resolve_ssm_value(self, target_value, unique_id=unique_id)
+                target_type = self._get_resolved_value(config=alias_config, key="target_type", record_type=record_type)
+                target_value = self._get_resolved_value(config=alias_config, key="target_value", record_type=record_type)
+                
+                
                 
-                if not target_type or not target_value:
-                    message = f"Alias record missing target_type or target_value: {record}"
-                    logger.warning(message)
-                    missing_configurations.append(message)
-                    continue
                 
                 # Create appropriate target based on type
                 alias_target = None
                 if target_type == "cloudfront":
                     # CloudFront distribution target
                     distribution_domain = target_value
-                    distribution_id = alias_config.get("distribution_id", "")
-                    if not distribution_id:
-                        message = f"Alias record missing distribution_id: {record}"
-                        logger.warning(message)
-                        missing_configurations.append(message)
-                        continue
+                    distribution_id = self._get_resolved_value(config=alias_config, key="distribution_id", record_type=record_type)
+                    
                     
                     # Get or create the distribution (reuses if already created)
                     distribution = self._get_or_create_cloudfront_distribution(distribution_domain, distribution_id)
                     alias_target = route53.RecordTarget.from_alias(
                         targets.CloudFrontTarget(distribution)
                     )
-                elif target_type == "loadbalancer" or target_type == "alb":
-                    # Load Balancer target
-                    alias_target = route53.RecordTarget.from_alias(
-                        targets.LoadBalancerTarget(
-                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
-                                self, f"ALB-{record_name}",
-                                load_balancer_dns_name=target_value,
-                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
-                            )
-                        )
-                    )
-                elif target_type == "elbv2":
-                    # Generic ELBv2 target
-                    alias_target = route53.RecordTarget.from_alias(
-                        targets.LoadBalancerTarget(
-                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
-                                self, f"ELB-{record_name}",
-                                load_balancer_dns_name=target_value,
-                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
-                            )
-                        )
-                    )
+                elif target_type == "loadbalancer" or target_type == "alb" or target_type == "elbv2":
+                    # ALB alias target using imported load balancer attributes
+
+                    security_group_id=self._get_resolved_value(config=alias_config, key="security_group_id", record_type=record_type)                
+                    load_balancer_dns_name = self._get_resolved_value(config=alias_config, key="load_balancer_dns_name", record_type=record_type)                
+                    load_balancer_zone_id = self._get_resolved_value(config=alias_config, key="load_balancer_zone_id", record_type=record_type)
+                    
+                    
+                    
+                    target = self._get_or_create_alb_target(record_name, target_value, load_balancer_zone_id, security_group_id, load_balancer_dns_name)
+                            
+                    alias_target = route53.RecordTarget.from_alias(target)
+                
                 else:
                     message = f"Unsupported alias target type: {target_type}"
                     logger.warning(message)
                     missing_configurations.append(message)
                     continue
                 
-                # Create the alias record
-                route53.ARecord(
-                    self,
-                    f"AliasRecord-{record_name}-{record_type}",
-                    zone=self.hosted_zone,
-                    record_name=record_name,
-                    target=alias_target,
-                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
-                ) if record_type == "A" else route53.AaaaRecord(
-                    self,
-                    f"AliasRecord-{record_name}-{record_type}",
-                    zone=self.hosted_zone,
+                route_53_record = None
+                id = f"AliasRecord-{record_name}-{record_type}"
+                print(f"creating record {id}")
+                if record_type == "A":
+                    route_53_record = route53.ARecord(
+                        self,
+                        id,
+                        zone=self.hosted_zone,
                     record_name=record_name,
                     target=alias_target,
                     ttl=cdk.Duration.seconds(record.get("ttl", 300))
                 )
+                elif record_type == "AAAA":
+                    route_53_record = route53.AaaaRecord(
+                        self,
+                        id,
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=alias_target,
+                        ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                    )
                 
             # Handle standard records with values
             elif "values" in record:
@@ -326,89 +332,47 @@ class Route53Stack(IStack, StandardizedSsmMixin):
                 else:
                     message = f"Unsupported record type: {record_type}"
                     logger.warning(message)
-                    missing_configurations.append(message)
+                    self._missing_configurations.append(message)
                     continue
             
             else:
                 message = f"Record missing 'alias' or 'values' configuration: {record}"
                 logger.warning(message)
-                missing_configurations.append(message)
+                self._missing_configurations.append(message)
                 continue
 
-        if missing_configurations and len(missing_configurations) > 0:
+        if self._missing_configurations and len(self._missing_configurations) > 0:
             # print all missing configurations
             print("Missing configurations:")
-            for message in missing_configurations:
+            for message in self._missing_configurations:
                 print(message)
             
-            messages = "\n".join(missing_configurations)
+            messages = "\n".join(self._missing_configurations)
             raise ValueError(f"Missing Configurations:\n{messages}")
 
-    def _create_dns_records_old(self) -> None:
-        """Create DNS records based on configuration"""
-        # Create alias records
-        for alias_record in self.route53_config.aliases:
-            record_name = alias_record.get("name", "")
-            target_type = alias_record.get("target_type", "")
-            target_value = alias_record.get("target_value", "")
-            
-            # target value needs to handle SSM parameters
-            if "{{ssm:" in target_value and "}}" in target_value:
-                # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
-                ssm_path = target_value.split("{{ssm:")[1].split("}}")[0]
-                target_value = self.get_ssm_imported_value(ssm_path)
+    def _get_resolved_value(self, *, config: dict, key: str, required: bool = True, record_type: str = ""   ) -> str:
+        
+        value = config.get(key, "")
+        x = str(value).replace("{", "").replace("}", "").replace(":", "")
+        unique_id = f"{key}-id-{record_type}-{x}"
 
-            if not record_name or not target_type or not target_value:
-                continue
-                
-            # Determine the alias target
-            alias_target = None
-            if target_type == "alb":
-                # Get the ALB from the workload if available
-                if hasattr(self.workload, "load_balancer"):
-                    alb = self.workload.load_balancer
-                    alias_target = route53.RecordTarget.from_alias(targets.LoadBalancerTarget(alb))
-                else:
-                    # Try to get ALB from target value
-                    alb = elbv2.ApplicationLoadBalancer.from_lookup(
-                        self,
-                        f"ALB-{record_name}",
-                        load_balancer_arn=target_value
-                    )
-                    alias_target = route53.RecordTarget.from_alias(targets.LoadBalancerTarget(alb))
-            elif target_type == "cloudfront":
-                # For CloudFront, we would need the distribution
-                # This is a simplified implementation
-                pass
-                
-            if alias_target:
-                record = route53.ARecord(
-                    self,
-                    f"AliasRecord-{record_name}",
-                    zone=self.hosted_zone,
-                    record_name=record_name,
-                    target=alias_target
-                )
-                self.records[record_name] = record
-                
-        # Create CNAME records
-        for cname_record in self.route53_config.cname_records:
-            record_name = cname_record.get("name", "")
-            target_domain = cname_record.get("target_domain", "")
-            ttl = cname_record.get("ttl", 300)
-            
-            if not record_name or not target_domain:
-                continue
-                
-            record = route53.CnameRecord(
-                self,
-                f"CnameRecord-{record_name}",
-                zone=self.hosted_zone,
-                record_name=record_name,
-                domain_name=target_domain,
-                ttl=cdk.Duration.seconds(ttl)
-            )
-            self.records[record_name] = record
+        if unique_id in self._local_cache:
+            return self._local_cache[unique_id]
+        
+        
+        
+        # Handle SSM parameter references in target_value                
+        value = self.resolve_ssm_value(self, value, unique_id=unique_id)
+
+        if required and not value:
+            self._missing_configurations.append(f"Missing required value for key: {key}")
+
+        self._local_cache[unique_id] = value
+
+
+        return value
+
+    
 
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the Route53 resources"""

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.19.19"
+__version__ = "0.21.1"

{cdk_factory-0.19.19.dist-info → cdk_factory-0.21.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.19.19
+Version: 0.21.1
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.19.19.dist-info → cdk_factory-0.21.1.dist-info}/RECORD

@@ -2,7 +2,7 @@ cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=RnX0-pwdTAPAdKJK_j13Zl8anf9zYKBwboR0KA8K8xM,10346
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
 cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
-cdk_factory/version.py,sha256=7SkXrcCPPywUj5iTSUoEUN_6FonxdNwtTRVl_D3253s,24
+cdk_factory/version.py,sha256=SgjjYIjRx1j_wfbQTv5G4w3woiZ-Jp6WCRh6Z-HHPxc,23
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=eJ3Pl3GWk1jVr_bYQaaWlw4_-ZiFGaiXllI_fOOX1i0,9323
@@ -40,7 +40,7 @@ cdk_factory/configurations/resources/lambda_layers.py,sha256=gVeP_-LC3Eq0lkPaG_J
 cdk_factory/configurations/resources/lambda_triggers.py,sha256=MD7cdMNKEulNBhtMLIFnWJuJ5R-yyIqa0LHUgbSQerA,834
 cdk_factory/configurations/resources/load_balancer.py,sha256=P-jKemIjIWWqScmQKspmRy1m3BrwNkRtTNHDStOAJds,5617
 cdk_factory/configurations/resources/monitoring.py,sha256=CPYWbUbWQzoPqDhdPiB4Vahq-pPi6BEkavkVohadSIo,2422
-cdk_factory/configurations/resources/rds.py,sha256=pX6uihguv1apYH93obcE4RloQDP48q5JHnYTnO39Pn0,15935
+cdk_factory/configurations/resources/rds.py,sha256=fK2_GBIlVEF_I0Q73EaCz5AIuaTDIn2YQk-WcV-vf6s,16329
 cdk_factory/configurations/resources/resource_mapping.py,sha256=cwv3n63RJ6E59ErsmSTdkW4i-g8huhHtKI0ExbRhJxA,2182
 cdk_factory/configurations/resources/resource_naming.py,sha256=VE9S2cpzp11qqPL2z1sX79wXH0o1SntO2OG74nEmWC8,5508
 cdk_factory/configurations/resources/resource_types.py,sha256=1WQHyDoErb-M-tETZZzyLDtbq_jdC85-I403dM48pgE,2317
@@ -86,7 +86,7 @@ cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ
 cdk_factory/stack_library/acm/acm_stack.py,sha256=LW4QgzcMDvtSpqwfc4ykgpzDGvXe4udvWVE_DtBN4Zg,5414
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=PvLdGvcopGpLP0FwpfUcfXNiTIfYLTXqrG-TniE38yc,39643
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=G8OOgTAfsTDVArvuDfzuNpuGHzqz8kREHnnkMtjulAQ,25334
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=gjDxYWC4QZEZ4UOhGjgziggP7391dEMEe3vaslHSZ0c,25884
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
@@ -98,19 +98,25 @@ cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=-_Ij1zXIxUuZIWgdevam
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=KLbd5WN5-ZiojsS5wJ4PX-tIL0cCylCSvXjO6sVrgWY,2102
 cdk_factory/stack_library/ecs/__init__.py,sha256=o5vGDtD_h-gVXb3-Ysr8xUNpEcMsnmMVgZv2Pupcdow,219
-cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=sAPTLU5CAwMoLTW_pNy_cd0OtVkfDR7IxxsSq5AE0yo,12091
-cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=KB4YCIsMm5JIGM9Bm-bKcr3eX5xXFgnoA7jST_ekK44,28209
-cdk_factory/stack_library/lambda_edge/EDGE_LOG_RETENTION_TODO.md,sha256=nD49nLm5OyrZUvcGNFBy9H1MfSUOuZ7sasHNI-IO0Zk,6635
+cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=j0Cc7CyTK8MQDGCeZzo7XYrj1AM1hQBLH9DGXs7k-hQ,12165
+cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=fm3Q2oeMN5JULatYFrQDfyTs58k283weQjPEuhpz1Sc,28297
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
-cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=b8PE4v5zGsqu_mVOaPejb8JKkV6b83N-VS0AxSlLTtk,20119
+cdk_factory/stack_library/lambda_edge/lambda_edge_log_retention_stack.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=QxuyJ1mR8018HRqDXERkmsFMuEHd5YsVIACmXitYZDY,23344
+cdk_factory/stack_library/lambda_edge/functions/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/__init__.py,sha256=0JJIk47ubXY4QddDJ6hyyDMXBGYd0IzQyd3-SPqVikU,964
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/app.py,sha256=i77H3f0KATiNhnPo0Ca8-B5OWPtDRT8def4HHiCp8Zw,858
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/edge_log_retention.py,sha256=a-i0N_44RehzHA_hSx0Z9NFLfy4T-RZKA1sMS-CcYAw,3744
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/requirements.txt,sha256=nJ0ZsOr7cuZEKNQd6e3EPStDJI7Y5Jnshi-FoydLE7o,46
+cdk_factory/stack_library/lambda_edge/functions/log_retention_manager/test.py,sha256=CwjyMIjQ5kbeYicMUnAIK3eflBYbobEaM1noq-7Ck1Q,567
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
-cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=ApW5q3SAvSJtiK0RInNljmubqXqKZU5QBAaUoeIW-pM,28287
+cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=iR-l5ujLS4zUReI-deWs8sDIUbmFYoWKt9kEZri1z2A,28441
 cdk_factory/stack_library/monitoring/__init__.py,sha256=k1G_KDx47Aw0UugaL99PN_TKlyLK4nkJVApCaAK7GJg,153
 cdk_factory/stack_library/monitoring/monitoring_stack.py,sha256=N_1YvEXE7fboH_S3kv_dSKZsufxMuPdFMjGzlNFpuSo,19283
 cdk_factory/stack_library/rds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/rds/rds_stack.py,sha256=VToW-uFKAfilyhN4T8-TXaFW8f_VuXEIuUoBHvDN0Ns,14398
+cdk_factory/stack_library/rds/rds_stack.py,sha256=UwLaDpyNNvPnMV8DfZon8fyusuGkvcpJiUB5V3Gjrt4,14748
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/route53/route53_stack.py,sha256=taREOw-s7i1NZcdR-za1lKkj-Cj8UPmr4BO5txS18fI,18348
+cdk_factory/stack_library/route53/route53_stack.py,sha256=PaYpVVYC_jZ-pbsmK0vW_OVleJ4En0L2O_a92jlWi18,16601
 cdk_factory/stack_library/rum/__init__.py,sha256=gUrWQdzd4rZ2J0YzAQC8PsEGAS7QgyYjB2ZCUKWasy4,90
 cdk_factory/stack_library/rum/rum_stack.py,sha256=c67m0Jbyx8hx9TTx9TBBhZMDqtSK7QCqKx_Ec1t8LgY,14067
 cdk_factory/stack_library/security_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -137,8 +143,8 @@ cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITE
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/validation/config_validator.py,sha256=Pb0TkLiPFzUplBOgMorhRCVm08vEzZhRU5xXCDTa5CA,17602
 cdk_factory/workload/workload_factory.py,sha256=yDI3cRhVI5ELNDcJPLpk9UY54Uind1xQoV3spzT4z7E,6068
-cdk_factory-0.19.19.dist-info/METADATA,sha256=syphI_KKN3_606LBfCKYQLU_3YX4ppprIwsKcAENNBk,2452
-cdk_factory-0.19.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.19.19.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.19.19.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.19.19.dist-info/RECORD,,
+cdk_factory-0.21.1.dist-info/METADATA,sha256=9FoDlo8hg9_wGFmPmaVmnEQUO_Os-We2cYJgCiWSKZ4,2451
+cdk_factory-0.21.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.21.1.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.21.1.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.21.1.dist-info/RECORD,,

cdk_factory/stack_library/lambda_edge/EDGE_LOG_RETENTION_TODO.md

@@ -1,226 +0,0 @@
-# Lambda@Edge Log Retention - Implementation Plan
-
-## 🚨 Current Status: DISABLED
-
-Lambda@Edge log retention configuration has been **disabled** because edge log groups are created on-demand when the function is invoked at edge locations, not during CloudFormation deployment.
-
-## 🔍 Problem Analysis
-
-### Why Deployment-Time Configuration Fails
-1. **On-Demand Creation**: Lambda@Edge log groups are created only when the function is actually invoked at edge locations
-2. **Timing Issue**: CloudFormation deployment happens before any edge invocations occur
-3. **Error**: `The specified log group does not exist` when trying to set retention policies
-
-### Log Group Naming Pattern
-```
-Pattern: /aws/lambda/{edge-region}.{function-name}
-Example: /aws/lambda/eu-central-1.trav-talks-blue-green-edge-function
-Location: All edge log groups are created in us-east-1
-```
-
-## 💡 Proposed Solutions
-
-### Solution 1: EventBridge + Lambda (Recommended)
-```yaml
-# EventBridge rule to detect log group creation
-EventPattern:
-  source: ["aws.logs"]
-  detail-type: ["AWS API Call via CloudTrail"]
-  detail:
-    eventSource: ["logs.amazonaws.com"]
-    eventName: ["CreateLogGroup"]
-    requestParameters:
-      logGroupName: ["/aws/lambda/*.edge-function"]
-```
-
-**Implementation:**
-1. Create EventBridge rule that triggers on log group creation
-2. Lambda function receives event and sets retention policy
-3. Automatic handling of new edge log groups
-
-**Pros:**
-- Automatic and real-time
-- No manual intervention required
-- Handles all edge regions
-
-**Cons:**
-- Additional Lambda function to maintain
-- Requires CloudTrail enabled for CloudWatch Logs
-
-### Solution 2: Periodic Lambda Function
-```python
-def lambda_handler(event, context):
-    # Scan for edge log groups
-    log_groups = logs.describe_log_groups(
-        logGroupNamePrefix='/aws/lambda/eu-central-1.trav-talks-blue-green-edge-function'
-    )
-    
-    # Apply retention policy
-    for log_group in log_groups['logGroups']:
-        logs.put_retention_policy(
-            logGroupName=log_group['logGroupName'],
-            retentionInDays=7
-        )
-```
-
-**Implementation:**
-1. Create Lambda function on schedule (e.g., every hour)
-2. Scan for edge log groups with function name pattern
-3. Apply retention policy if not already set
-
-**Pros:**
-- Simple to implement
-- No CloudTrail dependency
-- Can handle existing log groups
-
-**Cons:**
-- Not real-time (delayed retention)
-- Runs periodically even when not needed
-
-### Solution 3: Post-Deployment Script
-```bash
-#!/bin/bash
-# Wait for edge log groups to appear
-function_name="trav-talks-blue-green-edge-function"
-edge_regions=("eu-central-1" "eu-west-1" "ap-southeast-1")
-
-for region in "${edge_regions[@]}"; do
-    log_group="/aws/lambda/${region}.${function_name}"
-    
-    # Wait for log group to exist
-    until aws logs describe-log-groups --log-group-name-prefix "$log_group" --region us-east-1; do
-        echo "Waiting for log group: $log_group"
-        sleep 30
-    done
-    
-    # Set retention policy
-    aws logs put-retention-policy --log-group-name "$log_group" --retention-in-days 7 --region us-east-1
-done
-```
-
-**Implementation:**
-1. Script runs after Lambda@Edge deployment
-2. Waits for edge log groups to be created
-3. Sets retention policies when they appear
-
-**Pros:**
-- Direct control over timing
-- No additional AWS resources needed
-
-**Cons:**
-- Manual process
-- Hard to determine when log groups will appear
-- Not automated
-
-### Solution 4: CloudWatch Logs Subscription
-```python
-# Lambda triggered by log group creation via subscription filter
-def lambda_handler(event, context):
-    for record in event['Records']:
-        log_group = record['logGroup']
-        if 'edge-function' in log_group:
-            # Set retention policy
-            logs.put_retention_policy(
-                logGroupName=log_group,
-                retentionInDays=7
-            )
-```
-
-**Implementation:**
-1. Create subscription filter on log group pattern
-2. Lambda function triggered by log events
-3. Set retention policy on first log event
-
-**Pros:**
-- Event-driven
-- No CloudTrail needed
-
-**Cons:**
-- Requires log group to exist first
-- Complex subscription filter setup
-
-## 🎯 Recommended Implementation
-
-### Phase 1: Quick Win (Solution 2)
-Implement periodic Lambda function as temporary solution:
-- Easy to implement quickly
-- Solves immediate problem
-- Can be replaced later with better solution
-
-### Phase 2: Production Solution (Solution 1)
-Implement EventBridge + Lambda for production:
-- Real-time response
-- Automatic handling
-- Best long-term solution
-
-## 📋 Implementation Steps for Solution 1
-
-### 1. Create EventBridge Rule
-```python
-event_rule = events.Rule(
-    self, "EdgeLogGroupRule",
-    event_pattern=events.EventPattern(
-        source=["aws.logs"],
-        detail_type=["AWS API Call via CloudTrail"],
-        detail={
-            "eventSource": ["logs.amazonaws.com"],
-            "eventName": ["CreateLogGroup"],
-            "requestParameters": {
-                "logGroupName": [{"prefix": "/aws/lambda/"}]
-            }
-        }
-    )
-)
-```
-
-### 2. Create Lambda Function
-```python
-retention_handler = _lambda.Function(
-    self, "EdgeLogRetentionHandler",
-    runtime=_lambda.Runtime.PYTHON_3_9,
-    handler="handler.lambda_handler",
-    code=_lambda.Code.from_asset("lambda/edge_log_retention"),
-    environment={
-        "RETENTION_DAYS": "7",
-        "FUNCTION_NAME_PATTERN": "*edge-function"
-    }
-)
-```
-
-### 3. Add Permissions
-```python
-retention_handler.add_to_role_policy(
-    iam.PolicyStatement(
-        actions=["logs:PutRetentionPolicy", "logs:DescribeLogGroups"],
-        resources=["*"]
-    )
-)
-```
-
-### 4. Connect EventBridge to Lambda
-```python
-event_rule.add_target(targets.LambdaFunction(retention_handler))
-```
-
-## 🔧 Current Configuration
-
-The edge log retention configuration is currently **disabled** in the Lambda Edge stack:
-
-```python
-def _configure_edge_log_retention(self, function_name: str) -> None:
-    # DISABLED: See implementation plan above
-    logger.warning("Edge log retention disabled - see TODO for implementation")
-    return
-```
-
-## 📊 Configuration Impact
-
-| Setting | Current Behavior | Target Behavior |
-|---------|------------------|-----------------|
-| `edge_log_retention_days` | Warning logged, no action applied | Retention policy set on all edge log groups |
-| Edge log groups | Created with default retention (never expire) | Created with specified retention (e.g., 7 days) |
-| Cost impact | Potential high log storage costs | Controlled log storage costs |
-
----
-
-**Status**: Ready for implementation when edge log retention is required.