fixup! feat: allow specifying excluded ignored_keys

Author: spaceone

src/logfmter/formatter.py

@@ -141,44 +141,39 @@ def normalize_key(cls, key: str) -> str:
 
         return key.replace(" ", "_").replace("\n", "\\n")
 
-    def get_extra(self, record: logging.LogRecord) -> dict:
+    @classmethod
+    def get_extra(cls, record: logging.LogRecord) -> dict:
         """
         Return a dictionary of logger extra parameters by filtering any reserved keys.
         """
         extras = {}
 
         for key, value in record.__dict__.items():
-            if key in self.ignored_keys:
-                continue
-            key = self.normalize_key(key)
+            key = cls.normalize_key(key)
 
             if key in RESERVED:
                 continue
 
             if isinstance(value, dict):
-                extras.update(self.flatten_dict(value, key))
+                extras.update(cls.flatten_dict(value, key))
             else:
                 extras[key] = value
 
         return extras
 
-    def flatten_dict(self, v: dict, root: str = "") -> dict[str, Any]:
+    @classmethod
+    def flatten_dict(cls, v: dict, root: str = "") -> dict[str, Any]:
         """
         Return a dictionary whereby the input dictionary is converted to
         depth equal to one with keys that are joined via periods.
         """
         flattened = {}
 
         for key, value in v.items():
-            key = (
-                f"{root}.{self.normalize_key(key)}" if root else self.normalize_key(key)
-            )
-
-            if key in self.ignored_keys:
-                continue
+            key = f"{root}.{cls.normalize_key(key)}" if root else cls.normalize_key(key)
 
             if isinstance(value, dict):
-                flattened.update(self.flatten_dict(value, key))
+                flattened.update(cls.flatten_dict(value, key))
             else:
                 flattened[key] = value
 
@@ -211,8 +206,6 @@ def format(self, record: logging.LogRecord) -> str:
 
         if isinstance(record.msg, dict):
             params = self.flatten_dict(record.msg)
-        elif "msg" in self.ignored_keys:
-            params = {}
         else:
             params = {"msg": record.getMessage()}
 
@@ -251,7 +244,14 @@ def format(self, record: logging.LogRecord) -> str:
 
             tokens.append("{}={}".format(key, self.format_value(value)))
 
-        formatted_params = self.format_params(params)
+        formatted_params = self.format_params(
+            {
+                k: v
+                for k, v in params.items()
+                if k not in self.ignored_keys
+                and k.split(".", 1)[0] not in self.ignored_keys
+            }
+        )
         if formatted_params:
             tokens.append(formatted_params)