skypilot-nightly 1.0.0.dev20250417__py3-none-any.whl → 1.0.0.dev20250422__py3-none-any.whl

sky/provision/provisioner.py

@@ -670,6 +670,7 @@ def post_provision_runtime_setup(
                 ux_utils.error_message(
                     'Failed to set up SkyPilot runtime on cluster.',
                     provision_logging.config.log_path))
-            logger.debug(f'Stacktrace:\n{traceback.format_exc()}')
+            if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+                logger.debug(f'Stacktrace:\n{traceback.format_exc()}')
             with ux_utils.print_exception_no_traceback():
                 raise

sky/provision/runpod/utils.py

@@ -14,11 +14,19 @@ from sky.utils import common_utils
 logger = sky_logging.init_logger(__name__)
 
 GPU_NAME_MAP = {
+    # AMD
+    'MI300X': 'AMD Instinct MI300X OAM',
+
+    # NVIDIA A-series
     'A100-80GB': 'NVIDIA A100 80GB PCIe',
-    'A100-40GB': 'NVIDIA A100-PCIE-40GB',
     'A100-80GB-SXM': 'NVIDIA A100-SXM4-80GB',
     'A30': 'NVIDIA A30',
     'A40': 'NVIDIA A40',
+
+    # NVIDIA B-series
+    'B200': 'NVIDIA B200',
+
+    # GeForce
     'RTX3070': 'NVIDIA GeForce RTX 3070',
     'RTX3080': 'NVIDIA GeForce RTX 3080',
     'RTX3080Ti': 'NVIDIA GeForce RTX 3080 Ti',
@@ -26,25 +34,43 @@ GPU_NAME_MAP = {
     'RTX3090Ti': 'NVIDIA GeForce RTX 3090 Ti',
     'RTX4070Ti': 'NVIDIA GeForce RTX 4070 Ti',
     'RTX4080': 'NVIDIA GeForce RTX 4080',
+    'RTX4080SUPER': 'NVIDIA GeForce RTX 4080 SUPER',
     'RTX4090': 'NVIDIA GeForce RTX 4090',
+    'RTX5080': 'NVIDIA GeForce RTX 5080',
+    'RTX5090': 'NVIDIA GeForce RTX 5090',
+
+    # NVIDIA H100/H200
     # Following instance is displayed as SXM at the console
     # but the ID from the API appears as HBM
     'H100-SXM': 'NVIDIA H100 80GB HBM3',
+    'H100-NVL': 'NVIDIA H100 NVL',
     'H100': 'NVIDIA H100 PCIe',
+    'H200-SXM': 'NVIDIA H200',
+
+    # NVIDIA L-series
     'L4': 'NVIDIA L4',
     'L40': 'NVIDIA L40',
-    'RTX4000-Ada-SFF': 'NVIDIA RTX 4000 SFF Ada Generation',
+    'L40S': 'NVIDIA L40S',
+
+    # Ada generation (GeForce & RTX A)
+    'RTX2000-Ada': 'NVIDIA RTX 2000 Ada Generation',
     'RTX4000-Ada': 'NVIDIA RTX 4000 Ada Generation',
+    'RTX4000-Ada-SFF': 'NVIDIA RTX 4000 SFF Ada Generation',
+    'RTX5000-Ada': 'NVIDIA RTX 5000 Ada Generation',
     'RTX6000-Ada': 'NVIDIA RTX 6000 Ada Generation',
+
+    # NVIDIA RTX A-series
+    'RTXA2000': 'NVIDIA RTX A2000',
     'RTXA4000': 'NVIDIA RTX A4000',
     'RTXA4500': 'NVIDIA RTX A4500',
     'RTXA5000': 'NVIDIA RTX A5000',
     'RTXA6000': 'NVIDIA RTX A6000',
-    'RTX5000': 'Quadro RTX 5000',
+
+    # Tesla V100 variants
     'V100-16GB-FHHL': 'Tesla V100-FHHL-16GB',
-    'V100-16GB-SXM2': 'V100-SXM2-16GB',
-    'RTXA2000': 'NVIDIA RTX A2000',
-    'V100-16GB-PCIe': 'Tesla V100-PCIE-16GB'
+    'V100-16GB-SXM2': 'Tesla V100-SXM2-16GB',
+    'V100-32GB-SXM2': 'Tesla V100-SXM2-32GB',
+    'V100-16GB-PCIe': 'Tesla V100-PCIE-16GB',
 }
 
 

sky/resources.py

@@ -1370,7 +1370,8 @@ class Resources:
         return features
 
     @staticmethod
-    def apply_resource_config_aliases(config: Optional[Dict[str, Any]]) -> None:
+    def _apply_resource_config_aliases(
+            config: Optional[Dict[str, Any]]) -> None:
         """Mutatively applies overriding aliases to the passed in config.
 
         Note: Nested aliases are not supported.
@@ -1399,7 +1400,15 @@ class Resources:
         if config is None:
             return {Resources()}
 
-        Resources.apply_resource_config_aliases(config)
+        Resources._apply_resource_config_aliases(config)
+        anyof = config.get('any_of')
+        if anyof is not None and isinstance(anyof, list):
+            for anyof_config in anyof:
+                Resources._apply_resource_config_aliases(anyof_config)
+        ordered = config.get('ordered')
+        if ordered is not None and isinstance(ordered, list):
+            for ordered_config in ordered:
+                Resources._apply_resource_config_aliases(ordered_config)
         common_utils.validate_schema(config, schemas.get_resources_schema(),
                                      'Invalid resources YAML: ')
 

sky/serve/__init__.py

@@ -3,6 +3,7 @@ import os
 
 from sky.serve.client.sdk import down
 from sky.serve.client.sdk import status
+from sky.serve.client.sdk import sync_down_logs
 from sky.serve.client.sdk import tail_logs
 from sky.serve.client.sdk import terminate_replica
 from sky.serve.client.sdk import up
@@ -37,6 +38,7 @@ __all__ = [
     'LB_POLICIES',
     'ReplicaStatus',
     'ServiceComponent',
+    'sync_down_logs',
     'ServiceStatus',
     'ServeCodeGen',
     'SkyServiceSpec',

sky/serve/autoscalers.py

@@ -676,8 +676,12 @@ class FallbackRequestRateAutoscaler(RequestRateAutoscaler):
             # because the provisioning spot can fail to UP due to the capacity
             # issue, and on-demand should fill the gap between the required
             # number of spot and ready spot.
-            num_ondemand_to_provision += (num_spot_to_provision -
-                                          num_ready_spot)
+            # When scaling down spot instances, it is possible that the number
+            # of ready spot is more than the number of spot to provision, thus
+            # generate a negative number. In this case, we don't need to
+            # provision on-demand instances.
+            num_ondemand_to_provision += max(
+                0, num_spot_to_provision - num_ready_spot)
 
         # Make sure we don't launch on-demand fallback for
         # overprovisioned replicas.

sky/serve/client/sdk.py

@@ -374,3 +374,64 @@ def tail_logs(service_name: str,
     )
     request_id = server_common.get_request_id(response)
     sdk.stream_response(request_id, response, output_stream)
+
+
+@usage_lib.entrypoint
+@server_common.check_server_healthy_or_start
+def sync_down_logs(service_name: str,
+                   local_dir: str,
+                   *,
+                   targets: Optional[Union[
+                       str, 'serve_utils.ServiceComponent',
+                       List[Union[str,
+                                  'serve_utils.ServiceComponent']]]] = None,
+                   replica_ids: Optional[List[int]] = None) -> None:
+    """Sync down logs from the service components to a local directory.
+
+    This function syncs logs from the specified service components (controller,
+    load balancer, replicas) via the API server to a specified local directory.
+
+    Args:
+        service_name: The name of the service to download logs from.
+        targets: Which component(s) to download logs for. If None or empty,
+            means download all logs (controller, load-balancer, all replicas).
+            Can be a string (e.g. "controller"), or a `ServiceComponent` object,
+            or a list of them for multiple components. Currently accepted
+            values:
+                - "controller"/ServiceComponent.CONTROLLER
+                - "load_balancer"/ServiceComponent.LOAD_BALANCER
+                - "replica"/ServiceComponent.REPLICA
+        replica_ids: The list of replica IDs to download logs from, specified
+            when target includes `ServiceComponent.REPLICA`. If target includes
+            `ServiceComponent.REPLICA` but this is None/empty, logs for all
+            replicas will be downloaded.
+        local_dir: Local directory to sync down logs to. Defaults to
+            `~/sky_logs`.
+
+    Raises:
+        RuntimeError: If fails to gather logs or fails to rsync from the
+          controller.
+        sky.exceptions.ClusterNotUpError: If the controller is not up.
+        ValueError: Arguments not valid.
+    """
+    # Avoid circular import.
+    from sky.client import sdk  # pylint: disable=import-outside-toplevel
+
+    body = payloads.ServeDownloadLogsBody(
+        service_name=service_name,
+        # No need to set here, since the server will override it
+        # to a directory on the API server.
+        local_dir=local_dir,
+        targets=targets,
+        replica_ids=replica_ids,
+    )
+    response = requests.post(
+        f'{server_common.get_server_url()}/serve/sync-down-logs',
+        json=json.loads(body.model_dump_json()),
+        timeout=(5, None),
+    )
+    remote_dir = sdk.stream_and_get(server_common.get_request_id(response))
+
+    # Download from API server paths to the client's local_dir
+    client_common.download_logs_from_api_server([remote_dir], remote_dir,
+                                                local_dir)

sky/serve/replica_managers.py

@@ -257,14 +257,6 @@ class ReplicaStatusProperty:
     # is set to True and it can fail immediately due to spot availability.
     failed_spot_availability: bool = False
 
-    def remove_terminated_replica(self) -> bool:
-        """Whether to remove the replica record from the replica table.
-
-        If not, the replica will stay in the replica table permanently to
-        notify the user that something is wrong with the user code / setup.
-        """
-        return self.is_scale_down
-
     def unrecoverable_failure(self) -> bool:
         """Whether the replica fails and cannot be recovered.
 
@@ -730,6 +722,12 @@ class SkyPilotReplicaManager(ReplicaManager):
                            replica_drain_delay_seconds: int,
                            is_scale_down: bool = False,
                            purge: bool = False) -> None:
+        left_in_record = not (is_scale_down or purge)
+        if left_in_record:
+            assert sync_down_logs, (
+                'For the replica left in the record, '
+                'the logs should always be synced down. '
+                'So that the user can see the logs to debug.')
 
         if replica_id in self._launch_process_pool:
             info = serve_state.get_replica_info_from_id(self._service_name,

sky/serve/serve_utils.py

@@ -13,7 +13,7 @@ import threading
 import time
 import typing
 from typing import (Any, Callable, DefaultDict, Dict, Generic, Iterator, List,
-                    Optional, TextIO, Type, TypeVar)
+                    Optional, TextIO, Type, TypeVar, Union)
 import uuid
 
 import colorama
@@ -81,6 +81,38 @@ class ServiceComponent(enum.Enum):
     REPLICA = 'replica'
 
 
+@dataclasses.dataclass
+class ServiceComponentTarget:
+    """Represents a target service component with an optional replica ID.
+    """
+    component: ServiceComponent
+    replica_id: Optional[int] = None
+
+    def __init__(self,
+                 component: Union[str, ServiceComponent],
+                 replica_id: Optional[int] = None):
+        if isinstance(component, str):
+            component = ServiceComponent(component)
+        self.component = component
+        self.replica_id = replica_id
+
+    def __post_init__(self):
+        """Validate that replica_id is only provided for REPLICA component."""
+        if (self.component
+                == ServiceComponent.REPLICA) != (self.replica_id is None):
+            raise ValueError(
+                'replica_id must be specified if and only if component is '
+                'REPLICA.')
+
+    def __hash__(self) -> int:
+        return hash((self.component, self.replica_id))
+
+    def __str__(self) -> str:
+        if self.component == ServiceComponent.REPLICA:
+            return f'{self.component.value}-{self.replica_id}'
+        return self.component.value
+
+
 class UserSignal(enum.Enum):
     """User signal to send to controller.
 

sky/serve/server/core.py

@@ -1,9 +1,11 @@
 """SkyServe core APIs."""
+import pathlib
 import re
 import signal
 import tempfile
 import threading
-from typing import Any, Dict, List, Optional, Tuple, Union
+import typing
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import colorama
 
@@ -29,6 +31,9 @@ from sky.utils import rich_utils
 from sky.utils import subprocess_utils
 from sky.utils import ux_utils
 
+if typing.TYPE_CHECKING:
+    from sky.backends import cloud_vm_ray_backend
+
 logger = sky_logging.init_logger(__name__)
 
 
@@ -64,6 +69,41 @@ def _rewrite_tls_credential_paths_and_get_tls_env_vars(
     return tls_template_vars
 
 
+def _get_all_replica_targets(
+    service_name: str, backend: backends.CloudVmRayBackend,
+    handle: backends.CloudVmRayResourceHandle
+) -> Set[serve_utils.ServiceComponentTarget]:
+    """Helper function to get targets for all live replicas."""
+    code = serve_utils.ServeCodeGen.get_service_status([service_name])
+    returncode, serve_status_payload, stderr = backend.run_on_head(
+        handle,
+        code,
+        require_outputs=True,
+        stream_logs=False,
+        separate_stderr=True)
+
+    try:
+        subprocess_utils.handle_returncode(returncode,
+                                           code,
+                                           'Failed to fetch services',
+                                           stderr,
+                                           stream_logs=True)
+    except exceptions.CommandError as e:
+        raise RuntimeError(e.error_msg) from e
+
+    service_records = serve_utils.load_service_status(serve_status_payload)
+    if not service_records:
+        raise ValueError(f'Service {service_name!r} not found.')
+    assert len(service_records) == 1
+    service_record = service_records[0]
+
+    return {
+        serve_utils.ServiceComponentTarget(serve_utils.ServiceComponent.REPLICA,
+                                           replica_info['replica_id'])
+        for replica_info in service_record['replica_info']
+    }
+
+
 @usage_lib.entrypoint
 def up(
     task: 'sky.Task',
@@ -685,11 +725,14 @@ def status(
     return service_records
 
 
+ServiceComponentOrStr = Union[str, serve_utils.ServiceComponent]
+
+
 @usage_lib.entrypoint
 def tail_logs(
     service_name: str,
     *,
-    target: Union[str, serve_utils.ServiceComponent],
+    target: ServiceComponentOrStr,
     replica_id: Optional[int] = None,
     follow: bool = True,
 ) -> None:
@@ -743,10 +786,11 @@ def tail_logs(
             with ux_utils.print_exception_no_traceback():
                 raise ValueError('`replica_id` must be None when using '
                                  'target=CONTROLLER/LOAD_BALANCER.')
+
+    controller_type = controller_utils.Controllers.SKY_SERVE_CONTROLLER
     handle = backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.SKY_SERVE_CONTROLLER,
-        stopped_message=(controller_utils.Controllers.SKY_SERVE_CONTROLLER.
-                         value.default_hint_if_non_existent))
+        controller=controller_type,
+        stopped_message=controller_type.value.default_hint_if_non_existent)
 
     backend = backend_utils.get_backend_from_handle(handle)
     assert isinstance(backend, backends.CloudVmRayBackend), backend
@@ -775,3 +819,141 @@ def tail_logs(
                         stream_logs=True,
                         process_stream=False,
                         ssh_mode=command_runner.SshMode.INTERACTIVE)
+
+
+@usage_lib.entrypoint
+def sync_down_logs(
+    service_name: str,
+    *,
+    local_dir: str,
+    targets: Union[ServiceComponentOrStr, List[ServiceComponentOrStr],
+                   None] = None,
+    replica_ids: Optional[List[int]] = None,
+) -> str:
+    """Sync down logs from the controller for the given service.
+
+    This function is called by the server endpoint. It gathers logs from the
+    controller, load balancer, and/or replicas and places them in a directory
+    under the user's log space on the API server filesystem.
+
+    Args:
+        service_name: The name of the service to download logs from.
+        local_dir: The local directory to save the logs to.
+        targets: Which component(s) to download logs for. If None or empty,
+            means download all logs (controller, load-balancer, all replicas).
+            Can be a string (e.g. "controller"), or a `ServiceComponent` object,
+            or a list of them for multiple components. Currently accepted
+            values:
+                - "controller"/ServiceComponent.CONTROLLER
+                - "load_balancer"/ServiceComponent.LOAD_BALANCER
+                - "replica"/ServiceComponent.REPLICA
+        replica_ids: The list of replica IDs to download logs from, specified
+            when target includes `ServiceComponent.REPLICA`. If target includes
+            `ServiceComponent.REPLICA` but this is None/empty, logs for all
+            replicas will be downloaded.
+
+    Returns:
+        A dict mapping component names to local paths where the logs were synced
+        down to.
+
+    Raises:
+        RuntimeError: If fails to gather logs or fails to rsync from the
+          controller.
+        sky.exceptions.ClusterNotUpError: If the controller is not up.
+        ValueError: Arguments not valid.
+    """
+    # Step 0) get the controller handle
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Checking service status...')):
+        controller_type = controller_utils.Controllers.SKY_SERVE_CONTROLLER
+        handle = backend_utils.is_controller_accessible(
+            controller=controller_type,
+            stopped_message=controller_type.value.default_hint_if_non_existent)
+        backend: backends.CloudVmRayBackend = (
+            backend_utils.get_backend_from_handle(handle))
+
+    requested_components: Set[serve_utils.ServiceComponent] = set()
+    if not targets:
+        # No targets specified -> request all components
+        requested_components = {
+            serve_utils.ServiceComponent.CONTROLLER,
+            serve_utils.ServiceComponent.LOAD_BALANCER,
+            serve_utils.ServiceComponent.REPLICA
+        }
+    else:
+        # Parse provided targets
+        if isinstance(targets, (str, serve_utils.ServiceComponent)):
+            requested_components = {serve_utils.ServiceComponent(targets)}
+        else:  # list
+            requested_components = {
+                serve_utils.ServiceComponent(t) for t in targets
+            }
+
+    normalized_targets: Set[serve_utils.ServiceComponentTarget] = set()
+    if serve_utils.ServiceComponent.CONTROLLER in requested_components:
+        normalized_targets.add(
+            serve_utils.ServiceComponentTarget(
+                serve_utils.ServiceComponent.CONTROLLER))
+    if serve_utils.ServiceComponent.LOAD_BALANCER in requested_components:
+        normalized_targets.add(
+            serve_utils.ServiceComponentTarget(
+                serve_utils.ServiceComponent.LOAD_BALANCER))
+    if serve_utils.ServiceComponent.REPLICA in requested_components:
+        with rich_utils.safe_status(
+                ux_utils.spinner_message('Getting live replica infos...')):
+            replica_targets = _get_all_replica_targets(service_name, backend,
+                                                       handle)
+        if not replica_ids:
+            # Replica target requested but no specific IDs
+            # -> Get all replica logs
+            normalized_targets.update(replica_targets)
+        else:
+            # Replica target requested with specific IDs
+            requested_replica_targets = [
+                serve_utils.ServiceComponentTarget(
+                    serve_utils.ServiceComponent.REPLICA, rid)
+                for rid in replica_ids
+            ]
+            for target in requested_replica_targets:
+                if target not in replica_targets:
+                    logger.warning(f'Replica ID {target.replica_id} not found '
+                                   f'for {service_name}. Skipping...')
+                else:
+                    normalized_targets.add(target)
+
+    def sync_down_logs_by_target(target: serve_utils.ServiceComponentTarget):
+        component = target.component
+        # We need to set one side of the pipe to a logs stream, and the other
+        # side to a file.
+        log_path = str(pathlib.Path(local_dir) / f'{target}.log')
+        stream_logs_code: str
+
+        if component == serve_utils.ServiceComponent.CONTROLLER:
+            stream_logs_code = (
+                serve_utils.ServeCodeGen.stream_serve_process_logs(
+                    service_name, stream_controller=True, follow=False))
+        elif component == serve_utils.ServiceComponent.LOAD_BALANCER:
+            stream_logs_code = (
+                serve_utils.ServeCodeGen.stream_serve_process_logs(
+                    service_name, stream_controller=False, follow=False))
+        elif component == serve_utils.ServiceComponent.REPLICA:
+            replica_id = target.replica_id
+            assert replica_id is not None, service_name
+            stream_logs_code = serve_utils.ServeCodeGen.stream_replica_logs(
+                service_name, replica_id, follow=False)
+        else:
+            assert False, component
+
+        # Refer to the notes in
+        # sky/backends/cloud_vm_ray_backend.py::CloudVmRayBackend::tail_logs.
+        backend.run_on_head(handle,
+                            stream_logs_code,
+                            stream_logs=False,
+                            process_stream=False,
+                            ssh_mode=command_runner.SshMode.INTERACTIVE,
+                            log_path=log_path)
+
+    subprocess_utils.run_in_parallel(sync_down_logs_by_target,
+                                     list(normalized_targets))
+
+    return local_dir

sky/serve/server/server.py

@@ -1,13 +1,17 @@
 """Rest APIs for SkyServe."""
 
+import pathlib
+
 import fastapi
 
 from sky import sky_logging
 from sky.serve.server import core
+from sky.server import common as server_common
 from sky.server import stream_utils
 from sky.server.requests import executor
 from sky.server.requests import payloads
 from sky.server.requests import requests as api_requests
+from sky.skylet import constants
 from sky.utils import common
 
 logger = sky_logging.init_logger(__name__)
@@ -110,3 +114,27 @@ async def tail_logs(
         logs_path=request_task.log_path,
         background_tasks=background_tasks,
     )
+
+
+@router.post('/sync-down-logs')
+async def download_logs(
+    request: fastapi.Request,
+    download_logs_body: payloads.ServeDownloadLogsBody,
+) -> None:
+    user_hash = download_logs_body.env_vars[constants.USER_ID_ENV_VAR]
+    timestamp = sky_logging.get_run_timestamp()
+    logs_dir_on_api_server = (
+        pathlib.Path(server_common.api_server_user_logs_dir_prefix(user_hash)) /
+        'service' / f'{download_logs_body.service_name}_{timestamp}')
+    logs_dir_on_api_server.mkdir(parents=True, exist_ok=True)
+    # We should reuse the original request body, so that the env vars, such as
+    # user hash, are kept the same.
+    download_logs_body.local_dir = str(logs_dir_on_api_server)
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='serve.sync_down_logs',
+        request_body=download_logs_body,
+        func=core.sync_down_logs,
+        schedule_type=api_requests.ScheduleType.SHORT,
+        request_cluster_name=common.SKY_SERVE_CONTROLLER_NAME,
+    )

sky/server/common.py

@@ -293,7 +293,25 @@ def _start_api_server(deploy: bool = False,
                 time.sleep(0.5)
             else:
                 break
-        logger.info(ux_utils.finishing_message('SkyPilot API server started.'))
+
+        dashboard_msg = (f'Dashboard: {get_server_url(host)}/dashboard')
+        api_server_info = get_api_server_status(get_server_url(host))
+        if api_server_info.version == _DEV_VERSION:
+            dashboard_msg += (
+                f'\n{colorama.Style.RESET_ALL}{ux_utils.INDENT_SYMBOL}'
+                f'{colorama.Fore.YELLOW}')
+            if not os.path.isdir(server_constants.DASHBOARD_DIR):
+                dashboard_msg += (
+                    'Dashboard is not built, '
+                    'to build: npm --prefix sky/dashboard run build')
+            else:
+                dashboard_msg += (
+                    'Dashboard may be stale when installed from source, '
+                    'to rebuild: npm --prefix sky/dashboard run build')
+            dashboard_msg += f'{colorama.Style.RESET_ALL}'
+        logger.info(
+            ux_utils.finishing_message(
+                f'SkyPilot API server started. {dashboard_msg}'))
 
 
 def check_server_healthy(endpoint: Optional[str] = None,) -> None:

sky/server/constants.py

@@ -1,5 +1,7 @@
 """Constants for the API servers."""
 
+import os
+
 from sky.skylet import constants
 
 # API server version, whenever there is a change in API server that requires a
@@ -24,3 +26,7 @@ CLUSTER_REFRESH_DAEMON_INTERVAL_SECONDS = 60
 
 # Environment variable for a file path to the API cookie file.
 API_COOKIE_FILE_ENV_VAR = f'{constants.SKYPILOT_ENV_VAR_PREFIX}API_COOKIE_FILE'
+
+# The path to the dashboard build output
+DASHBOARD_DIR = os.path.join(os.path.dirname(__file__), '..', 'dashboard',
+                             'out')

sky/server/requests/executor.py

@@ -358,6 +358,10 @@ def _request_execution_wrapper(request_id: str,
         # captured in the log file.
         try:
             with override_request_env_and_config(request_body):
+                if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+                    config = skypilot_config.to_dict()
+                    logger.debug(f'request config: \n'
+                                 f'{common_utils.dump_yaml_str(dict(config))}')
                 return_value = func(**request_body.to_kwargs())
                 f.flush()
         except KeyboardInterrupt: