cronradar-celery 0.0.2__py3-none-any.whl

cronradar_celery/__init__.py

@@ -0,0 +1,66 @@
+"""
+CronRadar Celery Integration
+
+Automatic monitoring for Celery periodic tasks.
+Monitors all tasks by default - use @skip_monitor to opt-out.
+"""
+
+import sys
+from typing import Optional
+from celery import Celery
+from celery.signals import task_success, task_failure, task_retry
+
+from .monitors import setup_task_monitoring, skip_monitor_decorator
+from .discovery import discover_and_sync_tasks
+
+__version__ = "0.0.2"
+
+# Track initialization to prevent duplicate setup
+_initialized = False
+
+
+def setup_cronradar(app: Celery, api_key: Optional[str] = None) -> None:
+    """
+    Configure CronRadar monitoring for Celery tasks.
+    Monitors all periodic tasks by default - use @skip_monitor decorator to opt-out.
+
+    Args:
+        app: Celery application instance
+        api_key: Optional API key (defaults to CRONRADAR_API_KEY env var)
+
+    Example:
+        from celery import Celery
+        from cronradar_celery import setup_cronradar
+
+        app = Celery('myapp')
+        setup_cronradar(app)
+    """
+    global _initialized
+
+    if _initialized:
+        print("[CronRadar.Celery] Already initialized. Skipping duplicate setup.", file=sys.stderr)
+        return
+
+    _initialized = True
+
+    # Store API key in environment if provided
+    if api_key:
+        import os
+        os.environ['CRONRADAR_API_KEY'] = api_key
+
+    print("[CronRadar.Celery] Initializing MonitorAll mode - use @skip_monitor to opt-out", file=sys.stderr)
+
+    # Setup task monitoring via signals
+    setup_task_monitoring(app)
+
+    # Auto-discover and sync beat schedule tasks
+    discover_and_sync_tasks(app)
+
+    print("[CronRadar.Celery] ✓ Monitoring enabled successfully!", file=sys.stderr)
+
+
+# Decorator for opting out
+skip_monitor = skip_monitor_decorator
+
+
+__all__ = ['setup_cronradar', 'skip_monitor', '__version__']

cronradar_celery/discovery.py

@@ -0,0 +1,77 @@
+"""
+Auto-discovery of Celery Beat periodic tasks.
+"""
+
+import sys
+from typing import Dict, Any
+from celery import Celery
+
+import cronradar
+from .utils import normalize_task_name, generate_readable_name, schedule_to_cron
+
+
+def discover_and_sync_tasks(app: Celery) -> None:
+    """
+    Discover Celery Beat periodic tasks and sync them to CronRadar.
+    Syncs all periodic tasks found in beat schedule.
+
+    Args:
+        app: Celery application instance
+    """
+    try:
+        # Get beat schedule configuration
+        beat_schedule = app.conf.beat_schedule
+
+        if not beat_schedule:
+            print("[CronRadar.Celery] No beat schedule configured. Skipping auto-discovery.", file=sys.stderr)
+            return
+
+        print(f"[CronRadar.Celery] Discovering {len(beat_schedule)} periodic tasks...", file=sys.stderr)
+
+        synced_count = 0
+
+        for schedule_name, schedule_config in beat_schedule.items():
+            try:
+                # Extract task name and schedule
+                task_name = schedule_config.get('task')
+                schedule = schedule_config.get('schedule')
+
+                if not task_name or not schedule:
+                    continue
+
+                # Normalize task name to monitor key
+                monitor_key = normalize_task_name(task_name)
+
+                if not monitor_key:
+                    continue
+
+                # Convert schedule to cron expression
+                cron_expression = schedule_to_cron(schedule)
+
+                if not cron_expression:
+                    print(f"[CronRadar.Celery] Skipping '{task_name}': Unable to convert schedule to cron", file=sys.stderr)
+                    continue
+
+                # Generate readable name
+                readable_name = generate_readable_name(task_name)
+
+                # Sync to CronRadar
+                cronradar.sync_monitor(
+                    monitor_key,
+                    cron_expression,
+                    source='celery',
+                    name=readable_name
+                )
+
+                synced_count += 1
+
+            except Exception as e:
+                print(f"[CronRadar.Celery] Failed to sync '{schedule_name}': {e}", file=sys.stderr)
+                continue
+
+        if synced_count > 0:
+            print(f"[CronRadar.Celery] ✓ Synced {synced_count} periodic tasks", file=sys.stderr)
+
+    except Exception as e:
+        print(f"[CronRadar.Celery] Discovery error: {e}", file=sys.stderr)
+        # Don't fail app startup on discovery errors

cronradar_celery/monitors.py

@@ -0,0 +1,105 @@
+"""
+Task monitoring via Celery signals.
+"""
+
+import sys
+from functools import wraps
+from typing import Any, Callable
+from celery import Celery
+from celery.signals import task_success
+
+import cronradar
+from .utils import normalize_task_name
+
+
+def skip_monitor_decorator(func: Callable) -> Callable:
+    """
+    Mark a Celery task to skip monitoring in MonitorAll mode.
+
+    Example:
+        from cronradar_celery import skip_monitor
+
+        @app.task
+        @skip_monitor
+        def internal_cleanup():
+            pass
+    """
+    func._cronradar_skip = True
+    return func
+
+
+def setup_task_monitoring(app: Celery) -> None:
+    """
+    Setup Celery signal handlers for task monitoring.
+    Monitors all tasks unless they have @skip_monitor decorator.
+
+    Args:
+        app: Celery application instance
+    """
+
+    @task_success.connect
+    def handle_task_success(sender=None, **kwargs):
+        """
+        Handle successful task execution.
+        Monitors all tasks unless marked with @skip_monitor.
+        """
+        try:
+            # Get task name from sender
+            if not sender or not hasattr(sender, 'name'):
+                return
+
+            task_name = sender.name
+
+            # Check if this task should be monitored
+            if not should_monitor_task(sender):
+                return
+
+            # Normalize task name to monitor key
+            monitor_key = normalize_task_name(task_name)
+
+            if not monitor_key:
+                return
+
+            # Use base SDK to monitor
+            # Don't pass schedule here - it's already synced via discovery
+            cronradar.monitor(monitor_key)
+
+        except Exception as e:
+            # Never break user's task execution
+            print(f"[CronRadar.Celery] Monitor error: {e}", file=sys.stderr)
+
+
+def should_monitor_task(task) -> bool:
+    """
+    Determine if a task should be monitored.
+    Monitors all tasks unless marked with @skip_monitor decorator.
+
+    Args:
+        task: Celery task instance
+
+    Returns:
+        True if task should be monitored
+    """
+    try:
+        # Get the actual task function
+        task_func = None
+
+        # Try to get the original function
+        if hasattr(task, 'run'):
+            task_func = task.run
+        elif hasattr(task, '__wrapped__'):
+            task_func = task.__wrapped__
+        elif callable(task):
+            task_func = task
+
+        if not task_func:
+            # If we can't determine, monitor by default
+            return True
+
+        # Monitor all tasks unless @skip_monitor decorator present
+        return not getattr(task_func, '_cronradar_skip', False)
+
+    except Exception as e:
+        print(f"[CronRadar.Celery] Error checking task decorators: {e}", file=sys.stderr)
+        # If we can't determine, monitor by default
+        return True

cronradar_celery/utils.py

@@ -0,0 +1,196 @@
+"""
+Utility functions for Celery integration.
+"""
+
+import sys
+import re
+from typing import Optional
+from datetime import timedelta
+
+
+def normalize_task_name(task_name: str) -> str:
+    """
+    Normalize Celery task name to CronRadar monitor key format.
+
+    Examples:
+        'myapp.tasks.send_email' -> 'myapp-tasks-send-email'
+        'tasks.process_queue' -> 'tasks-process-queue'
+    """
+    if not task_name:
+        return task_name
+
+    # Replace dots and underscores with hyphens
+    key = task_name.replace('.', '-').replace('_', '-')
+
+    # Lowercase
+    key = key.lower()
+
+    # Remove any non-alphanumeric except hyphens
+    key = re.sub(r'[^a-z0-9-]+', '-', key)
+
+    # Remove leading/trailing hyphens
+    key = key.strip('-')
+
+    # Limit length
+    if len(key) > 64:
+        key = key[:64]
+
+    return key
+
+
+def generate_readable_name(task_name: str) -> str:
+    """
+    Generate human-readable name from Celery task name.
+
+    Examples:
+        'myapp.tasks.send_email' -> 'Send Email'
+        'tasks.process_queue' -> 'Process Queue'
+    """
+    if not task_name:
+        return task_name
+
+    # Take last part after final dot (the actual task name)
+    parts = task_name.split('.')
+    name = parts[-1] if parts else task_name
+
+    # Convert snake_case to Title Case
+    if '_' in name:
+        return ' '.join(word.capitalize() for word in name.split('_'))
+
+    # Convert camelCase to Title Case
+    if name and name[0].islower() and any(c.isupper() for c in name):
+        result = re.sub(r'([A-Z])', r' \1', name)
+        return result.strip().title()
+
+    # Default: capitalize first letter
+    return name.capitalize()
+
+
+def crontab_to_cron(crontab_obj) -> Optional[str]:
+    """
+    Convert Celery crontab schedule to cron expression string.
+
+    Args:
+        crontab_obj: celery.schedules.crontab instance
+
+    Returns:
+        Cron expression string or None if conversion fails
+
+    Examples:
+        crontab(hour=0, minute=0) -> '0 0 * * *'
+        crontab(hour='*/6', minute=0) -> '0 */6 * * *'
+    """
+    try:
+        from celery.schedules import crontab
+
+        if not isinstance(crontab_obj, crontab):
+            return None
+
+        # Extract fields (minute, hour, day_of_month, month, day_of_week)
+        minute = _format_cron_field(crontab_obj.minute)
+        hour = _format_cron_field(crontab_obj.hour)
+        day_of_month = _format_cron_field(crontab_obj.day_of_month)
+        month = _format_cron_field(crontab_obj.month_of_year)
+        day_of_week = _format_cron_field(crontab_obj.day_of_week)
+
+        return f"{minute} {hour} {day_of_month} {month} {day_of_week}"
+    except Exception as e:
+        print(f"[CronRadar.Celery] Failed to convert crontab: {e}", file=sys.stderr)
+        return None
+
+
+def timedelta_to_cron(interval: timedelta) -> str:
+    """
+    Convert timedelta interval to approximate cron expression.
+
+    Args:
+        interval: timedelta representing the repeat interval
+
+    Returns:
+        Approximate cron expression
+
+    Examples:
+        timedelta(hours=1) -> '0 * * * *'
+        timedelta(days=1) -> '0 0 * * *'
+    """
+    total_seconds = interval.total_seconds()
+
+    # Convert to common intervals
+    if total_seconds < 60:
+        return "* * * * *"  # Every minute (can't represent sub-minute)
+    elif total_seconds == 60:
+        return "* * * * *"  # Every minute
+    elif total_seconds == 300:
+        return "*/5 * * * *"  # Every 5 minutes
+    elif total_seconds == 900:
+        return "*/15 * * * *"  # Every 15 minutes
+    elif total_seconds == 1800:
+        return "*/30 * * * *"  # Every 30 minutes
+    elif total_seconds == 3600:
+        return "0 * * * *"  # Every hour
+    elif total_seconds % 3600 == 0 and total_seconds < 86400:
+        hours = int(total_seconds / 3600)
+        return f"0 */{hours} * * *"  # Every N hours
+    elif total_seconds == 86400:
+        return "0 0 * * *"  # Daily
+    elif total_seconds == 604800:
+        return "0 0 * * 0"  # Weekly (Sunday)
+    else:
+        # Default to hourly for other intervals
+        return "0 * * * *"
+
+
+def _format_cron_field(field) -> str:
+    """
+    Format a Celery crontab field for cron expression.
+
+    Celery uses sets for multiple values and '*' for all.
+    """
+    if field is None or field == '*':
+        return '*'
+
+    # If it's a set, join with commas
+    if isinstance(field, set):
+        return ','.join(str(x) for x in sorted(field))
+
+    # If it's a string, return as-is (handles '*/N' patterns)
+    if isinstance(field, str):
+        return field
+
+    # Single value
+    return str(field)
+
+
+def schedule_to_cron(schedule) -> Optional[str]:
+    """
+    Convert any Celery schedule object to cron expression.
+
+    Args:
+        schedule: Celery schedule object (crontab, timedelta, solar, etc.)
+
+    Returns:
+        Cron expression string or None if conversion fails
+    """
+    try:
+        from celery.schedules import crontab, schedule as base_schedule
+
+        # Handle crontab directly
+        if isinstance(schedule, crontab):
+            return crontab_to_cron(schedule)
+
+        # Handle schedule objects with run_every (timedelta-based)
+        if isinstance(schedule, base_schedule) and hasattr(schedule, 'run_every'):
+            if isinstance(schedule.run_every, timedelta):
+                return timedelta_to_cron(schedule.run_every)
+
+        # Handle raw timedelta
+        if isinstance(schedule, timedelta):
+            return timedelta_to_cron(schedule)
+
+        # Unknown schedule type
+        print(f"[CronRadar.Celery] Unknown schedule type: {type(schedule)}", file=sys.stderr)
+        return None
+
+    except Exception as e:
+        print(f"[CronRadar.Celery] Failed to convert schedule: {e}", file=sys.stderr)
+        return None

cronradar_celery-0.0.2.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: cronradar-celery
+Version: 0.0.2
+Summary: Automatic monitoring for Celery periodic tasks. Monitor selective tasks or all tasks with auto-discovery.
+Home-page: https://github.com/cronradar/cronradar-celery
+Author: Administrator
+Author-email: contact@cronradar.com
+License: Proprietary
+Project-URL: Documentation, https://cronradar.com/docs
+Project-URL: Source, https://github.com/cronradar/cronradar-celery
+Project-URL: Tracker, https://github.com/cronradar/cronradar-celery/issues
+Keywords: celery monitoring cron task beat periodic auto-discovery cronradar
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cronradar>=0.0.1
+Requires-Dist: celery>=5.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CronRadar Celery Integration
+
+Monitor Celery periodic tasks. Auto-discover Beat schedules and track execution. Get alerts when tasks fail or don't run on schedule.
+
+## Installation
+
+```bash
+pip install cronradar-celery
+```
+
+## Configuration
+
+Set environment variable:
+```bash
+export CRONRADAR_API_KEY=ck_app_xxxxx_yyyyy
+```
+
+Get your API key from [cronradar.com/dashboard](https://cronradar.com/dashboard)
+
+Or pass it directly:
+
+```python
+setup_cronradar(app, api_key='ck_app_xxxxx_yyyyy')
+```
+
+## Quick Start
+
+Monitor all periodic tasks by default - use `@skip_monitor` to opt-out:
+
+```python
+from celery import Celery
+from cronradar_celery import setup_cronradar, skip_monitor
+
+app = Celery('myapp')
+setup_cronradar(app)
+
+@app.task
+def send_daily_report():
+    # Monitored automatically
+    generate_report()
+
+@app.task
+@skip_monitor
+def internal_cleanup():
+    # Opted out
+    pass
+```
+
+## Decorator Order (Important!)
+
+The `@skip_monitor` decorator **must** be placed **after** `@app.task`:
+
+```python
+# ✅ Correct
+@app.task
+@skip_monitor
+def my_task():
+    pass
+
+# ❌ Wrong - won't work
+@skip_monitor
+@app.task
+def my_task():
+    pass
+```
+
+## Requirements
+
+- Python 3.8+
+- Celery 5.0+
+- cronradar 1.0+
+
+## Links
+
+- 📚 [Documentation](https://cronradar.com/docs/sdks/celery)
+- 📦 [PyPI](https://pypi.org/project/cronradar-celery)
+- 🐛 [GitHub Issues](https://github.com/cronradar/cronradar-celery/issues)
+- ✉️ support@cronradar.com
+
+## License
+
+Proprietary - © 2025 CronRadar. All rights reserved.
+
+See [LICENSE](./LICENSE) for details. This integration may only be used with the CronRadar monitoring service.

cronradar_celery-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+cronradar_celery/__init__.py,sha256=n-XaIACZ_XD1V9L80rnMJsRhPEsR_QTPbcleT4lY-lM,1873
+cronradar_celery/discovery.py,sha256=wfUAKJYMpx9N11cF1oFuop6VMwiGITIqGwLDtgRSxv0,2582
+cronradar_celery/monitors.py,sha256=DOBINczz5WIjaN3kSq2-XsPAO1ys1uL8uxYRBBQeyCE,2923
+cronradar_celery/utils.py,sha256=ncXWHHGAt_RgOWZ3HWOgXVi4xGH_tRgPL9OVT4PPp3g,5920
+cronradar_celery-0.0.2.dist-info/licenses/LICENSE,sha256=jsvzCDX0wx-tjGeCiBXLFeEQ_lIhQmf4KPxGa0619SI,1484
+cronradar_celery-0.0.2.dist-info/METADATA,sha256=s_oe3kwU98Vdv3uZwSJ74d7QWujT__-4a1VyW4MsdTg,3375
+cronradar_celery-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cronradar_celery-0.0.2.dist-info/top_level.txt,sha256=XuNSMb2-Fmd47TD9MFPV64w18xaMyEajwvDD37YnD4Q,17
+cronradar_celery-0.0.2.dist-info/RECORD,,

cronradar_celery-0.0.2.dist-info/WHEEL

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

cronradar_celery-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,41 @@
+CronRadar SDK License
+
+Copyright (c) 2025 CronRadar. All rights reserved.
+
+## Permitted Use
+
+You may use this software solely in connection with the CronRadar monitoring
+service available at cronradar.com. You may view, study, and modify the source
+code for the purpose of fixing bugs or improving functionality.
+
+## Contributions
+
+If you modify this software to fix bugs or add improvements, you may submit
+those modifications back to CronRadar via pull request. By submitting, you
+grant CronRadar a perpetual, worldwide, non-exclusive, royalty-free license
+to use, modify, and distribute your contributions under any terms.
+
+## Restrictions
+
+You may NOT:
+- Use this software with any service other than CronRadar
+- Fork or use this software for your own projects or products
+- Redistribute this software (use official package managers only)
+- Create derivative works for purposes other than contributing back to CronRadar
+- Remove or modify any license, copyright, or attribution notices
+- Use this software to create a competing monitoring service
+
+## Termination
+
+Your license terminates immediately if you violate any restriction. Upon
+termination, you must stop using the software.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL CRONRADAR BE LIABLE FOR ANY DAMAGES ARISING FROM
+THE USE OF THIS SOFTWARE.
+
+## Questions
+
+For licensing questions: support@cronradar.com

cronradar_celery-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+cronradar_celery