Enterprise agent platform for building, deploying, and operating AI teammates.
"""Request URLs are logged without credential-bearing query values."""
import logging
from collections.abc import Iterator
from logging.config import dictConfig
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from xagent.web import logging_config
from xagent.web.app import global_exception_handler, validation_exception_handler
from xagent.web.logging_config import setup_logging
from xagent.web.request_log_redaction import (
REDACTED,
RequestTargetRedactionFilter,
install_request_log_redaction,
redact_request_target,
)
SECRET = "guest.jwt.SECRET-VALUE"
@pytest.fixture
def restore_logging_state() -> Iterator[None]:
"""Snapshot every logger's level/handlers/filters and restore them after.
``setup_logging(force=True)`` and ``dictConfig`` rewrite global logging
state (including resetting child loggers of configured names), which would
otherwise leak into later tests.
"""
manager = logging.Logger.manager
loggers = [logging.getLogger()] + [
logger
for logger in list(manager.loggerDict.values())
if isinstance(logger, logging.Logger)
]
snapshot = [
(
logger,
logger.level,
list(logger.handlers),
list(logger.filters),
logger.propagate,
logger.disabled,
)
for logger in loggers
]
was_applied = logging_config._is_applied
try:
yield
finally:
for logger, level, handlers, filters, propagate, disabled in snapshot:
logger.setLevel(level)
logger.handlers[:] = handlers
logger.filters[:] = filters
logger.propagate = propagate
logger.disabled = disabled
logging_config._is_applied = was_applied
@pytest.mark.parametrize(
"target, expected",
[
("/api/files/public/preview/abc", "/api/files/public/preview/abc"),
(
f"/api/widget/chat/ws/1?token={SECRET}",
f"/api/widget/chat/ws/1?token={REDACTED}",
),
(
f"/api/files/public/preview/abc?relative_path=a.png&ticket={SECRET}",
f"/api/files/public/preview/abc?relative_path=a.png&ticket={REDACTED}",
),
(
f"/widget/chat/x?guest_id=g1&widget_key={SECRET}&embed_ticket={SECRET}",
f"/widget/chat/x?guest_id=g1&widget_key={REDACTED}&embed_ticket={REDACTED}",
),
(
f"/cb?code={SECRET}&state={SECRET}&access_token={SECRET}",
f"/cb?code={REDACTED}&state={REDACTED}&access_token={REDACTED}",
),
# Composio's verification trip and its denial redirect (#3532).
(
"/api/auth/meta/callback?session_uri=https%3A%2F%2Fbackend.composio.dev"
"%2Fverify%2Fsess_1",
f"/api/auth/meta/callback?session_uri={REDACTED}",
),
(
"/api/auth/meta/callback?status=failed&error=access_denied"
"&connected_account_id=ca_1",
"/api/auth/meta/callback?status=failed&error=access_denied"
f"&connected_account_id={REDACTED}",
),
(
f"https://host.example/a?api_key={SECRET}&page=2",
f"https://host.example/a?api_key={REDACTED}&page=2",
),
("/a?token=", "/a?token="),
("/a?validation_only=true", "/a?validation_only=true"),
# Nothing sensitive: returned byte-for-byte, never re-serialized.
("/search?q=a+b&flag&x=%5B1%5D", "/search?q=a+b&flag&x=%5B1%5D"),
],
)
def test_redact_request_target(target, expected):
assert redact_request_target(target) == expected
def test_access_log_record_args_are_redacted():
# uvicorn.access: '%s - "%s %s HTTP/%s" %d' with the raw path+query.
record = logging.LogRecord(
"uvicorn.access",
logging.INFO,
__file__,
1,
'%s - "%s %s HTTP/%s" %d',
("127.0.0.1:1", "GET", f"/api/share/chat/ws/1?token={SECRET}", "1.1", 101),
None,
)
assert RequestTargetRedactionFilter().filter(record) is True
assert SECRET not in record.getMessage()
assert f"?token={REDACTED}" in record.getMessage()
def test_access_log_record_redacts_an_encoded_composio_session_uri():
# The verifier URI arrives percent-encoded in the callback's query.
session_uri = "https%3A%2F%2Fbackend.composio.dev%2Fverify%2Fsess_SECRET"
record = logging.LogRecord(
"uvicorn.access",
logging.INFO,
__file__,
1,
'%s - "%s %s HTTP/%s" %d',
(
"127.0.0.1:1",
"GET",
f"/api/auth/meta/callback?session_uri={session_uri}",
"1.1",
200,
),
None,
)
assert RequestTargetRedactionFilter().filter(record) is True
message = record.getMessage()
assert "sess_SECRET" not in message
assert "backend.composio.dev" not in message
assert f"?session_uri={REDACTED}" in message
@pytest.mark.usefixtures("restore_logging_state")
def test_server_loggers_keep_the_filter_across_logging_reconfiguration():
setup_logging(force=True)
# The ASGI server applies its own dictConfig after ours.
dictConfig(
{
"version": 1,
"disable_existing_loggers": False,
"loggers": {
"uvicorn.access": {"level": "INFO"},
"uvicorn.error": {"level": "INFO"},
},
}
)
install_request_log_redaction() # idempotent
for name in ("uvicorn.access", "uvicorn.error"):
filters = [
f
for f in logging.getLogger(name).filters
if isinstance(f, RequestTargetRedactionFilter)
]
assert len(filters) == 1
# The server attaches its own non-propagating handlers; capture the same way.
records: list[logging.LogRecord] = []
capture = logging.Handler()
capture.emit = records.append # type: ignore[method-assign]
server_logger = logging.getLogger("uvicorn.error")
server_logger.addHandler(capture)
server_logger.setLevel(logging.INFO)
server_logger.info(
'%s - "WebSocket %s" [accepted]',
"127.0.0.1:1",
f"/api/widget/chat/ws/1?token={SECRET}",
)
message = records[-1].getMessage()
assert SECRET not in message
assert f"/api/widget/chat/ws/1?token={REDACTED}" in message
def _app_with_handlers() -> FastAPI:
app = FastAPI()
from fastapi.exceptions import RequestValidationError
app.add_exception_handler(RequestValidationError, validation_exception_handler)
app.add_exception_handler(Exception, global_exception_handler)
@app.get("/v1/boom")
def boom() -> None:
raise RuntimeError("boom")
@app.get("/api/typed")
def typed(count: int) -> dict[str, int]:
return {"count": count}
return app
def test_exception_handlers_log_the_path_not_the_query(caplog):
client = TestClient(_app_with_handlers(), raise_server_exceptions=False)
with caplog.at_level(logging.ERROR, logger="xagent.web.app"):
assert client.get(f"/v1/boom?token={SECRET}").status_code == 500
# The rejected input value itself is a potential secret too.
assert (
client.get(f"/api/typed?count={SECRET}&ticket={SECRET}").status_code == 422
)
assert SECRET not in caplog.text
assert "GET /v1/boom" in caplog.text
assert "GET /api/typed" in caplog.text
@pytest.mark.parametrize(
"direction, name, value, expected",
[
(
"<",
"Sec-WebSocket-Protocol",
f"xagent-auth-v1, xagent-auth-token.{SECRET}",
f"xagent-auth-v1, xagent-auth-token.{REDACTED}",
),
("<", "Authorization", f"Bearer {SECRET}", f"Bearer {REDACTED}"),
("<", "authorization", SECRET, REDACTED),
("<", "Proxy-Authorization", f"Basic {SECRET}", f"Basic {REDACTED}"),
("<", "Cookie", f"session={SECRET}", REDACTED),
("<", "X-Api-Key", SECRET, REDACTED),
("<", "X-Auth-Token", SECRET, REDACTED),
("<", "Sec-WebSocket-Protocol", "xagent-auth-v1", "xagent-auth-v1"),
("<", "Sec-WebSocket-Key", "dGhlIHNhbXBsZQ==", "dGhlIHNhbXBsZQ=="),
("<", "Host", "localhost:8000", "localhost:8000"),
("<", "Origin", "https://example.com", "https://example.com"),
(">", "Sec-WebSocket-Protocol", "xagent-auth-v1", "xagent-auth-v1"),
(">", "Set-Cookie", f"session={SECRET}", REDACTED),
],
)
def test_handshake_header_records_are_redacted(direction, name, value, expected):
# websockets' legacy and Sans-I/O servers both log one debug record per
# handshake header to the logger uvicorn passes them (uvicorn.error):
# logger.debug("< %s: %s", name, value) for the request, "> %s: %s" for
# the response.
record = logging.LogRecord(
"uvicorn.error",
logging.DEBUG,
__file__,
1,
f"{direction} %s: %s",
(name, value),
None,
)
assert RequestTargetRedactionFilter().filter(record) is True
assert record.getMessage() == f"{direction} {name}: {expected}"
def _capture_debug_handshake(ws_impl: str, **connect_kwargs: object) -> list[str]:
"""Run one real WebSocket handshake through uvicorn at debug level."""
import asyncio
import threading
import time
import uvicorn
from websockets.sync.client import connect
async def app(scope, receive, send): # type: ignore[no-untyped-def]
if scope["type"] != "websocket":
return
await receive()
offered = scope.get("subprotocols") or []
await send(
{
"type": "websocket.accept",
"subprotocol": "xagent-auth-v1" if offered else None,
}
)
await send({"type": "websocket.close", "code": 1000})
install_request_log_redaction()
records: list[logging.LogRecord] = []
capture = logging.Handler()
capture.emit = records.append # type: ignore[method-assign]
server_logger = logging.getLogger("uvicorn.error")
server_logger.addHandler(capture)
config = uvicorn.Config(
app,
host="127.0.0.1",
port=0,
ws=ws_impl,
log_level="debug",
log_config=None,
lifespan="off",
)
server = uvicorn.Server(config)
thread = threading.Thread(target=lambda: asyncio.run(server.serve()), daemon=True)
thread.start()
try:
deadline = time.monotonic() + 10
while not server.started:
assert time.monotonic() < deadline, "server did not start"
time.sleep(0.02)
port = server.servers[0].sockets[0].getsockname()[1]
with connect(f"ws://127.0.0.1:{port}/api/widget/chat/ws/1", **connect_kwargs):
pass
finally:
server.should_exit = True
thread.join(timeout=10)
server_logger.removeHandler(capture)
return [record.getMessage() for record in records]
@pytest.mark.usefixtures("restore_logging_state")
@pytest.mark.parametrize("ws_impl", ["websockets", "websockets-sansio"])
@pytest.mark.parametrize(
"connect_kwargs, carrier_line",
[
(
{"subprotocols": ["xagent-auth-v1", f"xagent-auth-token.{SECRET}"]},
f"< Sec-WebSocket-Protocol: xagent-auth-v1, xagent-auth-token.{REDACTED}",
),
(
{"additional_headers": {"Authorization": f"Bearer {SECRET}"}},
f"< Authorization: Bearer {REDACTED}",
),
],
)
def test_debug_websocket_handshake_logs_no_header_credentials(
ws_impl, connect_kwargs, carrier_line
):
messages = _capture_debug_handshake(ws_impl, **connect_kwargs)
assert messages, "the debug handshake logged nothing"
assert not [m for m in messages if SECRET in m]
# Header names are logged as the client spelled them.
lowered = [m.lower() for m in messages]
assert carrier_line.lower() in lowered
# Safe diagnostics remain.
assert any(m.startswith("< sec-websocket-key: ") for m in lowered)
assert "< get /api/widget/chat/ws/1 http/1.1" in lowered