django-structlog 9.0.0.dev2__py3-none-any.whl → 9.0.1.dev1__py3-none-any.whl

django_structlog/__init__.py

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

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/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/celery/receivers.py

@@ -1,36 +1,42 @@
+from typing import TYPE_CHECKING, Any, Optional, Type, cast
+
 import structlog
 from celery import current_app
 from celery.signals import (
-    before_task_publish,
     after_task_publish,
+    before_task_publish,
+    task_failure,
     task_prerun,
+    task_rejected,
     task_retry,
-    task_success,
-    task_failure,
     task_revoked,
+    task_success,
     task_unknown,
-    task_rejected,
 )
 
 from . import signals
 
+if TYPE_CHECKING:  # pragma: no cover
+    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, Any]] = None,
+        routing_key: Optional[str] = None,
+        **kwargs: dict[str, str],
+    ) -> None:
         if current_app.conf.task_protocol < 2:
             return
 
@@ -46,12 +52,16 @@ class CeleryReceiver:
         )
         if properties:
             self._priority = properties.get("priority", None)
-
-        headers["__django_structlog__"] = context
+        cast(dict[str, Any], 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 +69,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 +95,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 +114,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 +136,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 +157,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/celery/signals.py

@@ -1,6 +1,5 @@
 import django.dispatch
 
-
 bind_extra_task_metadata = django.dispatch.Signal()
 """ Signal to add extra ``structlog`` bindings from ``celery``'s task.
 

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/commands.py

@@ -1,16 +1,25 @@
-import structlog
 import uuid
+from typing import TYPE_CHECKING, Any, List, Mapping, Tuple, Type
+
+import structlog
+from django_extensions.management.signals import (  # type: ignore[import-untyped]
+    post_command,
+    pre_command,
+)
 
-from django_extensions.management.signals import pre_command, post_command
+if TYPE_CHECKING:  # pragma: no cover
+    import contextvars
 
 logger = structlog.getLogger(__name__)
 
 
 class DjangoCommandReceiver:
-    def __init__(self):
+    stack: List[Tuple[str, Mapping[str, "contextvars.Token[Any]"]]]
+
+    def __init__(self) -> None:
         self.stack = []
 
-    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 +35,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/middlewares/__init__.py

@@ -1 +1,5 @@
 from .request import RequestMiddleware  # noqa F401
+
+__all__ = [
+    "RequestMiddleware",
+]

django_structlog/middlewares/request.py

@@ -2,28 +2,58 @@ import asyncio
 import logging
 import sys
 import uuid
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Generator,
+    Iterator,
+    Type,
+    Union,
+    cast,
+)
 
 import structlog
-from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+from asgiref import sync
 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 sys.version_info >= (3, 12, 0):
+    from inspect import (  # type: ignore[attr-defined]
+        iscoroutinefunction,
+        markcoroutinefunction,
+    )
+else:
+    from asgiref.sync import (  # type: ignore[no-redef]
+        iscoroutinefunction,
+        markcoroutinefunction,
+    )
+
+if TYPE_CHECKING:  # pragma: no cover
+    from types import TracebackType
+
+    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: Iterator[bytes], context: Any
+) -> Generator[bytes, None, None]:
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -31,11 +61,14 @@ def sync_streaming_content_wrapper(streaming_content, context):
                 yield chunk
         except Exception:
             logger.exception("streaming_failed")
+            raise
         else:
             logger.info("streaming_finished")
 
 
-async def async_streaming_content_wrapper(streaming_content, context):
+async def async_streaming_content_wrapper(
+    streaming_content: AsyncIterator[bytes], context: Any
+) -> AsyncGenerator[bytes, Any]:
     with structlog.contextvars.bound_contextvars(**context):
         logger.info("streaming_started")
         try:
@@ -46,6 +79,7 @@ async def async_streaming_content_wrapper(streaming_content, context):
             raise
         except Exception:
             logger.exception("streaming_failed")
+            raise
         else:
             logger.info("streaming_finished")
 
@@ -63,36 +97,38 @@ 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)
         got_request_exception.connect(self.process_got_request_exception)
 
-    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)
         self.prepare(request)
-        response = self.get_response(request)
+        response = cast("HttpResponse", self.get_response(request))
         self.handle_response(request, response)
         return response
 
-    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):
+    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)
@@ -121,15 +157,13 @@ class RequestMiddleware:
             )
             if isinstance(response, StreamingHttpResponse):
                 streaming_content = response.streaming_content
-                try:
-                    iter(streaming_content)
-                except TypeError:
+                if response.is_async:
                     response.streaming_content = async_streaming_content_wrapper(
-                        streaming_content, context
+                        cast(AsyncIterator[bytes], streaming_content), context
                     )
                 else:
                     response.streaming_content = sync_streaming_content_wrapper(
-                        streaming_content, context
+                        cast(Iterator[bytes], streaming_content), context
                     )
 
         else:
@@ -144,8 +178,8 @@ class RequestMiddleware:
             )
         structlog.contextvars.clear_contextvars()
 
-    def prepare(self, request):
-        from ipware import get_client_ip
+    def prepare(self, request: "HttpRequest") -> None:
+        from ipware import get_client_ip  # type: ignore[import-untyped]
 
         request_id = get_request_header(
             request, "x-request-id", "HTTP_X_REQUEST_ID"
@@ -169,11 +203,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
@@ -183,7 +217,17 @@ class RequestMiddleware:
                     user_id = str(user_id)
             structlog.contextvars.bind_contextvars(user_id=user_id)
 
-    def process_exception(self, request, exception):
+    def process_got_request_exception(
+        self, sender: Type[Any], request: "HttpRequest", **kwargs: Any
+    ) -> None:
+        if not hasattr(request, "_raised_exception"):
+            ex = cast(
+                tuple[Type[Exception], Exception, "TracebackType"],
+                sys.exc_info(),
+            )
+            self._process_exception(request, ex[1])
+
+    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/signals.py

@@ -1,6 +1,5 @@
 import django.dispatch
 
-
 bind_extra_request_metadata = django.dispatch.Signal()
 """ Signal to add extra ``structlog`` bindings from ``django``'s request.
 

{django_structlog-9.0.0.dev2.dist-info → django_structlog-9.0.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: django-structlog
-Version: 9.0.0.dev2
+Version: 9.0.1.dev1
 Summary: Structured Logging for Django
 Author-email: Jules Robichaud-Gagnon <j.robichaudg+pypi@gmail.com>
 License: MIT
@@ -24,6 +24,7 @@ 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
@@ -43,8 +44,14 @@ django-structlog
 
 | |pypi| |wheels| |build-status| |docs| |coverage| |open_issues| |pull_requests|
 | |django| |python| |license| |black| |ruff|
+| |django_packages|
 | |watchers| |stars| |forks|
 
+
+.. |django_packages| image:: https://img.shields.io/badge/Published%20on-Django%20Packages-0c3c26
+   :target: https://djangopackages.org/packages/p/django-structlog/
+   :alt: Published on Django Packages
+
 .. |build-status| image:: https://github.com/jrobichaud/django-structlog/actions/workflows/main.yml/badge.svg?branch=main
    :target: https://github.com/jrobichaud/django-structlog/actions
    :alt: Build Status
@@ -407,6 +414,44 @@ Json file (\ ``logs/json.log``\ )
 Upgrade Guide
 =============
 
+.. _upgrade_9.0:
+
+Upgrading to 9.0+
+^^^^^^^^^^^^^^^^^
+
+Minimum requirements
+~~~~~~~~~~~~~~~~~~~~
+- requires python 3.9+
+- django 4.2 and 5.0+ are supported
+
+
+Type hints
+~~~~~~~~~~
+
+``django-structlog`` now uses `python type hints <https://docs.python.org/3/library/typing.html>`_ and is being validated with `mypy <https://mypy.readthedocs.io/en/stable/>`_ ``--strict``.
+
+
+For ``drf-standardized-errors`` users
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now unhandled exceptions when using `drf-standardized-errors <https://github.com/ghazi-git/drf-standardized-errors>`_ will be intercepted and the exception logged properly.
+
+If you also use `structlog-sentry <https://github.com/kiwicom/structlog-sentry>`_, the exception will now be propagated as expected.
+
+Other libraries alike may be affected by this change.
+
+Internal changes in how ``RequestMiddleware`` handles exceptions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This only affects you if you implemented a middleware inheriting from ``RequestMiddleware`` and you overrided the ``process_exception`` method.
+
+Did you?
+
+If so:
+
+   - ``RequestMiddleware.process_exception`` was renamed to ``RequestMiddleware._process_exception``, you should to the same in the middleware.
+
+
 .. _upgrade_8.0:
 
 Upgrading to 8.0+

django_structlog-9.0.1.dev1.dist-info/RECORD

@@ -0,0 +1,17 @@
+django_structlog/__init__.py,sha256=PD9sNCVA1rbswModeXBrqYVsweBpQ3eNqDXAzp801fI,214
+django_structlog/app_settings.py,sha256=yf1wYt_H_RL7pwBXgmCqblJuRxGbpve3YoWhlfkYA3A,697
+django_structlog/apps.py,sha256=Ntfsd0xD09tVIOk6AnqUkc-Nl0Z2LJjmKC9u_xTIQ9c,614
+django_structlog/commands.py,sha256=-TIHdwneBgamy4RNOMdG1gtR-wZ5ClJH-36iNlnbeEw,1562
+django_structlog/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_structlog/signals.py,sha256=T9YDBG-NDiaqntFbFukTeoWRXLr9k_Foe12WrDMTC4M,3161
+django_structlog/celery/__init__.py,sha256=6KuRCmnb49FOMkJGtrZnx8qgrj4pYLBgNraz_NIJ7KE,57
+django_structlog/celery/receivers.py,sha256=-pxO0yEf6uNmPA0NvlVIc41VraRm3MQ3CjEKlZg8YFA,6187
+django_structlog/celery/signals.py,sha256=CN40ApldyRU6ArbFpn13MlGoR7aFIzMGZ0WVPbXscXg,2115
+django_structlog/celery/steps.py,sha256=9ipqdEc6T_J0R0PPR961x0uAi8bI1RfuFuNLvp4DVxo,641
+django_structlog/middlewares/__init__.py,sha256=Csed6IUMq9SvydoDj1WJ9_o7B49z2qiPR9FUxnVwCco,92
+django_structlog/middlewares/request.py,sha256=cDe6VwkT699YkWtU8Tc5K4gbmPHITzVwvTn3k_FFJIk,8637
+django_structlog-9.0.1.dev1.dist-info/LICENSE.rst,sha256=FmQJJGUr0CAup1Q81JpUuEGsjZM8PCBiNZUuoyHgtBQ,1079
+django_structlog-9.0.1.dev1.dist-info/METADATA,sha256=A_JGRJa60LJ_l3lhYPicfUeAmxJ6yQcBEo6v5rjXaYc,29131
+django_structlog-9.0.1.dev1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+django_structlog-9.0.1.dev1.dist-info/top_level.txt,sha256=tGM_7H0Zgu3x7zaOXRkkZx-i18y6fJE9TJi5RhaYd0Y,17
+django_structlog-9.0.1.dev1.dist-info/RECORD,,

{django_structlog-9.0.0.dev2.dist-info → django_structlog-9.0.1.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

django_structlog-9.0.0.dev2.dist-info/RECORD

@@ -1,16 +0,0 @@
-django_structlog/__init__.py,sha256=my3aISCn2ONUTxtGIsjEH-bpnuTnxcZ7LHFiNgK1fcg,214
-django_structlog/app_settings.py,sha256=-tfrpUhubJAkkuqpYEWUvf5wLjxirudKe2qcWIZpkiM,667
-django_structlog/apps.py,sha256=mVi5b1mIJnVrZRC6UtbxWlpMN2hohVP1olomLELqrAM,606
-django_structlog/commands.py,sha256=bJwosyO-XXVpx_nFEemIGVceL-6OJ0mI8g5FqLrRMpY,1227
-django_structlog/signals.py,sha256=EHy_HMnclfJYJ9gUaJ1kBIvNr9Q2CRZnCDtSi7otVCY,3162
-django_structlog/celery/__init__.py,sha256=6KuRCmnb49FOMkJGtrZnx8qgrj4pYLBgNraz_NIJ7KE,57
-django_structlog/celery/receivers.py,sha256=GBLrO5GKN3n9DlpbWptmIHx6WiTEfvXKFB7KDm6IzQ0,4859
-django_structlog/celery/signals.py,sha256=7iksKd0Xaw2iUFWrPshn2p8nIjbRanrww6caeJsgYtQ,2116
-django_structlog/celery/steps.py,sha256=i3vA9G3MgRzbhHELbx-yLZGjNAcJ7v2vpiCrFCFZ2vc,599
-django_structlog/middlewares/__init__.py,sha256=yi0jJFSPaCt6ilsC4EMQaJEPFJn-uxtW3VmjPefTGvs,52
-django_structlog/middlewares/request.py,sha256=-Cq3c8ENvIR4pge2kPAr6noBSsPNdIfX2-BrioEwUXk,7271
-django_structlog-9.0.0.dev2.dist-info/LICENSE.rst,sha256=FmQJJGUr0CAup1Q81JpUuEGsjZM8PCBiNZUuoyHgtBQ,1079
-django_structlog-9.0.0.dev2.dist-info/METADATA,sha256=wZD5Z2fp35_zdzhq8gMTtqK8Q2aoT0clkz-iXvZ30wk,27624
-django_structlog-9.0.0.dev2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-django_structlog-9.0.0.dev2.dist-info/top_level.txt,sha256=tGM_7H0Zgu3x7zaOXRkkZx-i18y6fJE9TJi5RhaYd0Y,17
-django_structlog-9.0.0.dev2.dist-info/RECORD,,