django-structlog 9.0.0.dev1__tar.gz → 9.0.0.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-structlog
-Version: 9.0.0.dev1
+Version: 9.0.0.dev2
 Summary: Structured Logging for Django
 Author-email: Jules Robichaud-Gagnon <j.robichaudg+pypi@gmail.com>
 License: MIT
@@ -24,7 +24,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Logging
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst

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

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

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

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

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

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

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

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

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

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

@@ -1,23 +1,16 @@
-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) -> None:
-        self.stack: List[Tuple[str, Mapping[str, contextvars.Token[Any]]]] = []
+    def __init__(self):
+        self.stack = []
 
-    def pre_receiver(self, sender: Type[Any], *args: Any, **kwargs: Any) -> None:
+    def pre_receiver(self, sender, *args, **kwargs):
         command_id = str(uuid.uuid4())
         if len(self.stack):
             parent_command_id, _ = self.stack[-1]
@@ -33,15 +26,13 @@ class DjangoCommandReceiver:
             command_name=sender.__module__.replace(".management.commands", ""),
         )
 
-    def post_receiver(
-        self, sender: Type[Any], outcome: str, *args: Any, **kwargs: Any
-    ) -> None:
+    def post_receiver(self, sender, outcome, *args, **kwargs):
         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) -> None:
+    def connect_signals(self):
         pre_command.connect(self.pre_receiver)
         post_command.connect(self.post_receiver)

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

@@ -1,45 +1,29 @@
-from __future__ import annotations
-
 import asyncio
 import logging
+import sys
 import uuid
-from typing import (
-    Any,
-    Generator,
-    AsyncGenerator,
-    Callable,
-    Union,
-    Awaitable,
-    cast,
-    Iterator,
-    TYPE_CHECKING,
-)
 
 import structlog
 from asgiref.sync import iscoroutinefunction, markcoroutinefunction
 from django.core.exceptions import PermissionDenied
+from django.core.signals import got_request_exception
 from django.http import Http404, StreamingHttpResponse
 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: HttpRequest, header_key: str, meta_key: str) -> Any:
+def get_request_header(request, header_key, meta_key):
     if hasattr(request, "headers"):
         return request.headers.get(header_key)
 
     return request.META.get(meta_key)
 
 
-def sync_streaming_content_wrapper(
-    streaming_content: Any, context: Any
-) -> Generator[Any, None, None]:
+def sync_streaming_content_wrapper(streaming_content, context):
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -51,9 +35,7 @@ def sync_streaming_content_wrapper(
             logger.info("streaming_finished")
 
 
-async def async_streaming_content_wrapper(
-    streaming_content: Any, context: Any
-) -> AsyncGenerator[Any, None]:
+async def async_streaming_content_wrapper(streaming_content, context):
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -81,37 +63,36 @@ class RequestMiddleware:
     sync_capable = True
     async_capable = True
 
-    def __init__(
-        self,
-        get_response: Callable[
-            [HttpRequest], Union[HttpResponse, Awaitable[HttpResponse]]
-        ],
-    ) -> None:
+    def __init__(self, get_response):
         self.get_response = get_response
         if iscoroutinefunction(self.get_response):
             markcoroutinefunction(self)
+        got_request_exception.connect(self.process_got_request_exception)
 
-    def __call__(
-        self, request: HttpRequest
-    ) -> Union[HttpResponse, Awaitable[HttpResponse]]:
+    def __call__(self, request):
         if iscoroutinefunction(self):
-            return cast(RequestMiddleware, self).__acall__(request)  # type: ignore[redundant-cast,unused-ignore]
+            return self.__acall__(request)
         self.prepare(request)
-        response = cast("HttpResponse", self.get_response(request))
+        response = self.get_response(request)
         self.handle_response(request, response)
         return response
 
-    async def __acall__(self, request: HttpRequest) -> HttpResponse:
+    def process_got_request_exception(self, sender, request, **kwargs):
+        if not hasattr(request, "_raised_exception"):
+            ex = sys.exc_info()
+            self.process_exception(request, ex[1])
+
+    async def __acall__(self, request):
         await sync.sync_to_async(self.prepare)(request)
         try:
-            response = await cast(Awaitable["HttpResponse"], self.get_response(request))
+            response = await 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: HttpRequest, response: HttpResponse) -> None:
+    def handle_response(self, request, response):
         if not hasattr(request, "_raised_exception"):
             self.bind_user_id(request)
             context = structlog.contextvars.get_merged_contextvars(logger)
@@ -141,7 +122,7 @@ class RequestMiddleware:
             if isinstance(response, StreamingHttpResponse):
                 streaming_content = response.streaming_content
                 try:
-                    iter(cast(Iterator[bytes], streaming_content))
+                    iter(streaming_content)
                 except TypeError:
                     response.streaming_content = async_streaming_content_wrapper(
                         streaming_content, context
@@ -163,7 +144,7 @@ class RequestMiddleware:
             )
         structlog.contextvars.clear_contextvars()
 
-    def prepare(self, request: HttpRequest) -> None:
+    def prepare(self, request):
         from ipware import get_client_ip
 
         request_id = get_request_header(
@@ -188,11 +169,11 @@ class RequestMiddleware:
         logger.info("request_started", **log_kwargs)
 
     @staticmethod
-    def format_request(request: HttpRequest) -> str:
+    def format_request(request):
         return f"{request.method} {request.get_full_path()}"
 
     @staticmethod
-    def bind_user_id(request: HttpRequest) -> None:
+    def bind_user_id(request):
         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
@@ -202,7 +183,7 @@ class RequestMiddleware:
                     user_id = str(user_id)
             structlog.contextvars.bind_contextvars(user_id=user_id)
 
-    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
+    def process_exception(self, request, exception):
         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-9.0.0.dev1 → django_structlog-9.0.0.dev2/django_structlog.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-structlog
-Version: 9.0.0.dev1
+Version: 9.0.0.dev2
 Summary: Structured Logging for Django
 Author-email: Jules Robichaud-Gagnon <j.robichaudg+pypi@gmail.com>
 License: MIT
@@ -24,7 +24,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Logging
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst

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

@@ -6,7 +6,6 @@ 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-9.0.0.dev1 → django_structlog-9.0.0.dev2}/pyproject.toml

@@ -34,7 +34,6 @@ build-backend = "setuptools.build_meta"
     "Topic :: System :: Logging",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    "Typing :: Typed",
   ]
 
 [project.urls]
@@ -153,22 +152,3 @@ 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