tinybird 0.0.1.dev291__py3-none-any.whl → 1.0.5__py3-none-any.whl

tinybird/tb/modules/local.py

@@ -1,12 +1,18 @@
+import json
+import uuid
 from pathlib import Path
+from typing import Any
 
 import click
+import jwt
 import requests
-
 from docker.client import DockerClient
+
 from tinybird.tb.modules.cli import cli
-from tinybird.tb.modules.common import update_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,
@@ -14,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:
@@ -72,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()
@@ -125,7 +183,33 @@ def remove() -> None:
     is_flag=True,
     help="Skip pulling the latest Tinybird Local image. Use directly your current local image.",
 )
-def start(use_aws_creds: bool, volumes_path: str, skip_new_version: bool) -> None:
+@click.option(
+    "--user-token",
+    default=None,
+    envvar="TB_LOCAL_USER_TOKEN",
+    help="User token to use for the Tinybird Local container.",
+)
+@click.option(
+    "--workspace-token",
+    default=None,
+    envvar="TB_LOCAL_WORKSPACE_TOKEN",
+    help="Workspace token to use for the Tinybird Local container.",
+)
+@click.option(
+    "--daemon/--watch",
+    "-d/-w",
+    default=False,
+    is_flag=True,
+    help="Run Tinybird Local in the background.",
+)
+def start(
+    use_aws_creds: bool,
+    volumes_path: str,
+    skip_new_version: bool,
+    user_token: str,
+    workspace_token: str,
+    daemon: bool,
+) -> None:
     """Start Tinybird Local"""
     if volumes_path is not None:
         absolute_path = Path(volumes_path).absolute()
@@ -134,8 +218,12 @@ def start(use_aws_creds: bool, volumes_path: str, skip_new_version: bool) -> Non
 
     click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
     docker_client = get_docker_client()
-    start_tinybird_local(docker_client, use_aws_creds, volumes_path, skip_new_version)
-    click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
+    watch = not daemon
+    start_tinybird_local(
+        docker_client, use_aws_creds, volumes_path, skip_new_version, user_token, workspace_token, watch=watch
+    )
+    if daemon:
+        click.echo(FeedbackManager.success(message="✓ Tinybird Local is ready!"))
 
 
 @local.command()
@@ -183,3 +271,35 @@ def version() -> None:
     """Show Tinybird Local version"""
     response = requests.get(f"{TB_LOCAL_ADDRESS}/version")
     click.echo(FeedbackManager.success(message=f"✓ Tinybird Local version: {response.text}"))
+
+
+@local.command()
+@click.pass_context
+def generate_tokens(ctx: click.Context) -> None:
+    """Generate static tokens for initializing Tinybird Local"""
+    output = ctx.ensure_object(dict).get("output")
+    user_id = str(uuid.uuid4())
+    workspace_id = str(uuid.uuid4())
+    user_token_id = str(uuid.uuid4())
+    workspace_token_id = str(uuid.uuid4())
+    payload = {"u": user_id, "id": user_token_id, "host": None}
+    user_token = generate_token(payload)
+    payload = {"u": workspace_id, "id": workspace_token_id, "host": None}
+    workspace_token = generate_token(payload)
+
+    if output == "json":
+        echo_json({"workspace_token": workspace_token, "user_token": user_token})
+    else:
+        click.echo(FeedbackManager.gray(message="Workspace token: ") + FeedbackManager.info(message=workspace_token))
+        click.echo(FeedbackManager.gray(message="User token: ") + FeedbackManager.info(message=user_token))
+        click.echo(FeedbackManager.success(message="✓ Tinybird Local tokens generated!"))
+
+
+def generate_token(payload: dict[str, Any]) -> str:
+    algo = jwt.algorithms.get_default_algorithms()["HS256"]
+    msg = json.dumps(payload)
+    msg_base64 = jwt.utils.base64url_encode(msg.encode())
+    sign_key = algo.prepare_key("abcd")
+    signature = algo.sign(msg_base64, sign_key)
+    token = msg_base64 + b"." + jwt.utils.base64url_encode(signature)
+    return "p." + token.decode()

tinybird/tb/modules/local_common.py

@@ -4,20 +4,31 @@ import logging
 import os
 import re
 import subprocess
+import threading
 import time
+import uuid
 from typing import Any, Dict, Optional
 
 import boto3
 import click
 import requests
-
-import docker
 from docker.client import DockerClient
 from docker.models.containers import Container
+
+import docker
 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
 
@@ -34,11 +45,18 @@ def get_tinybird_local_client(
     config_obj: Dict[str, Any], test: bool = False, staging: bool = False, silent: bool = False
 ) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
-
-    config = get_tinybird_local_config(config_obj, test=test, silent=silent)
-    client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
-    load_secrets(config_obj.get("path", ""), client)
-    return client
+    try:
+        config = get_tinybird_local_config(config_obj, test=test, silent=silent)
+        client = config.get_client(host=TB_LOCAL_ADDRESS, staging=staging)
+        load_secrets(config_obj.get("path", ""), client)
+        return client
+    # if some of the API calls to tinybird local fail due to a JSONDecodeError, it means that container is running but it's unhealthy
+    except json.JSONDecodeError:
+        raise CLILocalException(
+            message=FeedbackManager.error(
+                message="Tinybird Local is running but it's unhealthy. Please check if it's running and try again. If the problem persists, please run `tb local restart` and try again."
+            )
+        )
 
 
 def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, silent: bool = False) -> CLIConfig:
@@ -56,6 +74,18 @@ def get_tinybird_local_config(config_obj: Dict[str, Any], test: bool = False, si
     if path:
         user_client = config.get_client(host=TB_LOCAL_ADDRESS, token=user_token)
         if test:
+            # delete any Tinybird_Local_Test_* workspace
+            user_workspaces = requests.get(
+                f"{TB_LOCAL_ADDRESS}/v1/user/workspaces?with_organization=true&token={admin_token}"
+            ).json()
+            local_workspaces = user_workspaces.get("workspaces", [])
+            for ws in local_workspaces:
+                is_test_workspace = ws["name"].startswith("Tinybird_Local_Test_")
+                if is_test_workspace:
+                    requests.delete(
+                        f"{TB_LOCAL_ADDRESS}/v1/workspaces/{ws['id']}?token={user_token}&hard_delete_confirmation=yes"
+                    )
+
             ws_name = get_test_workspace_name(path)
         else:
             ws_name = config.get("name") or config_obj.get("name") or get_build_workspace_name(path)
@@ -104,8 +134,8 @@ def get_build_workspace_name(path: str) -> str:
 
 
 def get_test_workspace_name(path: str) -> str:
-    folder_hash = hashlib.sha256(path.encode()).hexdigest()
-    return f"Tinybird_Local_Test_{folder_hash}"
+    random_folder_suffix = str(uuid.uuid4()).replace("-", "_")
+    return f"Tinybird_Local_Test_{random_folder_suffix}"
 
 
 def get_local_tokens() -> Dict[str, str]:
@@ -127,6 +157,7 @@ def get_local_tokens() -> Dict[str, str]:
                 },
             )
 
+            # TODO: If docker errors persist, explain that you can use custom environments too once they are open for everyone
             if container and container.status == "running":
                 if container.health == "healthy":
                     raise CLILocalException(
@@ -206,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!"))
@@ -221,7 +252,10 @@ def start_tinybird_local(
     docker_client: DockerClient,
     use_aws_creds: bool,
     volumes_path: Optional[str] = None,
-    skip_new_version: bool = False,
+    skip_new_version: bool = True,
+    user_token: Optional[str] = None,
+    workspace_token: Optional[str] = None,
+    watch: bool = False,
 ) -> None:
     """Start the Tinybird container."""
     pull_show_prompt = False
@@ -248,7 +282,13 @@ def start_tinybird_local(
         if pull_required:
             docker_client.images.pull(TB_IMAGE_NAME, platform="linux/amd64")
 
-    environment = get_use_aws_creds() if use_aws_creds else {}
+    environment = {}
+    if use_aws_creds:
+        environment.update(get_use_aws_creds())
+    if user_token:
+        environment["TB_LOCAL_USER_TOKEN"] = user_token
+    if workspace_token:
+        environment["TB_LOCAL_WORKSPACE_TOKEN"] = workspace_token
 
     container = get_existing_container_with_matching_env(docker_client, TB_CONTAINER_NAME, environment)
 
@@ -278,18 +318,151 @@ def start_tinybird_local(
         )
 
     click.echo(FeedbackManager.info(message="* Waiting for Tinybird Local to be ready..."))
+
+    if watch:
+        # Stream logs in a separate thread while monitoring container health
+        container_ready = threading.Event()
+        stop_requested = threading.Event()
+        health_check: dict[str, str] = {}
+
+        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,
+            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}"))
+                            memory_warning_shown = True
+
+                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.get("error"):
+                            time.sleep(0.5)  # Give log thread time to finish printing
+                            raise CLILocalException(
+                                FeedbackManager.error(
+                                    message=f"{health_check.get('error')}\n"
+                                    "Please run `tb local restart` to restart the container."
+                                )
+                            )
+                            return
+                        time.sleep(1)
+                if health == "unhealthy":
+                    stop_requested.set()
+                    # 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..."))
+            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
+
         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."
-                )
-            )
-
+            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
@@ -408,7 +581,8 @@ def get_docker_client() -> DockerClient:
                 message=(
                     f"No container runtime is running. Make sure a Docker-compatible runtime is installed and running. "
                     f"{docker_location_message}\n\n"
-                    "If you're using a custom location, please provide it using the DOCKER_HOST environment variable."
+                    "If you're using a custom location, please provide it using the DOCKER_HOST environment variable.\n\n"
+                    "Alternatively, you can use Tinybird branches to develop your project without Docker. Run `tb branch create my_feature_branch` to create one. Learn more at: https://www.tinybird.co/docs/forward/test-and-deploy/branches"
                 )
             )
         )
@@ -453,3 +627,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