prefect-client 3.1.0__py3-none-any.whl → 3.1.1__py3-none-any.whl

prefect/_internal/compatibility/async_dispatch.py

@@ -0,0 +1,73 @@
+import asyncio
+import inspect
+from functools import wraps
+from typing import Any, Callable, Coroutine, Protocol, TypeVar, Union
+
+from typing_extensions import ParamSpec
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+class AsyncDispatchable(Protocol[P, R]):
+    """Protocol for functions decorated with async_dispatch."""
+
+    def __call__(
+        self, *args: P.args, **kwargs: P.kwargs
+    ) -> Union[R, Coroutine[Any, Any, R]]:
+        ...
+
+    aio: Callable[P, Coroutine[Any, Any, R]]
+    sync: Callable[P, R]
+
+
+def is_in_async_context() -> bool:
+    """Check if we're in an async context."""
+    try:
+        # First check if we're in a coroutine
+        if asyncio.current_task() is not None:
+            return True
+
+        # Check if we have a loop and it's running
+        loop = asyncio.get_event_loop()
+        return loop.is_running()
+    except RuntimeError:
+        return False
+
+
+def async_dispatch(
+    async_impl: Callable[P, Coroutine[Any, Any, R]],
+) -> Callable[[Callable[P, R]], AsyncDispatchable[P, R]]:
+    """
+    Decorator that adds async compatibility to a sync function.
+
+    The decorated function will:
+    - Return a coroutine when in an async context (detected via running event loop)
+    - Run synchronously when in a sync context
+    - Provide .aio for explicit async access
+    - Provide .sync for explicit sync access
+
+    Args:
+        async_impl: The async implementation to dispatch to when async execution
+                   is needed
+    """
+    if not inspect.iscoroutinefunction(async_impl):
+        raise TypeError(
+            "async_impl must be an async function to dispatch in async contexts"
+        )
+
+    def decorator(sync_fn: Callable[P, R]) -> AsyncDispatchable[P, R]:
+        @wraps(sync_fn)
+        def wrapper(
+            *args: P.args, **kwargs: P.kwargs
+        ) -> Union[R, Coroutine[Any, Any, R]]:
+            if is_in_async_context():
+                return async_impl(*args, **kwargs)
+            return sync_fn(*args, **kwargs)
+
+        # Attach both async and sync implementations directly
+        wrapper.aio = async_impl
+        wrapper.sync = sync_fn
+        return wrapper  # type: ignore
+
+    return decorator

prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-31T12:43:46-0700",
+ "date": "2024-11-08T12:38:16-0800",
  "dirty": true,
  "error": null,
- "full-revisionid": "a83ba39b095e5945140ab6313e39dbc56056afe1",
- "version": "3.1.0"
+ "full-revisionid": "6b50a2b9f9d4ebf59703c55e1156c6f79151f1c3",
+ "version": "3.1.1"
 }
 '''  # END VERSION_JSON
 

prefect/client/orchestration.py

@@ -99,6 +99,7 @@ from prefect.client.schemas.objects import (
     TaskRunResult,
     Variable,
     Worker,
+    WorkerMetadata,
     WorkPool,
     WorkQueue,
     WorkQueueStatusDetail,
@@ -2596,6 +2597,7 @@ class PrefectClient:
         worker_name: str,
         heartbeat_interval_seconds: Optional[float] = None,
         get_worker_id: bool = False,
+        worker_metadata: Optional[WorkerMetadata] = None,
     ) -> Optional[UUID]:
         """
         Sends a worker heartbeat for a given work pool.
@@ -2604,20 +2606,20 @@ class PrefectClient:
             work_pool_name: The name of the work pool to heartbeat against.
             worker_name: The name of the worker sending the heartbeat.
             return_id: Whether to return the worker ID. Note: will return `None` if the connected server does not support returning worker IDs, even if `return_id` is `True`.
+            worker_metadata: Metadata about the worker to send to the server.
         """
-
+        params = {
+            "name": worker_name,
+            "heartbeat_interval_seconds": heartbeat_interval_seconds,
+        }
+        if worker_metadata:
+            params["worker_metadata"] = worker_metadata.model_dump(mode="json")
         if get_worker_id:
-            return_dict = {"return_id": get_worker_id}
-        else:
-            return_dict = {}
+            params["return_id"] = get_worker_id
 
         resp = await self._client.post(
             f"/work_pools/{work_pool_name}/workers/heartbeat",
-            json={
-                "name": worker_name,
-                "heartbeat_interval_seconds": heartbeat_interval_seconds,
-            }
-            | return_dict,
+            json=params,
         )
 
         if (

prefect/client/schemas/objects.py

@@ -1689,3 +1689,24 @@ class CsrfToken(ObjectBaseModel):
 
 
 __getattr__ = getattr_migration(__name__)
+
+
+class Integration(PrefectBaseModel):
+    """A representation of an installed Prefect integration."""
+
+    name: str = Field(description="The name of the Prefect integration.")
+    version: str = Field(description="The version of the Prefect integration.")
+
+
+class WorkerMetadata(PrefectBaseModel):
+    """
+    Worker metadata.
+
+    We depend on the structure of `integrations`, but otherwise, worker classes
+    should support flexible metadata.
+    """
+
+    integrations: List[Integration] = Field(
+        default=..., description="Prefect integrations installed in the worker."
+    )
+    model_config = ConfigDict(extra="allow")

prefect/logging/handlers.py

@@ -32,6 +32,7 @@ from prefect.settings import (
     PREFECT_LOGGING_TO_API_BATCH_SIZE,
     PREFECT_LOGGING_TO_API_MAX_LOG_SIZE,
     PREFECT_LOGGING_TO_API_WHEN_MISSING_FLOW,
+    get_current_settings,
 )
 
 
@@ -180,6 +181,7 @@ class APILogHandler(logging.Handler):
         """
         flow_run_id = getattr(record, "flow_run_id", None)
         task_run_id = getattr(record, "task_run_id", None)
+        worker_id = getattr(record, "worker_id", None)
 
         if not flow_run_id:
             try:
@@ -215,6 +217,7 @@ class APILogHandler(logging.Handler):
         log = LogCreate(
             flow_run_id=flow_run_id if is_uuid_like else None,
             task_run_id=task_run_id,
+            worker_id=worker_id,
             name=record.name,
             level=record.levelno,
             timestamp=pendulum.from_timestamp(
@@ -236,6 +239,44 @@ class APILogHandler(logging.Handler):
         return len(json.dumps(log).encode())
 
 
+class WorkerAPILogHandler(APILogHandler):
+    def emit(self, record: logging.LogRecord):
+        if get_current_settings().experiments.worker_logging_to_api_enabled:
+            super().emit(record)
+        else:
+            return
+
+    def prepare(self, record: logging.LogRecord) -> Dict[str, Any]:
+        """
+        Convert a `logging.LogRecord` to the API `LogCreate` schema and serialize.
+
+        This will add in the worker id to the log.
+
+        Logs exceeding the maximum size will be dropped.
+        """
+
+        worker_id = getattr(record, "worker_id", None)
+
+        log = LogCreate(
+            worker_id=worker_id,
+            name=record.name,
+            level=record.levelno,
+            timestamp=pendulum.from_timestamp(
+                getattr(record, "created", None) or time.time()
+            ),
+            message=self.format(record),
+        ).model_dump(mode="json")
+
+        log_size = log["__payload_size__"] = self._get_payload_size(log)
+        if log_size > PREFECT_LOGGING_TO_API_MAX_LOG_SIZE.value():
+            raise ValueError(
+                f"Log of size {log_size} is greater than the max size of "
+                f"{PREFECT_LOGGING_TO_API_MAX_LOG_SIZE.value()}"
+            )
+
+        return log
+
+
 class PrefectConsoleHandler(logging.StreamHandler):
     def __init__(
         self,

prefect/logging/loggers.py

@@ -12,6 +12,7 @@ from typing_extensions import Self
 import prefect
 from prefect.exceptions import MissingContextError
 from prefect.logging.filters import ObfuscateApiKeyFilter
+from prefect.telemetry.logging import add_telemetry_log_handler
 
 if TYPE_CHECKING:
     from prefect.client.schemas import FlowRun as ClientFlowRun
@@ -19,6 +20,7 @@ if TYPE_CHECKING:
     from prefect.context import RunContext
     from prefect.flows import Flow
     from prefect.tasks import Task
+    from prefect.workers.base import BaseWorker
 
 
 class PrefectLogAdapter(logging.LoggerAdapter):
@@ -75,6 +77,8 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
     obfuscate_api_key_filter = ObfuscateApiKeyFilter()
     logger.addFilter(obfuscate_api_key_filter)
 
+    add_telemetry_log_handler(logger=logger)
+
     return logger
 
 
@@ -136,6 +140,12 @@ def get_run_logger(
     else:
         raise MissingContextError("There is no active flow or task run context.")
 
+    if isinstance(logger, logging.LoggerAdapter):
+        assert isinstance(logger.logger, logging.Logger)
+        add_telemetry_log_handler(logger.logger)
+    else:
+        add_telemetry_log_handler(logger)
+
     return logger
 
 
@@ -205,6 +215,29 @@ def task_run_logger(
     )
 
 
+def get_worker_logger(worker: "BaseWorker", name: Optional[str] = None):
+    """
+    Create a worker logger with the worker's metadata attached.
+
+    If the worker has a backend_id, it will be attached to the log records.
+    If the worker does not have a backend_id a basic logger will be returned.
+    If the worker does not have a backend_id attribute, a basic logger will be returned.
+    """
+
+    worker_log_name = name or f"workers.{worker.__class__.type}.{worker.name.lower()}"
+
+    worker_id = getattr(worker, "backend_id", None)
+    if worker_id:
+        return PrefectLogAdapter(
+            get_logger(worker_log_name),
+            extra={
+                "worker_id": str(worker.backend_id),
+            },
+        )
+    else:
+        return get_logger(worker_log_name)
+
+
 @contextmanager
 def disable_logger(name: str):
     """

prefect/logging/logging.yml

@@ -69,6 +69,10 @@ handlers:
     class: logging.StreamHandler
     formatter: debug
 
+  worker_api:
+    level: 0
+    class: prefect.logging.handlers.WorkerAPILogHandler
+
 loggers:
   prefect:
     level: "${PREFECT_LOGGING_LEVEL}"
@@ -86,6 +90,10 @@ loggers:
     level: NOTSET
     handlers: [api]
 
+  prefect.workers:
+    level: NOTSET
+    handlers: [worker_api]
+
   prefect.server:
     level: "${PREFECT_SERVER_LOGGING_LEVEL}"
 

prefect/main.py

@@ -57,6 +57,11 @@ prefect.logging.get_logger("profiles").debug(
     f"Using profile {prefect.context.get_settings_context().profile.name!r}"
 )
 
+# Configure telemetry
+import prefect.telemetry.bootstrap
+
+prefect.telemetry.bootstrap.setup_telemetry()
+
 
 from prefect._internal.compatibility.deprecated import (
     inject_renamed_module_alias_finder,

prefect/settings/models/api.py

@@ -25,7 +25,7 @@ class APISettings(PrefectBaseSettings):
     )
     tls_insecure_skip_verify: bool = Field(
         default=False,
-        description="If `True`, disables SSL checking to allow insecure requests. This is recommended only during development, e.g. when using self-signed certificates.",
+        description="If `True`, disables SSL checking to allow insecure requests. Setting to False is recommended only during development. For example, when using self-signed certificates.",
     )
     ssl_cert_file: Optional[str] = Field(
         default=os.environ.get("SSL_CERT_FILE"),

prefect/settings/models/experiments.py

@@ -22,3 +22,8 @@ class ExperimentsSettings(PrefectBaseSettings):
         default=False,
         description="Enables the logging of worker logs to Prefect Cloud.",
     )
+
+    telemetry_enabled: bool = Field(
+        default=False,
+        description="Enables sending telemetry to Prefect Cloud.",
+    )

prefect/settings/models/logging.py

@@ -1,11 +1,18 @@
+from functools import partial
 from pathlib import Path
 from typing import Annotated, Literal, Optional, Union
 
-from pydantic import AfterValidator, AliasChoices, AliasPath, Field, model_validator
+from pydantic import (
+    AliasChoices,
+    AliasPath,
+    BeforeValidator,
+    Field,
+    model_validator,
+)
 from typing_extensions import Self
 
 from prefect.settings.base import PrefectBaseSettings, _build_settings_config
-from prefect.types import LogLevel
+from prefect.types import LogLevel, validate_set_T_from_delim_string
 
 
 def max_log_size_smaller_than_batch_size(values):
@@ -97,7 +104,7 @@ class LoggingSettings(PrefectBaseSettings):
 
     extra_loggers: Annotated[
         Union[str, list[str], None],
-        AfterValidator(lambda v: [n.strip() for n in v.split(",")] if v else []),
+        BeforeValidator(partial(validate_set_T_from_delim_string, type_=str)),
     ] = Field(
         default=None,
         description="Additional loggers to attach to Prefect logging at runtime.",

prefect/settings/models/root.py

@@ -72,7 +72,7 @@ class Settings(PrefectBaseSettings):
 
     client: ClientSettings = Field(
         default_factory=ClientSettings,
-        description="Settings for for controlling API client behavior",
+        description="Settings for controlling API client behavior",
     )
 
     cloud: CloudSettings = Field(

prefect/settings/models/server/events.py

@@ -128,7 +128,7 @@ class ServerEventsSettings(PrefectBaseSettings):
 
     messaging_cache: str = Field(
         default="prefect.server.utilities.messaging.memory",
-        description="Which cache implementation to use for the events system.  Should point to a module that exports a Cache class.",
+        description="Which cache implementation to use for the events system. Should point to a module that exports a Cache class.",
         validation_alias=AliasChoices(
             AliasPath("messaging_cache"),
             "prefect_server_events_messaging_cache",

prefect/settings/sources.py

@@ -4,6 +4,7 @@ import warnings
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Type
 
+import dotenv
 import toml
 from pydantic import AliasChoices
 from pydantic.fields import FieldInfo
@@ -15,6 +16,7 @@ from pydantic_settings import (
 from pydantic_settings.sources import ConfigFileSourceMixin
 
 from prefect.settings.constants import DEFAULT_PREFECT_HOME, DEFAULT_PROFILES_PATH
+from prefect.utilities.collections import get_from_dict
 
 
 class EnvFilterSettingsSource(EnvSettingsSource):
@@ -230,6 +232,25 @@ def _get_profiles_path() -> Path:
         return DEFAULT_PROFILES_PATH
     if env_path := os.getenv("PREFECT_PROFILES_PATH"):
         return Path(env_path)
+    if dotenv_path := dotenv.dotenv_values(".env").get("PREFECT_PROFILES_PATH"):
+        return Path(dotenv_path)
+    if toml_path := _get_profiles_path_from_toml("prefect.toml", ["profiles_path"]):
+        return Path(toml_path)
+    if pyproject_path := _get_profiles_path_from_toml(
+        "pyproject.toml", ["tool", "prefect", "profiles_path"]
+    ):
+        return Path(pyproject_path)
     if not (DEFAULT_PREFECT_HOME / "profiles.toml").exists():
         return DEFAULT_PROFILES_PATH
     return DEFAULT_PREFECT_HOME / "profiles.toml"
+
+
+def _get_profiles_path_from_toml(path: str, keys: List[str]) -> Optional[str]:
+    """Helper to get the profiles path from a toml file."""
+
+    try:
+        toml_data = toml.load(path)
+    except FileNotFoundError:
+        return None
+
+    return get_from_dict(toml_data, keys)

prefect/telemetry/bootstrap.py

@@ -0,0 +1,32 @@
+from typing import TYPE_CHECKING, Union
+
+import prefect.settings
+from prefect.client.base import ServerType, determine_server_type
+
+if TYPE_CHECKING:
+    from opentelemetry.sdk._logs import LoggerProvider
+    from opentelemetry.sdk.metrics import MeterProvider
+    from opentelemetry.sdk.trace import TracerProvider
+
+
+def setup_telemetry() -> (
+    Union[
+        tuple["TracerProvider", "MeterProvider", "LoggerProvider"],
+        tuple[None, None, None],
+    ]
+):
+    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
+
+    assert settings.api.key
+    assert settings.api.url
+
+    # This import is here to defer importing of the `opentelemetry` packages.
+    from .instrumentation import setup_exporters
+
+    return setup_exporters(settings.api.url, settings.api.key.get_secret_value())

prefect/telemetry/instrumentation.py

@@ -0,0 +1,125 @@
+import logging
+import os
+import re
+from typing import TYPE_CHECKING
+from urllib.parse import urljoin
+from uuid import UUID
+
+from opentelemetry import metrics, trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import SimpleLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+
+from .logging import set_log_handler
+from .processors import InFlightSpanProcessor
+
+if TYPE_CHECKING:
+    from opentelemetry.sdk._logs import LoggerProvider
+
+UUID_REGEX = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+
+ACCOUNTS_PREFIX = "accounts/"
+ACCOUNT_ID_REGEX = f"{ACCOUNTS_PREFIX}{UUID_REGEX}"
+
+WORKSPACES_PREFIX = "workspaces/"
+WORKSPACE_ID_REGEX = f"{WORKSPACES_PREFIX}{UUID_REGEX}"
+
+
+def extract_account_and_workspace_id(url: str) -> tuple[UUID, UUID]:
+    account_id, workspace_id = None, None
+
+    if res := re.search(ACCOUNT_ID_REGEX, url):
+        account_id = UUID(res.group().removeprefix(ACCOUNTS_PREFIX))
+
+    if res := re.search(WORKSPACE_ID_REGEX, url):
+        workspace_id = UUID(res.group().removeprefix(WORKSPACES_PREFIX))
+
+    if account_id and workspace_id:
+        return account_id, workspace_id
+
+    raise ValueError(
+        f"Could not extract account and workspace id from API url: {url!r}"
+    )
+
+
+def _url_join(base_url: str, path: str) -> str:
+    return urljoin(base_url.rstrip("/") + "/", path.lstrip("/"))
+
+
+def setup_exporters(
+    api_url: str, api_key: str
+) -> tuple[TracerProvider, MeterProvider, "LoggerProvider"]:
+    account_id, workspace_id = extract_account_and_workspace_id(api_url)
+    telemetry_url = _url_join(api_url, "telemetry/")
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+    }
+
+    resource = Resource.create(
+        {
+            "service.name": "prefect",
+            "service.instance.id": os.uname().nodename,
+            "prefect.account": str(account_id),
+            "prefect.workspace": str(workspace_id),
+        }
+    )
+
+    trace_provider = _setup_trace_provider(resource, headers, telemetry_url)
+    meter_provider = _setup_meter_provider(resource, headers, telemetry_url)
+    logger_provider = _setup_logger_provider(resource, headers, telemetry_url)
+
+    return trace_provider, meter_provider, logger_provider
+
+
+def _setup_trace_provider(
+    resource: Resource, headers: dict[str, str], telemetry_url: str
+) -> TracerProvider:
+    trace_provider = TracerProvider(resource=resource)
+    otlp_span_exporter = OTLPSpanExporter(
+        endpoint=_url_join(telemetry_url, "v1/traces"),
+        headers=headers,
+    )
+    trace_provider.add_span_processor(InFlightSpanProcessor(otlp_span_exporter))
+    trace.set_tracer_provider(trace_provider)
+
+    return trace_provider
+
+
+def _setup_meter_provider(
+    resource: Resource, headers: dict[str, str], telemetry_url: str
+) -> MeterProvider:
+    metric_reader = PeriodicExportingMetricReader(
+        OTLPMetricExporter(
+            endpoint=_url_join(telemetry_url, "v1/metrics"),
+            headers=headers,
+        )
+    )
+    meter_provider = MeterProvider(resource=resource, metric_readers=[metric_reader])
+    metrics.set_meter_provider(meter_provider)
+
+    return meter_provider
+
+
+def _setup_logger_provider(
+    resource: Resource, headers: dict[str, str], telemetry_url: str
+) -> LoggerProvider:
+    logger_provider = LoggerProvider(resource=resource)
+    otlp_exporter = OTLPLogExporter(
+        endpoint=_url_join(telemetry_url, "v1/logs"),
+        headers=headers,
+    )
+    logger_provider.add_log_record_processor(SimpleLogRecordProcessor(otlp_exporter))
+    set_logger_provider(logger_provider)
+    log_handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
+
+    set_log_handler(log_handler)
+
+    return logger_provider

prefect/telemetry/logging.py

@@ -0,0 +1,26 @@
+import logging
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from opentelemetry.sdk._logs import LoggingHandler
+
+_log_handler: Optional["LoggingHandler"] = None
+
+
+def set_log_handler(log_handler: Optional["LoggingHandler"]) -> None:
+    """Set the OTLP log handler."""
+    global _log_handler
+    _log_handler = log_handler
+
+
+def get_log_handler() -> Optional["LoggingHandler"]:
+    """Get the OTLP log handler."""
+    global _log_handler
+    return _log_handler
+
+
+def add_telemetry_log_handler(logger: logging.Logger) -> None:
+    """Add the OTLP log handler to the given logger if the log handler has
+    been configured."""
+    if log_handler := get_log_handler():
+        logger.addHandler(log_handler)

prefect/telemetry/processors.py

@@ -0,0 +1,57 @@
+import time
+from threading import Event, Lock, Thread
+from typing import Optional
+
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+
+
+class InFlightSpanProcessor(SpanProcessor):
+    def __init__(self, span_exporter: SpanExporter):
+        self.span_exporter = span_exporter
+        self._in_flight = {}
+        self._lock = Lock()
+        self._stop_event = Event()
+        self._export_thread = Thread(target=self._export_periodically, daemon=True)
+        self._export_thread.start()
+
+    def _export_periodically(self) -> None:
+        while not self._stop_event.is_set():
+            time.sleep(1)
+            with self._lock:
+                to_export = [
+                    self._readable_span(span) for span in self._in_flight.values()
+                ]
+                if to_export:
+                    self.span_exporter.export(to_export)
+
+    def _readable_span(self, span: Span) -> ReadableSpan:
+        readable = span._readable_span()
+        readable._end_time = time.time_ns()
+        readable._attributes = {
+            **(readable._attributes or {}),
+            "prefect.in-flight": True,
+        }
+        return readable
+
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
+        if not span.context or not span.context.trace_flags.sampled:
+            return
+        with self._lock:
+            self._in_flight[span.context.span_id] = span
+
+    def on_end(self, span: ReadableSpan) -> None:
+        if not span.context or not span.context.trace_flags.sampled:
+            return
+        with self._lock:
+            del self._in_flight[span.context.span_id]
+            self.span_exporter.export((span,))
+
+    def shutdown(self) -> None:
+        self._stop_event.set()
+        self._export_thread.join()
+        self.span_exporter.shutdown()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True

prefect/types/__init__.py

@@ -7,7 +7,6 @@ import pydantic
 from pydantic import (
     BeforeValidator,
     Field,
-    SecretStr,
     StrictBool,
     StrictFloat,
     StrictInt,
@@ -110,7 +109,7 @@ def validate_set_T_from_delim_string(
     T_adapter = TypeAdapter(type_)
     delim = delim or ","
     if isinstance(value, str):
-        return {T_adapter.validate_strings(s) for s in value.split(delim)}
+        return {T_adapter.validate_strings(s.strip()) for s in value.split(delim)}
     errors = []
     try:
         return {T_adapter.validate_python(value)}

prefect/workers/base.py

@@ -8,7 +8,9 @@ from uuid import UUID, uuid4
 
 import anyio
 import anyio.abc
+import httpx
 import pendulum
+from importlib_metadata import distributions
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 from pydantic.json_schema import GenerateJsonSchema
 from typing_extensions import Literal
@@ -18,7 +20,12 @@ from prefect._internal.schemas.validators import return_v_or_none
 from prefect.client.base import ServerType
 from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.actions import WorkPoolCreate, WorkPoolUpdate
-from prefect.client.schemas.objects import StateType, WorkPool
+from prefect.client.schemas.objects import (
+    Integration,
+    StateType,
+    WorkerMetadata,
+    WorkPool,
+)
 from prefect.client.utilities import inject_client
 from prefect.events import Event, RelatedResource, emit_event
 from prefect.events.related import object_as_related_resource, tags_as_related_resources
@@ -26,7 +33,11 @@ from prefect.exceptions import (
     Abort,
     ObjectNotFound,
 )
-from prefect.logging.loggers import PrefectLogAdapter, flow_run_logger, get_logger
+from prefect.logging.loggers import (
+    PrefectLogAdapter,
+    flow_run_logger,
+    get_worker_logger,
+)
 from prefect.plugins import load_prefect_collections
 from prefect.settings import (
     PREFECT_API_URL,
@@ -50,6 +61,7 @@ from prefect.utilities.templating import (
     resolve_block_document_references,
     resolve_variables,
 )
+from prefect.utilities.urls import url_for
 
 if TYPE_CHECKING:
     from prefect.client.schemas.objects import Flow, FlowRun
@@ -407,7 +419,8 @@ class BaseWorker(abc.ABC):
             raise ValueError("Worker name cannot contain '/' or '%'")
         self.name = name or f"{self.__class__.__name__} {uuid4()}"
         self._started_event: Optional[Event] = None
-        self._logger = get_logger(f"worker.{self.__class__.type}.{self.name.lower()}")
+        self.backend_id: Optional[UUID] = None
+        self._logger = get_worker_logger(self)
 
         self.is_setup = False
         self._create_pool_if_not_found = create_pool_if_not_found
@@ -422,7 +435,6 @@ class BaseWorker(abc.ABC):
             heartbeat_interval_seconds or PREFECT_WORKER_HEARTBEAT_SECONDS.value()
         )
 
-        self.backend_id: Optional[UUID] = None
         self._work_pool: Optional[WorkPool] = None
         self._exit_stack: AsyncExitStack = AsyncExitStack()
         self._runs_task_group: Optional[anyio.abc.TaskGroup] = None
@@ -433,6 +445,7 @@ class BaseWorker(abc.ABC):
         self._submitting_flow_run_ids = set()
         self._cancelling_flow_run_ids = set()
         self._scheduled_task_scopes = set()
+        self._worker_metadata_sent = False
 
     @classmethod
     def get_documentation_url(cls) -> str:
@@ -490,15 +503,19 @@ class BaseWorker(abc.ABC):
         return slugify(self.name)
 
     def get_flow_run_logger(self, flow_run: "FlowRun") -> PrefectLogAdapter:
+        extra = {
+            "worker_name": self.name,
+            "work_pool_name": (
+                self._work_pool_name if self._work_pool else "<unknown>"
+            ),
+            "work_pool_id": str(getattr(self._work_pool, "id", "unknown")),
+        }
+        if self.backend_id:
+            extra["worker_id"] = str(self.backend_id)
+
         return flow_run_logger(flow_run=flow_run).getChild(
             "worker",
-            extra={
-                "worker_name": self.name,
-                "work_pool_name": (
-                    self._work_pool_name if self._work_pool else "<unknown>"
-                ),
-                "work_pool_id": str(getattr(self._work_pool, "id", "unknown")),
-            },
+            extra=extra,
         )
 
     async def start(
@@ -712,54 +729,97 @@ class BaseWorker(abc.ABC):
 
         self._work_pool = work_pool
 
-    async def _send_worker_heartbeat(
-        self, get_worker_id: bool = False
-    ) -> Optional[UUID]:
+    async def _worker_metadata(self) -> Optional[WorkerMetadata]:
         """
-        Sends a heartbeat to the API.
-
-        If `get_worker_id` is True, the worker ID will be retrieved from the API.
+        Returns metadata about installed Prefect collections for the worker.
         """
-        if self._work_pool:
-            return await self._client.send_worker_heartbeat(
-                work_pool_name=self._work_pool_name,
-                worker_name=self.name,
-                heartbeat_interval_seconds=self.heartbeat_interval_seconds,
-                get_worker_id=get_worker_id,
-            )
+        installed_integrations = load_prefect_collections().keys()
 
-    async def sync_with_backend(self):
+        integration_versions = [
+            Integration(name=dist.metadata["Name"], version=dist.version)
+            for dist in distributions()
+            # PyPI packages often use dashes, but Python package names use underscores
+            # because they must be valid identifiers.
+            if dist.metadata.get("Name").replace("-", "_") in installed_integrations
+        ]
+
+        if integration_versions:
+            return WorkerMetadata(integrations=integration_versions)
+        return None
+
+    async def _send_worker_heartbeat(self) -> Optional[UUID]:
         """
-        Updates the worker's local information about it's current work pool and
-        queues. Sends a worker heartbeat to the API.
+        Sends a heartbeat to the API.
         """
-        await self._update_local_work_pool_info()
-        # Only do this logic if we've enabled the experiment, are connected to cloud and we don't have an ID.
+        if not self._client:
+            self._logger.warning("Client has not been initialized; skipping heartbeat.")
+            return None
+        if not self._work_pool:
+            self._logger.debug("Worker has no work pool; skipping heartbeat.")
+            return None
+
+        should_get_worker_id = self._should_get_worker_id()
+
+        params = {
+            "work_pool_name": self._work_pool_name,
+            "worker_name": self.name,
+            "heartbeat_interval_seconds": self.heartbeat_interval_seconds,
+            "get_worker_id": should_get_worker_id,
+        }
         if (
-            get_current_settings().experiments.worker_logging_to_api_enabled
-            and (
-                self._client.server_type == ServerType.CLOUD
-                or get_current_settings().testing.test_mode
-            )
-            and self.backend_id is None
+            self._client.server_type == ServerType.CLOUD
+            and not self._worker_metadata_sent
         ):
-            get_worker_id = True
-        else:
-            get_worker_id = False
+            worker_metadata = await self._worker_metadata()
+            if worker_metadata:
+                params["worker_metadata"] = worker_metadata
+                self._worker_metadata_sent = True
 
-        remote_id = await self._send_worker_heartbeat(get_worker_id=get_worker_id)
+        worker_id = None
+        try:
+            worker_id = await self._client.send_worker_heartbeat(**params)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 422 and should_get_worker_id:
+                self._logger.warning(
+                    "Failed to retrieve worker ID from the Prefect API server."
+                )
+                params["get_worker_id"] = False
+                worker_id = await self._client.send_worker_heartbeat(**params)
+            else:
+                raise e
 
-        if get_worker_id and remote_id is None:
+        if should_get_worker_id and worker_id is None:
             self._logger.warning(
                 "Failed to retrieve worker ID from the Prefect API server."
             )
-        else:
+
+        return worker_id
+
+    async def sync_with_backend(self):
+        """
+        Updates the worker's local information about it's current work pool and
+        queues. Sends a worker heartbeat to the API.
+        """
+        await self._update_local_work_pool_info()
+
+        remote_id = await self._send_worker_heartbeat()
+        if remote_id:
             self.backend_id = remote_id
+            self._logger = get_worker_logger(self)
 
         self._logger.debug(
             f"Worker synchronized with the Prefect API server. Remote ID: {self.backend_id}"
         )
 
+    def _should_get_worker_id(self):
+        """Determines if the worker should request an ID from the API server."""
+        return (
+            get_current_settings().experiments.worker_logging_to_api_enabled
+            and self._client
+            and self._client.server_type == ServerType.CLOUD
+            and self.backend_id is None
+        )
+
     async def _get_scheduled_flow_runs(
         self,
     ) -> List["WorkerFlowRunResponse"]:
@@ -813,6 +873,17 @@ class BaseWorker(abc.ABC):
                 run_logger.info(
                     f"Worker '{self.name}' submitting flow run '{flow_run.id}'"
                 )
+                if (
+                    get_current_settings().experiments.worker_logging_to_api_enabled
+                    and self.backend_id
+                ):
+                    worker_path = f"worker/{self.backend_id}"
+                    base_url = url_for("work-pool", self._work_pool.id)
+
+                    run_logger.info(
+                        f"Running on worker id: {self.backend_id}. See worker logs here: {base_url}/{worker_path}"
+                    )
+
                 self._submitting_flow_run_ids.add(flow_run.id)
                 self._runs_task_group.start_soon(
                     self._submit_run,

{prefect_client-3.1.0.dist-info → prefect_client-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.1.0
+Version: 3.1.1
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect_client-3.1.0.dist-info → prefect_client-3.1.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 prefect/.prefectignore,sha256=awSprvKT0vI8a64mEOLrMxhxqcO-b0ERQeYpA2rNKVQ,390
 prefect/__init__.py,sha256=UZPTpdap8ECK1zLoggfeOtZGkKcf6um1-lMb-nn4o5I,3450
-prefect/_version.py,sha256=Hzj0kOJRJpRTvV4Al2Mi2t5EvQK_0Q2ixDr6TVvMbNM,496
+prefect/_version.py,sha256=l2zyL-F66iaGpmwpxB6wRww__gYWl19cPDqMKnOCZ2w,496
 prefect/agent.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
 prefect/artifacts.py,sha256=dsxFWmdg2r9zbHM3KgKOR5YbJ29_dXUYF9kipJpbxkE,13009
 prefect/automations.py,sha256=NlQ62GPJzy-gnWQqX7c6CQJKw7p60WLGDAFcy82vtg4,5613
@@ -13,7 +13,7 @@ prefect/flow_engine.py,sha256=BuxfnKDqYcJvmVfPlAv8yMSwkDM25SBeJVk_MGQnm8k,30076
 prefect/flow_runs.py,sha256=EaXRIQTOnwnA0fO7_EjwafFRmS57K_CRy0Xsz3JDIhc,16070
 prefect/flows.py,sha256=PUEPpQx5pjXMVfnrPbIeAvWUdEdeaNPO4DXj7tgxGcA,90185
 prefect/futures.py,sha256=DlZvdccKtwQKuDUFrZ4zcINeO9C1chLiNOwjE5gTgCk,16356
-prefect/main.py,sha256=IdtnJR5-IwP8EZsfhMFKj92ylMhNyau9X_eMcTP2ZjM,2336
+prefect/main.py,sha256=TPktwZJ8a6l9U5A01a6x6wEZ7DqD4z7OWz0WadAPS6I,2441
 prefect/plugins.py,sha256=HY7Z7OJlltqzsUiPMEL1Y_hQbHw0CeZKayWiK-k8DP4,2435
 prefect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/results.py,sha256=D8pjiiK0btWuTSQ4txw4glB4VFxvdrqef6z51-JgU5c,47670
@@ -32,6 +32,7 @@ prefect/_internal/integrations.py,sha256=U4cZMDbnilzZSKaMxvzZcSL27a1tzRMjDoTfr2u
 prefect/_internal/pytz.py,sha256=WWl9x16rKFWequGmcOGs_ljpCDPf2LDHMyZp_4D8e6c,13748
 prefect/_internal/retries.py,sha256=xtgj6oPSvYQLbyk451LR6swcRQvRVWEzCxY6GMK7qA4,2284
 prefect/_internal/compatibility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prefect/_internal/compatibility/async_dispatch.py,sha256=QpfHgjdmLW4PXp-sBXIqUlGL0bJnXhtLBGXi7PWR8Bo,2174
 prefect/_internal/compatibility/deprecated.py,sha256=PVME2C3Oe4_8tKIGufx1W4EpGkz5IQY8gFohPVOjNcM,7533
 prefect/_internal/compatibility/migration.py,sha256=oifIj6mKwVUfrUO13ODLKOCwLON4YqaTXzhBFh8AK6E,6797
 prefect/_internal/concurrency/__init__.py,sha256=YlTwU9ryjPNwbJa45adLJY00t_DGCh1QrdtY9WdVFfw,2140
@@ -69,13 +70,13 @@ prefect/client/base.py,sha256=2K8UiWzorZNNM4c8c-OiGeZ5i5ViUfZ_Q31oPobbOO0,24956
 prefect/client/cloud.py,sha256=P8GctOSRqrukU_j9iXDuOW9lIiscRFP6WLxASDcmn_o,6207
 prefect/client/collections.py,sha256=u-96saqu0RALAazRI0YaZCJahnuafMppY21KN6ggx80,1059
 prefect/client/constants.py,sha256=Z_GG8KF70vbbXxpJuqW5pLnwzujTVeHbcYYRikNmGH0,29
-prefect/client/orchestration.py,sha256=iyZRzoqwQSzxjT4uvP9O9O-mH4o1cmtTvgG4MCFCH2g,151297
+prefect/client/orchestration.py,sha256=p3vblcSgrle4p-_Rl99GDz1sNzH-2pltxYUZHbFwUeM,151496
 prefect/client/subscriptions.py,sha256=oqF2MJsgN3psJg-MePfvwMtEWjromfP9StWF00xc1eg,3403
 prefect/client/utilities.py,sha256=89fmza0cRMOayxgXRdO51TKb11TczJ0ByOZmcZVrt44,3286
 prefect/client/schemas/__init__.py,sha256=KlyqFV-hMulMkNstBn_0ijoHoIwJZaBj6B1r07UmgvE,607
 prefect/client/schemas/actions.py,sha256=m2HJr9oAoK9vqigCHSwMGwvKPTjGNEtP0xdXgforIT0,28629
 prefect/client/schemas/filters.py,sha256=ynzD3mdvHHkI51pJ_NWgeDv8Awr7-2QtpUq7fTInEYM,36316
-prefect/client/schemas/objects.py,sha256=A57O9l8KlcwIY1iEAqVM-G-SA00eHB5DqKdpibijz5w,55995
+prefect/client/schemas/objects.py,sha256=H3yeFyyV3LGRe6IA8Yj-1RxpVgSfqVhodOQ6YhuIcXI,56629
 prefect/client/schemas/responses.py,sha256=tV06W8npA8oCjV9d0ZNvjro4QcbHxayb8PC4LmanXjo,15467
 prefect/client/schemas/schedules.py,sha256=8rpqjOYtknu2-1n5_WD4cOplgu93P3mCyX86B22LfL4,13070
 prefect/client/schemas/sorting.py,sha256=L-2Mx-igZPtsUoRUguTcG3nIEstMEMPD97NwPM2Ox5s,2579
@@ -137,10 +138,10 @@ prefect/logging/__init__.py,sha256=zx9f5_dWrR4DbcTOFBpNGOPoCZ1QcPFudr7zxb2XRpA,1
 prefect/logging/configuration.py,sha256=5kOYdd4Hi6t-wJhxEncYS9bUAMEMTRKy_i22pepjDrw,3343
 prefect/logging/filters.py,sha256=9keHLN4-cpnsWcii1qU0RITNi9-m7pOhkJ_t0MtCM4k,1117
 prefect/logging/formatters.py,sha256=3nBWgawvD48slT0zgkKeus1gIyf0OjmDKdLwMEe5mPU,3923
-prefect/logging/handlers.py,sha256=EvXFVM9AnSZSk0QA75KnQ0Pso95QQvs3x9rMC5PA46U,10417
+prefect/logging/handlers.py,sha256=86uVPKimc6sBqpig6-nMSSbgXFkftvlKiRgZ7EtMqsw,11776
 prefect/logging/highlighters.py,sha256=pH6TZmMaMdAkMLJB-U9NPWZIj3GUfczYCSFzCbBCq2s,1776
-prefect/logging/loggers.py,sha256=9fN5iTXQwBAHwKfE9iBo-90f2SyGs9Z3OKmkLPG91VY,10995
-prefect/logging/logging.yml,sha256=IRxiQ_D0aWHfRBpVfSxKgbPCq9Sw4bfJJZExl8ZyssM,3023
+prefect/logging/loggers.py,sha256=BKYjyP8N2aJPdHwpqNU5Od4uu0pKztsDQ7RPRNb4oGo,12146
+prefect/logging/logging.yml,sha256=-HoWPYLsKMt5bKRgjIqk8S7tQlAaQ93pGkwIkYtMVMo,3172
 prefect/records/__init__.py,sha256=rJJhaJBa0AWu63fJhtB-yHBi64qL6p4svo7F0qvm2sc,30
 prefect/records/base.py,sha256=Ne-7pRGNfmk0a_Vm3t5zRrj26KgGr_L2_XfLID0XzIY,8035
 prefect/records/filesystem.py,sha256=X-h7r5deiHH5IaaDk4ugOCmR5ZKnJeU2cLgp0AkMt0E,7316
@@ -165,19 +166,19 @@ prefect/settings/context.py,sha256=yKxnaDJHX8e2jmAVtw1RF9o7X4V3AOcz61sVeQyPX2c,2
 prefect/settings/legacy.py,sha256=GcaB1mkahc4HbjnUvr4_3qNNxleke08dYnOXCUt8w3k,5617
 prefect/settings/profiles.py,sha256=VZdzOV-KSuAkCxtdhBmSG9i84-K2QLSx6g2-vIUkfig,12169
 prefect/settings/profiles.toml,sha256=kTvqDNMzjH3fsm5OEI-NKY4dMmipor5EvQXRB6rPEjY,522
-prefect/settings/sources.py,sha256=CfgJlHStFSP0Kiq_bFPY0BmXqNzaivrId-3lYZ1wuJI,8604
+prefect/settings/sources.py,sha256=ixt4dTP766s2nr_IjPKS81ZneAaiWzw93zjrWCnkKp8,9345
 prefect/settings/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prefect/settings/models/api.py,sha256=1MQhokm0L64ZAjG3LbgArtY_uiJX_hK6SKb1dC9aCHU,1491
+prefect/settings/models/api.py,sha256=DuoBHYeMX9MlgjT6JNLWPHSj_iySo98a0uNuTVSk1r8,1511
 prefect/settings/models/cli.py,sha256=mHB-BHBVO9qfQcr9uHbBmU6MMDLlLUUDxjyaRz7v1ls,958
 prefect/settings/models/client.py,sha256=Ua18wKXWrNi0Ktb6cd42kdSOQYhFnObwTHTc3QDYg2k,2985
 prefect/settings/models/cloud.py,sha256=7-WtW0rGPMOuG1O9Lwv_H_keEldXPo9YGHmoGwCXpeg,1767
 prefect/settings/models/deployments.py,sha256=ui4xqT7N-6B_gMnGnkJ8Ys0hzdfNTOtlcwzAQo2LlQI,1235
-prefect/settings/models/experiments.py,sha256=AlSj4ItrVDGLvTTXJVtDmzlYEiCBjrGKNFs7VGqH1fo,728
+prefect/settings/models/experiments.py,sha256=CXezPxuyV4pTxvQ9xroUmpEudXbDgUv-Y56A16307Wc,862
 prefect/settings/models/flows.py,sha256=IrW3cFQJnu-31cXvSihCl6naRhmZc2eFqSgqdnNLUzg,1056
 prefect/settings/models/internal.py,sha256=mJ7h3d_WHw-0FBVhIbDHPjYI041YtuReD1bZO98G1OU,612
-prefect/settings/models/logging.py,sha256=gzTjdiuh2tMdtorW86rZIp4n66jJLh3oYh5uRLi8DD4,4473
+prefect/settings/models/logging.py,sha256=YxD8fOcWOROUrq6dH6EIadJwYL7LlLSUGWlHVLn-l3Y,4560
 prefect/settings/models/results.py,sha256=lU-3oVlgxGradSB1EYU-VZogK-rzE5LDw_wOcKhJp4M,1397
-prefect/settings/models/root.py,sha256=MkprdKVpWb0M2rR08nvUtfkSPGDIp_a3cz6cUKKmIWU,16381
+prefect/settings/models/root.py,sha256=7PC_Oiz7SYM3Ea3rqn_XnozvdivNq3rKc2dEcjTA5L4,16377
 prefect/settings/models/runner.py,sha256=TOYDnmYmv6Ec5Ma6Vii-rPUTeMGszDluecLwy65Gnm4,1644
 prefect/settings/models/tasks.py,sha256=qXLWJIVZT4L1GQcaCD_NUJktpB5WYOxthOq_PDLdj20,3309
 prefect/settings/models/testing.py,sha256=r6KCYi8nvflCEwRFqS2T5J9baMHtVJfW0Q8EWARu1PQ,1733
@@ -187,13 +188,18 @@ prefect/settings/models/server/api.py,sha256=EKpt31hlX9dwrrsW-QztuJCHfUXqeWSz5xA
 prefect/settings/models/server/database.py,sha256=0eerMb05A9wD9_C4SefTzVvmba3rW18K2eteL2IcXLg,7201
 prefect/settings/models/server/deployments.py,sha256=_GcxGOsMMrCzGEnOwC2i6JQW77h2tbyAdBJzAigHDas,778
 prefect/settings/models/server/ephemeral.py,sha256=WxSpF-z9iDKAEjvcqrA5aggLEPRbl_ERocoLxPlu424,923
-prefect/settings/models/server/events.py,sha256=RRpwduwrV4jysp-AfxKhLnM0JEYCG4gxT7ls15yfJJg,5148
+prefect/settings/models/server/events.py,sha256=UJ-cQdTvkYOxU5WCTx3EebTv01E_gDaA-3ni8jwyjN8,5147
 prefect/settings/models/server/flow_run_graph.py,sha256=MCKKV91-I6AOAGJ9ieTvHIMqH5JEri7cfuDbadEFu4w,1026
 prefect/settings/models/server/root.py,sha256=uhryCvrk6oGAu8S3GGZNc3IaxXyd_dFnsKfi1q8En_U,5128
 prefect/settings/models/server/services.py,sha256=xDQyRUh18mU_cTgp1Q_BwKpdeZHKLSh2o_YNNXvzsoo,16748
 prefect/settings/models/server/tasks.py,sha256=YzfRTcmiYnD_INezR_29rvO0M_YbAqT1by7kiK2KP60,2814
 prefect/settings/models/server/ui.py,sha256=6cTSC2RQsS4c2HpB1Se6qRms4RMEKSsaI40T2CTkobg,1780
-prefect/types/__init__.py,sha256=A714iHFE9makA5LiAKd0Y5wfdb7m13gBwvrpQzdLVgs,3647
+prefect/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prefect/telemetry/bootstrap.py,sha256=oOdEjIHDQHANviyP2ZKpz9B4yBq832f9y1PKwAQ5-ro,987
+prefect/telemetry/instrumentation.py,sha256=S7IRYqKXaixAt-W5oxDO4CqkyXc3dy4ATgBmuindJIM,4241
+prefect/telemetry/logging.py,sha256=yn5D4D2GGRrAv0y8wlHPN7PZDmQucGjQT_YauK9M9Yo,727
+prefect/telemetry/processors.py,sha256=5vxjk9m-0FxqGDmVySY_u4zceZ9mwmTPiSFuCDOyGWA,2006
+prefect/types/__init__.py,sha256=oabzKSvuT7tKBX6OiBev40wUtN1JstJT2L7ocpEUZ14,3640
 prefect/types/entrypoint.py,sha256=2FF03-wLPgtnqR_bKJDB2BsXXINPdu8ptY9ZYEZnXg8,328
 prefect/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prefect/utilities/annotations.py,sha256=Ocj2s5zhnGr8uXUBnOli-OrybXVJdu4-uZvCRpKpV_Q,2820
@@ -224,14 +230,14 @@ prefect/utilities/schema_tools/__init__.py,sha256=KsFsTEHQqgp89TkDpjggkgBBywoHQP
 prefect/utilities/schema_tools/hydration.py,sha256=k12qVCdLLrK-mNo1hPCdhxM5f_N14Nj0vJdtiWYWffk,8858
 prefect/utilities/schema_tools/validation.py,sha256=2GCjxwApTFwzey40ul9OkcAXrU3r-kWK__9ucMo0qbk,9744
 prefect/workers/__init__.py,sha256=8dP8SLZbWYyC_l9DRTQSE3dEbDgns5DZDhxkp_NfsbQ,35
-prefect/workers/base.py,sha256=jAea-LuUYjLJ9--Y4oD82lubIgAakK33Pa3bvcotASs,45381
+prefect/workers/base.py,sha256=ChdMddrKvpmk08m-UQXiP2R4xCIfsiej-0zD2jt9llc,47795
 prefect/workers/block.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
 prefect/workers/cloud.py,sha256=BOVVY5z-vUIQ2u8LwMTXDaNys2fjOZSS5YGDwJmTQjI,230
 prefect/workers/process.py,sha256=tcJ3fbiraLCfpVGpv8dOHwMSfVzeD_kyguUOvPuIz6I,19796
 prefect/workers/server.py,sha256=lgh2FfSuaNU7b6HPxSFm8JtKvAvHsZGkiOo4y4tW1Cw,2022
 prefect/workers/utilities.py,sha256=VfPfAlGtTuDj0-Kb8WlMgAuOfgXCdrGAnKMapPSBrwc,2483
-prefect_client-3.1.0.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
-prefect_client-3.1.0.dist-info/METADATA,sha256=c3Er1Cd_i5J7vmVAyc8IL9iE3Dwm34D5Y3q3kGNGcUI,7338
-prefect_client-3.1.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-prefect_client-3.1.0.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
-prefect_client-3.1.0.dist-info/RECORD,,
+prefect_client-3.1.1.dist-info/LICENSE,sha256=MCxsn8osAkzfxKC4CC_dLcUkU8DZLkyihZ8mGs3Ah3Q,11357
+prefect_client-3.1.1.dist-info/METADATA,sha256=OlGsslMyT1YoImmLFDnko6XXPcvfqJV__WBbd6KClG4,7338
+prefect_client-3.1.1.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+prefect_client-3.1.1.dist-info/top_level.txt,sha256=MJZYJgFdbRc2woQCeB4vM6T33tr01TmkEhRcns6H_H4,8
+prefect_client-3.1.1.dist-info/RECORD,,