Used command black django_structlog django_structlog_demo_project

django_structlog/__init__.py

@@ -2,7 +2,7 @@
 """
 
 
-default_app_config = 'django_structlog.apps.DjangoStructLogConfig'
+default_app_config = "django_structlog.apps.DjangoStructLogConfig"
 name = "django_structlog"
 
 VERSION = (1, 2, 2)

django_structlog/apps.py

@@ -2,4 +2,4 @@
 
 
 class DjangoStructLogConfig(AppConfig):
-    name = 'django_structlog'
+    name = "django_structlog"

django_structlog/celery/middlewares.py

@@ -12,12 +12,11 @@ class CeleryMiddleware(object):
     ... ]
 
     """
+
     def __init__(self, get_response=None):
         self.get_response = get_response
-        from celery.signals import (
-            before_task_publish,
-            after_task_publish,
-        )
+        from celery.signals import before_task_publish, after_task_publish
+
         before_task_publish.connect(receiver_before_task_publish)
         after_task_publish.connect(receiver_after_task_publish)
 

django_structlog/celery/receivers.py

@@ -10,42 +10,52 @@ def receiver_before_task_publish(sender=None, headers=None, body=None, **kwargs)
     immutable_logger = structlog.threadlocal.as_immutable(logger)
     # noinspection PyProtectedMember
     context = dict(immutable_logger._context)
-    if 'task_id' in context:
-        context['parent_task_id'] = context.pop('task_id')
-    headers['__django_structlog__'] = context
+    if "task_id" in context:
+        context["parent_task_id"] = context.pop("task_id")
+    headers["__django_structlog__"] = context
 
 
 def receiver_after_task_publish(sender=None, headers=None, body=None, **kwargs):
-    logger.info('task_enqueued', child_task_id=headers['id'], child_task_name=headers['task'])
+    logger.info(
+        "task_enqueued", child_task_id=headers["id"], child_task_name=headers["task"]
+    )
 
 
 def receiver_task_pre_run(task_id, task, *args, **kwargs):
     logger.new()
     logger.bind(task_id=task_id)
-    signals.bind_extra_task_metadata.send(sender=receiver_task_pre_run, task=task, logger=logger)
-    metadata = getattr(task.request, '__django_structlog__', {})
+    signals.bind_extra_task_metadata.send(
+        sender=receiver_task_pre_run, task=task, logger=logger
+    )
+    metadata = getattr(task.request, "__django_structlog__", {})
     logger.bind(**metadata)
 
 
 def receiver_task_retry(request=None, reason=None, einfo=None, **kwargs):
-    logger.warning('task_retrying', reason=reason)
+    logger.warning("task_retrying", reason=reason)
 
 
 def receiver_task_success(result=None, **kwargs):
-    logger.info('task_succeed', result=str(result))
+    logger.info("task_succeed", result=str(result))
 
 
-def receiver_task_failure(task_id=None, exception=None, traceback=None, einfo=None, *args, **kwargs):
-    logger.error('task_failed', error=str(exception))
+def receiver_task_failure(
+    task_id=None, exception=None, traceback=None, einfo=None, *args, **kwargs
+):
+    logger.error("task_failed", error=str(exception))
 
 
-def receiver_task_revoked(request=None, terminated=None, signum=None, expired=None, **kwargs):
-    logger.warning('task_revoked', terminated=terminated, signum=signum, expired=expired)
+def receiver_task_revoked(
+    request=None, terminated=None, signum=None, expired=None, **kwargs
+):
+    logger.warning(
+        "task_revoked", terminated=terminated, signum=signum, expired=expired
+    )
 
 
 def receiver_task_unknown(message=None, exc=None, name=None, id=None, **kwargs):
-    logger.error('task_not_found', message=message)
+    logger.error("task_not_found", message=message)
 
 
 def receiver_task_rejected(message=None, exc=None, **kwargs):
-    logger.error('task_rejected', message=message)
+    logger.error("task_rejected", message=message)

django_structlog/celery/steps.py

@@ -27,6 +27,7 @@ def __init__(self, parent, **kwargs):
             task_unknown,
             task_rejected,
         )
+
         before_task_publish.connect(receivers.receiver_before_task_publish)
         after_task_publish.connect(receivers.receiver_after_task_publish)
         task_prerun.connect(receivers.receiver_task_pre_run)

django_structlog/middlewares/__init__.py

@@ -1,8 +1,4 @@
-from .request import (  # noqa F401
-    RequestMiddleware,
-)
+from .request import RequestMiddleware  # noqa F401
 
 # noinspection PyUnresolvedReferences
-from ..celery.middlewares import (  # noqa F401
-    CeleryMiddleware,
-)
+from ..celery.middlewares import CeleryMiddleware  # noqa F401

django_structlog/middlewares/request.py

@@ -17,36 +17,34 @@ class RequestMiddleware(object):
     ... ]
 
     """
+
     def __init__(self, get_response):
         self.get_response = get_response
 
     def __call__(self, request):
         from ipware import get_client_ip
+
         request_id = str(uuid.uuid4())
         with structlog.threadlocal.tmp_bind(logger):
             logger.bind(request_id=request_id)
             logger.bind(user_id=request.user.id)
             ip, routable = get_client_ip(request)
             logger.bind(ip=ip)
-            signals.bind_extra_request_metadata.send(sender=self.__class__, request=request, logger=logger)
+            signals.bind_extra_request_metadata.send(
+                sender=self.__class__, request=request, logger=logger
+            )
 
             logger.info(
-                'request_started',
+                "request_started",
                 request=request,
-                user_agent=request.META.get('HTTP_USER_AGENT'),
+                user_agent=request.META.get("HTTP_USER_AGENT"),
             )
             try:
                 response = self.get_response(request)
             except Exception as e:
-                logger.error(
-                    'request_failed',
-                    exception=str(e),
-                )
+                logger.error("request_failed", exception=str(e))
                 raise
             else:
-                logger.info(
-                    'request_finished',
-                    code=response.status_code,
-                )
+                logger.info("request_finished", code=response.status_code)
 
         return response

django_structlog/signals.py

@@ -1,7 +1,9 @@
 import django.dispatch
 
 
-bind_extra_request_metadata = django.dispatch.Signal(providing_args=["request", "logger"])
+bind_extra_request_metadata = django.dispatch.Signal(
+    providing_args=["request", "logger"]
+)
 """ Signal to add extra ``structlog`` bindings from ``django``'s request.
 
 >>> from django.dispatch import receiver

django_structlog_demo_project/contrib/sites/migrations/0003_set_site_domain_and_name.py

@@ -12,10 +12,7 @@ def update_site_forward(apps, schema_editor):
     Site = apps.get_model("sites", "Site")
     Site.objects.update_or_create(
         id=settings.SITE_ID,
-        defaults={
-            "domain": "example.com",
-            "name": "django_structlog_demo_project",
-        },
+        defaults={"domain": "example.com", "name": "django_structlog_demo_project"},
     )
 
 

django_structlog_demo_project/home/views.py

@@ -1,25 +1,27 @@
 import structlog
 from django.http import HttpResponse
-from django_structlog_demo_project.taskapp.celery import successful_task, failing_task, nesting_task
+from django_structlog_demo_project.taskapp.celery import (
+    successful_task,
+    failing_task,
+    nesting_task,
+)
 
 logger = structlog.get_logger(__name__)
 
 
 def enqueue_successful_task(request):
     logger.info("Enqueuing successful task")
-    successful_task.delay(foo='bar')
+    successful_task.delay(foo="bar")
     return HttpResponse(status=201)
 
 
 def enqueue_failing_task(request):
     logger.info("Enqueuing failing task")
-    failing_task.delay(foo='bar')
+    failing_task.delay(foo="bar")
     return HttpResponse(status=201)
 
 
 def enqueue_nesting_task(request):
     logger.info("Enqueuing nesting task")
     nesting_task.delay()
     return HttpResponse(status=201)
-
-

django_structlog_demo_project/taskapp/celery.py

@@ -24,14 +24,14 @@
 app.config_from_object("django.conf:settings", namespace="CELERY")
 
 # A step to initialize django-structlog
-app.steps['worker'].add(DjangoStructLogInitStep)
+app.steps["worker"].add(DjangoStructLogInitStep)
 
 
 @setup_logging.connect
-def receiver_setup_logging(loglevel, logfile, format, colorize, **kwargs):  # pragma: no cover
-    logging.basicConfig(
-        **settings.LOGGING,
-    )
+def receiver_setup_logging(
+    loglevel, logfile, format, colorize, **kwargs
+):  # pragma: no cover
+    logging.basicConfig(**settings.LOGGING)
 
     structlog.configure(
         processors=[
@@ -44,7 +44,7 @@ def receiver_setup_logging(loglevel, logfile, format, colorize, **kwargs):  # pr
             structlog.processors.format_exc_info,
             structlog.processors.UnicodeDecoder(),
             structlog.processors.ExceptionPrettyPrinter(),
-            #structlog.processors.KeyValueRenderer(),
+            # structlog.processors.KeyValueRenderer(),
             structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
         ],
         context_class=structlog.threadlocal.wrap_dict(dict),
@@ -71,27 +71,30 @@ def debug_task(self):
 @shared_task
 def successful_task(foo=None):
     import structlog
+
     logger = structlog.getLogger(__name__)
-    logger.info('This is a successful task')
+    logger.info("This is a successful task")
 
 
 @shared_task
 def failing_task(foo=None, **kwargs):
-    raise Exception('This is a failed task')
+    raise Exception("This is a failed task")
 
 
 @shared_task
 def nesting_task():
     import structlog
+
     logger = structlog.getLogger(__name__)
-    logger.bind(foo='Bar')
-    logger.info('This is a nesting task')
+    logger.bind(foo="Bar")
+    logger.info("This is a nesting task")
 
     nested_task.delay()
 
 
 @shared_task
 def nested_task():
     import structlog
+
     logger = structlog.getLogger(__name__)
-    logger.info('This is a nested task')
+    logger.info("This is a nested task")

django_structlog_demo_project/taskapp/tests/test_celery.py

@@ -7,30 +7,30 @@
 
 class TestSuccessfulTask:
     def test(self, caplog):
-        celery.successful_task(foo='bar')
+        celery.successful_task(foo="bar")
         assert len(caplog.records) == 1
         record = caplog.records[0]
-        assert record.msg['event'] == "This is a successful task"
+        assert record.msg["event"] == "This is a successful task"
 
 
 class TestFailingTask:
     def test(self):
         with pytest.raises(Exception) as e:
-            celery.failing_task(foo='bar')
-        assert str(e.value) == 'This is a failed task'
+            celery.failing_task(foo="bar")
+        assert str(e.value) == "This is a failed task"
 
 
 class TestNestingTask:
     def test(self, caplog):
         celery.nesting_task()
         assert len(caplog.records) == 1
         record = caplog.records[0]
-        assert record.msg['event'] == "This is a nesting task"
+        assert record.msg["event"] == "This is a nesting task"
 
 
 class TestNestedTask:
     def test(self, caplog):
         celery.nested_task()
         assert len(caplog.records) == 1
         record = caplog.records[0]
-        assert record.msg['event'] == "This is a nested task"
+        assert record.msg["event"] == "This is a nested task"

django_structlog_demo_project/test_app/__init__.py

@@ -1 +1 @@
-default_app_config = 'django_structlog_demo_project.test_app.apps.TestAppConfig'
+default_app_config = "django_structlog_demo_project.test_app.apps.TestAppConfig"

django_structlog_demo_project/test_app/apps.py

@@ -2,4 +2,4 @@
 
 
 class TestAppConfig(AppConfig):
-    name = 'django_structlog_demo_project.test_app'
+    name = "django_structlog_demo_project.test_app"