prefect-client 3.0.2__py3-none-any.whl → 3.0.4__py3-none-any.whl

prefect/events/clients.py

@@ -34,6 +34,7 @@ from prefect.settings import (
     PREFECT_API_KEY,
     PREFECT_API_URL,
     PREFECT_CLOUD_API_URL,
+    PREFECT_DEBUG_MODE,
     PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
 )
 
@@ -67,6 +68,18 @@ EVENT_WEBSOCKET_CHECKPOINTS = Counter(
 logger = get_logger(__name__)
 
 
+def http_to_ws(url: str):
+    return url.replace("https://", "wss://").replace("http://", "ws://").rstrip("/")
+
+
+def events_in_socket_from_api_url(url: str):
+    return http_to_ws(url) + "/events/in"
+
+
+def events_out_socket_from_api_url(url: str):
+    return http_to_ws(url) + "/events/out"
+
+
 def get_events_client(
     reconnection_attempts: int = 10,
     checkpoint_every: int = 700,
@@ -251,12 +264,7 @@ class PrefectEventsClient(EventsClient):
                 "api_url must be provided or set in the Prefect configuration"
             )
 
-        self._events_socket_url = (
-            api_url.replace("https://", "wss://")
-            .replace("http://", "ws://")
-            .rstrip("/")
-            + "/events/in"
-        )
+        self._events_socket_url = events_in_socket_from_api_url(api_url)
         self._connect = connect(self._events_socket_url)
         self._websocket = None
         self._reconnection_attempts = reconnection_attempts
@@ -285,11 +293,26 @@ class PrefectEventsClient(EventsClient):
             self._websocket = None
             await self._connect.__aexit__(None, None, None)
 
-        self._websocket = await self._connect.__aenter__()
-
-        # make sure we have actually connected
-        pong = await self._websocket.ping()
-        await pong
+        try:
+            self._websocket = await self._connect.__aenter__()
+            # make sure we have actually connected
+            pong = await self._websocket.ping()
+            await pong
+        except Exception as e:
+            # The client is frequently run in a background thread
+            # so we log an additional warning to ensure
+            # surfacing the error to the user.
+            logger.warning(
+                "Unable to connect to %r. "
+                "Please check your network settings to ensure websocket connections "
+                "to the API are allowed. Otherwise event data (including task run data) may be lost. "
+                "Reason: %s. "
+                "Set PREFECT_DEBUG_MODE=1 to see the full error.",
+                self._events_socket_url,
+                str(e),
+                exc_info=PREFECT_DEBUG_MODE,
+            )
+            raise
 
         events_to_resend = self._unconfirmed_events
         # Clear the unconfirmed events here, because they are going back through emit
@@ -412,7 +435,6 @@ class PrefectCloudEventsClient(PrefectEventsClient):
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
         )
-
         self._connect = connect(
             self._events_socket_url,
             extra_headers={"Authorization": f"bearer {api_key}"},
@@ -468,11 +490,7 @@ class PrefectEventSubscriber:
         self._filter = filter or EventFilter()  # type: ignore[call-arg]
         self._seen_events = TTLCache(maxsize=SEEN_EVENTS_SIZE, ttl=SEEN_EVENTS_TTL)
 
-        socket_url = (
-            api_url.replace("https://", "wss://")
-            .replace("http://", "ws://")
-            .rstrip("/")
-        ) + "/events/out"
+        socket_url = events_out_socket_from_api_url(api_url)
 
         logger.debug("Connecting to %s", socket_url)
 
@@ -527,11 +545,11 @@ class PrefectEventSubscriber:
                 f"Reason: {e.args[0]}"
             )
         except ConnectionClosedError as e:
-            raise Exception(
-                "Unable to authenticate to the event stream. Please ensure the "
-                "provided api_key you are using is valid for this environment. "
-                f"Reason: {e.reason}"
-            ) from e
+            reason = getattr(e.rcvd, "reason", None)
+            msg = "Unable to authenticate to the event stream. Please ensure the "
+            msg += "provided api_key you are using is valid for this environment. "
+            msg += f"Reason: {reason}" if reason else ""
+            raise Exception(msg) from e
 
         from prefect.events.filters import EventOccurredFilter
 

prefect/filesystems.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional
 
 import anyio
 import fsspec
-from pydantic import Field, SecretStr, field_validator
+from pydantic import BaseModel, Field, SecretStr, field_validator
 
 from prefect._internal.schemas.validators import (
     stringify_path,
@@ -519,4 +519,29 @@ class SMB(WritableFileSystem, WritableDeploymentStorage):
         return await self.filesystem.write_path(path=path, content=content)
 
 
+class NullFileSystem(BaseModel):
+    """
+    A file system that does not store any data.
+    """
+
+    async def read_path(self, path: str) -> None:
+        pass
+
+    async def write_path(self, path: str, content: bytes) -> None:
+        pass
+
+    async def get_directory(
+        self, from_path: Optional[str] = None, local_path: Optional[str] = None
+    ) -> None:
+        pass
+
+    async def put_directory(
+        self,
+        local_path: Optional[str] = None,
+        to_path: Optional[str] = None,
+        ignore_file: Optional[str] = None,
+    ) -> None:
+        pass
+
+
 __getattr__ = getattr_migration(__name__)

prefect/flows.py

@@ -51,8 +51,8 @@ from prefect._internal.concurrency.api import create_call, from_async
 from prefect.blocks.core import Block
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.objects import ConcurrencyLimitConfig, FlowRun
 from prefect.client.schemas.objects import Flow as FlowSchema
-from prefect.client.schemas.objects import FlowRun
 from prefect.client.utilities import client_injector
 from prefect.docker.docker_image import DockerImage
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
@@ -258,11 +258,11 @@ class Flow(Generic[P, R]):
         if not callable(fn):
             raise TypeError("'fn' must be callable")
 
-        # Validate name if given
-        if name:
-            _raise_on_name_with_banned_characters(name)
-
-        self.name = name or fn.__name__.replace("_", "-")
+        self.name = name or fn.__name__.replace("_", "-").replace(
+            "<lambda>",
+            "unknown-lambda",  # prefect API will not accept "<" or ">" in flow names
+        )
+        _raise_on_name_with_banned_characters(self.name)
 
         if flow_run_name is not None:
             if not isinstance(flow_run_name, str) and not callable(flow_run_name):
@@ -535,7 +535,7 @@ class Flow(Generic[P, R]):
 
         def resolve_block_reference(data: Any) -> Any:
             if isinstance(data, dict) and "$ref" in data:
-                return Block.load_from_ref(data["$ref"])
+                return Block.load_from_ref(data["$ref"], _sync=True)
             return data
 
         try:
@@ -643,7 +643,7 @@ class Flow(Generic[P, R]):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -715,6 +715,7 @@ class Flow(Generic[P, R]):
                 storage=self._storage,
                 entrypoint=self._entrypoint,
                 name=name,
+                flow_name=self.name,
                 interval=interval,
                 cron=cron,
                 rrule=rrule,
@@ -733,7 +734,7 @@ class Flow(Generic[P, R]):
             )  # type: ignore # TODO: remove sync_compatible
         else:
             return RunnerDeployment.from_flow(
-                self,
+                flow=self,
                 name=name,
                 interval=interval,
                 cron=cron,
@@ -798,6 +799,7 @@ class Flow(Generic[P, R]):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
+        global_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
@@ -827,6 +829,7 @@ class Flow(Generic[P, R]):
             paused: Whether or not to set this deployment as paused.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
+            global_limit: The maximum number of concurrent runs allowed across all served flow instances associated with the same deployment.
             parameters: A dictionary of default parameter values to pass to runs of this deployment.
             description: A description for the created deployment. Defaults to the flow's
                 description if not provided.
@@ -838,7 +841,7 @@ class Flow(Generic[P, R]):
             pause_on_shutdown: If True, provided schedule will be paused when the serve function is stopped.
                 If False, the schedules will continue running.
             print_starting_message: Whether or not to print the starting message when flow is served.
-            limit: The maximum number of runs that can be executed concurrently.
+            limit: The maximum number of runs that can be executed concurrently by the created runner; only applies to this served flow. To apply a limit across multiple served flows, use `global_limit`.
             webserver: Whether or not to start a monitoring webserver for this flow.
             entrypoint_type: Type of entrypoint to use for the deployment. When using a module path
                 entrypoint, ensure that the module will be importable in the execution environment.
@@ -890,6 +893,7 @@ class Flow(Generic[P, R]):
             rrule=rrule,
             paused=paused,
             schedules=schedules,
+            concurrency_limit=global_limit,
             parameters=parameters,
             description=description,
             tags=tags,
@@ -1057,7 +1061,7 @@ class Flow(Generic[P, R]):
         rrule: Optional[str] = None,
         paused: Optional[bool] = None,
         schedules: Optional[List[DeploymentScheduleCreate]] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
@@ -1252,6 +1256,15 @@ class Flow(Generic[P, R]):
     ) -> T:
         ...
 
+    @overload
+    def __call__(
+        self: "Flow[P, Coroutine[Any, Any, T]]",
+        *args: P.args,
+        return_state: Literal[True],
+        **kwargs: P.kwargs,
+    ) -> Awaitable[State[T]]:
+        ...
+
     @overload
     def __call__(
         self: "Flow[P, T]",
@@ -1622,7 +1635,7 @@ def flow(
         )
 
 
-def _raise_on_name_with_banned_characters(name: str) -> str:
+def _raise_on_name_with_banned_characters(name: Optional[str]) -> Optional[str]:
     """
     Raise an InvalidNameError if the given name contains any invalid
     characters.

prefect/locking/filesystem.py

@@ -38,10 +38,10 @@ class FileSystemLockManager(LockManager):
     """
 
     def __init__(self, lock_files_directory: Path):
-        self.lock_files_directory = lock_files_directory
+        self.lock_files_directory = lock_files_directory.expanduser().resolve()
         self._locks: Dict[str, _LockInfo] = {}
 
-    def _ensure_records_directory_exists(self):
+    def _ensure_lock_files_directory_exists(self):
         self.lock_files_directory.mkdir(parents=True, exist_ok=True)
 
     def _lock_path_for_key(self, key: str) -> Path:
@@ -98,7 +98,7 @@ class FileSystemLockManager(LockManager):
         acquire_timeout: Optional[float] = None,
         hold_timeout: Optional[float] = None,
     ) -> bool:
-        self._ensure_records_directory_exists()
+        self._ensure_lock_files_directory_exists()
         lock_path = self._lock_path_for_key(key)
 
         if self.is_locked(key) and not self.is_lock_holder(key, holder):

prefect/plugins.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, Union
 import prefect.settings
 from prefect.utilities.compat import EntryPoints, entry_points
 
+COLLECTIONS: Union[None, Dict[str, Union[ModuleType, Exception]]] = None
+
 
 def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception, Any]]:
     """
@@ -38,11 +40,16 @@ def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception
     return results
 
 
-def load_prefect_collections() -> Dict[str, ModuleType]:
+def load_prefect_collections() -> Dict[str, Union[ModuleType, Exception]]:
     """
     Load all Prefect collections that define an entrypoint in the group
     `prefect.collections`.
     """
+    global COLLECTIONS
+
+    if COLLECTIONS is not None:
+        return COLLECTIONS
+
     collection_entrypoints: EntryPoints = entry_points(group="prefect.collections")
     collections = safe_load_entrypoints(collection_entrypoints)
 
@@ -61,4 +68,5 @@ def load_prefect_collections() -> Dict[str, ModuleType]:
             if prefect.settings.PREFECT_DEBUG_MODE:
                 print(f"Loaded collection {name!r}.")
 
+    COLLECTIONS = collections
     return collections

prefect/results.py

@@ -8,6 +8,7 @@ from functools import partial
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
+    Annotated,
     Any,
     Callable,
     Dict,
@@ -25,8 +26,10 @@ from cachetools import LRUCache
 from pydantic import (
     BaseModel,
     ConfigDict,
+    Discriminator,
     Field,
     PrivateAttr,
+    Tag,
     ValidationError,
     model_serializer,
     model_validator,
@@ -47,6 +50,7 @@ from prefect.exceptions import (
 )
 from prefect.filesystems import (
     LocalFileSystem,
+    NullFileSystem,
     WritableFileSystem,
 )
 from prefect.locking.protocol import LockManager
@@ -91,18 +95,26 @@ async def get_default_result_storage() -> WritableFileSystem:
     Generate a default file system for result storage.
     """
     default_block = PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value()
+    basepath = PREFECT_LOCAL_STORAGE_PATH.value()
+
+    cache_key = (str(default_block), str(basepath))
+
+    if cache_key in _default_storages:
+        return _default_storages[cache_key]
 
     if default_block is not None:
-        return await resolve_result_storage(default_block)
+        storage = await resolve_result_storage(default_block)
+    else:
+        # Use the local file system
+        storage = LocalFileSystem(basepath=str(basepath))
 
-    # otherwise, use the local file system
-    basepath = PREFECT_LOCAL_STORAGE_PATH.value()
-    return LocalFileSystem(basepath=str(basepath))
+    _default_storages[cache_key] = storage
+    return storage
 
 
 @sync_compatible
 async def resolve_result_storage(
-    result_storage: Union[ResultStorage, UUID],
+    result_storage: Union[ResultStorage, UUID, Path],
 ) -> WritableFileSystem:
     """
     Resolve one of the valid `ResultStorage` input types into a saved block
@@ -119,6 +131,8 @@ async def resolve_result_storage(
             storage_block_id = storage_block._block_document_id
         else:
             storage_block_id = None
+    elif isinstance(result_storage, Path):
+        storage_block = LocalFileSystem(basepath=str(result_storage))
     elif isinstance(result_storage, str):
         storage_block = await Block.load(result_storage, client=client)
         storage_block_id = storage_block._block_document_id
@@ -208,6 +222,19 @@ def _format_user_supplied_storage_key(key: str) -> str:
 T = TypeVar("T")
 
 
+def result_storage_discriminator(x: Any) -> str:
+    if isinstance(x, dict):
+        if "block_type_slug" in x:
+            return "WritableFileSystem"
+        else:
+            return "NullFileSystem"
+    if isinstance(x, WritableFileSystem):
+        return "WritableFileSystem"
+    if isinstance(x, NullFileSystem):
+        return "NullFileSystem"
+    return "None"
+
+
 @deprecated_field(
     "persist_result",
     when=lambda x: x is not None,
@@ -235,7 +262,14 @@ class ResultStore(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     result_storage: Optional[WritableFileSystem] = Field(default=None)
-    metadata_storage: Optional[WritableFileSystem] = Field(default=None)
+    metadata_storage: Annotated[
+        Union[
+            Annotated[WritableFileSystem, Tag("WritableFileSystem")],
+            Annotated[NullFileSystem, Tag("NullFileSystem")],
+            Annotated[None, Tag("None")],
+        ],
+        Discriminator(result_storage_discriminator),
+    ] = Field(default=None)
     lock_manager: Optional[LockManager] = Field(default=None)
     cache_result_in_memory: bool = Field(default=True)
     serializer: Serializer = Field(default_factory=get_default_result_serializer)
@@ -271,6 +305,7 @@ class ResultStore(BaseModel):
             update["cache_result_in_memory"] = flow.cache_result_in_memory
         if self.result_storage is None and update.get("result_storage") is None:
             update["result_storage"] = await get_default_result_storage()
+        update["metadata_storage"] = NullFileSystem()
         return self.model_copy(update=update)
 
     @sync_compatible
@@ -284,6 +319,8 @@ class ResultStore(BaseModel):
         Returns:
             An updated result store.
         """
+        from prefect.transactions import get_transaction
+
         update = {}
         if task.result_storage is not None:
             update["result_storage"] = await resolve_result_storage(task.result_storage)
@@ -295,8 +332,30 @@ class ResultStore(BaseModel):
             update["storage_key_fn"] = partial(
                 _format_user_supplied_storage_key, task.result_storage_key
             )
+
+        # use the lock manager from a parent transaction if it exists
+        if (current_txn := get_transaction()) and isinstance(
+            current_txn.store, ResultStore
+        ):
+            update["lock_manager"] = current_txn.store.lock_manager
+
+        if task.cache_policy is not None and task.cache_policy is not NotSet:
+            if task.cache_policy.key_storage is not None:
+                storage = task.cache_policy.key_storage
+                if isinstance(storage, str) and not len(storage.split("/")) == 2:
+                    storage = Path(storage)
+                update["metadata_storage"] = await resolve_result_storage(storage)
+            # if the cache policy has a lock manager, it takes precedence over the parent transaction
+            if task.cache_policy.lock_manager is not None:
+                update["lock_manager"] = task.cache_policy.lock_manager
+
         if self.result_storage is None and update.get("result_storage") is None:
             update["result_storage"] = await get_default_result_storage()
+        if (
+            isinstance(self.metadata_storage, NullFileSystem)
+            and update.get("metadata_storage", NotSet) is NotSet
+        ):
+            update["metadata_storage"] = None
         return self.model_copy(update=update)
 
     @staticmethod
@@ -414,7 +473,9 @@ class ResultStore(BaseModel):
             )
         else:
             content = await self.result_storage.read_path(key)
-            result_record = ResultRecord.deserialize(content)
+            result_record = ResultRecord.deserialize(
+                content, backup_serializer=self.serializer
+            )
 
         if self.cache_result_in_memory:
             if self.result_storage_block_id is None and hasattr(
@@ -427,26 +488,36 @@ class ResultStore(BaseModel):
             self.cache[cache_key] = result_record
         return result_record
 
-    def read(self, key: str, holder: Optional[str] = None) -> "ResultRecord":
+    def read(
+        self,
+        key: str,
+        holder: Optional[str] = None,
+    ) -> "ResultRecord":
         """
         Read a result record from storage.
 
         Args:
             key: The key to read the result record from.
             holder: The holder of the lock if a lock was set on the record.
+
         Returns:
             A result record.
         """
         holder = holder or self.generate_default_holder()
         return self._read(key=key, holder=holder, _sync=True)
 
-    async def aread(self, key: str, holder: Optional[str] = None) -> "ResultRecord":
+    async def aread(
+        self,
+        key: str,
+        holder: Optional[str] = None,
+    ) -> "ResultRecord":
         """
         Read a result record from storage.
 
         Args:
             key: The key to read the result record from.
             holder: The holder of the lock if a lock was set on the record.
+
         Returns:
             A result record.
         """
@@ -1007,17 +1078,31 @@ class ResultRecord(BaseModel, Generic[R]):
         )
 
     @classmethod
-    def deserialize(cls, data: bytes) -> "ResultRecord[R]":
+    def deserialize(
+        cls, data: bytes, backup_serializer: Optional[Serializer] = None
+    ) -> "ResultRecord[R]":
         """
         Deserialize a record from bytes.
 
         Args:
             data: the serialized record
+            backup_serializer: The serializer to use to deserialize the result record. Only
+                necessary if the provided data does not specify a serializer.
 
         Returns:
             ResultRecord: the deserialized record
         """
-        instance = cls.model_validate_json(data)
+        try:
+            instance = cls.model_validate_json(data)
+        except ValidationError:
+            if backup_serializer is None:
+                raise
+            else:
+                result = backup_serializer.loads(data)
+                return cls(
+                    metadata=ResultRecordMetadata(serializer=backup_serializer),
+                    result=result,
+                )
         if isinstance(instance.result, bytes):
             instance.result = instance.serializer.loads(instance.result)
         elif isinstance(instance.result, str):

prefect/runner/runner.py

@@ -64,12 +64,16 @@ from prefect.client.schemas.filters import (
     FlowRunFilterStateName,
     FlowRunFilterStateType,
 )
+from prefect.client.schemas.objects import (
+    ConcurrencyLimitConfig,
+    FlowRun,
+    State,
+    StateType,
+)
 from prefect.client.schemas.objects import Flow as APIFlow
-from prefect.client.schemas.objects import FlowRun, State, StateType
 from prefect.concurrency.asyncio import (
     AcquireConcurrencySlotTimeoutError,
     ConcurrencySlotAcquisitionError,
-    concurrency,
 )
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.events.related import tags_as_related_resources
@@ -87,7 +91,6 @@ from prefect.settings import (
     get_current_settings,
 )
 from prefect.states import (
-    AwaitingConcurrencySlot,
     Crashed,
     Pending,
     exception_to_failed_state,
@@ -236,7 +239,7 @@ class Runner:
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        concurrency_limit: Optional[int] = None,
+        concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -1042,28 +1045,12 @@ class Runner:
     ) -> Union[Optional[int], Exception]:
         run_logger = self._get_flow_run_logger(flow_run)
 
-        if flow_run.deployment_id:
-            deployment = await self._client.read_deployment(flow_run.deployment_id)
-        if deployment and deployment.concurrency_limit:
-            limit_name = f"deployment:{deployment.id}"
-            concurrency_ctx = concurrency
-
-            # ensure that the global concurrency limit is available
-            # and up-to-date before attempting to acquire a slot
-            await self._client.upsert_global_concurrency_limit_by_name(
-                limit_name, deployment.concurrency_limit
-            )
-        else:
-            limit_name = ""
-            concurrency_ctx = asyncnullcontext
-
         try:
-            async with concurrency_ctx(limit_name, max_retries=0, strict=True):
-                status_code = await self._run_process(
-                    flow_run=flow_run,
-                    task_status=task_status,
-                    entrypoint=entrypoint,
-                )
+            status_code = await self._run_process(
+                flow_run=flow_run,
+                task_status=task_status,
+                entrypoint=entrypoint,
+            )
         except (
             AcquireConcurrencySlotTimeoutError,
             ConcurrencySlotAcquisitionError,
@@ -1165,26 +1152,6 @@ class Runner:
                 exc_info=True,
             )
 
-    async def _propose_scheduled_state(self, flow_run: "FlowRun") -> None:
-        run_logger = self._get_flow_run_logger(flow_run)
-        try:
-            state = await propose_state(
-                self._client,
-                AwaitingConcurrencySlot(),
-                flow_run_id=flow_run.id,
-            )
-            self._logger.info(f"Flow run {flow_run.id} now has state {state.name}")
-        except Abort as exc:
-            run_logger.info(
-                (
-                    f"Aborted rescheduling of flow run '{flow_run.id}'. "
-                    f"Server sent an abort signal: {exc}"
-                ),
-            )
-            pass
-        except Exception:
-            run_logger.exception(f"Failed to update state of flow run '{flow_run.id}'")
-
     async def _propose_crashed_state(self, flow_run: "FlowRun", message: str) -> None:
         run_logger = self._get_flow_run_logger(flow_run)
         try: