Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Redact proxy values at all logging sinks (#8285)
Aaron Perez15d59ef176d6
diff --git a/skyvern/forge/log_redaction.py b/skyvern/forge/log_redaction.pyindex 0b5fde68b..db1ef07e6 100644--- a/skyvern/forge/log_redaction.py+++ b/skyvern/forge/log_redaction.py@@ -6,8 +6,11 @@ it from here would break logging on a core ``pip install skyvern``.Public surface (imported by ``forge_log``, ``request_logging`` and the copilottracing modules): ``REDACTED``, ``SENSITIVE_HEADERS``, ``SENSITIVE_FIELDS``,-``is_sensitive_key``, ``strip_artifact_url_query``, ``redact_bearer_tokens_in_text``-and ``redact_sensitive_fields``.+``is_sensitive_key``, ``strip_artifact_url_query``, ``redact_bearer_tokens_in_text``,+``redact_sensitive_fields``, ``is_proxy_observability_key``,+``register_proxy_observability_renderer`` and ``redact_proxy_observability_value``.+``ProxyObservabilityField`` and ``RedactedProxyLogValue`` are defined in+``skyvern.schemas.proxy_pinning``."""from __future__ import annotations@@ -19,6 +22,11 @@ from collections.abc import Mappingfrom pydantic import BaseModel+from skyvern.schemas.proxy_pinning import (+ ProxyObservabilityField,+ RedactedProxyLogValue,+ render_proxy_observability_value,+)from skyvern.utils.action_redaction import redact_action_payload_for_logREDACTED = "****"@@ -66,6 +74,12 @@ SENSITIVE_FIELDS: set[str] = {"totp_secret",} | SENSITIVE_HEADERS+_PROXY_OBSERVABILITY_FIELDS = {field.value: field for field in ProxyObservabilityField}+_PROXY_OBSERVABILITY_SUFFIXES = tuple((f"_{field.value}", field) for field in ProxyObservabilityField)+_proxy_observability_renderer: typing.Callable[[ProxyObservabilityField, object], RedactedProxyLogValue] = (+ render_proxy_observability_value+)+# Matches a signed artifact-content URL (absolute or path-relative) anywhere in a# string and captures everything up to — but excluding — its query, so re.sub can# drop the capability params (expiry/kid/sig) while leaving surrounding text and@@ -109,6 +123,42 @@ def is_sensitive_key(key: typing.Any, *, redact_metadata: bool = False) -> bool:return normalized in SENSITIVE_FIELDS or (redact_metadata and normalized == "metadata")+def is_proxy_observability_key(key: object) -> bool:+ return _proxy_observability_field(key) is not None+++def _proxy_observability_field(key: object) -> ProxyObservabilityField | None:+ if not isinstance(key, str):+ return None+ normalized = key.lower()+ exact = _PROXY_OBSERVABILITY_FIELDS.get(normalized)+ if exact is not None:+ return exact+ return next((field for suffix, field in _PROXY_OBSERVABILITY_SUFFIXES if normalized.endswith(suffix)), None)+++def register_proxy_observability_renderer(+ renderer: typing.Callable[[ProxyObservabilityField, object], RedactedProxyLogValue],+) -> None:+ global _proxy_observability_renderer+ _proxy_observability_renderer = renderer+++def redact_proxy_observability_value(key: object, value: object) -> RedactedProxyLogValue:+ if isinstance(value, RedactedProxyLogValue):+ return value+ field = _proxy_observability_field(key)+ if field is None:+ return RedactedProxyLogValue(REDACTED)+ try:+ rendered = _proxy_observability_renderer(field, value)+ except Exception: # noqa: BLE001 - any renderer failure must fail closed at this boundary+ return RedactedProxyLogValue(REDACTED)+ if not isinstance(rendered, RedactedProxyLogValue):+ return RedactedProxyLogValue(REDACTED)+ return rendered++def strip_artifact_url_query(value: str) -> str:return _ARTIFACT_CONTENT_URL_QUERY_RE.sub(r"\1", value)@@ -141,7 +191,7 @@ def redact_sensitive_fields(redact_metadata: bool = False,_seen: set[int] | None = None,) -> typing.Any:- """Redact sensitive fields, bearer credentials, and artifact-URL capability queries.+ """Redact sensitive fields, semantic proxy fields, bearer credentials, and artifact-URL capability queries.Field names use exact-match (case-insensitive) rather than substring/regexto avoid false positives on fields like ``credential_id``, ``author``, or@@ -149,11 +199,12 @@ def redact_sensitive_fields(credentials embedded in nested string values are stripped too, so a header dictlike ``{"Proxy-Authorization": "Bearer sk-..."}`` cannot slip through under akey name the middleware does not classify.+ Semantic proxy fields are rendered by the registered observability renderer."""if isinstance(obj, str):sanitized_value = _redact_string(obj)if _depth > 20:- return sanitized_value+ return REDACTED if sanitized_value.lstrip()[:1] in {"{", "["} else sanitized_valuetry:parsed_value = json.loads(sanitized_value)except (json.JSONDecodeError, TypeError):@@ -176,11 +227,8 @@ def redact_sensitive_fields(_seen.add(marker)if _depth > 20:- # Stop recursing but still redact sensitive keys at this level. Any Mapping- # (not just dict) so header containers such as httpx / starlette Headers,- # MappingProxyType and CIMultiDict are covered.- if isinstance(obj, Mapping):- return {k: REDACTED if is_sensitive_key(k, redact_metadata=redact_metadata) else v for k, v in obj.items()}+ if isinstance(obj, (BaseModel, Mapping, list, tuple, set, frozenset)):+ return REDACTEDreturn objif isinstance(obj, BaseModel):# A model kwarg is otherwise rendered in full by the log formatter, carrying@@ -190,7 +238,7 @@ def redact_sensitive_fields(try:dumped = obj.model_dump()except Exception:- return obj+ return REDACTEDdumped = redact_action_payload_for_log(dumped)return redact_sensitive_fields(dumped, _depth + 1, redact_metadata=redact_metadata, _seen=_seen)if isinstance(obj, Mapping):@@ -198,6 +246,8 @@ def redact_sensitive_fields(k: (REDACTEDif is_sensitive_key(k, redact_metadata=redact_metadata)+ else redact_proxy_observability_value(k, v)+ if is_proxy_observability_key(k)else redact_sensitive_fields(v, _depth + 1, redact_metadata=redact_metadata, _seen=_seen))for k, v in obj.items()diff --git a/skyvern/forge/sdk/copilot/tracing_setup.py b/skyvern/forge/sdk/copilot/tracing_setup.pyindex b0254f627..8dfe546a8 100644--- a/skyvern/forge/sdk/copilot/tracing_setup.py+++ b/skyvern/forge/sdk/copilot/tracing_setup.py@@ -424,4 +424,8 @@ def copilot_span(name: str, data: dict[str, Any] | None = None) -> Any:return contextlib.nullcontext()raise- return custom_span(name, data=data)+ try:+ redacted_data = redact_sensitive_fields(data) if data is not None else None+ except Exception: # noqa: BLE001 - trace redaction must drop data rather than expose it or disrupt execution+ redacted_data = None+ return custom_span(name, data=redacted_data)diff --git a/skyvern/forge/sdk/forge_log.py b/skyvern/forge/sdk/forge_log.pyindex daa3cb247..6f1c1a7cb 100644--- a/skyvern/forge/sdk/forge_log.py+++ b/skyvern/forge/sdk/forge_log.py@@ -17,8 +17,10 @@ from skyvern._version import __version__from skyvern.config import settingsfrom skyvern.forge.log_redaction import (REDACTED,+ is_proxy_observability_key,is_sensitive_key,redact_bearer_tokens_in_text,+ redact_proxy_observability_value,redact_sensitive_fields,)from skyvern.forge.sdk.core import skyvern_context@@ -592,6 +594,8 @@ def redact_sensitive_event_fields(logger: logging.Logger, method_name: str, eventry:if is_sensitive_key(key):event_dict[key] = REDACTED+ elif is_proxy_observability_key(key):+ event_dict[key] = redact_proxy_observability_value(key, value)elif not isinstance(value, str):event_dict[key] = redact_sensitive_fields(value)except Exception:@@ -1069,6 +1073,7 @@ def setup_logger() -> None:structlog.stdlib.ExtraAdder(),add_error_processor,structlog.processors.format_exc_info,+ redact_sensitive_event_fields,]+ foreign_msg_chain,processors=[@@ -1082,9 +1087,9 @@ def setup_logger() -> None:# exc_info to a string by now, so a secret in the exception text is reachable.# These stay duplicated in the structlog chain above on purpose: that pass also# guards `context.log`, which is persisted to the per-run S3 log artifact.- # `redact_sensitive_event_fields` is deliberately NOT duplicated here: foreign- # records carry only string values, and native records arrive already redacted,- # so it could only re-walk every structured kwarg a second time.+ # Native records are already redacted before `context.log`; foreign records get+ # their one field-redaction pass in `foreign_pre_chain`. Keep this shared+ # renderer chain unchanged so native structured values are not walked twice.redact_bearer_tokens,redact_registered_secrets,redact_codeblock_parameters,diff --git a/skyvern/schemas/proxy_pinning.py b/skyvern/schemas/proxy_pinning.pyindex c42c09260..641dd110e 100644--- a/skyvern/schemas/proxy_pinning.py+++ b/skyvern/schemas/proxy_pinning.py@@ -4,6 +4,7 @@ import hmacimport jsonimport reimport secrets+from enum import StrEnumfrom hashlib import sha256from typing import Any@@ -74,7 +75,18 @@ def _form_of(value: object) -> str:return type(value).__name__-def redact_proxy_location(value: object) -> str:+class RedactedProxyLogValue(str):+ """A proxy value already rendered safely for logs and traces."""+++class ProxyObservabilityField(StrEnum):+ PROXY_LOCATION = "proxy_location"+ PROXY_URL = "proxy_url"+ PROXY_HOST = "proxy_host"+ GEO_TARGET = "geo_target"+++def redact_proxy_location(value: object) -> RedactedProxyLogValue:"""A proxy_location named for a log line, never rendered into one.Only values a type or a closed character class proves cannot hold a credential are printed:@@ -88,15 +100,27 @@ def redact_proxy_location(value: object) -> str:value's length or contents is emitted alongside it."""if isinstance(value, ProxyLocation):- return value.value+ return RedactedProxyLogValue(value.value)if isinstance(value, GeoTarget):# NOT safe wholesale: city takes 100 characters of free text and subdivision 10, so a# validated GeoTarget can carry a URL. country is pinned to a supported set, so it is the# only field of it that can be shown.- return f"geo_target:{value.country}:{_identify(value)}"+ return RedactedProxyLogValue(f"geo_target:{value.country}:{_identify(value)}")if isinstance(value, str) and _ENUM_SHAPED_RE.fullmatch(value):- return value- return f"{_form_of(value)}:{_identify(value)}"+ return RedactedProxyLogValue(value)+ return RedactedProxyLogValue(f"{_form_of(value)}:{_identify(value)}")+++def render_proxy_observability_value(+ field: ProxyObservabilityField,+ value: object,+) -> RedactedProxyLogValue:+ """Render a value according to its semantic proxy field family."""+ if field is ProxyObservabilityField.PROXY_LOCATION:+ return redact_proxy_location(value)+ if field is ProxyObservabilityField.GEO_TARGET and isinstance(value, GeoTarget):+ return RedactedProxyLogValue(f"geo_target:{value.country}:{_identify(value)}")+ return RedactedProxyLogValue(f"{field.value}:{_identify(value)}")def should_generate_proxy_session_id(proxy_location: object | None) -> bool:diff --git a/tests/unit/test_copilot_tracing_setup.py b/tests/unit/test_copilot_tracing_setup.pyindex 1a1e93469..c458ee95c 100644--- a/tests/unit/test_copilot_tracing_setup.py+++ b/tests/unit/test_copilot_tracing_setup.py@@ -9,6 +9,7 @@ covered by an integration test once the copilot runtime wiring lands.from __future__ import annotationsimport contextlib+import jsonimport sysimport threadingfrom types import SimpleNamespace@@ -20,6 +21,16 @@ import pytestfrom skyvern.config import settingsfrom skyvern.forge.sdk.copilot import tracing_setup+_SYNTHETIC_PROXY_CREDENTIAL = "synthetic-proxy-secret"+_SYNTHETIC_PROXY_HOST = "internalproxy"+_SYNTHETIC_PROXY_URL = f"http://user:{_SYNTHETIC_PROXY_CREDENTIAL}@{_SYNTHETIC_PROXY_HOST}:8080"+++def _nested_mapping(value: object, depth: int = 22) -> object:+ for _ in range(depth):+ value = {"child": value}+ return value+@pytest.fixture(autouse=True)def _reset_module_state(monkeypatch: pytest.MonkeyPatch) -> None:@@ -341,6 +352,92 @@ class TestTracingSetup:assert span is fake_spanassert captured == {"name": "run_blocks", "data": {"block_count": 2}}+ def test_copilot_span_redacts_proxy_data_when_enabled(+ self,+ monkeypatch: pytest.MonkeyPatch,+ ) -> None:+ monkeypatch.setenv("COPILOT_TRACING_ENABLED", "1")+ monkeypatch.setattr(tracing_setup, "ensure_tracing_initialized", lambda: None)+ captured: dict[str, Any] = {}+ fake_span = object()++ def fake_custom_span(name: str, data: dict[str, Any] | None = None) -> object:+ captured["name"] = name+ captured["data"] = data+ return fake_span++ monkeypatch.setattr("agents.tracing.custom_span", fake_custom_span)++ span = tracing_setup.copilot_span(+ "workflow_proxy_location_normalized",+ {+ "input_proxy_location": {+ "url": "http://user:[email protected]:8080",+ },+ "effective_proxy_location": "RESIDENTIAL",+ "input_proxy_location_present": True,+ },+ )++ assert span is fake_span+ serialized = json.dumps(captured["data"])+ assert "synthetic-secret" not in serialized+ assert "token.proxy.example" not in serialized+ assert captured["data"]["input_proxy_location"].startswith("custom_url:")+ assert captured["data"]["effective_proxy_location"] == "RESIDENTIAL"+ assert captured["data"]["input_proxy_location_present"] is True++ def test_copilot_span_fails_closed_beyond_the_depth_cap(+ self,+ monkeypatch: pytest.MonkeyPatch,+ ) -> None:+ monkeypatch.setenv("COPILOT_TRACING_ENABLED", "1")+ monkeypatch.setattr(tracing_setup, "ensure_tracing_initialized", lambda: None)+ captured: dict[str, Any] = {}++ def fake_custom_span(name: str, data: dict[str, Any] | None = None) -> object:+ captured["name"] = name+ captured["data"] = data+ return object()++ monkeypatch.setattr("agents.tracing.custom_span", fake_custom_span)++ tracing_setup.copilot_span(+ "deep_proxy_data",+ {"payload": _nested_mapping({"proxy_url": _SYNTHETIC_PROXY_URL})},+ )++ serialized = json.dumps(captured["data"])+ assert _SYNTHETIC_PROXY_CREDENTIAL not in serialized+ assert _SYNTHETIC_PROXY_HOST not in serialized+ assert "****" in serialized++ def test_copilot_span_drops_data_when_redaction_fails(+ self,+ monkeypatch: pytest.MonkeyPatch,+ ) -> None:+ monkeypatch.setenv("COPILOT_TRACING_ENABLED", "1")+ monkeypatch.setattr(tracing_setup, "ensure_tracing_initialized", lambda: None)+ captured: dict[str, Any] = {}+ fake_span = object()++ def fail_redaction(value: object) -> object:+ del value+ raise RuntimeError("synthetic redaction failure")++ def fake_custom_span(name: str, data: dict[str, Any] | None = None) -> object:+ captured["name"] = name+ captured["data"] = data+ return fake_span++ monkeypatch.setattr(tracing_setup, "redact_sensitive_fields", fail_redaction)+ monkeypatch.setattr("agents.tracing.custom_span", fake_custom_span)++ span = tracing_setup.copilot_span("redaction_failure", {"proxy_url": _SYNTHETIC_PROXY_URL})++ assert span is fake_span+ assert captured == {"name": "redaction_failure", "data": None}+class TestPatchAgentSpanAttributes:"""Tests that invoke `_patch_agent_span_attributes`. The autouse fixturediff --git a/tests/unit/test_forge_log_redaction.py b/tests/unit/test_forge_log_redaction.pyindex a739ead89..2d5d6fb87 100644--- a/tests/unit/test_forge_log_redaction.py+++ b/tests/unit/test_forge_log_redaction.py@@ -1,5 +1,6 @@import jsonimport logging+import reimport subprocessimport sysimport textwrap@@ -11,13 +12,20 @@ import pytestimport structlogfrom pydantic import BaseModel+from skyvern.config import settings+from skyvern.forge import log_redactionfrom skyvern.forge.log_redaction import (+ REDACTED,+ is_proxy_observability_key,redact_bearer_tokens_in_text,+ redact_proxy_observability_value,redact_sensitive_fields,strip_artifact_url_query,)from skyvern.forge.sdk.copilot import secret_scrubfrom skyvern.forge.sdk.copilot.secret_scrub import REDACTED_SECRET_PLACEHOLDER+from skyvern.forge.sdk.core import skyvern_context+from skyvern.forge.sdk.core.skyvern_context import SkyvernContextfrom skyvern.forge.sdk.forge_log import (compact_action_objects,redact_bearer_tokens,@@ -25,9 +33,112 @@ from skyvern.forge.sdk.forge_log import (redact_sensitive_event_fields,setup_logger,)+from skyvern.schemas.proxy_pinning import ProxyObservabilityField, RedactedProxyLogValue, redact_proxy_location+from skyvern.schemas.runs import GeoTarget_FAKE_CREDENTIAL = "fake-pa55w0rd-7x9"_REDACTED = "****"+_SYNTHETIC_PROXY_CREDENTIAL = "synthetic-proxy-secret"+_SYNTHETIC_PROXY_HOST = "internalproxy"+_SYNTHETIC_PROXY_URL = f"http://user:{_SYNTHETIC_PROXY_CREDENTIAL}@{_SYNTHETIC_PROXY_HOST}:8080"+++def _nested_mapping(value: object, depth: int = 22) -> object:+ for _ in range(depth):+ value = {"child": value}+ return value+++def _emit_native_json_log(+ capsys: pytest.CaptureFixture[str],+ context: SkyvernContext,+ **event_fields: object,+) -> str:+ root = logging.getLogger()+ saved_config = structlog.get_config()+ saved_handlers = root.handlers[:]+ saved_level = root.level+ try:+ setup_logger()+ with skyvern_context.scoped(context):+ structlog.get_logger("skyvern.test.proxy_redaction").warning("synthetic proxy event", **event_fields)+ return capsys.readouterr().err+ finally:+ structlog.configure(**saved_config)+ root.handlers[:] = saved_handlers+ root.setLevel(saved_level)+++def test_proxy_observability_key_classifier_matches_values_not_metadata() -> None:+ for key in (+ "proxy_location",+ "profile_proxy_location",+ "input_proxy_location",+ "effective_proxy_location",+ "proxy_url",+ "proxy_host",+ "geo_target",+ ):+ assert is_proxy_observability_key(key)++ for key in ("proxy_location_type", "input_proxy_location_present", "proxy_session_id", 200):+ assert not is_proxy_observability_key(key)+++def test_proxy_observability_renderer_preserves_marked_values() -> None:+ rendered = redact_proxy_location({"url": "http://user:[email protected]:8080"})++ assert redact_proxy_observability_value("proxy_location", rendered) is rendered+++def test_proxy_observability_renderer_fails_closed(monkeypatch: pytest.MonkeyPatch) -> None:+ def fail_renderer(field: ProxyObservabilityField, value: object) -> RedactedProxyLogValue:+ assert field is ProxyObservabilityField.PROXY_LOCATION+ del value+ raise RuntimeError("synthetic renderer failure")++ monkeypatch.setattr(log_redaction, "_proxy_observability_renderer", fail_renderer)++ rendered = redact_proxy_observability_value(+ "proxy_location", "http://user:[email protected]:8080"+ )++ assert rendered == REDACTED+ assert isinstance(rendered, RedactedProxyLogValue)+++def test_proxy_observability_renderer_rejects_unmarked_values(monkeypatch: pytest.MonkeyPatch) -> None:+ def unsafe_renderer(field: ProxyObservabilityField, value: object) -> str:+ del field+ del value+ return "http://user:[email protected]:8080"++ monkeypatch.setattr(log_redaction, "_proxy_observability_renderer", unsafe_renderer)++ rendered = redact_proxy_observability_value("proxy_location", "proxy_location")++ assert rendered == REDACTED+ assert isinstance(rendered, RedactedProxyLogValue)+++def test_proxy_field_families_render_by_semantics() -> None:+ out = redact_sensitive_event_fields(+ None,+ "warning",+ {+ "proxy_location": "RESIDENTIAL",+ "proxy_host": _SYNTHETIC_PROXY_HOST,+ "proxy_url": _SYNTHETIC_PROXY_URL,+ "geo_target": GeoTarget(country="US", subdivision="CA", city="Chicago"),+ },+ ) # type: ignore[arg-type]++ assert out["proxy_location"] == "RESIDENTIAL"+ assert re.fullmatch(r"proxy_host:[0-9a-f]{12}", out["proxy_host"])+ assert re.fullmatch(r"proxy_url:[0-9a-f]{12}", out["proxy_url"])+ assert re.fullmatch(r"geo_target:US:[0-9a-f]{12}", out["geo_target"])+ assert _SYNTHETIC_PROXY_CREDENTIAL not in json.dumps(out)+ assert _SYNTHETIC_PROXY_HOST not in json.dumps(out)@pytest.fixture(autouse=True)@@ -216,6 +327,77 @@ def test_leaves_plain_string_values_untouched() -> None:assert out == event+def test_proxy_values_are_redacted_at_the_structlog_boundary() -> None:+ custom_proxy = {"url": "http://user:[email protected]:8080"}+ event = {+ "event": "synthetic proxy event",+ "proxy_location": custom_proxy,+ "profile_proxy_location": custom_proxy,+ "proxy_host": "token.proxy.example",+ "proxy_location_type": "dict",+ "input_proxy_location_present": True,+ "payload": {"effective_proxy_location": custom_proxy},+ }++ out = redact_sensitive_event_fields(None, "warning", event) # type: ignore[arg-type]+ dumped = json.dumps(out)++ assert "synthetic-secret" not in dumped+ assert "token.proxy.example" not in dumped+ assert re.fullmatch(r"custom_url:[0-9a-f]{12}", out["proxy_location"])+ assert out["profile_proxy_location"] == out["proxy_location"]+ assert re.fullmatch(r"proxy_host:[0-9a-f]{12}", out["proxy_host"])+ assert out["payload"]["effective_proxy_location"] == out["proxy_location"]+ assert out["proxy_location_type"] == "dict"+ assert out["input_proxy_location_present"] is True+++def test_proxy_boundary_does_not_render_a_marked_value_twice() -> None:+ rendered = redact_proxy_location({"url": "http://user:[email protected]:8080"})++ out = redact_sensitive_event_fields(None, "info", {"proxy_location": rendered}) # type: ignore[arg-type]++ assert out["proxy_location"] is rendered+++def test_native_pipeline_redacts_proxy_output_and_context_log(+ monkeypatch: pytest.MonkeyPatch,+ capsys: pytest.CaptureFixture[str],+) -> None:+ monkeypatch.setattr(settings, "JSON_LOGGING", True)+ context = SkyvernContext()++ rendered = _emit_native_json_log(+ capsys,+ context,+ proxy_host=_SYNTHETIC_PROXY_HOST,+ proxy_url=_SYNTHETIC_PROXY_URL,+ )+ persisted = json.dumps(context.log)++ for output in (rendered, persisted):+ assert _SYNTHETIC_PROXY_CREDENTIAL not in output+ assert _SYNTHETIC_PROXY_HOST not in output+ assert re.fullmatch(r"proxy_host:[0-9a-f]{12}", context.log[0]["proxy_host"])+++def test_native_pipeline_fails_closed_beyond_the_depth_cap(+ monkeypatch: pytest.MonkeyPatch,+ capsys: pytest.CaptureFixture[str],+) -> None:+ monkeypatch.setattr(settings, "JSON_LOGGING", True)+ context = SkyvernContext()+ payload = _nested_mapping({"proxy_url": _SYNTHETIC_PROXY_URL})++ rendered = _emit_native_json_log(capsys, context, payload=payload)+ persisted = json.dumps(context.log)++ for output in (rendered, persisted):+ assert _SYNTHETIC_PROXY_CREDENTIAL not in output+ assert _SYNTHETIC_PROXY_HOST not in output+ assert REDACTED in persisted++def test_webhook_failure_event_is_fully_redacted_through_processors() -> None:# Composed in the exact order setup_logger installs them: redact_bearer_tokens# first (top-level strings only), then redact_sensitive_event_fields (recurses@@ -324,6 +506,14 @@ class _FakeTaskModel(BaseModel):extra_http_headers: dict[str, str] | None = None+class _UndumpableProxyModel(BaseModel):+ proxy_url: str++ def model_dump(self, *args: object, **kwargs: object) -> dict[str, object]:+ del args, kwargs+ raise RuntimeError("synthetic model_dump failure")++def test_masks_sensitive_fields_inside_a_model_kwarg() -> None:"""A model kwarg is rendered in full by the formatter, so it has to be redacted too."""event = {"event": "x", "task": _FakeTaskModel(task_id="tsk_1", extra_http_headers={"X-Auth": "test-token-123"})}@@ -333,6 +523,21 @@ def test_masks_sensitive_fields_inside_a_model_kwarg() -> None:assert out["task"]["task_id"] == "tsk_1"+def test_model_dump_failure_fails_closed() -> None:+ model = _UndumpableProxyModel(proxy_url=_SYNTHETIC_PROXY_URL)++ assert redact_sensitive_fields(model) == REDACTED+++def test_depth_cap_redacts_remaining_containers_and_json_shaped_strings() -> None:+ raw = {"proxy_url": _SYNTHETIC_PROXY_URL}++ assert redact_sensitive_fields(raw, 21) == REDACTED+ assert redact_sensitive_fields([raw], 21) == REDACTED+ assert redact_sensitive_fields(json.dumps(raw), 21) == REDACTED+ assert redact_sensitive_fields("ordinary text", 21) == "ordinary text"++def test_masks_sensitive_fields_inside_tuple_and_set_kwargs() -> None:event = {"event": "x", "pair": ({"token": "test-token-123"},), "names": {"alpha", "beta"}}out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]diff --git a/tests/unit/test_forge_log_stdlib_extra.py b/tests/unit/test_forge_log_stdlib_extra.pyindex e79919dbe..ca0f465d9 100644--- a/tests/unit/test_forge_log_stdlib_extra.py+++ b/tests/unit/test_forge_log_stdlib_extra.py@@ -2,7 +2,9 @@ from __future__ import annotationsimport jsonimport logging+import refrom collections.abc import Iterator+from typing import Anyimport pytest@@ -28,13 +30,13 @@ def _render(record: logging.LogRecord) -> str:return formatter.format(record)-def _render_json(record: logging.LogRecord, monkeypatch: pytest.MonkeyPatch) -> dict[str, str]:+def _render_json(record: logging.LogRecord, monkeypatch: pytest.MonkeyPatch) -> dict[str, Any]:"""Render through the JSON branch — the one production and staging run."""monkeypatch.setattr(settings, "JSON_LOGGING", True)return json.loads(_render(record))-def _foreign_record(**extra: str) -> logging.LogRecord:+def _foreign_record(**extra: object) -> logging.LogRecord:"""A stdlib record shaped like `LOG.warning(msg, extra={...})` produces."""record = logging.LogRecord(name="codeblock.codeblock_grpc",@@ -96,6 +98,20 @@ def test_json_foreign_record_keeps_its_message_alongside_extra_fields(monkeypatcassert payload["grpc_status"] == "UNAVAILABLE"+def test_json_foreign_record_redacts_proxy_extra(monkeypatch: pytest.MonkeyPatch) -> None:+ payload = _render_json(+ _foreign_record(+ proxy_location={"url": "http://user:[email protected]:8080"},+ ),+ monkeypatch,+ )+ rendered = json.dumps(payload)++ assert "synthetic-secret" not in rendered+ assert "token.proxy.example" not in rendered+ assert re.fullmatch(r"custom_url:[0-9a-f]{12}", payload["proxy_location"])++def test_json_foreign_record_carries_organization_id_from_context(monkeypatch: pytest.MonkeyPatch) -> None:# The runner-unavailable alert groups by organization_id. A foreign record cannot bind# structlog context itself, so it has to be stamped from the ambient SkyvernContext.diff --git a/tests/unit/test_proxy_url_custom.py b/tests/unit/test_proxy_url_custom.pyindex 92abb524a..78f391c17 100644--- a/tests/unit/test_proxy_url_custom.py+++ b/tests/unit/test_proxy_url_custom.py@@ -12,7 +12,7 @@ from skyvern.forge.agent_functions import AgentFunctionfrom skyvern.forge.sdk.db.utils import deserialize_proxy_location, serialize_proxy_locationfrom skyvern.forge.sdk.schemas.browser_profiles import UpdateBrowserProfileRequestfrom skyvern.forge.sdk.schemas.credentials import UpdateCredentialRequest-from skyvern.schemas.proxy_pinning import redact_proxy_location+from skyvern.schemas.proxy_pinning import RedactedProxyLogValue, redact_proxy_locationfrom skyvern.schemas.runs import GeoTarget, ProxyLocationfrom skyvern.webeye.browser_factory import BrowserContextFactory, _redact_url_query@@ -183,6 +183,14 @@ def test_redact_proxy_location_never_renders_a_credentialed_value(value: object)assert _NAMED_ONLY_RE.fullmatch(rendered), rendered+def test_redact_proxy_location_returns_a_safe_log_value() -> None:+ rendered = redact_proxy_location({"url": "http://user:[email protected]:8080"})++ assert isinstance(rendered, RedactedProxyLogValue)+ assert "synthetic-secret" not in rendered+ assert "token.proxy.example" not in rendered++@pytest.mark.parametrize(("value", "expected"),[