Logging: allow setting name, args on default handler (post-blacken) (#6828)

- Expose 'stream' argument to handler constructors.

  Defaults to 'None', passed to stdlib's 'logging.StreamHandler'.

- Expose 'name' argument to 'ContainerEngineHandler'.

* Add '**kw' to 'Client.{get_default_handler,setup_logging}'.

  Plumb them through to the underlying handler constructor.

Closes #6206.

Author: tseaver

google/cloud/logging/client.py

@@ -317,9 +317,12 @@ def list_metrics(self, page_size=None, page_token=None):
         """
         return self.metrics_api.list_metrics(self.project, page_size, page_token)
 
-    def get_default_handler(self):
+    def get_default_handler(self, **kw):
         """Return the default logging handler based on the local environment.
 
+        :type kw: dict
+        :param kw: keyword args passed to handler constructor
+
         :rtype: :class:`logging.Handler`
         :returns: The default log handler based on the environment
         """
@@ -329,14 +332,14 @@ def get_default_handler(self):
             _APPENGINE_FLEXIBLE_ENV_VM in os.environ
             or _APPENGINE_INSTANCE_ID in os.environ
         ):
-            return AppEngineHandler(self)
+            return AppEngineHandler(self, **kw)
         elif gke_cluster_name is not None:
-            return ContainerEngineHandler()
+            return ContainerEngineHandler(**kw)
         else:
-            return CloudLoggingHandler(self)
+            return CloudLoggingHandler(self, **kw)
 
     def setup_logging(
-        self, log_level=logging.INFO, excluded_loggers=EXCLUDED_LOGGER_DEFAULTS
+        self, log_level=logging.INFO, excluded_loggers=EXCLUDED_LOGGER_DEFAULTS, **kw
     ):
         """Attach default Stackdriver logging handler to the root logger.
 
@@ -354,6 +357,9 @@ def setup_logging(
                                  handler to. This will always include the
                                  loggers in the path of the logging client
                                  itself.
+
+        :type kw: dict
+        :param kw: keyword args passed to handler constructor
         """
-        handler = self.get_default_handler()
+        handler = self.get_default_handler(**kw)
         setup_logging(handler, log_level=log_level, excluded_loggers=excluded_loggers)

google/cloud/logging/handlers/app_engine.py

@@ -46,12 +46,19 @@ class AppEngineHandler(logging.StreamHandler):
     :param transport: The transport class. It should be a subclass
                       of :class:`.Transport`. If unspecified,
                       :class:`.BackgroundThreadTransport` will be used.
+
+    :type stream: file-like object
+    :param stream: (optional) stream to be used by the handler.
     """
 
     def __init__(
-        self, client, name=_DEFAULT_GAE_LOGGER_NAME, transport=BackgroundThreadTransport
+        self,
+        client,
+        name=_DEFAULT_GAE_LOGGER_NAME,
+        transport=BackgroundThreadTransport,
+        stream=None,
     ):
-        super(AppEngineHandler, self).__init__()
+        super(AppEngineHandler, self).__init__(stream)
         self.name = name
         self.client = client
         self.transport = transport(client, name)

google/cloud/logging/handlers/container_engine.py

@@ -29,8 +29,18 @@ class ContainerEngineHandler(logging.StreamHandler):
 
     This handler is written to format messages for the Google Container Engine
     (GKE) fluentd plugin, so that metadata such as log level are properly set.
+
+    :type name: str
+    :param name: (optional) the name of the custom log in Stackdriver Logging.
+
+    :type stream: file-like object
+    :param stream: (optional) stream to be used by the handler.
     """
 
+    def __init__(self, name=None, stream=None):
+        super(ContainerEngineHandler, self).__init__()
+        self.name = name
+
     def format(self, record):
         """Format the message into JSON expected by fluentd.
 

google/cloud/logging/handlers/handlers.py

@@ -58,6 +58,9 @@ class CloudLoggingHandler(logging.StreamHandler):
     :type labels: dict
     :param labels: (Optional) Mapping of labels for the entry.
 
+    :type stream: file-like object
+    :param stream: (optional) stream to be used by the handler.
+
     Example:
 
     .. code-block:: python
@@ -74,7 +77,6 @@ class CloudLoggingHandler(logging.StreamHandler):
         cloud_logger.addHandler(handler)
 
         cloud_logger.error('bad news')  # API call
-
     """
 
     def __init__(
@@ -84,8 +86,9 @@ def __init__(
         transport=BackgroundThreadTransport,
         resource=_GLOBAL_RESOURCE,
         labels=None,
+        stream=None,
     ):
-        super(CloudLoggingHandler, self).__init__()
+        super(CloudLoggingHandler, self).__init__(stream)
         self.name = name
         self.client = client
         self.transport = transport(client, name)

tests/unit/handlers/test_app_engine.py

@@ -29,11 +29,9 @@ def _get_target_class(self):
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-    def test_constructor(self):
-        from google.cloud.logging.handlers.app_engine import _GAE_PROJECT_ENV_FLEX
-        from google.cloud.logging.handlers.app_engine import _GAE_PROJECT_ENV_STANDARD
-        from google.cloud.logging.handlers.app_engine import _GAE_SERVICE_ENV
-        from google.cloud.logging.handlers.app_engine import _GAE_VERSION_ENV
+    def test_constructor_w_gae_standard_env(self):
+        import sys
+        from google.cloud.logging.handlers import app_engine
 
         client = mock.Mock(project=self.PROJECT, spec=["project"])
 
@@ -42,35 +40,51 @@ def test_constructor(self):
         with mock.patch(
             "os.environ",
             new={
-                _GAE_PROJECT_ENV_STANDARD: "test_project",
-                _GAE_SERVICE_ENV: "test_service",
-                _GAE_VERSION_ENV: "test_version",
+                app_engine._GAE_PROJECT_ENV_STANDARD: "test_project",
+                app_engine._GAE_SERVICE_ENV: "test_service",
+                app_engine._GAE_VERSION_ENV: "test_version",
             },
         ):
             handler = self._make_one(client, transport=_Transport)
+
         self.assertIs(handler.client, client)
+        self.assertEqual(handler.name, app_engine._DEFAULT_GAE_LOGGER_NAME)
         self.assertEqual(handler.resource.type, "gae_app")
         self.assertEqual(handler.resource.labels["project_id"], "test_project")
         self.assertEqual(handler.resource.labels["module_id"], "test_service")
         self.assertEqual(handler.resource.labels["version_id"], "test_version")
+        self.assertIs(handler.stream, sys.stderr)
+
+    def test_constructor_w_gae_flex_env(self):
+        import io
+        from google.cloud.logging.handlers import app_engine
+
+        client = mock.Mock(project=self.PROJECT, spec=["project"])
+        name = "test-logger"
+        stream = io.BytesIO()
 
         # Verify that _GAE_PROJECT_ENV_FLEX environment variable takes
         # precedence over _GAE_PROJECT_ENV_STANDARD.
         with mock.patch(
             "os.environ",
             new={
-                _GAE_PROJECT_ENV_FLEX: "test_project_2",
-                _GAE_PROJECT_ENV_STANDARD: "test_project_should_be_overridden",
-                _GAE_SERVICE_ENV: "test_service_2",
-                _GAE_VERSION_ENV: "test_version_2",
+                app_engine._GAE_PROJECT_ENV_FLEX: "test_project_2",
+                app_engine._GAE_PROJECT_ENV_STANDARD: "test_project_should_be_overridden",
+                app_engine._GAE_SERVICE_ENV: "test_service_2",
+                app_engine._GAE_VERSION_ENV: "test_version_2",
             },
         ):
-            handler = self._make_one(client, transport=_Transport)
+            handler = self._make_one(
+                client, name=name, transport=_Transport, stream=stream
+            )
+
         self.assertIs(handler.client, client)
+        self.assertEqual(handler.name, name)
         self.assertEqual(handler.resource.type, "gae_app")
         self.assertEqual(handler.resource.labels["project_id"], "test_project_2")
         self.assertEqual(handler.resource.labels["module_id"], "test_service_2")
         self.assertEqual(handler.resource.labels["version_id"], "test_version_2")
+        self.assertIs(handler.stream, stream)
 
     def test_emit(self):
         client = mock.Mock(project=self.PROJECT, spec=["project"])

tests/unit/handlers/test_container_engine.py

@@ -28,6 +28,14 @@ def _get_target_class(self):
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
+    def test_ctor_defaults(self):
+        handler = self._make_one()
+        self.assertIsNone(handler.name)
+
+    def test_ctor_w_name(self):
+        handler = self._make_one(name="foo")
+        self.assertEqual(handler.name, "foo")
+
     def test_format(self):
         import logging
         import json

tests/unit/handlers/test_handlers.py

@@ -29,10 +29,47 @@ def _get_target_class():
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-    def test_ctor(self):
+    def test_ctor_defaults(self):
+        import sys
+        from google.cloud.logging.logger import _GLOBAL_RESOURCE
+        from google.cloud.logging.handlers.handlers import DEFAULT_LOGGER_NAME
+
         client = _Client(self.PROJECT)
         handler = self._make_one(client, transport=_Transport)
-        self.assertEqual(handler.client, client)
+        self.assertEqual(handler.name, DEFAULT_LOGGER_NAME)
+        self.assertIs(handler.client, client)
+        self.assertIsInstance(handler.transport, _Transport)
+        self.assertIs(handler.transport.client, client)
+        self.assertEqual(handler.transport.name, DEFAULT_LOGGER_NAME)
+        self.assertIs(handler.resource, _GLOBAL_RESOURCE)
+        self.assertIsNone(handler.labels)
+        self.assertIs(handler.stream, sys.stderr)
+
+    def test_ctor_explicit(self):
+        import io
+        from google.cloud.logging.resource import Resource
+
+        resource = Resource("resource_type", {"resource_label": "value"})
+        labels = {"handler_lable": "value"}
+        name = "test-logger"
+        client = _Client(self.PROJECT)
+        stream = io.BytesIO()
+        handler = self._make_one(
+            client,
+            name=name,
+            transport=_Transport,
+            resource=resource,
+            labels=labels,
+            stream=stream,
+        )
+        self.assertEqual(handler.name, name)
+        self.assertIs(handler.client, client)
+        self.assertIsInstance(handler.transport, _Transport)
+        self.assertIs(handler.transport.client, client)
+        self.assertEqual(handler.transport.name, name)
+        self.assertIs(handler.resource, resource)
+        self.assertEqual(handler.labels, labels)
+        self.assertIs(handler.stream, stream)
 
     def test_emit(self):
         from google.cloud.logging.logger import _GLOBAL_RESOURCE
@@ -108,7 +145,8 @@ def __init__(self, project):
 
 class _Transport(object):
     def __init__(self, client, name):
-        pass
+        self.client = client
+        self.name = name
 
     def send(self, record, message, resource, labels=None):
         self.send_called_with = (record, message, resource, labels)

tests/unit/test_client.py

@@ -552,20 +552,23 @@ def test_get_default_handler_app_engine(self):
         from google.cloud.logging.handlers import AppEngineHandler
 
         credentials = _make_credentials()
+        client = self._make_one(
+            project=self.PROJECT, credentials=credentials, _use_grpc=False
+        )
 
         with _Monkey(os, environ={_APPENGINE_FLEXIBLE_ENV_VM: "True"}):
-            client = self._make_one(
-                project=self.PROJECT, credentials=credentials, _use_grpc=False
-            )
             handler = client.get_default_handler()
 
+        handler.transport.worker.stop()
+
         self.assertIsInstance(handler, AppEngineHandler)
 
     def test_get_default_handler_container_engine(self):
         from google.cloud.logging.handlers import ContainerEngineHandler
 
+        credentials = _make_credentials()
         client = self._make_one(
-            project=self.PROJECT, credentials=_make_credentials(), _use_grpc=False
+            project=self.PROJECT, credentials=credentials, _use_grpc=False
         )
 
         patch = mock.patch(
@@ -579,29 +582,92 @@ def test_get_default_handler_container_engine(self):
         self.assertIsInstance(handler, ContainerEngineHandler)
 
     def test_get_default_handler_general(self):
+        import io
         from google.cloud.logging.handlers import CloudLoggingHandler
+        from google.cloud.logging.resource import Resource
 
-        credentials = _make_credentials()
+        name = "test-logger"
+        resource = Resource("resource_type", {"resource_label": "value"})
+        labels = {"handler_label": "value"}
+        stream = io.BytesIO()
 
+        credentials = _make_credentials()
         client = self._make_one(
             project=self.PROJECT, credentials=credentials, _use_grpc=False
         )
-        handler = client.get_default_handler()
+
+        handler = client.get_default_handler(
+            name=name, resource=resource, labels=labels, stream=stream
+        )
+
+        handler.transport.worker.stop()
 
         self.assertIsInstance(handler, CloudLoggingHandler)
+        self.assertEqual(handler.name, name)
+        self.assertEqual(handler.resource, resource)
+        self.assertEqual(handler.labels, labels)
 
     def test_setup_logging(self):
-        setup_logging = mock.Mock(spec=[])
+        from google.cloud.logging.handlers import CloudLoggingHandler
 
         credentials = _make_credentials()
+        client = self._make_one(
+            project=self.PROJECT, credentials=credentials, _use_grpc=False
+        )
 
-        with mock.patch("google.cloud.logging.client.setup_logging", new=setup_logging):
-            client = self._make_one(
-                project=self.PROJECT, credentials=credentials, _use_grpc=False
-            )
+        with mock.patch("google.cloud.logging.client.setup_logging") as mocked:
             client.setup_logging()
 
-        setup_logging.assert_called()
+        self.assertEqual(len(mocked.mock_calls), 1)
+        _, args, kwargs = mocked.mock_calls[0]
+
+        handler, = args
+        self.assertIsInstance(handler, CloudLoggingHandler)
+
+        handler.transport.worker.stop()
+
+        expected_kwargs = {
+            "excluded_loggers": ("google.cloud", "google.auth", "google_auth_httplib2"),
+            "log_level": 20,
+        }
+        self.assertEqual(kwargs, expected_kwargs)
+
+    def test_setup_logging_w_extra_kwargs(self):
+        import io
+        from google.cloud.logging.handlers import CloudLoggingHandler
+        from google.cloud.logging.resource import Resource
+
+        name = "test-logger"
+        resource = Resource("resource_type", {"resource_label": "value"})
+        labels = {"handler_label": "value"}
+        stream = io.BytesIO()
+
+        credentials = _make_credentials()
+        client = self._make_one(
+            project=self.PROJECT, credentials=credentials, _use_grpc=False
+        )
+
+        with mock.patch("google.cloud.logging.client.setup_logging") as mocked:
+            client.setup_logging(
+                name=name, resource=resource, labels=labels, stream=stream
+            )
+
+        self.assertEqual(len(mocked.mock_calls), 1)
+        _, args, kwargs = mocked.mock_calls[0]
+
+        handler, = args
+        self.assertIsInstance(handler, CloudLoggingHandler)
+        self.assertEqual(handler.name, name)
+        self.assertEqual(handler.resource, resource)
+        self.assertEqual(handler.labels, labels)
+
+        handler.transport.worker.stop()
+
+        expected_kwargs = {
+            "excluded_loggers": ("google.cloud", "google.auth", "google_auth_httplib2"),
+            "log_level": 20,
+        }
+        self.assertEqual(kwargs, expected_kwargs)
 
 
 class _Connection(object):