hatchet-sdk 1.15.2__py3-none-any.whl → 1.16.0__py3-none-any.whl

hatchet_sdk/runnables/workflow.py

@@ -2,7 +2,16 @@ import asyncio
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, get_type_hints
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    TypeVar,
+    cast,
+    get_type_hints,
+    overload,
+)
 
 from google.protobuf import timestamp_pb2
 from pydantic import BaseModel, model_validator
@@ -651,39 +660,83 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
         return await ref.aio_result()
 
+    def _get_result(
+        self, ref: WorkflowRunRef, return_exceptions: bool
+    ) -> dict[str, Any] | BaseException:
+        try:
+            return ref.result()
+        except Exception as e:
+            if return_exceptions:
+                return e
+            raise e
+
+    @overload
+    def run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[True],
+    ) -> list[dict[str, Any] | BaseException]: ...
+
+    @overload
     def run_many(
         self,
         workflows: list[WorkflowRunTriggerConfig],
-    ) -> list[dict[str, Any]]:
+        return_exceptions: Literal[False] = False,
+    ) -> list[dict[str, Any]]: ...
+
+    def run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: bool = False,
+    ) -> list[dict[str, Any]] | list[dict[str, Any] | BaseException]:
         """
         Run a workflow in bulk and wait for all runs to complete.
         This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
 
         :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :param return_exceptions: If `True`, exceptions will be returned as part of the results instead of raising them.
         :returns: A list of results for each workflow run.
         """
         refs = self.client._client.admin.run_workflows(
             workflows=workflows,
         )
 
-        return [ref.result() for ref in refs]
+        return [self._get_result(ref, return_exceptions) for ref in refs]
 
+    @overload
     async def aio_run_many(
         self,
         workflows: list[WorkflowRunTriggerConfig],
-    ) -> list[dict[str, Any]]:
+        return_exceptions: Literal[True],
+    ) -> list[dict[str, Any] | BaseException]: ...
+
+    @overload
+    async def aio_run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[False] = False,
+    ) -> list[dict[str, Any]]: ...
+
+    async def aio_run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: bool = False,
+    ) -> list[dict[str, Any]] | list[dict[str, Any] | BaseException]:
         """
         Run a workflow in bulk and wait for all runs to complete.
         This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
 
         :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :param return_exceptions: If `True`, exceptions will be returned as part of the results instead of raising them.
         :returns: A list of results for each workflow run.
         """
         refs = await self.client._client.admin.aio_run_workflows(
             workflows=workflows,
         )
 
-        return await asyncio.gather(*[ref.aio_result() for ref in refs])
+        return await asyncio.gather(
+            *[ref.aio_result() for ref in refs], return_exceptions=return_exceptions
+        )
 
     def run_many_no_wait(
         self,
@@ -946,7 +999,7 @@ class Workflow(BaseWorkflow[TWorkflowInput]):
 
         :param backoff_max_seconds: The maximum number of seconds to allow retries with exponential backoff to continue.
 
-        :param concurrency: A list of concurrency expressions for the on-success task.
+        :param concurrency: A list of concurrency expressions for the on-failure task.
 
         :returns: A decorator which creates a `Task` object.
         """
@@ -1137,7 +1190,18 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
         self.config = self._workflow.config
 
-    def _extract_result(self, result: dict[str, Any]) -> R:
+    @overload
+    def _extract_result(self, result: dict[str, Any]) -> R: ...
+
+    @overload
+    def _extract_result(self, result: BaseException) -> BaseException: ...
+
+    def _extract_result(
+        self, result: dict[str, Any] | BaseException
+    ) -> R | BaseException:
+        if isinstance(result, BaseException):
+            return result
+
         output = result.get(self._task.name)
 
         if not self._output_validator:
@@ -1217,30 +1281,72 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
 
         return TaskRunRef[TWorkflowInput, R](self, ref)
 
-    def run_many(self, workflows: list[WorkflowRunTriggerConfig]) -> list[R]:
+    @overload
+    def run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[True],
+    ) -> list[R | BaseException]: ...
+
+    @overload
+    def run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[False] = False,
+    ) -> list[R]: ...
+
+    def run_many(
+        self, workflows: list[WorkflowRunTriggerConfig], return_exceptions: bool = False
+    ) -> list[R] | list[R | BaseException]:
         """
         Run a workflow in bulk and wait for all runs to complete.
         This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
 
         :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :param return_exceptions: If `True`, exceptions will be returned as part of the results instead of raising them.
         :returns: A list of results for each workflow run.
         """
         return [
             self._extract_result(result)
-            for result in self._workflow.run_many(workflows)
+            for result in self._workflow.run_many(
+                workflows,
+                ## hack: typing needs literal
+                True if return_exceptions else False,  # noqa: SIM210
+            )
         ]
 
-    async def aio_run_many(self, workflows: list[WorkflowRunTriggerConfig]) -> list[R]:
+    @overload
+    async def aio_run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[True],
+    ) -> list[R | BaseException]: ...
+
+    @overload
+    async def aio_run_many(
+        self,
+        workflows: list[WorkflowRunTriggerConfig],
+        return_exceptions: Literal[False] = False,
+    ) -> list[R]: ...
+
+    async def aio_run_many(
+        self, workflows: list[WorkflowRunTriggerConfig], return_exceptions: bool = False
+    ) -> list[R] | list[R | BaseException]:
         """
         Run a workflow in bulk and wait for all runs to complete.
         This method triggers multiple workflow runs, blocks until all of them complete, and returns the final results.
 
         :param workflows: A list of `WorkflowRunTriggerConfig` objects, each representing a workflow run to be triggered.
+        :param return_exceptions: If `True`, exceptions will be returned as part of the results instead of raising them.
         :returns: A list of results for each workflow run.
         """
         return [
             self._extract_result(result)
-            for result in await self._workflow.aio_run_many(workflows)
+            for result in await self._workflow.aio_run_many(
+                workflows,
+                ## hack: typing needs literal
+                True if return_exceptions else False,  # noqa: SIM210
+            )
         ]
 
     def run_many_no_wait(
@@ -1273,3 +1379,104 @@ class Standalone(BaseWorkflow[TWorkflowInput], Generic[TWorkflowInput, R]):
         refs = await self._workflow.aio_run_many_no_wait(workflows)
 
         return [TaskRunRef[TWorkflowInput, R](self, ref) for ref in refs]
+
+    def mock_run(
+        self,
+        input: TWorkflowInput | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
+        parent_outputs: dict[str, JSONSerializableMapping] | None = None,
+        retry_count: int = 0,
+        lifespan: Any = None,
+    ) -> R:
+        """
+        Mimic the execution of a task. This method is intended to be used to unit test
+        tasks without needing to interact with the Hatchet engine. Use `mock_run` for sync
+        tasks and `aio_mock_run` for async tasks.
+
+        :param input: The input to the task.
+        :param additional_metadata: Additional metadata to attach to the task.
+        :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
+        :param retry_count: The number of times the task has been retried.
+        :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+
+        :return: The output of the task.
+        """
+
+        return self._task.mock_run(
+            input=input,
+            additional_metadata=additional_metadata,
+            parent_outputs=parent_outputs,
+            retry_count=retry_count,
+            lifespan=lifespan,
+        )
+
+    async def aio_mock_run(
+        self,
+        input: TWorkflowInput | None = None,
+        additional_metadata: JSONSerializableMapping | None = None,
+        parent_outputs: dict[str, JSONSerializableMapping] | None = None,
+        retry_count: int = 0,
+        lifespan: Any = None,
+    ) -> R:
+        """
+        Mimic the execution of a task. This method is intended to be used to unit test
+        tasks without needing to interact with the Hatchet engine. Use `mock_run` for sync
+        tasks and `aio_mock_run` for async tasks.
+
+        :param input: The input to the task.
+        :param additional_metadata: Additional metadata to attach to the task.
+        :param parent_outputs: Outputs from parent tasks, if any. This is useful for mimicking DAG functionality. For instance, if you have a task `step_2` that has a `parent` which is `step_1`, you can pass `parent_outputs={"step_1": {"result": "Hello, world!"}}` to `step_2.mock_run()` to be able to access `ctx.task_output(step_1)` in `step_2`.
+        :param retry_count: The number of times the task has been retried.
+        :param lifespan: The lifespan to be used in the task, which is useful if one was set on the worker. This will allow you to access `ctx.lifespan` inside of your task.
+
+        :return: The output of the task.
+        """
+
+        return await self._task.aio_mock_run(
+            input=input,
+            additional_metadata=additional_metadata,
+            parent_outputs=parent_outputs,
+            retry_count=retry_count,
+            lifespan=lifespan,
+        )
+
+    @property
+    def is_async_function(self) -> bool:
+        """
+        Check if the task is an async function.
+
+        :returns: True if the task is an async function, False otherwise.
+        """
+        return self._task.is_async_function
+
+    def get_run_ref(self, run_id: str) -> TaskRunRef[TWorkflowInput, R]:
+        """
+        Get a reference to a task run by its run ID.
+
+        :param run_id: The ID of the run to get the reference for.
+        :returns: A `TaskRunRef` object representing the reference to the task run.
+        """
+        wrr = self._workflow.client._client.runs.get_run_ref(run_id)
+        return TaskRunRef[TWorkflowInput, R](self, wrr)
+
+    async def aio_get_result(self, run_id: str) -> R:
+        """
+        Get the result of a task run by its run ID.
+
+        :param run_id: The ID of the run to get the result for.
+        :returns: The result of the task run.
+        """
+        run_ref = self.get_run_ref(run_id)
+
+        return await run_ref.aio_result()
+
+    def get_result(self, run_id: str) -> R:
+        """
+        Get the result of a task run by its run ID.
+
+        :param run_id: The ID of the run to get the result for.
+        :returns: The result of the task run.
+        """
+        run_ref = self.get_run_ref(run_id)
+
+        return run_ref.result()

hatchet_sdk/utils/serde.py

@@ -2,10 +2,7 @@ from typing import Any, TypeVar, cast, overload
 
 T = TypeVar("T")
 K = TypeVar("K")
-
-
-@overload
-def remove_null_unicode_character(data: str, replacement: str = "") -> str: ...
+R = TypeVar("R")
 
 
 @overload
@@ -24,9 +21,13 @@ def remove_null_unicode_character(
 ) -> tuple[T, ...]: ...
 
 
+@overload
+def remove_null_unicode_character(data: R, replacement: str = "") -> R: ...
+
+
 def remove_null_unicode_character(
-    data: str | dict[K, T] | list[T] | tuple[T, ...], replacement: str = ""
-) -> str | dict[K, T] | list[T] | tuple[T, ...]:
+    data: dict[K, T] | list[T] | tuple[T, ...] | R, replacement: str = ""
+) -> str | dict[K, T] | list[T] | tuple[T, ...] | R:
     """
     Recursively traverse a dictionary (a task's output) and remove the unicode escape sequence \\u0000 which will cause unexpected behavior in Hatchet.
 
@@ -36,7 +37,6 @@ def remove_null_unicode_character(
     :param replacement: The string to replace \\u0000 with.
 
     :return: The same dictionary with all \\u0000 characters removed from strings, and nested dictionaries/lists processed recursively.
-    :raises TypeError: If the input is not a string, dictionary, list, or tuple.
     """
     if isinstance(data, str):
         return data.replace("\u0000", replacement)
@@ -57,6 +57,4 @@ def remove_null_unicode_character(
             remove_null_unicode_character(cast(Any, item), replacement) for item in data
         )
 
-    raise TypeError(
-        f"Unsupported type {type(data)}. Expected str, dict, list, or tuple."
-    )
+    return data

hatchet_sdk/worker/action_listener_process.py

@@ -132,8 +132,8 @@ class WorkerActionListenerProcess:
             )
 
             logger.debug(f"acquired action listener: {self.listener.worker_id}")
-        except grpc.RpcError as rpc_error:
-            logger.error(f"could not start action listener: {rpc_error}")
+        except grpc.RpcError:
+            logger.exception("could not start action listener")
             return
 
         # Start both loops as background tasks
@@ -168,7 +168,7 @@ class WorkerActionListenerProcess:
                     count += 1
 
             if count > 0:
-                logger.warning(f"{BLOCKED_THREAD_WARNING}: Waiting Steps {count}")
+                logger.warning(f"{BLOCKED_THREAD_WARNING} Waiting Steps {count}")
             await asyncio.sleep(1)
 
     async def send_event(self, event: ActionEvent, retry_attempt: int = 1) -> None:
@@ -188,7 +188,7 @@ class WorkerActionListenerProcess:
                             )
                             if diff > 0.1:
                                 logger.warning(
-                                    f"{BLOCKED_THREAD_WARNING}: time to start: {diff}s"
+                                    f"{BLOCKED_THREAD_WARNING} time to start: {diff}s"
                                 )
                             else:
                                 logger.debug(f"start time: {diff}")
@@ -225,9 +225,9 @@ class WorkerActionListenerProcess:
                     )
                 case _:
                     logger.error("unknown action type for event send")
-        except Exception as e:
-            logger.error(
-                f"could not send action event ({retry_attempt}/{ACTION_EVENT_RETRY_COUNT}): {e}"
+        except Exception:
+            logger.exception(
+                f"could not send action event ({retry_attempt}/{ACTION_EVENT_RETRY_COUNT})"
             )
             if retry_attempt <= ACTION_EVENT_RETRY_COUNT:
                 await exp_backoff_sleep(retry_attempt, 1)
@@ -291,11 +291,11 @@ class WorkerActionListenerProcess:
                         )
                 try:
                     self.action_queue.put(action)
-                except Exception as e:
-                    logger.error(f"error putting action: {e}")
+                except Exception:
+                    logger.exception("error putting action")
 
-        except Exception as e:
-            logger.error(f"error in action loop: {e}")
+        except Exception:
+            logger.exception("error in action loop")
         finally:
             logger.info("action loop closed")
             if not self.killing:

hatchet_sdk/worker/runner/runner.py

@@ -40,6 +40,7 @@ from hatchet_sdk.logger import logger
 from hatchet_sdk.runnables.action import Action, ActionKey, ActionType
 from hatchet_sdk.runnables.contextvars import (
     ctx_action_key,
+    ctx_additional_metadata,
     ctx_step_run_id,
     ctx_worker_id,
     ctx_workflow_run_id,
@@ -54,6 +55,8 @@ from hatchet_sdk.worker.action_listener_process import ActionEvent
 from hatchet_sdk.worker.runner.utils.capture_logs import (
     AsyncLogSender,
     ContextVarToCopy,
+    ContextVarToCopyDict,
+    ContextVarToCopyStr,
     copy_context_vars,
 )
 
@@ -295,6 +298,7 @@ class Runner:
         ctx_workflow_run_id.set(action.workflow_run_id)
         ctx_worker_id.set(action.worker_id)
         ctx_action_key.set(action.key)
+        ctx_additional_metadata.set(action.additional_metadata)
 
         try:
             if task.is_async_function:
@@ -305,20 +309,34 @@ class Runner:
                 copy_context_vars,
                 [
                     ContextVarToCopy(
-                        name="ctx_step_run_id",
-                        value=action.step_run_id,
+                        var=ContextVarToCopyStr(
+                            name="ctx_step_run_id",
+                            value=action.step_run_id,
+                        )
+                    ),
+                    ContextVarToCopy(
+                        var=ContextVarToCopyStr(
+                            name="ctx_workflow_run_id",
+                            value=action.workflow_run_id,
+                        )
                     ),
                     ContextVarToCopy(
-                        name="ctx_workflow_run_id",
-                        value=action.workflow_run_id,
+                        var=ContextVarToCopyStr(
+                            name="ctx_worker_id",
+                            value=action.worker_id,
+                        )
                     ),
                     ContextVarToCopy(
-                        name="ctx_worker_id",
-                        value=action.worker_id,
+                        var=ContextVarToCopyStr(
+                            name="ctx_action_key",
+                            value=action.key,
+                        )
                     ),
                     ContextVarToCopy(
-                        name="ctx_action_key",
-                        value=action.key,
+                        var=ContextVarToCopyDict(
+                            name="ctx_additional_metadata",
+                            value=action.additional_metadata,
+                        )
                     ),
                 ],
                 self.thread_action_func,
@@ -344,34 +362,34 @@ class Runner:
             "threads_daemon": sum(1 for t in self.thread_pool._threads if t.daemon),
         }
 
-        logger.warning("Thread pool detailed status %s", thread_pool_details)
+        logger.warning("thread pool detailed status %s", thread_pool_details)
 
     async def _start_monitoring(self) -> None:
-        logger.debug("Thread pool monitoring started")
+        logger.debug("thread pool monitoring started")
         try:
             while True:
                 await self.log_thread_pool_status()
 
                 for key in self.threads:
                     if key not in self.tasks:
-                        logger.debug(f"Potential zombie thread found for key {key}")
+                        logger.debug(f"potential zombie thread found for key {key}")
 
                 for key, task in self.tasks.items():
                     if task.done() and key in self.threads:
                         logger.debug(
-                            f"Task is done but thread still exists for key {key}"
+                            f"task is done but thread still exists for key {key}"
                         )
 
                 await asyncio.sleep(60)
         except asyncio.CancelledError:
-            logger.warning("Thread pool monitoring task cancelled")
+            logger.warning("thread pool monitoring task cancelled")
         except Exception as e:
-            logger.exception(f"Error in thread pool monitoring: {e}")
+            logger.exception(f"error in thread pool monitoring: {e}")
 
     def start_background_monitoring(self) -> None:
         loop = asyncio.get_event_loop()
         self.monitoring_task = loop.create_task(self._start_monitoring())
-        logger.debug("Started thread pool monitoring background task")
+        logger.debug("started thread pool monitoring background task")
 
     def cleanup_run_id(self, key: ActionKey) -> None:
         if key in self.tasks:
@@ -503,7 +521,7 @@ class Runner:
 
             ident = cast(int, thread.ident)
 
-            logger.info(f"Forcefully terminating thread {ident}")
+            logger.info(f"forcefully terminating thread {ident}")
 
             exc = ctypes.py_object(SystemExit)
             res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(ident), exc)
@@ -516,13 +534,13 @@ class Runner:
                 ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, 0)
                 raise SystemError("PyThreadState_SetAsyncExc failed")
 
-            logger.info(f"Successfully terminated thread {ident}")
+            logger.info(f"successfully terminated thread {ident}")
 
             # Immediately add a new thread to the thread pool, because we've actually killed a worker
             # in the ThreadPoolExecutor
             self.thread_pool.submit(lambda: None)
         except Exception as e:
-            logger.exception(f"Failed to terminate thread: {e}")
+            logger.exception(f"failed to terminate thread: {e}")
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     async def handle_cancel_action(self, action: Action) -> None:
@@ -546,7 +564,7 @@ class Runner:
                     await asyncio.sleep(1)
 
                 logger.warning(
-                    f"Thread {self.threads[key].ident} with key {key} is still running after cancellation. This could cause the thread pool to get blocked and prevent new tasks from running."
+                    f"thread {self.threads[key].ident} with key {key} is still running after cancellation. This could cause the thread pool to get blocked and prevent new tasks from running."
                 )
         finally:
             self.cleanup_run_id(key)
@@ -568,8 +586,8 @@ class Runner:
 
         try:
             serialized_output = json.dumps(output, default=str)
-        except Exception as e:
-            logger.error(f"Could not serialize output: {e}")
+        except Exception:
+            logger.exception("could not serialize output")
             serialized_output = str(output)
 
         if "\\u0000" in serialized_output:

hatchet_sdk/worker/runner/utils/capture_logs.py

@@ -5,29 +5,42 @@ from collections.abc import Awaitable, Callable
 from io import StringIO
 from typing import Literal, ParamSpec, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from hatchet_sdk.clients.events import EventClient
 from hatchet_sdk.logger import logger
 from hatchet_sdk.runnables.contextvars import (
     ctx_action_key,
+    ctx_additional_metadata,
     ctx_step_run_id,
     ctx_worker_id,
     ctx_workflow_run_id,
 )
-from hatchet_sdk.utils.typing import STOP_LOOP, STOP_LOOP_TYPE
+from hatchet_sdk.utils.typing import STOP_LOOP, STOP_LOOP_TYPE, JSONSerializableMapping
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
-class ContextVarToCopy(BaseModel):
+class ContextVarToCopyStr(BaseModel):
     name: Literal[
-        "ctx_workflow_run_id", "ctx_step_run_id", "ctx_action_key", "ctx_worker_id"
+        "ctx_workflow_run_id",
+        "ctx_step_run_id",
+        "ctx_action_key",
+        "ctx_worker_id",
     ]
     value: str | None
 
 
+class ContextVarToCopyDict(BaseModel):
+    name: Literal["ctx_additional_metadata"]
+    value: JSONSerializableMapping | None
+
+
+class ContextVarToCopy(BaseModel):
+    var: ContextVarToCopyStr | ContextVarToCopyDict = Field(discriminator="name")
+
+
 def copy_context_vars(
     ctx_vars: list[ContextVarToCopy],
     func: Callable[P, T],
@@ -35,16 +48,18 @@ def copy_context_vars(
     **kwargs: P.kwargs,
 ) -> T:
     for var in ctx_vars:
-        if var.name == "ctx_workflow_run_id":
-            ctx_workflow_run_id.set(var.value)
-        elif var.name == "ctx_step_run_id":
-            ctx_step_run_id.set(var.value)
-        elif var.name == "ctx_action_key":
-            ctx_action_key.set(var.value)
-        elif var.name == "ctx_worker_id":
-            ctx_worker_id.set(var.value)
+        if var.var.name == "ctx_workflow_run_id":
+            ctx_workflow_run_id.set(var.var.value)
+        elif var.var.name == "ctx_step_run_id":
+            ctx_step_run_id.set(var.var.value)
+        elif var.var.name == "ctx_action_key":
+            ctx_action_key.set(var.var.value)
+        elif var.var.name == "ctx_worker_id":
+            ctx_worker_id.set(var.var.value)
+        elif var.var.name == "ctx_additional_metadata":
+            ctx_additional_metadata.set(var.var.value or {})
         else:
-            raise ValueError(f"Unknown context variable name: {var.name}")
+            raise ValueError(f"Unknown context variable name: {var.var.name}")
 
     return func(*args, **kwargs)
 
@@ -73,13 +88,13 @@ class AsyncLogSender:
                     step_run_id=record.step_run_id,
                 )
             except Exception:
-                logger.exception("Failed to send log to Hatchet")
+                logger.exception("failed to send log to Hatchet")
 
     def publish(self, record: LogRecord | STOP_LOOP_TYPE) -> None:
         try:
             self.q.put_nowait(record)
         except asyncio.QueueFull:
-            logger.warning("Log queue is full, dropping log message")
+            logger.warning("log queue is full, dropping log message")
 
 
 class CustomLogHandler(logging.StreamHandler):  # type: ignore[type-arg]