Add ability to set log retention for lambda functions globally

Author: hamishfagg

chalice/awsclient.py

@@ -1110,6 +1110,27 @@ def delete_role(self, name: str) -> None:
             self.delete_role_policy(name, policy_name)
         client.delete_role(RoleName=name)
 
+    def log_group_exists(self, name: str) -> bool:
+        """Check if an CloudWatch LOG GROUP exists."""
+        client = self._client('logs')
+        result = client.describe_log_groups(
+            logGroupNamePrefix=name
+        )
+        if len(result['logGroups']) == 0:
+            return False
+        return True
+
+    def create_log_group(self, name: str) -> None:
+        self._client('logs').create_log_group(
+            logGroupName=name
+        )
+
+    def put_retention_policy(self, name: str, retention_in_days: int) -> None:
+        self._client('logs').put_retention_policy(
+            logGroupName=name,
+            retentionInDays=retention_in_days
+        )
+
     def get_rest_api_id(self, name: str) -> Optional[str]:
         """Get rest api id associated with an API name.
 

chalice/config.py

@@ -160,6 +160,10 @@ def lambda_python_version(self) -> str:
             return 'python3.8'
         return 'python3.9'
 
+    @property
+    def log_retention_in_days(self) -> int:
+        return self._chain_lookup('log_retention_in_days')
+
     @property
     def layers(self) -> List:
         return self._chain_lookup('layers',

chalice/deploy/appgraph.py

@@ -48,6 +48,13 @@ def build(self, config, stage_name):
             resources.append(websocket_api)
         return models.Application(stage_name, resources)
 
+    def _create_log_group(self,
+                          config,            # type: Config
+                          log_group_name     # type: str
+                          ):
+        # type: (...) -> models.LogGroup
+        return models.LogGroup(resource_name=log_group_name, retention_in_days=config.log_retention_in_days)
+
     def _create_custom_domain_name(
             self,
             api_type,                # type: models.APIType
@@ -367,6 +374,8 @@ def _create_lambda_model(self,
             new_config, name, handler_name,
             deployment, role
         )
+        if config.log_retention_in_days:
+            resource.log_group = self._create_log_group(config, '/aws/lambda/%s-%s-%s' % (config.app_name, stage_name, name))
         return resource
 
     def _get_managed_lambda_layer(self, config):

chalice/deploy/models.py

@@ -208,12 +208,16 @@ class LambdaFunction(ManagedModel):
     layers = attrib()                 # type: List[str]
     managed_layer = attrib(
         default=None)                 # type: Opt[LambdaLayer]
+    log_group = attrib(default=None)  # type: LogGroup
+
 
     def dependencies(self):
         # type: () -> List[Model]
         resources = []  # type: List[Model]
         if self.managed_layer is not None:
             resources.append(self.managed_layer)
+        if self.log_group is not None:
+            resources.append(self.log_group)
         resources.extend([self.role, self.deployment_package])
         return resources
 
@@ -245,6 +249,12 @@ class ScheduledEvent(CloudWatchEventBase):
     rule_description = attrib(default=None)     # type: str
 
 
+@attrs
+class LogGroup(ManagedModel):
+    resource_type = 'log_group'
+    retention_in_days = attrib()    # type: int
+
+
 @attrs
 class APIMapping(ManagedModel):
     resource_type = 'api_mapping'

chalice/deploy/planner.py

@@ -139,6 +139,10 @@ def _resource_exists_lambdalayer(self, resource):
         return bool(self._client.get_layer_version(
             deployed_values['layer_version_arn']))
 
+    def _resource_exists_loggroup(self, resource):
+        # type: (models.LogGroup) -> bool
+        return self._client.log_group_exists(resource.resource_name)
+    
     def _resource_exists_lambdafunction(self, resource):
         # type: (models.LambdaFunction) -> bool
         return self._client.lambda_function_exists(resource.function_name)
@@ -820,6 +824,29 @@ def _plan_kinesiseventsource(self, resource):
             }
         )
 
+    def _plan_loggroup(self, resource):
+        # type: (models.LogGroup) -> Sequence[InstructionMsg]
+        instructions = []  # type: List[InstructionMsg]
+        if self._remote_state.resource_exists(resource):
+            return instructions + [
+                models.APICall(
+                    method_name='put_retention_policy',
+                    params={'name': resource.resource_name,
+                            'retention_in_days': resource.retention_in_days}
+                )
+            ]
+        return instructions + [
+            models.APICall(
+                method_name='create_log_group',
+                params={'name': resource.resource_name}
+            ),
+            models.APICall(
+                method_name='put_retention_policy',
+                params={'name': resource.resource_name,
+                        'retention_in_days': resource.retention_in_days}
+            )
+        ]
+
     def _plan_dynamodbeventsource(self, resource):
         # type: (models.DynamoDBEventSource) -> Sequence[InstructionMsg]
         uuid_varname = '%s_uuid' % resource.resource_name