dbos 1.5.0a2__tar.gz → 1.5.0a4__tar.gz

{dbos-1.5.0a2 → dbos-1.5.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 1.5.0a2
+Version: 1.5.0a4
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_admin_server.py

@@ -139,8 +139,8 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
         elif self.path == _global_timeout_path:
             inputs = json.loads(post_data.decode("utf-8"))
-            timeout_ms = inputs.get("timeout_ms", None)
-            global_timeout(self.dbos, timeout_ms)
+            cutoff_epoch_timestamp_ms = inputs.get("cutoff_epoch_timestamp_ms", None)
+            global_timeout(self.dbos, cutoff_epoch_timestamp_ms)
             self.send_response(204)
             self._end_headers()
         else:

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_conductor/conductor.py

@@ -13,7 +13,9 @@ from websockets.sync.connection import Connection
 from dbos._context import SetWorkflowID
 from dbos._utils import GlobalParams
 from dbos._workflow_commands import (
+    garbage_collect,
     get_workflow,
+    global_timeout,
     list_queued_workflows,
     list_workflow_steps,
     list_workflows,
@@ -356,6 +358,41 @@ class ConductorWebsocket(threading.Thread):
                                 error_message=error_message,
                             )
                             websocket.send(list_steps_response.to_json())
+                        elif msg_type == p.MessageType.RETENTION:
+                            retention_message = p.RetentionRequest.from_json(message)
+                            success = True
+                            try:
+                                garbage_collect(
+                                    self.dbos,
+                                    cutoff_epoch_timestamp_ms=retention_message.body[
+                                        "gc_cutoff_epoch_ms"
+                                    ],
+                                    rows_threshold=retention_message.body[
+                                        "gc_rows_threshold"
+                                    ],
+                                )
+                                if (
+                                    retention_message.body["timeout_cutoff_epoch_ms"]
+                                    is not None
+                                ):
+                                    global_timeout(
+                                        self.dbos,
+                                        retention_message.body[
+                                            "timeout_cutoff_epoch_ms"
+                                        ],
+                                    )
+                            except Exception as e:
+                                error_message = f"Exception encountered during enforcing retention policy: {traceback.format_exc()}"
+                                self.dbos.logger.error(error_message)
+                                success = False
+
+                            retention_response = p.RetentionResponse(
+                                type=p.MessageType.RETENTION,
+                                request_id=base_message.request_id,
+                                success=success,
+                                error_message=error_message,
+                            )
+                            websocket.send(retention_response.to_json())
                         else:
                             self.dbos.logger.warning(
                                 f"Unexpected message type: {msg_type}"

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_conductor/protocol.py

@@ -18,6 +18,7 @@ class MessageType(str, Enum):
     EXIST_PENDING_WORKFLOWS = "exist_pending_workflows"
     LIST_STEPS = "list_steps"
     FORK_WORKFLOW = "fork_workflow"
+    RETENTION = "retention"
 
 
 T = TypeVar("T", bound="BaseMessage")
@@ -280,3 +281,20 @@ class ForkWorkflowRequest(BaseMessage):
 class ForkWorkflowResponse(BaseMessage):
     new_workflow_id: Optional[str]
     error_message: Optional[str] = None
+
+
+class RetentionBody(TypedDict):
+    gc_cutoff_epoch_ms: Optional[int]
+    gc_rows_threshold: Optional[int]
+    timeout_cutoff_epoch_ms: Optional[int]
+
+
+@dataclass
+class RetentionRequest(BaseMessage):
+    body: RetentionBody
+
+
+@dataclass
+class RetentionResponse(BaseMessage):
+    success: bool
+    error_message: Optional[str] = None

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_core.py

@@ -404,9 +404,9 @@ def _execute_workflow_wthread(
                     return dbos._background_event_loop.submit_coroutine(
                         cast(Pending[R], result)()
                     )
-            except Exception:
+            except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"
+                    f"Exception encountered in asynchronous workflow:", exc_info=e
                 )
                 raise
 
@@ -430,9 +430,9 @@ async def _execute_workflow_async(
                     _get_wf_invoke_func(dbos, status)
                 )
                 return await result()
-            except Exception:
+            except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered in asynchronous workflow: {traceback.format_exc()}"
+                    f"Exception encountered in asynchronous workflow:", exc_info=e
                 )
                 raise
 

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_dbos.py

@@ -521,8 +521,8 @@ class DBOS:
                 handler.flush()
             add_otlp_to_all_loggers()
             add_transformer_to_all_loggers()
-        except Exception:
-            dbos_logger.error(f"DBOS failed to launch: {traceback.format_exc()}")
+        except Exception as e:
+            dbos_logger.error(f"DBOS failed to launch:", exc_info=e)
             raise
 
     @classmethod

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_queue.py

@@ -1,5 +1,4 @@
 import threading
-import traceback
 from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, TypedDict
 
 from psycopg import errors

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_recovery.py

@@ -1,7 +1,5 @@
-import os
 import threading
 import time
-import traceback
 from typing import TYPE_CHECKING, Any, List
 
 from dbos._utils import GlobalParams
@@ -39,9 +37,9 @@ def startup_recovery_thread(
             time.sleep(1)
         except Exception as e:
             dbos.logger.error(
-                f"Exception encountered when recovering workflows: {traceback.format_exc()}"
+                f"Exception encountered when recovering workflows:", exc_info=e
             )
-            raise e
+            raise
 
 
 def recover_pending_workflows(
@@ -59,9 +57,9 @@ def recover_pending_workflows(
                 workflow_handles.append(handle)
             except Exception as e:
                 dbos.logger.error(
-                    f"Exception encountered when recovering workflows: {traceback.format_exc()}"
+                    f"Exception encountered when recovering workflows:", exc_info=e
                 )
-                raise e
+                raise
         dbos.logger.info(
             f"Recovering {len(pending_workflows)} workflows for executor {executor_id} from version {GlobalParams.app_version}"
         )

{dbos-1.5.0a2 → dbos-1.5.0a4}/dbos/_workflow_commands.py

@@ -141,8 +141,7 @@ def garbage_collect(
         dbos._app_db.garbage_collect(cutoff_epoch_timestamp_ms, pending_workflow_ids)
 
 
-def global_timeout(dbos: "DBOS", timeout_ms: int) -> None:
-    cutoff_epoch_timestamp_ms = int(time.time() * 1000) - timeout_ms
+def global_timeout(dbos: "DBOS", cutoff_epoch_timestamp_ms: int) -> None:
     cutoff_iso = datetime.fromtimestamp(cutoff_epoch_timestamp_ms / 1000).isoformat()
     for workflow in dbos.list_workflows(
         status=WorkflowStatusString.PENDING.value, end_time=cutoff_iso

{dbos-1.5.0a2 → dbos-1.5.0a4}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "1.5.0a2"
+version = "1.5.0a4"
 
 [project.license]
 text = "MIT"

{dbos-1.5.0a2 → dbos-1.5.0a4}/tests/test_admin_server.py

@@ -484,10 +484,10 @@ def test_admin_global_timeout(dbos: DBOS) -> None:
 
     handle = DBOS.start_workflow(workflow)
     time.sleep(1)
-
+    cutoff_epoch_timestamp_ms = int(time.time() * 1000) - 1000
     response = requests.post(
         f"http://localhost:3001/dbos-global-timeout",
-        json={"timeout_ms": 1000},
+        json={"cutoff_epoch_timestamp_ms": cutoff_epoch_timestamp_ms},
         timeout=5,
     )
     response.raise_for_status()

{dbos-1.5.0a2 → dbos-1.5.0a4}/tests/test_workflow_management.py

@@ -737,7 +737,8 @@ def test_global_timeout(dbos: DBOS) -> None:
     # Wait one second, start one final workflow, then timeout all workflows started more than one second ago
     time.sleep(1)
     final_handle = DBOS.start_workflow(blocked_workflow)
-    global_timeout(dbos, 1000)
+    cutoff_epoch_timestamp_ms = int(time.time() * 1000) - 1000
+    global_timeout(dbos, cutoff_epoch_timestamp_ms)
 
     # Verify all workflows started before the global timeout are cancelled
     for handle in handles: