python-json-logger 4.0.0.dev0__tar.gz → 4.0.0rc1__tar.gz

{python_json_logger-4.0.0.dev0/src/python_json_logger.egg-info → python_json_logger-4.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-json-logger
-Version: 4.0.0.dev0
+Version: 4.0.0rc1
 Summary: JSON Log Formatter for the Python Logging Package
 Author-email: Zakaria Zajac <zak@madzak.com>, Nicholas Hairs <info+python-json-logger@nicholashairs.com>
 Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-json-logger"
-version = "4.0.0.dev0"
+version = "4.0.0.rc1"
 description = "JSON Log Formatter for the Python Logging Package"
 authors = [
     {name = "Zakaria Zajac", email = "zak@madzak.com"},

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1/src/python_json_logger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-json-logger
-Version: 4.0.0.dev0
+Version: 4.0.0rc1
 Summary: JSON Log Formatter for the Python Logging Package
 Author-email: Zakaria Zajac <zak@madzak.com>, Nicholas Hairs <info+python-json-logger@nicholashairs.com>
 Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/src/pythonjsonlogger/core.py

@@ -7,11 +7,10 @@ from __future__ import annotations
 
 ## Standard Library
 from datetime import datetime, timezone
-import importlib
 import logging
 import re
 import sys
-from typing import Optional, Union, Callable, List, Dict, Container, Any, Sequence
+from typing import Optional, Union, List, Dict, Container, Any, Sequence
 
 if sys.version_info >= (3, 10):
     from typing import TypeAlias
@@ -72,31 +71,15 @@ STYLE_PERCENT_REGEX = re.compile(r"%\((.+?)\)", re.IGNORECASE)  # % style
 
 ## Type Aliases
 ## -----------------------------------------------------------------------------
-OptionalCallableOrStr: TypeAlias = Optional[Union[Callable, str]]
-"""Type alias"""
+LogData: TypeAlias = Dict[str, Any]
+"""Type alias
 
-LogRecord: TypeAlias = Dict[str, Any]
-"""Type alias"""
+*Changed in 4.0*: renamed from `LogRecord` to `LogData`
+"""
 
 
 ### FUNCTIONS
 ### ============================================================================
-def str_to_object(obj: Any) -> Any:
-    """Import strings to an object, leaving non-strings as-is.
-
-    Args:
-        obj: the object or string to process
-
-    *New in 3.1*
-    """
-
-    if not isinstance(obj, str):
-        return obj
-
-    module_name, attribute_name = obj.rsplit(".", 1)
-    return getattr(importlib.import_module(module_name), attribute_name)
-
-
 def merge_record_extra(
     record: logging.LogRecord,
     target: Dict,
@@ -135,7 +118,7 @@ class BaseJsonFormatter(logging.Formatter):
 
     *Changed in 3.2*: `defaults` argument is no longer ignored.
 
-    *Added in UNRELEASED*: `exc_info_as_array` and `stack_info_as_array` options are added.
+    *Added in 3.3*: `exc_info_as_array` and `stack_info_as_array` options are added.
     """
 
     _style: Union[logging.PercentStyle, str]  # type: ignore[assignment]
@@ -145,7 +128,7 @@ class BaseJsonFormatter(logging.Formatter):
     # pylint: disable=too-many-arguments,super-init-not-called
     def __init__(
         self,
-        fmt: Optional[str] = None,
+        fmt: Optional[Union[str, Sequence[str]]] = None,
         datefmt: Optional[str] = None,
         style: str = "%",
         validate: bool = True,
@@ -162,11 +145,11 @@ class BaseJsonFormatter(logging.Formatter):
     ) -> None:
         """
         Args:
-            fmt: string representing fields to log
+            fmt: String format or `Sequence` of field names of fields to log.
             datefmt: format to use when formatting `asctime` field
-            style: how to extract log fields from `fmt`
+            style: how to extract log fields from `fmt`. Ignored if `fmt` is a `Sequence[str]`.
             validate: validate `fmt` against style, if implementing a custom `style` you
-                must set this to `False`.
+                must set this to `False`. Ignored if `fmt` is a `Sequence[str]`.
             defaults: a dictionary containing default fields that are added before all other fields and
                 may be overridden. The supplied fields are still subject to `rename_fields`.
             prefix: an optional string prefix added at the beginning of
@@ -192,23 +175,40 @@ class BaseJsonFormatter(logging.Formatter):
         - Renaming fields now preserves the order that fields were added in and avoids adding
           missing fields. The original behaviour, missing fields have a value of `None`, is still
           available by setting `rename_fields_keep_missing` to `True`.
+
+        *Added in 4.0*:
+
+        - `fmt` now supports comma seperated lists (`style=","`). Note that this style is specific
+          to `python-json-logger` and thus care should be taken to not to pass this format to other
+          logging Formatter implementations.
+        - `fmt` now supports sequences of strings (e.g. lists and tuples) of field names.
         """
         ## logging.Formatter compatibility
         ## ---------------------------------------------------------------------
-        # Note: validate added in 3.8, defaults added in 3.10
-        if style in logging._STYLES:
-            _style = logging._STYLES[style][0](fmt)  # type: ignore[operator]
-            if validate:
-                _style.validate()
-            self._style = _style
-            self._fmt = _style._fmt
-
-        elif not validate:
-            self._style = style
-            self._fmt = fmt
-
-        else:
-            raise ValueError(f"Style must be one of: {','.join(logging._STYLES.keys())}")
+        # Note: validate added in python 3.8, defaults added in 3.10
+        if fmt is None or isinstance(fmt, str):
+            if style in logging._STYLES:
+                _style = logging._STYLES[style][0](fmt)  # type: ignore[operator]
+                if validate:
+                    _style.validate()
+                self._style = _style
+                self._fmt = _style._fmt
+
+            elif style == "," or not validate:
+                self._style = style
+                self._fmt = fmt
+                # TODO: Validate comma format
+
+            else:
+                raise ValueError("Style must be one of: '%{$,'")
+
+            self._required_fields = self.parse()
+
+        # Note: we do this check second as string is still a Sequence[str]
+        elif isinstance(fmt, Sequence):
+            self._style = "__sequence__"
+            self._fmt = str(fmt)
+            self._required_fields = list(fmt)
 
         self.datefmt = datefmt
 
@@ -230,7 +230,6 @@ class BaseJsonFormatter(logging.Formatter):
         self.reserved_attrs = set(reserved_attrs if reserved_attrs is not None else RESERVED_ATTRS)
         self.timestamp = timestamp
 
-        self._required_fields = self.parse()
         self._skip_fields = set(self._required_fields)
         self._skip_fields.update(self.reserved_attrs)
         self.defaults = defaults if defaults is not None else {}
@@ -269,11 +268,11 @@ class BaseJsonFormatter(logging.Formatter):
         if record.stack_info and not message_dict.get("stack_info"):
             message_dict["stack_info"] = self.formatStack(record.stack_info)
 
-        log_record: LogRecord = {}
-        self.add_fields(log_record, record, message_dict)
-        log_record = self.process_log_record(log_record)
+        log_data: LogData = {}
+        self.add_fields(log_data, record, message_dict)
+        log_data = self.process_log_record(log_data)
 
-        return self.serialize_log_record(log_record)
+        return self.serialize_log_record(log_data)
 
     ## JSON Formatter Specific Methods
     ## -------------------------------------------------------------------------
@@ -288,6 +287,18 @@ class BaseJsonFormatter(logging.Formatter):
         Returns:
             list of fields to be extracted and serialized
         """
+        if self._fmt is None:
+            return []
+
+        if isinstance(self._style, str):
+            if self._style == "__sequence__":
+                raise RuntimeError("Must not call parse when fmt is a sequence of strings")
+
+            if self._style == ",":
+                return [field.strip() for field in self._fmt.split(",") if field.strip()]
+
+            raise ValueError(f"Style {self._style!r} is not supported")
+
         if isinstance(self._style, logging.StringTemplateStyle):
             formatter_style_pattern = STYLE_STRING_TEMPLATE_REGEX
 
@@ -302,22 +313,21 @@ class BaseJsonFormatter(logging.Formatter):
         else:
             raise ValueError(f"Style {self._style!r} is not supported")
 
-        if self._fmt:
-            return formatter_style_pattern.findall(self._fmt)
-
-        return []
+        return formatter_style_pattern.findall(self._fmt)
 
-    def serialize_log_record(self, log_record: LogRecord) -> str:
-        """Returns the final representation of the log record.
+    def serialize_log_record(self, log_data: LogData) -> str:
+        """Returns the final representation of the data to be logged
 
         Args:
-            log_record: the log record
+            log_data: the data
+
+        *Changed in 4.0*: `log_record` renamed to `log_data`
         """
-        return self.prefix + self.jsonify_log_record(log_record)
+        return self.prefix + self.jsonify_log_record(log_data)
 
     def add_fields(
         self,
-        log_record: Dict[str, Any],
+        log_data: Dict[str, Any],
         record: logging.LogRecord,
         message_dict: Dict[str, Any],
     ) -> None:
@@ -326,38 +336,40 @@ class BaseJsonFormatter(logging.Formatter):
         This method can be overridden to implement custom logic for adding fields.
 
         Args:
-            log_record: data that will be logged
+            log_data: data that will be logged
             record: the record to extract data from
             message_dict: dictionary that was logged instead of a message. e.g
                 `logger.info({"is_this_message_dict": True})`
+
+        *Changed in 4.0*: `log_record` renamed to `log_data`
         """
         for field in self.defaults:
-            log_record[self._get_rename(field)] = self.defaults[field]
+            log_data[self._get_rename(field)] = self.defaults[field]
 
         for field in self._required_fields:
-            log_record[self._get_rename(field)] = record.__dict__.get(field)
+            log_data[self._get_rename(field)] = record.__dict__.get(field)
 
         for data_dict in [self.static_fields, message_dict]:
             for key, value in data_dict.items():
-                log_record[self._get_rename(key)] = value
+                log_data[self._get_rename(key)] = value
 
         merge_record_extra(
             record,
-            log_record,
+            log_data,
             reserved=self._skip_fields,
             rename_fields=self.rename_fields,
         )
 
         if self.timestamp:
             key = self.timestamp if isinstance(self.timestamp, str) else "timestamp"
-            log_record[self._get_rename(key)] = datetime.fromtimestamp(
+            log_data[self._get_rename(key)] = datetime.fromtimestamp(
                 record.created, tz=timezone.utc
             )
 
         if self.rename_fields_keep_missing:
             for field in self.rename_fields.values():
-                if field not in log_record:
-                    log_record[field] = None
+                if field not in log_data:
+                    log_data[field] = None
         return
 
     def _get_rename(self, key: str) -> str:
@@ -365,26 +377,30 @@ class BaseJsonFormatter(logging.Formatter):
 
     # Child Methods
     # ..........................................................................
-    def jsonify_log_record(self, log_record: LogRecord) -> str:
-        """Convert this log record into a JSON string.
+    def jsonify_log_record(self, log_data: LogData) -> str:
+        """Convert the log data into a JSON string.
 
         Child classes MUST override this method.
 
         Args:
-            log_record: the data to serialize
+            log_data: the data to serialize
+
+        *Changed in 4.0*: `log_record` renamed to `log_data`
         """
         raise NotImplementedError()
 
-    def process_log_record(self, log_record: LogRecord) -> LogRecord:
-        """Custom processing of the log record.
+    def process_log_record(self, log_data: LogData) -> LogData:
+        """Custom processing of the data to be logged.
 
         Child classes can override this method to alter the log record before it
         is serialized.
 
         Args:
-            log_record: incoming data
+            log_data: incoming data
+
+        *Changed in 4.0*: `log_record` renamed to `log_data`
         """
-        return log_record
+        return log_data
 
     def formatException(self, ei) -> Union[str, list[str]]:  # type: ignore
         """Format and return the specified exception information.

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/src/pythonjsonlogger/json.py

@@ -67,9 +67,9 @@ class JsonFormatter(core.BaseJsonFormatter):
     def __init__(
         self,
         *args,
-        json_default: core.OptionalCallableOrStr = None,
-        json_encoder: core.OptionalCallableOrStr = None,
-        json_serializer: Union[Callable, str] = json.dumps,
+        json_default: Optional[Callable] = None,
+        json_encoder: Optional[Callable] = None,
+        json_serializer: Callable = json.dumps,
         json_indent: Optional[Union[int, str]] = None,
         json_ensure_ascii: bool = True,
         **kwargs,
@@ -87,19 +87,19 @@ class JsonFormatter(core.BaseJsonFormatter):
         """
         super().__init__(*args, **kwargs)
 
-        self.json_default = core.str_to_object(json_default)
-        self.json_encoder = core.str_to_object(json_encoder)
-        self.json_serializer = core.str_to_object(json_serializer)
+        self.json_default = json_default
+        self.json_encoder = json_encoder
+        self.json_serializer = json_serializer
         self.json_indent = json_indent
         self.json_ensure_ascii = json_ensure_ascii
         if not self.json_encoder and not self.json_default:
             self.json_encoder = JsonEncoder
         return
 
-    def jsonify_log_record(self, log_record: core.LogRecord) -> str:
-        """Returns a json string of the log record."""
+    def jsonify_log_record(self, log_data: core.LogData) -> str:
+        """Returns a json string of the log data."""
         return self.json_serializer(
-            log_record,
+            log_data,
             default=self.json_default,
             cls=self.json_encoder,
             indent=self.json_indent,

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/src/pythonjsonlogger/msgspec.py

@@ -6,7 +6,7 @@
 from __future__ import annotations
 
 ## Standard Library
-from typing import Any
+from typing import Any, Optional, Callable
 
 ## Installed
 
@@ -43,7 +43,7 @@ class MsgspecFormatter(core.BaseJsonFormatter):
     def __init__(
         self,
         *args,
-        json_default: core.OptionalCallableOrStr = msgspec_default,
+        json_default: Optional[Callable] = msgspec_default,
         **kwargs,
     ) -> None:
         """
@@ -54,10 +54,10 @@ class MsgspecFormatter(core.BaseJsonFormatter):
         """
         super().__init__(*args, **kwargs)
 
-        self.json_default = core.str_to_object(json_default)
+        self.json_default = json_default
         self._encoder = msgspec.json.Encoder(enc_hook=self.json_default)
         return
 
-    def jsonify_log_record(self, log_record: core.LogRecord) -> str:
-        """Returns a json string of the log record."""
-        return self._encoder.encode(log_record).decode("utf8")
+    def jsonify_log_record(self, log_data: core.LogData) -> str:
+        """Returns a json string of the log data."""
+        return self._encoder.encode(log_data).decode("utf8")

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/src/pythonjsonlogger/orjson.py

@@ -6,7 +6,7 @@
 from __future__ import annotations
 
 ## Standard Library
-from typing import Any
+from typing import Any, Optional, Callable
 
 ## Installed
 
@@ -45,7 +45,7 @@ class OrjsonFormatter(core.BaseJsonFormatter):
     def __init__(
         self,
         *args,
-        json_default: core.OptionalCallableOrStr = orjson_default,
+        json_default: Optional[Callable] = orjson_default,
         json_indent: bool = False,
         **kwargs,
     ) -> None:
@@ -58,14 +58,14 @@ class OrjsonFormatter(core.BaseJsonFormatter):
         """
         super().__init__(*args, **kwargs)
 
-        self.json_default = core.str_to_object(json_default)
+        self.json_default = json_default
         self.json_indent = json_indent
         return
 
-    def jsonify_log_record(self, log_record: core.LogRecord) -> str:
-        """Returns a json string of the log record."""
+    def jsonify_log_record(self, log_data: core.LogData) -> str:
+        """Returns a json string of the log data."""
         opt = orjson.OPT_NON_STR_KEYS
         if self.json_indent:
             opt |= orjson.OPT_INDENT_2
 
-        return orjson.dumps(log_record, default=self.json_default, option=opt).decode("utf8")
+        return orjson.dumps(log_data, default=self.json_default, option=opt).decode("utf8")

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/tests/test_dictconfig.py

@@ -19,12 +19,24 @@ import pytest
 _LOGGER_COUNT = 0
 EXT_VAL = 999
 
+
+class Dummy:
+    pass
+
+
+def my_json_default(obj: Any) -> Any:
+    if isinstance(obj, Dummy):
+        return "DUMMY"
+    return obj
+
+
 LOGGING_CONFIG = {
     "version": 1,
     "disable_existing_loggers": False,
     "formatters": {
         "default": {
             "()": "pythonjsonlogger.json.JsonFormatter",
+            "json_default": "ext://tests.test_dictconfig.my_json_default",
             "static_fields": {"ext-val": "ext://tests.test_dictconfig.EXT_VAL"},
         }
     },
@@ -73,8 +85,12 @@ def env() -> Generator[LoggingEnvironment, None, None]:
 ### TESTS
 ### ============================================================================
 def test_external_reference_support(env: LoggingEnvironment):
-    env.logger.info("hello")
+
+    assert logging.root.handlers[0].formatter.json_default is my_json_default  # type: ignore[union-attr]
+
+    env.logger.info("hello", extra={"dummy": Dummy()})
     log_json = env.load_json()
 
     assert log_json["ext-val"] == EXT_VAL
+    assert log_json["dummy"] == "DUMMY"
     return

{python_json_logger-4.0.0.dev0 → python_json_logger-4.0.0rc1}/tests/test_formatters.py

@@ -158,12 +158,48 @@ def test_default_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]
 
 @pytest.mark.parametrize("class_", ALL_FORMATTERS)
 def test_percentage_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
-    env.set_formatter(
-        class_(
-            # All kind of different styles to check the regex
-            "[%(levelname)8s] %(message)s %(filename)s:%(lineno)d %(asctime)"
-        )
-    )
+    # Note: We use different %s styles in the format to check the regex correctly collects them
+    env.set_formatter(class_("[%(levelname)8s] %(message)s %(filename)s:%(lineno)d %(asctime)"))
+
+    msg = "testing logging format"
+    env.logger.info(msg)
+    log_json = env.load_json()
+
+    assert log_json["message"] == msg
+    assert log_json.keys() == {"levelname", "message", "filename", "lineno", "asctime"}
+    return
+
+
+@pytest.mark.parametrize("class_", ALL_FORMATTERS)
+def test_comma_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
+    # Note: we have double comma `,,` to test handling "empty" names
+    env.set_formatter(class_("levelname,,message,filename,lineno,asctime,", style=","))
+
+    msg = "testing logging format"
+    env.logger.info(msg)
+    log_json = env.load_json()
+
+    assert log_json["message"] == msg
+    assert log_json.keys() == {"levelname", "message", "filename", "lineno", "asctime"}
+    return
+
+
+@pytest.mark.parametrize("class_", ALL_FORMATTERS)
+def test_sequence_list_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
+    env.set_formatter(class_(["levelname", "message", "filename", "lineno", "asctime"]))
+
+    msg = "testing logging format"
+    env.logger.info(msg)
+    log_json = env.load_json()
+
+    assert log_json["message"] == msg
+    assert log_json.keys() == {"levelname", "message", "filename", "lineno", "asctime"}
+    return
+
+
+@pytest.mark.parametrize("class_", ALL_FORMATTERS)
+def test_sequence_tuple_format(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
+    env.set_formatter(class_(("levelname", "message", "filename", "lineno", "asctime")))
 
     msg = "testing logging format"
     env.logger.info(msg)
@@ -380,9 +416,9 @@ def test_log_extra(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
 def test_custom_logic_adds_field(env: LoggingEnvironment, class_: type[BaseJsonFormatter]):
     class CustomJsonFormatter(class_):  # type: ignore[valid-type,misc]
 
-        def process_log_record(self, log_record):
-            log_record["custom"] = "value"
-            return super().process_log_record(log_record)
+        def process_log_record(self, log_data):
+            log_data["custom"] = "value"
+            return super().process_log_record(log_data)
 
     env.set_formatter(CustomJsonFormatter())
     env.logger.info("message")