python-json-logger 2.0.7__py3-none-any.whl → 3.0.0__py3-none-any.whl

{python_json_logger-2.0.7.dist-info → python_json_logger-3.0.0.dist-info}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011, Zakaria Zajac 
+Copyright (c) 2011, Zakaria Zajac and the python-json-logger Contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

{python_json_logger-2.0.7.dist-info → python_json_logger-3.0.0.dist-info}/METADATA

@@ -1,58 +1,78 @@
 Metadata-Version: 2.1
 Name: python-json-logger
-Version: 2.0.7
-Summary: A python library adding a json log formatter
-Home-page: http://github.com/madzak/python-json-logger
-Author: Zakaria Zajac
-Author-email: zak@madzak.com
-License: BSD
+Version: 3.0.0
+Summary: JSON Log Formatter for the Python Logging Package
+Author-email: Zakaria Zajac <zak@madzak.com>
+Maintainer-email: Nicholas Hairs <info+python-json-logger@nicholashairs.com>
+License: BSD-2-Clause License
+Project-URL: GitHub, https://github.com/nhairs/python-json-logger
 Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Logging
-Requires-Python: >=3.6
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-
-![Build Status](https://github.com/madzak/python-json-logger/actions/workflows/build.yml/badge.svg)
+Provides-Extra: lint
+Requires-Dist: validate-pyproject[all] ; extra == 'lint'
+Requires-Dist: black ; extra == 'lint'
+Requires-Dist: pylint ; extra == 'lint'
+Requires-Dist: mypy ; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+
+![Build Status](https://github.com/nhairs/python-json-logger/actions/workflows/test-suite.yml/badge.svg)
 [![License](https://img.shields.io/pypi/l/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 [![Version](https://img.shields.io/pypi/v/python-json-logger.svg)](https://pypi.python.org/pypi/python-json-logger/)
 
-Overview
-=======
+# Python JSON Logger
+
 This library is provided to allow standard python logging to output log data as json objects. With JSON we can make our logs more readable by machines and we can stop writing custom parsers for syslog type records.
 
-News
-=======
-Hi, I see this package is quiet alive and I am sorry for ignoring it so long. I will be stepping up my maintenance of this package so please allow me a week to get things back in order (and most likely a new minor version) and I'll post and update here once I am caught up.
 
-Installing
-==========
-Pip:
+### 🚨 Important 🚨
+
+This repository is a maintained fork of [madzak/python-json-logger](https://github.com/madzak/python-json-logger) pending [a PEP 541 request](https://github.com/pypi/support/issues/3607) for the PyPI package.  The future direction of the project is being discussed [here](https://github.com/nhairs/python-json-logger/issues/1).
+
+## Installation
+
+### Install via pip / PyPI
+
+Until the PEP 541 request is complete you will need to use one of the alternative methods below.
+
+### Install from GitHub
 
-    pip install python-json-logger
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git'
+```
+
+To install a specific version:
 
-Pypi:
+```shell
+pip install 'python-json-logger@git+https://github.com/nhairs/python-json-logger.git@v2.0.7'
+```
 
-   https://pypi.python.org/pypi/python-json-logger
 
-Manual:
+### Install from Source
 
-    python setup.py install
+```shell
+git clone https://github.com/nhairs/python-json-logger.git
+cd python-json-logger
+pip install -e .
+```
 
-Usage
-=====
+## Usage
 
-## Integrating with Python's logging framework
+### Integrating with Python's logging framework
 
 Json outputs are provided by the JsonFormatter logging formatter. You can add the custom formatter like below:
 
@@ -70,7 +90,7 @@ Json outputs are provided by the JsonFormatter logging formatter. You can add th
     logger.addHandler(logHandler)
 ```
 
-## Customizing fields
+### Customizing fields
 
 The fmt parser can also be overidden if you want to have required fields that differ from the default of just `message`.
 
@@ -112,7 +132,7 @@ formatter = CustomJsonFormatter('%(timestamp)s %(level)s %(name)s %(message)s')
 
 Items added to the log record will be included in *every* log message, no matter what the format requires.
 
-## Adding custom object serialization
+### Adding custom object serialization
 
 For custom handling of object serialization you can specify default json object translator or provide a custom encoder
 
@@ -129,7 +149,7 @@ logger.info({"special": "value", "run": 12})
 logger.info("classic message", extra={"special": "value", "run": 12})
 ```
 
-## Using a Config File
+### Using a Config File
 
 To use the module with a config file using the [`fileConfig` function](https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig), use the class `pythonjsonlogger.jsonlogger.JsonFormatter`. Here is a sample config file.
 
@@ -162,8 +182,7 @@ format = %(message)s
 class = pythonjsonlogger.jsonlogger.JsonFormatter
 ```
 
-Example Output
-==============
+## Example Output
 
 Sample JSON with a full formatter (basically the log message from the unit test). Every log message will appear on 1 line like a typical logger.
 
@@ -191,9 +210,14 @@ Sample JSON with a full formatter (basically the log message from the unit test)
 }
 ```
 
-External Examples
-=================
+## License
+
+This project is licensed under the BSD 2 Clause License - see [`LICENSE`](https://github.com/nhairs/python-json-logger/blob/main/LICENSE)
+
+## Authors and Maintainers
+
+This project was originally authored by [Zakaria Zajac](https://github.com/madzak) and our wonderful [contributors](https://github.com/nhairs/python-json-logger/graphs/contributors)
 
-- [Wesley Tanaka - Structured log files in Python using python-json-logger](http://web.archive.org/web/20201130054012/https://wtanaka.com/node/8201)
+It is currently maintained by:
 
-- [Archive](https://web.archive.org/web/20201130054012/https://wtanaka.com/node/8201)
+- [Nicholas Hairs](https://github.com/nhairs) - [nicholashairs.com](https://www.nicholashairs.com)

python_json_logger-3.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pythonjsonlogger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonjsonlogger/jsonlogger.py,sha256=dIKseexAUbEyJDQVjVrYY-gcJWn_T9sIzEFkaptHhmE,11255
+pythonjsonlogger/py.typed,sha256=4RLptUHQuSqzK6CDbigff8uvWQjwPPQMxikWPkV4OtA,80
+python_json_logger-3.0.0.dist-info/LICENSE,sha256=GOqVF546Xg4k62zhbED7--IxM8JQKTOi91-KPhoFW1Q,1329
+python_json_logger-3.0.0.dist-info/METADATA,sha256=3tNA-gXRR5EooajrvPCV1Q2fg8VPkQsC-g2Y9sZY634,7508
+python_json_logger-3.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+python_json_logger-3.0.0.dist-info/top_level.txt,sha256=9G-OsTkbwPgM8t-bXKPmWDBRZv9cbzLIiEDE5EnGk2I,17
+python_json_logger-3.0.0.dist-info/RECORD,,

{python_json_logger-2.0.7.dist-info → python_json_logger-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pythonjsonlogger/jsonlogger.py

@@ -1,15 +1,16 @@
-'''
+"""
 This library is provided to allow standard python logging
 to output log data as JSON formatted strings
-'''
+"""
+
 import logging
 import json
 import re
-from datetime import date, datetime, time, timezone
 import traceback
 import importlib
-
-from typing import Any, Dict, Optional, Union, List, Tuple
+from datetime import date, datetime, time, timezone
+import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from inspect import istraceback
 
@@ -17,19 +18,45 @@ from collections import OrderedDict
 
 # skip natural LogRecord attributes
 # http://docs.python.org/library/logging.html#logrecord-attributes
-RESERVED_ATTRS: Tuple[str, ...] = (
-    'args', 'asctime', 'created', 'exc_info', 'exc_text', 'filename',
-    'funcName', 'levelname', 'levelno', 'lineno', 'module',
-    'msecs', 'message', 'msg', 'name', 'pathname', 'process',
-    'processName', 'relativeCreated', 'stack_info', 'thread', 'threadName')
-
+# Changed in 3.0.0, is now list[str] instead of tuple[str, ...]
+RESERVED_ATTRS: List[str] = [
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "module",
+    "msecs",
+    "message",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+]
+
+if sys.version_info >= (3, 12):
+    # taskName added in python 3.12
+    RESERVED_ATTRS.append("taskName")
+    RESERVED_ATTRS.sort()
+
+OptionalCallableOrStr = Optional[Union[Callable, str]]
 
 
 def merge_record_extra(
     record: logging.LogRecord,
     target: Dict,
     reserved: Union[Dict, List],
-    rename_fields: Optional[Dict[str,str]] = None,
+    rename_fields: Optional[Dict[str, str]] = None,
 ) -> Dict:
     """
     Merges extra attributes from LogRecord object into target dictionary
@@ -44,10 +71,8 @@ def merge_record_extra(
         rename_fields = {}
     for key, value in record.__dict__.items():
         # this allows to have numeric keys
-        if (key not in reserved
-            and not (hasattr(key, "startswith")
-                     and key.startswith('_'))):
-            target[rename_fields.get(key,key)] = value
+        if key not in reserved and not (hasattr(key, "startswith") and key.startswith("_")):
+            target[rename_fields.get(key, key)] = value
     return target
 
 
@@ -56,30 +81,34 @@ class JsonEncoder(json.JSONEncoder):
     A custom encoder extending the default JSONEncoder
     """
 
-    def default(self, obj):
-        if isinstance(obj, (date, datetime, time)):
-            return self.format_datetime_obj(obj)
+    def default(self, o: Any) -> Any:
+        if isinstance(o, (date, datetime, time)):
+            return self.format_datetime_obj(o)
 
-        elif istraceback(obj):
-            return ''.join(traceback.format_tb(obj)).strip()
+        if istraceback(o):
+            return "".join(traceback.format_tb(o)).strip()
 
-        elif type(obj) == Exception \
-                or isinstance(obj, Exception) \
-                or type(obj) == type:
-            return str(obj)
+        # pylint: disable=unidiomatic-typecheck
+        if type(o) == Exception or isinstance(o, Exception) or type(o) == type:
+            return str(o)
 
         try:
-            return super(JsonEncoder, self).default(obj)
+            return super().default(o)
 
         except TypeError:
             try:
-                return str(obj)
+                return str(o)
 
-            except Exception:
+            except Exception:  # pylint: disable=broad-exception-caught
                 return None
 
-    def format_datetime_obj(self, obj):
-        return obj.isoformat()
+    def format_datetime_obj(self, o):
+        """Format datetime objects found in self.default
+
+        This allows subclasses to change the datetime format without understanding the
+        internals of the default method.
+        """
+        return o.isoformat()
 
 
 class JsonFormatter(logging.Formatter):
@@ -89,22 +118,35 @@ class JsonFormatter(logging.Formatter):
     json default encoder
     """
 
-    def __init__(self, *args, **kwargs):
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        *args: Any,
+        json_default: OptionalCallableOrStr = None,
+        json_encoder: OptionalCallableOrStr = None,
+        json_serialiser: Union[Callable, str] = json.dumps,
+        json_indent: Optional[Union[int, str]] = None,
+        json_ensure_ascii: bool = True,
+        prefix: str = "",
+        rename_fields: Optional[dict] = None,
+        static_fields: Optional[dict] = None,
+        reserved_attrs: Union[Tuple[str, ...], List[str], None] = None,
+        timestamp: Union[bool, str] = False,
+        **kwargs: Any,
+    ) -> None:
         """
         :param json_default: a function for encoding non-standard objects
             as outlined in https://docs.python.org/3/library/json.html
         :param json_encoder: optional custom encoder
         :param json_serializer: a :meth:`json.dumps`-compatible callable
             that will be used to serialize the log record.
-        :param json_indent: an optional :meth:`json.dumps`-compatible numeric value
-            that will be used to customize the indent of the output json.
+        :param json_indent: indent parameter for json.dumps
+        :param json_ensure_ascii: ensure_ascii parameter for json.dumps
         :param prefix: an optional string prefix added at the beginning of
             the formatted string
         :param rename_fields: an optional dict, used to rename field names in the output.
             Rename message to @message: {'message': '@message'}
         :param static_fields: an optional dict, used to add fields with static values to all logs
-        :param json_indent: indent parameter for json.dumps
-        :param json_ensure_ascii: ensure_ascii parameter for json.dumps
         :param reserved_attrs: an optional list of fields that will be skipped when
             outputting json log record. Defaults to all log record attributes:
             http://docs.python.org/library/logging.html#logrecord-attributes
@@ -113,17 +155,18 @@ class JsonFormatter(logging.Formatter):
             to log record using string as key. If True boolean is passed, timestamp key
             will be "timestamp". Defaults to False/off.
         """
-        self.json_default = self._str_to_fn(kwargs.pop("json_default", None))
-        self.json_encoder = self._str_to_fn(kwargs.pop("json_encoder", None))
-        self.json_serializer = self._str_to_fn(kwargs.pop("json_serializer", json.dumps))
-        self.json_indent = kwargs.pop("json_indent", None)
-        self.json_ensure_ascii = kwargs.pop("json_ensure_ascii", True)
-        self.prefix = kwargs.pop("prefix", "")
-        self.rename_fields = kwargs.pop("rename_fields", {})
-        self.static_fields = kwargs.pop("static_fields", {})
-        reserved_attrs = kwargs.pop("reserved_attrs", RESERVED_ATTRS)
+        self.json_default = self._str_to_fn(json_default)
+        self.json_encoder = self._str_to_fn(json_encoder)
+        self.json_serializer = self._str_to_fn(json_serialiser)
+        self.json_indent = json_indent
+        self.json_ensure_ascii = json_ensure_ascii
+        self.prefix = prefix
+        self.rename_fields = rename_fields or {}
+        self.static_fields = static_fields or {}
+        if reserved_attrs is None:
+            reserved_attrs = RESERVED_ATTRS
         self.reserved_attrs = dict(zip(reserved_attrs, reserved_attrs))
-        self.timestamp = kwargs.pop("timestamp", False)
+        self.timestamp = timestamp
 
         # super(JsonFormatter, self).__init__(*args, **kwargs)
         logging.Formatter.__init__(self, *args, **kwargs)
@@ -131,9 +174,9 @@ class JsonFormatter(logging.Formatter):
             self.json_encoder = JsonEncoder
 
         self._required_fields = self.parse()
-        self._skip_fields = dict(zip(self._required_fields,
-                                     self._required_fields))
+        self._skip_fields = dict(zip(self._required_fields, self._required_fields))
         self._skip_fields.update(self.reserved_attrs)
+        return
 
     def _str_to_fn(self, fn_as_str):
         """
@@ -146,7 +189,7 @@ class JsonFormatter(logging.Formatter):
         if not isinstance(fn_as_str, str):
             return fn_as_str
 
-        path, _, function = fn_as_str.rpartition('.')
+        path, _, function = fn_as_str.rpartition(".")
         module = importlib.import_module(path)
         return getattr(module, function)
 
@@ -158,22 +201,26 @@ class JsonFormatter(logging.Formatter):
         to include in all log messages.
         """
         if isinstance(self._style, logging.StringTemplateStyle):
-            formatter_style_pattern = re.compile(r'\$\{(.+?)\}', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"\$\{(.+?)\}", re.IGNORECASE)
         elif isinstance(self._style, logging.StrFormatStyle):
-            formatter_style_pattern = re.compile(r'\{(.+?)\}', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"\{(.+?)\}", re.IGNORECASE)
         # PercentStyle is parent class of StringTemplateStyle and StrFormatStyle so
         # it needs to be checked last.
         elif isinstance(self._style, logging.PercentStyle):
-            formatter_style_pattern = re.compile(r'%\((.+?)\)', re.IGNORECASE)
+            formatter_style_pattern = re.compile(r"%\((.+?)\)", re.IGNORECASE)
         else:
-            raise ValueError('Invalid format: %s' % self._fmt)
+            raise ValueError(f"Invalid format: {self._fmt!r}")
 
         if self._fmt:
             return formatter_style_pattern.findall(self._fmt)
-        else:
-            return []
-
-    def add_fields(self, log_record: Dict[str, Any], record: logging.LogRecord, message_dict: Dict[str, Any]) -> None:
+        return []
+
+    def add_fields(
+        self,
+        log_record: Dict[str, Any],
+        record: logging.LogRecord,
+        message_dict: Dict[str, Any],
+    ) -> None:
         """
         Override this method to implement custom logic for adding fields.
         """
@@ -182,42 +229,53 @@ class JsonFormatter(logging.Formatter):
 
         log_record.update(self.static_fields)
         log_record.update(message_dict)
-        merge_record_extra(record, log_record, reserved=self._skip_fields, rename_fields=self.rename_fields)
+        merge_record_extra(
+            record,
+            log_record,
+            reserved=self._skip_fields,
+            rename_fields=self.rename_fields,
+        )
 
         if self.timestamp:
-            key = self.timestamp if type(self.timestamp) == str else 'timestamp'
+            # TODO: Can this use isinstance instead?
+            # pylint: disable=unidiomatic-typecheck
+            key = self.timestamp if type(self.timestamp) == str else "timestamp"
             log_record[key] = datetime.fromtimestamp(record.created, tz=timezone.utc)
 
         self._perform_rename_log_fields(log_record)
+        return
 
-    def _perform_rename_log_fields(self, log_record):
+    def _perform_rename_log_fields(self, log_record: Dict[str, Any]) -> None:
         for old_field_name, new_field_name in self.rename_fields.items():
             log_record[new_field_name] = log_record[old_field_name]
             del log_record[old_field_name]
+        return
 
-    def process_log_record(self, log_record):
+    def process_log_record(self, log_record: Dict[str, Any]) -> Dict[str, Any]:
         """
         Override this method to implement custom logic
         on the possibly ordered dictionary.
         """
         return log_record
 
-    def jsonify_log_record(self, log_record):
+    def jsonify_log_record(self, log_record: Dict[str, Any]) -> str:
         """Returns a json string of the log record."""
-        return self.json_serializer(log_record,
-                                    default=self.json_default,
-                                    cls=self.json_encoder,
-                                    indent=self.json_indent,
-                                    ensure_ascii=self.json_ensure_ascii)
+        return self.json_serializer(
+            log_record,
+            default=self.json_default,
+            cls=self.json_encoder,
+            indent=self.json_indent,
+            ensure_ascii=self.json_ensure_ascii,
+        )
 
     def serialize_log_record(self, log_record: Dict[str, Any]) -> str:
         """Returns the final representation of the log record."""
-        return "%s%s" % (self.prefix, self.jsonify_log_record(log_record))
+        return self.prefix + self.jsonify_log_record(log_record)
 
     def format(self, record: logging.LogRecord) -> str:
         """Formats a log record and serializes to json"""
         message_dict: Dict[str, Any] = {}
-        # FIXME: logging.LogRecord.msg and logging.LogRecord.message in typeshed
+        # TODO: logging.LogRecord.msg and logging.LogRecord.message in typeshed
         #        are always type of str. We shouldn't need to override that.
         if isinstance(record.msg, dict):
             message_dict = record.msg
@@ -230,14 +288,14 @@ class JsonFormatter(logging.Formatter):
 
         # Display formatted exception, but allow overriding it in the
         # user-supplied dict.
-        if record.exc_info and not message_dict.get('exc_info'):
-            message_dict['exc_info'] = self.formatException(record.exc_info)
-        if not message_dict.get('exc_info') and record.exc_text:
-            message_dict['exc_info'] = record.exc_text
+        if record.exc_info and not message_dict.get("exc_info"):
+            message_dict["exc_info"] = self.formatException(record.exc_info)
+        if not message_dict.get("exc_info") and record.exc_text:
+            message_dict["exc_info"] = record.exc_text
         # Display formatted record of stack frames
         # default format is a string returned from :func:`traceback.print_stack`
-        if record.stack_info and not message_dict.get('stack_info'):
-            message_dict['stack_info'] = self.formatStack(record.stack_info)
+        if record.stack_info and not message_dict.get("stack_info"):
+            message_dict["stack_info"] = self.formatStack(record.stack_info)
 
         log_record: Dict[str, Any] = OrderedDict()
         self.add_fields(log_record, record, message_dict)

python_json_logger-2.0.7.dist-info/RECORD

@@ -1,8 +0,0 @@
-pythonjsonlogger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pythonjsonlogger/jsonlogger.py,sha256=R_eb9uR7t9q06gykfWZ3LhZMIEVYMOXDXx7iz0i06X0,10274
-pythonjsonlogger/py.typed,sha256=4RLptUHQuSqzK6CDbigff8uvWQjwPPQMxikWPkV4OtA,80
-python_json_logger-2.0.7.dist-info/LICENSE,sha256=wVvJlIz5ho1mHqGh4PckLVZ8D4NXa_9LoQH5jeBweus,1290
-python_json_logger-2.0.7.dist-info/METADATA,sha256=G8GNdTilEbOa3kQiOALmbsSu997Lt5iylpT4Ej2tCbc,6484
-python_json_logger-2.0.7.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-python_json_logger-2.0.7.dist-info/top_level.txt,sha256=9G-OsTkbwPgM8t-bXKPmWDBRZv9cbzLIiEDE5EnGk2I,17
-python_json_logger-2.0.7.dist-info/RECORD,,