PrintLogger: switch to print

src/structlog/_loggers.py

@@ -12,6 +12,7 @@
 import threading
 
 from pickle import PicklingError
+from sys import stderr, stdout
 from typing import IO, Any, BinaryIO, Dict, Optional, TextIO
 
 from structlog._utils import until_not_interrupted
@@ -49,20 +50,18 @@ class PrintLogger:
     """
 
     def __init__(self, file: Optional[TextIO] = None):
-        self._file = file or sys.stdout
-        self._write = self._file.write
-        self._flush = self._file.flush
+        self._file = file or stdout
 
         self._lock = _get_lock_for_file(self._file)
 
     def __getstate__(self) -> str:
         """
         Our __getattr__ magic makes this necessary.
         """
-        if self._file is sys.stdout:
+        if self._file is stdout:
             return "stdout"
 
-        elif self._file is sys.stderr:
+        elif self._file is stderr:
             return "stderr"
 
         raise PicklingError(
@@ -74,28 +73,24 @@ def __setstate__(self, state: Any) -> None:
         Our __getattr__ magic makes this necessary.
         """
         if state == "stdout":
-            self._file = sys.stdout
+            self._file = stdout
         else:
-            self._file = sys.stderr
+            self._file = stderr
 
-        self._write = self._file.write
-        self._flush = self._file.flush
         self._lock = _get_lock_for_file(self._file)
 
     def __deepcopy__(self, memodict: Dict[Any, Any] = {}) -> "PrintLogger":
         """
         Create a new PrintLogger with the same attributes. Similar to pickling.
         """
-        if self._file not in (sys.stdout, sys.stderr):
+        if self._file not in (stdout, stderr):
             raise copy.error(
                 "Only PrintLoggers to sys.stdout and sys.stderr "
                 "can be deepcopied."
             )
 
         newself = self.__class__(self._file)
 
-        newself._write = newself._file.write
-        newself._flush = newself._file.flush
         newself._lock = _get_lock_for_file(newself._file)
 
         return newself
@@ -107,9 +102,9 @@ def msg(self, message: str) -> None:
         """
         Print *message*.
         """
+        f = self._file if self._file is not stdout else None
         with self._lock:
-            until_not_interrupted(self._write, message + "\n")
-            until_not_interrupted(self._flush)
+            until_not_interrupted(print, message, file=f, flush=True)
 
     log = debug = info = warn = warning = msg
     fatal = failure = err = error = critical = exception = msg

tests/test_loggers.py

@@ -7,7 +7,7 @@
 import pickle
 import sys
 
-from io import BytesIO
+from io import BytesIO, StringIO
 
 import pytest
 
@@ -125,6 +125,20 @@ def test_deepcopy_no_stdout(self, tmp_path):
 
         assert "hello\n" == p.read_text()
 
+    def test_stdout_monkeypatch(self, monkeypatch, capsys):
+        """
+        If stdout gets monkeypatched, the new instance receives the output.
+        """
+        p = PrintLogger()
+        new_stdout = StringIO()
+        monkeypatch.setattr(sys, "stdout", new_stdout)
+        p.msg("hello")
+
+        out, err = capsys.readouterr()
+        assert "hello\n" == new_stdout.getvalue()
+        assert "" == out
+        assert "" == err
+
 
 class TestPrintLoggerFactory:
     def test_does_not_cache(self):