Add support for packaging app with log retention config

Also added a warning in the docs about using this config value
when generating cloudformation templates.

Author: jamesls

chalice/deploy/appgraph.py

@@ -50,10 +50,12 @@ def build(self, config, stage_name):
 
     def _create_log_group(self,
                           config,            # type: Config
+                          resource_name,     # type: str
                           log_group_name     # type: str
                           ):
         # type: (...) -> models.LogGroup
-        return models.LogGroup(resource_name=log_group_name,
+        return models.LogGroup(resource_name=resource_name,
+                               log_group_name=log_group_name,
                                retention_in_days=config.log_retention_in_days)
 
     def _create_custom_domain_name(
@@ -376,9 +378,11 @@ def _create_lambda_model(self,
             deployment, role
         )
         if config.log_retention_in_days:
+            log_resource_name = '%s-log-group' % name
+            log_group_name = '/aws/lambda/%s-%s-%s' % (
+                config.app_name, stage_name, name)
             resource.log_group = self._create_log_group(
-                config,
-                '/aws/lambda/%s-%s-%s' % (config.app_name, stage_name, name))
+                config, log_resource_name, log_group_name)
         return resource
 
     def _get_managed_lambda_layer(self, config):

chalice/deploy/models.py

@@ -251,6 +251,7 @@ class ScheduledEvent(CloudWatchEventBase):
 @attrs
 class LogGroup(ManagedModel):
     resource_type = 'log_group'
+    log_group_name = attrib()       # type: str
     retention_in_days = attrib()    # type: int
 
 

chalice/deploy/planner.py

@@ -831,18 +831,18 @@ def _plan_loggroup(self, resource):
             return instructions + [
                 models.APICall(
                     method_name='put_retention_policy',
-                    params={'name': resource.resource_name,
+                    params={'name': resource.log_group_name,
                             'retention_in_days': resource.retention_in_days}
                 )
             ]
         return instructions + [
             models.APICall(
                 method_name='create_log_group',
-                params={'name': resource.resource_name}
+                params={'name': resource.log_group_name}
             ),
             models.APICall(
                 method_name='put_retention_policy',
-                params={'name': resource.resource_name,
+                params={'name': resource.log_group_name,
                         'retention_in_days': resource.retention_in_days}
             )
         ]

chalice/package.py

@@ -281,6 +281,21 @@ def _generate_lambdafunction(self, resource, template):
             }  # type: Dict[str, Any]
             lambdafunction_definition['Properties'].update(layers_config)
 
+        if resource.log_group is not None:
+            num_days = resource.log_group.retention_in_days
+            log_name = self._register_cfn_resource_name(
+                resource.log_group.resource_name)
+            log_def = {
+                'Type': 'AWS::Logs::LogGroup',
+                'Properties': {
+                    'LogGroupName': {
+                        'Fn::Sub': '/aws/lambda/${%s}' % cfn_name
+                    },
+                    'RetentionInDays': num_days
+                }
+            }
+            resources[log_name] = log_def
+
         resources[cfn_name] = lambdafunction_definition
         self._add_iam_role(resource, resources[cfn_name])
 
@@ -299,6 +314,11 @@ def _add_iam_role(self, resource, cfn_resource):
             role = cast(models.PreCreatedIAMRole, role)
             cfn_resource['Properties']['Role'] = role.role_arn
 
+    def _generate_loggroup(self, resource, template):
+        # type: (models.LogGroup, Dict[str, Any]) -> None
+        # Handled in LambdaFunction generation
+        pass
+
     def _generate_restapi(self, resource, template):
         # type: (models.RestAPI, Dict[str, Any]) -> None
         resources = template['Resources']
@@ -1263,9 +1283,22 @@ def _generate_lambdafunction(self, resource, template):
             role = cast(models.PreCreatedIAMRole, resource.role)
             func_definition['role'] = role.role_arn
 
+        if resource.log_group is not None:
+            log_group = resource.log_group
+            num_days = log_group.retention_in_days
+            template['resource'].setdefault('aws_cloudwatch_log_group', {})[
+                log_group.resource_name] = {
+                    'name': log_group.resource_name,
+                    'retention_in_days': num_days,
+            }
         template['resource'].setdefault('aws_lambda_function', {})[
             resource.resource_name] = func_definition
 
+    def _generate_log_group(self, resource, remplate):
+        # type: (models.LogGroup, Dict[str, Any]) -> None
+        # Handled in LambdaFunction generation
+        pass
+
     def _generate_restapi(self, resource, template):
         # type: (models.RestAPI, Dict[str, Any]) -> None
 

docs/source/topics/configfile.rst

@@ -323,6 +323,15 @@ function log groups. Only certain values are valid, see the `AWS CloudWatch
 Logs docs
 <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutRetentionPolicy.html#API_PutRetentionPolicy_RequestParameters>`__
 
+.. warning::
+   If you using the `chalice package` command to generate a CloudFormation template,
+   a Log Group resource will be added to your template with the configured
+   ``log_retention_in_days``.  This will cause your deployment to fail
+   if this Log Group resource already exists (i.e. if the associated
+   Lambda function has previously been invoked which results in Lambda
+   automatically created a Log Group for the function).  In order to use
+   this configuration option, it should be part of the initial deployment
+   of the Lambda function.
 
 .. _lambda-config:
 

tests/unit/deploy/test_appgraph.py

@@ -169,7 +169,8 @@ def test_can_build_single_lambda_function_app_with_log_retention(
             managed_layer=None,
             xray=None,
             log_group=models.LogGroup(
-                resource_name='/aws/lambda/%s-%s-%s' %
+                resource_name='myfunction-log-group',
+                log_group_name='/aws/lambda/%s-%s-%s' %
                               (config.app_name, 'dev', 'myfunction'),
                 retention_in_days=14)
         )

tests/unit/deploy/test_planner.py

@@ -3187,32 +3187,34 @@ def test_can_create_log_group(self):
         self.remote_state.declare_no_resources_exists()
         resource = models.LogGroup(
             resource_name='default-log-group',
+            log_group_name='/aws/lambda/func-name',
             retention_in_days=14,
         )
         plan = self.determine_plan(resource)
         assert plan == [
             models.APICall(
                 method_name='create_log_group',
-                params={'name': 'default-log-group'}
+                params={'name': '/aws/lambda/func-name'}
             ),
             models.APICall(
                 method_name='put_retention_policy',
-                params={'name': 'default-log-group',
+                params={'name': '/aws/lambda/func-name',
                         'retention_in_days': 14},
             ),
         ]
 
     def test_can_update_log_group(self):
         resource = models.LogGroup(
             resource_name='default-log-group',
+            log_group_name='/aws/lambda/func-name',
             retention_in_days=14,
         )
         self.remote_state.declare_resource_exists(resource)
         plan = self.determine_plan(resource)
         assert plan == [
             models.APICall(
                 method_name='put_retention_policy',
-                params={'name': 'default-log-group',
+                params={'name': '/aws/lambda/func-name',
                         'retention_in_days': 14},
             ),
         ]

tests/unit/test_package.py

@@ -449,6 +449,20 @@ def test_adds_reserved_concurrency_when_provided(self, sample_app):
         tf_resource = self.get_function(template)
         assert tf_resource['reserved_concurrent_executions'] == 5
 
+    def test_adds_log_group_resource_when_configured(self, sample_app):
+        function = self.lambda_function()
+        name = function.resource_name + '-log-group'
+        function.log_group = models.LogGroup(
+            resource_name=name,
+            log_group_name='/aws/lambda/%s' % function.function_name,
+            retention_in_days=7)
+        template = self.template_gen.generate([function])
+        log_resource = template['resource']['aws_cloudwatch_log_group'][name]
+        assert log_resource == {
+            'name': name,
+            'retention_in_days': 7,
+        }
+
     def test_can_add_tracing_config(self, sample_app):
         function = self.lambda_function()
         function.xray = True
@@ -1202,6 +1216,22 @@ def test_adds_reserved_concurrency_when_provided(self, sample_app):
         cfn_resource = list(template['Resources'].values())[0]
         assert cfn_resource['Properties']['ReservedConcurrentExecutions'] == 5
 
+    def test_adds_log_group_resource_when_configured(self, sample_app):
+        function = self.lambda_function()
+        function.log_group = models.LogGroup(
+            resource_name=function.resource_name + '-log-group',
+            log_group_name='/aws/lambda/%s' % function.function_name,
+            retention_in_days=7)
+        template = self.template_gen.generate([function])
+        log_resource = template['Resources']['FooLogGroup']
+        assert log_resource == {
+            'Type': 'AWS::Logs::LogGroup',
+            'Properties': {
+                'LogGroupName': {'Fn::Sub': '/aws/lambda/${Foo}'},
+                'RetentionInDays': 7
+            }
+        }
+
     def test_adds_layers_when_provided(self, sample_app):
         function = self.lambda_function()
         function.layers = ['arn:aws:layer1', 'arn:aws:layer2']