cdk-factory 0.9.12__py3-none-any.whl → 0.10.0__py3-none-any.whl

cdk_factory/stack_library/monitoring/monitoring_stack.py

@@ -0,0 +1,492 @@
+"""
+Monitoring Stack - CloudWatch Alarms and Dashboards
+Geek Cafe, LLC
+Maintainers: Eric Wilson
+MIT License. See Project Root for the license information.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+
+from aws_cdk import (
+    Duration,
+    aws_cloudwatch as cloudwatch,
+    aws_cloudwatch_actions as cw_actions,
+    aws_sns as sns,
+    aws_sns_subscriptions as subscriptions,
+    aws_ssm as ssm,
+    aws_logs as logs,
+    CfnOutput,
+)
+from constructs import Construct
+
+from cdk_factory.interfaces.istack import IStack
+from cdk_factory.stack.stack_module_registry import register_stack
+from cdk_factory.configurations.stack import StackConfig
+from cdk_factory.configurations.resources.monitoring import MonitoringConfig
+
+logger = logging.getLogger(__name__)
+
+
+@register_stack("monitoring_library_module")
+class MonitoringStack(IStack):
+    """
+    Monitoring Stack with CloudWatch Alarms and Dashboards
+    
+    Supports:
+    - SNS topics for notifications
+    - CloudWatch alarms (metric, composite, anomaly detection)
+    - CloudWatch dashboards
+    - Log metric filters
+    - Email/Slack/PagerDuty subscriptions
+    """
+
+    def __init__(
+        self,
+        scope: Construct,
+        id: str,
+        stack_config: StackConfig,
+        deployment,
+        **kwargs,
+    ) -> None:
+        super().__init__(scope, id, **kwargs)
+
+        self.stack_config = stack_config
+        self.deployment = deployment
+        
+        # Monitoring config
+        monitoring_dict = stack_config.dictionary.get("monitoring", {})
+        self.monitoring_config = MonitoringConfig(monitoring_dict, deployment)
+        
+        # Resources
+        self.sns_topics: Dict[str, sns.Topic] = {}
+        self.alarms: Dict[str, cloudwatch.Alarm] = {}
+        self.dashboards: Dict[str, cloudwatch.Dashboard] = {}
+
+    def build(
+        self,
+        vpc=None,
+        target_groups=None,
+        security_groups=None,
+        shared=None,
+    ):
+        """Build monitoring resources"""
+        
+        logger.info(f"Building monitoring stack: {self.monitoring_config.name}")
+        
+        # Create SNS topics first
+        self._create_sns_topics()
+        
+        # Create log metric filters
+        self._create_log_metric_filters()
+        
+        # Create alarms
+        self._create_alarms()
+        
+        # Create composite alarms
+        self._create_composite_alarms()
+        
+        # Create dashboards
+        self._create_dashboards()
+        
+        # Export SSM parameters
+        self._export_ssm_parameters()
+        
+        # Create outputs
+        self._create_outputs()
+        
+        return self
+
+    def _create_sns_topics(self) -> None:
+        """Create SNS topics for alarm notifications"""
+        topics_config = self.monitoring_config.sns_topics
+        
+        for topic_config in topics_config:
+            topic_name = topic_config.get("name")
+            if not topic_name:
+                logger.warning("SNS topic name is required, skipping")
+                continue
+            
+            # Create topic
+            topic = sns.Topic(
+                self,
+                f"Topic-{topic_name}",
+                topic_name=topic_name,
+                display_name=topic_config.get("display_name", topic_name),
+            )
+            
+            # Add subscriptions
+            subscriptions_config = topic_config.get("subscriptions", [])
+            for sub_config in subscriptions_config:
+                protocol = sub_config.get("protocol", "email")
+                endpoint = sub_config.get("endpoint")
+                
+                if not endpoint:
+                    logger.warning(f"Subscription endpoint required for {topic_name}, skipping")
+                    continue
+                
+                if protocol == "email":
+                    topic.add_subscription(subscriptions.EmailSubscription(endpoint))
+                elif protocol == "sms":
+                    topic.add_subscription(subscriptions.SmsSubscription(endpoint))
+                elif protocol == "https":
+                    topic.add_subscription(subscriptions.UrlSubscription(endpoint))
+                elif protocol == "lambda":
+                    # Lambda ARN as endpoint
+                    logger.warning(f"Lambda subscriptions not yet implemented for {topic_name}")
+                else:
+                    logger.warning(f"Unsupported protocol {protocol} for {topic_name}")
+            
+            self.sns_topics[topic_name] = topic
+            logger.info(f"Created SNS topic: {topic_name}")
+
+    def _create_log_metric_filters(self) -> None:
+        """Create CloudWatch Logs metric filters"""
+        filters_config = self.monitoring_config.log_metric_filters
+        
+        for filter_config in filters_config:
+            filter_name = filter_config.get("name")
+            log_group_name = filter_config.get("log_group_name")
+            filter_pattern = filter_config.get("filter_pattern")
+            metric_namespace = filter_config.get("metric_namespace", "CustomMetrics")
+            metric_name = filter_config.get("metric_name")
+            
+            if not all([filter_name, log_group_name, filter_pattern, metric_name]):
+                logger.warning(f"Missing required fields for metric filter {filter_name}, skipping")
+                continue
+            
+            # Import log group
+            log_group = logs.LogGroup.from_log_group_name(
+                self,
+                f"LogGroup-{filter_name}",
+                log_group_name=log_group_name
+            )
+            
+            # Create metric filter
+            logs.MetricFilter(
+                self,
+                f"MetricFilter-{filter_name}",
+                log_group=log_group,
+                filter_pattern=logs.FilterPattern.literal(filter_pattern),
+                metric_namespace=metric_namespace,
+                metric_name=metric_name,
+                metric_value=filter_config.get("metric_value", "1"),
+                default_value=filter_config.get("default_value", 0),
+            )
+            
+            logger.info(f"Created metric filter: {filter_name}")
+
+    def _create_alarms(self) -> None:
+        """Create CloudWatch alarms"""
+        alarms_config = self.monitoring_config.alarms
+        
+        for alarm_config in alarms_config:
+            alarm_name = alarm_config.get("name")
+            if not alarm_name:
+                logger.warning("Alarm name is required, skipping")
+                continue
+            
+            # Determine alarm type
+            alarm_type = alarm_config.get("type", "metric")
+            
+            if alarm_type == "metric":
+                alarm = self._create_metric_alarm(alarm_config)
+            elif alarm_type == "anomaly":
+                alarm = self._create_anomaly_alarm(alarm_config)
+            else:
+                logger.warning(f"Unsupported alarm type: {alarm_type}")
+                continue
+            
+            if alarm:
+                self.alarms[alarm_name] = alarm
+                logger.info(f"Created alarm: {alarm_name}")
+
+    def _create_metric_alarm(self, config: Dict[str, Any]) -> Optional[cloudwatch.Alarm]:
+        """Create a metric-based alarm"""
+        alarm_name = config.get("name")
+        
+        # Get metric configuration
+        metric_config = config.get("metric", {})
+        
+        # Check if using SSM import for resource
+        namespace = metric_config.get("namespace")
+        metric_name = metric_config.get("metric_name")
+        dimensions = metric_config.get("dimensions", {})
+        
+        # Resolve SSM parameters in dimensions
+        resolved_dimensions = {}
+        for dim_name, dim_value in dimensions.items():
+            if isinstance(dim_value, str) and dim_value.startswith("{{ssm:") and dim_value.endswith("}}"):
+                ssm_param = dim_value[6:-2]
+                dim_value = ssm.StringParameter.value_from_lookup(self, ssm_param)
+            resolved_dimensions[dim_name] = dim_value
+        
+        # Create metric
+        metric = cloudwatch.Metric(
+            namespace=namespace,
+            metric_name=metric_name,
+            dimensions_map=resolved_dimensions if resolved_dimensions else None,
+            statistic=metric_config.get("statistic", "Average"),
+            period=Duration.seconds(metric_config.get("period", 300)),
+        )
+        
+        # Comparison operator
+        comparison_op_map = {
+            "GreaterThanThreshold": cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD,
+            "GreaterThanOrEqualToThreshold": cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+            "LessThanThreshold": cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,
+            "LessThanOrEqualToThreshold": cloudwatch.ComparisonOperator.LESS_THAN_OR_EQUAL_TO_THRESHOLD,
+        }
+        comparison_op = comparison_op_map.get(
+            config.get("comparison_operator", "GreaterThanThreshold"),
+            cloudwatch.ComparisonOperator.GREATER_THAN_THRESHOLD
+        )
+        
+        # Treat missing data
+        treat_missing_data_map = {
+            "breaching": cloudwatch.TreatMissingData.BREACHING,
+            "notBreaching": cloudwatch.TreatMissingData.NOT_BREACHING,
+            "ignore": cloudwatch.TreatMissingData.IGNORE,
+            "missing": cloudwatch.TreatMissingData.MISSING,
+        }
+        treat_missing_data = treat_missing_data_map.get(
+            config.get("treat_missing_data", "notBreaching"),
+            cloudwatch.TreatMissingData.NOT_BREACHING
+        )
+        
+        # Create alarm
+        alarm = cloudwatch.Alarm(
+            self,
+            f"Alarm-{alarm_name}",
+            alarm_name=alarm_name,
+            alarm_description=config.get("description", ""),
+            metric=metric,
+            threshold=config.get("threshold", 0),
+            evaluation_periods=config.get("evaluation_periods", 1),
+            datapoints_to_alarm=config.get("datapoints_to_alarm"),
+            comparison_operator=comparison_op,
+            treat_missing_data=treat_missing_data,
+            actions_enabled=config.get("actions_enabled", True),
+        )
+        
+        # Add alarm actions (SNS topics)
+        actions = config.get("actions", [])
+        for action in actions:
+            if action in self.sns_topics:
+                alarm.add_alarm_action(cw_actions.SnsAction(self.sns_topics[action]))
+        
+        # Add OK actions
+        ok_actions = config.get("ok_actions", [])
+        for action in ok_actions:
+            if action in self.sns_topics:
+                alarm.add_ok_action(cw_actions.SnsAction(self.sns_topics[action]))
+        
+        # Add insufficient data actions
+        insufficient_data_actions = config.get("insufficient_data_actions", [])
+        for action in insufficient_data_actions:
+            if action in self.sns_topics:
+                alarm.add_insufficient_data_action(cw_actions.SnsAction(self.sns_topics[action]))
+        
+        return alarm
+
+    def _create_anomaly_alarm(self, config: Dict[str, Any]) -> Optional[cloudwatch.Alarm]:
+        """Create an anomaly detection alarm"""
+        # Anomaly detection alarms use a different approach
+        # For now, log and skip - can be implemented later
+        logger.info(f"Anomaly detection alarm {config.get('name')} - implementation pending")
+        return None
+
+    def _create_composite_alarms(self) -> None:
+        """Create composite alarms (combine multiple alarms)"""
+        composite_config = self.monitoring_config.composite_alarms
+        
+        for comp_config in composite_config:
+            comp_name = comp_config.get("name")
+            if not comp_name:
+                logger.warning("Composite alarm name is required, skipping")
+                continue
+            
+            # Build alarm rule
+            alarm_rule = comp_config.get("alarm_rule")
+            if not alarm_rule:
+                logger.warning(f"Alarm rule required for {comp_name}, skipping")
+                continue
+            
+            # Replace alarm names with ARNs in the rule
+            # This is a simplified version - full implementation would parse the rule
+            # For now, just pass through
+            
+            composite_alarm = cloudwatch.CompositeAlarm(
+                self,
+                f"CompositeAlarm-{comp_name}",
+                composite_alarm_name=comp_name,
+                alarm_description=comp_config.get("description", ""),
+                alarm_rule=cloudwatch.AlarmRule.from_string(alarm_rule),
+                actions_enabled=comp_config.get("actions_enabled", True),
+            )
+            
+            # Add actions
+            actions = comp_config.get("actions", [])
+            for action in actions:
+                if action in self.sns_topics:
+                    composite_alarm.add_alarm_action(cw_actions.SnsAction(self.sns_topics[action]))
+            
+            logger.info(f"Created composite alarm: {comp_name}")
+
+    def _create_dashboards(self) -> None:
+        """Create CloudWatch dashboards"""
+        dashboards_config = self.monitoring_config.dashboards
+        
+        for dashboard_config in dashboards_config:
+            dashboard_name = dashboard_config.get("name")
+            if not dashboard_name:
+                logger.warning("Dashboard name is required, skipping")
+                continue
+            
+            # Create dashboard
+            dashboard = cloudwatch.Dashboard(
+                self,
+                f"Dashboard-{dashboard_name}",
+                dashboard_name=dashboard_name,
+            )
+            
+            # Add widgets
+            widgets_config = dashboard_config.get("widgets", [])
+            for widget_config in widgets_config:
+                widget = self._create_widget(widget_config)
+                if widget:
+                    # Add to dashboard (position will be auto-calculated)
+                    dashboard.add_widgets(widget)
+            
+            self.dashboards[dashboard_name] = dashboard
+            logger.info(f"Created dashboard: {dashboard_name}")
+
+    def _create_widget(self, config: Dict[str, Any]) -> Optional[cloudwatch.IWidget]:
+        """Create a dashboard widget"""
+        widget_type = config.get("type", "graph")
+        
+        if widget_type == "graph":
+            return self._create_graph_widget(config)
+        elif widget_type == "number":
+            return self._create_single_value_widget(config)
+        elif widget_type == "log":
+            return self._create_log_widget(config)
+        elif widget_type == "alarm":
+            return self._create_alarm_widget(config)
+        else:
+            logger.warning(f"Unsupported widget type: {widget_type}")
+            return None
+
+    def _create_graph_widget(self, config: Dict[str, Any]) -> cloudwatch.GraphWidget:
+        """Create a graph widget"""
+        metrics_config = config.get("metrics", [])
+        metrics = []
+        
+        for metric_config in metrics_config:
+            metric = cloudwatch.Metric(
+                namespace=metric_config.get("namespace"),
+                metric_name=metric_config.get("metric_name"),
+                dimensions_map=metric_config.get("dimensions", {}),
+                statistic=metric_config.get("statistic", "Average"),
+                period=Duration.seconds(metric_config.get("period", 300)),
+                label=metric_config.get("label"),
+            )
+            metrics.append(metric)
+        
+        return cloudwatch.GraphWidget(
+            title=config.get("title", ""),
+            left=metrics,
+            width=config.get("width", 12),
+            height=config.get("height", 6),
+            legend_position=cloudwatch.LegendPosition.BOTTOM,
+        )
+
+    def _create_single_value_widget(self, config: Dict[str, Any]) -> cloudwatch.SingleValueWidget:
+        """Create a single value widget"""
+        metrics_config = config.get("metrics", [])
+        metrics = []
+        
+        for metric_config in metrics_config:
+            metric = cloudwatch.Metric(
+                namespace=metric_config.get("namespace"),
+                metric_name=metric_config.get("metric_name"),
+                dimensions_map=metric_config.get("dimensions", {}),
+                statistic=metric_config.get("statistic", "Average"),
+                period=Duration.seconds(metric_config.get("period", 300)),
+            )
+            metrics.append(metric)
+        
+        return cloudwatch.SingleValueWidget(
+            title=config.get("title", ""),
+            metrics=metrics,
+            width=config.get("width", 6),
+            height=config.get("height", 3),
+        )
+
+    def _create_log_widget(self, config: Dict[str, Any]) -> cloudwatch.LogQueryWidget:
+        """Create a log query widget"""
+        log_group_names = config.get("log_group_names", [])
+        query_string = config.get("query_string", "")
+        
+        return cloudwatch.LogQueryWidget(
+            title=config.get("title", ""),
+            log_group_names=log_group_names,
+            query_string=query_string,
+            width=config.get("width", 24),
+            height=config.get("height", 6),
+        )
+
+    def _create_alarm_widget(self, config: Dict[str, Any]) -> cloudwatch.AlarmWidget:
+        """Create an alarm status widget"""
+        alarm_names = config.get("alarm_names", [])
+        alarms = [self.alarms[name] for name in alarm_names if name in self.alarms]
+        
+        if not alarms:
+            logger.warning(f"No alarms found for alarm widget")
+            return None
+        
+        return cloudwatch.AlarmWidget(
+            title=config.get("title", "Alarms"),
+            alarms=alarms,
+            width=config.get("width", 12),
+            height=config.get("height", 6),
+        )
+
+    def _export_ssm_parameters(self) -> None:
+        """Export monitoring resources to SSM Parameter Store"""
+        ssm_exports = self.monitoring_config.ssm_exports
+        
+        if not ssm_exports:
+            return
+        
+        # Export SNS topic ARNs
+        for topic_name, topic in self.sns_topics.items():
+            param_name = ssm_exports.get(f"sns_topic_{topic_name}")
+            if param_name:
+                ssm.StringParameter(
+                    self,
+                    f"SnsTopicParam-{topic_name}",
+                    parameter_name=param_name,
+                    string_value=topic.topic_arn,
+                    description=f"SNS Topic ARN for {topic_name}",
+                )
+
+    def _create_outputs(self) -> None:
+        """Create CloudFormation outputs"""
+        # Output SNS topic ARNs
+        for topic_name, topic in self.sns_topics.items():
+            CfnOutput(
+                self,
+                f"SnsTopicArn-{topic_name}",
+                value=topic.topic_arn,
+                description=f"SNS Topic ARN: {topic_name}",
+            )
+        
+        # Output dashboard URLs
+        for dashboard_name, dashboard in self.dashboards.items():
+            CfnOutput(
+                self,
+                f"DashboardUrl-{dashboard_name}",
+                value=f"https://console.aws.amazon.com/cloudwatch/home?region={self.region}#dashboards:name={dashboard_name}",
+                description=f"Dashboard URL: {dashboard_name}",
+            )

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.9.12"
+__version__ = "0.10.0"

cdk_factory/workload/workload_factory.py

@@ -42,6 +42,8 @@ class WorkloadFactory:
             runtime_directory=runtime_directory,
             paths=paths,
         )
+        # TODO: do we need to get other settings like configs, environment vars, etc?
+        outdir = outdir or "./cdk.out"
         self.workload: WorkloadConfig = WorkloadConfig(config=self.cdk_config.config)
         self.workload.paths = paths or []
         self.workload.cdk_app_file = cdk_app_file or __file__

{cdk_factory-0.9.12.dist-info → cdk_factory-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.9.12
+Version: 0.10.0
 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.9.12.dist-info → cdk_factory-0.10.0.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=XR5b9xrEQYlPbzUgeAtHjn10uKetzrpCdRIvgcGJkoI,23
+cdk_factory/version.py,sha256=v4zmKjsKOPZbp6BrWoz7iK4ST0sdZdUh9bQSJmluZ5o,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=JKjhNsy0RCUZy1s8n5D_aXXI-upR9izaLtCTfKYiV9k,9624
@@ -20,8 +20,8 @@ cdk_factory/configurations/workload.py,sha256=sM-B6UKOdOn5_H-eWmW03J9oa8YZZmO0bv
 cdk_factory/configurations/resources/_resources.py,sha256=tnXGn4kEC0JPQaTWB3QpAZG-2hIGBtugHTzuKn1OTvE,2548
 cdk_factory/configurations/resources/api_gateway.py,sha256=-k4hMGszIdQLb5DGmWBIPy49YGutp8zczafRh-Vob0I,4904
 cdk_factory/configurations/resources/apigateway_route_config.py,sha256=6ytn_nwKwlfpBtHL5sV6gxMpgAJ3p6QFGumMoW4CTHM,2351
-cdk_factory/configurations/resources/auto_scaling.py,sha256=OAVl8iUdHiOYVzme1qNDwA3w2raxDNUo_W2_Vebqtx8,5005
-cdk_factory/configurations/resources/cloudfront.py,sha256=xwDIrYQDqQMgekXSJ5vrgNXIUCfY6O8aiybE5ewwijw,1055
+cdk_factory/configurations/resources/auto_scaling.py,sha256=rY-lZBZIS3bq0Lzf4IGbmMxhgiD_tknjjTZhh4Z6yFI,5922
+cdk_factory/configurations/resources/cloudfront.py,sha256=oCWa9I8hbXVu114t-IO5frW6hgvPoovFgDbipDqFoGs,3848
 cdk_factory/configurations/resources/cloudwatch_widget.py,sha256=EdEQSXUkDtoY_Mg_cJBWo1Hp84jSiK7U9tsd3k1VhKI,1271
 cdk_factory/configurations/resources/code_artifact.py,sha256=P2X2i6NEcePitEf2wkN6lFTjIbXasn0uzrlPOT0tEac,3253
 cdk_factory/configurations/resources/code_artifact_login.py,sha256=mKd8Bx0WypmSspfibwXbgubbIzW-6gGdQqIHvOnDAYQ,6066
@@ -30,12 +30,14 @@ cdk_factory/configurations/resources/cognito.py,sha256=udX2AJ1ITLhy4f1XiJQwrva6F
 cdk_factory/configurations/resources/docker.py,sha256=hUbuxkuhcQu9LnLX7I8_57eTmHefEAGVnOHO37MkqC4,2166
 cdk_factory/configurations/resources/dynamodb.py,sha256=HsZMOaRwfuNPwKIzokeeE3f5zAQLTB5hRb_GzYq2ibg,2903
 cdk_factory/configurations/resources/ecr.py,sha256=o9hHzEBVPoxUvWZGXGbRJ-98FmP6fMLY5a1-qg42jL0,8253
-cdk_factory/configurations/resources/ecs_service.py,sha256=kEzSlasDejobl1ZxZtgtM7kVYF11AT3vCGsDInQNY3I,4319
+cdk_factory/configurations/resources/ecs_service.py,sha256=NlFkSgWhO58QtCGZZRFQECA3km7O5D_Ee0BIfAcfDxE,4729
 cdk_factory/configurations/resources/exisiting.py,sha256=EVOLnkB-DGfTlmDgyQ5DD5k2zYfpFxqI3gugDR7mifI,478
+cdk_factory/configurations/resources/lambda_edge.py,sha256=2rcwk2MlvW9mW2qHbNg7CsSNilZrJlmDXDjitKr5xyM,3256
 cdk_factory/configurations/resources/lambda_function.py,sha256=VENZ9-ABJ5mjcN8J8wdLH4KHDYr1kWO0iFDH0B2mJXA,14659
 cdk_factory/configurations/resources/lambda_layers.py,sha256=gVeP_-LC3Eq0lkPaG_JfFUwboM5evRPr99SfKj53m7A,633
 cdk_factory/configurations/resources/lambda_triggers.py,sha256=MD7cdMNKEulNBhtMLIFnWJuJ5R-yyIqa0LHUgbSQerA,834
 cdk_factory/configurations/resources/load_balancer.py,sha256=DHVKuEDaTfbB0UKYBt7UQQCPCM4FY-ThT1T52lcwg_E,4897
+cdk_factory/configurations/resources/monitoring.py,sha256=zsfDMa7yph33Ql8iP7lIqqLAyixh-Mesi0imtZJFdcE,2310
 cdk_factory/configurations/resources/rds.py,sha256=vHmR1zpDmV8HqgYhLgWi26w0S3lJN9hpgFboomiQgY8,4315
 cdk_factory/configurations/resources/resource_mapping.py,sha256=cwv3n63RJ6E59ErsmSTdkW4i-g8huhHtKI0ExbRhJxA,2182
 cdk_factory/configurations/resources/resource_naming.py,sha256=VE9S2cpzp11qqPL2z1sX79wXH0o1SntO2OG74nEmWC8,5508
@@ -48,7 +50,7 @@ cdk_factory/configurations/resources/security_group.py,sha256=8kQtaaRVEn2aDm8XoC
 cdk_factory/configurations/resources/security_group_full_stack.py,sha256=x5MIMCa_olO7prFBKx9zVOfvsVdKo-2mWyhrCy27dFw,2031
 cdk_factory/configurations/resources/sqs.py,sha256=fAh2dqttJ6PX46enFRULuiLEu3TEj0Vb2xntAOgUpYE,4346
 cdk_factory/configurations/resources/vpc.py,sha256=sNn6w76bHFwmt6N76gZZhqpsuNB9860C1SZu6tebaXY,3835
-cdk_factory/constructs/cloudfront/cloudfront_distribution_construct.py,sha256=7uDkDbFigeUOuYgsQ9ghA4dGlx63rUCa6Iiq4RWokEA,14627
+cdk_factory/constructs/cloudfront/cloudfront_distribution_construct.py,sha256=Eu30OITGGZaSoMq9Nj7tFGohgDO0-Ls7yKjpwYI2HrQ,16956
 cdk_factory/constructs/ecr/ecr_construct.py,sha256=JLz3gWrsjlM0XghvbgxuoGlF-VIo_7IYxtgX7mTkidE,10660
 cdk_factory/constructs/lambdas/lambda_function_construct.py,sha256=SQ5SEXn4kezVAzXuv_A_JB3o_svyBXOMi-htvfB9HQs,4516
 cdk_factory/constructs/lambdas/lambda_function_docker_construct.py,sha256=aSyn3eh1YnuIahZ7CbZ5WswwPL8u70ZibMoS24QQifc,9907
@@ -64,6 +66,7 @@ cdk_factory/interfaces/istack.py,sha256=bhTBs-o9FgKwvJMSuwxjUV6D3nUlvZHVzfm27jP9
 cdk_factory/interfaces/live_ssm_resolver.py,sha256=3FIr9a02SXqZmbFs3RT0WxczWEQR_CF7QSt7kWbDrVE,8163
 cdk_factory/interfaces/ssm_parameter_mixin.py,sha256=uA2j8HmAOpuEA9ynRj51s0WjUHMVLsbLQN-QS9NKyHA,12089
 cdk_factory/lambdas/health_handler.py,sha256=dd40ykKMxWCFEIyp2ZdQvAGNjw_ylI9CSm1N24Hp2ME,196
+cdk_factory/lambdas/edge/ip_gate/handler.py,sha256=MPSAOQGYVMSALdH6f9QTXqMSKKJ1tva-yidtaDTbXsg,3241
 cdk_factory/pipeline/path_utils.py,sha256=fvWdrcb4onmpIu1APkHLhXg8zWfK74HcW3Ra2ynxfXM,2586
 cdk_factory/pipeline/pipeline_factory.py,sha256=rvtkdlTPJG477nTVRN8S2ksWt4bwpd9eVLFd9WO02pM,17248
 cdk_factory/pipeline/stage.py,sha256=Be7ExMB9A-linRM18IQDOzQ-cP_I2_ThRNzlT4FIrUg,437
@@ -78,19 +81,25 @@ cdk_factory/stack_library/__init__.py,sha256=5Y9TpIe8ZK1688G60PGcuP-hM0RvYEY_3Hl
 cdk_factory/stack_library/stack_base.py,sha256=tTleSFmlf26DuKVF_ytftf8P7IVWb5iex8cYfYupfvQ,4940
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=l6J5uurBQqbhj9JuvQitV9PiIHS5kqa-dFWifCeA3GM,39347
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=UsFqUb_3XPJAlmZ6F75nXna3elOggD1KuFmmdmhi0Lg,19070
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=XPTPGF-W8ARvzW8UYd4yPJ7xFUw-2BrdxQOYk9I-v3g,23490
 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
+cdk_factory/stack_library/cloudfront/__init__.py,sha256=Zfx50q4xIJ4ZEoVIzUBDTKbRE9DKDM6iyVIFhtQXvww,153
+cdk_factory/stack_library/cloudfront/cloudfront_stack.py,sha256=-mw24FbvwLUzAa1NNKCKGFILZpNXtsuSdxNSNtEz6D8,26804
 cdk_factory/stack_library/code_artifact/code_artifact_stack.py,sha256=vySYIjWGTdVfMcUOyJdW6gTL1maHWq9ThzfrN_rVL5A,6290
 cdk_factory/stack_library/cognito/cognito_stack.py,sha256=zEHkKVCIeyZywPs_GIMXCXyCux9RAKdl5kba3wy8wtQ,24608
 cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=TVyOrUhgaSuN8uymkpaQcpOaSA0lkYJ8QUMgakTCKus,6771
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=1xA68sxFVyqreYjXrP_7U9I8RF9RtFeR6KeEfSWuC2U,2118
 cdk_factory/stack_library/ecs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=mFanYtkZ9GpgT8g31D9tj-2yYbmmcuHN7ADaRD-ri9o,20638
+cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=zuGdZEP5KmeVDTJb-H47LYhvs-85-Fi4Xb78nsA-lF4,24685
+cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
+cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=m87aaeGNEG-LN2mr6Kj6O3WmeXcmh-ACp8oXdlqOI1E,8070
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
 cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=t5JUe5lMUbQCRFZR08k8nO-g-53yWY8gKB9v8ZnedBs,24391
+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=-IQFmacO_UgedAN72Uo0ZGlcmqGcDinr3tquBdhQZXw,8559
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -119,9 +128,9 @@ cdk_factory/utilities/json_loading_utility.py,sha256=YRgzA1I-B_HwZm1eWJTeQ1JLkeb
 cdk_factory/utilities/lambda_function_utilities.py,sha256=S1GvBsY_q2cyUiaud3HORJMnLhI5cRi31fbeaktY-_Q,15826
 cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITEP7EuSU,1019
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
-cdk_factory/workload/workload_factory.py,sha256=yBUDGIuB8-5p_mGcVFxsD2ZoZIziak3yh3LL3JvS0M4,5903
-cdk_factory-0.9.12.dist-info/METADATA,sha256=wgeRcZWqPKX7AJQGcU38dz44uB09hpGdp-MVTjfxsOA,2451
-cdk_factory-0.9.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.9.12.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.9.12.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.9.12.dist-info/RECORD,,
+cdk_factory/workload/workload_factory.py,sha256=mM8GU_5mKq_0OyK060T3JrUSUiGAcKf0eqNlT9mfaws,6028
+cdk_factory-0.10.0.dist-info/METADATA,sha256=HZeUq_9_oU9e86iAoXouf2uIJNXlJMSk9P36L1vEBns,2451
+cdk_factory-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.10.0.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.10.0.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.10.0.dist-info/RECORD,,