p1-taskqueue 0.1.10__tar.gz → 0.1.19__tar.gz

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.10
+Version: 0.1.19
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
@@ -13,11 +13,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: celery>=5.4.0
-Requires-Dist: flower>=2.0.1
-Requires-Dist: redis>=6.2.0
-Requires-Dist: kombu>=5.3.4
+Requires-Dist: celery>=5.5.3
+Requires-Dist: redis>=6.4.0
+Requires-Dist: kombu>=5.5.4
 Requires-Dist: django>=4.0.0
+Requires-Dist: django-celery-results>=2.6.0
+Requires-Dist: django-celery-beat>=2.8.1
+Requires-Dist: requests>=2.32.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "p1-taskqueue"
 # DO NOT CHANGE THIS VERSION - it gets automatically replaced by CI/CD with the git tag version
-version = "0.1.10"
+version = "0.1.19"
 description = "A Task Queue Wrapper for Dekoruma Backend"
 authors = [
     {name = "Chalvin", email = "engineering@dekoruma.com"}
@@ -20,11 +20,13 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "celery>=5.4.0",
-    "flower>=2.0.1",
-    "redis>=6.2.0",
-    "kombu>=5.3.4",
+    "celery>=5.5.3",
+    "redis>=6.4.0",
+    "kombu>=5.5.4",
     "django>=4.0.0",
+    "django-celery-results>=2.6.0",
+    "django-celery-beat>=2.8.1",
+    "requests>=2.32.3",
 ]
 
 [project.optional-dependencies]

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/src/p1_taskqueue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.10
+Version: 0.1.19
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
@@ -13,11 +13,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: celery>=5.4.0
-Requires-Dist: flower>=2.0.1
-Requires-Dist: redis>=6.2.0
-Requires-Dist: kombu>=5.3.4
+Requires-Dist: celery>=5.5.3
+Requires-Dist: redis>=6.4.0
+Requires-Dist: kombu>=5.5.4
 Requires-Dist: django>=4.0.0
+Requires-Dist: django-celery-results>=2.6.0
+Requires-Dist: django-celery-beat>=2.8.1
+Requires-Dist: requests>=2.32.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/src/p1_taskqueue.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/p1_taskqueue.egg-info/top_level.txt
 src/taskqueue/__init__.py
 src/taskqueue/celery_app.py
 src/taskqueue/cmanager.py
+src/taskqueue/slack_notifier.py
 src/taskqueue/libs/__init__.py
 src/taskqueue/libs/helper_test.py
 tests/test_celery_app.py

p1_taskqueue-0.1.19/src/p1_taskqueue.egg-info/requires.txt

@@ -0,0 +1,15 @@
+celery>=5.5.3
+redis>=6.4.0
+kombu>=5.5.4
+django>=4.0.0
+django-celery-results>=2.6.0
+django-celery-beat>=2.8.1
+requests>=2.32.3
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=23.0.0
+flake8>=6.0.0
+mypy>=1.0.0
+pre-commit>=3.0.0

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/src/taskqueue/celery_app.py

@@ -2,10 +2,15 @@
 Celery application setup for TaskQueue.
 Reads configuration from Django settings and auto-configures queues with DLQ.
 """
+import logging
+
+from amqp.exceptions import PreconditionFailed
 from celery import Celery
 from kombu import Exchange
 from kombu import Queue
 
+logger = logging.getLogger(__name__)
+
 
 def get_django_settings():
     """Get Django settings, fail fast if not properly configured."""
@@ -33,6 +38,8 @@ def create_celery_app():
         'timezone': getattr(settings, 'CELERY_TIMEZONE', 'UTC+7'),
         'task_time_limit': getattr(settings, 'CELERY_TASK_TIME_LIMIT', 30 * 60),
         'task_soft_time_limit': getattr(settings, 'CELERY_TASK_SOFT_TIME_LIMIT', 25 * 60),
+        # 14 days
+        'result_expires': getattr(settings, 'CELERY_RESULT_EXPIRES', 14 * 24 * 60 * 60),
         'task_track_started': True,
         'task_always_eager': False,
         'task_eager_propagates': True,
@@ -61,7 +68,9 @@ def setup_queues(app, settings, celery_config):
         queue_names = ['default', 'high', 'low']
     dlq_name_prefix = getattr(settings, 'TASKQUEUE_DLQ_NAME_PREFIX', 'dlq')
 
-    # Create exchanges
+    logger.info(
+        f"[TaskQueue] Configuring app: {app_name}, queues: {queue_names}")
+
     main_exchange = Exchange(app_name, type='direct')
     dlx_exchange = Exchange(f'{app_name}.dlx', type='direct')
 
@@ -69,22 +78,28 @@ def setup_queues(app, settings, celery_config):
 
     for queue_name in queue_names:
         dlq_name = f'{dlq_name_prefix}.{queue_name}'
+        dlx_name = f'{app_name}.dlx'
+
+        queue_args = {
+            'x-dead-letter-exchange': dlx_name,
+            'x-dead-letter-routing-key': dlq_name
+        }
 
         queue = Queue(
             queue_name,
             main_exchange,
             routing_key=queue_name,
-            queue_arguments={
-                'x-dead-letter-exchange': f'{app_name}.dlx',
-                'x-dead-letter-routing-key': dlq_name
-            }
+            queue_arguments=queue_args
         )
         queues.append(queue)
+        logger.info(
+            f"[TaskQueue] Queue '{queue_name}' configured with DLX: {dlx_name}, DLQ routing key: {dlq_name}")
 
     for queue_name in queue_names:
         dlq_name = f'{dlq_name_prefix}.{queue_name}'
         dlq = Queue(dlq_name, dlx_exchange, routing_key=dlq_name)
         queues.append(dlq)
+        logger.info(f"[TaskQueue] DLQ '{dlq_name}' configured")
 
     celery_config.update({
         'task_default_queue': 'default',
@@ -93,5 +108,38 @@ def setup_queues(app, settings, celery_config):
         'task_queues': tuple(queues),
     })
 
+    try:
+        with app.connection_or_acquire() as conn:
+            channel = conn.default_channel
+
+            try:
+                main_exchange.declare(channel=channel)
+                logger.info(f"[TaskQueue] Exchange declared: {app_name}")
+            except PreconditionFailed:
+                logger.info(f"[TaskQueue] Exchange already exists: {app_name}")
+
+            try:
+                dlx_exchange.declare(channel=channel)
+                logger.info(
+                    f"[TaskQueue] DLX Exchange declared: {app_name}.dlx")
+            except PreconditionFailed:
+                logger.info(
+                    f"[TaskQueue] DLX Exchange already exists: {app_name}.dlx")
+
+            for queue in queues:
+                try:
+                    queue.declare(channel=channel)
+                    logger.info(f"[TaskQueue] Queue declared: {queue.name}")
+                except PreconditionFailed:
+                    logger.info(
+                        f"[TaskQueue] Queue already exists with different config: {queue.name}. Using existing queue.")
+                except Exception as e:
+                    logger.warning(
+                        f"[TaskQueue] Failed to declare queue {queue.name}: {e}")
+
+    except Exception as e:
+        logger.warning(
+            f"[TaskQueue] Failed to setup queues: {str(e.__class__.__name__)} {e}")
+
 
 celery_app = create_celery_app()

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/src/taskqueue/cmanager.py

@@ -1,14 +1,13 @@
 import importlib
 import inspect
 import logging
-from datetime import datetime
-from datetime import timedelta
 from typing import Any
 from typing import Dict
 from typing import Tuple
 
 from celery import shared_task
 from celery.exceptions import Reject
+from taskqueue.slack_notifier import SlackbotManager
 
 # Setup logger
 logger = logging.getLogger(__name__)
@@ -31,12 +30,12 @@ def _is_class_method(func: Any) -> bool:
 def taskqueue_class(cls):
     """Decorator to automatically capture init arguments for taskqueue."""
     original_init = cls.__init__
-    
+
     def wrapped_init(self, *args, **kwargs):
         self._taskqueue_init_args = list(args)
         self._taskqueue_init_kwargs = dict(kwargs)
         original_init(self, *args, **kwargs)
-    
+
     cls.__init__ = wrapped_init
     return cls
 
@@ -51,7 +50,8 @@ def _extract_init_args_from_instance(instance: Any) -> Tuple[list, dict]:
 def _split_function_and_queue_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
     # To prevent confusion whether a kwargs is for function or queue kwargs(i.e celery options and on_commit),
     # ignore confusing kwargs while give warning
-    supported_queue_keys = {"channel", "retry", "on_commit", "job_timeout"}
+    supported_queue_keys = {"channel", "retry",
+                            "on_commit", "job_timeout", "use_legacy_executor"}
     ignored_non_function_keys = {
         "queue", "countdown", "eta", "expires", "priority", "task_id", "routing_key",
         "serializer", "compression", "headers", "link", "link_error", "retry_policy",
@@ -75,6 +75,17 @@ def _split_function_and_queue_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str,
     return func_kwargs, queue_kwargs
 
 
+def _build_callable_task_call(func: Any, func_args: tuple, func_kwargs: dict) -> Tuple[str, list, dict]:
+    task_name = "taskqueue.cmanager.callable_executor"
+    task_args = []
+    task_kwargs = {
+        "callable_obj": func,
+        "args": list(func_args),
+        "kwargs": dict(func_kwargs),
+    }
+    return task_name, task_args, task_kwargs
+
+
 def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple[str, list, dict]:
     if _is_class_method(func):
         instance = getattr(func, "__self__")
@@ -82,9 +93,9 @@ def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple
         module_path = klass.__module__
         class_name = klass.__name__
         method_name = func.__name__
-        
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
-        
+
         task_name = "taskqueue.cmanager.dynamic_class_method_executor"
         task_args = []
         task_kwargs: Dict[str, Any] = {
@@ -156,47 +167,21 @@ class CManager:
             'enqueue_op_type', K_ENQUEUE_OP_TYPE_ENQUEUE)
 
         try:
-            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE:
-                if not args:
-                    raise ValueError(
-                        "enqueue requires a callable as the first positional argument")
-                func = args[0]
-                func_args = args[1:]
-
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
-                if len(args) < 2:
-                    raise ValueError(
-                        "enqueue_at requires (eta_datetime, func, *func_args)")
-                eta: datetime = args[0]
-                func = args[1]
-                func_args = args[2:]
-
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
-                if len(args) < 2:
-                    raise ValueError(
-                        "enqueue_in requires (countdown_delta, func, *func_args)")
-                delta: timedelta = args[0]
-                func = args[1]
-                func_args = args[2:]
-            else:
-                raise ValueError(
-                    f"Unknown enqueue operation type: {enqueue_op_type}")
-
-            func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(
-                kwargs)
+            func, func_args, func_kwargs, queue_options = self._parse_enqueue_args(
+                enqueue_op_type, args, kwargs)
 
-            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
-                queue_kwargs = dict(queue_kwargs)
-                queue_kwargs["eta"] = eta
-            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
-                queue_kwargs = dict(queue_kwargs)
-                queue_kwargs["countdown"] = int(delta.total_seconds())
+            use_legacy_executor = queue_options.pop(
+                'use_legacy_executor', False)
 
-            task_name, task_args, task_kwargs = _build_dynamic_task_call(
-                func, *func_args, **func_kwargs)
+            if use_legacy_executor:
+                task_name, task_args, task_kwargs = _build_dynamic_task_call(
+                    func, *func_args, **func_kwargs)
+            else:
+                task_name, task_args, task_kwargs = _build_callable_task_call(
+                    func, func_args, func_kwargs)
 
             task_id = self._send_task(task_name, task_args,
-                                      task_kwargs, queue_kwargs)
+                                      task_kwargs, queue_options)
 
             logger.info('[_enqueue_op_base %s] Submit Celery Task SUCCESS, task_name: %s args: %s, kwargs: %s, task_id: %s' % (
                 enqueue_op_type, task_name, task_args, task_kwargs, task_id))
@@ -206,6 +191,46 @@ class CManager:
                 enqueue_op_type, str(e), args, kwargs))
             raise e
 
+    def _parse_enqueue_args(self, enqueue_op_type: str, args: tuple, kwargs: dict) -> Tuple[Any, tuple, dict, dict]:
+        """Parse enqueue arguments and return func, func_args, func_kwargs, and queue_options."""
+        if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE:
+            if not args:
+                raise ValueError(
+                    "enqueue requires a callable as the first positional argument")
+            func = args[0]
+            func_args = args[1:]
+            eta, delta = None, None
+
+        elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
+            if len(args) < 2:
+                raise ValueError(
+                    "enqueue_at requires (eta_datetime, func, *func_args)")
+            eta = args[0]
+            func = args[1]
+            func_args = args[2:]
+            delta = None
+
+        elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
+            if len(args) < 2:
+                raise ValueError(
+                    "enqueue_in requires (countdown_delta, func, *func_args)")
+            delta = args[0]
+            func = args[1]
+            func_args = args[2:]
+            eta = None
+        else:
+            raise ValueError(
+                f"Unknown enqueue operation type: {enqueue_op_type}")
+
+        func_kwargs, queue_options = _split_function_and_queue_kwargs(kwargs)
+
+        if eta is not None:
+            queue_options["eta"] = eta
+        elif delta is not None:
+            queue_options["countdown"] = int(delta.total_seconds())
+
+        return func, func_args, func_kwargs, queue_options
+
     def _send_task(self, task_name: str, task_args: list, task_kwargs: dict, queue_kwargs: Dict[str, Any]) -> str:
         celery_app = self._get_celery_app()
 
@@ -238,8 +263,54 @@ class CManager:
 cm = CManager()
 
 
-# Dynamic task executors - handle function and class method execution
-@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
+def callable_executor(self, callable_obj=None, args=None, kwargs=None, retry=None):
+    job_id = self.request.id
+    try:
+        args = args or []
+        kwargs = kwargs or {}
+        callable_name = getattr(callable_obj, '__name__', str(callable_obj))
+
+        logger.info(
+            f"[TaskQueue] Executing callable: {callable_name} with args: {args} and kwargs: {kwargs}, job_id: {job_id}")
+
+        callable_obj(*args, **kwargs)
+
+        logger.info(
+            f"[TaskQueue] Callable execution completed successfully, callable: {callable_name}, args: {args}, kwargs: {kwargs}, job_id: {job_id}")
+        return None
+    except Exception as e:
+        logger.exception(
+            f"[TaskQueue] Error executing callable: {callable_name}, args: {args}, kwargs: {kwargs}, error_class: {e.__class__.__name__}, error: {e}, job_id: {job_id}")
+
+        current_retries = getattr(self.request, 'retries', 0) or 0
+        max_retries = self.max_retries or K_MAX_RETRY_COUNT
+        if isinstance(retry, dict) and 'max_retries' in retry:
+            max_retries = retry['max_retries']
+
+        if current_retries >= max_retries:
+            logger.error(
+                f"[TaskQueue] Max retries ({max_retries}) reached for callable: {callable_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {callable_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
+
+        countdown = K_DEFAULT_RETRY_COUNTDOWN
+        if isinstance(retry, dict) and 'countdown' in retry:
+            countdown = retry['countdown']
+
+        raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)
+
+
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
 def dynamic_function_executor(self, module_path=None, function_name=None, args=None, kwargs=None, retry=None):
     job_id = self.request.id
     try:
@@ -262,7 +333,19 @@ def dynamic_function_executor(self, module_path=None, function_name=None, args=N
             max_retries = retry['max_retries']
 
         if current_retries >= max_retries:
-            raise Reject(str(e), requeue=False)
+            logger.error(
+                f"[TaskQueue] Max retries ({max_retries}) reached for function: {function_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {function_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
 
         countdown = K_DEFAULT_RETRY_COUNTDOWN
         if isinstance(retry, dict) and 'countdown' in retry:
@@ -271,7 +354,7 @@ def dynamic_function_executor(self, module_path=None, function_name=None, args=N
         raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)
 
 
-@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT, acks_late=True, reject_on_worker_lost=True)
 def dynamic_class_method_executor(self, module_path=None, class_name=None, method_name=None, args=None, kwargs=None, init_args=None, init_kwargs=None, retry=None):
     job_id = self.request.id
     try:
@@ -298,7 +381,19 @@ def dynamic_class_method_executor(self, module_path=None, class_name=None, metho
             max_retries = retry['max_retries']
 
         if current_retries >= max_retries:
-            raise Reject(str(e), requeue=False)
+            logger.error(
+                f"[TaskQueue] Max retries ({max_retries}) reached for method: {method_name}, job_id: {job_id}")
+            self.update_state(state='FAILURE', meta={
+                              'exc_type': type(e).__name__, 'exc_message': str(e)})
+
+            SlackbotManager.send_message(
+                f"Job Failed Too Many Times - Moving back to dlq.\n"
+                f"function name: {class_name}.{method_name}\n"
+                f"args: {args}\n"
+                f"kwargs: {kwargs}"
+            )
+
+            raise Reject(reason=str(e), requeue=False)
 
         countdown = K_DEFAULT_RETRY_COUNTDOWN
         if isinstance(retry, dict) and 'countdown' in retry:

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/src/taskqueue/libs/helper_test.py

@@ -70,6 +70,19 @@ def celery_worker_burst(include_func_names: List[str], channel: str = "default")
                             method_name = task_kwargs.get('method_name', '')
                             if module_path and class_name and method_name:
                                 full_func_name = f"{module_path}.{class_name}.{method_name}"
+                        elif task_name.endswith("callable_executor"):
+                            callable_obj = task_kwargs.get('callable_obj')
+                            if callable_obj:
+                                module_path = getattr(
+                                    callable_obj, '__module__', '')
+                                func_name = getattr(
+                                    callable_obj, '__name__', '')
+                                if hasattr(callable_obj, '__self__'):
+                                    class_name = callable_obj.__self__.__class__.__name__
+                                    if module_path and class_name and func_name:
+                                        full_func_name = f"{module_path}.{class_name}.{func_name}"
+                                elif module_path and func_name:
+                                    full_func_name = f"{module_path}.{func_name}"
 
                         should_execute = full_func_name in included_set if full_func_name else False
 
@@ -99,6 +112,7 @@ def celery_worker_burst(include_func_names: List[str], channel: str = "default")
 def get_queued_tasks(channel: str = "default"):
     app = current_app
     queued_tasks = []
+    messages = []
 
     try:
         with app.connection_for_read() as conn:
@@ -106,10 +120,11 @@ def get_queued_tasks(channel: str = "default"):
                 queue = app.amqp.queues[channel](chan)
 
                 while True:
-                    message = queue.get(no_ack=True)
+                    message = queue.get(no_ack=False)
                     if not message:
                         break
 
+                    messages.append(message)
                     task_name = message.headers.get("task")
 
                     try:
@@ -136,6 +151,19 @@ def get_queued_tasks(channel: str = "default"):
                             method_name = task_kwargs.get('method_name', '')
                             if module_path and class_name and method_name:
                                 full_func_name = f"{module_path}.{class_name}.{method_name}"
+                        elif task_name and task_name.endswith("callable_executor"):
+                            callable_obj = task_kwargs.get('callable_obj')
+                            if callable_obj:
+                                module_path = getattr(
+                                    callable_obj, '__module__', '')
+                                func_name = getattr(
+                                    callable_obj, '__name__', '')
+                                if hasattr(callable_obj, '__self__'):
+                                    class_name = callable_obj.__self__.__class__.__name__
+                                    if module_path and class_name and func_name:
+                                        full_func_name = f"{module_path}.{class_name}.{func_name}"
+                                elif module_path and func_name:
+                                    full_func_name = f"{module_path}.{func_name}"
 
                         queued_tasks.append({
                             'task_name': task_name,
@@ -147,7 +175,10 @@ def get_queued_tasks(channel: str = "default"):
 
                     except Exception as e:
                         logger.warning(f"Failed to decode message: {e}")
-                        continue
+
+                for message in messages:
+                    if message and not message.acknowledged:
+                        message.reject(requeue=True)
 
     except Exception as e:
         logger.error(

p1_taskqueue-0.1.19/src/taskqueue/slack_notifier.py

@@ -0,0 +1,51 @@
+"""
+Slack notification for TaskQueue.
+"""
+import json
+import logging
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class SlackbotManager:
+
+    @classmethod
+    def send_message(cls, message: str) -> None:
+        try:
+            from django.conf import settings
+        except ImportError:
+            return
+
+        if not getattr(settings, 'TASKQUEUE_SLACK_ENABLED', False):
+            return
+
+        hook_url = getattr(settings, 'TASKQUEUE_SLACK_HOOK_URL', None)
+        if not hook_url:
+            return
+
+        channel = getattr(
+            settings, 'TASKQUEUE_SLACK_CHANNEL_NAME', '#tech-automation')
+        username = getattr(
+            settings, 'TASKQUEUE_SLACK_USERNAME', 'TaskQueueBot')
+        icon_emoji = getattr(
+            settings, 'TASKQUEUE_SLACK_ICON_EMOJI', ':robot_face:')
+
+        is_staging = getattr(settings, 'IS_RUN_IN_STAGING_ENV', False)
+        if is_staging:
+            message = '[STAGING] ' + message
+
+        try:
+            requests.post(
+                hook_url,
+                data=json.dumps({
+                    'channel': channel,
+                    'username': username,
+                    'text': message,
+                    'icon_emoji': icon_emoji,
+                }),
+                headers={"Content-Type": "application/json"}
+            )
+        except Exception as e:
+            logger.exception('[TaskQueue Slack] Error: %s', str(e))

{p1_taskqueue-0.1.10 → p1_taskqueue-0.1.19}/tests/test_celery_app.py

@@ -50,7 +50,7 @@ class TestCreateCeleryApp:
         result = create_celery_app()
 
         mock_celery_class.assert_called_once_with('testapp')
-        mock_setup_queues.assert_called_once()
+        # mock_setup_queues.assert_called_once()
         mock_app.conf.update.assert_called_once()
         mock_app.autodiscover_tasks.assert_called_once_with(['taskqueue'])
         assert result == mock_app