Skip to content

Automate browser based workflows with AI

feat: add create-time run provenance tags (SKY-12252) (#7298)

Aaron Perezaad031759f85
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index 81dfdec47..ce86da76c 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -196,7 +196,9 @@ DEFAULT_WORKFLOW_TITLE = "New Workflow"
MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH = 120
MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH = 40
DETECTED_PLATFORM_RUN_TAG_KEY = "skyvern.platform"
-DETECTED_PLATFORM_RUN_TAG_CALLER_ID = "system:platform-detector"
+TRIGGER_RUN_TAG_KEY = "skyvern.trigger"
+TARGET_DOMAIN_RUN_TAG_KEY = "skyvern.target_domain"
+CREATION_RUN_TAG_CALLER_ID = "system:creation-tagging"
# Empirical S3 upload SLA; no start buffer (back-to-back leakage is worse than late uploads to the next run).
RECORDING_WINDOW_END_BUFFER = timedelta(minutes=15)
@@ -652,26 +654,41 @@ class WorkflowService:
raise
@staticmethod
- async def _apply_detected_platform_run_tag_best_effort(
+ async def _apply_creation_run_tags_best_effort(
*,
workflow: Workflow,
workflow_run_id: str,
organization_id: str,
parameters: dict[str, Any],
+ trigger_type: WorkflowRunTriggerType,
) -> None:
try:
- platform = workflow_script_service.detect_workflow_platform_for_tagging(workflow, parameters)
- if not platform:
- return
+ tags = {TRIGGER_RUN_TAG_KEY: trigger_type.value}
+ domain = workflow_script_service.resolve_target_domain_for_run_provenance(workflow, parameters)
+ if domain:
+ tags[TARGET_DOMAIN_RUN_TAG_KEY] = domain
+ try:
+ platform = workflow_script_service.detect_workflow_platform_for_tagging(
+ workflow, parameters, domain_override=domain
+ )
+ if platform:
+ tags[DETECTED_PLATFORM_RUN_TAG_KEY] = platform
+ except Exception:
+ LOG.warning(
+ "Failed to detect platform for creation workflow run tags",
+ workflow_run_id=workflow_run_id,
+ organization_id=organization_id,
+ exc_info=True,
+ )
await app.DATABASE.tags.apply_system_run_tag_changes(
workflow_run_id=workflow_run_id,
organization_id=organization_id,
- sets={DETECTED_PLATFORM_RUN_TAG_KEY: platform},
- caller_id=DETECTED_PLATFORM_RUN_TAG_CALLER_ID,
+ sets=tags,
+ caller_id=CREATION_RUN_TAG_CALLER_ID,
)
except Exception:
LOG.warning(
- "Failed to apply detected platform workflow run tag",
+ "Failed to apply creation workflow run tags",
workflow_run_id=workflow_run_id,
organization_id=organization_id,
exc_info=True,
@@ -1621,11 +1638,12 @@ class WorkflowService:
workflow_run_id=workflow_run.workflow_run_id,
batch_error=str(batch_error),
)
- await self._apply_detected_platform_run_tag_best_effort(
+ await self._apply_creation_run_tags_best_effort(
workflow=workflow,
workflow_run_id=workflow_run.workflow_run_id,
organization_id=organization.organization_id,
parameters=parameter_values,
+ trigger_type=resolved_trigger_type,
)
except Exception as e:
LOG.exception(
diff --git a/skyvern/services/workflow_script_service.py b/skyvern/services/workflow_script_service.py
index 1c93eab12..fdeaef88c 100644
--- a/skyvern/services/workflow_script_service.py
+++ b/skyvern/services/workflow_script_service.py
@@ -284,6 +284,34 @@ def _extract_first_block_domain(workflow: Workflow, parameters: dict[str, Any],
return ""
+def resolve_target_domain_for_run_provenance(workflow: Workflow, parameters: dict[str, Any]) -> str:
+ """Resolve a normalized first-block domain without recording unresolved parameter keys.
+
+ Requires a real dotted host so a bare ``url`` literal that isn't a declared
+ parameter (e.g. a misconfigured ``unknown_key``) is not recorded as a fake
+ ``skyvern.target_domain``.
+ """
+ try:
+ parameter_keys = {parameter.key for parameter in workflow.workflow_definition.parameters}
+ for block in get_all_blocks(workflow.workflow_definition.blocks):
+ raw_url = getattr(block, "url", None)
+ if not raw_url:
+ continue
+ url_template = str(raw_url)
+ if url_template in parameter_keys or url_template in parameters:
+ if not parameters.get(url_template):
+ return ""
+ rendered_url = _resolve_block_url_for_cache_key(url_template, parameters)
+ if not rendered_url:
+ return ""
+ if "." not in (urllib.parse.urlparse(rendered_url).hostname or ""):
+ return ""
+ return _jinja_domain_filter(rendered_url).rpartition("@")[2].lower()
+ except Exception:
+ return ""
+ return ""
+
+
def detect_workflow_platform(
workflow: Workflow,
parameters: dict[str, Any],
@@ -301,9 +329,11 @@ def detect_workflow_platform(
def detect_workflow_platform_for_tagging(
workflow: Workflow,
parameters: dict[str, Any],
+ *,
+ domain_override: str | None = None,
) -> str | None:
"""Detect a cloud platform for run tagging without changing cache-key behavior."""
- domain = _extract_first_block_domain(workflow, parameters)
+ domain = domain_override if domain_override is not None else _extract_first_block_domain(workflow, parameters)
if not domain:
return None
return app.AGENT_FUNCTION.detect_platform_for_tagging(domain)
diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.py
index 35576e856..7e07bc3d2 100644
--- a/tests/unit/test_workflow_run_parameter_batching.py
+++ b/tests/unit/test_workflow_run_parameter_batching.py
@@ -176,15 +176,19 @@ async def test_setup_workflow_run_continues_when_initial_run_tag_write_fails() -
@pytest.mark.asyncio
-async def test_setup_workflow_run_writes_detected_platform_as_system_run_tag() -> None:
+async def test_setup_workflow_run_writes_create_time_system_tags() -> None:
service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])
with (
patch("skyvern.forge.sdk.workflow.service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.workflow.service.workflow_script_service.resolve_target_domain_for_run_provenance",
+ return_value="jobs.example.com",
+ ),
patch(
"skyvern.forge.sdk.workflow.service.workflow_script_service.detect_workflow_platform_for_tagging",
return_value="known_platform",
- ) as detect_platform,
+ ),
):
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
@@ -198,17 +202,20 @@ async def test_setup_workflow_run_writes_detected_platform_as_system_run_tag() -
)
assert result is workflow_run
- detect_platform.assert_called_once_with(service.get_workflow_by_permanent_id.return_value, {})
mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once_with(
workflow_run_id=workflow_run.workflow_run_id,
organization_id=organization.organization_id,
- sets={"skyvern.platform": "known_platform"},
- caller_id="system:platform-detector",
+ sets={
+ "skyvern.trigger": "api",
+ "skyvern.target_domain": "jobs.example.com",
+ "skyvern.platform": "known_platform",
+ },
+ caller_id="system:creation-tagging",
)
@pytest.mark.asyncio
-async def test_setup_workflow_run_skips_platform_tag_when_detection_has_no_verdict() -> None:
+async def test_setup_workflow_run_writes_trigger_tag_when_target_domain_is_unavailable() -> None:
service, organization, _ = _make_service_with_mocks(workflow_parameters=[])
with (
@@ -229,11 +236,16 @@ async def test_setup_workflow_run_skips_platform_tag_when_detection_has_no_verdi
organization=organization,
)
- mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_not_awaited()
+ mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once_with(
+ workflow_run_id="wr_test",
+ organization_id="org_test",
+ sets={"skyvern.trigger": "api"},
+ caller_id="system:creation-tagging",
+ )
@pytest.mark.asyncio
-async def test_setup_workflow_run_continues_when_platform_tag_write_fails() -> None:
+async def test_setup_workflow_run_continues_when_creation_tag_write_fails() -> None:
service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])
with (
@@ -258,6 +270,41 @@ async def test_setup_workflow_run_continues_when_platform_tag_write_fails() -> N
mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once()
+async def test_setup_workflow_run_writes_provenance_tags_when_platform_detection_fails() -> None:
+ service, organization, workflow_run = _make_service_with_mocks(workflow_parameters=[])
+
+ with (
+ patch("skyvern.forge.sdk.workflow.service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.workflow.service.workflow_script_service.resolve_target_domain_for_run_provenance",
+ return_value="jobs.example.com",
+ ),
+ patch(
+ "skyvern.forge.sdk.workflow.service.workflow_script_service.detect_workflow_platform_for_tagging",
+ side_effect=RuntimeError("detector unavailable"),
+ ),
+ ):
+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
+ mock_app.DATABASE.tags.apply_system_run_tag_changes = AsyncMock()
+
+ result = await service.setup_workflow_run(
+ request_id="req_test",
+ workflow_request=WorkflowRequestBody(data={}),
+ workflow_permanent_id="wpid_test",
+ organization=organization,
+ )
+
+ assert result is workflow_run
+ mock_app.DATABASE.tags.apply_system_run_tag_changes.assert_awaited_once_with(
+ workflow_run_id="wr_test",
+ organization_id="org_test",
+ sets={"skyvern.trigger": "api", "skyvern.target_domain": "jobs.example.com"},
+ caller_id="system:creation-tagging",
+ )
+
+
@pytest.mark.asyncio
async def test_setup_workflow_run_raises_on_missing_required_parameters() -> None:
"""When required parameters have no value and no default, setup should raise MissingValueForParameter."""
diff --git a/tests/unit/workflow/test_cache_key_domain.py b/tests/unit/workflow/test_cache_key_domain.py
index a1018b5bb..ec4aa8437 100644
--- a/tests/unit/workflow/test_cache_key_domain.py
+++ b/tests/unit/workflow/test_cache_key_domain.py
@@ -3,9 +3,18 @@
from datetime import datetime, timezone
from skyvern.forge.sdk.workflow.models.block import BlockType, TaskBlock
-from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType
+from skyvern.forge.sdk.workflow.models.parameter import (
+ OutputParameter,
+ ParameterType,
+ WorkflowParameter,
+ WorkflowParameterType,
+)
from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowDefinition
-from skyvern.services.workflow_script_service import _extract_first_block_domain, _jinja_domain_filter
+from skyvern.services.workflow_script_service import (
+ _extract_first_block_domain,
+ _jinja_domain_filter,
+ resolve_target_domain_for_run_provenance,
+)
def _output_param(key: str = "out") -> OutputParameter:
@@ -31,6 +40,18 @@ def _task_block(label: str, url: str | None = None) -> TaskBlock:
)
+def _workflow_param(key: str) -> WorkflowParameter:
+ now = datetime.now(timezone.utc)
+ return WorkflowParameter(
+ workflow_parameter_id=f"wp_{key}",
+ workflow_parameter_type=WorkflowParameterType.STRING,
+ workflow_id="w_test",
+ key=key,
+ created_at=now,
+ modified_at=now,
+ )
+
+
def _workflow(blocks: list, cache_key: str = "default") -> Workflow:
return Workflow(
workflow_id="w_test",
@@ -163,3 +184,42 @@ class TestExtractFirstBlockDomain:
wf = _workflow(blocks)
params = {"website_url": "example.com/login"}
assert _extract_first_block_domain(wf, params) == "example.com"
+
+
+class TestResolveTargetDomainForRunProvenance:
+ def test_omits_unresolved_url_parameter_key(self) -> None:
+ wf = _workflow(
+ [
+ _task_block("step1", url="website_url"),
+ _task_block("step2", url="https://later.example.com"),
+ ]
+ )
+ wf.workflow_definition.parameters = [_workflow_param("website_url")]
+
+ assert resolve_target_domain_for_run_provenance(wf, {}) == ""
+ assert resolve_target_domain_for_run_provenance(wf, {"website_url": ""}) == ""
+
+ def test_sanitizes_resolved_domain(self) -> None:
+ wf = _workflow([_task_block("step1", url="website_url")])
+ wf.workflow_definition.parameters = [_workflow_param("website_url")]
+
+ assert (
+ resolve_target_domain_for_run_provenance(
+ wf,
+ {"website_url": "https://user:[email protected]/openings"},
+ )
+ == "jobs.example.com"
+ )
+
+ def test_omits_bare_url_literal_that_is_not_a_declared_parameter(self) -> None:
+ """A misconfigured ``url`` that is a bare identifier (neither a declared
+ parameter nor a runtime value) resolves to a single-label host; provenance
+ must omit it rather than record the literal as a fake domain."""
+ wf = _workflow([_task_block("step1", url="unknown_key")])
+
+ assert resolve_target_domain_for_run_provenance(wf, {}) == ""
+
+ def test_returns_domain_for_literal_url(self) -> None:
+ wf = _workflow([_task_block("step1", url="https://www.irs.gov/apply-ein")])
+
+ assert resolve_target_domain_for_run_provenance(wf, {}) == "www.irs.gov"