tinybird 0.0.1.dev311__tar.gz → 0.0.1.dev312__tar.gz

{tinybird-0.0.1.dev311 → tinybird-0.0.1.dev312}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev311
+Version: 0.0.1.dev312
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird

{tinybird-0.0.1.dev311 → tinybird-0.0.1.dev312}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev311'
-__revision__ = 'd56057f'
+__version__ = '0.0.1.dev312'
+__revision__ = '2324ba4'

{tinybird-0.0.1.dev311 → tinybird-0.0.1.dev312}/tinybird/tb/modules/local.py

@@ -10,7 +10,9 @@ from docker.client import DockerClient
 
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import echo_json, update_cli
+from tinybird.tb.modules.exceptions import CLILocalException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
+from tinybird.tb.modules.info import get_local_info
 from tinybird.tb.modules.local_common import (
     TB_CONTAINER_NAME,
     TB_LOCAL_ADDRESS,
@@ -18,6 +20,19 @@ from tinybird.tb.modules.local_common import (
     get_existing_container_with_matching_env,
     start_tinybird_local,
 )
+from tinybird.tb.modules.local_logs import (
+    check_memory_sufficient,
+    clickhouse_is_ready,
+    container_is_ready,
+    container_is_starting,
+    container_is_stopping,
+    container_is_unhealthy,
+    container_stats,
+    events_is_ready,
+    local_authentication_is_ready,
+    redis_is_ready,
+    server_is_ready,
+)
 
 
 def stop_tinybird_local(docker_client: DockerClient) -> None:
@@ -76,30 +91,69 @@ def stop() -> None:
 @click.pass_context
 def status(ctx: click.Context) -> None:
     """Check status of Tinybird Local"""
+
+    click.echo(FeedbackManager.highlight(message="» Checking status..."))
     docker_client = get_docker_client()
     container = get_existing_container_with_matching_env(docker_client, TB_CONTAINER_NAME, {})
 
-    if container:
-        status = container.status
-        health = container.attrs.get("State", {}).get("Health", {}).get("Status")
-
-        if status == "running" and health == "healthy":
-            click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
-            click.echo(FeedbackManager.highlight(message="\n» Tinybird Local:"))
-            from tinybird.tb.modules.info import get_local_info
-
-            config = ctx.ensure_object(dict).get("config", {})
-            get_local_info(config)
-        elif status == "restarting" or (status == "running" and health == "starting"):
-            click.echo(FeedbackManager.highlight(message="* Tinybird Local is starting..."))
-        elif status == "removing":
-            click.echo(FeedbackManager.highlight(message="* Tinybird Local is stopping..."))
+    try:
+        if container:
+            if container_is_ready(container):
+                stats = container_stats(container, docker_client)
+                click.echo(FeedbackManager.info(message=f"✓ Tinybird Local container ({stats})"))
+
+                # Check memory sufficiency
+                is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                if not is_sufficient and warning_msg:
+                    click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+
+                if not clickhouse_is_ready(container):
+                    raise Exception("Clickhouse is not ready.")
+                click.echo(FeedbackManager.info(message="✓ Clickhouse"))
+
+                if not redis_is_ready(container):
+                    raise Exception("Redis is not ready.")
+                click.echo(FeedbackManager.info(message="✓ Redis"))
+
+                if not server_is_ready(container):
+                    raise Exception("Server is not ready.")
+                click.echo(FeedbackManager.info(message="✓ Server"))
+
+                if not events_is_ready(container):
+                    raise Exception("Events is not ready.")
+                click.echo(FeedbackManager.info(message="✓ Events"))
+
+                if not local_authentication_is_ready(container):
+                    raise Exception("Tinybird Local authentication is not ready.")
+                click.echo(FeedbackManager.info(message="✓ Tinybird Local authentication"))
+
+                click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+                click.echo(FeedbackManager.highlight(message="\n» Tinybird Local:"))
+                config = ctx.ensure_object(dict).get("config", {})
+                get_local_info(config)
+            elif container_is_starting(container):
+                click.echo(FeedbackManager.highlight(message="* Tinybird Local is starting..."))
+            elif container_is_stopping(container):
+                click.echo(FeedbackManager.highlight(message="* Tinybird Local is stopping..."))
+            elif container_is_unhealthy(container):
+                is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                if not is_sufficient and warning_msg:
+                    click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                click.echo(
+                    FeedbackManager.error(
+                        message="* Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+                    )
+                )
+            else:
+                click.echo(
+                    FeedbackManager.error(message="✗ Tinybird Local is not running. Run 'tb local start' to start it")
+                )
         else:
             click.echo(
-                FeedbackManager.info(message="✗ Tinybird Local is not running. Run 'tb local start' to start it")
+                FeedbackManager.error(message="✗ Tinybird Local is not running. Run 'tb local start' to start it")
             )
-    else:
-        click.echo(FeedbackManager.info(message="✗ Tinybird Local is not running. Run 'tb local start' to start it"))
+    except Exception as e:
+        raise CLILocalException(FeedbackManager.error(message=f"Tinybird Local is not ready. Reason: {e}"))
 
 
 @local.command()

{tinybird-0.0.1.dev311 → tinybird-0.0.1.dev312}/tinybird/tb/modules/local_common.py

@@ -20,6 +20,15 @@ from tinybird.tb.client import AuthNoTokenException, TinyB
 from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import CLILocalException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
+from tinybird.tb.modules.local_logs import (
+    check_memory_sufficient,
+    clickhouse_is_ready,
+    container_stats,
+    events_is_ready,
+    local_authentication_is_ready,
+    redis_is_ready,
+    server_is_ready,
+)
 from tinybird.tb.modules.secret_common import load_secrets
 from tinybird.tb.modules.telemetry import add_telemetry_event
 
@@ -228,7 +237,7 @@ def get_local_tokens() -> Dict[str, str]:
                 default=True,
             )
             if yes:
-                click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
+                click.echo(FeedbackManager.highlight(message="» Watching Tinybird Local... (Press Ctrl+C to stop)"))
                 docker_client = get_docker_client()
                 start_tinybird_local(docker_client, False)
                 click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
@@ -314,164 +323,84 @@ def start_tinybird_local(
         # Stream logs in a separate thread while monitoring container health
         container_ready = threading.Event()
         stop_requested = threading.Event()
-        health_check_error = {"message": ""}  # Mutable dict to store error message
+        health_check: dict[str, str] = {}
 
-        def check_endpoints_health() -> None:
-            """Continuously check /tokens and /v0/health endpoints"""
-            # Wait for container to be ready before starting health checks
-            container_ready.wait()
-
-            # Give container a moment to fully start up
-            time.sleep(2)
-
-            check_interval = 10  # Check every 10 seconds
-
-            while not stop_requested.is_set():
-                try:
-                    # Check /tokens endpoint
-                    tokens_response = requests.get(f"{TB_LOCAL_ADDRESS}/tokens", timeout=5)
-                    if tokens_response.status_code != 200:
-                        health_check_error["message"] = (
-                            f"/tokens endpoint returned status {tokens_response.status_code}. "
-                            "Tinybird Local may be unhealthy."
-                        )
-                        stop_requested.set()
-                        break
-
-                    # Check /v0/health endpoint
-                    health_response = requests.get(f"{TB_LOCAL_ADDRESS}/v0/health", timeout=5)
-                    if health_response.status_code != 200:
-                        health_check_error["message"] = (
-                            f"/v0/health endpoint returned status {health_response.status_code}. "
-                            "Tinybird Local may be unhealthy."
-                        )
-                        stop_requested.set()
-                        break
-
-                    # Verify tokens response has expected structure
-                    try:
-                        tokens_data = tokens_response.json()
-                        if not all(
-                            key in tokens_data for key in ["user_token", "admin_token", "workspace_admin_token"]
-                        ):
-                            health_check_error["message"] = (
-                                "/tokens endpoint returned unexpected data. Tinybird Local may be unhealthy."
-                            )
-                            stop_requested.set()
-                            break
-                    except json.JSONDecodeError:
-                        health_check_error["message"] = (
-                            "/tokens endpoint returned invalid JSON. Tinybird Local may be unhealthy."
-                        )
-                        stop_requested.set()
-                        break
-
-                except Exception as e:
-                    # Check if it's a connection error
-                    error_str = str(e)
-                    if "connect" in error_str.lower() or "timeout" in error_str.lower():
-                        health_check_error["message"] = f"Failed to connect to Tinybird Local: {error_str}"
-                    else:
-                        health_check_error["message"] = f"Health check failed: {error_str}"
-                    stop_requested.set()
-                    break
-
-                # Wait before next check
-                for _ in range(check_interval):
-                    if stop_requested.is_set():
-                        break
-                    time.sleep(1)
-
-        def stream_logs_with_health_check() -> None:
-            """Stream logs and monitor container health in parallel"""
-            log_names = {
-                "/var/log/tinybird-local-setup.log": "SETUP",
-                "/var/log/tinybird-local-server.log": "SERVER",
-            }
-
-            # Wait briefly for log files to be created
-            retry_count = 0
-            max_retries = 3
-            exec_result = None
-
-            while retry_count < max_retries and not stop_requested.is_set():
-                try:
-                    # Try to tail the log files (only new logs, not historical)
-                    # Use -F to follow by name and retry if files don't exist yet
-                    cmd = ["tail", "-n", "0", "-F", *log_names.keys()]
-                    exec_result = container.exec_run(cmd=cmd, stream=True, tty=False, stdout=True, stderr=True)
-                    break  # Success, exit retry loop
-                except Exception:
-                    # Log file might not exist yet, wait and retry
-                    retry_count += 1
-                    if retry_count < max_retries:
-                        time.sleep(2)
-
-            # If we couldn't start tailing, fall back to container logs
-            if not exec_result and not stop_requested.is_set():
-                try:
-                    for line in container.logs(stream=True, follow=True):
-                        if stop_requested.is_set():
-                            break
-                        click.echo(line.decode("utf-8").rstrip())
-                    return
-                except Exception:
-                    return  # Silently ignore errors in log streaming
-
-            # Stream logs continuously
-            if exec_result:
-                try:
-                    for line in exec_result.output:
-                        if stop_requested.is_set():
-                            break
-
-                        decoded_line = line.decode("utf-8").rstrip()
-
-                        # Skip tail error messages about files not existing yet
-                        if "tail:" in decoded_line and (
-                            "cannot open" in decoded_line or "no files remaining" in decoded_line
-                        ):
-                            continue
-
-                        # Replace file path headers with friendly names
-                        for file_path, friendly_name in log_names.items():
-                            log_header = f"==> {file_path} <=="
-                            if log_header in decoded_line:
-                                decoded_line = decoded_line.replace(log_header, f"==> {friendly_name} <==")
-
-                        # Print "ready" message when container becomes healthy
-                        if container_ready.is_set() and not hasattr(stream_logs_with_health_check, "ready_printed"):
-                            click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
-                            click.echo(
-                                FeedbackManager.highlight(message="» Watching Tinybird Local... (Press Ctrl+C to stop)")
-                            )
-                            stream_logs_with_health_check.ready_printed = True  # type: ignore
-
-                        click.echo(decoded_line)
-                except Exception:
-                    pass  # Silently ignore errors when stream is interrupted
-
-        log_thread = threading.Thread(target=stream_logs_with_health_check, daemon=True)
+        log_thread = threading.Thread(
+            target=stream_logs_with_health_check,
+            args=(container, container_ready, stop_requested),
+            daemon=True,
+        )
         log_thread.start()
 
-        health_check_thread = threading.Thread(target=check_endpoints_health, daemon=True)
+        health_check_thread = threading.Thread(
+            target=check_endpoints_health,
+            args=(container, docker_client, container_ready, stop_requested, health_check),
+            daemon=True,
+        )
         health_check_thread.start()
 
         # Monitor container health in main thread
+        memory_warning_shown = False
         try:
             while True:
                 container.reload()  # Refresh container attributes
                 health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+                if not container_ready.is_set():
+                    click.echo(FeedbackManager.info(message=f"* Tinybird Local container status: {health}"))
+                    stats = container_stats(container, docker_client)
+                    click.echo(f"* {stats}")
+
+                    # Check memory sufficiency
+                    if not memory_warning_shown:
+                        is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                        if not is_sufficient and warning_msg:
+                            click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                            raise CLILocalException(
+                                FeedbackManager.error(
+                                    message="Tinybird Local is unhealthy. Adjust memory and try again."
+                                )
+                            )
+
                 if health == "healthy":
+                    click.echo(FeedbackManager.highlight(message="» Checking services..."))
+                    stats = container_stats(container, docker_client)
+                    click.echo(FeedbackManager.info(message=f"✓ Tinybird Local container ({stats})"))
+
+                    # Check memory sufficiency before checking services
+                    if not memory_warning_shown:
+                        is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                        if not is_sufficient and warning_msg:
+                            click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                            memory_warning_shown = True
+
+                    if not clickhouse_is_ready(container):
+                        raise Exception("Clickhouse is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Clickhouse"))
+
+                    if not redis_is_ready(container):
+                        raise Exception("Redis is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Redis"))
+
+                    if not server_is_ready(container):
+                        raise Exception("Server is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Server"))
+
+                    if not events_is_ready(container):
+                        raise Exception("Events is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Events"))
+
+                    if not local_authentication_is_ready(container):
+                        raise Exception("Tinybird Local authentication is not ready.")
+                    click.echo(FeedbackManager.info(message="✓ Tinybird Local authentication"))
                     container_ready.set()
                     # Keep monitoring and streaming logs until Ctrl+C or health check failure
                     while True:
                         # Check if health check detected an error
-                        if stop_requested.is_set() and health_check_error["message"]:
+                        if stop_requested.is_set() and health_check.get("error"):
                             time.sleep(0.5)  # Give log thread time to finish printing
-                            click.echo(
+                            raise CLILocalException(
                                 FeedbackManager.error(
-                                    message=f"\n✗ {health_check_error['message']}\n"
+                                    message=f"{health_check.get('error')}\n"
                                     "Please run `tb local restart` to restart the container."
                                 )
                             )
@@ -479,31 +408,70 @@ def start_tinybird_local(
                         time.sleep(1)
                 if health == "unhealthy":
                     stop_requested.set()
-                    raise CLILocalException(
-                        FeedbackManager.error(
-                            message="Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+                    # Check if memory might be the cause of unhealthy status
+                    is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+                    error_msg = "Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+                    if not is_sufficient and warning_msg:
+                        error_msg = (
+                            "Tinybird Local is unhealthy.\nnAfter adjusting memory, try running `tb local restart`."
                         )
-                    )
+                    raise CLILocalException(FeedbackManager.error(message=error_msg))
                 time.sleep(5)
         except KeyboardInterrupt:
             stop_requested.set()
             click.echo(FeedbackManager.highlight(message="» Stopping Tinybird Local..."))
-            container.stop()
-            click.echo(FeedbackManager.success(message="✓ Tinybird Local stopped."))
+            try:
+                container.stop()
+                click.echo(FeedbackManager.success(message="✓ Tinybird Local stopped."))
+            except KeyboardInterrupt:
+                click.echo(FeedbackManager.warning(message="⚠ Forced exit. Container may still be running."))
+                click.echo(FeedbackManager.info(message="  Run `tb local stop` to stop the container manually."))
             return
 
     # Non-watch mode: just wait for container to be healthy
+    memory_warning_shown = False
     while True:
         container.reload()  # Refresh container attributes
         health = container.attrs.get("State", {}).get("Health", {}).get("Status")
+        click.echo(FeedbackManager.info(message=f"* Tinybird Local container status: {health}"))
+        stats = container_stats(container, docker_client)
+        click.echo(f"* {stats}")
+
+        # Check memory sufficiency
+        if not memory_warning_shown:
+            is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+            if not is_sufficient and warning_msg:
+                click.echo(FeedbackManager.warning(message=f"△ {warning_msg}"))
+                memory_warning_shown = True
+                raise CLILocalException(
+                    FeedbackManager.error(message="Tinybird Local is unhealthy. Adjust memory and try again.")
+                )
+
         if health == "healthy":
+            click.echo(FeedbackManager.highlight(message="» Checking services..."))
+            stats = container_stats(container, docker_client)
+            click.echo(FeedbackManager.info(message=f"✓ Tinybird Local container ({stats})"))
+            if not clickhouse_is_ready(container):
+                raise Exception("Clickhouse is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Clickhouse"))
+            if not redis_is_ready(container):
+                raise Exception("Redis is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Redis"))
+            if not server_is_ready(container):
+                raise Exception("Server is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Server"))
+            if not events_is_ready(container):
+                raise Exception("Events is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Events"))
+            if not local_authentication_is_ready(container):
+                raise Exception("Tinybird Local authentication is not ready.")
+            click.echo(FeedbackManager.info(message="✓ Tinybird Local authentication"))
             break
         if health == "unhealthy":
-            raise CLILocalException(
-                FeedbackManager.error(
-                    message="Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
-                )
-            )
+            # Check if memory might be the cause of unhealthy status
+            is_sufficient, warning_msg = check_memory_sufficient(container, docker_client)
+            error_msg = "Tinybird Local is unhealthy. Try running `tb local restart` in a few seconds."
+            raise CLILocalException(FeedbackManager.error(message=error_msg))
         time.sleep(5)
 
     # Remove tinybird-local dangling images to avoid running out of disk space
@@ -667,3 +635,157 @@ def get_use_aws_creds() -> dict[str, str]:
         )
 
     return credentials
+
+
+SERVICE_COLORS = {
+    "[EVENTS]": "\033[95m",  # Magenta
+    "[SERVER]": "\033[94m",  # Blue
+    "[HEALTH]": "\033[96m",  # Cyan
+    "[KAFKA]": "\033[93m",  # Yellow
+    "[AUTH]": "\033[90m",  # Gray
+}
+
+RESET = "\033[0m"
+
+
+def check_endpoints_health(
+    container: Container,
+    docker_client: DockerClient,
+    container_ready: threading.Event,
+    stop_requested: threading.Event,
+    health_check: dict[str, str],
+) -> None:
+    """Continuously check /tokens and /v0/health endpoints"""
+    # Wait for container to be ready before starting health checks
+    container_ready.wait()
+
+    # Give container a moment to fully start up
+    time.sleep(2)
+
+    check_interval = 10  # Check every 10 seconds
+
+    while not stop_requested.is_set():
+        try:
+            # Check /tokens endpoint
+            tokens_response = requests.get(f"{TB_LOCAL_ADDRESS}/tokens", timeout=5)
+            if tokens_response.status_code != 200:
+                health_check["error"] = (
+                    f"/tokens endpoint returned status {tokens_response.status_code}. Tinybird Local may be unhealthy."
+                )
+                stop_requested.set()
+                break
+
+            # Check /v0/health endpoint
+            health_response = requests.get(f"{TB_LOCAL_ADDRESS}/v0/health", timeout=5)
+            if health_response.status_code != 200:
+                health_check["error"] = (
+                    f"/v0/health endpoint returned status {health_response.status_code}. "
+                    "Tinybird Local may be unhealthy."
+                )
+                stop_requested.set()
+                break
+
+            # Verify tokens response has expected structure
+            try:
+                tokens_data = tokens_response.json()
+                if not all(key in tokens_data for key in ["user_token", "admin_token", "workspace_admin_token"]):
+                    health_check["error"] = (
+                        "/tokens endpoint returned unexpected data. Tinybird Local may be unhealthy."
+                    )
+                    stop_requested.set()
+                    break
+            except json.JSONDecodeError:
+                health_check["error"] = "/tokens endpoint returned invalid JSON. Tinybird Local may be unhealthy."
+                stop_requested.set()
+                break
+
+        except Exception as e:
+            # Check if it's a connection error
+            error_str = str(e)
+            if "connect" in error_str.lower() or "timeout" in error_str.lower():
+                health_check["error"] = f"Failed to connect to Tinybird Local: {error_str}"
+            else:
+                health_check["error"] = f"Health check failed: {error_str}"
+            stop_requested.set()
+            break
+
+        if container_ready.is_set():
+            stats = container_stats(container, docker_client)
+            click.echo(f"{SERVICE_COLORS['[HEALTH]']}[HEALTH]{RESET} {stats}")
+
+        # Wait before next check
+        for _ in range(check_interval):
+            if stop_requested.is_set():
+                break
+            time.sleep(1)
+
+
+def stream_logs_with_health_check(
+    container: Container, container_ready: threading.Event, stop_requested: threading.Event
+) -> None:
+    """Stream logs and monitor container health in parallel"""
+    # Wait for container to be ready before starting health checks
+    container_ready.wait()
+
+    # Give container a moment to fully start up
+    time.sleep(2)
+
+    retry_count = 0
+    max_retries = 10
+    exec_result = None
+
+    while retry_count < max_retries and not stop_requested.is_set():
+        try:
+            # Try to tail the log files (only new logs, not historical)
+            # Use -F to follow by name and retry if files don't exist yet
+            log_files = {
+                "/var/log/tinybird-local-server.log": "SERVER",
+                "/var/log/tinybird-local-hfi.log": "EVENTS",
+                "/var/log/tinybird-local-setup.log": "AUTH",
+                "/var/log/tinybird-local-kafka.log": "KAFKA",
+            }
+            # Build commands to tail each file and prefix with its label (using stdbuf for unbuffered output)
+            tail_commands = [
+                f'tail -n 0 -f {path} | stdbuf -oL sed "s/^/[{source}] /"' for path, source in log_files.items()
+            ]
+            # Join with & to run in parallel, then wait for all
+            cmd = f"sh -c '({' & '.join(tail_commands)}) & wait'"
+            exec_result = container.exec_run(cmd, stream=True, tty=False, stdout=True, stderr=True)
+            break  # Success, exit retry loop
+        except Exception:
+            # Log file might not exist yet, wait and retry
+            retry_count += 1
+            if retry_count < max_retries:
+                time.sleep(2)
+
+    # Stream logs continuously
+    if exec_result:
+        try:
+            for line in exec_result.output:
+                if stop_requested.is_set():
+                    break
+
+                raw_line = line.decode("utf-8").rstrip()
+                lines = raw_line.split("\n")
+
+                # Print "ready" message when container becomes healthy
+                if container_ready.is_set() and not hasattr(stream_logs_with_health_check, "ready_printed"):
+                    click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+                    stream_logs_with_health_check.ready_printed = True  # type: ignore
+
+                for line in lines:
+                    # Apply color to service label
+                    for service, color in SERVICE_COLORS.items():
+                        if line.startswith(service):
+                            message = line[len(service) :]
+                            # extract content of message="...""
+                            match = re.search(r'message="([^"]*)"', message)
+                            if match:
+                                message = match.group(1)
+                            line = f"{color}{service}{RESET} {message}"
+                            break
+
+                    click.echo(line)
+
+        except Exception:
+            pass  # Silently ignore errors when stream is interrupted