matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__py3-none-any.whl

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -18,6 +18,8 @@ from ..utils import (
     BBoxSmoothingConfig,
     BBoxSmoothingTracker
 )
+# Import alert system utilities
+from ..utils.alert_instance_utils import ALERT_INSTANCE
 # External dependencies
 import cv2
 import numpy as np
@@ -31,11 +33,15 @@ import asyncio
 import urllib
 import urllib.request
 import base64
+from pathlib import Path
 # Get the major and minor version numbers
 major_version = sys.version_info.major
 minor_version = sys.version_info.minor
 print(f"Python version: {major_version}.{minor_version}")
 os.environ["ORT_LOG_SEVERITY_LEVEL"] = "3"
+import base64
+from matrice_common.stream.matrice_stream import MatriceStream, StreamType
+from  matrice_common.session import Session
 
 
 # Lazy import mechanism for LicensePlateRecognizer
@@ -129,7 +135,6 @@ from ..ocr.preprocessing import ImagePreprocessor
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
 try:
-    from  matrice_common.session import Session
     HAS_MATRICE_SESSION = True
 except ImportError:
     HAS_MATRICE_SESSION = False
@@ -156,6 +161,7 @@ class LicensePlateMonitorConfig(BaseConfig):
     ocr_mode:str = field(default_factory=lambda: "numeric") # "alphanumeric" or "numeric" or "alphabetic"
     session: Optional[Session] = None
     lpr_server_id: Optional[str] = None  # Optional LPR server ID for remote logging
+    redis_server_id: Optional[str] = None  # Optional Redis server ID for instant alerts
     plate_log_cooldown: float = 30.0  # Cooldown period in seconds for logging same plate
     
     def validate(self) -> List[str]:
@@ -237,6 +243,7 @@ class LicensePlateMonitorLogger:
         # Fetch server connection info if lpr_server_id is provided
         if config.lpr_server_id:
             self.lpr_server_id = config.lpr_server_id
+            self.logger.info(f"[LP_LOGGING] CONFIG PRINTTEST: {config}")
             self.logger.info(f"[LP_LOGGING] Fetching LPR server connection info for server ID: {self.lpr_server_id}")
             try:
                 self.server_info = self.get_server_connection_info()
@@ -265,6 +272,7 @@ class LicensePlateMonitorLogger:
                     self.logger.error("[LP_LOGGING]  Failed to fetch LPR server connection info - server_info is None")
                     self.logger.error("[LP_LOGGING] This will prevent plate logging from working!")
             except Exception as e:
+                #pass
                 self.logger.error(f"[LP_LOGGING]  Error fetching LPR server connection info: {e}", exc_info=True)
                 self.logger.error("[LP_LOGGING] This will prevent plate logging from working!")
         else:
@@ -284,6 +292,17 @@ class LicensePlateMonitorLogger:
             self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
             return "localhost"
 
+    def _get_backend_base_url(self) -> str:
+        """Resolve backend base URL based on ENV variable: prod/staging/dev."""
+        env = os.getenv("ENV", "prod").strip().lower()
+        if env in ("prod", "production"):
+            host = "prod.backend.app.matrice.ai"
+        elif env in ("dev", "development"):
+            host = "dev.backend.app.matrice.ai"
+        else:
+            host = "staging.backend.app.matrice.ai"
+        return f"https://{host}"
+
     def get_server_connection_info(self) -> Optional[Dict[str, Any]]:
         """Fetch server connection info from RPC."""
         if not self.lpr_server_id:
@@ -406,16 +425,21 @@ class LicensePlateMonitorLogger:
             self.logger.info(f"[LP_LOGGING] ===== PLATE LOG REQUEST END (SKIPPED) =====")
             return False
         
+        if not stream_info:
+            self.logger.info(f"[LP_LOGGING] Stream info is None, skipping plate log")
+            stream_info = {}
+        
         try:
             camera_info = stream_info.get("camera_info", {})
-            camera_name = camera_info.get("camera_name", "")
-            location = camera_info.get("location", "")
+            camera_name = camera_info.get("camera_name", "default_camera")
+            location = camera_info.get("location", "default_location")
             frame_id = stream_info.get("frame_id", "")
             
             print(f"[LP_LOGGING] Camera: '{camera_name}', Location: '{location}'")
             self.logger.info(f"[LP_LOGGING] Stream Info - Camera: '{camera_name}', Location: '{location}', Frame ID: '{frame_id}'")
             
             # Get project ID from server_info
+            self.logger.info(f"[LP_LOGGING] SERVER-INFO: '{self.server_info}'")
             project_id = self.server_info.get('projectID', '') if self.server_info else ''
             self.logger.info(f"[LP_LOGGING] Project ID: '{project_id}'")
             
@@ -438,7 +462,7 @@ class LicensePlateMonitorLogger:
             full_url = f"{self.server_base_url}{endpoint}"
             print(f"[LP_LOGGING] Sending POST to: {full_url}")
             self.logger.info(f"[LP_LOGGING] Sending POST request to: {full_url}")
-            self.logger.info(f"[LP_LOGGING] Payload: licensePlate='{plate_text}', frameId='{frame_id}', location='{location}', camera='{camera_name}', imageData length={len(image_data) if image_data else 0}")
+            self.logger.info(f"[LP_LOGGING] Payload: licensePlate='{plate_text}', frameId='{frame_id}', location='{location}', camera='{camera_name}'")
             
             response = await self.session.rpc.post_async(endpoint, payload=payload, base_url=self.server_base_url)
             
@@ -509,9 +533,397 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         
         # Initialize plate logger (optional, only used if lpr_server_id is provided)
         self.plate_logger: Optional[LicensePlateMonitorLogger] = None
-        self._logging_enabled = True
+        self._logging_enabled = True # False  //ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION. ##
         self._plate_logger_initialized = False  # Track if plate logger has been initialized
+
+        # Initialize instant alert manager (will be lazily initialized on first process() call)
+        self.alert_manager: Optional[ALERT_INSTANCE] = None
+        self._alert_manager_initialized = False  # Track initialization to do it only once
+
+    def set_alert_manager(self, alert_manager: ALERT_INSTANCE) -> None:
+        """
+        Set the alert manager instance for instant alerts.
+
+        Args:
+            alert_manager: ALERT_INSTANCE instance configured with Redis/Kafka clients
+        """
+        self.alert_manager = alert_manager
+        self.logger.info("Alert manager set for license plate monitoring")
+
+    def _discover_action_id(self) -> Optional[str]:
+        """Discover action_id from current working directory name (and parents), similar to face_recognition flow."""
+        try:
+            import re as _re
+            pattern = _re.compile(r"^[0-9a-f]{8,}$", _re.IGNORECASE)
+            candidates: List[str] = []
+            try:
+                cwd = Path.cwd()
+                candidates.append(cwd.name)
+                for parent in cwd.parents:
+                    candidates.append(parent.name)
+            except Exception:
+                pass
+
+            try:
+                usr_src = Path("/usr/src")
+                if usr_src.exists():
+                    for child in usr_src.iterdir():
+                        if child.is_dir():
+                            candidates.append(child.name)
+            except Exception:
+                pass
+
+            for candidate in candidates:
+                if candidate and len(candidate) >= 8 and pattern.match(candidate):
+                    return candidate
+        except Exception:
+            pass
+        return None
+    
+    def _get_backend_base_url(self) -> str:
+        """Resolve backend base URL based on ENV variable: prod/staging/dev."""
+        env = os.getenv("ENV", "prod").strip().lower()
+        if env in ("prod", "production"):
+            host = "prod.backend.app.matrice.ai"
+        elif env in ("dev", "development"):
+            host = "dev.backend.app.matrice.ai"
+        else:
+            host = "staging.backend.app.matrice.ai"
+        return f"https://{host}"
+
+    def _mask_value(self, value: Optional[str]) -> str:
+        """Mask sensitive values for logging/printing."""
+        if not value:
+            return ""
+        if len(value) <= 4:
+            return "*" * len(value)
+        return value[:2] + "*" * (len(value) - 4) + value[-2:]
+
+    def _get_public_ip(self) -> str:
+        """Get the public IP address of this machine."""
+        self.logger.info("Fetching public IP address...")
+        try:
+            public_ip = urllib.request.urlopen("https://v4.ident.me", timeout=120).read().decode("utf8").strip()
+            #self.logger.info(f"Successfully fetched external IP: {public_ip}")
+            return public_ip
+        except Exception as e:
+            #self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
+            return "localhost"
+
+    def _fetch_location_name(self, location_id: str, session: Optional[Session] = None) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            session: Matrice session for API calls
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[LOCATION] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if not hasattr(self, '_location_name_cache'):
+            self._location_name_cache: Dict[str, str] = {}
+        
+        if location_id in self._location_name_cache:
+            cached_name = self._location_name_cache[location_id]
+            self.logger.debug(f"[LOCATION] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        if not session:
+            self.logger.warning(f"[LOCATION] No session provided, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[LOCATION] Fetching location name from API: {endpoint}")
+            
+            response = session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[LOCATION] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    self._location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[LOCATION] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[LOCATION] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[LOCATION] Error fetching location name for '{location_id}': {e}", exc_info=True)
         
+        # Use default on any failure
+        self.logger.info(f"[LOCATION] Using default location name: '{default_location}'")
+        self._location_name_cache[location_id] = default_location
+        return default_location
+
+    def _initialize_alert_manager_once(self, config: LicensePlateMonitorConfig) -> None:
+        """
+        Initialize alert manager ONCE with Redis OR Kafka clients (Environment based).
+        Called from process() on first invocation.
+        Uses config.session (existing session from pipeline).
+        """
+        if self._alert_manager_initialized:
+            return
+
+        try:
+            # Import required modules
+            import base64
+            from matrice_common.stream.matrice_stream import MatriceStream, StreamType
+
+            # Use existing session from config (same pattern as plate_logger)
+            if not config.session:
+                account_number = os.getenv("MATRICE_ACCOUNT_NUMBER", "")
+                access_key_id = os.getenv("MATRICE_ACCESS_KEY_ID", "")
+                secret_key = os.getenv("MATRICE_SECRET_ACCESS_KEY", "")
+                project_id = os.getenv("MATRICE_PROJECT_ID", "")
+                
+                self.session = Session(
+                    account_number=account_number,
+                    access_key=access_key_id,
+                    secret_key=secret_key,
+                    project_id=project_id,
+                )
+                config.session = self.session
+                if not self.session:
+                    self.logger.warning("[ALERT] No session in config OR manual, skipping alert manager initialization")
+                    self._alert_manager_initialized = True
+                    return
+
+            rpc = config.session.rpc
+
+            # Determine environment: Localhost vs Cloud
+            # We use LPR server info to determine if we are local or cloud, similar to face_recognition_client
+            is_localhost = False
+            lpr_server_id = config.lpr_server_id
+            print("--------------------------------CONFIG-PRINT---------------------------")
+            print(config)
+            print("--------------------------------CONFIG-PRINT---------------------------")
+            if lpr_server_id:
+                try:
+                    # Fetch LPR server info to compare IPs
+                    response = rpc.get(f"/v1/actions/lpr_servers/{lpr_server_id}")
+                    if response.get("success", False) and response.get("data"):
+                        server_data = response.get("data", {})
+                        server_host = server_data.get("host", "")
+                        public_ip = self._get_public_ip()
+                        
+                        # Check if server_host indicates localhost
+                        localhost_indicators = ["localhost", "127.0.0.1", "0.0.0.0"]
+                        if server_host in localhost_indicators or server_host == public_ip:
+                            is_localhost = True
+                            self.logger.info(f"[ALERT] Detected Localhost environment (Public IP={public_ip}, Server IP={server_host})")
+                        else:
+                            is_localhost = False
+                            self.logger.info(f"[ALERT] Detected Cloud environment (Public IP={public_ip}, Server IP={server_host})")
+                    else:
+                        self.logger.warning(f"[ALERT] Failed to fetch LPR server info for environment detection, defaulting to Cloud mode")
+                except Exception as e:
+                    self.logger.warning(f"[ALERT] Error detecting environment: {e}, defaulting to Cloud mode")
+            else:
+                 self.logger.info("[ALERT] No LPR server ID, defaulting to Cloud mode")
+
+            # ------------------------------------------------------------------
+            # Discover action_id and fetch action details (STRICT API-DRIVEN)
+            # ------------------------------------------------------------------
+            action_id = self._discover_action_id()
+            if not action_id:
+                self.logger.error("[ALERT] Could not discover action_id from working directory or parents")
+                print("----- ALERT ACTION DISCOVERY -----")
+                print("action_id: NOT FOUND")
+                print("----------------------------------")
+                self._alert_manager_initialized = True
+                return
+
+            try:
+                action_url = f"/v1/actions/action/{action_id}/details"
+                action_resp = rpc.get(action_url)
+                if not (action_resp and action_resp.get("success", False)):
+                    raise RuntimeError(action_resp.get("message", "Unknown error") if isinstance(action_resp, dict) else "Unknown error")
+                action_doc = action_resp.get("data", {}) if isinstance(action_resp, dict) else {}
+                action_details = action_doc.get("actionDetails", {}) if isinstance(action_doc, dict) else {}
+
+                # server id and type extraction (robust to variants)
+                server_id = (
+                    action_details.get("serverId")
+                    or action_details.get("server_id")
+                    or action_details.get("serverID")
+                    or action_details.get("redis_server_id")
+                    or action_details.get("kafka_server_id")
+                )
+                server_type = (
+                    action_details.get("serverType")
+                    or action_details.get("server_type")
+                    or action_details.get("type")
+                )
+
+                # Persist identifiers for future
+                self._action_id = action_id
+                self._deployment_id = action_details.get("_idDeployment") or action_details.get("deployment_id")
+                self._app_deployment_id = action_details.get("app_deployment_id")
+                self._instance_id = action_details.get("instanceID") or action_details.get("instanceId")
+                self._external_ip = action_details.get("externalIP") or action_details.get("externalIp")
+
+                print("----- ALERT ACTION DETAILS -----")
+                print(f"action_id: {action_id}")
+                print(f"server_type: {server_type}")
+                print(f"server_id: {server_id}")
+                print(f"deployment_id: {self._deployment_id}")
+                print(f"app_deployment_id: {self._app_deployment_id}")
+                print(f"instance_id: {self._instance_id}")
+                print(f"external_ip: {self._external_ip}")
+                print("--------------------------------")
+                self.logger.info(f"[ALERT] Action details fetched | action_id={action_id}, server_type={server_type}, server_id={server_id}")
+                self.logger.debug(f"[ALERT] Full action_details: {action_details}")
+            except Exception as e:
+                self.logger.error(f"[ALERT] Failed to fetch action details for action_id={action_id}: {e}", exc_info=True)
+                print("----- ALERT ACTION DETAILS ERROR -----")
+                print(f"action_id: {action_id}")
+                print(f"error: {e}")
+                print("--------------------------------------")
+                self._alert_manager_initialized = True
+                return
+
+            redis_client = None
+            kafka_client = None
+
+            # STRICT SWITCH: Only Redis if localhost, Only Kafka if cloud
+            if is_localhost:
+                # Initialize Redis client (ONLY) using STRICT API by instanceID
+                instance_id = getattr(self, "_instance_id", None)
+                if not instance_id:
+                    self.logger.error("[ALERT] Localhost mode but instance_id missing in action details for Redis initialization")
+                else:
+                    try:
+                        backend_base = self._get_backend_base_url()
+                        url = f"/v1/actions/get_redis_server_by_instance_id/{instance_id}"
+                        self.logger.info(f"[ALERT] Initializing Redis client via API for Localhost mode (instance_id={instance_id})")
+                        response = rpc.get(url)
+                        if isinstance(response, dict) and response.get("success", False):
+                            data = response.get("data", {})
+                            host = data.get("host")
+                            port = data.get("port")
+                            username = data.get("username")
+                            password = data.get("password", "")
+                            db_index = data.get("db", 0)
+                            conn_timeout = data.get("connection_timeout", 120)
+
+                            print("----- REDIS SERVER PARAMS -----")
+                            print(f"server_type: {server_type}")
+                            print(f"instance_id: {instance_id}")
+                            print(f"host: {host}")
+                            print(f"port: {port}")
+                            print(f"username: {username}")
+                            print(f"password: {password}")
+                            print(f"db: {db_index}")
+                            print(f"connection_timeout: {conn_timeout}")
+                            print("--------------------------------")
+
+                            self.logger.info(f"[ALERT] Redis server params | instance_id={instance_id}, host={host}, port={port}, user={username}, db={db_index}")
+
+                            # Initialize without gating on status
+                            redis_client = MatriceStream(
+                                StreamType.REDIS,
+                                host=host,
+                                port=int(port),
+                                password=password,
+                                username=username,
+                                db=db_index,
+                                connection_timeout=conn_timeout
+                            )
+                            redis_client.setup("alert_instant_config_request")
+                            self.logger.info("[ALERT] Redis client initialized successfully")
+                        else:
+                            self.logger.warning(f"[ALERT] Failed to fetch Redis server info: {response.get('message', 'Unknown error') if isinstance(response, dict) else 'Unknown error'}")
+                    except Exception as e:
+                        self.logger.warning(f"[ALERT] Redis initialization failed: {e}")
+
+            else:
+                # Initialize Kafka client (ONLY) using STRICT API (global info endpoint)
+                try:
+                    backend_base = self._get_backend_base_url()
+                    url = f"/v1/actions/get_kafka_info"
+                    self.logger.info("[ALERT] Initializing Kafka client via API for Cloud mode")
+                    response = rpc.get(url)
+                    if isinstance(response, dict) and response.get("success", False):
+                        data = response.get("data", {})
+                        enc_ip = data.get("ip")
+                        enc_port = data.get("port")
+                        ip_addr = None
+                        port = None
+                        try:
+                            ip_addr = base64.b64decode(str(enc_ip)).decode("utf-8")
+                        except Exception:
+                            ip_addr = enc_ip
+                        try:
+                            port = base64.b64decode(str(enc_port)).decode("utf-8")
+                        except Exception:
+                            port = enc_port
+
+                        print("----- KAFKA SERVER PARAMS -----")
+                        print(f"server_type: {server_type}")
+                        print(f"ipAddress: {ip_addr}")
+                        print(f"port: {port}")
+                        print("--------------------------------")
+
+                        self.logger.info(f"[ALERT] Kafka server params | ip={ip_addr}, port={port}")
+
+                        bootstrap_servers = f"{ip_addr}:{port}"
+                        kafka_client = MatriceStream(
+                            StreamType.KAFKA,
+                            bootstrap_servers=bootstrap_servers,
+                            sasl_mechanism="SCRAM-SHA-256",
+                            sasl_username="matrice-sdk-user",
+                            sasl_password="matrice-sdk-password",
+                            security_protocol="SASL_PLAINTEXT"
+                        )
+                        kafka_client.setup("alert_instant_config_request", consumer_group_id="py_analytics_lpr_alerts")
+                        self.logger.info(f"[ALERT] Kafka client initialized successfully (servers={bootstrap_servers})")
+                    else:
+                        self.logger.warning(f"[ALERT] Failed to fetch Kafka server info: {response.get('message', 'Unknown error') if isinstance(response, dict) else 'Unknown error'}")
+                except Exception as e:
+                    self.logger.warning(f"[ALERT] Kafka initialization failed: {e}")
+
+            # Create alert manager if client is available
+            if redis_client or kafka_client:
+                # Get app_deployment_id from action_details for filtering alerts
+                app_deployment_id_for_alert = getattr(self, '_app_deployment_id', None)
+                self.logger.info(f"[ALERT] Using app_deployment_id for alert filtering: {app_deployment_id_for_alert}")
+                
+                self.alert_manager = ALERT_INSTANCE(
+                    redis_client=redis_client,
+                    kafka_client=kafka_client,
+                    config_topic="alert_instant_config_request",
+                    trigger_topic="alert_instant_triggered",
+                    polling_interval=10,  # Poll every 10 seconds
+                    logger=self.logger,
+                    app_deployment_id=app_deployment_id_for_alert
+                )
+                self.alert_manager.start()
+                transport = "Redis" if redis_client else "Kafka"
+                self.logger.info(f"[ALERT] Alert manager initialized and started with {transport} (polling every 10s)")
+            else:
+                self.logger.warning(f"[ALERT] No {'Redis' if is_localhost else 'Kafka'} client available for {'Localhost' if is_localhost else 'Cloud'} mode, alerts disabled")
+
+        except Exception as e:
+            self.logger.error(f"[ALERT] Alert manager initialization failed: {e}", exc_info=True)
+        finally:
+            self._alert_manager_initialized = True  # Mark as initialized (don't retry every frame)
 
     def reset_tracker(self) -> None:
         """Reset the advanced tracker instance."""
@@ -537,6 +949,171 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.reset_tracker()
         self.reset_plate_tracking()
         self.logger.info("All plate tracking state reset")
+
+    def _send_instant_alerts(
+        self,
+        detections: List[Dict[str, Any]],
+        stream_info: Optional[Dict[str, Any]],
+        config: LicensePlateMonitorConfig
+    ) -> None:
+        """
+        Send detection events to the instant alert system.
+
+        This method processes detections and sends them to the alert manager
+        for evaluation against active alert configurations.
+
+        Args:
+            detections: List of detection dictionaries with plate_text
+            stream_info: Stream information containing camera_id and other metadata
+            config: License plate monitoring configuration
+        """
+        self.logger.info(f"[ALERT_DEBUG] ========== SEND INSTANT ALERTS ==========")
+        
+        if not self.alert_manager:
+            self.logger.debug("[ALERT_DEBUG] Alert manager not configured, skipping instant alerts")
+            return
+
+        if not detections:
+            self.logger.debug("[ALERT_DEBUG] No detections to send to alert manager")
+            return
+        
+        self.logger.info(f"[ALERT_DEBUG] Processing {len(detections)} detection(s) for alerts")
+
+        # Extract metadata directly from stream_info with empty string defaults
+        # No complex nested checks - if not found, pass empty string (no errors)
+        camera_id = ""
+        app_deployment_id = ""
+        application_id = ""
+        camera_name = ""
+        frame_id = ""
+        location_name = ""
+
+        if stream_info:
+            self.logger.debug(f"[ALERT_DEBUG] stream_info keys: {list(stream_info.keys())}")
+            # Direct extraction with safe defaults
+            camera_id = stream_info.get("camera_id", "")
+            if not camera_id and "camera_info" in stream_info:
+                camera_id = stream_info.get("camera_info", {}).get("camera_id", "")
+
+            camera_name = stream_info.get("camera_name", "")
+            if not camera_name and "camera_info" in stream_info:
+                camera_name = stream_info.get("camera_info", {}).get("camera_name", "")
+
+            app_deployment_id = stream_info.get("app_deployment_id", "")
+            application_id = stream_info.get("application_id", stream_info.get("app_id", ""))
+            
+            # Extract frame_id - it's at root level of stream_info
+            frame_id = stream_info.get("frame_id", "")
+            
+            # Extract location_id and fetch location_name from API
+            location_id = ""
+            if "camera_info" in stream_info:
+                location_id = stream_info.get("camera_info", {}).get("location", "")
+            
+            if location_id:
+                # Fetch location name from API
+                location_name = self._fetch_location_name(location_id, config.session)
+            else:
+                location_name = "Entry Reception"  # Default if no location_id
+            
+            self.logger.debug(f"[ALERT_DEBUG] Extracted metadata from stream_info:")
+            self.logger.debug(f"[ALERT_DEBUG]   - camera_id: '{camera_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - camera_name: '{camera_name}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - app_deployment_id: '{app_deployment_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - application_id: '{application_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - frame_id: '{frame_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - location_id: '{location_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - location_name: '{location_name}'")
+        else:
+            self.logger.warning("[ALERT_DEBUG] stream_info is None")
+            location_name = "Entry Reception"  # Default
+
+        # Process each detection with a valid plate_text
+        sent_count = 0
+        skipped_count = 0
+        for i, detection in enumerate(detections):
+            self.logger.debug(f"[ALERT_DEBUG] --- Processing detection #{i+1} ---")
+            self.logger.debug(f"[ALERT_DEBUG] Detection keys: {list(detection.keys())}")
+            
+            plate_text = detection.get('plate_text', '.')
+            if plate_text:
+                plate_text = plate_text.strip()
+            else:
+                plate_text = ''
+            self.logger.debug(f"[ALERT_DEBUG] Plate text: '{plate_text}'")
+            
+            if not plate_text or plate_text == '':
+                self.logger.debug(f"[ALERT_DEBUG] Skipping detection #{i+1} - no plate_text")
+                skipped_count += 1
+                continue
+
+            # Extract detection metadata
+            confidence = detection.get('score', detection.get('confidence', 0.0))
+            bbox = detection.get('bbox', detection.get('bounding_box', []))
+            
+            self.logger.debug(f"[ALERT_DEBUG] Confidence: {confidence}")
+            self.logger.debug(f"[ALERT_DEBUG] BBox: {bbox}")
+
+            # Build coordinates dict
+            coordinates = {}
+            if isinstance(bbox, dict):
+                # Handle dict format bbox
+                if 'xmin' in bbox:
+                    coordinates = {
+                        "x": int(bbox.get('xmin', 0)),
+                        "y": int(bbox.get('ymin', 0)),
+                        "width": int(bbox.get('xmax', 0) - bbox.get('xmin', 0)),
+                        "height": int(bbox.get('ymax', 0) - bbox.get('ymin', 0))
+                    }
+                elif 'x' in bbox:
+                    coordinates = {
+                        "x": int(bbox.get('x', 0)),
+                        "y": int(bbox.get('y', 0)),
+                        "width": int(bbox.get('width', 0)),
+                        "height": int(bbox.get('height', 0))
+                    }
+            elif isinstance(bbox, list) and len(bbox) >= 4:
+                x1, y1, x2, y2 = bbox[:4]
+                coordinates = {
+                    "x": int(x1),
+                    "y": int(y1),
+                    "width": int(x2 - x1),
+                    "height": int(y2 - y1)
+                }
+            
+            self.logger.debug(f"[ALERT_DEBUG] Coordinates: {coordinates}")
+
+            # Build detection event for alert system
+            detection_event = {
+                "camera_id": camera_id,
+                "app_deployment_id": app_deployment_id,
+                "application_id": application_id,
+                "detectionType": "license_plate",
+                "plateNumber": plate_text,
+                "confidence": float(confidence),
+                "frameUrl": "",  # Will be filled by analytics publisher if needed
+                "coordinates": coordinates,
+                "cameraName": camera_name,
+                "locationName": location_name,
+                "frame_id": frame_id,
+                "vehicleType": detection.get('vehicle_type', ''),
+                "vehicleColor": detection.get('vehicle_color', ''),
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+            
+            self.logger.info(f"[ALERT_DEBUG] Detection event #{i+1} built: {detection_event}")
+
+            # Send to alert manager for evaluation
+            try:
+                self.logger.info(f"[ALERT_DEBUG] Sending detection event #{i+1} to alert manager...")
+                self.alert_manager.process_detection_event(detection_event)
+                self.logger.info(f"[ALERT_DEBUG] ✓ Sent detection event to alert manager: plate={plate_text}, confidence={confidence:.2f}")
+                sent_count += 1
+            except Exception as e:
+                self.logger.error(f"[ALERT_DEBUG] ❌ Error sending detection event to alert manager: {e}", exc_info=True)
+        
+        self.logger.info(f"[ALERT_DEBUG] Summary: {sent_count} sent, {skipped_count} skipped")
+        self.logger.info(f"[ALERT_DEBUG] ========== INSTANT ALERTS PROCESSED ==========")
     
     def _initialize_plate_logger(self, config: LicensePlateMonitorConfig) -> bool:
         """Initialize the plate logger if lpr_server_id is provided. Returns True if successful."""
@@ -575,7 +1152,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         print(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}, Stream info exists: {stream_info is not None}")
-        #self._logging_enabled=False  
+        
+        #self._logging_enabled = False # ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION
         if not self._logging_enabled:
             print("[LP_LOGGING] Plate logging is DISABLED")
             self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")
@@ -586,10 +1164,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - plate_logger is not initialized (lpr_server_id may not be configured)")
             return
         
-        if not stream_info:
-            print("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-            self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-            return
+        # if not stream_info:
+        #     print("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
+        #     self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
+        #     return
         
         print("[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
         self.logger.info(f"[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
@@ -617,6 +1195,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 else:
                     self.logger.warning(f"[LP_LOGGING] Failed to decode image bytes")
             except Exception as e:
+                #pass
                 self.logger.error(f"[LP_LOGGING] Exception while encoding frame image: {e}", exc_info=True)
         else:
             self.logger.info(f"[LP_LOGGING] No image_bytes provided, sending without image")
@@ -657,14 +1236,18 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                         print(f"[LP_LOGGING] Plate {plate_text}: {status}")
                         self.logger.info(f"[LP_LOGGING] Plate {plate_text}: {status}")
                     except Exception as e:
+                        #pass
                         print(f"[LP_LOGGING] ERROR - Plate {plate_text} failed: {e}")
                         self.logger.error(f"[LP_LOGGING] Plate {plate_text} raised exception: {e}", exc_info=True)
                 
                 print("[LP_LOGGING] Plate logging complete")
                 self.logger.info(f"[LP_LOGGING] Plate logging complete")
             except Exception as e:
+                print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
+                
                 print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
                 self.logger.error(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}", exc_info=True)
+                pass
         else:
             print("[LP_LOGGING] No plates to log")
             self.logger.info(f"[LP_LOGGING] No plates to log (plates_to_log is empty)")
@@ -693,11 +1276,16 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 else:
                     self.logger.error(f"[LP_LOGGING] Plate logger initialization FAILED - plates will NOT be sent")
             elif self._plate_logger_initialized:
-                self.logger.debug(f"[LP_LOGGING] Plate logger already initialized, skipping re-initialization")
+                 self.logger.debug(f"[LP_LOGGING] Plate logger already initialized, skipping re-initialization")
             elif not config.lpr_server_id:
-                if self._total_frame_counter == 0:  # Only log once at start
-                    self.logger.warning(f"[LP_LOGGING] Plate logging will be DISABLED - no lpr_server_id provided in config")
-            
+                 if self._total_frame_counter == 0:   #Only log once at start
+                     self.logger.warning(f"[LP_LOGGING] Plate logging will be DISABLED - no lpr_server_id provided in config")
+
+            # Initialize alert manager once (lazy initialization on first call)
+            if not self._alert_manager_initialized:
+                self._initialize_alert_manager_once(config)
+                self.logger.info(f"[ALERT] CONFIG OF ALERT SHOULD BE PRINTED")
+
             # Normalize alert_config if provided as a plain dict (JS JSON)
             if isinstance(getattr(config, 'alert_config', None), dict):
                 try:
@@ -718,13 +1306,13 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             # print("---------CONFIDENCE FILTERING",config.confidence_threshold)
             # print("---------DATA1--------------",data)
             processed_data = filter_by_confidence(data, config.confidence_threshold)
-            #self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
+            self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
             
             # Step 2: Apply category mapping if provided
             if config.index_to_category:
                 processed_data = apply_category_mapping(processed_data, config.index_to_category)
                 #self.logger.debug("Applied category mapping")
-            #print("---------DATA2--------------",processed_data)
+            print("---------DATA2-STREAM--------------",stream_info)
             # Step 3: Filter to target categories (handle dict or list)
             if isinstance(processed_data, dict):
                 processed_data = processed_data.get("detections", [])
@@ -775,25 +1363,29 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             #print("---------DATA5--------------",processed_data)
             # Step 8: Perform OCR on media
             ocr_analysis = self._analyze_ocr_in_media(processed_data, input_bytes, config)
-            self.logger.info(f"[LP_LOGGING] OCR analysis completed, found {len(ocr_analysis)} results")
+            #self.logger.info(f"[LP_LOGGING] OCR analysis completed, found {len(ocr_analysis)} results")
             ocr_plates_found = [r.get('plate_text') for r in ocr_analysis if r.get('plate_text')]
-            if ocr_plates_found:
-                self.logger.info(f"[LP_LOGGING] OCR detected plates: {ocr_plates_found}")
-            else:
-                self.logger.warning(f"[LP_LOGGING] OCR did not detect any valid plate texts")
+            # if ocr_plates_found:
+            #     self.logger.info(f"[LP_LOGGING] OCR detected plates: {ocr_plates_found}")
+            # else:
+            #     self.logger.warning(f"[LP_LOGGING] OCR did not detect any valid plate texts")
             
             # Step 9: Update plate texts
             processed_data = self._update_detections_with_ocr(processed_data, ocr_analysis)
             self._update_plate_texts(processed_data)
-            
+            print("[LP_LOGGING]DEBUG -1")
+
             # Log final detection state before sending
             final_plates = [d.get('plate_text') for d in processed_data if d.get('plate_text')]
             self.logger.info(f"[LP_LOGGING] After OCR update, {len(final_plates)} detections have plate_text: {final_plates}")
-            
+
             # Step 9.5: Log detected plates to RPC (optional, only if lpr_server_id is provided)
             # Direct await since process is now async
             await self._log_detected_plates(processed_data, config, stream_info, input_bytes)
-            
+            print("[LP_LOGGING]DEBUG -2")
+            # Step 9.6: Send detections to instant alert system (if configured)
+            self._send_instant_alerts(processed_data, stream_info, config)
+            print("[LP_LOGGING]DEBUG -3")
             # Step 10: Update frame counter
             self._total_frame_counter += 1
             
@@ -809,6 +1401,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             # Step 12: Calculate summaries
             counting_summary = self._count_categories(processed_data, config)
             counting_summary['total_counts'] = self.get_total_counts()
+            print("[LP_LOGGING]DEBUG -4")
             
             # Step 13: Generate alerts and summaries
             alerts = self._check_alerts(counting_summary, frame_number, config)
@@ -856,7 +1449,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             processing_fps = (1.0 / proc_time) if proc_time > 0 else None
             # Log the performance metrics using the module-level logger
             print("latency in ms:",processing_latency_ms,"| Throughput fps:",processing_fps,"| Frame_Number:",self._total_frame_counter)
-
+            print("[LP_LOGGING]DEBUG -5")
             return result
             
         except Exception as e:
@@ -1162,35 +1755,39 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         human_text_lines = []
         #print("counting_summary", counting_summary)
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
+        sum_of_current_frame_detections = sum(per_category_count.values())
+        
         if total_detections > 0:
+            #for cat, count in per_category_count.items():
+            human_text_lines.append(f"\t- License Plates Detected: {sum_of_current_frame_detections}")
             category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
             detection_text = category_counts[0] + " detected" if len(category_counts) == 1 else f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
-            human_text_lines.append(f"\t- {detection_text}")
-            # Show dominant per-track license plates for current frame
+            #human_text_lines.append(f"\t- {detection_text}")
+            #Show dominant per-track license plates for current frame
             seen = set()
             display_texts = []
             for det in counting_summary.get("detections", []):
                 t = det.get("track_id")
                 dom = det.get("plate_text")
-                if not dom or not (self._min_plate_len <= len(dom) <= 6):
+                if not dom or not (self._min_plate_len <= len(dom) <= 5):
                     continue
                 if t in seen:
                     continue
                 seen.add(t)
                 display_texts.append(dom)
-            if display_texts:
-                human_text_lines.append(f"\t- License Plates: {', '.join(display_texts)}")
+            # if display_texts:
+            #     human_text_lines.append(f"\t- License Plates: {', '.join(display_texts)}")
         else:
-            human_text_lines.append(f"\t- No detections")
+            human_text_lines.append(f"\t- License Plates Detected: 0")
         
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        human_text_lines.append(f"\t- Total Detected: {cumulative_total}")
+        # human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
+        # human_text_lines.append(f"\t- Total Detected: {cumulative_total}")
 
-        if self._unique_plate_texts:
-            human_text_lines.append("\t- Unique License Plates:")
-            for text in sorted(self._unique_plate_texts.values()):
-                human_text_lines.append(f"\t\t- {text}")
+        # if self._unique_plate_texts:
+        #     human_text_lines.append("\t- Unique License Plates:")
+        #     for text in sorted(self._unique_plate_texts.values()):
+        #         human_text_lines.append(f"\t\t- {text}")
 
         current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items() if count > 0 or total_detections > 0]
         total_counts_list = [{"category": cat, "count": count} for cat, count in total_counts.items() if count > 0 or cumulative_total > 0]
@@ -1200,10 +1797,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         for detection in counting_summary.get("detections", []):
             dom = detection.get("plate_text", "")
             if not dom:
-                dom = "license_plate"
+                dom = ""
             bbox = detection.get("bounding_box", {})
-            category = detection.get("category", "license_plate")
-            segmentation = detection.get("masks", detection.get("segmentation", detection.get("mask", [])))
+            category = detection.get("category", "")
+            #egmentation = detection.get("masks", detection.get("segmentation", detection.get("mask", [])))
             detection_obj = self.create_detection_object(category, bbox, segmentation=None, plate_text=dom)
             detections.append(detection_obj)
         
@@ -1244,6 +1841,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = self.target_categories
         tracking_stats.append(tracking_stat)
         return tracking_stats