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())