prefect 3.1.1.dev1__tar.gz → 3.1.1.dev2__tar.gz

{prefect-3.1.1.dev1/src/prefect.egg-info → prefect-3.1.1.dev2}/PKG-INFO

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

{prefect-3.1.1.dev1 → prefect-3.1.1.dev2}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-31T15:40:02-0500",
+ "date": "2024-11-01T17:07:05-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "3f31e136d9d759c2e1914dc949b4d26fdb03ac82",
- "version": "3.1.1.dev1"
+ "full-revisionid": "f196fb3da6ae747f7362be2f21e85b01f32e539c",
+ "version": "3.1.1.dev2"
 }
 '''  # END VERSION_JSON
 

{prefect-3.1.1.dev1 → prefect-3.1.1.dev2}/src/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,
 )
 
 
@@ -236,6 +237,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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/prefect/logging/loggers.py

@@ -19,6 +19,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):
@@ -205,6 +206,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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/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-3.1.1.dev1 → prefect-3.1.1.dev2}/src/prefect/workers/base.py

@@ -8,6 +8,7 @@ from uuid import UUID, uuid4
 
 import anyio
 import anyio.abc
+import httpx
 import pendulum
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 from pydantic.json_schema import GenerateJsonSchema
@@ -26,7 +27,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,
@@ -407,7 +412,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 +428,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
@@ -734,32 +739,40 @@ class BaseWorker(abc.ABC):
         queues. Sends a worker 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 (
-            get_current_settings().experiments.worker_logging_to_api_enabled
-            and (
-                self._client.server_type == ServerType.CLOUD
-                or get_current_settings().testing.test_mode
+        try:
+            remote_id = await self._send_worker_heartbeat(
+                get_worker_id=(self._should_get_worker_id())
             )
-            and self.backend_id is None
-        ):
-            get_worker_id = True
-        else:
-            get_worker_id = False
-
-        remote_id = await self._send_worker_heartbeat(get_worker_id=get_worker_id)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 422 and self._should_get_worker_id():
+                self._logger.warning(
+                    "Failed to retrieve worker ID from the Prefect API server."
+                )
+                await self._send_worker_heartbeat(get_worker_id=False)
+                remote_id = None
+            else:
+                raise e
 
-        if get_worker_id and remote_id is None:
+        if self._should_get_worker_id() and remote_id is None:
             self._logger.warning(
                 "Failed to retrieve worker ID from the Prefect API server."
             )
-        else:
+        elif self.backend_id is None and remote_id is not None:
             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.server_type == ServerType.CLOUD
+            and self.backend_id is None
+        )
+
     async def _get_scheduled_flow_runs(
         self,
     ) -> List["WorkerFlowRunResponse"]:

{prefect-3.1.1.dev1 → prefect-3.1.1.dev2/src/prefect.egg-info}/PKG-INFO

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

{prefect-3.1.1.dev1 → prefect-3.1.1.dev2}/tests/test_logging.py

@@ -6,6 +6,7 @@ import uuid
 from contextlib import nullcontext
 from functools import partial
 from io import StringIO
+from typing import Type
 from unittest.mock import ANY, MagicMock
 
 import pendulum
@@ -30,7 +31,12 @@ from prefect.logging.configuration import (
 )
 from prefect.logging.filters import ObfuscateApiKeyFilter
 from prefect.logging.formatters import JsonFormatter
-from prefect.logging.handlers import APILogHandler, APILogWorker, PrefectConsoleHandler
+from prefect.logging.handlers import (
+    APILogHandler,
+    APILogWorker,
+    PrefectConsoleHandler,
+    WorkerAPILogHandler,
+)
 from prefect.logging.highlighters import PrefectConsoleHighlighter
 from prefect.logging.loggers import (
     PrefectLogAdapter,
@@ -39,12 +45,14 @@ from prefect.logging.loggers import (
     flow_run_logger,
     get_logger,
     get_run_logger,
+    get_worker_logger,
     patch_print,
     task_run_logger,
 )
 from prefect.server.schemas.actions import LogCreate
 from prefect.settings import (
     PREFECT_API_KEY,
+    PREFECT_EXPERIMENTS_WORKER_LOGGING_TO_API_ENABLED,
     PREFECT_LOGGING_COLORS,
     PREFECT_LOGGING_LEVEL,
     PREFECT_LOGGING_MARKUP,
@@ -60,6 +68,7 @@ from prefect.settings import (
 from prefect.testing.cli import temporary_console_width
 from prefect.testing.utilities import AsyncMock
 from prefect.utilities.names import obfuscate
+from prefect.workers.base import BaseJobConfiguration, BaseWorker
 
 
 @pytest.fixture
@@ -627,6 +636,86 @@ class TestAPILogHandler:
         assert handler._get_payload_size(dict_log) == log_size
 
 
+class TestWorkerLogging:
+    class WorkerTestImpl(BaseWorker):
+        type: str = "logging_test"
+        job_configuration: Type[BaseJobConfiguration] = BaseJobConfiguration
+
+        async def _send_worker_heartbeat(self, *_, **__):
+            return "test_backend_id"
+
+        async def run(self, *_, **__):
+            pass
+
+    @pytest.fixture
+    def experiment_enabled(self):
+        with temporary_settings(
+            updates={PREFECT_EXPERIMENTS_WORKER_LOGGING_TO_API_ENABLED: True}
+        ):
+            yield
+
+    @pytest.fixture
+    def logging_to_api_enabled(self):
+        with temporary_settings(updates={PREFECT_LOGGING_TO_API_ENABLED: True}):
+            yield
+
+    @pytest.fixture
+    def worker_handler(self):
+        yield WorkerAPILogHandler()
+
+    @pytest.fixture
+    def logger(self, worker_handler):
+        logger = logging.getLogger(__name__)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(worker_handler)
+        yield logger
+        logger.removeHandler(worker_handler)
+
+    async def test_get_worker_logger_works_with_no_backend_id(self, experiment_enabled):
+        async with self.WorkerTestImpl(
+            name="test", work_pool_name="test-work-pool"
+        ) as worker:
+            logger = get_worker_logger(worker)
+            assert logger.name == "prefect.workers.logging_test.test"
+
+    async def test_get_worker_logger_works_with_backend_id(self, experiment_enabled):
+        async with self.WorkerTestImpl(
+            name="test", work_pool_name="test-work-pool"
+        ) as worker:
+            await worker.sync_with_backend()
+            logger = get_worker_logger(worker)
+            assert logger.name == "prefect.workers.logging_test.test"
+            assert logger.extra["worker_id"] == "test_backend_id"
+
+    async def test_worker_emits_logs_with_worker_id(self, caplog, experiment_enabled):
+        async with self.WorkerTestImpl(
+            name="test", work_pool_name="test-work-pool"
+        ) as worker:
+            await worker.sync_with_backend()
+            worker._logger.info("testing_with_extras")
+
+            record_with_extras = [
+                r for r in caplog.records if "testing_with_extras" in r.message
+            ]
+
+            assert "testing_with_extras" in caplog.text
+            assert record_with_extras[0].worker_id == worker.backend_id
+            assert worker._logger.extra["worker_id"] == worker.backend_id
+
+    def test_worker_logger_sends_log_to_api_worker(
+        self, logger, mock_log_worker, experiment_enabled, logging_to_api_enabled
+    ):
+        logger.info("test-worker-log")
+
+        mock_log_worker.instance().send.assert_called_once()
+        assert len(mock_log_worker.instance().send.call_args_list) == 1
+
+        log_statement = mock_log_worker.instance().send.call_args.args[0]
+        assert log_statement["name"] == logger.name
+        assert log_statement["level"] == 20
+        assert log_statement["message"] == "test-worker-log"
+
+
 class TestAPILogWorker:
     @pytest.fixture
     async def worker(self):