dstack 0.19.25rc1__py3-none-any.whl → 0.19.27__py3-none-any.whl

dstack/_internal/core/models/resources.py

@@ -130,6 +130,12 @@ DEFAULT_GPU_COUNT = Range[int](min=1)
 
 
 class CPUSpec(CoreModel):
+    arch: Annotated[
+        Optional[gpuhunt.CPUArchitecture],
+        Field(description="The CPU architecture, one of: `x86`, `arm`"),
+    ] = None
+    count: Annotated[Range[int], Field(description="The number of CPU cores")] = DEFAULT_CPU_COUNT
+
     class Config(CoreModel.Config):
         @staticmethod
         def schema_extra(schema: Dict[str, Any]):
@@ -138,12 +144,6 @@ class CPUSpec(CoreModel):
                 extra_types=[{"type": "integer"}, {"type": "string"}],
             )
 
-    arch: Annotated[
-        Optional[gpuhunt.CPUArchitecture],
-        Field(description="The CPU architecture, one of: `x86`, `arm`"),
-    ] = None
-    count: Annotated[Range[int], Field(description="The number of CPU cores")] = DEFAULT_CPU_COUNT
-
     @classmethod
     def __get_validators__(cls):
         yield cls.parse
@@ -191,22 +191,6 @@ class CPUSpec(CoreModel):
 
 
 class GPUSpec(CoreModel):
-    class Config(CoreModel.Config):
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["count"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["memory"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
-            add_extra_schema_types(
-                schema["properties"]["total_memory"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
-
     vendor: Annotated[
         Optional[gpuhunt.AcceleratorVendor],
         Field(
@@ -234,6 +218,26 @@ class GPUSpec(CoreModel):
         Field(description="The minimum compute capability of the GPU (e.g., `7.5`)"),
     ] = None
 
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["count"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["name"],
+                extra_types=[{"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["memory"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["total_memory"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+
     @classmethod
     def __get_validators__(cls):
         yield cls.parse
@@ -314,6 +318,8 @@ class GPUSpec(CoreModel):
 
 
 class DiskSpec(CoreModel):
+    size: Annotated[Range[Memory], Field(description="Disk size")]
+
     class Config(CoreModel.Config):
         @staticmethod
         def schema_extra(schema: Dict[str, Any]):
@@ -322,8 +328,6 @@ class DiskSpec(CoreModel):
                 extra_types=[{"type": "integer"}, {"type": "string"}],
             )
 
-    size: Annotated[Range[Memory], Field(description="Disk size")]
-
     @classmethod
     def __get_validators__(cls):
         yield cls._parse
@@ -340,6 +344,24 @@ DEFAULT_DISK = DiskSpec(size=Range[Memory](min=Memory.parse("100GB"), max=None))
 
 
 class ResourcesSpec(CoreModel):
+    # TODO: Remove Range[int] in 0.20. Range[int] for backward compatibility only.
+    cpu: Annotated[Union[CPUSpec, Range[int]], Field(description="The CPU requirements")] = (
+        CPUSpec()
+    )
+    memory: Annotated[Range[Memory], Field(description="The RAM size (e.g., `8GB`)")] = (
+        DEFAULT_MEMORY_SIZE
+    )
+    shm_size: Annotated[
+        Optional[Memory],
+        Field(
+            description="The size of shared memory (e.g., `8GB`). "
+            "If you are using parallel communicating processes (e.g., dataloaders in PyTorch), "
+            "you may need to configure this"
+        ),
+    ] = None
+    gpu: Annotated[Optional[GPUSpec], Field(description="The GPU requirements")] = None
+    disk: Annotated[Optional[DiskSpec], Field(description="The disk resources")] = DEFAULT_DISK
+
     class Config(CoreModel.Config):
         @staticmethod
         def schema_extra(schema: Dict[str, Any]):
@@ -364,24 +386,6 @@ class ResourcesSpec(CoreModel):
                 extra_types=[{"type": "integer"}, {"type": "string"}],
             )
 
-    # TODO: Remove Range[int] in 0.20. Range[int] for backward compatibility only.
-    cpu: Annotated[Union[CPUSpec, Range[int]], Field(description="The CPU requirements")] = (
-        CPUSpec()
-    )
-    memory: Annotated[Range[Memory], Field(description="The RAM size (e.g., `8GB`)")] = (
-        DEFAULT_MEMORY_SIZE
-    )
-    shm_size: Annotated[
-        Optional[Memory],
-        Field(
-            description="The size of shared memory (e.g., `8GB`). "
-            "If you are using parallel communicating processes (e.g., dataloaders in PyTorch), "
-            "you may need to configure this"
-        ),
-    ] = None
-    gpu: Annotated[Optional[GPUSpec], Field(description="The GPU requirements")] = None
-    disk: Annotated[Optional[DiskSpec], Field(description="The disk resources")] = DEFAULT_DISK
-
     def pretty_format(self) -> str:
         # TODO: Remove in 0.20. Use self.cpu directly
         cpu = parse_obj_as(CPUSpec, self.cpu)

dstack/_internal/core/models/runs.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timedelta
 from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Type
+from urllib.parse import urlparse
 
 from pydantic import UUID4, Field, root_validator
 from typing_extensions import Annotated
@@ -9,7 +10,7 @@ from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import ApplyAction, CoreModel, NetworkMode, RegistryAuth
 from dstack._internal.core.models.configurations import (
     DEFAULT_PROBE_METHOD,
-    DEFAULT_REPO_DIR,
+    LEGACY_REPO_DIR,
     AnyRunConfiguration,
     HTTPHeaderSpec,
     HTTPMethod,
@@ -258,6 +259,7 @@ class JobSpec(CoreModel):
     retry: Optional[Retry]
     volumes: Optional[List[MountPoint]] = None
     ssh_key: Optional[JobSSHKey] = None
+    # `working_dir` is always absolute (if not None) since 0.19.27
     working_dir: Optional[str]
     # `repo_data` is optional for client compatibility with pre-0.19.17 servers and for compatibility
     # with jobs submitted before 0.19.17. All new jobs are expected to have non-None `repo_data`.
@@ -267,6 +269,8 @@ class JobSpec(CoreModel):
     # submitted before 0.19.17. See `_get_repo_code_hash` on how to get the correct `repo_code_hash`
     # TODO: drop this comment when supporting jobs submitted before 0.19.17 is no longer relevant.
     repo_code_hash: Optional[str] = None
+    # `repo_dir` was added in 0.19.27. Default value is set for backward compatibility
+    repo_dir: str = LEGACY_REPO_DIR
     file_archives: list[FileArchiveMapping] = []
     # None for non-services and pre-0.19.19 services. See `get_service_port`
     service_port: Optional[int] = None
@@ -408,17 +412,27 @@ class RunSpec(CoreModel):
         Optional[str],
         Field(description="The hash of the repo diff. Can be omitted if there is no repo diff."),
     ] = None
+    repo_dir: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The repo path inside the container. Relative paths are resolved"
+                f" relative to the working directory. Defaults to `{LEGACY_REPO_DIR}`."
+            )
+        ),
+    ] = None
     file_archives: Annotated[
         list[FileArchiveMapping],
-        Field(description="The list of file archive ID to container path mappings"),
+        Field(description="The list of file archive ID to container path mappings."),
     ] = []
+    # Server uses configuration.working_dir instead of this field since 0.19.27, but
+    # the field still exists for compatibility with older servers
     working_dir: Annotated[
         Optional[str],
         Field(
             description=(
-                "The path to the working directory inside the container."
-                f" It's specified relative to the repository directory (`{DEFAULT_REPO_DIR}`) and should be inside it."
-                ' Defaults to `"."`.'
+                "The absolute path to the working directory inside the container."
+                " Defaults to the default working directory from the `image`."
             )
         ),
     ] = None
@@ -483,6 +497,9 @@ class ServiceSpec(CoreModel):
     model: Optional[ServiceModelSpec] = None
     options: Dict[str, Any] = {}
 
+    def get_domain(self) -> Optional[str]:
+        return urlparse(self.url).hostname
+
 
 class RunStatus(str, Enum):
     PENDING = "pending"
@@ -502,10 +519,16 @@ class RunStatus(str, Enum):
         return self in self.finished_statuses()
 
 
+class RunFleet(CoreModel):
+    id: UUID4
+    name: str
+
+
 class Run(CoreModel):
     id: UUID4
     project_name: str
     user: str
+    fleet: Optional[RunFleet] = None
     submitted_at: datetime
     last_processed_at: datetime
     status: RunStatus

dstack/_internal/core/services/configs/__init__.py

@@ -38,7 +38,10 @@ class ConfigManager:
             with open(self.config_filepath, "r") as f:
                 config = yaml.safe_load(f)
             self.config = GlobalConfig.parse_obj(config)
-        except (FileNotFoundError, ValidationError):
+        except FileNotFoundError:
+            self.config = GlobalConfig()
+        except ValidationError:
+            logger.error(f"Error in `{self.config_filepath}`", exc_info=True)
             self.config = GlobalConfig()
 
     def get_project_config(self, name: Optional[str] = None) -> Optional[ProjectConfig]:
@@ -65,8 +68,8 @@ class ConfigManager:
         if len(self.config.projects) == 1:
             self.config.projects[0].default = True
 
-    def list_projects(self):
-        return [project.name for project in self.config.projects]
+    def list_project_configs(self) -> list[ProjectConfig]:
+        return self.config.projects
 
     def delete_project(self, name: str):
         self.config.projects = [p for p in self.config.projects if p.name != name]

dstack/_internal/core/services/profiles.py

@@ -37,10 +37,10 @@ def get_termination(
 ) -> Tuple[TerminationPolicy, int]:
     termination_policy = TerminationPolicy.DESTROY_AFTER_IDLE
     termination_idle_time = default_termination_idle_time
-    if profile.idle_duration is not None and int(profile.idle_duration) < 0:
+    if profile.idle_duration is not None and profile.idle_duration < 0:
         termination_policy = TerminationPolicy.DONT_DESTROY
     elif profile.idle_duration is not None:
         termination_idle_time = profile.idle_duration
     if termination_policy == TerminationPolicy.DONT_DESTROY:
         termination_idle_time = -1
-    return termination_policy, int(termination_idle_time)
+    return termination_policy, termination_idle_time

dstack/_internal/core/services/repos.py

@@ -1,9 +1,10 @@
 import os
+from contextlib import suppress
 from pathlib import Path
+from tempfile import NamedTemporaryFile
 from typing import Optional, Union
 
-import git
-import requests
+import git.cmd
 import yaml
 from git.exc import GitCommandError
 
@@ -13,11 +14,7 @@ from dstack._internal.core.models.repos import LocalRepo, RemoteRepo, RemoteRepo
 from dstack._internal.core.models.repos.remote import GitRepoURL
 from dstack._internal.utils.logging import get_logger
 from dstack._internal.utils.path import PathLike
-from dstack._internal.utils.ssh import (
-    get_host_config,
-    make_ssh_command_for_git,
-    try_ssh_key_passphrase,
-)
+from dstack._internal.utils.ssh import get_host_config, make_git_env, try_ssh_key_passphrase
 
 logger = get_logger(__name__)
 
@@ -29,117 +26,127 @@ class InvalidRepoCredentialsError(DstackError):
     pass
 
 
-def get_local_repo_credentials(
+def get_repo_creds_and_default_branch(
     repo_url: str,
     identity_file: Optional[PathLike] = None,
+    private_key: Optional[str] = None,
     oauth_token: Optional[str] = None,
-) -> RemoteRepoCreds:
+) -> tuple[RemoteRepoCreds, Optional[str]]:
     url = GitRepoURL.parse(repo_url, get_ssh_config=get_host_config)
 
     # no auth
-    r = requests.get(f"{url.as_https()}/info/refs?service=git-upload-pack", timeout=10)
-    if r.status_code == 200:
-        return RemoteRepoCreds(
-            clone_url=url.as_https(),
-            private_key=None,
-            oauth_token=None,
-        )
-
-    # user-provided ssh key
-    if identity_file is not None:
-        identity_file = os.path.expanduser(identity_file)
-        return check_remote_repo_credentials_ssh(url, identity_file)
-
-    # user-provided oauth token
+    with suppress(InvalidRepoCredentialsError):
+        return _get_repo_creds_and_default_branch_https(url)
+
+    # ssh key provided by the user or pulled from the server
+    if identity_file is not None or private_key is not None:
+        if identity_file is not None:
+            private_key = _read_private_key(identity_file)
+            return _get_repo_creds_and_default_branch_ssh(url, identity_file, private_key)
+        elif private_key is not None:
+            with NamedTemporaryFile("w+", 0o600) as f:
+                f.write(private_key)
+                f.flush()
+                return _get_repo_creds_and_default_branch_ssh(url, f.name, private_key)
+        else:
+            assert False, "should not reach here"
+
+    # oauth token provided by the user or pulled from the server
     if oauth_token is not None:
-        return check_remote_repo_credentials_https(url, oauth_token)
+        return _get_repo_creds_and_default_branch_https(url, oauth_token)
 
     # key from ssh config
     identities = get_host_config(url.original_host).get("identityfile")
     if identities:
-        return check_remote_repo_credentials_ssh(url, identities[0])
+        _identity_file = identities[0]
+        with suppress(InvalidRepoCredentialsError):
+            _private_key = _read_private_key(_identity_file)
+            return _get_repo_creds_and_default_branch_ssh(url, _identity_file, _private_key)
 
     # token from gh config
     if os.path.exists(gh_config_path):
         with open(gh_config_path, "r") as f:
             gh_hosts = yaml.load(f, Loader=yaml.FullLoader)
-        oauth_token = gh_hosts.get(url.host, {}).get("oauth_token")
-        if oauth_token is not None:
-            try:
-                return check_remote_repo_credentials_https(url, oauth_token)
-            except InvalidRepoCredentialsError:
-                pass
+        _oauth_token = gh_hosts.get(url.host, {}).get("oauth_token")
+        if _oauth_token is not None:
+            with suppress(InvalidRepoCredentialsError):
+                return _get_repo_creds_and_default_branch_https(url, _oauth_token)
 
     # default user key
     if os.path.exists(default_ssh_key):
-        try:
-            return check_remote_repo_credentials_ssh(url, default_ssh_key)
-        except InvalidRepoCredentialsError:
-            pass
+        with suppress(InvalidRepoCredentialsError):
+            _private_key = _read_private_key(default_ssh_key)
+            return _get_repo_creds_and_default_branch_ssh(url, default_ssh_key, _private_key)
 
     raise InvalidRepoCredentialsError(
         "No valid default Git credentials found. Pass valid `--token` or `--git-identity`."
     )
 
 
-def check_remote_repo_credentials_https(url: GitRepoURL, oauth_token: str) -> RemoteRepoCreds:
+def _get_repo_creds_and_default_branch_ssh(
+    url: GitRepoURL, identity_file: PathLike, private_key: str
+) -> tuple[RemoteRepoCreds, Optional[str]]:
+    _url = url.as_ssh()
     try:
-        git.cmd.Git().ls_remote(url.as_https(oauth_token), env=dict(GIT_TERMINAL_PROMPT="0"))
-    except GitCommandError:
-        masked = len(oauth_token[:-4]) * "*" + oauth_token[-4:]
-        raise InvalidRepoCredentialsError(
-            f"Can't access `{url.as_https()}` using the `{masked}` token"
-        )
-    return RemoteRepoCreds(
-        clone_url=url.as_https(),
-        oauth_token=oauth_token,
+        default_branch = _get_repo_default_branch(_url, make_git_env(identity_file=identity_file))
+    except GitCommandError as e:
+        message = f"Cannot access `{_url}` using the `{identity_file}` private SSH key"
+        raise InvalidRepoCredentialsError(message) from e
+    creds = RemoteRepoCreds(
+        clone_url=_url,
+        private_key=private_key,
+        oauth_token=None,
+    )
+    return creds, default_branch
+
+
+def _get_repo_creds_and_default_branch_https(
+    url: GitRepoURL, oauth_token: Optional[str] = None
+) -> tuple[RemoteRepoCreds, Optional[str]]:
+    _url = url.as_https()
+    try:
+        default_branch = _get_repo_default_branch(url.as_https(oauth_token), make_git_env())
+    except GitCommandError as e:
+        message = f"Cannot access `{_url}`"
+        if oauth_token is not None:
+            masked_token = len(oauth_token[:-4]) * "*" + oauth_token[-4:]
+            message = f"{message} using the `{masked_token}` token"
+        raise InvalidRepoCredentialsError(message) from e
+    creds = RemoteRepoCreds(
+        clone_url=_url,
         private_key=None,
+        oauth_token=oauth_token,
     )
+    return creds, default_branch
 
 
-def check_remote_repo_credentials_ssh(url: GitRepoURL, identity_file: PathLike) -> RemoteRepoCreds:
+def _get_repo_default_branch(url: str, env: dict[str, str]) -> Optional[str]:
+    # output example: "ref: refs/heads/dev\tHEAD\n545344f77c0df78367085952a97fc3a058eb4c65\tHEAD"
+    output: str = git.cmd.Git().ls_remote("--symref", url, "HEAD", env=env)
+    for line in output.splitlines():
+        # line format: `<oid> TAB <ref> LF`
+        oid, _, ref = line.partition("\t")
+        if oid.startswith("ref:") and ref == "HEAD":
+            return oid.rsplit("/", maxsplit=1)[-1]
+    return None
+
+
+def _read_private_key(identity_file: PathLike) -> str:
+    identity_file = Path(identity_file).expanduser().resolve()
     if not Path(identity_file).exists():
-        raise InvalidRepoCredentialsError(f"The {identity_file} private SSH key doesn't exist")
+        raise InvalidRepoCredentialsError(f"The `{identity_file}` private SSH key doesn't exist")
     if not os.access(identity_file, os.R_OK):
-        raise InvalidRepoCredentialsError(f"Can't access the {identity_file} private SSH key")
+        raise InvalidRepoCredentialsError(f"Cannot access the `{identity_file}` private SSH key")
     if not try_ssh_key_passphrase(identity_file):
         raise InvalidRepoCredentialsError(
             f"Cannot use the `{identity_file}` private SSH key. "
             "Ensure that it is valid and passphrase-free"
         )
-    with open(identity_file, "r") as f:
-        private_key = f.read()
-
-    try:
-        git.cmd.Git().ls_remote(
-            url.as_ssh(), env=dict(GIT_SSH_COMMAND=make_ssh_command_for_git(identity_file))
-        )
-    except GitCommandError:
-        raise InvalidRepoCredentialsError(
-            f"Can't access `{url.as_ssh()}` using the `{identity_file}` private SSH key"
-        )
-
-    return RemoteRepoCreds(
-        clone_url=url.as_ssh(),
-        private_key=private_key,
-        oauth_token=None,
-    )
-
-
-def get_default_branch(remote_url: str) -> Optional[str]:
-    """
-    Get the default branch of a remote Git repository.
-    """
-    try:
-        output = git.cmd.Git().ls_remote("--symref", remote_url, "HEAD")
-        for line in output.splitlines():
-            if line.startswith("ref:"):
-                return line.split()[1].split("/")[-1]
-    except Exception as e:
-        logger.debug("Failed to get remote repo default branch: %s", repr(e))
-    return None
+    with open(identity_file, "r") as file:
+        return file.read()
 
 
+# Used for `config.yml` only, remove it with `repos` in `config.yml`
 def load_repo(config: RepoConfig) -> Union[RemoteRepo, LocalRepo]:
     if config.repo_type == "remote":
         return RemoteRepo(repo_id=config.repo_id, local_repo_dir=config.path)

dstack/_internal/core/services/ssh/ports.py

@@ -74,7 +74,7 @@ class PortsLock:
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             if IS_WINDOWS:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)  # type: ignore[attr-defined]
             sock.bind(("", port))
             return sock
         except socket.error as e:

dstack/_internal/proxy/lib/deps.py

@@ -21,12 +21,16 @@ class ProxyDependencyInjector(ABC):
     def __init__(self) -> None:
         self._service_conn_pool = ServiceConnectionPool()
 
+    # Abstract AsyncGenerator does not need async def since
+    # type checkers infer a different type without yield in body.
+    # https://mypy.readthedocs.io/en/stable/more_types.html#asynchronous-iterators
+
     @abstractmethod
-    async def get_repo(self) -> AsyncGenerator[BaseProxyRepo, None]:
+    def get_repo(self) -> AsyncGenerator[BaseProxyRepo, None]:
         pass
 
     @abstractmethod
-    async def get_auth_provider(self) -> AsyncGenerator[BaseProxyAuthProvider, None]:
+    def get_auth_provider(self) -> AsyncGenerator[BaseProxyAuthProvider, None]:
         pass
 
     async def get_service_connection_pool(self) -> ServiceConnectionPool:

dstack/_internal/server/app.py

@@ -110,9 +110,11 @@ async def lifespan(app: FastAPI):
     _print_dstack_logo()
     if not check_required_ssh_version():
         logger.warning("OpenSSH 8.4+ is required. The dstack server may not work properly")
+    server_config_manager = None
+    server_config_loaded = False
     if settings.SERVER_CONFIG_ENABLED:
         server_config_manager = ServerConfigManager()
-        config_loaded = server_config_manager.load_config()
+        server_config_loaded = server_config_manager.load_config()
         # Encryption has to be configured before working with users and projects
         await server_config_manager.apply_encryption()
     async with get_session_ctx() as session:
@@ -126,11 +128,9 @@ async def lifespan(app: FastAPI):
                 session=session,
                 user=admin,
             )
-            if settings.SERVER_CONFIG_ENABLED:
-                server_config_dir = str(SERVER_CONFIG_FILE_PATH).replace(
-                    os.path.expanduser("~"), "~", 1
-                )
-                if not config_loaded:
+            if server_config_manager is not None:
+                server_config_dir = _get_server_config_dir()
+                if not server_config_loaded:
                     logger.info("Initializing the default configuration...", {"show_path": False})
                     await server_config_manager.init_config(session=session)
                     logger.info(
@@ -153,6 +153,7 @@ async def lifespan(app: FastAPI):
     )
     if settings.SERVER_S3_BUCKET is not None or settings.SERVER_GCS_BUCKET is not None:
         init_default_storage()
+    scheduler = None
     if settings.SERVER_BACKGROUND_PROCESSING_ENABLED:
         scheduler = start_background_tasks()
     else:
@@ -167,7 +168,7 @@ async def lifespan(app: FastAPI):
     for func in _ON_STARTUP_HOOKS:
         await func(app)
     yield
-    if settings.SERVER_BACKGROUND_PROCESSING_ENABLED:
+    if scheduler is not None:
         scheduler.shutdown()
     PROBES_SCHEDULER.shutdown(wait=False)
     await gateway_connections_pool.remove_all()
@@ -371,6 +372,18 @@ def _is_prometheus_request(request: Request) -> bool:
     return request.url.path.startswith("/metrics")
 
 
+def _sentry_traces_sampler(sampling_context: SamplingContext) -> float:
+    parent_sampling_decision = sampling_context["parent_sampled"]
+    if parent_sampling_decision is not None:
+        return float(parent_sampling_decision)
+    transaction_context = sampling_context["transaction_context"]
+    name = transaction_context.get("name")
+    if name is not None:
+        if name.startswith("background."):
+            return settings.SENTRY_TRACES_BACKGROUND_SAMPLE_RATE
+    return settings.SENTRY_TRACES_SAMPLE_RATE
+
+
 def _print_dstack_logo():
     console.print(
         """[purple]╱╱╭╮╱╱╭╮╱╱╱╱╱╱╭╮
@@ -387,13 +400,5 @@ def _print_dstack_logo():
     )
 
 
-def _sentry_traces_sampler(sampling_context: SamplingContext) -> float:
-    parent_sampling_decision = sampling_context["parent_sampled"]
-    if parent_sampling_decision is not None:
-        return float(parent_sampling_decision)
-    transaction_context = sampling_context["transaction_context"]
-    name = transaction_context.get("name")
-    if name is not None:
-        if name.startswith("background."):
-            return settings.SENTRY_TRACES_BACKGROUND_SAMPLE_RATE
-    return settings.SENTRY_TRACES_SAMPLE_RATE
+def _get_server_config_dir() -> str:
+    return str(SERVER_CONFIG_FILE_PATH).replace(os.path.expanduser("~"), "~", 1)