Fixing up CI and mutations

Author: crimsonknave

.github/workflows/pytest.yaml

@@ -12,7 +12,10 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        # pytest-forked does not work on windows and we currently use it for isolation
+        # of logging configs as logging.dictConfig has a setting to not disable old loggers
+        # but, does seem to trample old handlers, filters and formatters
+        os: [ubuntu-latest, macos-latest]
         python-version: ["3.9", "3.10", "3.11", "pypy3.9", "pypy3.10"]
         exclude:
           - os: macos-latest

annotated_logger/__init__.py

@@ -87,12 +87,12 @@ class AnnotatedClass(Protocol[C_co]):
 Annotations = dict[str, Any]
 
 
-DEFAULT_LOGGING_CONFIG = {  # pragma: no mutate
+DEFAULT_LOGGING_CONFIG = {
     "version": 1,
-    "disable_existing_loggers": False,
+    "disable_existing_loggers": False,  # pragma: no mutate
     "filters": {
         "annotated_filter": {
-            "annotated_filter": True,
+            "annotated_filter": True,  # pragma: no mutate
         }
     },
     "handlers": {
@@ -104,19 +104,19 @@ class AnnotatedClass(Protocol[C_co]):
     },
     "formatters": {
         "annotated_formatter": {
-            "class": "pythonjsonlogger.jsonlogger.JsonFormatter",
+            "class": "pythonjsonlogger.jsonlogger.JsonFormatter",  # pragma: no mutate
             # Note that this format string uses `time` and `level` which are
             # set by the renamer plugin. Because the handler is using the
             # annotated_filter the plugings will be run and the fields will be renamed
-            "format": "{created} {levelname} {name} {message}",
+            "format": "{created} {levelname} {name} {message}",  # pragma: no mutate
             "style": "{",
         },
     },
     "loggers": {
         "annotated_logger": {
             "level": "DEBUG",
             "handlers": ["annotated_handler"],
-            "propagate": False,
+            "propagate": False,  # pragma: no mutate
         },
     },
 }
@@ -337,7 +337,6 @@ def __init__(  # noqa: PLR0913
         log_level: int = logging.INFO,
         name: str = "annotated_logger",
         config: dict[str, Any] | Literal[False] | None = None,
-        # TODO: boolean for correlation_id and then auto generate it
     ) -> None:
         """Store the settings.
 

annotated_logger/mocks.py

@@ -106,18 +106,14 @@ def _check_record_matches(
         record: logging.LogRecord,
     ) -> list[str]:
         differences = []
-        if "levelname" in record.__dict__:
-            level = record.levelname
-        elif "level" in record.__dict__:
-            level = record.level  # pyright: ignore[reportAttributeAccessIssue]
-        # If you have removed levelname and levelno and didn't add level... good luck
-        else:
-            level = {
-                logging.DEBUG: "DEBUG",
-                logging.INFO: "INFO",
-                logging.WARNING: "WARNING",
-                logging.ERROR: "ERROR",
-            }[record.levelno]
+        # `levelname` is often renamed. But, `levelno` shouldn't be touched as often
+        # So, don't try to guess what the level name is, just use the levelno.
+        level = {
+            logging.DEBUG: "DEBUG",
+            logging.INFO: "INFO",
+            logging.WARNING: "WARNING",
+            logging.ERROR: "ERROR",
+        }[record.levelno]
         actual = {
             "level": level,
             "msg": record.msg,

example/logging_config.py

@@ -40,11 +40,11 @@
             # But, if you want to do that you are likely better off
             # using a filter not associated with an AnnotatedLogger
             # like the `logging_config.logger_filter_parens` below
-            "annotations": {"decorated": False},
+            "annotations": {"config_based_filter": True},
         },
         "logging_config.logger_filter_parens": {
             "()": AnnotatedFilter,
-            "annotations": {"decorated": False},
+            "annotations": {"decorated": False, "class_based_filter": True},
             "class_annotations": {},
             "runtime_annotations": {"custom_runtime": lambda _record: True},
             "plugins": [BasePlugin()],
@@ -80,10 +80,9 @@
     "formatters": {
         "logging_config.annotated_formatter": {
             "class": "pythonjsonlogger.jsonlogger.JsonFormatter",
-            # Note that this format string uses `time` and `level` which are
-            # set by the renamer plugin. Because the handler is using the
-            # annotated_filter the plugings will be run and the fields will be renamed
-            # This also pulls the `runtime` annotation to a specific place in the log
+            # Note that this format string uses `time` which is set by the renamer
+            # plugin. It also has `lvl` which is there strictly to test our fallback
+            # to using `levelno` in the mocks to determine level.
             "format": "{time} {lvl} {name} {runtime} {message}",
             "style": "{",
         },
@@ -92,7 +91,7 @@
             "style": "{",
         },
         "logging_config.long_formatter": {
-            "format": "{level} Long message, may be split {message}",
+            "format": "{lvl} Long message, may be split {message}",
             # 3.12 added support for defaults in dict configs
             # With that we can add the format and defaults below
             # for a more realistic example. Not all of the messages
@@ -143,7 +142,7 @@ def runtime(_record: logging.LogRecord) -> str:
 annotated_logger = AnnotatedLogger(
     annotations={"hostname": "my-host"},
     runtime_annotations={"runtime": runtime},
-    plugins=[RenamerPlugin(time="created", level="levelname")],
+    plugins=[RenamerPlugin(time="created", lvl="levelname")],
     log_level=logging.DEBUG,
     max_length=200,
     name="annotated_logger.logging_config",

test/test_logging_config.py

@@ -22,8 +22,12 @@ def test_base_logging(self, annotated_logger_mock):
             annotated_logger_mock.assert_logged(
                 level,
                 f"this is {level}",
-                present={"decorated": False},
-                absent=["weird"],
+                present={
+                    "decorated": False,
+                    "config_based_filter": True,
+                    "class_based_filter": True,
+                },
+                absent=["weird", "hostname"],
             )
 
     def test_annotated_logging(self, annotated_logger_mock: AnnotatedLogMock):