nebu 0.1.116__tar.gz → 0.1.118__tar.gz

{nebu-0.1.116/src/nebu.egg-info → nebu-0.1.118}/PKG-INFO

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

{nebu-0.1.116 → nebu-0.1.118}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nebu"
-version = "0.1.116"
+version = "0.1.118"
 description = "A globally distributed container runtime"
 readme = "README.md"
 requires-python = ">=3.10.14"

{nebu-0.1.116 → nebu-0.1.118}/src/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-0.1.118/src/nebu/processors/consumer_health_worker.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+import json
+import logging
+import os
+import socket
+import sys
+import time
+from typing import Any, Dict, List, Optional, Tuple, cast
+
+import redis
+import socks
+from redis import ConnectionError, ResponseError
+from redis.exceptions import TimeoutError as RedisTimeoutError
+
+# Assuming these are imported from other modules
+from nebu.processors.models import V1ProcessorHealthResponse
+
+
+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}")
+
+    health_status = "ok"
+    health_message: Optional[str] = "Health check processed successfully."
+    details: Optional[Dict[str, Any]] = None
+    return_stream: Optional[str] = None
+
+    try:
+        if "data" in message_data:
+            data = json.loads(message_data["data"])
+            logger.info(f"Health check data: {data}")
+            # Example: Extract return_stream if present in the health check data
+            return_stream = data.get("return_stream")
+            # Example: Update details if provided
+            if "check_details" in data:
+                details = {"processed_details": data["check_details"]}
+
+    except (json.JSONDecodeError, KeyError) as e:
+        logger.warning(f"Could not parse health check message data: {e}")
+        health_status = "error"
+        health_message = f"Failed to parse health check message data: {e}"
+        details = {"error": str(e)}
+
+    # Construct the health response
+    health_response = V1ProcessorHealthResponse(
+        status=health_status, message=health_message, details=details
+    )
+
+    logger.info(
+        f"Health response for message {message_id}: {health_response.model_dump_json()}"
+    )
+
+    # If a return_stream is specified, send the response there
+    if return_stream:
+        try:
+            # It's good practice to set a maxlen for the return stream to prevent it from growing indefinitely
+            redis_conn.xadd(
+                return_stream,
+                health_response.model_dump(),  # type: ignore[arg-type]
+                maxlen=1000,
+                approximate=True,
+            )
+            logger.info(
+                f"Sent health response for {message_id} to stream: {return_stream}"
+            )
+        except Exception as e_resp_send:
+            logger.error(
+                f"Failed to send health response for {message_id} to stream {return_stream}: {e_resp_send}"
+            )
+
+    # 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-0.1.116 → nebu-0.1.118}/src/nebu/processors/models.py

@@ -149,3 +149,9 @@ class V1OpenAIStreamResponse(BaseModel):
     content: Any  # Using Any for ChatCompletionResponse
     created_at: int
     user_id: Optional[str] = None
+
+
+class V1ProcessorHealthResponse(BaseModel):
+    status: str
+    message: Optional[str] = None
+    details: Optional[Any] = None

{nebu-0.1.116 → nebu-0.1.118}/src/nebu/processors/processor.py

@@ -1,7 +1,8 @@
 import json
 import threading
 import time
-import uuid
+
+# import uuid # Removed unused import
 from typing import (
     Any,
     Dict,
@@ -23,6 +24,7 @@ from nebu.meta import V1ResourceMetaRequest, V1ResourceReference
 from nebu.processors.models import (
     V1ContainerRequest,
     V1Processor,
+    V1ProcessorHealthResponse,
     V1ProcessorRequest,
     V1Processors,
     V1ProcessorScaleRequest,
@@ -246,7 +248,7 @@ class Processor(Generic[InputType, OutputType]):
 
         # --- Wait for health check if requested ---
         if wait_for_healthy:
-            self.wait_for_health_check()
+            self.wait_for_healthy()
 
     def __call__(
         self,
@@ -315,6 +317,9 @@ class Processor(Generic[InputType, OutputType]):
         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}")
 
@@ -556,11 +561,11 @@ class Processor(Generic[InputType, OutputType]):
         else:
             logger.info(f"No active log stream to stop for {self.name}.")
 
-    def wait_for_health_check(
+    def wait_for_healthy(
         self, timeout: float = 3600.0, retry_interval: float = 5.0
     ) -> None:
         """
-        Wait for the processor to respond to health checks.
+        Wait for the processor to respond to health checks using the health endpoint.
 
         Args:
             timeout: Maximum time to wait for health check in seconds
@@ -570,40 +575,25 @@ class Processor(Generic[InputType, OutputType]):
             raise ValueError("Processor not found, cannot perform health check")
 
         logger.info(
-            f"Waiting for processor {self.processor.metadata.name} to be healthy..."
+            f"Waiting for processor {self.processor.metadata.name} to be healthy via health endpoint..."
         )
 
         start_time = time.time()
         while time.time() - start_time < timeout:
             try:
-                # Create a health check message
-                health_check_data = {
-                    "kind": "HealthCheck",
-                    "id": str(uuid.uuid4()),
-                    "content": {},
-                    "created_at": time.time(),
-                }
-
-                # Send health check and wait for response
-                response = self.send(
-                    data=health_check_data,  # type: ignore[arg-type]
-                    wait=True,
-                    timeout=30.0,  # Short timeout for individual health check
+                health_response = self.health()  # Use the new health() method
+                logger.info(
+                    f">>> Health check response: {health_response.model_dump_json()}"
                 )
-                logger.info(f">>> Health check response: {response}")
 
                 # Check if the response indicates health
-                if response and isinstance(response, dict):
-                    status = response.get("status")
-                    if status == "healthy":
-                        logger.info(
-                            f"Processor {self.processor.metadata.name} is healthy!"
-                        )
-                        return
-
-                logger.info(
-                    f"Health check attempt failed, retrying in {retry_interval}s..."
-                )
+                if health_response.status == "ok":  # Check for "ok" status
+                    logger.info(f"Processor {self.processor.metadata.name} is healthy!")
+                    return
+                else:
+                    logger.info(
+                        f"Processor {self.processor.metadata.name} reported status: {health_response.status}. Retrying in {retry_interval}s..."
+                    )
 
             except Exception as e:
                 logger.info(
@@ -616,3 +606,39 @@ class Processor(Generic[InputType, OutputType]):
         raise TimeoutError(
             f"Processor {self.processor.metadata.name} failed to become healthy within {timeout} seconds"
         )
+
+    def health(self) -> V1ProcessorHealthResponse:
+        """
+        Performs a health check on the processor by calling the health endpoint.
+        """
+        if (
+            not self.processor
+            or not self.processor.metadata.name
+            or not self.processor.metadata.namespace
+        ):
+            raise ValueError(
+                "Processor not found or missing metadata (name/namespace), cannot perform health check."
+            )
+
+        health_url = f"{self.orign_host}/v1/processors/{self.processor.metadata.namespace}/{self.processor.metadata.name}/health"
+        logger.debug(f"Calling health check endpoint: {health_url}")
+
+        try:
+            response = requests.get(
+                health_url,
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                timeout=30.0,  # Standard timeout for a health check
+            )
+            response.raise_for_status()  # Raise an exception for HTTP errors
+            health_response_data = response.json()
+            return V1ProcessorHealthResponse.model_validate(health_response_data)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Health check request to {health_url} failed: {e}")
+            # Optionally, return a V1ProcessorHealthResponse indicating an error
+            # For now, re-raising the exception or a custom one might be better
+            raise RuntimeError(f"Failed to get health status: {e}") from e
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during health check: {e}")
+            raise RuntimeError(
+                f"Unexpected error during health status retrieval: {e}"
+            ) from e

{nebu-0.1.116 → nebu-0.1.118/src/nebu.egg-info}/PKG-INFO

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

{nebu-0.1.116 → nebu-0.1.118}/src/nebu.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ src/nebu/containers/models.py
 src/nebu/namespaces/models.py
 src/nebu/namespaces/namespace.py
 src/nebu/processors/consumer.py
+src/nebu/processors/consumer_health_worker.py
 src/nebu/processors/consumer_process_worker.py
 src/nebu/processors/decorate.py
 src/nebu/processors/default.py