django-structlog 8.1.0__tar.gz → 9.0.0.dev1__tar.gz

{django_structlog-8.1.0/django_structlog.egg-info → django_structlog-9.0.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-structlog
-Version: 8.1.0
+Version: 9.0.0.dev1
 Summary: Structured Logging for Django
 Author-email: Jules Robichaud-Gagnon <j.robichaudg+pypi@gmail.com>
 License: MIT
@@ -13,17 +13,19 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
 Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-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: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Logging
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: django>=4.2

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/__init__.py

@@ -3,6 +3,6 @@
 
 name = "django_structlog"
 
-VERSION = (8, 1, 0)
+VERSION = (9, 0, 0, "dev1")
 
 __version__ = ".".join(str(v) for v in VERSION)

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/app_settings.py

@@ -8,19 +8,19 @@ class AppSettings:
     PREFIX = "DJANGO_STRUCTLOG_"
 
     @property
-    def CELERY_ENABLED(self):
+    def CELERY_ENABLED(self) -> bool:
         return getattr(settings, self.PREFIX + "CELERY_ENABLED", False)
 
     @property
-    def STATUS_4XX_LOG_LEVEL(self):
+    def STATUS_4XX_LOG_LEVEL(self) -> int:
         return getattr(settings, self.PREFIX + "STATUS_4XX_LOG_LEVEL", logging.WARNING)
 
     @property
-    def COMMAND_LOGGING_ENABLED(self):
+    def COMMAND_LOGGING_ENABLED(self) -> bool:
         return getattr(settings, self.PREFIX + "COMMAND_LOGGING_ENABLED", False)
 
     @property
-    def USER_ID_FIELD(self):
+    def USER_ID_FIELD(self) -> str:
         return getattr(settings, self.PREFIX + "USER_ID_FIELD", "pk")
 
 

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/apps.py

@@ -6,7 +6,7 @@ from .app_settings import app_settings
 class DjangoStructLogConfig(AppConfig):
     name = "django_structlog"
 
-    def ready(self):
+    def ready(self) -> None:
         if app_settings.CELERY_ENABLED:
             from .celery.receivers import CeleryReceiver
 

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/celery/receivers.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Type, Any, Optional, cast, TYPE_CHECKING
+
 import structlog
 from celery import current_app
 from celery.signals import (
@@ -14,23 +18,27 @@ from celery.signals import (
 
 from . import signals
 
+if TYPE_CHECKING:
+    from types import TracebackType
 
 logger = structlog.getLogger(__name__)
 
 
 class CeleryReceiver:
-    def __init__(self):
+    _priority: Optional[str]
+
+    def __init__(self) -> None:
         self._priority = None
 
     def receiver_before_task_publish(
         self,
-        sender=None,
-        headers=None,
-        body=None,
-        properties=None,
-        routing_key=None,
-        **kwargs,
-    ):
+        sender: Optional[Type[Any]] = None,
+        headers: Optional[dict[str, Any]] = None,
+        body: Optional[dict[str, str]] = None,
+        properties: Optional[dict[str, Optional[str]]] = None,
+        routing_key: Optional[str] = None,
+        **kwargs: dict[str, str],
+    ) -> None:
         if current_app.conf.task_protocol < 2:
             return
 
@@ -46,12 +54,17 @@ class CeleryReceiver:
         )
         if properties:
             self._priority = properties.get("priority", None)
-
-        headers["__django_structlog__"] = context
+        if headers is not None:
+            headers["__django_structlog__"] = context
 
     def receiver_after_task_publish(
-        self, sender=None, headers=None, body=None, routing_key=None, **kwargs
-    ):
+        self,
+        sender: Optional[Type[Any]] = None,
+        headers: Optional[dict[str, Optional[str]]] = None,
+        body: Optional[dict[str, Optional[str]]] = None,
+        routing_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
         properties = {}
         if self._priority is not None:
             properties["priority"] = self._priority
@@ -59,13 +72,23 @@ class CeleryReceiver:
 
         logger.info(
             "task_enqueued",
-            child_task_id=headers.get("id") if headers else body.get("id"),
-            child_task_name=headers.get("task") if headers else body.get("task"),
+            child_task_id=(
+                headers.get("id")
+                if headers
+                else cast(dict[str, Optional[str]], body).get("id")
+            ),
+            child_task_name=(
+                headers.get("task")
+                if headers
+                else cast(dict[str, Optional[str]], body).get("task")
+            ),
             routing_key=routing_key,
             **properties,
         )
 
-    def receiver_task_prerun(self, task_id, task, *args, **kwargs):
+    def receiver_task_prerun(
+        self, task_id: str, task: Any, *args: Any, **kwargs: Any
+    ) -> None:
         structlog.contextvars.clear_contextvars()
         structlog.contextvars.bind_contextvars(task_id=task_id)
         metadata = getattr(task.request, "__django_structlog__", {})
@@ -75,10 +98,18 @@ class CeleryReceiver:
         )
         logger.info("task_started", task=task.name)
 
-    def receiver_task_retry(self, request=None, reason=None, einfo=None, **kwargs):
+    def receiver_task_retry(
+        self,
+        request: Optional[Any] = None,
+        reason: Optional[str] = None,
+        einfo: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
         logger.warning("task_retrying", reason=reason)
 
-    def receiver_task_success(self, result=None, **kwargs):
+    def receiver_task_success(
+        self, result: Optional[str] = None, **kwargs: Any
+    ) -> None:
         signals.pre_task_succeeded.send(
             sender=self.receiver_task_success, logger=logger, result=result
         )
@@ -86,14 +117,14 @@ class CeleryReceiver:
 
     def receiver_task_failure(
         self,
-        task_id=None,
-        exception=None,
-        traceback=None,
-        einfo=None,
-        sender=None,
-        *args,
-        **kwargs,
-    ):
+        task_id: Optional[str] = None,
+        exception: Optional[Exception] = None,
+        traceback: Optional[TracebackType] = None,
+        einfo: Optional[Any] = None,
+        sender: Optional[Type[Any]] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         throws = getattr(sender, "throws", ())
         if isinstance(exception, throws):
             logger.info(
@@ -108,8 +139,13 @@ class CeleryReceiver:
             )
 
     def receiver_task_revoked(
-        self, request=None, terminated=None, signum=None, expired=None, **kwargs
-    ):
+        self,
+        request: Any,
+        terminated: Optional[bool] = None,
+        signum: Optional[Any] = None,
+        expired: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
         metadata = getattr(request, "__django_structlog__", {}).copy()
         metadata["task_id"] = request.id
         metadata["task"] = request.task
@@ -124,24 +160,31 @@ class CeleryReceiver:
         )
 
     def receiver_task_unknown(
-        self, message=None, exc=None, name=None, id=None, **kwargs
-    ):
+        self,
+        message: Optional[str] = None,
+        exc: Optional[Exception] = None,
+        name: Optional[str] = None,
+        id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
         logger.error(
             "task_not_found",
             task=name,
             task_id=id,
         )
 
-    def receiver_task_rejected(self, message=None, exc=None, **kwargs):
+    def receiver_task_rejected(
+        self, message: Any, exc: Optional[Exception] = None, **kwargs: Any
+    ) -> None:
         logger.exception(
             "task_rejected", task_id=message.properties.get("correlation_id")
         )
 
-    def connect_signals(self):
+    def connect_signals(self) -> None:
         before_task_publish.connect(self.receiver_before_task_publish)
         after_task_publish.connect(self.receiver_after_task_publish)
 
-    def connect_worker_signals(self):
+    def connect_worker_signals(self) -> None:
         before_task_publish.connect(self.receiver_before_task_publish)
         after_task_publish.connect(self.receiver_after_task_publish)
         task_prerun.connect(self.receiver_task_prerun)

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/celery/steps.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from celery import bootsteps
 
 from .receivers import CeleryReceiver
@@ -14,7 +16,7 @@ class DjangoStructLogInitStep(bootsteps.Step):
 
     """
 
-    def __init__(self, parent, **kwargs):
+    def __init__(self, parent: Any, **kwargs: Any) -> None:
         super().__init__(parent, **kwargs)
         self.receiver = CeleryReceiver()
         self.receiver.connect_worker_signals()

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/commands.py

@@ -1,16 +1,23 @@
+from __future__ import annotations
+
+from typing import List, Tuple, Mapping, Any, Type, TYPE_CHECKING
+
 import structlog
 import uuid
 
 from django_extensions.management.signals import pre_command, post_command
 
+if TYPE_CHECKING:
+    import contextvars
+
 logger = structlog.getLogger(__name__)
 
 
 class DjangoCommandReceiver:
-    def __init__(self):
-        self.stack = []
+    def __init__(self) -> None:
+        self.stack: List[Tuple[str, Mapping[str, contextvars.Token[Any]]]] = []
 
-    def pre_receiver(self, sender, *args, **kwargs):
+    def pre_receiver(self, sender: Type[Any], *args: Any, **kwargs: Any) -> None:
         command_id = str(uuid.uuid4())
         if len(self.stack):
             parent_command_id, _ = self.stack[-1]
@@ -26,13 +33,15 @@ class DjangoCommandReceiver:
             command_name=sender.__module__.replace(".management.commands", ""),
         )
 
-    def post_receiver(self, sender, outcome, *args, **kwargs):
+    def post_receiver(
+        self, sender: Type[Any], outcome: str, *args: Any, **kwargs: Any
+    ) -> None:
         logger.info("command_finished")
 
         if len(self.stack):  # pragma: no branch
             command_id, tokens = self.stack.pop()
             structlog.contextvars.reset_contextvars(**tokens)
 
-    def connect_signals(self):
+    def connect_signals(self) -> None:
         pre_command.connect(self.pre_receiver)
         post_command.connect(self.post_receiver)

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog/middlewares/request.py

@@ -1,6 +1,19 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 import uuid
+from typing import (
+    Any,
+    Generator,
+    AsyncGenerator,
+    Callable,
+    Union,
+    Awaitable,
+    cast,
+    Iterator,
+    TYPE_CHECKING,
+)
 
 import structlog
 from asgiref.sync import iscoroutinefunction, markcoroutinefunction
@@ -11,17 +24,22 @@ from asgiref import sync
 from .. import signals
 from ..app_settings import app_settings
 
+if TYPE_CHECKING:
+    from django.http import HttpRequest, HttpResponse
+
 logger = structlog.getLogger(__name__)
 
 
-def get_request_header(request, header_key, meta_key):
+def get_request_header(request: HttpRequest, header_key: str, meta_key: str) -> Any:
     if hasattr(request, "headers"):
         return request.headers.get(header_key)
 
     return request.META.get(meta_key)
 
 
-def sync_streaming_content_wrapper(streaming_content, context):
+def sync_streaming_content_wrapper(
+    streaming_content: Any, context: Any
+) -> Generator[Any, None, None]:
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -33,7 +51,9 @@ def sync_streaming_content_wrapper(streaming_content, context):
             logger.info("streaming_finished")
 
 
-async def async_streaming_content_wrapper(streaming_content, context):
+async def async_streaming_content_wrapper(
+    streaming_content: Any, context: Any
+) -> AsyncGenerator[Any, None]:
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -61,30 +81,37 @@ class RequestMiddleware:
     sync_capable = True
     async_capable = True
 
-    def __init__(self, get_response):
+    def __init__(
+        self,
+        get_response: Callable[
+            [HttpRequest], Union[HttpResponse, Awaitable[HttpResponse]]
+        ],
+    ) -> None:
         self.get_response = get_response
         if iscoroutinefunction(self.get_response):
             markcoroutinefunction(self)
 
-    def __call__(self, request):
+    def __call__(
+        self, request: HttpRequest
+    ) -> Union[HttpResponse, Awaitable[HttpResponse]]:
         if iscoroutinefunction(self):
-            return self.__acall__(request)
+            return cast(RequestMiddleware, self).__acall__(request)  # type: ignore[redundant-cast,unused-ignore]
         self.prepare(request)
-        response = self.get_response(request)
+        response = cast("HttpResponse", self.get_response(request))
         self.handle_response(request, response)
         return response
 
-    async def __acall__(self, request):
+    async def __acall__(self, request: HttpRequest) -> HttpResponse:
         await sync.sync_to_async(self.prepare)(request)
         try:
-            response = await self.get_response(request)
+            response = await cast(Awaitable["HttpResponse"], self.get_response(request))
         except asyncio.CancelledError:
             logger.warning("request_cancelled")
             raise
         await sync.sync_to_async(self.handle_response)(request, response)
         return response
 
-    def handle_response(self, request, response):
+    def handle_response(self, request: HttpRequest, response: HttpResponse) -> None:
         if not hasattr(request, "_raised_exception"):
             self.bind_user_id(request)
             context = structlog.contextvars.get_merged_contextvars(logger)
@@ -114,7 +141,7 @@ class RequestMiddleware:
             if isinstance(response, StreamingHttpResponse):
                 streaming_content = response.streaming_content
                 try:
-                    iter(streaming_content)
+                    iter(cast(Iterator[bytes], streaming_content))
                 except TypeError:
                     response.streaming_content = async_streaming_content_wrapper(
                         streaming_content, context
@@ -136,7 +163,7 @@ class RequestMiddleware:
             )
         structlog.contextvars.clear_contextvars()
 
-    def prepare(self, request):
+    def prepare(self, request: HttpRequest) -> None:
         from ipware import get_client_ip
 
         request_id = get_request_header(
@@ -161,11 +188,11 @@ class RequestMiddleware:
         logger.info("request_started", **log_kwargs)
 
     @staticmethod
-    def format_request(request):
+    def format_request(request: HttpRequest) -> str:
         return f"{request.method} {request.get_full_path()}"
 
     @staticmethod
-    def bind_user_id(request):
+    def bind_user_id(request: HttpRequest) -> None:
         user_id_field = app_settings.USER_ID_FIELD
         if hasattr(request, "user") and request.user is not None and user_id_field:
             user_id = None
@@ -175,7 +202,7 @@ class RequestMiddleware:
                     user_id = str(user_id)
             structlog.contextvars.bind_contextvars(user_id=user_id)
 
-    def process_exception(self, request, exception):
+    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
         if isinstance(exception, (Http404, PermissionDenied)):
             # We don't log an exception here, and we don't set that we handled
             # an error as we want the standard `request_finished` log message

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1/django_structlog.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-structlog
-Version: 8.1.0
+Version: 9.0.0.dev1
 Summary: Structured Logging for Django
 Author-email: Jules Robichaud-Gagnon <j.robichaudg+pypi@gmail.com>
 License: MIT
@@ -13,17 +13,19 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
 Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-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: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Logging
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: django>=4.2

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/django_structlog.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ django_structlog/__init__.py
 django_structlog/app_settings.py
 django_structlog/apps.py
 django_structlog/commands.py
+django_structlog/py.typed
 django_structlog/signals.py
 django_structlog.egg-info/PKG-INFO
 django_structlog.egg-info/SOURCES.txt

{django_structlog-8.1.0 → django_structlog-9.0.0.dev1}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
   ]
   readme = "README.rst"
   dynamic = ["version"]
-  requires-python = ">=3.8"
+  requires-python = ">=3.9"
   license = { text = "MIT" }
   dependencies = [
     "django>=4.2",
@@ -23,16 +23,18 @@ build-backend = "setuptools.build_meta"
     "Framework :: Django",
     "Framework :: Django :: 4.2",
     "Framework :: Django :: 5.0",
+    "Framework :: Django :: 5.1",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: System :: Logging",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
+    "Typing :: Typed",
   ]
 
 [project.urls]
@@ -62,11 +64,11 @@ build-backend = "setuptools.build_meta"
 [tool.black]
   line-length = 88
   target-version = [
-    'py38',
     'py39',
     'py310',
     'py311',
     'py312',
+    'py313',
   ]
   include = '\.pyi?$'
   exclude = '''
@@ -84,7 +86,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.ruff]
   line-length = 88
-  target-version = "py312"
+  target-version = "py313"
   lint.ignore = [
     'E501',
   ]
@@ -99,17 +101,18 @@ build-backend = "setuptools.build_meta"
     #
     # Also, make sure that all python versions used here are included in ./github/worksflows/main.yml
     envlist =
-        py{38,39,310,311}-django42-celery5{2,3}-redis{3,4}-kombu5,
-        py31{0,1}-django50-celery53-redis4-kombu5,
-        py312-django{42,50}-celery53-redis4-kombu5,
+        py{39,310,311}-django42-celery5{2,3}-redis{3,4}-kombu5,
+        py31{0,1}-django5{0,1}-celery5{3,4}-redis4-kombu5,
+        py312-django{42,50,51}-celery5{3,4}-redis4-kombu5,
+        py313-django{51}-celery5{3,4}-redis4-kombu5,
 
     [gh-actions]
     python =
-        3.8: py38
         3.9: py39
         3.10: py310
         3.11: py311
         3.12: py312
+        3.13: py313
 
     [testenv]
     setenv =
@@ -125,8 +128,10 @@ build-backend = "setuptools.build_meta"
         celery51: Celery >=5.1, <5.2
         celery52: Celery >=5.2, <5.3
         celery53: Celery >=5.3, <5.4
+        celery54: Celery >=5.4, <5.5
         django42: Django >=4.2, <5.0
         django50: Django >=5.0, <5.1
+        django51: Django >=5.1, <5.2
         -r{toxinidir}/requirements/ci.txt
 
     commands = pytest --cov=./test_app --cov=./django_structlog --cov-append test_app
@@ -148,3 +153,22 @@ include = [
   "./django_structlog_demo_project/*",
   "./test_app/*",
 ]
+
+[tool.mypy]
+python_version=3.9
+strict=true
+packages=[
+  "django_structlog"
+]
+disallow_subclassing_any=false
+
+[[tool.mypy.overrides]]
+module = [
+  "django_extensions.*",
+  "ipware",
+  "django.*",
+  "structlog.*",
+  "celery.*",
+  "asgiref.*",
+]
+ignore_missing_imports = true