flowstash-runtime 0.7.2__tar.gz → 0.8.0__tar.gz

{flowstash_runtime-0.7.2 → flowstash_runtime-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flowstash-runtime
-Version: 0.7.2
+Version: 0.8.0
 Summary: Actual runtime engine and bootstrap layer for the flowstash platform.
 Author: juraj.bezdek@gmail.com
 Author-email: juraj.bezdek@gmail.com
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: apscheduler (>=3.11.0)
 Requires-Dist: dramatiq (>=1.16.0)
 Requires-Dist: fastapi (>=0.110.0)
-Requires-Dist: flowstash-clients (>=0.7.2,<0.8.0)
-Requires-Dist: flowstash-lib (>=0.7.2,<0.8.0)
+Requires-Dist: flowstash-clients (>=0.8.0,<0.9.0)
+Requires-Dist: flowstash-lib (>=0.8.0,<0.9.0)
 Requires-Dist: pyyaml (>=6.0.1)
 Requires-Dist: uvicorn (>=0.29.0)

{flowstash_runtime-0.7.2 → flowstash_runtime-0.8.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "flowstash-runtime"
-version = "0.7.2"
+version = "0.8.0"
 description = "Actual runtime engine and bootstrap layer for the flowstash platform."
 authors = [{name = "juraj.bezdek@gmail.com", email = "juraj.bezdek@gmail.com"}]
 requires-python = ">=3.11"
 dependencies = [
-    "flowstash-clients>=0.7.2,<0.8.0",
-    "flowstash-lib>=0.7.2,<0.8.0",
+    "flowstash-clients>=0.8.0,<0.9.0",
+    "flowstash-lib>=0.8.0,<0.9.0",
     "fastapi>=0.110.0",
     "uvicorn>=0.29.0",
     "dramatiq>=1.16.0",

{flowstash_runtime-0.7.2 → flowstash_runtime-0.8.0}/src/flowstash/runtime/worker/backends/managed/http_entrypoint.py

@@ -10,7 +10,6 @@ Feed endpoints:
   POST /internal/feed/deliver/classic — single-record classic delivery (called by Cloud Tasks)
 """
 
-import inspect
 import logging
 import os
 from contextlib import asynccontextmanager
@@ -20,7 +19,7 @@ from typing import Any, Dict, List, Optional
 import httpx
 from fastapi import APIRouter, HTTPException, Request, status
 from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from flowstash.context import integration_context
 from flowstash.observability.ingestion import (
@@ -31,7 +30,6 @@ from flowstash.observability.ingestion import (
 
 from .drain import ManagedTaskDrainController
 from .task_resolver import (
-    register_task,
     resolve_function as _registry_resolve,
     _invoke_task_callable,
 )
@@ -52,28 +50,80 @@ class DelegationMetadataModel(BaseModel):
     target_task: Optional[str] = None
     accepted_id: Optional[str] = None
     schedule_time: Optional[str] = None
-    attrs: Dict[str, Any] = {}
+    attrs: Dict[str, Any] = Field(default_factory=dict)
 
 
 class ManagedHandleTaskPayload(BaseModel):
-    """Nested payload within the /handle_task protocol envelope."""
+    """Legacy nested payload accepted for backward compatibility."""
 
     func_ref: Optional[str] = None
-    args: list = []
-    kwargs: dict = {}
+    args: list = Field(default_factory=list)
+    kwargs: dict = Field(default_factory=dict)
+    integration: Optional[str] = None
+    pipeline: Optional[str] = None
+    triggered_by: Optional[str] = None
+    cron: Optional[str] = None
+    run_id: Optional[str] = None
     tags: Optional[Dict[str, Any]] = None
     delegation: Optional[DelegationMetadataModel] = None
 
 
-class ManagedHandleTaskEnvelope(BaseModel):
-    """Protocol envelope delivered by the platform to /handle_task."""
+class TaskPayload(BaseModel):
+    """Payload pushed by Managed Scheduler or Platform API."""
 
-    task_id: str
+    task_id: Optional[str] = None
     task_name: Optional[str] = None
+    func_ref: Optional[str] = None
+    args: list = Field(default_factory=list)
+    kwargs: dict = Field(default_factory=dict)
     integration: Optional[str] = None
     pipeline: Optional[str] = None
     triggered_by: Optional[str] = None
-    payload: ManagedHandleTaskPayload = ManagedHandleTaskPayload()
+    cron: Optional[str] = None
+    # run_id is kept for backward compatibility with older payloads that carry it,
+    # but it is NOT used as the execution run_id. The execution side always allocates
+    # a fresh run_id. Causal metadata is carried in the `delegation` field instead.
+    run_id: Optional[str] = None
+    tags: Optional[Dict[str, Any]] = None
+    delegation: Optional[DelegationMetadataModel] = None
+    payload: Optional[ManagedHandleTaskPayload] = None
+
+    def _payload_value(self, field_name: str) -> Any:
+        if self.payload is None:
+            return None
+        return getattr(self.payload, field_name)
+
+    def effective_func_ref(self) -> Optional[str]:
+        return self.func_ref or self._payload_value("func_ref")
+
+    def effective_args(self) -> list:
+        return self.args or self._payload_value("args") or []
+
+    def effective_kwargs(self) -> dict:
+        return self.kwargs or self._payload_value("kwargs") or {}
+
+    def effective_integration(self) -> Optional[str]:
+        return self.integration or self._payload_value("integration")
+
+    def effective_pipeline(self) -> Optional[str]:
+        return self.pipeline or self._payload_value("pipeline")
+
+    def effective_triggered_by(self) -> Optional[str]:
+        return self.triggered_by or self._payload_value("triggered_by")
+
+    def effective_cron(self) -> Optional[str]:
+        return self.cron or self._payload_value("cron")
+
+    def effective_tags(self) -> Dict[str, Any]:
+        tags = dict(self._payload_value("tags") or {})
+        tags.update(self.tags or {})
+        return tags
+
+    def effective_delegation(self) -> Optional[DelegationMetadataModel]:
+        return self.delegation or self._payload_value("delegation")
+
+    def execution_task_ref(self) -> Optional[str]:
+        return self.task_id or self.task_name or self.effective_func_ref()
 
 
 # ─── Task Resolution ─────────────────────────────────────────────────
@@ -131,23 +181,30 @@ async def _managed_request_scope(request: Request, kind: str, task_ref: str):
         await _flush_observability()
 
 
-async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
-    payload = envelope.payload
-    integration = envelope.integration or "unknown"
-    pipeline = envelope.pipeline or "unknown"
+async def _execute_managed_task(payload: TaskPayload) -> dict:
+    integration = payload.effective_integration() or "unknown"
+    pipeline = payload.effective_pipeline() or "unknown"
     parent_run_id: Optional[str] = None
     operation_id: Optional[str] = None
-    if payload.delegation:
-        parent_run_id = payload.delegation.parent_run_id
-        operation_id = payload.delegation.operation_id
-    tags = dict(payload.tags or {})
-
-    if envelope.triggered_by:
-        tags["triggered_by"] = envelope.triggered_by
-
-    func_ref = payload.func_ref or envelope.task_id
-    entry_point = envelope.task_name or func_ref
-    raw_args = {"args": payload.args, "kwargs": payload.kwargs}
+    delegation = payload.effective_delegation()
+    if delegation:
+        parent_run_id = delegation.parent_run_id
+        operation_id = delegation.operation_id
+    tags = payload.effective_tags()
+
+    triggered_by = payload.effective_triggered_by()
+    if triggered_by:
+        tags["triggered_by"] = triggered_by
+
+    cron = payload.effective_cron()
+    if cron:
+        tags["cron"] = cron
+
+    func_ref = payload.effective_func_ref() or payload.task_id
+    entry_point = payload.task_name or func_ref or payload.task_id or "unknown"
+    args = payload.effective_args()
+    kwargs = payload.effective_kwargs()
+    raw_args = {"args": args, "kwargs": kwargs}
 
     with integration_context(
         integration=integration,
@@ -159,7 +216,9 @@ async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
         record_lifecycle=False,
     ) as ctx:
         try:
-            func = _resolve_task_callable(envelope.task_name, payload.func_ref)
+            func = _resolve_task_callable(
+                payload.task_name or payload.task_id, func_ref
+            )
         except ValueError as e:
             logger.warning(f"Could not resolve task '{entry_point}': {e}")
             await record_run_started(
@@ -174,7 +233,7 @@ async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
             )
             raise
 
-        normalized_args = normalize_arguments(func, payload.args, payload.kwargs)
+        normalized_args = normalize_arguments(func, args, kwargs)
         await record_run_started(
             correlation=ctx.corelation,
             entry_point=entry_point,
@@ -182,7 +241,7 @@ async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
         )
 
         try:
-            await _invoke_task_callable(func, payload.args, payload.kwargs)
+            await _invoke_task_callable(func, args, kwargs)
         except Exception as e:
             import traceback
 
@@ -194,10 +253,6 @@ async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
                 correlation=ctx.corelation,
                 attrs={"error": error, "traceback": tb},
             )
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail={"status": "FAILED", "error": error, "task": func_ref},
-            )
 
         await record_run_ended(
             status="SUCCEEDED",
@@ -214,31 +269,36 @@ async def _execute_managed_task(envelope: ManagedHandleTaskEnvelope) -> dict:
 
 
 @router.post("/handle_task")
-async def handle_task(request: Request, envelope: ManagedHandleTaskEnvelope):
+async def handle_task(request: Request, payload: TaskPayload):
     """
     Receive and execute a task delivered by the managed platform.
 
-    Expects the three-tier protocol envelope with a nested `payload` object.
+    Accepts the original flat task payload. A nested `payload` object is still
+    accepted for backward compatibility with already-enqueued deliveries.
     Returns 404 + {"status": "TASK_NOT_FOUND"} when the task cannot be resolved
     (signals the platform to clean up orphaned schedules).
     Returns 500 on execution failure so Cloud Tasks retries the delivery.
     """
-    task_id = envelope.task_id
-    task_name = envelope.task_name
-    async with _managed_request_scope(request, "task", task_id) as admitted:
+    task_ref = payload.execution_task_ref()
+    if not task_ref:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing 'task_id', 'task_name', or 'func_ref' in payload",
+        )
+
+    async with _managed_request_scope(request, "task", task_ref) as admitted:
         if not admitted:
             return JSONResponse(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                content={"status": "DRAINING", "task": task_id},
+                content={"status": "DRAINING", "task": task_ref},
             )
 
         try:
-            return await _execute_managed_task(envelope)
-        except Exception as e:
-            print(f"Failed processing task '{task_name}': {e}")
+            return await _execute_managed_task(payload)
+        except ValueError as e:
             return JSONResponse(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                content={"status": "Processing failed!", "task_id": task_id},
+                status_code=status.HTTP_404_NOT_FOUND,
+                content={"status": "TASK_NOT_FOUND", "detail": str(e)},
             )