Skip to content

Automate browser based workflows with AI

Redact proxy values at all logging sinks (#8285)

Aaron Perez15d59ef176d6
diff --git a/skyvern/forge/log_redaction.py b/skyvern/forge/log_redaction.py
index 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 copilot
tracing 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 Mapping
from 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_log
REDACTED = "****"
@@ -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/regex
to 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 dict
like ``{"Proxy-Authorization": "Bearer sk-..."}`` cannot slip through under a
key 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_value
try:
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 REDACTED
return obj
if 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 REDACTED
dumped = 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: (
REDACTED
if 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.py
index 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.py
index 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 settings
from 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, even
try:
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.py
index c42c09260..641dd110e 100644
--- a/skyvern/schemas/proxy_pinning.py
+++ b/skyvern/schemas/proxy_pinning.py
@@ -4,6 +4,7 @@ import hmac
import json
import re
import secrets
+from enum import StrEnum
from hashlib import sha256
from 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.py
index 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 annotations
import contextlib
+import json
import sys
import threading
from types import SimpleNamespace
@@ -20,6 +21,16 @@ import pytest
from skyvern.config import settings
from 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_span
assert 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 fixture
diff --git a/tests/unit/test_forge_log_redaction.py b/tests/unit/test_forge_log_redaction.py
index a739ead89..2d5d6fb87 100644
--- a/tests/unit/test_forge_log_redaction.py
+++ b/tests/unit/test_forge_log_redaction.py
@@ -1,5 +1,6 @@
import json
import logging
+import re
import subprocess
import sys
import textwrap
@@ -11,13 +12,20 @@ import pytest
import structlog
from pydantic import BaseModel
+from skyvern.config import settings
+from skyvern.forge import log_redaction
from 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_scrub
from 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 SkyvernContext
from 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.py
index 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 annotations
import json
import logging
+import re
from collections.abc import Iterator
+from typing import Any
import 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(monkeypatc
assert 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.py
index 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 AgentFunction
from skyvern.forge.sdk.db.utils import deserialize_proxy_location, serialize_proxy_location
from skyvern.forge.sdk.schemas.browser_profiles import UpdateBrowserProfileRequest
from 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_location
from skyvern.schemas.runs import GeoTarget, ProxyLocation
from 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"),
[