vellum-workflow-server 0.14.72.post6__tar.gz → 0.14.72.post8__tar.gz

{vellum_workflow_server-0.14.72.post6 → vellum_workflow_server-0.14.72.post8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-workflow-server
-Version: 0.14.72.post6
+Version: 0.14.72.post8
 Summary: 
 License: AGPL
 Requires-Python: >=3.9.0,<4

{vellum_workflow_server-0.14.72.post6 → vellum_workflow_server-0.14.72.post8}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-workflow-server"
 
 [tool.poetry]
 name = "vellum-workflow-server"
-version = "0.14.72.post6"
+version = "0.14.72.post8"
 description = ""
 readme = "README.md"
 authors = []

{vellum_workflow_server-0.14.72.post6 → vellum_workflow_server-0.14.72.post8}/src/workflow_server/api/workflow_view.py

@@ -32,6 +32,7 @@ from workflow_server.core.events import (
     VembdaExecutionInitiatedEvent,
 )
 from workflow_server.core.executor import stream_node_pebble_timeout, stream_workflow_process_timeout
+from workflow_server.core.utils import create_vembda_rejected_event, serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     NodeExecutorContext,
@@ -119,19 +120,7 @@ def stream_workflow_route() -> Response:
         sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id))
         logger.exception(e)
 
-        vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id,
-            span_id=context.execution_id,
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                stderr=traceback.format_exc(),
-                container_overhead_latency=context.container_overhead_latency,
-            ),
-            parent=None,
-        )
-        process_output_queue.put(vembda_fulfilled_event.model_dump(mode="json"))
+        process_output_queue.put(create_vembda_rejected_event(context, traceback.format_exc()))
 
     first_item = process_output_queue.get(timeout=0.1)
     if isinstance(first_item, str) and first_item.startswith(SPAN_ID_EVENT):
@@ -184,18 +173,9 @@ def stream_workflow_route() -> Response:
             if get_is_oom_killed():
                 logger.warning("Workflow stream OOM Kill event")
 
-                yield VembdaExecutionFulfilledEvent(
-                    id=uuid4(),
-                    timestamp=datetime.now(),
-                    trace_id=context.trace_id,
-                    span_id=context.execution_id,
-                    body=VembdaExecutionFulfilledBody(
-                        exit_code=-1,
-                        container_overhead_latency=context.container_overhead_latency,
-                        stderr=f"Organization Workflow server has exceeded {MEMORY_LIMIT_MB}MB memory limit.",
-                    ),
-                    parent=None,
-                ).model_dump(mode="json")
+                yield create_vembda_rejected_event(
+                    context, f"Organization Workflow server has exceeded {MEMORY_LIMIT_MB}MB memory limit."
+                )
 
                 if process and process.is_alive():
                     process.kill()
@@ -216,18 +196,9 @@ def stream_workflow_route() -> Response:
                     if process and not process.is_alive():
                         logger.error("Workflow process exited abnormally")
 
-                        yield VembdaExecutionFulfilledEvent(
-                            id=uuid4(),
-                            timestamp=datetime.now(),
-                            trace_id=context.trace_id,
-                            span_id=context.execution_id,
-                            body=VembdaExecutionFulfilledBody(
-                                exit_code=-1,
-                                container_overhead_latency=context.container_overhead_latency,
-                                stderr="Internal Server Error, Workflow process exited abnormally",
-                            ),
-                            parent=None,
-                        ).model_dump(mode="json")
+                        yield create_vembda_rejected_event(
+                            context, "Internal Server Error, Workflow process exited abnormally"
+                        )
 
                         break
 
@@ -330,19 +301,7 @@ def stream_node_route() -> Response:
                 if stream_future.exception() is not None:
                     # This happens when theres a problem with the stream function call
                     # itself not the workflow runner
-                    vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-                        id=uuid4(),
-                        timestamp=datetime.now(),
-                        trace_id=context.trace_id,
-                        span_id=context.execution_id,
-                        body=VembdaExecutionFulfilledBody(
-                            exit_code=-1,
-                            stderr="Internal Server Error",
-                            container_overhead_latency=context.container_overhead_latency,
-                        ),
-                        parent=None,
-                    )
-                    yield vembda_fulfilled_event.model_dump(mode="json")
+                    yield create_vembda_rejected_event(context, "Internal Server Error")
                     sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id))
                     app.logger.exception(stream_future.exception())
                     break
@@ -454,18 +413,7 @@ def startup_error_generator(
         yield "\n"
         yield vembda_initiated_event.model_dump_json()
         yield "\n"
-        yield VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id,
-            span_id=context.execution_id,
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                container_overhead_latency=context.container_overhead_latency,
-                stderr=message,
-            ),
-            parent=None,
-        ).model_dump_json()
+        yield serialize_vembda_rejected_event(context, message)
         yield "\n"
         yield "END"
         yield "\n"

{vellum_workflow_server-0.14.72.post6 → vellum_workflow_server-0.14.72.post8}/src/workflow_server/code_exec_runner.py

@@ -9,13 +9,9 @@ import sentry_sdk
 
 from vellum.workflows.exceptions import WorkflowInitializationException
 from workflow_server.api.workflow_view import get_workflow_request_context
-from workflow_server.core.events import (
-    VembdaExecutionFulfilledBody,
-    VembdaExecutionFulfilledEvent,
-    VembdaExecutionInitiatedBody,
-    VembdaExecutionInitiatedEvent,
-)
+from workflow_server.core.events import VembdaExecutionInitiatedBody, VembdaExecutionInitiatedEvent
 from workflow_server.core.executor import stream_workflow
+from workflow_server.core.utils import serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import WorkflowExecutorContext
 from workflow_server.utils.utils import get_version
 
@@ -57,34 +53,11 @@ def run_code_exec_stream() -> None:
             for line in stream_iterator:
                 print(f"{_EVENT_LINE}{json.dumps(line)}")  # noqa: T201
         except WorkflowInitializationException as e:
-            fulfilled_event = VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=context.trace_id,
-                span_id=context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr=str(e),
-                    container_overhead_latency=context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-
-            print(f"{_EVENT_LINE}{json.dumps(fulfilled_event)}")  # noqa: T201
+            fulfilled_event = serialize_vembda_rejected_event(context, str(e))
+            print(f"{_EVENT_LINE}{fulfilled_event}")  # noqa: T201
     except Exception as e:
         sentry_sdk.set_tag("vellum_trace_id", str(context.trace_id) if context else "unknown")
         logger.exception(e)
 
-        vembda_fulfilled_event = VembdaExecutionFulfilledEvent(
-            id=uuid4(),
-            timestamp=datetime.now(),
-            trace_id=context.trace_id if context else uuid4(),
-            span_id=context.execution_id if context else uuid4(),
-            body=VembdaExecutionFulfilledBody(
-                exit_code=-1,
-                stderr="Internal Server Error",
-            ),
-            parent=None,
-        )
-        event = json.dumps(vembda_fulfilled_event.model_dump(mode="json"))
+        event = serialize_vembda_rejected_event(context, "Internal Server Error")
         print(f"{_EVENT_LINE}{event}")  # noqa: T201

{vellum_workflow_server-0.14.72.post6 → vellum_workflow_server-0.14.72.post8}/src/workflow_server/core/executor.py

@@ -40,6 +40,7 @@ from workflow_server.core.events import (
     VembdaExecutionFulfilledBody,
     VembdaExecutionFulfilledEvent,
 )
+from workflow_server.core.utils import serialize_vembda_rejected_event
 from workflow_server.core.workflow_executor_context import (
     DEFAULT_TIMEOUT_SECONDS,
     BaseExecutorContext,
@@ -101,40 +102,14 @@ def _stream_workflow_wrapper(executor_context: WorkflowExecutorContext, queue: Q
         if not span_id_emitted:
             queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
 
-        queue.put(
-            VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=executor_context.trace_id,
-                span_id=executor_context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr=str(e),
-                    container_overhead_latency=executor_context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-        )
+        queue.put(serialize_vembda_rejected_event(executor_context, str(e)))
     except Exception as e:
         if not span_id_emitted:
             queue.put(f"{SPAN_ID_EVENT}:{uuid4()}")
 
         sentry_sdk.set_tag("vellum_trace_id", str(executor_context.trace_id))
         logger.exception(e)
-        queue.put(
-            VembdaExecutionFulfilledEvent(
-                id=uuid4(),
-                timestamp=datetime.now(),
-                trace_id=executor_context.trace_id,
-                span_id=executor_context.execution_id,
-                body=VembdaExecutionFulfilledBody(
-                    exit_code=-1,
-                    stderr="Internal Server Error",
-                    container_overhead_latency=executor_context.container_overhead_latency,
-                ),
-                parent=None,
-            ).model_dump(mode="json")
-        )
+        queue.put(serialize_vembda_rejected_event(executor_context, "Internal Server Error"))
     queue.put(STREAM_FINISHED_EVENT)
 
     exit(0)

vellum_workflow_server-0.14.72.post8/src/workflow_server/core/utils.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+from uuid import uuid4
+from typing import Optional
+
+from workflow_server.core.events import VembdaExecutionFulfilledBody, VembdaExecutionFulfilledEvent
+from workflow_server.core.workflow_executor_context import BaseExecutorContext
+
+
+def _create_vembda_rejected_event_base(
+    executor_context: Optional[BaseExecutorContext], error_message: str
+) -> VembdaExecutionFulfilledEvent:
+    if executor_context:
+        trace_id = executor_context.trace_id
+        span_id = executor_context.execution_id
+        container_overhead_latency = executor_context.container_overhead_latency
+    else:
+        trace_id = uuid4()
+        span_id = uuid4()
+        container_overhead_latency = None
+
+    return VembdaExecutionFulfilledEvent(
+        id=uuid4(),
+        timestamp=datetime.now(),
+        trace_id=trace_id,
+        span_id=span_id,
+        body=VembdaExecutionFulfilledBody(
+            exit_code=-1,
+            stderr=error_message,
+            container_overhead_latency=container_overhead_latency,
+        ),
+        parent=None,
+    )
+
+
+def create_vembda_rejected_event(executor_context: Optional[BaseExecutorContext], error_message: str) -> dict:
+    return _create_vembda_rejected_event_base(executor_context, error_message).model_dump(mode="json")
+
+
+def serialize_vembda_rejected_event(executor_context: Optional[BaseExecutorContext], error_message: str) -> str:
+    return _create_vembda_rejected_event_base(executor_context, error_message).model_dump_json()