refactor(telemetry): migrate EnrichmentService to AsyncService base

- Extend AsyncService for standardized async/sync orchestration
- Replace custom worker checking with inherited implementation
- Simplify enqueue_enrichment using execute_with_fallback
- Use batch_execute for efficient multi-trace processing

Author: EmanueleDeRossi1

apps/backend/src/rhesis/backend/app/services/telemetry/enrichment/service.py

@@ -4,10 +4,11 @@
 """
 
 import logging
-from typing import TYPE_CHECKING, List, Set
+from typing import TYPE_CHECKING, Any, List, Set
 
 from sqlalchemy.orm import Session
 
+from rhesis.backend.app.services.async_service import AsyncService
 from rhesis.backend.app.services.telemetry.enrichment.processor import TraceEnricher
 
 if TYPE_CHECKING:
@@ -17,43 +18,51 @@
 logger = logging.getLogger(__name__)
 
 
-class EnrichmentService:
+class EnrichmentService(AsyncService[dict]):
     """Service for orchestrating trace enrichment with async/sync fallback."""
 
     def __init__(self, db: Session):
         """Initialize the enrichment service."""
+        super().__init__()
         self.db = db
 
-    def _check_workers_available(self) -> bool:
+    def _execute_sync(self, trace_id: str, project_id: str, organization_id: str) -> dict | None:
         """
-        Check if Celery workers are available to process telemetry tasks.
+        Synchronous enrichment (development fallback).
+
+        Args:
+            trace_id: Trace ID to enrich
+            project_id: Project ID for access control
+            organization_id: Organization ID for multi-tenant security
 
         Returns:
-            True if workers are available, False otherwise
+            Enriched trace data or None if enrichment failed
         """
-        try:
-            from rhesis.backend.worker import app as celery_app
-
-            # Use ping with 3 second timeout - more reliable for solo pool workers
-            # Solo pool workers process tasks sequentially, so stats() may timeout
-            # while ping() is faster and gets prioritized
-            inspect = celery_app.control.inspect(timeout=3.0)
+        enricher = TraceEnricher(self.db)
+        enriched_data = enricher.enrich_trace(trace_id, project_id, organization_id)
+        if enriched_data:
+            logger.info(f"Completed sync enrichment for trace {trace_id}")
+        else:
+            logger.warning(f"Sync enrichment returned no data for trace {trace_id}")
+        return enriched_data
 
-            # Ping is faster and works better with solo pool
-            ping_result = inspect.ping()
+    def _enqueue_async(self, trace_id: str, project_id: str, organization_id: str) -> Any:
+        """
+        Enqueue async enrichment task.
 
-            if not ping_result:
-                return False
+        Args:
+            trace_id: Trace ID to enrich
+            project_id: Project ID for access control
+            organization_id: Organization ID for multi-tenant security
 
-            # If we can ping workers, they're available
-            logger.debug(
-                f"Found {len(ping_result)} available worker(s): {list(ping_result.keys())}"
-            )
-            return True
+        Returns:
+            Celery AsyncResult
+        """
+        from rhesis.backend.tasks.telemetry.enrich import enrich_trace_async
 
-        except Exception as e:
-            logger.debug(f"Worker availability check failed: {e}")
-            return False
+        result = enrich_trace_async.delay(trace_id, project_id, organization_id)
+        logger.debug(f"Enqueued async enrichment for trace {trace_id} (task: {result.id})")
+        return result
 
     def enqueue_enrichment(
         self,
@@ -80,40 +89,14 @@ def enqueue_enrichment(
         Returns:
             True if async task was enqueued, False if sync fallback was used
         """
-        # Check if workers are available (use cached result if provided)
-        if workers_available is None:
-            workers_available = self._check_workers_available()
-
-        if workers_available:
-            try:
-                from rhesis.backend.tasks.telemetry.enrich import enrich_trace_async
-
-                # Try to enqueue async task
-                result = enrich_trace_async.delay(trace_id, project_id, organization_id)
-                logger.debug(f"Enqueued async enrichment for trace {trace_id} (task: {result.id})")
-                return True
-
-            except Exception as e:
-                logger.warning(
-                    f"Async enrichment failed for trace {trace_id}, using sync fallback: {e}"
-                )
-        else:
-            logger.info(f"No Celery workers available, using sync enrichment for trace {trace_id}")
-
-        # Fall back to synchronous enrichment
         try:
-            enricher = TraceEnricher(self.db)
-            enriched_data = enricher.enrich_trace(trace_id, project_id, organization_id)
-            if enriched_data:
-                logger.info(f"Completed sync enrichment for trace {trace_id}")
-            else:
-                logger.warning(f"Sync enrichment returned no data for trace {trace_id}")
-            return False
-        except Exception as sync_error:
-            # Log but don't fail the ingestion
-            logger.error(
-                f"Sync enrichment failed for trace {trace_id}: {sync_error}", exc_info=True
+            was_async, _ = self.execute_with_fallback(
+                trace_id, project_id, organization_id, workers_available=workers_available
             )
+            return was_async
+        except Exception as e:
+            # Log but don't fail the ingestion
+            logger.error(f"Enrichment failed for trace {trace_id}: {e}", exc_info=True)
             return False
 
     def enrich_traces(
@@ -130,20 +113,8 @@ def enrich_traces(
         Returns:
             Tuple of (async_count, sync_count)
         """
-        async_count = 0
-        sync_count = 0
-
-        # Check worker availability once before the loop to avoid N×3 second timeout
-        # when workers are unavailable (prevents batch processing delays)
-        workers_available = self._check_workers_available()
-
-        for trace_id in trace_ids:
-            if self.enqueue_enrichment(trace_id, project_id, organization_id, workers_available):
-                async_count += 1
-            else:
-                sync_count += 1
-
-        return async_count, sync_count
+        items = [((trace_id, project_id, organization_id), {}) for trace_id in trace_ids]
+        return self.batch_execute(items)
 
     def create_and_enrich_spans(
         self,