rrq 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

rrq/worker.py

@@ -29,6 +29,7 @@ from .registry import JobRegistry
 from .settings import RRQSettings
 from .store import JobStore
 from .cron import CronJob
+from .telemetry import get_telemetry
 
 logger = logging.getLogger(__name__)
 
@@ -83,9 +84,9 @@ class RRQWorker:
         self._semaphore = asyncio.Semaphore(self.settings.worker_concurrency)
         self._running_tasks: set[asyncio.Task] = set()
         self._shutdown_event = asyncio.Event()
-        self._loop = None  # Will be set in run()
-        self._health_check_task: Optional[asyncio.Task] = None
-        self._cron_task: Optional[asyncio.Task] = None
+        self._loop: asyncio.AbstractEventLoop | None = None  # Will be set in run()
+        self._health_check_task: asyncio.Task | None = None
+        self._cron_task: asyncio.Task | None = None
         self.status: str = "initializing"  # Worker status (e.g., initializing, running, polling, idle, stopped)
         logger.info(
             f"Initializing RRQWorker {self.worker_id} for queues: {self.queues}"
@@ -145,8 +146,18 @@ class RRQWorker:
         self.status = "running"
         self._loop = asyncio.get_running_loop()
         self._setup_signal_handlers()
+        telemetry = get_telemetry()
         try:
             await self._call_startup_hook()
+            try:
+                telemetry.worker_started(
+                    worker_id=self.worker_id, queues=list(self.queues)
+                )
+            except Exception as e_telemetry:
+                logger.error(
+                    f"Worker {self.worker_id} error during telemetry startup: {e_telemetry}",
+                    exc_info=True,
+                )
             await self._run_loop()
         except asyncio.CancelledError:
             logger.info(f"Worker {self.worker_id} run cancelled.")
@@ -154,6 +165,20 @@ class RRQWorker:
             logger.info(f"Worker {self.worker_id} shutting down cleanly.")
             await self._call_shutdown_hook()
             self.status = "stopped"
+            try:
+                telemetry.worker_stopped(worker_id=self.worker_id)
+            except Exception as e_telemetry:
+                logger.error(
+                    f"Worker {self.worker_id} error during telemetry shutdown: {e_telemetry}",
+                    exc_info=True,
+                )
+            try:
+                await self.close()
+            except Exception as e_close:
+                logger.error(
+                    f"Worker {self.worker_id} error closing resources during shutdown: {e_close}",
+                    exc_info=True,
+                )
             logger.info(f"Worker {self.worker_id} stopped.")
 
     async def _run_loop(self) -> None:
@@ -162,11 +187,13 @@ class RRQWorker:
         Continuously polls queues for jobs, manages concurrency, and handles shutdown.
         """
         logger.info(f"Worker {self.worker_id} starting run loop.")
-        self._health_check_task = self._loop.create_task(self._heartbeat_loop())
+        loop = self._loop
+        assert loop is not None
+        self._health_check_task = loop.create_task(self._heartbeat_loop())
         if self.cron_jobs:
             for cj in self.cron_jobs:
                 cj.schedule_next()
-            self._cron_task = self._loop.create_task(self._cron_loop())
+            self._cron_task = loop.create_task(self._cron_loop())
 
         while not self._shutdown_event.is_set():
             try:
@@ -187,6 +214,17 @@ class RRQWorker:
                             f"Worker {self.worker_id} burst mode complete: no more jobs."
                         )
                         break
+                    if fetched_count == 0:
+                        if self.status != "idle (no jobs)":
+                            logger.debug(
+                                f"Worker {self.worker_id} no jobs found. Waiting..."
+                            )
+                            self.status = "idle (no jobs)"
+                        # Avoid tight polling loop when queues are empty
+                        jittered_delay = self._calculate_jittered_delay(
+                            self.settings.default_poll_delay_seconds
+                        )
+                        await asyncio.sleep(jittered_delay)
                 else:
                     if self.status != "idle (concurrency limit)":
                         logger.debug(
@@ -223,7 +261,7 @@ class RRQWorker:
             with suppress(asyncio.CancelledError):
                 await self._cron_task
 
-    async def _poll_for_jobs(self, count: int) -> None:
+    async def _poll_for_jobs(self, count: int) -> int:
         """Polls configured queues round-robin and attempts to start processing jobs.
 
         Args:
@@ -351,7 +389,9 @@ class RRQWorker:
 
             # Create and track the execution task
             # The semaphore will be released when this task completes
-            task = self._loop.create_task(self._execute_job(job, queue_name))
+            loop = self._loop
+            assert loop is not None
+            task = loop.create_task(self._execute_job(job, queue_name))
             self._running_tasks.add(task)
             task.add_done_callback(lambda t: self._task_cleanup(t, self._semaphore))
             logger.info(
@@ -423,93 +463,182 @@ class RRQWorker:
             if job.job_timeout_seconds is not None
             else self.settings.default_job_timeout_seconds
         )
+        attempt = job.current_retries + 1
+        telemetry = get_telemetry()
+
+        span_cm = telemetry.job_span(
+            job=job,
+            worker_id=self.worker_id,
+            queue_name=queue_name,
+            attempt=attempt,
+            timeout_seconds=float(actual_job_timeout),
+        )
 
         try:
-            # --- Find Handler ---
-            handler = self.job_registry.get_handler(job.function_name)
-            if not handler:
-                raise ValueError(
-                    f"No handler registered for function '{job.function_name}'"
-                )
-
-            # --- Prepare Context ---
-            context = {
-                "job_id": job.id,
-                "job_try": job.current_retries + 1,  # Attempt number (1-based)
-                "enqueue_time": job.enqueue_time,
-                "settings": self.settings,
-                "worker_id": self.worker_id,
-                "queue_name": queue_name,
-                "rrq_client": self.client,
-            }
-
-            # --- Execute Handler ---
-            result = None
-            exc: Optional[BaseException] = None  # Stores caught exception
-
-            try:  # Inner try for handler execution and its specific exceptions
-                logger.debug(f"Calling handler '{job.function_name}' for job {job.id}")
-                result = await asyncio.wait_for(
-                    handler(context, *job.job_args, **job.job_kwargs),
-                    timeout=float(actual_job_timeout),
-                )
-                logger.debug(f"Handler for job {job.id} returned successfully.")
-            except TimeoutError as e_timeout:  # Specifically from wait_for
-                exc = e_timeout
-                logger.warning(
-                    f"Job {job.id} execution timed out after {actual_job_timeout}s."
-                )
-            except RetryJob as e_retry:  # Handler explicitly requests retry
-                exc = e_retry
-                logger.info(f"Job {job.id} requested retry: {e_retry}")
-            except Exception as e_other:  # Any other exception from the handler itself
-                exc = e_other
-                logger.error(
-                    f"Job {job.id} handler '{job.function_name}' raised unhandled exception:",
-                    exc_info=e_other,
-                )
-
-            # --- Process Outcome ---
-            duration = time.monotonic() - start_time
-            if exc is None:  # Success
-                await self._handle_job_success(job, result)
-                logger.info(f"Job {job.id} completed successfully in {duration:.2f}s.")
-            elif isinstance(exc, RetryJob):
-                await self._process_retry_job(job, exc, queue_name)
-                # Logging done within _process_retry_job
-            elif isinstance(exc, asyncio.TimeoutError):
-                error_msg = (
-                    str(exc)
-                    if str(exc)
-                    else f"Job timed out after {actual_job_timeout}s."
-                )
-                await self._handle_job_timeout(job, queue_name, error_msg)
-                # Logging done within _handle_job_timeout
-            else:  # Other unhandled exception from handler
-                await self._process_other_failure(job, exc, queue_name)
-                # Logging done within _process_other_failure
-
-        except ValueError as ve:  # Catches "handler not found"
-            logger.error(f"Job {job.id} fatal error: {ve}. Moving to DLQ.")
-            await self._handle_fatal_job_error(job, queue_name, str(ve))
-        except asyncio.CancelledError:
-            # Catches cancellation of this _execute_job task (e.g., worker shutdown)
-            logger.warning(
-                f"Job {job.id} execution was cancelled (likely worker shutdown). Handling cancellation."
-            )
-            await self._handle_job_cancellation_on_shutdown(job, queue_name)
-            # Do not re-raise; cancellation is handled.
-        except (
-            Exception
-        ) as critical_exc:  # Safety net for unexpected errors in this method
-            logger.critical(
-                f"Job {job.id} encountered an unexpected critical error during execution logic: {critical_exc}",
-                exc_info=critical_exc,
-            )
-            # Fallback: Try to move to DLQ to avoid losing the job entirely
-            await self._handle_fatal_job_error(
-                job, queue_name, f"Critical worker error: {critical_exc}"
-            )
+            with span_cm as span:
+                try:
+                    # --- Find Handler ---
+                    handler = self.job_registry.get_handler(job.function_name)
+                    if not handler:
+                        raise ValueError(
+                            f"No handler registered for function '{job.function_name}'"
+                        )
+
+                    # --- Prepare Context ---
+                    context = {
+                        "job_id": job.id,
+                        "job_try": attempt,  # Attempt number (1-based)
+                        "enqueue_time": job.enqueue_time,
+                        "settings": self.settings,
+                        "worker_id": self.worker_id,
+                        "queue_name": queue_name,
+                        "rrq_client": self.client,
+                    }
+
+                    # --- Execute Handler ---
+                    result = None
+                    exc: Optional[BaseException] = None  # Stores caught exception
+
+                    try:  # Inner try for handler execution and its specific exceptions
+                        logger.debug(
+                            f"Calling handler '{job.function_name}' for job {job.id}"
+                        )
+                        result = await asyncio.wait_for(
+                            handler(context, *job.job_args, **job.job_kwargs),
+                            timeout=float(actual_job_timeout),
+                        )
+                        logger.debug(f"Handler for job {job.id} returned successfully.")
+                    except TimeoutError as e_timeout:  # Specifically from wait_for
+                        exc = e_timeout
+                        logger.warning(
+                            f"Job {job.id} execution timed out after {actual_job_timeout}s."
+                        )
+                    except RetryJob as e_retry:  # Handler explicitly requests retry
+                        exc = e_retry
+                        logger.info(f"Job {job.id} requested retry: {e_retry}")
+                    except (
+                        Exception
+                    ) as e_other:  # Any other exception from the handler itself
+                        exc = e_other
+                        logger.error(
+                            f"Job {job.id} handler '{job.function_name}' raised unhandled exception:",
+                            exc_info=e_other,
+                        )
+
+                    # --- Process Outcome ---
+                    duration = time.monotonic() - start_time
+                    if exc is None:  # Success
+                        await self._handle_job_success(job, result)
+                        span.success(duration_seconds=duration)
+                        logger.info(
+                            f"Job {job.id} completed successfully in {duration:.2f}s."
+                        )
+                    elif isinstance(exc, RetryJob):
+                        anticipated_retry_count = job.current_retries + 1
+                        delay_seconds = exc.defer_seconds
+                        if (
+                            delay_seconds is None
+                            and anticipated_retry_count < job.max_retries
+                        ):
+                            temp_job_for_backoff = Job(
+                                id=job.id,
+                                function_name=job.function_name,
+                                current_retries=anticipated_retry_count,
+                                max_retries=job.max_retries,
+                            )
+                            delay_seconds = (
+                                self._calculate_backoff_ms(temp_job_for_backoff)
+                                / 1000.0
+                            )
+                        await self._process_retry_job(job, exc, queue_name)
+                        if anticipated_retry_count >= job.max_retries:
+                            span.dlq(
+                                duration_seconds=duration,
+                                reason="max_retries",
+                                error=exc,
+                            )
+                        else:
+                            span.retry(
+                                duration_seconds=duration,
+                                delay_seconds=delay_seconds,
+                                reason=str(exc) or None,
+                            )
+                    elif isinstance(exc, asyncio.TimeoutError):
+                        error_msg = (
+                            str(exc)
+                            if str(exc)
+                            else f"Job timed out after {actual_job_timeout}s."
+                        )
+                        await self._handle_job_timeout(job, queue_name, error_msg)
+                        span.timeout(
+                            duration_seconds=duration,
+                            timeout_seconds=float(actual_job_timeout),
+                            error_message=error_msg,
+                        )
+                    else:  # Other unhandled exception from handler
+                        anticipated_retry_count = job.current_retries + 1
+                        delay_seconds = None
+                        if anticipated_retry_count < job.max_retries:
+                            delay_seconds = (
+                                self._calculate_backoff_ms(
+                                    Job(
+                                        id=job.id,
+                                        function_name=job.function_name,
+                                        current_retries=anticipated_retry_count,
+                                        max_retries=job.max_retries,
+                                    )
+                                )
+                                / 1000.0
+                            )
+                        await self._process_other_failure(job, exc, queue_name)
+                        if anticipated_retry_count >= job.max_retries:
+                            span.dlq(
+                                duration_seconds=duration,
+                                reason="max_retries",
+                                error=exc,
+                            )
+                        else:
+                            span.retry(
+                                duration_seconds=duration,
+                                delay_seconds=delay_seconds,
+                                reason=str(exc) or None,
+                            )
+
+                except ValueError as ve:  # Catches "handler not found"
+                    logger.error(f"Job {job.id} fatal error: {ve}. Moving to DLQ.")
+                    await self._handle_fatal_job_error(job, queue_name, str(ve))
+                    span.dlq(
+                        duration_seconds=time.monotonic() - start_time,
+                        reason=str(ve),
+                        error=ve,
+                    )
+                except asyncio.CancelledError:
+                    # Catches cancellation of this _execute_job task (e.g., worker shutdown)
+                    logger.warning(
+                        f"Job {job.id} execution was cancelled (likely worker shutdown). Handling cancellation."
+                    )
+                    await self._handle_job_cancellation_on_shutdown(job, queue_name)
+                    span.cancelled(
+                        duration_seconds=time.monotonic() - start_time,
+                        reason="shutdown",
+                    )
+                    # Do not re-raise; cancellation is handled.
+                except (
+                    Exception
+                ) as critical_exc:  # Safety net for unexpected errors in this method
+                    logger.critical(
+                        f"Job {job.id} encountered an unexpected critical error during execution logic: {critical_exc}",
+                        exc_info=critical_exc,
+                    )
+                    # Fallback: Try to move to DLQ to avoid losing the job entirely
+                    await self._handle_fatal_job_error(
+                        job, queue_name, f"Critical worker error: {critical_exc}"
+                    )
+                    span.dlq(
+                        duration_seconds=time.monotonic() - start_time,
+                        reason="critical_worker_error",
+                        error=critical_exc,
+                    )
         finally:
             # CRITICAL: Ensure the lock is released regardless of outcome
             await self.job_store.release_job_lock(job.id)
@@ -592,6 +721,15 @@ class RRQWorker:
             new_retry_count = await self.job_store.atomic_retry_job(
                 job.id, target_queue, retry_at_score, str(exc), JobStatus.RETRYING
             )
+            try:
+                next_run_time = datetime.fromtimestamp(
+                    float(retry_at_score) / 1000.0, tz=timezone.utc
+                )
+                await self.job_store.update_job_next_scheduled_run_time(
+                    job.id, next_run_time
+                )
+            except Exception:
+                pass
 
             logger.info(
                 f"{log_prefix} explicitly retrying in {defer_seconds:.2f}s "
@@ -646,6 +784,15 @@ class RRQWorker:
             new_retry_count = await self.job_store.atomic_retry_job(
                 job.id, target_queue, retry_at_score, last_error_str, JobStatus.RETRYING
             )
+            try:
+                next_run_time = datetime.fromtimestamp(
+                    float(retry_at_score) / 1000.0, tz=timezone.utc
+                )
+                await self.job_store.update_job_next_scheduled_run_time(
+                    job.id, next_run_time
+                )
+            except Exception:
+                pass
 
             logger.info(
                 f"{log_prefix} failed, retrying in {defer_ms / 1000.0:.2f}s "
@@ -732,9 +879,12 @@ class RRQWorker:
 
     def _setup_signal_handlers(self) -> None:
         """Sets up POSIX signal handlers for graceful shutdown."""
+        loop = self._loop
+        if loop is None:
+            return
         for sig in self.SIGNALS:
             try:
-                self._loop.add_signal_handler(sig, self._request_shutdown)
+                loop.add_signal_handler(sig, self._request_shutdown)
                 logger.debug(
                     f"Worker {self.worker_id} registered signal handler for {sig.name}."
                 )
@@ -805,6 +955,7 @@ class RRQWorker:
     async def _heartbeat_loop(self) -> None:
         """Periodically updates the worker's health status key in Redis with a TTL."""
         logger.debug(f"Worker {self.worker_id} starting heartbeat loop.")
+        telemetry = get_telemetry()
         while not self._shutdown_event.is_set():
             try:
                 health_data = {
@@ -821,6 +972,9 @@ class RRQWorker:
                 await self.job_store.set_worker_health(
                     self.worker_id, health_data, int(ttl)
                 )
+                telemetry.worker_heartbeat(
+                    worker_id=self.worker_id, health_data=health_data
+                )
                 # Logger call moved into set_worker_health
             except Exception as e:
                 # Log error but continue the loop
@@ -860,6 +1014,15 @@ class RRQWorker:
             if cj.due(now):
                 unique_key = f"cron:{cj.function_name}" if cj.unique else None
                 try:
+                    if unique_key:
+                        # For unique cron jobs, skip enqueueing while the unique lock is held
+                        # to avoid accumulating deferred duplicates on every cron tick.
+                        ttl = await self.job_store.get_lock_ttl(unique_key)
+                        if ttl > 0:
+                            logger.debug(
+                                f"Skipping cron job '{cj.function_name}' due to active unique lock (TTL: {ttl}s)."
+                            )
+                            continue
                     await self.client.enqueue(
                         cj.function_name,
                         *cj.args,
@@ -974,7 +1137,9 @@ class RRQWorker:
         )
         try:
             job.status = JobStatus.PENDING
-            job.next_scheduled_run_time = datetime.now(timezone.utc)  # Re-queue immediately
+            job.next_scheduled_run_time = datetime.now(
+                timezone.utc
+            )  # Re-queue immediately
             job.last_error = "Job execution interrupted by worker shutdown. Re-queued."
             # Do not increment retries for shutdown interruption
 

{rrq-0.7.0.dist-info → rrq-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rrq
-Version: 0.7.0
+Version: 0.8.0
 Summary: RRQ is a Python library for creating reliable job queues using Redis and asyncio
 Project-URL: Homepage, https://github.com/getresq/rrq
 Project-URL: Bug Tracker, https://github.com/getresq/rrq/issues
@@ -8,40 +8,42 @@ Author-email: Mazdak Rezvani <mazdak@me.com>
 License-File: LICENSE
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Classifier: Topic :: System :: Monitoring
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: click>=8.1.3
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pydantic>=2.11.4
-Requires-Dist: redis[hiredis]<6,>=4.2.0
+Requires-Dist: redis[hiredis]>=4.2.0
 Requires-Dist: rich>=14.0.0
 Requires-Dist: watchfiles>=0.19.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Requires-Dist: ruff==0.14.9; extra == 'dev'
+Requires-Dist: ty==0.0.1-alpha.26; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # RRQ: Reliable Redis Queue
 
 RRQ is a Python library for creating reliable job queues using Redis and `asyncio`, inspired by [ARQ (Async Redis Queue)](https://github.com/samuelcolvin/arq). It focuses on providing at-least-once job processing semantics with features like automatic retries, job timeouts, dead-letter queues, and graceful worker shutdown.
 
-## 🆕 What's New in v0.7.0
+## 🆕 What's New in v0.7.1
 
 - **Comprehensive CLI Tools**: 15+ new commands for monitoring, debugging, and management
 - **Real-time Monitoring Dashboard**: Interactive dashboard with `rrq monitor`
 - **Enhanced DLQ Management**: Sophisticated filtering and requeuing capabilities
-- **Python 3.10 Support**: Expanded compatibility from Python 3.11+ to 3.10+
 - **Bug Fixes**: Critical fix for unique job enqueue failures with proper deferral
 
 ## Requirements
 
-- Python 3.10 or higher
+- Python 3.11 or higher
 - Redis 5.0 or higher
 - asyncio-compatible environment
 
@@ -143,6 +145,8 @@ this purpose.
 
 ```python
 # worker_script.py
+import asyncio
+
 from rrq.worker import RRQWorker
 from config import rrq_settings # Import your settings
 from main_setup import job_registry # Import your registry
@@ -152,7 +156,7 @@ worker = RRQWorker(settings=rrq_settings, job_registry=job_registry)
 
 # Run the worker (blocking)
 if __name__ == "__main__":
-    worker.run()
+    asyncio.run(worker.run())
 ```
 
 You can run multiple instances of `worker_script.py` for concurrent processing.
@@ -432,6 +436,41 @@ RRQ can be configured in several ways, with the following precedence:
 
 **Important Note on `job_registry`**: The `job_registry` attribute in your `RRQSettings` object is **critical** for RRQ to function. It must be an instance of `JobRegistry` and is used to register job handlers. Without a properly configured `job_registry`, workers will not know how to process jobs, and most operations will fail. Ensure it is set in your settings object to map job names to their respective handler functions.
 
+## Telemetry (Datadog / OTEL / Logfire)
+
+RRQ supports optional distributed tracing for enqueue and job execution. Enable the
+integration in both the producer and worker processes to get end-to-end traces
+across the Redis queue.
+
+### Datadog (ddtrace)
+
+```python
+from rrq.integrations.ddtrace import enable as enable_rrq_ddtrace
+
+enable_rrq_ddtrace(service="myapp-rrq")
+```
+
+This only instruments RRQ spans + propagation; it does **not** call
+`ddtrace.patch_all()`. Configure `ddtrace` in your app as you already do.
+
+### Logfire
+
+```python
+import logfire
+from rrq.integrations.logfire import enable as enable_rrq_logfire
+
+logfire.configure(service_name="myapp-rrq")
+enable_rrq_logfire(service_name="myapp-rrq")
+```
+
+### OpenTelemetry (generic)
+
+```python
+from rrq.integrations.otel import enable as enable_rrq_otel
+
+enable_rrq_otel(service_name="myapp-rrq")
+```
+
 ### Comprehensive CLI Command System
 - **New modular CLI architecture** with dedicated command modules for better organization
 - **Enhanced monitoring capabilities** with real-time dashboards and beautiful table output

rrq-0.8.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+rrq/__init__.py,sha256=3WYv9UkvnCbjKXrvmqiLm7yuVVQiLclbVCOXq5wb6ZM,290
+rrq/cli.py,sha256=paUyLTN75KtC4nSVumiCE3taMhcMF27Jv0TSkaOwb5k,27092
+rrq/client.py,sha256=HGegw6H_oF6EBHPYeC8CKJXYbnliYHlibbh7CI3JBik,9057
+rrq/constants.py,sha256=vWSQcNX1v0_p0f8S4skZTnUgwOK4QSNVx-CK6VmxQog,2019
+rrq/cron.py,sha256=DQv9O1OS9qsuGY_AsEPZoXeInykordA_9TIhP0dYAhw,7710
+rrq/exc.py,sha256=NJq3C7pUfcd47AB8kghIN8vdY0l90UrsHQEg4McBHP8,1281
+rrq/hooks.py,sha256=kLrYrdCXYVh0tQl-6UKmT2IYVHgPB-_Zm0FbKba_HpE,8455
+rrq/job.py,sha256=z3q8hChF9CvX_bJUCO5Qh_eVWiXs6gMO2VMdHP9HVN8,4320
+rrq/registry.py,sha256=NQNC2gAVlKxmcU2P-oyqPsF_xsyaXsqLkdhLrSGKxSw,2844
+rrq/settings.py,sha256=NHbom3cG5jW70A2ApshBJBdf4D5ErCtGkv7OSCquSwE,5033
+rrq/store.py,sha256=UfMcYudHMtHsP9IoKLuyPb3sWVRUfieaSD8buKthl2o,37783
+rrq/telemetry.py,sha256=Jh3gd-QvE0ineHBd_WUM86IZxsjKykD8KH4FUUOMFww,3090
+rrq/worker.py,sha256=Isuk2EX8TmBoO7kpTsKrhgQomO3pNu14wb51l45vyfQ,52846
+rrq/cli_commands/__init__.py,sha256=1YO4QL-R5F3eBRp2LZVQpqFQCBBdlsCdEcrPVzUo-TA,21
+rrq/cli_commands/base.py,sha256=0UY5ilCHPIFuREHyiJpSpqt_rv5QWfWdZsYneR_B1oc,3087
+rrq/cli_commands/utils.py,sha256=6gxefcOPOLSefPCXcpYcrIh8R5iHu-DR2WTix-QmQNA,4352
+rrq/cli_commands/commands/__init__.py,sha256=e5ahM66Lb_nj7L4sjLrWr67vF-dwA9bxbCxsu8MrTy0,30
+rrq/cli_commands/commands/debug.py,sha256=U5t6gXIlur-QO4c-ik12DCA-amyqQdhIuWNexlYXiwQ,18460
+rrq/cli_commands/commands/dlq.py,sha256=Swk-2CuqoXsCuuhQsmQNPXtJLMe_kVwIZGI6iyTwy7w,30751
+rrq/cli_commands/commands/jobs.py,sha256=aPabfegOGklXKExz8fCs0-xugQEvhsRJVFdvLpY5gDY,18128
+rrq/cli_commands/commands/monitor.py,sha256=jAAxmd5cwh2XWu8beHiT17LxKA3PXw9CLEIZilZiZ54,29978
+rrq/cli_commands/commands/queues.py,sha256=C-qPFNclHxptZkJe2vzqjAg2bgLp98U5vFw4YBC5Enc,19653
+rrq/exporters/__init__.py,sha256=Tv3M3NXivbyr1GqRsQitHwGwxyj13NrERqBtgTvtsZY,48
+rrq/exporters/prometheus.py,sha256=xfaU7yezF8CJ4kHnGNIRb7fxF54h4BwBG8M2qNciFfU,3078
+rrq/exporters/statsd.py,sha256=zVjX3Beni1iQyX4Y9T5Oqaz8hRC9OE-dcizQUZGQsMA,1876
+rrq/integrations/__init__.py,sha256=UMTqvpUUW5OA3j7r0-Ydn-_xq1XGwJVHGjeuWNc-0FI,62
+rrq/integrations/ddtrace.py,sha256=_lSCJvblMCD9KlMB0-8voiQi4RfP1MmAJqlg0_gUo50,13892
+rrq/integrations/logfire.py,sha256=ZyIAMYdOQThGOeIpPR6aUhe2yfMFSi7jutnuM0yDTqo,756
+rrq/integrations/otel.py,sha256=biJj7NRRBmNmlCOu1cT_ZC3ZWLebhol9JSNyckVqlPQ,10048
+rrq-0.8.0.dist-info/METADATA,sha256=rGL8CIC1IytUfugyU-g-kFLYV2UJCtpvZMkbGntMAig,20804
+rrq-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rrq-0.8.0.dist-info/entry_points.txt,sha256=f8eFjk2ygDSyu9USwXGj5IM8xeyQqZgDa1rSrCj4Mis,36
+rrq-0.8.0.dist-info/licenses/LICENSE,sha256=XDvu5hKdS2-_ByiSj3tiu_3zSsrXXoJsgbILGoMpKCw,554
+rrq-0.8.0.dist-info/RECORD,,

{rrq-0.7.0.dist-info → rrq-0.8.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

rrq-0.7.0.dist-info/RECORD

@@ -1,26 +0,0 @@
-rrq/__init__.py,sha256=3WYv9UkvnCbjKXrvmqiLm7yuVVQiLclbVCOXq5wb6ZM,290
-rrq/cli.py,sha256=8ykQqM6VOzqHh2eK3ibtvtgk0gTr83vfyE8SHDpz4PI,27046
-rrq/client.py,sha256=PTuWZ23KQhNR4eHL0TuZaBsc_QLcuLVnbLx5apBdR2E,8245
-rrq/constants.py,sha256=vWSQcNX1v0_p0f8S4skZTnUgwOK4QSNVx-CK6VmxQog,2019
-rrq/cron.py,sha256=DQv9O1OS9qsuGY_AsEPZoXeInykordA_9TIhP0dYAhw,7710
-rrq/exc.py,sha256=NJq3C7pUfcd47AB8kghIN8vdY0l90UrsHQEg4McBHP8,1281
-rrq/hooks.py,sha256=rJpD7ARUbtwhht-had1WTgguJgI8TYVTWqRJpRDii8E,7478
-rrq/job.py,sha256=YCdrYMrAF2DjckD4LoZfqg_Ow5HySBH9IYLK4bYnctQ,4052
-rrq/registry.py,sha256=NQNC2gAVlKxmcU2P-oyqPsF_xsyaXsqLkdhLrSGKxSw,2844
-rrq/settings.py,sha256=RzuPV5nNzP6gpRut15_xWUagCLTXDCu7e_YAprLPFLE,5030
-rrq/store.py,sha256=VdSObK6zkNtL3Ems1p_U-xd4Ir4zHqFvo9nqNw2NpQ8,36022
-rrq/worker.py,sha256=w_1fOIMPSDkvXXYEmPPiC-uNz3PX3XOVjKCJK_Dpt3Y,44990
-rrq/cli_commands/__init__.py,sha256=1YO4QL-R5F3eBRp2LZVQpqFQCBBdlsCdEcrPVzUo-TA,21
-rrq/cli_commands/base.py,sha256=A00NM2qAHemy5geqU8udaxhMurkZLyGShHeuXNJ0nWM,2990
-rrq/cli_commands/utils.py,sha256=rZDmMi_HlBXf7BxMZbmrsOY9hur3ox9sbWrmHabuZy8,4299
-rrq/cli_commands/commands/__init__.py,sha256=e5ahM66Lb_nj7L4sjLrWr67vF-dwA9bxbCxsu8MrTy0,30
-rrq/cli_commands/commands/debug.py,sha256=pt_1mP-VuXkoWpmMF60lsrR0hKr9XP5PymxkskUOSWk,18462
-rrq/cli_commands/commands/dlq.py,sha256=Swk-2CuqoXsCuuhQsmQNPXtJLMe_kVwIZGI6iyTwy7w,30751
-rrq/cli_commands/commands/jobs.py,sha256=aPabfegOGklXKExz8fCs0-xugQEvhsRJVFdvLpY5gDY,18128
-rrq/cli_commands/commands/monitor.py,sha256=hdXv6ZTNG5MWUydtrQxDbH4gTBB6VLriTHpsP1cWfqA,28809
-rrq/cli_commands/commands/queues.py,sha256=5UrsweVwwtMlG9TXG0zlgXTUhGPIb3x_zvQIV7m_-ig,19648
-rrq-0.7.0.dist-info/METADATA,sha256=T3BvtahQ28B6i33XxDSwy_RYOffrv3enRXiegbRq8XI,19847
-rrq-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rrq-0.7.0.dist-info/entry_points.txt,sha256=f8eFjk2ygDSyu9USwXGj5IM8xeyQqZgDa1rSrCj4Mis,36
-rrq-0.7.0.dist-info/licenses/LICENSE,sha256=XDvu5hKdS2-_ByiSj3tiu_3zSsrXXoJsgbILGoMpKCw,554
-rrq-0.7.0.dist-info/RECORD,,