indexify 0.4.21__py3-none-any.whl → 0.4.23__py3-none-any.whl

indexify/cli/executor.py

@@ -1,4 +1,4 @@
-from tensorlake.utils.logging import (
+from indexify.executor.logging import (
     configure_development_mode_logging,
     configure_logging_early,
     configure_production_mode_logging,
@@ -162,13 +162,6 @@ def executor(
         shutil.rmtree(str(executor_cache_path))
     executor_cache_path.mkdir(parents=True, exist_ok=True)
 
-    blob_store: BLOBStore = BLOBStore(
-        # Local FS mode is used in tests and in cases when user wants to store data on NFS.
-        local=LocalFSBLOBStore(),
-        # S3 is initiliazed lazily so it's okay to create it even if the user is not going to use it.
-        s3=S3BLOBStore(),
-    )
-
     host_resources_provider: HostResourcesProvider = HostResourcesProvider(
         gpu_allocator=NvidiaGPUAllocator(logger),
         # Assuming a simple setup in OSS where Executor container has a single file system
@@ -200,6 +193,6 @@ def executor(
         config_path=config_path,
         monitoring_server_host=monitoring_server_host,
         monitoring_server_port=monitoring_server_port,
-        blob_store=blob_store,
+        blob_store=BLOBStore(),
         host_resources_provider=host_resources_provider,
     ).run()

indexify/executor/blob_store/blob_store.py

@@ -1,13 +1,25 @@
-from typing import Any, Optional
+from typing import Any
 
 from .local_fs_blob_store import LocalFSBLOBStore
 from .metrics.blob_store import (
+    metric_abort_multipart_upload_errors,
+    metric_abort_multipart_upload_latency,
+    metric_abort_multipart_upload_requests,
+    metric_complete_multipart_upload_errors,
+    metric_complete_multipart_upload_latency,
+    metric_complete_multipart_upload_requests,
+    metric_create_multipart_upload_errors,
+    metric_create_multipart_upload_latency,
+    metric_create_multipart_upload_requests,
     metric_get_blob_errors,
     metric_get_blob_latency,
     metric_get_blob_requests,
-    metric_put_blob_errors,
-    metric_put_blob_latency,
-    metric_put_blob_requests,
+    metric_presign_uri_errors,
+    metric_presign_uri_latency,
+    metric_presign_uri_requests,
+    metric_upload_blob_errors,
+    metric_upload_blob_latency,
+    metric_upload_blob_requests,
 )
 from .s3_blob_store import S3BLOBStore
 
@@ -15,12 +27,9 @@ from .s3_blob_store import S3BLOBStore
 class BLOBStore:
     """Dispatches generic BLOB store calls to their real backends."""
 
-    def __init__(
-        self, local: Optional[LocalFSBLOBStore] = None, s3: Optional[S3BLOBStore] = None
-    ):
-        """Creates a BLOB store that uses the supplied BLOB stores."""
-        self._local: Optional[LocalFSBLOBStore] = local
-        self._s3: Optional[S3BLOBStore] = s3
+    def __init__(self):
+        self._local: LocalFSBLOBStore = LocalFSBLOBStore()
+        self._s3: S3BLOBStore = S3BLOBStore()
 
     async def get(self, uri: str, logger: Any) -> bytes:
         """Returns binary value stored in BLOB with the supplied URI.
@@ -33,36 +42,111 @@ class BLOBStore:
         ):
             metric_get_blob_requests.inc()
             if _is_file_uri(uri):
-                self._check_local_is_available()
                 return await self._local.get(uri, logger)
             else:
-                self._check_s3_is_available()
                 return await self._s3.get(uri, logger)
 
-    async def put(self, uri: str, value: bytes, logger: Any) -> None:
+    async def presign_get_uri(self, uri: str, expires_in_sec: int, logger: Any) -> str:
+        """Returns a presigned URI for getting the BLOB with the supplied URI.
+
+        The URI allows to read any byte range in the BLOB."""
+        with (
+            metric_presign_uri_errors.count_exceptions(),
+            metric_presign_uri_latency.time(),
+        ):
+            metric_presign_uri_requests.inc()
+            if _is_file_uri(uri):
+                return await self._local.presign_get_uri(uri, expires_in_sec, logger)
+            else:
+                return await self._s3.presign_get_uri(uri, expires_in_sec, logger)
+
+    async def upload(self, uri: str, value: bytes, logger: Any) -> None:
         """Stores the supplied binary value in a BLOB with the supplied URI.
 
         Overwrites existing BLOB. Raises Exception on error.
         """
         with (
-            metric_put_blob_errors.count_exceptions(),
-            metric_put_blob_latency.time(),
+            metric_upload_blob_errors.count_exceptions(),
+            metric_upload_blob_latency.time(),
+        ):
+            metric_upload_blob_requests.inc()
+            if _is_file_uri(uri):
+                await self._local.upload(uri, value, logger)
+            else:
+                await self._s3.upload(uri, value, logger)
+
+    async def create_multipart_upload(self, uri: str, logger: Any) -> str:
+        """Creates a multipart upload for BLOB with the supplied URI and returns the upload ID."""
+        with (
+            metric_create_multipart_upload_errors.count_exceptions(),
+            metric_create_multipart_upload_latency.time(),
         ):
-            metric_put_blob_requests.inc()
+            metric_create_multipart_upload_requests.inc()
             if _is_file_uri(uri):
-                self._check_local_is_available()
-                await self._local.put(uri, value, logger)
+                return await self._local.create_multipart_upload(uri, logger)
             else:
-                self._check_s3_is_available()
-                await self._s3.put(uri, value, logger)
+                return await self._s3.create_multipart_upload(uri, logger)
 
-    def _check_local_is_available(self):
-        if self._local is None:
-            raise RuntimeError("Local file system BLOB store is not available")
+    async def complete_multipart_upload(
+        self, uri: str, upload_id: str, parts_etags: list[str], logger: Any
+    ) -> None:
+        """Completes a multipart upload for BLOB with the supplied URI.
 
-    def _check_s3_is_available(self):
-        if self._s3 is None:
-            raise RuntimeError("S3 BLOB store is not available")
+        parts_etags is a list of ETags for the parts that were uploaded.
+        The list is ordered by part number starting from 1.
+        """
+        with (
+            metric_complete_multipart_upload_errors.count_exceptions(),
+            metric_complete_multipart_upload_latency.time(),
+        ):
+            metric_complete_multipart_upload_requests.inc()
+            if _is_file_uri(uri):
+                await self._local.complete_multipart_upload(
+                    uri, upload_id, parts_etags, logger
+                )
+            else:
+                await self._s3.complete_multipart_upload(
+                    uri, upload_id, parts_etags, logger
+                )
+
+    async def abort_multipart_upload(
+        self, uri: str, upload_id: str, logger: Any
+    ) -> None:
+        """Aborts a multipart upload for BLOB with the supplied URI."""
+        with (
+            metric_abort_multipart_upload_errors.count_exceptions(),
+            metric_abort_multipart_upload_latency.time(),
+        ):
+            metric_abort_multipart_upload_requests.inc()
+            if _is_file_uri(uri):
+                await self._local.abort_multipart_upload(uri, upload_id, logger)
+            else:
+                await self._s3.abort_multipart_upload(uri, upload_id, logger)
+
+    async def presign_upload_part_uri(
+        self,
+        uri: str,
+        part_number: int,
+        upload_id: str,
+        expires_in_sec: int,
+        logger: Any,
+    ) -> str:
+        """Returns a presigned URI for uploading a part in a multipart upload.
+
+        part_number starts from 1."""
+        with (
+            metric_presign_uri_errors.count_exceptions(),
+            metric_presign_uri_latency.time(),
+        ):
+            metric_presign_uri_requests.inc()
+            if _is_file_uri(uri):
+                return await self._local.presign_upload_part_uri(
+                    uri, part_number, upload_id, expires_in_sec, logger
+                )
+            else:
+                return await self._s3.presign_upload_part_uri(
+                    uri, part_number, upload_id, expires_in_sec, logger
+                )
 
 
 def _is_file_uri(uri: str) -> bool:

indexify/executor/blob_store/local_fs_blob_store.py

@@ -16,7 +16,14 @@ class LocalFSBLOBStore:
         # Run synchronous code in a thread to not block the event loop.
         return await asyncio.to_thread(self._sync_get, _path_from_file_uri(uri))
 
-    async def put(self, uri: str, value: bytes, logger: Any) -> None:
+    async def presign_get_uri(self, uri: str, expires_in_sec: int, logger: Any) -> str:
+        """Returns a presigned URI for getting the file at the supplied URI.
+
+        For local files, just returns the file URI itself.
+        """
+        return uri
+
+    async def upload(self, uri: str, value: bytes, logger: Any) -> None:
         """Stores the supplied binary value in a file at the supplied URI.
 
         The URI must be a file URI (starts with "file://"). The path must be absolute.
@@ -25,6 +32,39 @@ class LocalFSBLOBStore:
         # Run synchronous code in a thread to not block the event loop.
         return await asyncio.to_thread(self._sync_put, _path_from_file_uri(uri), value)
 
+    async def create_multipart_upload(self, uri: str, logger: Any) -> str:
+        """Creates a multipart upload for local file and returns a dummy upload ID."""
+        # Local files do not require multipart upload, return a dummy ID
+        return "local-multipart-upload-id"
+
+    async def complete_multipart_upload(
+        self, uri: str, upload_id: str, parts_etags: list[str], logger: Any
+    ) -> None:
+        """Completes a multipart upload for local file. No-op for local files."""
+        # No action needed for local files
+        return None
+
+    async def abort_multipart_upload(
+        self, uri: str, upload_id: str, logger: Any
+    ) -> None:
+        """Aborts a multipart upload for local file. No-op for local files."""
+        # No action needed for local files
+        return None
+
+    async def presign_upload_part_uri(
+        self,
+        uri: str,
+        part_number: int,
+        upload_id: str,
+        expires_in_sec: int,
+        logger: Any,
+    ) -> str:
+        """Returns a presigned URI for uploading a part in a multipart upload for local file.
+
+        For local files, just returns the file URI itself.
+        """
+        return uri
+
     def _sync_get(self, path: str) -> bytes:
         if not os.path.isabs(path):
             raise ValueError(f"Path {path} must be absolute")

indexify/executor/blob_store/metrics/blob_store.py

@@ -3,31 +3,103 @@ import prometheus_client
 from ...monitoring.metrics import latency_metric_for_fast_operation
 
 metric_get_blob_requests: prometheus_client.Counter = prometheus_client.Counter(
-    "get_blob_requests",
-    "Number of get blob requests",
+    "blob_store_get_requests",
+    "Number of get BLOB requests in BLOB store",
 )
 metric_get_blob_errors: prometheus_client.Counter = prometheus_client.Counter(
-    "get_blob_request_errors",
-    "Number of get blob request errors",
+    "blob_store_get_request_errors",
+    "Number of get BLOB request errors in BLOB store",
 )
 metric_get_blob_latency: prometheus_client.Histogram = (
     latency_metric_for_fast_operation(
-        "get_blob_request",
-        "get blob request",
+        "blob_store_get",
+        "BLOB store get BLOB request",
     )
 )
 
-metric_put_blob_requests: prometheus_client.Counter = prometheus_client.Counter(
-    "put_blob_requests",
-    "Number of put blob requests",
+metric_presign_uri_requests: prometheus_client.Counter = prometheus_client.Counter(
+    "blob_store_presign_uri_requests",
+    "Number of presign URI requests in BLOB store",
 )
-metric_put_blob_errors: prometheus_client.Counter = prometheus_client.Counter(
-    "put_blob_request_errors",
-    "Number of put blob request errors",
+metric_presign_uri_errors: prometheus_client.Counter = prometheus_client.Counter(
+    "blob_store_presign_uri_request_errors",
+    "Number of presign URI request errors in BLOB store",
 )
-metric_put_blob_latency: prometheus_client.Histogram = (
+metric_presign_uri_latency: prometheus_client.Histogram = (
     latency_metric_for_fast_operation(
-        "put_blob_request",
-        "put blob request",
+        "blob_store_presign_uri",
+        "BLOB store presign URI request",
+    )
+)
+
+metric_upload_blob_requests: prometheus_client.Counter = prometheus_client.Counter(
+    "blob_store_upload_requests",
+    "Number of upload BLOB requests in BLOB store",
+)
+metric_upload_blob_errors: prometheus_client.Counter = prometheus_client.Counter(
+    "blob_store_upload_request_errors",
+    "Number of upload BLOB request errors in BLOB store",
+)
+metric_upload_blob_latency: prometheus_client.Histogram = (
+    latency_metric_for_fast_operation(
+        "blob_store_upload",
+        "BLOB store upload BLOB request",
+    )
+)
+
+metric_create_multipart_upload_requests: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_create_multipart_upload_requests",
+        "Number of create multipart upload requests in BLOB store",
+    )
+)
+metric_create_multipart_upload_errors: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_create_multipart_upload_request_errors",
+        "Number of create multipart upload request errors in BLOB store",
+    )
+)
+metric_create_multipart_upload_latency: prometheus_client.Histogram = (
+    latency_metric_for_fast_operation(
+        "blob_store_create_multipart_upload_request",
+        "create multipart upload request in BLOB store",
+    )
+)
+
+metric_complete_multipart_upload_requests: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_complete_multipart_upload_requests",
+        "Number of complete multipart upload requests in BLOB store",
+    )
+)
+metric_complete_multipart_upload_errors: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_complete_multipart_upload_request_errors",
+        "Number of complete multipart upload request errors in BLOB store",
+    )
+)
+metric_complete_multipart_upload_latency: prometheus_client.Histogram = (
+    latency_metric_for_fast_operation(
+        "blob_store_complete_multipart_upload_request",
+        "complete multipart upload request in BLOB store",
+    )
+)
+
+metric_abort_multipart_upload_requests: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_abort_multipart_upload_requests",
+        "Number of abort multipart upload requests in BLOB store",
+    )
+)
+metric_abort_multipart_upload_errors: prometheus_client.Counter = (
+    prometheus_client.Counter(
+        "blob_store_abort_multipart_upload_request_errors",
+        "Number of abort multipart upload request errors in BLOB store",
+    )
+)
+metric_abort_multipart_upload_latency: prometheus_client.Histogram = (
+    latency_metric_for_fast_operation(
+        "blob_store_abort_multipart_upload_request",
+        "abort multipart upload request in BLOB store",
     )
 )

indexify/executor/blob_store/s3_blob_store.py

@@ -59,7 +59,28 @@ class S3BLOBStore:
             logger.error("failed to get S3 object", uri=uri, exc_info=e)
             raise
 
-    async def put(self, uri: str, value: bytes, logger: Any) -> None:
+    async def presign_get_uri(self, uri: str, expires_in_sec: int, logger: Any) -> str:
+        """Returns a presigned URI for getting the S3 object at the supplied URI."""
+        self._lazy_create_client()
+        bucket_name, key = _bucket_name_and_object_key_from_uri(uri)
+        try:
+            s3_uri: str = await asyncio.to_thread(
+                self._s3_client.generate_presigned_url,
+                ClientMethod="get_object",
+                Params={"Bucket": bucket_name, "Key": key},
+                ExpiresIn=expires_in_sec,
+            )
+            return s3_uri.replace("https://", "s3://", 1)
+        except Exception as e:
+            logger.error(
+                "failed to presign URI for get_object operation",
+                uri=uri,
+                exc_info=e,
+                expires_in_sec=expires_in_sec,
+            )
+            raise
+
+    async def upload(self, uri: str, value: bytes, logger: Any) -> None:
         """Stores the supplied binary value in a S3 object at the supplied URI.
 
         The URI must be S3 URI (starts with "s3://").
@@ -75,6 +96,96 @@ class S3BLOBStore:
             logger.error("failed to set S3 object", uri=uri, exc_info=e)
             raise
 
+    async def create_multipart_upload(self, uri: str, logger: Any) -> str:
+        """Creates a multipart upload for S3 object and returns the upload ID."""
+        self._lazy_create_client()
+        bucket_name, key = _bucket_name_and_object_key_from_uri(uri)
+        try:
+            response = await asyncio.to_thread(
+                self._s3_client.create_multipart_upload,
+                Bucket=bucket_name,
+                Key=key,
+            )
+            return response["UploadId"]
+        except Exception as e:
+            logger.error("failed to create multipart upload", uri=uri, exc_info=e)
+            raise
+
+    async def complete_multipart_upload(
+        self, uri: str, upload_id: str, parts_etags: list[str], logger: Any
+    ) -> None:
+        """Completes a multipart upload for S3 object."""
+        self._lazy_create_client()
+        bucket_name, key = _bucket_name_and_object_key_from_uri(uri)
+        try:
+            await asyncio.to_thread(
+                self._s3_client.complete_multipart_upload,
+                Bucket=bucket_name,
+                Key=key,
+                UploadId=upload_id,
+                MultipartUpload={
+                    "Parts": [
+                        {"ETag": etag, "PartNumber": i + 1}
+                        for i, etag in enumerate(parts_etags)
+                    ]
+                },
+            )
+        except Exception as e:
+            logger.error("failed to complete multipart upload", uri=uri, exc_info=e)
+            raise
+
+    async def abort_multipart_upload(
+        self, uri: str, upload_id: str, logger: Any
+    ) -> None:
+        """Aborts a multipart upload for S3 object."""
+        self._lazy_create_client()
+        bucket_name, key = _bucket_name_and_object_key_from_uri(uri)
+        try:
+            await asyncio.to_thread(
+                self._s3_client.abort_multipart_upload,
+                Bucket=bucket_name,
+                Key=key,
+                UploadId=upload_id,
+            )
+        except Exception as e:
+            logger.error("failed to abort multipart upload", uri=uri, exc_info=e)
+            raise
+
+    async def presign_upload_part_uri(
+        self,
+        uri: str,
+        part_number: int,
+        upload_id: str,
+        expires_in_sec: int,
+        logger: Any,
+    ) -> str:
+        """Returns a presigned URI for uploading a part in a multipart upload for S3 object."""
+        self._lazy_create_client()
+        bucket_name, key = _bucket_name_and_object_key_from_uri(uri)
+        try:
+            response = await asyncio.to_thread(
+                self._s3_client.generate_presigned_url,
+                ClientMethod="upload_part",
+                Params={
+                    "Bucket": bucket_name,
+                    "Key": key,
+                    "UploadId": upload_id,
+                    "PartNumber": part_number,
+                },
+                ExpiresIn=expires_in_sec,
+            )
+            return response
+        except Exception as e:
+            logger.error(
+                "failed to presign URI for upload_part operation",
+                uri=uri,
+                exc_info=e,
+                part_number=part_number,
+                upload_id=upload_id,
+                expires_in_sec=expires_in_sec,
+            )
+            raise
+
 
 def _bucket_name_and_object_key_from_uri(uri: str) -> tuple[str, str]:
     # Example S3 object URI:

indexify/executor/function_executor/function_executor.py

@@ -1,14 +1,11 @@
 import asyncio
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Optional
 
 import grpc
 from tensorlake.function_executor.proto.function_executor_pb2 import (
     InfoRequest,
     InfoResponse,
-    InitializationFailureReason,
-    InitializationOutcomeCode,
     InitializeRequest,
     InitializeResponse,
 )
@@ -18,6 +15,8 @@ from tensorlake.function_executor.proto.function_executor_pb2_grpc import (
 from tensorlake.function_executor.proto.message_validator import MessageValidator
 from tensorlake.utils.http_client import get_httpx_client
 
+from indexify.executor.monitoring.metrics import IdempotentCounterChanger
+
 from .health_checker import HealthChecker
 from .invocation_state_client import InvocationStateClient
 from .metrics.function_executor import (
@@ -60,19 +59,14 @@ from .server.function_executor_server_factory import (
 )
 
 
-class FunctionExecutorInitializationError(Enum):
-    FUNCTION_TIMEOUT = 1
-    FUNCTION_ERROR = 2
-
-
 @dataclass
 class FunctionExecutorInitializationResult:
     """Result of FunctionExecutor initialization."""
 
-    # None error means success.
-    error: Optional[FunctionExecutorInitializationError] = None
-    stdout: Optional[str] = None
-    stderr: Optional[str] = None
+    # If True, timed out waiting for the Function Executor to initialize.
+    is_timeout: bool
+    # FE is unresponsive if response is None.
+    response: Optional[InitializeResponse]
 
 
 class FunctionExecutor:
@@ -89,12 +83,17 @@ class FunctionExecutor:
 
     def __init__(self, server_factory: FunctionExecutorServerFactory, logger: Any):
         self._server_factory: FunctionExecutorServerFactory = server_factory
-        self._logger = logger.bind(module=__name__)
+        self._logger: Any = logger.bind(module=__name__)
         self._server: Optional[FunctionExecutorServer] = None
         self._channel: Optional[grpc.aio.Channel] = None
         self._invocation_state_client: Optional[InvocationStateClient] = None
         self._health_checker: Optional[HealthChecker] = None
-        metric_function_executors_count.inc()
+        self._function_executors_counter_changer: IdempotentCounterChanger = (
+            IdempotentCounterChanger(
+                metric_function_executors_count,
+            )
+        )
+        self._function_executors_counter_changer.inc()
 
     async def initialize(
         self,
@@ -102,11 +101,11 @@ class FunctionExecutor:
         initialize_request: InitializeRequest,
         base_url: str,
         config_path: Optional[str],
-        customer_code_timeout_sec: Optional[float] = None,
+        customer_code_timeout_sec: float,
     ) -> FunctionExecutorInitializationResult:
         """Creates and initializes a FunctionExecutorServer and all resources associated with it.
 
-        Raises an Exception if an internal error occured."""
+        Raises an Exception if an Executor side internal error occured."""
         try:
             with (
                 metric_create_errors.count_exceptions(),
@@ -126,7 +125,7 @@ class FunctionExecutor:
                 await self._create_health_checker(self._channel, stub)
 
                 return await _initialize_server(
-                    stub, initialize_request, customer_code_timeout_sec
+                    stub, initialize_request, customer_code_timeout_sec, self._logger
                 )
         except Exception:
             await self.destroy()
@@ -152,7 +151,7 @@ class FunctionExecutor:
                 metric_destroy_errors.count_exceptions(),
                 metric_destroy_latency.time(),
             ):
-                metric_function_executors_count.dec()
+                self._function_executors_counter_changer.dec()
                 metric_destroys.inc()
                 await self._destroy_health_checker()
                 await self._destroy_invocation_state_client()
@@ -306,7 +305,8 @@ async def _collect_server_info(stub: FunctionExecutorStub) -> None:
 async def _initialize_server(
     stub: FunctionExecutorStub,
     initialize_request: InitializeRequest,
-    customer_code_timeout_sec: Optional[float],
+    customer_code_timeout_sec: float,
+    logger: Any,
 ) -> FunctionExecutorInitializationResult:
     with (
         metric_initialize_rpc_errors.count_exceptions(),
@@ -317,46 +317,22 @@ async def _initialize_server(
                 initialize_request,
                 timeout=customer_code_timeout_sec,
             )
-
-            if (
-                initialize_response.outcome_code
-                == InitializationOutcomeCode.INITIALIZE_OUTCOME_CODE_SUCCESS
-            ):
+            return FunctionExecutorInitializationResult(
+                is_timeout=False,
+                response=initialize_response,
+            )
+        except grpc.aio.AioRpcError as e:
+            if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
                 return FunctionExecutorInitializationResult(
-                    stdout=initialize_response.stdout, stderr=initialize_response.stderr
+                    is_timeout=True,
+                    response=None,
                 )
-            elif (
-                initialize_response.outcome_code
-                == InitializationOutcomeCode.INITIALIZE_OUTCOME_CODE_FAILURE
-            ):
-                if (
-                    initialize_response.failure_reason
-                    == InitializationFailureReason.INITIALIZATION_FAILURE_REASON_FUNCTION_ERROR
-                ):
-                    return FunctionExecutorInitializationResult(
-                        error=FunctionExecutorInitializationError.FUNCTION_ERROR,
-                        stdout=initialize_response.stdout,
-                        stderr=initialize_response.stderr,
-                    )
-                elif (
-                    initialize_response.failure_reason
-                    == InitializationFailureReason.INITIALIZATION_FAILURE_REASON_INTERNAL_ERROR
-                ):
-                    # Don't add stdout/stderr because this is customer data.
-                    raise RuntimeError("initialize RPC failed with internal error")
-                else:
-                    raise ValueError(
-                        f"unexpected failure reason {InitializationFailureReason.Name(initialize_response.failure_reason)} in initialize RPC response"
-                    )
             else:
-                raise ValueError(
-                    f"unexpected outcome code {InitializationOutcomeCode.Name(initialize_response.outcome_code)} in initialize RPC response"
+                logger.error(
+                    "Function Executor initialize RPC failed",
+                    exc_info=e,
                 )
-
-        except grpc.aio.AioRpcError as e:
-            if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
                 return FunctionExecutorInitializationResult(
-                    error=FunctionExecutorInitializationError.FUNCTION_TIMEOUT,
-                    stderr=f"Function initialization exceeded its configured timeout of {customer_code_timeout_sec:.3f} sec.",
+                    is_timeout=False,
+                    response=None,
                 )
-            raise