devservices 1.0.16__tar.gz → 1.0.18__tar.gz

{devservices-1.0.16 → devservices-1.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: devservices
-Version: 1.0.16
+Version: 1.0.18
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml
@@ -13,3 +13,4 @@ Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
+Dynamic: license-file

devservices-1.0.18/README.md

@@ -0,0 +1,145 @@
+# devservices
+
+A standalone cli tool used to manage dependencies for services. It simplifies the process of managing services for development purposes and bringing services up/down.
+
+## Overview
+
+`devservices` reads configuration files located in the `devservices` directory of your repository. These configurations define services, their dependencies, and various modes of operation.
+
+## Usage
+
+devservices provides several commands to manage your services:
+
+### Commands
+
+NOTE: service-name is an optional parameter. If not provided, devservices will attempt to automatically find a devservices configuration in the current directory in order to proceed.
+
+- `devservices up <service-name>`: Bring up a service and its dependencies.
+- `devservices down <service-name>`: Bring down service including its dependencies.
+- `devservices status <service-name>`: Display the current status of all services, including their dependencies and ports.
+- `devservices logs <service-name>`: View logs for a specific service.
+- `devservices list-services`: List all available Sentry services.
+- `devservices list-dependencies <service-name>`: List all dependencies for a service and whether they are enabled/disabled.
+- `devservices update` Update devservices to the latest version.
+- `devservices purge`: Purge the local devservices cache.
+
+## Installation
+
+### 1. Add devservices to your requirements.txt
+
+The recommended way to install devservices is through a virtualenv in the requirements.txt. Once that is installed and a devservices config file is added, you should be able to run `devservices up` to begin local development.
+
+```
+devservices==1.0.18
+```
+
+### 2. Add devservices config files
+
+Each repo should have a `devservices` directory with a `config.yml` file. This file is used to define services, dependencies, and modes. Other files and subdirectories in the `devservices` directory are optional and can be most commonly used for volume mounts.
+
+The configuration file is a yaml file that looks like this:
+
+```yaml
+# This is a yaml block that holds devservices specific configuration settings. This is comprised of a few main sections:
+# - version: The version of the devservices config file. This is used to ensure compatibility between devservices and the config file.
+# - service_name: The name of the service. This is used to identify the service in the config file.
+# - dependencies: A list of dependencies for the service. Each dependency is a yaml block that holds the dependency configuration. There are two types of dependencies:
+#   - local: A dependency that is defined in the config file. These dependencies do not have a remote field. These dependency definitions are specific to the service and are not defined elsewhere.
+#   - remote: A dependency that is defined in the devservices directory in a remote repository. These configs are automatically fetched from the remote repository and installed. Any dependency with a remote field will be treated as a remote dependency. Example: https://github.com/getsentry/snuba/blob/59a5258ccbb502827ebc1d3b1bf80c607a3301bf/devservices/config.yml#L8
+# - modes: A list of modes for the service. Each mode includes a list of dependencies that are used in that mode.
+x-sentry-service-config:
+  version: 0.1
+  service_name: example-service
+  dependencies:
+    example-dependency-1:
+      description: Example dependency defined in the config file
+    example-dependency-2:
+      description: Example dependency defined in the config file
+    example-remote-dependency:
+      description: Remote dependency defined in the `devservices` directory in the example-repository repo
+      remote:
+        repo_name: example-repository
+        branch: main
+        repo_link: https://github.com/getsentry/example-repository.git
+        mode: default # Optional field, mode to run remote dependency in that defaults to `default`
+  modes:
+    default: [example-dependency-1, example-remote-dependency]
+    custom-mode: [example-dependency-1, example-dependency-2, example-remote-dependency]
+
+# This will be a standard block used by docker compose to define dependencies.
+#
+# The following fields are important to all dependencies:
+# - image: The docker image to use for the dependency.
+# - ports: The ports to expose for the dependency. Please only expose ports to localhost(127.0.0.1)
+# - healthcheck: The docker healthcheck to use for the dependency.
+# - environment: The environment variables to set for the dependency.
+# - extra_hosts: The extra hosts to add to the dependency.
+# - networks: The networks to add to the dependency. In order for devservices to work properly, the dependency must be on the `devservices` network.
+# - labels: The labels to add to the dependency. The `orchestrator=devservices` label is required for devservices to determine a container is managed by devservices.
+# - restart: The restart policy to use for the dependency.
+#
+# These fields are optional:
+# - ulimits: The ulimits to set for the dependency. This is useful for setting resource constraints for the dependency.
+# - volumes: The volumes to mount for the dependency. This is useful for mounting data volumes for the dependency if data should be persisted between runs. It can also be useful to use a bind mount to mount a local directory into a container. Example of bind mounting clickhouse configs from a local directory https://github.com/getsentry/snuba/blob/59a5258ccbb502827ebc1d3b1bf80c607a3301bf/devservices/config.yml#L44
+# - command: The command to run for the dependency. This can override the default command for the docker image.
+# For more information on the docker compose file services block, see the docker compose file reference: https://docs.docker.com/reference/compose-file/services/
+services:
+  example-dependency-1:
+    image: ghcr.io/getsentry/example-dependency-1:1.0.0
+    ulimits:
+      nofile:
+        soft: 262144
+        hard: 262144
+    healthcheck:
+      test: wget -q -O - http://localhost:1234/health
+      interval: 5s
+      timeout: 5s
+      retries: 3
+    environment:
+      EXAMPLE_ENV_VAR: example-value
+    volumes:
+      - example-dependency-1-data:/var/lib/example-dependency-1
+    restart: unless-stopped
+    # Everything below this line is required for devservices to work properly.
+    ports:
+      - 127.0.0.1:1234:1234
+    extra_hosts:
+      host.docker.internal: host-gateway
+    networks:
+      - devservices
+    labels:
+      - orchestrator=devservices
+
+  example-dependency-2:
+    image: ghcr.io/getsentry/example-dependency-2:1.0.0
+    command: ["devserver"]
+    healthcheck:
+      test: curl -f http://localhost:2345/health
+      interval: 5s
+      timeout: 5s
+      retries: 3
+    environment:
+      EXAMPLE_ENV_VAR: example-value
+    restart: unless-stopped
+    # Everything below this line is required for devservices to work properly.
+    ports:
+      - 127.0.0.1:2345:2345
+    extra_hosts:
+      host.docker.internal: host-gateway
+    networks:
+      - devservices
+    labels:
+      - orchestrator=devservices
+
+# This is a standard block used by docker compose to define volumes.
+# For more information, see the docker compose file reference: https://docs.docker.com/reference/compose-file/volumes/
+volumes:
+  example-dependency-1-data:
+
+# This is a standard block used by docker compose to define networks. Defining the devservices network is required for devservices to work properly. By default, devservices will create an external network called `devservices` that is used to connect all dependencies.
+# For more information, see the docker compose file reference: https://docs.docker.com/reference/compose-file/networks/
+networks:
+  devservices:
+    name: devservices
+    external: true
+```

{devservices-1.0.16 → devservices-1.0.18}/devservices/commands/down.py

@@ -30,6 +30,7 @@ from devservices.utils.docker_compose import get_docker_compose_commands_to_run
 from devservices.utils.docker_compose import run_cmd
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
+from devservices.utils.state import ServiceRuntime
 from devservices.utils.state import State
 from devservices.utils.state import StateTables
 
@@ -60,7 +61,7 @@ def down(args: Namespace) -> None:
     try:
         service = find_matching_service(service_name)
     except ConfigNotFoundError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure(
             f"{str(e)}. Please specify a service (i.e. `devservices down sentry`) or run the command from a directory with a devservices configuration."
         )
@@ -122,33 +123,23 @@ def down(args: Namespace) -> None:
         # Check if any service depends on the service we are trying to bring down
         # TODO: We should also take into account the active modes of the other services (this is not trivial to do)
         other_started_services = active_services.difference({service.name})
+        services_with_local_runtime = state.get_services_by_runtime(
+            ServiceRuntime.LOCAL
+        )
         dependent_service_name = None
-        for other_started_service in other_started_services:
-            other_service = find_matching_service(other_started_service)
-            other_service_active_starting_modes = state.get_active_modes_for_service(
-                other_service.name, StateTables.STARTING_SERVICES
-            )
-            other_service_active_started_modes = state.get_active_modes_for_service(
-                other_service.name, StateTables.STARTED_SERVICES
-            )
-            other_service_active_modes = (
-                other_service_active_starting_modes
-                or other_service_active_started_modes
+        # We can ignore checking if anything relies on the service
+        # if it is a locally running service
+        if service.name not in services_with_local_runtime:
+            dependent_service_name = _get_dependent_service(
+                service, other_started_services, state
             )
-            dependency_graph = construct_dependency_graph(
-                other_service, other_service_active_modes
-            )
-            # If the service we are trying to bring down is in the dependency graph of another service, we should not bring it down
-            if service.name in dependency_graph.graph:
-                dependent_service_name = other_started_service
-                break
 
         # If no other service depends on the service we are trying to bring down, we can bring it down
         if dependent_service_name is None:
             try:
                 _down(service, remote_dependencies, list(mode_dependencies), status)
             except DockerComposeError as dce:
-                capture_exception(dce)
+                capture_exception(dce, level="info")
                 status.failure(f"Failed to stop {service.name}: {dce.stderr}")
                 exit(1)
         else:
@@ -190,6 +181,17 @@ def _down(
     current_env[
         DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
     ] = relative_local_dependency_directory
+    state = State()
+    # We want to ignore any dependencies that are set to run locally
+    locally_running_services = state.get_services_by_runtime(ServiceRuntime.LOCAL)
+    mode_dependencies = [
+        dep for dep in mode_dependencies if dep not in locally_running_services
+    ]
+    remote_dependencies = {
+        dep
+        for dep in remote_dependencies
+        if dep.service_name not in locally_running_services
+    }
     docker_compose_commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=list(remote_dependencies),
@@ -209,3 +211,30 @@ def _down(
         ]
         for future in concurrent.futures.as_completed(futures):
             cmd_outputs.append(future.result())
+
+
+def _get_dependent_service(
+    service: Service,
+    other_started_services: set[str],
+    state: State,
+) -> str | None:
+    for other_started_service in other_started_services:
+        other_service = find_matching_service(other_started_service)
+        other_service_active_starting_modes = state.get_active_modes_for_service(
+            other_service.name, StateTables.STARTING_SERVICES
+        )
+        other_service_active_started_modes = state.get_active_modes_for_service(
+            other_service.name, StateTables.STARTED_SERVICES
+        )
+        other_service_active_modes = (
+            other_service_active_starting_modes or other_service_active_started_modes
+        )
+        dependency_graph = construct_dependency_graph(
+            other_service, other_service_active_modes
+        )
+        # If the service we are trying to bring down is in the dependency graph of another service,
+        # we should not bring it down
+        if service.name in dependency_graph.graph:
+            return other_started_service
+
+    return None

{devservices-1.0.16 → devservices-1.0.18}/devservices/commands/list_dependencies.py

@@ -34,7 +34,7 @@ def list_dependencies(args: Namespace) -> None:
     try:
         service = find_matching_service(service_name)
     except ConfigNotFoundError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure(
             f"{str(e)}. Please specify a service (i.e. `devservices list-dependencies sentry`) or run the command from a directory with a devservices configuration."
         )

{devservices-1.0.16 → devservices-1.0.18}/devservices/commands/logs.py

@@ -49,7 +49,7 @@ def logs(args: Namespace) -> None:
     try:
         service = find_matching_service(service_name)
     except ConfigNotFoundError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure(
             f"{str(e)}. Please specify a service (i.e. `devservices logs sentry`) or run the command from a directory with a devservices configuration."
         )
@@ -86,7 +86,7 @@ def logs(args: Namespace) -> None:
     try:
         logs_output = _logs(service, remote_dependencies, mode_dependencies)
     except DockerComposeError as dce:
-        capture_exception(dce)
+        capture_exception(dce, level="info")
         console.failure(f"Failed to get logs for {service.name}: {dce.stderr}")
         exit(1)
     for log in logs_output:

{devservices-1.0.16 → devservices-1.0.18}/devservices/commands/up.py

@@ -33,6 +33,7 @@ from devservices.utils.docker_compose import get_docker_compose_commands_to_run
 from devservices.utils.docker_compose import run_cmd
 from devservices.utils.services import find_matching_service
 from devservices.utils.services import Service
+from devservices.utils.state import ServiceRuntime
 from devservices.utils.state import State
 from devservices.utils.state import StateTables
 
@@ -63,7 +64,7 @@ def up(args: Namespace) -> None:
     try:
         service = find_matching_service(service_name)
     except ConfigNotFoundError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure(
             f"{str(e)}. Please specify a service (i.e. `devservices up sentry`) or run the command from a directory with a devservices configuration."
         )
@@ -106,11 +107,23 @@ def up(args: Namespace) -> None:
             pass
         # Add the service to the starting services table
         state.update_service_entry(service.name, mode, StateTables.STARTING_SERVICES)
+        mode_dependencies = modes[mode]
+        # We want to ignore any dependencies that are set to run locally
+        services_with_local_runtime = state.get_services_by_runtime(
+            ServiceRuntime.LOCAL
+        )
+        mode_dependencies = [
+            dep for dep in mode_dependencies if dep not in services_with_local_runtime
+        ]
+        remote_dependencies = {
+            dep
+            for dep in remote_dependencies
+            if dep.service_name not in services_with_local_runtime
+        }
         try:
-            mode_dependencies = modes[mode]
             _up(service, [mode], remote_dependencies, mode_dependencies, status)
         except DockerComposeError as dce:
-            capture_exception(dce)
+            capture_exception(dce, level="info")
             status.failure(f"Failed to start {service.name}: {dce.stderr}")
             exit(1)
     # TODO: We should factor in healthchecks here before marking service as running
@@ -118,12 +131,20 @@ def up(args: Namespace) -> None:
     state.update_service_entry(service.name, mode, StateTables.STARTED_SERVICES)
 
 
+def _pull_dependency_images(
+    cmd: DockerComposeCommand, current_env: dict[str, str], status: Status
+) -> None:
+    run_cmd(cmd.full_command, current_env)
+    for dependency in cmd.services:
+        status.info(f"Pulled image for {dependency}")
+
+
 def _bring_up_dependency(
     cmd: DockerComposeCommand, current_env: dict[str, str], status: Status
-) -> subprocess.CompletedProcess[str]:
+) -> None:
     for dependency in cmd.services:
         status.info(f"Starting {dependency}")
-    return run_cmd(cmd.full_command, current_env)
+    run_cmd(cmd.full_command, current_env)
 
 
 def _up(
@@ -150,26 +171,51 @@ def _up(
     sorted_remote_dependencies = sorted(
         remote_dependencies, key=lambda dep: starting_order.index(dep.service_name)
     )
-    docker_compose_commands = get_docker_compose_commands_to_run(
+    # Pull all images in parallel
+    status.info("Pulling images")
+    pull_commands = get_docker_compose_commands_to_run(
+        service=service,
+        remote_dependencies=sorted_remote_dependencies,
+        current_env=current_env,
+        command="pull",
+        options=[],
+        service_config_file_path=service_config_file_path,
+        mode_dependencies=mode_dependencies,
+    )
+
+    with concurrent.futures.ThreadPoolExecutor() as pull_dependency_executor:
+        futures = [
+            pull_dependency_executor.submit(
+                _pull_dependency_images, cmd, current_env, status
+            )
+            for cmd in pull_commands
+        ]
+        for future in concurrent.futures.as_completed(futures):
+            _ = future.result()
+
+    # Bring up all necessary containers
+    up_commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=sorted_remote_dependencies,
         current_env=current_env,
         command="up",
-        options=["-d", "--pull", "always"],
+        options=["-d"],
         service_config_file_path=service_config_file_path,
         mode_dependencies=mode_dependencies,
     )
 
     containers_to_check = []
-    with concurrent.futures.ThreadPoolExecutor() as dependency_executor:
+    with concurrent.futures.ThreadPoolExecutor() as up_dependency_executor:
         futures = [
-            dependency_executor.submit(_bring_up_dependency, cmd, current_env, status)
-            for cmd in docker_compose_commands
+            up_dependency_executor.submit(
+                _bring_up_dependency, cmd, current_env, status
+            )
+            for cmd in up_commands
         ]
         for future in concurrent.futures.as_completed(futures):
             _ = future.result()
 
-    for cmd in docker_compose_commands:
+    for cmd in up_commands:
         try:
             container_names = get_container_names_for_project(
                 cmd.project_name, cmd.config_path

{devservices-1.0.16 → devservices-1.0.18}/devservices/main.py

@@ -11,10 +11,13 @@ from importlib import metadata
 from sentry_sdk import capture_exception
 from sentry_sdk import flush
 from sentry_sdk import init
+from sentry_sdk import set_context
 from sentry_sdk import set_tag
 from sentry_sdk import set_user
 from sentry_sdk import start_transaction
 from sentry_sdk.integrations.argv import ArgvIntegration
+from sentry_sdk.types import Event
+from sentry_sdk.types import Hint
 
 from devservices.commands import down
 from devservices.commands import list_dependencies
@@ -42,6 +45,31 @@ disable_sentry = os.environ.get("DEVSERVICES_DISABLE_SENTRY", default="0") == "1
 logging.basicConfig(level=logging.INFO)
 current_version = metadata.version("devservices")
 
+error_trace_ids = set()
+
+
+def before_send_error(event: Event, hint: Hint) -> Event:
+    """Gets the trace_id from the errors we care about.
+
+    This function is used as a before_send callback for Sentry to track error trace IDs.
+    It adds the trace_id to error_trace_ids set for non-info level events.
+    """
+    if event["level"] != "info":
+        error_trace_ids.add(event["contexts"]["trace"]["trace_id"])
+    return event
+
+
+def before_send_transaction(event: Event, hint: Hint) -> Event:
+    """Manually sets the status of a transaction.
+
+    This function is used as a before_send_transaction callback for Sentry to mark transaction status
+    as unknown if they don't correspond to errors we care about.
+    """
+    if event["contexts"]["trace"]["trace_id"] not in error_trace_ids:
+        event["contexts"]["trace"]["status"] = "unknown"
+    return event
+
+
 if not disable_sentry:
     init(
         dsn="https://56470da7302c16e83141f62f88e46449@o1.ingest.us.sentry.io/4507946704961536",
@@ -50,16 +78,34 @@ if not disable_sentry:
         enable_tracing=True,
         integrations=[ArgvIntegration()],
         environment=sentry_environment,
+        before_send=before_send_error,
+        before_send_transaction=before_send_transaction,
         release=current_version,
     )
     username = getpass.getuser()
     set_user({"username": username})
     set_tag("user_platform", platform.platform())
+    if sentry_environment == "CI":
+        set_context(
+            "github",
+            {
+                "github_action": os.environ.get("GITHUB_ACTION"),
+                "github_action_path": os.environ.get("GITHUB_ACTION_PATH"),
+                "github_repository": os.environ.get("GITHUB_REPOSITORY"),
+                "github_ref_name": os.environ.get("GITHUB_REF_NAME"),
+                "github_run_id": os.environ.get("GITHUB_RUN_ID"),
+                "github_url": f"{os.environ.get('GITHUB_SERVER_URL')}/{os.environ.get('GITHUB_REPOSITORY')}/actions/runs/{os.environ.get('GITHUB_RUN_ID')}",
+                "github_run_attempt": os.environ.get("GITHUB_RUN_ATTEMPT"),
+                "github_workflow": os.environ.get("GITHUB_WORKFLOW"),
+                "github_workflow_run_id": os.environ.get("GITHUB_WORKFLOW_RUN_ID"),
+                "github_sha": os.environ.get("GITHUB_SHA"),
+            },
+        )
     try:
         git_version = get_git_version()
         set_tag("git_version", git_version)
     except GitError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         logging.debug("Failed to get git version: %s", e)
         set_tag("git_version", "unknown")
 
@@ -75,11 +121,11 @@ def main() -> None:
     try:
         check_docker_compose_version()
     except DockerDaemonNotRunningError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure(str(e))
         exit(1)
     except DockerComposeInstallationError as e:
-        capture_exception(e)
+        capture_exception(e, level="info")
         console.failure("Failed to ensure docker compose is installed and up-to-date")
         exit(1)
     parser = argparse.ArgumentParser(

{devservices-1.0.16 → devservices-1.0.18}/devservices/utils/dependencies.py

@@ -271,7 +271,8 @@ def get_non_shared_remote_dependencies(
     started_services = set(state.get_service_entries(StateTables.STARTED_SERVICES))
     active_services = starting_services.union(started_services)
     # We don't care about the remote dependencies of the service we are stopping
-    active_services.remove(service_to_stop.name)
+    if service_to_stop.name in active_services:
+        active_services.remove(service_to_stop.name)
 
     active_modes: dict[str, list[str]] = dict()
     for active_service in active_services:

{devservices-1.0.16 → devservices-1.0.18}/devservices/utils/docker.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import concurrent.futures
 import subprocess
 import time
+from typing import NamedTuple
 
 from devservices.constants import HEALTHCHECK_INTERVAL
 from devservices.constants import HEALTHCHECK_TIMEOUT
@@ -12,6 +13,11 @@ from devservices.exceptions import DockerError
 from devservices.utils.console import Status
 
 
+class ContainerNames(NamedTuple):
+    name: str
+    short_name: str
+
+
 def check_docker_daemon_running() -> None:
     """Checks if the Docker daemon is running. Raises DockerDaemonNotRunningError if not."""
     try:
@@ -25,8 +31,11 @@ def check_docker_daemon_running() -> None:
         raise DockerDaemonNotRunningError from e
 
 
-def check_all_containers_healthy(status: Status, containers: list[str]) -> None:
+def check_all_containers_healthy(
+    status: Status, containers: list[ContainerNames]
+) -> None:
     """Ensures all containers are healthy."""
+    status.info("Waiting for all containers to be healthy")
     with concurrent.futures.ThreadPoolExecutor() as healthcheck_executor:
         futures = [
             healthcheck_executor.submit(wait_for_healthy, container, status)
@@ -36,7 +45,7 @@ def check_all_containers_healthy(status: Status, containers: list[str]) -> None:
             future.result()
 
 
-def wait_for_healthy(container_name: str, status: Status) -> None:
+def wait_for_healthy(container: ContainerNames, status: Status) -> None:
     """
     Polls a Docker container's health status until it becomes healthy or a timeout is reached.
     """
@@ -51,31 +60,32 @@ def wait_for_healthy(container_name: str, status: Status) -> None:
                     "inspect",
                     "-f",
                     "{{if .State.Health}}{{.State.Health.Status}}{{else}}unknown{{end}}",
-                    container_name,
+                    container.name,
                 ],
                 stderr=subprocess.DEVNULL,
                 text=True,
             ).strip()
         except subprocess.CalledProcessError as e:
             raise DockerError(
-                command=f"docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}unknown{{end}}' {container_name}",
+                command=f"docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}unknown{{end}}' {container.name}",
                 returncode=e.returncode,
                 stdout=e.stdout,
                 stderr=e.stderr,
             ) from e
 
         if result == "healthy":
+            status.info(f"{container.short_name} is healthy")
             return
         if result == "unknown":
             status.warning(
-                f"WARNING: Container {container_name} does not have a healthcheck"
+                f"WARNING: Container {container.short_name} does not have a healthcheck"
             )
             return
 
         # If not healthy, wait and try again
         time.sleep(HEALTHCHECK_INTERVAL)
 
-    raise ContainerHealthcheckFailedError(container_name, HEALTHCHECK_TIMEOUT)
+    raise ContainerHealthcheckFailedError(container.short_name, HEALTHCHECK_TIMEOUT)
 
 
 def get_matching_containers(label: str) -> list[str]:

{devservices-1.0.16 → devservices-1.0.18}/devservices/utils/docker_compose.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import logging
 import os
 import platform
@@ -23,6 +24,7 @@ from devservices.exceptions import DockerComposeInstallationError
 from devservices.utils.console import Console
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.docker import check_docker_daemon_running
+from devservices.utils.docker import ContainerNames
 from devservices.utils.install_binary import install_binary
 from devservices.utils.services import Service
 
@@ -92,9 +94,11 @@ def install_docker_compose() -> None:
     console.success(f"Verified Docker Compose installation: v{version}")
 
 
-def get_container_names_for_project(project_name: str, config_path: str) -> list[str]:
+def get_container_names_for_project(
+    project_name: str, config_path: str
+) -> list[ContainerNames]:
     try:
-        container_names = subprocess.check_output(
+        output = subprocess.check_output(
             [
                 "docker",
                 "compose",
@@ -104,11 +108,15 @@ def get_container_names_for_project(project_name: str, config_path: str) -> list
                 config_path,
                 "ps",
                 "--format",
-                "{{.Name}}",
+                '{"name":"{{.Names}}", "short_name":"{{.Service}}"}',
             ],
             text=True,
         ).splitlines()
-        return container_names
+        return [
+            ContainerNames(name=json_data["name"], short_name=json_data["short_name"])
+            for line in output
+            if (json_data := json.loads(line))
+        ]
     except subprocess.CalledProcessError as e:
         raise DockerComposeError(
             command=f"docker compose -p {project_name} -f {config_path} ps --format {{.Name}}",