feat: allow specifying format-able default values

Author: spaceone

README.md

@@ -190,6 +190,34 @@ logging.basicConfig(handlers=[handler])
 logging.error("hello") # at=ERROR when=2022-04-20 msg=hello
 ```
 
+**defaults**
+
+Instead of providing key/value pairs at each log call, you can provide defaults:
+
+```py
+import logging
+from logfmter import Logfmter
+
+formatter = Logfmter(
+    keys=["at", "when", "trace_id"],
+    mapping={"at": "levelname", "when": "asctime"},
+    datefmt="%Y-%m-%d",
+    defaults={"trace_id": "123"},
+)
+
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+
+logging.basicConfig(handlers=[handler])
+
+logging.error("hello") # at=ERROR when=2022-04-20 trace_id=123 msg=hello
+```
+
+This will cause all logs to have the `trace_id=123` pair regardless of including
+`trace_id` in keys or manually adding `trace_id` to the `extra` parameter or the `msg` object.
+
+> Note, the defaults object uses format strings as values. This allows for variables templating. See "Aliases" guide for more information.
+
 ## Extension
 
 You can subclass the formatter to change its behavior.
@@ -222,24 +250,28 @@ logging.error({"example": True}) # at=ERROR example=yes
 
 ## Guides
 
-**Default Key/Value Pairs**
+**Aliases**
 
-Instead of providing key/value pairs at each log call, you can override
-the log record factory to provide defaults:
+Providing a format string as a default's key/value allows the realization of aliases:
 
 ```py
-_record_factory = logging.getLogRecordFactory()
+import logging
+from logfmter import Logfmter
 
-def record_factory(*args, **kwargs):
-    record = _record_factory(*args, **kwargs)
-    record.trace_id = 123
-    return record
+formatter = Logfmter(
+    keys=["at", "when", "func"],
+    mapping={"at": "levelname", "when": "asctime"},
+    datefmt="%Y-%m-%d",
+    defaults={"func": "{module}.{funcName}:{lineno}"},
+)
 
-logging.setLogRecordFactory(record_factory)
-```
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
 
-This will cause all logs to have the `trace_id=123` pair regardless of including
-`trace_id` in keys or manually adding `trace_id` to the `extra` parameter or the `msg` object.
+logging.basicConfig(handlers=[handler])
+
+logging.error("hello") # at=ERROR when=2022-04-20 func="mymodule.__main__:12" msg=hello
+```
 
 ## Gotchas
 

src/logfmter/formatter.py

@@ -37,6 +37,22 @@
 )
 
 
+class _DefaultFormatter(logging.Formatter):
+    def format(self, record):
+        exc_info = record.exc_info
+        exc_text = record.exc_text
+        stack_info = record.stack_info
+        record.exc_info = None
+        record.exc_text = None
+        record.stack_info = None
+        try:
+            return super().format(record)
+        finally:
+            record.exc_info = exc_info
+            record.exc_text = exc_text
+            record.stack_info = stack_info
+
+
 class Logfmter(logging.Formatter):
     @classmethod
     def format_string(cls, value: str) -> str:
@@ -168,12 +184,17 @@ def __init__(
         keys: List[str] = ["at"],
         mapping: Dict[str, str] = {"at": "levelname"},
         datefmt: Optional[str] = None,
+        defaults: Optional[Dict[str, str]] = None,
     ):
         self.keys = [self.normalize_key(key) for key in keys]
         self.mapping = {
             self.normalize_key(key): value for key, value in mapping.items()
         }
         self.datefmt = datefmt
+        self.defaults = {
+            key: _DefaultFormatter(value, style="{")
+            for key, value in (defaults or {}).items()
+        }
 
     def format(self, record: logging.LogRecord) -> str:
         # If the 'asctime' attribute will be used, then generate it.
@@ -208,12 +229,13 @@ def format(self, record: logging.LogRecord) -> str:
             if attribute in params:
                 continue
 
-            # If the attribute doesn't exist on the log record, then skip it.
-            if not hasattr(record, attribute):
+            if hasattr(record, attribute):
+                value = getattr(record, attribute)
+            elif attribute in self.defaults:
+                value = self.defaults[attribute].format(record)
+            else:
                 continue
 
-            value = getattr(record, attribute)
-
             tokens.append("{}={}".format(key, self.format_value(value)))
 
         formatted_params = self.format_params(params)

tests/test_formatter.py

@@ -316,3 +316,33 @@ def test_external_tools_compatibility(value):
     assert result.returncode == 0, formatted
     assert len(result.stdout.splitlines()) == 1, formatted
     assert result.stdout.splitlines()[0] == formatted
+
+
+@pytest.mark.parametrize(
+    "record",
+    [
+        {
+            "msg": "alpha",
+            "levelname": "INFO",
+            "funcName": "test_defaults",
+            "module": "test_formatter",
+            "lineno": "324",
+        },
+        {
+            "msg": {"msg": "alpha"},
+            "levelname": "INFO",
+            "funcName": "test_defaults",
+            "module": "test_formatter",
+            "lineno": "324",
+        },
+    ],
+)
+def test_defaults(record):
+    record = logging.makeLogRecord(record)
+
+    assert (
+        Logfmter(
+            keys=["at", "func"], defaults={"func": "{module}.{funcName}:{lineno}"}
+        ).format(record)
+        == "at=INFO func=test_formatter.test_defaults:324 msg=alpha"
+    )