Define method for oslo.log context parameters

This initial review defines a new method that will be used to define
and extend context attributes specifically useful in logging.
This enables other uses of the RequestContext to use the existing to_dict()
method.
This placholder is also needed for cross project dependencies with oslo.log.

Change-Id: I963a6db4aef74f7348e75a642e2e195cedacecaa
Implements: blueprint app-agnostic-logging-parameters

.gitignore

@@ -4,7 +4,7 @@
 *.so
 
 # Packages
-*.egg
+*.egg*
 *.egg-info
 dist
 build

oslo_context/context.py

@@ -14,10 +14,16 @@
 #    under the License.
 
 """
-Simple class that stores security context information in the web request.
+Base class for holding contextual information of a request
+
+This class has several uses:
+
+* Used for storing security information in a web request.
+* Used for passing contextual details to oslo.log.
 
 Projects should subclass this class if they wish to enhance the request
-context or provide additional information in their specific WSGI pipeline.
+context or provide additional information in their specific WSGI pipeline
+or logging context.
 """
 
 import itertools
@@ -29,6 +35,7 @@ _request_store = threading.local()
 
 
 def generate_request_id():
+    """Generate a unique request id."""
     return 'req-%s' % uuid.uuid4()
 
 
@@ -68,9 +75,11 @@ class RequestContext(object):
             self.update_store()
 
     def update_store(self):
+        """Store the context in the current thread."""
         _request_store.context = self
 
     def to_dict(self):
+        """Return a dictionary of context attributes."""
         user_idt = (
             self.user_idt_format.format(user=self.user or '-',
                                         tenant=self.tenant or '-',
@@ -91,8 +100,14 @@ class RequestContext(object):
                 'resource_uuid': self.resource_uuid,
                 'user_identity': user_idt}
 
+    def get_logging_values(self):
+        """Return a dictionary of logging specific context attributes."""
+        values = self.to_dict()
+        return values
+
     @classmethod
     def from_dict(cls, ctx):
+        """Construct a context object from a provided dictionary."""
         return cls(
             auth_token=ctx.get("auth_token"),
             user=ctx.get("user"),

oslo_context/tests/test_context.py

@@ -212,6 +212,70 @@ class ContextTest(test_base.BaseTestCase):
                                             user_domain, project_domain)
         self.assertEqual(user_identity, d['user_identity'])
 
+    def test_get_logging_values(self):
+        auth_token = "token1"
+        user = "user1"
+        tenant = "tenant1"
+        domain = "domain1"
+        user_domain = "user_domain1"
+        project_domain = "project_domain1"
+        is_admin = True
+        read_only = True
+        show_deleted = True
+        request_id = "id1"
+        resource_uuid = "uuid1"
+
+        ctx = context.RequestContext(auth_token=auth_token,
+                                     user=user,
+                                     tenant=tenant,
+                                     domain=domain,
+                                     user_domain=user_domain,
+                                     project_domain=project_domain,
+                                     is_admin=is_admin,
+                                     read_only=read_only,
+                                     show_deleted=show_deleted,
+                                     request_id=request_id,
+                                     resource_uuid=resource_uuid)
+        self.assertEqual(auth_token, ctx.auth_token)
+        self.assertEqual(user, ctx.user)
+        self.assertEqual(tenant, ctx.tenant)
+        self.assertEqual(domain, ctx.domain)
+        self.assertEqual(user_domain, ctx.user_domain)
+        self.assertEqual(project_domain, ctx.project_domain)
+        self.assertEqual(is_admin, ctx.is_admin)
+        self.assertEqual(read_only, ctx.read_only)
+        self.assertEqual(show_deleted, ctx.show_deleted)
+        self.assertEqual(request_id, ctx.request_id)
+        self.assertEqual(resource_uuid, ctx.resource_uuid)
+
+        d = ctx.get_logging_values()
+        self.assertIn('auth_token', d)
+        self.assertIn('user', d)
+        self.assertIn('tenant', d)
+        self.assertIn('domain', d)
+        self.assertIn('user_domain', d)
+        self.assertIn('project_domain', d)
+        self.assertIn('is_admin', d)
+        self.assertIn('read_only', d)
+        self.assertIn('show_deleted', d)
+        self.assertIn('request_id', d)
+        self.assertIn('resource_uuid', d)
+        self.assertIn('user_identity', d)
+
+        self.assertEqual(auth_token, d['auth_token'])
+        self.assertEqual(tenant, d['tenant'])
+        self.assertEqual(domain, d['domain'])
+        self.assertEqual(user_domain, d['user_domain'])
+        self.assertEqual(project_domain, d['project_domain'])
+        self.assertEqual(is_admin, d['is_admin'])
+        self.assertEqual(read_only, d['read_only'])
+        self.assertEqual(show_deleted, d['show_deleted'])
+        self.assertEqual(request_id, d['request_id'])
+        self.assertEqual(resource_uuid, d['resource_uuid'])
+        user_identity = "%s %s %s %s %s" % (user, tenant, domain,
+                                            user_domain, project_domain)
+        self.assertEqual(user_identity, d['user_identity'])
+
     def test_dict_empty_user_identity(self):
         ctx = context.RequestContext()
         d = ctx.to_dict()