nebu 0.1.115__py3-none-any.whl → 0.1.117__py3-none-any.whl

nebu/processors/consumer.py

@@ -33,11 +33,20 @@ local_namespace: Dict[str, Any] = {}  # Namespace for included objects
 last_load_mtime: float = 0.0
 entrypoint_abs_path: Optional[str] = None
 
+# Global health check subprocess
+health_subprocess: Optional[subprocess.Popen] = None
+
 REDIS_CONSUMER_GROUP = os.environ.get("REDIS_CONSUMER_GROUP")
 REDIS_STREAM = os.environ.get("REDIS_STREAM")
 NEBU_EXECUTION_MODE = os.environ.get("NEBU_EXECUTION_MODE", "inline").lower()
 execution_mode = NEBU_EXECUTION_MODE
 
+# Define health check stream and group names
+REDIS_HEALTH_STREAM = f"{REDIS_STREAM}.health" if REDIS_STREAM else None
+REDIS_HEALTH_CONSUMER_GROUP = (
+    f"{REDIS_CONSUMER_GROUP}-health" if REDIS_CONSUMER_GROUP else None
+)
+
 if execution_mode not in ["inline", "subprocess"]:
     logger.warning(
         f"Invalid NEBU_EXECUTION_MODE: {NEBU_EXECUTION_MODE}. Must be 'inline' or 'subprocess'. Defaulting to 'inline'."
@@ -328,20 +337,34 @@ socks.set_default_proxy(socks.SOCKS5, "localhost", 1055)
 socket.socket = socks.socksocket
 logger.info("Configured SOCKS5 proxy for socket connections via localhost:1055")
 
-# Connect to Redis
-try:
-    # Parse the Redis URL to handle potential credentials or specific DBs if needed
-    # Although from_url should work now with the patched socket
-    r = redis.from_url(
-        REDIS_URL, decode_responses=True
-    )  # Added decode_responses for convenience
-    r.ping()  # Test connection
-    redis_info = REDIS_URL.split("@")[-1] if "@" in REDIS_URL else REDIS_URL
-    logger.info(f"Connected to Redis via SOCKS proxy at {redis_info}")
-except Exception as e:
-    logger.critical(f"Failed to connect to Redis via SOCKS proxy: {e}")
-    logger.exception("Redis Connection Error Traceback:")
-    sys.exit(1)
+# Global Redis connection for the main consumer
+r: redis.Redis  # Initialized by connect_redis, which sys.exits on failure
+
+
+# --- Connect to Redis (Main Consumer) ---
+def connect_redis(redis_url: str) -> redis.Redis:
+    """Connects to Redis and returns the connection object."""
+    try:
+        # Parse the Redis URL to handle potential credentials or specific DBs if needed
+        # Although from_url should work now with the patched socket
+        logger.info(
+            f"Attempting to connect to Redis at {redis_url.split('@')[-1] if '@' in redis_url else redis_url}"
+        )
+        conn = redis.from_url(
+            redis_url, decode_responses=True
+        )  # Added decode_responses for convenience
+        conn.ping()  # Test connection
+        redis_info = redis_url.split("@")[-1] if "@" in redis_url else redis_url
+        logger.info(f"Connected to Redis via SOCKS proxy at {redis_info}")
+        return conn
+    except Exception as e:
+        logger.critical(f"Failed to connect to Redis via SOCKS proxy: {e}")
+        logger.exception("Redis Connection Error Traceback:")
+        sys.exit(1)
+
+
+r = connect_redis(REDIS_URL)
+
 
 # Create consumer group if it doesn't exist
 try:
@@ -360,6 +383,103 @@ except ResponseError as e:
         logger.exception("Consumer Group Creation Error Traceback:")
 
 
+# --- Health Check Subprocess Management ---
+def start_health_check_subprocess() -> Optional[subprocess.Popen]:
+    """Start the health check consumer subprocess."""
+    global REDIS_HEALTH_STREAM, REDIS_HEALTH_CONSUMER_GROUP
+
+    if not all([REDIS_URL, REDIS_HEALTH_STREAM, REDIS_HEALTH_CONSUMER_GROUP]):
+        logger.warning(
+            "[Consumer] Health check stream not configured. Health consumer subprocess not started."
+        )
+        return None
+
+    try:
+        # Type assertions to ensure variables are strings before using them
+        assert isinstance(REDIS_HEALTH_STREAM, str)
+        assert isinstance(REDIS_HEALTH_CONSUMER_GROUP, str)
+
+        # Prepare environment variables for the subprocess
+        health_env = os.environ.copy()
+        health_env["REDIS_HEALTH_STREAM"] = REDIS_HEALTH_STREAM
+        health_env["REDIS_HEALTH_CONSUMER_GROUP"] = REDIS_HEALTH_CONSUMER_GROUP
+
+        # Start the health check worker subprocess
+        health_cmd = [
+            sys.executable,
+            "-u",  # Force unbuffered stdout/stderr
+            "-m",
+            "nebu.processors.consumer_health_worker",
+        ]
+
+        process = subprocess.Popen(
+            health_cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Combine stderr with stdout
+            text=True,
+            encoding="utf-8",
+            env=health_env,
+            bufsize=1,  # Line buffered
+        )
+
+        logger.info(
+            f"[Consumer] Health check subprocess started with PID {process.pid}"
+        )
+        return process
+
+    except Exception as e:
+        logger.error(f"[Consumer] Failed to start health check subprocess: {e}")
+        logger.exception("Health Subprocess Start Error Traceback:")
+        return None
+
+
+def monitor_health_subprocess(process: subprocess.Popen) -> None:
+    """Monitor the health check subprocess and log its output."""
+    try:
+        # Read output from the subprocess
+        if process.stdout:
+            for line in iter(process.stdout.readline, ""):
+                logger.info(f"[HealthSubprocess] {line.strip()}")
+        process.stdout.close() if process.stdout else None
+    except Exception as e:
+        logger.error(f"[Consumer] Error monitoring health subprocess: {e}")
+
+
+def check_health_subprocess() -> bool:
+    """Check if the health subprocess is still running and restart if needed."""
+    global health_subprocess
+
+    if health_subprocess is None:
+        return False
+
+    # Check if process is still running
+    if health_subprocess.poll() is None:
+        return True  # Still running
+
+    # Process has exited
+    exit_code = health_subprocess.returncode
+    logger.warning(
+        f"[Consumer] Health subprocess exited with code {exit_code}. Restarting..."
+    )
+
+    # Start a new health subprocess
+    health_subprocess = start_health_check_subprocess()
+
+    if health_subprocess:
+        # Start monitoring thread for the new subprocess
+        monitor_thread = threading.Thread(
+            target=monitor_health_subprocess, args=(health_subprocess,), daemon=True
+        )
+        monitor_thread.start()
+        logger.info(
+            "[Consumer] Health subprocess restarted and monitoring thread started."
+        )
+        return True
+    else:
+        logger.error("[Consumer] Failed to restart health subprocess.")
+        return False
+
+
 # Function to process messages
 def process_message(message_id: str, message_data: Dict[str, str]) -> None:
     # Access the globally managed user code elements
@@ -1088,11 +1208,35 @@ logger.info(
     f"[Consumer] Hot code reloading is {'DISABLED' if disable_hot_reload else 'ENABLED'}."
 )
 
+# Start the health check consumer subprocess
+if REDIS_HEALTH_STREAM and REDIS_HEALTH_CONSUMER_GROUP:
+    health_subprocess = start_health_check_subprocess()
+    if health_subprocess:
+        # Start monitoring thread for subprocess output
+        monitor_thread = threading.Thread(
+            target=monitor_health_subprocess, args=(health_subprocess,), daemon=True
+        )
+        monitor_thread.start()
+        logger.info(
+            f"[Consumer] Health check subprocess for {REDIS_HEALTH_STREAM} started and monitoring thread started."
+        )
+    else:
+        logger.error("[Consumer] Failed to start health check subprocess.")
+else:
+    logger.warning(
+        "[Consumer] Health check stream not configured. Health consumer subprocess not started."
+    )
+
 try:
     while True:
         logger.debug(
             f"[{datetime.now(timezone.utc).isoformat()}] --- Top of main loop ---"
         )  # Added log
+
+        # --- Check Health Subprocess Status ---
+        if health_subprocess:
+            check_health_subprocess()
+
         # --- Check for Code Updates ---
         if not disable_hot_reload:
             logger.debug(
@@ -1356,18 +1500,21 @@ except ConnectionError as e:
     # Attempt to reconnect explicitly
     try:
         logger.info("Attempting Redis reconnection...")
-        # Close existing potentially broken connection? `r.close()` if available
-        r = redis.from_url(REDIS_URL, decode_responses=True)
-        r.ping()
+        # Close existing potentially broken connection?
+        if r:  # Check if r was initialized
+            try:
+                r.close()
+            except Exception:
+                pass  # Ignore errors during close
+        r = connect_redis(REDIS_URL)  # connect_redis will sys.exit on failure
         logger.info("Reconnected to Redis.")
-    except Exception as recon_e:
+    except Exception as recon_e:  # Should not be reached if connect_redis exits
         logger.error(f"Failed to reconnect to Redis: {recon_e}")
-        # Keep waiting
 
 except ResponseError as e:
     logger.error(f"Redis command error: {e}")
     # Should we exit or retry?
-    if "NOGROUP" in str(e):
+    if r and "NOGROUP" in str(e):  # Check if r is initialized
         logger.critical("Consumer group seems to have disappeared. Exiting.")
         sys.exit(1)
     time.sleep(1)
@@ -1379,4 +1526,15 @@ except Exception as e:
 
 finally:
     logger.info("Consumer loop exited.")
-    # Any other cleanup needed?
+    # Cleanup health subprocess
+    if health_subprocess and health_subprocess.poll() is None:
+        logger.info("[Consumer] Terminating health check subprocess...")
+        health_subprocess.terminate()
+        try:
+            health_subprocess.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            logger.warning(
+                "[Consumer] Health subprocess did not terminate gracefully, killing it."
+            )
+            health_subprocess.kill()
+        logger.info("[Consumer] Health subprocess cleanup complete.")

nebu/processors/consumer_health_worker.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+import json
+import logging
+import os
+import socket
+import sys
+import time
+from typing import Dict, List, Optional, Tuple, cast
+
+import redis
+import socks
+from redis import ConnectionError, ResponseError
+from redis.exceptions import TimeoutError as RedisTimeoutError
+
+
+def setup_health_logging():
+    """Set up logging for the health check worker to write to a dedicated file."""
+    # Create logs directory if it doesn't exist
+    log_dir = os.path.join(os.getcwd(), "logs")
+    os.makedirs(log_dir, exist_ok=True)
+
+    # Create log file path with timestamp
+    log_file = os.path.join(log_dir, f"health_consumer_{os.getpid()}.log")
+
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler(log_file),
+            logging.StreamHandler(
+                sys.stdout
+            ),  # Also log to stdout for subprocess monitoring
+        ],
+    )
+
+    logger = logging.getLogger("HealthConsumer")
+    logger.info(f"Health check worker started. Logging to: {log_file}")
+    return logger
+
+
+def process_health_check_message(
+    message_id: str,
+    message_data: Dict[str, str],
+    redis_conn: redis.Redis,
+    logger: logging.Logger,
+    health_stream: str,
+    health_group: str,
+) -> None:
+    """Processes a single health check message."""
+    logger.info(f"Processing health check message {message_id}: {message_data}")
+
+    # Parse the message if it contains JSON data
+    try:
+        if "data" in message_data:
+            data = json.loads(message_data["data"])
+            logger.info(f"Health check data: {data}")
+    except (json.JSONDecodeError, KeyError) as e:
+        logger.warning(f"Could not parse health check message data: {e}")
+
+    # You could add more logic here, e.g., update an internal health status,
+    # send a response, perform actual health checks, etc.
+
+    # Acknowledge the health check message
+    try:
+        redis_conn.xack(health_stream, health_group, message_id)
+        logger.info(f"Acknowledged health check message {message_id}")
+    except Exception as e_ack:
+        logger.error(
+            f"Failed to acknowledge health check message {message_id}: {e_ack}"
+        )
+
+
+def main():
+    """Main function for the health check consumer subprocess."""
+    logger = setup_health_logging()
+
+    # Get environment variables
+    redis_url = os.environ.get("REDIS_URL")
+    health_stream = os.environ.get("REDIS_HEALTH_STREAM")
+    health_group = os.environ.get("REDIS_HEALTH_CONSUMER_GROUP")
+
+    if not all([redis_url, health_stream, health_group]):
+        logger.error(
+            "Missing required environment variables: REDIS_URL, REDIS_HEALTH_STREAM, REDIS_HEALTH_CONSUMER_GROUP"
+        )
+        sys.exit(1)
+
+    # Type assertions after validation
+    assert isinstance(redis_url, str)
+    assert isinstance(health_stream, str)
+    assert isinstance(health_group, str)
+
+    logger.info(
+        f"Starting health consumer for stream: {health_stream}, group: {health_group}"
+    )
+
+    # Configure SOCKS proxy
+    socks.set_default_proxy(socks.SOCKS5, "localhost", 1055)
+    socket.socket = socks.socksocket
+    logger.info("Configured SOCKS5 proxy for socket connections via localhost:1055")
+
+    health_redis_conn: Optional[redis.Redis] = None
+    health_consumer_name = f"health-consumer-{os.getpid()}-{socket.gethostname()}"
+
+    while True:
+        try:
+            if health_redis_conn is None:
+                logger.info("Connecting to Redis for health stream...")
+                health_redis_conn = redis.from_url(redis_url, decode_responses=True)
+                health_redis_conn.ping()
+                logger.info("Connected to Redis for health stream.")
+
+                # Create health consumer group if it doesn't exist
+                try:
+                    health_redis_conn.xgroup_create(
+                        health_stream, health_group, id="0", mkstream=True
+                    )
+                    logger.info(
+                        f"Created consumer group {health_group} for stream {health_stream}"
+                    )
+                except ResponseError as e_group:
+                    if "BUSYGROUP" in str(e_group):
+                        logger.info(f"Consumer group {health_group} already exists.")
+                    else:
+                        logger.error(f"Error creating health consumer group: {e_group}")
+                        time.sleep(5)
+                        health_redis_conn = None
+                        continue
+                except Exception as e_group_other:
+                    logger.error(
+                        f"Unexpected error creating health consumer group: {e_group_other}"
+                    )
+                    time.sleep(5)
+                    health_redis_conn = None
+                    continue
+
+            # Read from health stream
+            assert health_redis_conn is not None
+
+            health_streams_arg: Dict[str, object] = {health_stream: ">"}
+            raw_messages = health_redis_conn.xreadgroup(
+                health_group,
+                health_consumer_name,
+                health_streams_arg,  # type: ignore[arg-type]
+                count=1,
+                block=5000,  # Block for 5 seconds
+            )
+
+            if raw_messages:
+                # Cast to expected type for decode_responses=True
+                messages = cast(
+                    List[Tuple[str, List[Tuple[str, Dict[str, str]]]]], raw_messages
+                )
+                for _stream_name, stream_messages in messages:
+                    for message_id, message_data in stream_messages:
+                        process_health_check_message(
+                            message_id,
+                            message_data,
+                            health_redis_conn,
+                            logger,
+                            health_stream,
+                            health_group,
+                        )
+
+        except (ConnectionError, RedisTimeoutError, TimeoutError) as e_conn:
+            logger.error(f"Redis connection error: {e_conn}. Reconnecting in 5s...")
+            if health_redis_conn:
+                try:
+                    health_redis_conn.close()
+                except Exception:
+                    pass
+            health_redis_conn = None
+            time.sleep(5)
+
+        except ResponseError as e_resp:
+            logger.error(f"Redis response error: {e_resp}")
+            if "NOGROUP" in str(e_resp):
+                logger.warning(
+                    "Health consumer group disappeared. Attempting to recreate..."
+                )
+                if health_redis_conn:
+                    try:
+                        health_redis_conn.close()
+                    except Exception:
+                        pass
+                health_redis_conn = None
+            elif "UNBLOCKED" in str(e_resp):
+                logger.info(
+                    "XREADGROUP unblocked, connection might have been closed. Reconnecting."
+                )
+                if health_redis_conn:
+                    try:
+                        health_redis_conn.close()
+                    except Exception:
+                        pass
+                health_redis_conn = None
+                time.sleep(1)
+            else:
+                time.sleep(5)
+
+        except KeyboardInterrupt:
+            logger.info("Received interrupt signal. Shutting down health consumer...")
+            break
+
+        except Exception as e:
+            logger.error(f"Unexpected error in health check consumer: {e}")
+            logger.exception("Traceback:")
+            time.sleep(5)
+
+    # Cleanup
+    if health_redis_conn:
+        try:
+            health_redis_conn.close()
+        except Exception:
+            pass
+
+    logger.info("Health check consumer shutdown complete.")
+
+
+if __name__ == "__main__":
+    main()

nebu/processors/decorate.py

@@ -802,7 +802,13 @@ def processor(
         )
         origin = get_origin(param_type) if param_type else None
         args = get_args(param_type) if param_type else tuple()
-        logger.debug(f"Decorator: get_origin result: {origin}, get_args result: {args}")
+        logger.debug(
+            f"Decorator: For param_type '{param_type_str_repr}': origin = {origin!s}, args = {args!s}"
+        )  # More detailed log
+        print(
+            f"Decorator: For param_type '{param_type_str_repr}': origin = {origin!s}, args = {args!s}"
+        )  # More detailed log
+
         is_stream_message = False
         content_type = None
         content_type_name_from_regex = None  # Store regex result here

nebu/processors/processor.py

@@ -311,6 +311,13 @@ class Processor(Generic[InputType, OutputType]):
         )
         response.raise_for_status()
         raw_response_json = response.json()
+
+        if "error" in raw_response_json:
+            raise Exception(raw_response_json["error"])
+
+        if "status" in raw_response_json:
+            return raw_response_json
+
         raw_content = raw_response_json.get("content")
         logger.debug(f">>> Raw content: {raw_content}")
 

{nebu-0.1.115.dist-info → nebu-0.1.117.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.115
+Version: 0.1.117
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown

{nebu-0.1.115.dist-info → nebu-0.1.117.dist-info}/RECORD

@@ -13,16 +13,17 @@ nebu/containers/container.py,sha256=Mrh_gvMsTvDkj3CwpqIPzJ72IMw0gQIg64y548vq0yg,
 nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
 nebu/namespaces/models.py,sha256=EqUOpzhVBhvJw2P92ONDUbIgC31M9jMmcaG5vyOrsWg,497
 nebu/namespaces/namespace.py,sha256=oeZyGqsIGIrppyjif1ZONsdTmqRgd9oSLFE1BChXTTE,5247
-nebu/processors/consumer.py,sha256=9WapzBTPuXRunH-vjPerTlGZy__hn_d4m13l1ajebY8,62732
+nebu/processors/consumer.py,sha256=18p3QKa9AgVdTv-HH3Iu7cwXTw1pjCy5pKuYqYt0Ndc,68524
+nebu/processors/consumer_health_worker.py,sha256=4tS2vyd71tXMCy93Ae_TQi_ESaZVLPO16f9Gf4Eavcg,7946
 nebu/processors/consumer_process_worker.py,sha256=h--eNFKaLbUayxn88mB8oGGdrU2liE1dnwm_TPlewX8,36960
-nebu/processors/decorate.py,sha256=wnos4w7htBUSOnNVyhY7NQgUuz9d2_-Kre5H99UiFpw,61089
+nebu/processors/decorate.py,sha256=5p9pQrk_H8-Fj0UjsgSVCYx7Jk7KFuhMZtNhkKvpmkQ,61306
 nebu/processors/default.py,sha256=cy4ETMdbdRGkrvbYec1o60h7mGDlGN5JsuUph0ENtDU,364
 nebu/processors/models.py,sha256=g4B1t6Rgoy-NUEHBLeQc0EENzHXLDlWSio8Muv7cTDU,4093
-nebu/processors/processor.py,sha256=fMXzodTe2qWnoCBry9nLsHLMEI6FxOOmcsR9DbuY_W0,24574
+nebu/processors/processor.py,sha256=oi9QdpvZV91UzVHz63pBFQw9-BeY7xvtJkJblFF_xew,24753
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.115.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.115.dist-info/METADATA,sha256=tud697lMA-FHCANFaBZKT20hTCyIxRMMQT3ZNdc0tQk,1798
-nebu-0.1.115.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-nebu-0.1.115.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.115.dist-info/RECORD,,
+nebu-0.1.117.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.117.dist-info/METADATA,sha256=T-j8N4SlzlgRjOk8QvUCc6sCUGvdSBllPd45bEghRUw,1798
+nebu-0.1.117.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+nebu-0.1.117.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.117.dist-info/RECORD,,