def __init__(self, parent, **kwargs):
super().__init__(parent, **kwargs)
import celery
from celery.signals import (
before_task_publish,
after_task_publish,
task_prerun,
task_retry,
task_success,
task_failure,
task_revoked,
)
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)
task_retry.connect(receivers.receiver_task_retry)
task_success.connect(receivers.receiver_task_success)
task_failure.connect(receivers.receiver_task_failure)
task_revoked.connect(receivers.receiver_task_revoked)
if celery.VERSION > (4, ):
from celery.signals import task_unknown, task_rejected
task_unknown.connect(receivers.receiver_task_unknown)
task_rejected.connect(receivers.receiver_task_rejected)
def test_defer_task(self):
expected_uuid = "00000000-0000-0000-0000-000000000000"
request = self.factory.get("/foo")
request.user = AnonymousUser()
@shared_task
def test_task(value): # pragma: no cover
pass
from celery.signals import before_task_publish, after_task_publish
before_task_publish.connect(receivers.receiver_before_task_publish)
after_task_publish.connect(receivers.receiver_after_task_publish)
try:
with structlog.threadlocal.tmp_bind(self.logger):
self.logger.bind(request_id=expected_uuid)
with self.assertLogs(
logging.getLogger("django_structlog.celery.receivers"), logging.INFO
) as log_results:
test_task.delay("foo")
finally:
before_task_publish.disconnect(receivers.receiver_before_task_publish)
after_task_publish.disconnect(receivers.receiver_after_task_publish)
self.assertEqual(1, len(log_results.records))
record = log_results.records[0]
self.assertEqual("task_enqueued", record.msg["event"])
self.assertEqual("INFO", record.levelname)
self.assertIn("child_task_id", record.msg)
self.assertEqual(expected_uuid, record.msg["request_id"])
def install():
installed = scout_apm.core.install()
if not installed:
return
before_task_publish.connect(before_publish_callback)
task_prerun.connect(prerun_callback)
task_postrun.connect(postrun_callback)
def register_signals(self):
''' Register celery signals for task publishing '''
# register signals
before_task_publish.connect(
self.before_task_publish_action,
sender=CeleryConstants.get_analyze_task_name())
after_task_publish.connect(
self.after_task_publish_action,
sender=CeleryConstants.get_analyze_task_name())
def connect_traced_handlers(self):
if self._propagate:
before_task_publish.connect(self._prepublish, weak=False)
after_task_publish.connect(self._postpublish, weak=False)
task_prerun.connect(self._start_span, weak=False)
task_failure.connect(self._tag_error, weak=False)
task_retry.connect(self._tag_retry, weak=False)
task_postrun.connect(self._finish_span, weak=False)
log.debug('Registered CeleryTracing signal handlers.')
def install(app=None):
if app is not None:
copy_configuration(app)
installed = scout_apm.core.install()
if not installed:
return
before_task_publish.connect(before_task_publish_callback)
task_prerun.connect(task_prerun_callback)
task_postrun.connect(task_postrun_callback)
def install(cls):
if hasattr(cls, "_instance"):
return
self = cls()
# Make sure to keep a reference alive so this is not garbage collected.
cls._instance = self
worker_ready.connect(self.on_worker_ready)
beat_init.connect(self.on_beat_init)
before_task_publish.connect(self.on_before_task_publish)
after_task_publish.connect(self.on_after_task_publish)
def bind(endpoint=None):
if not endpoint:
endpoint = Endpoint("Celery")
events.endpoint = endpoint
log.info("Attaching zipkin to celery signals")
before_task_publish.connect(events.task_send_handler)
task_prerun.connect(events.task_prerun_handler)
task_postrun.connect(events.task_postrun_handler)
log.info("zipkin signals attached")
def _test_with_regular_client(celery, tracer, task_error):
before_task_publish.disconnect(celery_hooks.before_task_publish_handler)
try:
result = _test_foo_task(celery, task_error)
spans = tracer.recorder.get_spans()
assert len(spans) == 1
span = spans[0]
assert span.parent_id is None
assert_span(span, result, 'run', tags.SPAN_KIND_RPC_SERVER)
finally:
before_task_publish.connect(celery_hooks.before_task_publish_handler)
def _install_patches(self):
Task.apply_async = task_apply_async_wrapper
before_task_publish.connect(before_task_publish_handler)
task_prerun.connect(task_prerun_handler)
task_success.connect(task_success_handler)
task_failure.connect(task_failure_handler)
def add_publish_signals(cls):
from celery.signals import before_task_publish, after_task_publish
before_task_publish.connect(cls.before_task_publish)
after_task_publish.connect(cls.after_task_publish)
from __future__ import absolute_import, unicode_literals
import os
import configurations
from celery import Celery
from celery.signals import before_task_publish, task_postrun, task_prerun
from django_origin_trail.celery_signals import set_logger_params, set_task_local_context, delete_task_local_context
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'JDemotions.settings')
os.environ.setdefault('DJANGO_CONFIGURATION', 'Development')
configurations.setup()
# register django-origin-trail signals
before_task_publish.connect(set_logger_params)
task_prerun.connect(set_task_local_context)
task_postrun.connect(delete_task_local_context)
# celery apps
app = Celery('JDemotions')
# Using a string here means the worker doesn't have to serialize
# the configuration object to child processes.
# - namespace='CELERY' means all celery-related configuration keys
# should have a `CELERY_` prefix.
app.config_from_object('JDemotions.settings.celery_settings:CELERY_SETTINGS')
# Load task modules from all registered Django apps configs.
app.autodiscover_tasks()
def __init__(self, get_response=None):
self.get_response = get_response
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)
def register_signals(self):
''' Register celery signals for task publishing '''
# register signals
before_task_publish.connect(self.before_task_publish_action, sender = CeleryConstants.get_analyze_task_name())
after_task_publish.connect(self.after_task_publish_action, sender = CeleryConstants.get_analyze_task_name())