Made logging integration entirely opt-in and configurable on the user-side

Author: dylan-robins

src/cleo/application.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import os
 import re
 import sys
@@ -30,7 +29,6 @@
 from cleo.io.io import IO
 from cleo.io.outputs.output import Verbosity
 from cleo.io.outputs.stream_output import StreamOutput
-from cleo.logging.cleo_handler import CleoHandler
 from cleo.terminal import Terminal
 from cleo.ui.ui import UI
 
@@ -311,7 +309,6 @@ def run(
             io = self.create_io(input, output, error_output)
 
             self._configure_io(io)
-            self._configure_logging(io)
 
             try:
                 exit_code = self._run(io)
@@ -533,17 +530,6 @@ def _configure_io(self, io: IO) -> None:
         if shell_verbosity == -1:
             io.interactive(False)
 
-    def _configure_logging(self, io: IO) -> None:
-        """
-        Configures the built-in logging package to write it's output via Cleo's output class.
-        """
-        handler = CleoHandler(io.output)
-        handler.setLevel(handler.remap_verbosity(io.output.verbosity))
-
-        root = logging.getLogger()
-        root.addHandler(handler)
-        root.setLevel(handler.level)
-
     @property
     def _default_definition(self) -> Definition:
         return Definition(

src/cleo/logging/cleo_handler.py

@@ -2,6 +2,7 @@
 
 import logging
 
+from logging import LogRecord
 from typing import TYPE_CHECKING
 from typing import ClassVar
 
@@ -12,6 +13,25 @@
     from cleo.io.outputs.output import Output
 
 
+class CleoFilter:
+    def __init__(self, output: Output):
+        self.output = output
+
+    @property
+    def current_loglevel(self) -> int:
+        verbosity_mapping: dict[Verbosity, int] = {
+            Verbosity.QUIET: logging.CRITICAL,  # Nothing gets emitted to the output anyway
+            Verbosity.NORMAL: logging.WARNING,
+            Verbosity.VERBOSE: logging.INFO,
+            Verbosity.VERY_VERBOSE: logging.DEBUG,
+            Verbosity.DEBUG: logging.DEBUG,
+        }
+        return verbosity_mapping[self.output.verbosity]
+
+    def filter(self, record: LogRecord) -> bool:
+        return record.levelno >= self.current_loglevel
+
+
 class CleoHandler(logging.Handler):
     """
     A handler class which writes logging records, appropriately formatted,
@@ -28,6 +48,7 @@ class CleoHandler(logging.Handler):
     def __init__(self, output: Output):
         super().__init__()
         self.output = output
+        self.addFilter(CleoFilter(output))
 
     def emit(self, record: logging.LogRecord) -> None:
         """
@@ -40,20 +61,10 @@ def emit(self, record: logging.LogRecord) -> None:
         has an 'encoding' attribute, it is used to determine how to do the
         output to the stream.
         """
+
         try:
             msg = self.tags.get(record.levelname, "") + self.format(record) + "</>"
             self.output.write(msg, new_line=True)
 
         except Exception:
             self.handleError(record)
-
-    @staticmethod
-    def remap_verbosity(verbosity: Verbosity) -> int:
-        verbosity_mapping: dict[Verbosity, int] = {
-            Verbosity.QUIET: logging.CRITICAL,  # Nothing gets emitted to the output anyway
-            Verbosity.NORMAL: logging.WARNING,
-            Verbosity.VERBOSE: logging.INFO,
-            Verbosity.VERY_VERBOSE: logging.DEBUG,
-            Verbosity.DEBUG: logging.DEBUG,
-        }
-        return verbosity_mapping[verbosity]

tests/fixtures/foo4_command.py

@@ -7,11 +7,14 @@
 from cleo.commands.command import Command
 
 
+_logger = logging.getLogger(__file__)
+
+
 def log_stuff() -> None:
-    logging.debug("This is an debug log record")
-    logging.info("This is an info log record")
-    logging.warning("This is an warning log record")
-    logging.error("This is an error log record")
+    _logger.debug("This is an debug log record")
+    _logger.info("This is an info log record")
+    _logger.warning("This is an warning log record")
+    _logger.error("This is an error log record")
 
 
 class Foo4Command(Command):

tests/test_logging.py

@@ -1,51 +1,70 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import logging
 
 import pytest
 
 from cleo.application import Application
+from cleo.logging.cleo_handler import CleoHandler
 from cleo.testers.application_tester import ApplicationTester
 from tests.fixtures.foo4_command import Foo4Command
 
 
-if TYPE_CHECKING:
-    from cleo.commands.command import Command
-
-
-@pytest.mark.parametrize("cmd", (Foo4Command(),))
-def test_run_with_logging_integration_normal(cmd: Command) -> None:
+@pytest.fixture
+def app() -> Application:
     app = Application()
+    cmd = Foo4Command()
     app.add(cmd)
+    app._default_command = cmd.name
+    return app
+
+
+@pytest.fixture
+def tester(app: Application) -> ApplicationTester:
+    app.catch_exceptions(False)
+    return ApplicationTester(app)
+
+
+@pytest.fixture
+def root_logger() -> logging.Logger:
+    root = logging.getLogger()
+    root.setLevel(logging.NOTSET)
+    return root
+
 
-    tester = ApplicationTester(app)
-    status_code = tester.execute(f"{cmd.name}")
+def test_run_with_logging_integration_normal(
+    tester: ApplicationTester, root_logger: logging.Logger
+) -> None:
+    handler = CleoHandler(tester.io.output)
+    root_logger.addHandler(handler)
+
+    status_code = tester.execute("")
 
     expected = "This is an warning log record\n" "This is an error log record\n"
 
     assert status_code == 0
     assert tester.io.fetch_output() == expected
 
 
-@pytest.mark.parametrize("cmd", (Foo4Command(),))
-def test_run_with_logging_integration_quiet(cmd: Command) -> None:
-    app = Application()
-    app.add(cmd)
+def test_run_with_logging_integration_quiet(
+    tester: ApplicationTester, root_logger: logging.Logger
+) -> None:
+    handler = CleoHandler(tester.io.output)
+    root_logger.addHandler(handler)
 
-    tester = ApplicationTester(app)
-    status_code = tester.execute(f"{cmd.name} -q")
+    status_code = tester.execute("-q")
 
     assert status_code == 0
     assert tester.io.fetch_output() == ""
 
 
-@pytest.mark.parametrize("cmd", (Foo4Command(),))
-def test_run_with_logging_integration_verbose(cmd: Command) -> None:
-    app = Application()
-    app.add(cmd)
+def test_run_with_logging_integration_verbose(
+    tester: ApplicationTester, root_logger: logging.Logger
+) -> None:
+    handler = CleoHandler(tester.io.output)
+    root_logger.addHandler(handler)
 
-    tester = ApplicationTester(app)
-    status_code = tester.execute(f"{cmd.name} -v")
+    status_code = tester.execute("-v")
 
     expected = (
         "This is an info log record\n"
@@ -57,13 +76,13 @@ def test_run_with_logging_integration_verbose(cmd: Command) -> None:
     assert tester.io.fetch_output() == expected
 
 
-@pytest.mark.parametrize("cmd", (Foo4Command(),))
-def test_run_with_logging_integration_very_verbose(cmd: Command) -> None:
-    app = Application()
-    app.add(cmd)
+def test_run_with_logging_integration_very_verbose(
+    tester: ApplicationTester, root_logger: logging.Logger
+) -> None:
+    handler = CleoHandler(tester.io.output)
+    root_logger.addHandler(handler)
 
-    tester = ApplicationTester(app)
-    status_code = tester.execute(f"{cmd.name} -vv")
+    status_code = tester.execute("-vv")
 
     expected = (
         "This is an debug log record\n"