prefect-client 3.1.11__py3-none-any.whl → 3.1.12__py3-none-any.whl

prefect/states.py

@@ -6,7 +6,7 @@ import uuid
 import warnings
 from collections import Counter
 from types import GeneratorType, TracebackType
-from typing import Any, Dict, Iterable, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Type
 
 import anyio
 import httpx
@@ -28,16 +28,16 @@ from prefect.exceptions import (
     UnfinishedRun,
 )
 from prefect.logging.loggers import get_logger, get_run_logger
-from prefect.results import (
-    R,
-    ResultRecord,
-    ResultRecordMetadata,
-    ResultStore,
-)
 from prefect.utilities.annotations import BaseAnnotation
 from prefect.utilities.asyncutils import in_async_main_thread, sync_compatible
 from prefect.utilities.collections import ensure_iterable
 
+if TYPE_CHECKING:
+    from prefect.results import (
+        R,
+        ResultStore,
+    )
+
 logger = get_logger("states")
 
 
@@ -49,11 +49,11 @@ logger = get_logger("states")
     help="Please ensure you are awaiting the call to `result()` when calling in an async context.",
 )
 def get_state_result(
-    state: State[R],
+    state: "State[R]",
     raise_on_failure: bool = True,
     fetch: bool = True,
     retry_result_failure: bool = True,
-) -> R:
+) -> "R":
     """
     Get the result from a state.
 
@@ -86,13 +86,18 @@ RESULT_READ_RETRY_DELAY = 0.25
 
 
 async def _get_state_result_data_with_retries(
-    state: State[R], retry_result_failure: bool = True
-) -> R:
+    state: "State[R]", retry_result_failure: bool = True
+) -> "R":
     # Results may be written asynchronously, possibly after their corresponding
     # state has been written and events have been emitted, so we should give some
     # grace here about missing results.  The exception below could come in the form
     # of a missing file, a short read, or other types of errors depending on the
     # result storage backend.
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     if retry_result_failure is False:
         max_attempts = 1
     else:
@@ -120,11 +125,16 @@ async def _get_state_result_data_with_retries(
 
 @sync_compatible
 async def _get_state_result(
-    state: State[R], raise_on_failure: bool, retry_result_failure: bool = True
-) -> R:
+    state: "State[R]", raise_on_failure: bool, retry_result_failure: bool = True
+) -> "R":
     """
     Internal implementation for `get_state_result` without async backwards compatibility
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     if state.is_paused():
         # Paused states are not truly terminal and do not have results associated with them
         raise PausedRun("Run is paused, its result is not available.", state=state)
@@ -181,7 +191,7 @@ def format_exception(exc: BaseException, tb: TracebackType = None) -> str:
 
 async def exception_to_crashed_state(
     exc: BaseException,
-    result_store: Optional[ResultStore] = None,
+    result_store: Optional["ResultStore"] = None,
 ) -> State:
     """
     Takes an exception that occurs _outside_ of user code and converts it to a
@@ -233,7 +243,7 @@ async def exception_to_crashed_state(
 
 async def exception_to_failed_state(
     exc: Optional[BaseException] = None,
-    result_store: Optional[ResultStore] = None,
+    result_store: Optional["ResultStore"] = None,
     write_result: bool = False,
     **kwargs,
 ) -> State:
@@ -285,12 +295,12 @@ async def exception_to_failed_state(
 
 
 async def return_value_to_state(
-    retval: R,
-    result_store: ResultStore,
+    retval: "R",
+    result_store: "ResultStore",
     key: Optional[str] = None,
     expiration: Optional[datetime.datetime] = None,
     write_result: bool = False,
-) -> State[R]:
+) -> "State[R]":
     """
     Given a return value from a user's function, create a `State` the run should
     be placed in.
@@ -311,6 +321,11 @@ async def return_value_to_state(
     Callers should resolve all futures into states before passing return values to this
     function.
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
+
     try:
         local_logger = get_run_logger()
     except MissingContextError:
@@ -443,6 +458,10 @@ async def get_state_exception(state: State) -> BaseException:
         - `CrashedRun` if the state type is CRASHED.
         - `CancelledRun` if the state type is CANCELLED.
     """
+    from prefect.results import (
+        ResultRecord,
+        ResultRecordMetadata,
+    )
 
     if state.is_failed():
         wrapper = FailedRun
@@ -586,7 +605,7 @@ class StateGroup:
         return f"StateGroup<{self.counts_message()}>"
 
 
-def _traced(cls: Type[State[R]], **kwargs: Any) -> State[R]:
+def _traced(cls: Type["State[R]"], **kwargs: Any) -> "State[R]":
     state_details = StateDetails.model_validate(kwargs.pop("state_details", {}))
 
     carrier = {}
@@ -597,10 +616,10 @@ def _traced(cls: Type[State[R]], **kwargs: Any) -> State[R]:
 
 
 def Scheduled(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Scheduled` states.
 
     Returns:
@@ -616,7 +635,7 @@ def Scheduled(
     return _traced(cls, type=StateType.SCHEDULED, state_details=state_details, **kwargs)
 
 
-def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Completed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Completed` states.
 
     Returns:
@@ -626,7 +645,7 @@ def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.COMPLETED, **kwargs)
 
 
-def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Running(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Running` states.
 
     Returns:
@@ -635,7 +654,7 @@ def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.RUNNING, **kwargs)
 
 
-def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Failed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Failed` states.
 
     Returns:
@@ -644,7 +663,7 @@ def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.FAILED, **kwargs)
 
 
-def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Crashed(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Crashed` states.
 
     Returns:
@@ -653,7 +672,7 @@ def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CRASHED, **kwargs)
 
 
-def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Cancelling(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Cancelling` states.
 
     Returns:
@@ -662,7 +681,7 @@ def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CANCELLING, **kwargs)
 
 
-def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Cancelled(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Cancelled` states.
 
     Returns:
@@ -671,7 +690,7 @@ def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     return _traced(cls, type=StateType.CANCELLED, **kwargs)
 
 
-def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Pending(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Pending` states.
 
     Returns:
@@ -681,13 +700,13 @@ def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
 
 
 def Paused(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     reschedule: bool = False,
     pause_key: Optional[str] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Paused` states.
 
     Returns:
@@ -717,7 +736,7 @@ def Paused(
 
 
 def Suspended(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     pause_key: Optional[str] = None,
@@ -740,10 +759,10 @@ def Suspended(
 
 
 def AwaitingRetry(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `AwaitingRetry` states.
 
     Returns:
@@ -755,10 +774,10 @@ def AwaitingRetry(
 
 
 def AwaitingConcurrencySlot(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `AwaitingConcurrencySlot` states.
 
     Returns:
@@ -769,7 +788,7 @@ def AwaitingConcurrencySlot(
     )
 
 
-def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
+def Retrying(cls: Type["State[R]"] = State, **kwargs: Any) -> "State[R]":
     """Convenience function for creating `Retrying` states.
 
     Returns:
@@ -779,10 +798,10 @@ def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
 
 
 def Late(
-    cls: Type[State[R]] = State,
+    cls: Type["State[R]"] = State,
     scheduled_time: Optional[datetime.datetime] = None,
     **kwargs: Any,
-) -> State[R]:
+) -> "State[R]":
     """Convenience function for creating `Late` states.
 
     Returns:

prefect/task_runners.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import asyncio
 import sys
@@ -14,7 +16,6 @@ from typing import (
     Iterable,
     List,
     Optional,
-    Set,
     overload,
 )
 
@@ -44,7 +45,7 @@ if TYPE_CHECKING:
 P = ParamSpec("P")
 T = TypeVar("T")
 R = TypeVar("R")
-F = TypeVar("F", bound=PrefectFuture, default=PrefectConcurrentFuture)
+F = TypeVar("F", bound=PrefectFuture[Any], default=PrefectConcurrentFuture[Any])
 
 
 class TaskRunner(abc.ABC, Generic[F]):
@@ -76,10 +77,10 @@ class TaskRunner(abc.ABC, Generic[F]):
     @abc.abstractmethod
     def submit(
         self,
-        task: "Task",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        task: "Task[P, R]",
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
     ) -> F:
         """
         Submit a task to the task run engine.
@@ -98,7 +99,7 @@ class TaskRunner(abc.ABC, Generic[F]):
     def map(
         self,
         task: "Task[P, R]",
-        parameters: Dict[str, Any],
+        parameters: dict[str, Any],
         wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
     ) -> PrefectFutureList[F]:
         """
@@ -138,9 +139,9 @@ class TaskRunner(abc.ABC, Generic[F]):
         # Ensure that any parameters in kwargs are expanded before this check
         parameters = explode_variadic_parameter(task.fn, parameters)
 
-        iterable_parameters = {}
-        static_parameters = {}
-        annotated_parameters = {}
+        iterable_parameters: dict[str, Any] = {}
+        static_parameters: dict[str, Any] = {}
+        annotated_parameters: dict[str, Any] = {}
         for key, val in parameters.items():
             if isinstance(val, (allow_failure, quote)):
                 # Unwrap annotated parameters to determine if they are iterable
@@ -172,9 +173,9 @@ class TaskRunner(abc.ABC, Generic[F]):
 
         map_length = list(lengths)[0]
 
-        futures: List[PrefectFuture] = []
+        futures: List[PrefectFuture[Any]] = []
         for i in range(map_length):
-            call_parameters = {
+            call_parameters: dict[str, Any] = {
                 key: value[i] for key, value in iterable_parameters.items()
             }
             call_parameters.update(
@@ -212,12 +213,12 @@ class TaskRunner(abc.ABC, Generic[F]):
         self._started = True
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any):
         self.logger.debug("Stopping task runner")
         self._started = False
 
 
-class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
+class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture[Any]]):
     def __init__(self, max_workers: Optional[int] = None):
         super().__init__()
         self._executor: Optional[ThreadPoolExecutor] = None
@@ -235,9 +236,9 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
     def submit(
         self,
         task: "Task[P, Coroutine[Any, Any, R]]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
     ) -> PrefectConcurrentFuture[R]:
         ...
 
@@ -245,19 +246,19 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
     def submit(
         self,
         task: "Task[Any, R]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
     ) -> PrefectConcurrentFuture[R]:
         ...
 
     def submit(
         self,
-        task: "Task",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    ):
+        task: "Task[P, R]",
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
+    ) -> PrefectConcurrentFuture[R]:
         """
         Submit a task to the task run engine running in a separate thread.
 
@@ -289,7 +290,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
         else:
             self.logger.debug(f"Submitting task {task.name} to thread pool executor...")
 
-        submit_kwargs = dict(
+        submit_kwargs: dict[str, Any] = dict(
             task=task,
             task_run_id=task_run_id,
             parameters=parameters,
@@ -322,8 +323,8 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
     def map(
         self,
         task: "Task[P, Coroutine[Any, Any, R]]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
     ) -> PrefectFutureList[PrefectConcurrentFuture[R]]:
         ...
 
@@ -331,17 +332,17 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
     def map(
         self,
         task: "Task[Any, R]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
     ) -> PrefectFutureList[PrefectConcurrentFuture[R]]:
         ...
 
     def map(
         self,
-        task: "Task",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-    ):
+        task: "Task[P, R]",
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+    ) -> PrefectFutureList[PrefectConcurrentFuture[R]]:
         return super().map(task, parameters, wait_for)
 
     def cancel_all(self):
@@ -358,7 +359,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
         self._executor = ThreadPoolExecutor(max_workers=self._max_workers)
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any):
         self.cancel_all()
         if self._executor is not None:
             self._executor.shutdown(cancel_futures=True)
@@ -375,7 +376,7 @@ class ThreadPoolTaskRunner(TaskRunner[PrefectConcurrentFuture]):
 ConcurrentTaskRunner = ThreadPoolTaskRunner
 
 
-class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture]):
+class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture[R]]):
     def __init__(self):
         super().__init__()
 
@@ -386,9 +387,9 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture]):
     def submit(
         self,
         task: "Task[P, Coroutine[Any, Any, R]]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
     ) -> PrefectDistributedFuture[R]:
         ...
 
@@ -396,19 +397,19 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture]):
     def submit(
         self,
         task: "Task[Any, R]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
     ) -> PrefectDistributedFuture[R]:
         ...
 
     def submit(
         self,
-        task: "Task",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        dependencies: Optional[Dict[str, Set[TaskRunInput]]] = None,
-    ):
+        task: "Task[P, R]",
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+        dependencies: dict[str, set[TaskRunInput]] | None = None,
+    ) -> PrefectDistributedFuture[R]:
         """
         Submit a task to the task run engine running in a separate thread.
 
@@ -443,8 +444,8 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture]):
     def map(
         self,
         task: "Task[P, Coroutine[Any, Any, R]]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
     ) -> PrefectFutureList[PrefectDistributedFuture[R]]:
         ...
 
@@ -452,15 +453,15 @@ class PrefectTaskRunner(TaskRunner[PrefectDistributedFuture]):
     def map(
         self,
         task: "Task[Any, R]",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
     ) -> PrefectFutureList[PrefectDistributedFuture[R]]:
         ...
 
     def map(
         self,
-        task: "Task",
-        parameters: Dict[str, Any],
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-    ):
+        task: "Task[P, R]",
+        parameters: dict[str, Any],
+        wait_for: Iterable[PrefectFuture[Any]] | None = None,
+    ) -> PrefectFutureList[PrefectDistributedFuture[R]]:
         return super().map(task, parameters, wait_for)

prefect/task_worker.py

@@ -21,7 +21,7 @@ from websockets.exceptions import InvalidStatusCode
 
 from prefect import Task
 from prefect._internal.concurrency.api import create_call, from_sync
-from prefect.cache_policies import DEFAULT, NONE
+from prefect.cache_policies import DEFAULT, NO_CACHE
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import TaskRun
 from prefect.client.subscriptions import Subscription
@@ -93,7 +93,7 @@ class TaskWorker:
                 if not isinstance(t, Task):
                     continue
 
-            if t.cache_policy in [None, NONE, NotSet]:
+            if t.cache_policy in [None, NO_CACHE, NotSet]:
                 self.tasks.append(
                     t.with_options(persist_result=True, cache_policy=DEFAULT)
                 )

prefect/tasks.py

@@ -30,7 +30,7 @@ from uuid import UUID, uuid4
 from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypeIs
 
 import prefect.states
-from prefect.cache_policies import DEFAULT, NONE, CachePolicy
+from prefect.cache_policies import DEFAULT, NO_CACHE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
 from prefect.client.schemas.objects import (
@@ -441,7 +441,9 @@ class Task(Generic[P, R]):
         if persist_result is None:
             if any(
                 [
-                    cache_policy and cache_policy != NONE and cache_policy != NotSet,
+                    cache_policy
+                    and cache_policy != NO_CACHE
+                    and cache_policy != NotSet,
                     cache_key_fn is not None,
                     result_storage_key is not None,
                     result_storage is not None,
@@ -451,8 +453,8 @@ class Task(Generic[P, R]):
                 persist_result = True
 
         if persist_result is False:
-            self.cache_policy = None if cache_policy is None else NONE
-            if cache_policy and cache_policy is not NotSet and cache_policy != NONE:
+            self.cache_policy = None if cache_policy is None else NO_CACHE
+            if cache_policy and cache_policy is not NotSet and cache_policy != NO_CACHE:
                 logger.warning(
                     "Ignoring `cache_policy` because `persist_result` is False"
                 )

prefect/telemetry/bootstrap.py

@@ -2,6 +2,9 @@ from typing import TYPE_CHECKING, Union
 
 import prefect.settings
 from prefect.client.base import ServerType, determine_server_type
+from prefect.logging.loggers import get_logger
+
+logger = get_logger(__name__)
 
 if TYPE_CHECKING:
     from opentelemetry.sdk._logs import LoggerProvider
@@ -16,30 +19,28 @@ def setup_telemetry() -> (
     ]
 ):
     settings = prefect.settings.get_current_settings()
-    if not settings.experiments.telemetry_enabled:
-        return None, None, None
 
     server_type = determine_server_type()
     if server_type != ServerType.CLOUD:
         return None, None, None
 
+    if not settings.cloud.enable_orchestration_telemetry:
+        return None, None, None
+
     if not settings.api.key:
-        raise ValueError(
+        logger.warning(
             "A Prefect Cloud API key is required to enable telemetry. Please set "
             "the `PREFECT_API_KEY` environment variable or authenticate with "
             "Prefect Cloud via the `prefect cloud login` command."
         )
+        return None, None, None
 
     assert settings.api.url
 
     # This import is here to defer importing of the `opentelemetry` packages.
     try:
         from .instrumentation import setup_exporters
-    except ImportError as exc:
-        raise ValueError(
-            "Unable to import OpenTelemetry instrumentation libraries. Please "
-            "ensure you have installed the `otel` extra when installing Prefect: "
-            "`pip install 'prefect[otel]'`"
-        ) from exc
+    except ImportError:
+        return None, None, None
 
     return setup_exporters(settings.api.url, settings.api.key.get_secret_value())

prefect/telemetry/services.py

@@ -53,6 +53,8 @@ class QueueingSpanExporter(BaseQueueingExporter[ReadableSpan], SpanExporter):
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         for item in spans:
+            if self._stopped:
+                break
             self.send(item)
         return SpanExportResult.SUCCESS
 
@@ -65,4 +67,6 @@ class QueueingLogExporter(BaseQueueingExporter[LogData], LogExporter):
 
     def export(self, batch: Sequence[LogData]) -> None:
         for item in batch:
+            if self._stopped:
+                break
             self.send(item)