fix(guardrails): log requests that a guardrail blocks on /apply_guardrail (#51014)

* fix(guardrails): record the guardrail verdict on a request dict that starts empty

The Bedrock guardrail and the shared `log_guardrail_information` wrapper both picked the request dict with `or {}`. An empty dict is falsy, so a caller that passed one had the verdict written to a throwaway dict. /apply_guardrail passes an empty dict for a request that carries no messages and no metadata, so nothing downstream could see what the guardrail decided. The verdict now goes to the dict the caller passed, and only a missing dict falls back to a new one.

* fix(guardrails): log requests that a guardrail blocks on /apply_guardrail

A request a guardrail blocked on /apply_guardrail was missing from the logs. The endpoint skipped the failure handlers for an HTTPException, the spend log failure hook wrote no row because the route is not an LLM API route, and the guardrail's verdict stayed on a request dict no logger reads.

The endpoint now runs the failure handlers for every exception and copies the verdict onto the logged request, so allowed and blocked requests both carry it along with the guardrail's cost. It marks the failure of a request it had set up with a sentinel, and the spend log failure hook writes its row for that mark. A request rejected before setup, such as one with a bad key or an unknown guardrail, is still not logged. Guardrail records a caller sends in metadata are dropped for both response formats so a verdict cannot be forged in the logs.

* fix(guardrails): keep Presidio and Gray Swan verdicts on empty request data

Presidio's text-only path and Gray Swan's API-failure path replaced an empty request dict with a throwaway one, so the verdict never reached the logged request. The apply_guardrail logging tests now run the real request setup and read what a logging callback receives.

* test(guardrails): cover the endpoint failure row, the sync decorator, and an unreachable Gray Swan without real sockets

* fix(logging): redact prompt text in guardrail records when message logging is off

* fix(logging): redact the failure payload when message logging is off

* fix(logging): keep guardrail details for other callbacks when one opts out of message logging

* fix(logging): redact failure events per callback and keep guardrail compression stats

A callback that turns off message logging now gets the same redacted copy on failure events as on success events, so a blocked /apply_guardrail call no longer hands it the raw prompt and verdict

Guardrail redaction keeps the numeric compression stats (tokens saved, compression ratio) that spend tracking reads, through one helper shared with the spend-log sanitizer

* fix(policy): test each batch input on its own copy of the request data

The guardrail logging decorator now records a verdict on an empty request dict instead of dropping it. The policy test endpoint shared one request dict across every input and merged it into the agent call, so each later input and agent request carried the earlier inputs' verdicts. Each input now gets its own copy, which keeps the caller's request data unchanged

* test(policy): look up the counting guardrail through the real registry

The batch isolation test now registers its guardrail as a litellm callback, so the endpoint finds it through the real guardrail registry instead of a mocked one, and its apply_guardrail override carries the same concrete types as the base class

---------

Co-authored-by: mateo-berri <277851410+mateo-berri@users.noreply.github.com>
This commit is contained in:
Agung Besti 2026-11-17 06:18:08 +07:00 • committed by GitHub
parent 1540acd7e4
commit c482013a8a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
20 changed files with 718 additions and 69 deletions

View file

@ -1989,7 +1989,13 @@ def log_guardrail_information(func):
async def async_wrapper(*args, **kwargs):
start_time: Final = datetime.now() # Move start_time inside the wrapper
self: Final[CustomGuardrail] = args[0]
request_data: Final[dict] = kwargs.get("data") or kwargs.get("request_data") or {}
request_data: Final[dict] = (
kwargs["data"]
if kwargs.get("data") is not None
else kwargs["request_data"]
if kwargs.get("request_data") is not None
else {}
)
event_type: Final = _infer_event_type_from_function_name(func.__name__)
# Store original inputs for comparison (for apply_guardrail functions)
@ -2029,7 +2035,13 @@ def log_guardrail_information(func):
def sync_wrapper(*args, **kwargs):
start_time: Final = datetime.now() # Move start_time inside the wrapper
self: Final[CustomGuardrail] = args[0]
request_data: Final[dict] = kwargs.get("data") or kwargs.get("request_data") or {}
request_data: Final[dict] = (
kwargs["data"]
if kwargs.get("data") is not None
else kwargs["request_data"]
if kwargs.get("request_data") is not None
else {}
)
event_type: Final = _infer_event_type_from_function_name(func.__name__)
# Store original inputs for comparison (for apply_guardrail functions)

View file

@ -186,6 +186,7 @@ from litellm.litellm_core_utils.redact_messages import (
redact_message_input_output_from_logging,
redacted_model_call_details_for_custom_logger,
redacted_response_obj_for_custom_logger,
redacted_standard_logging_payload,
should_redact_message_logging,
)
from litellm.litellm_core_utils.served_output_texts import (
@ -5203,7 +5204,7 @@ class Logging(LiteLLMLoggingBaseClass):
## STANDARDIZED LOGGING PAYLOAD
self.model_call_details["standard_logging_object"] = get_standard_logging_object_payload(
failure_payload: Final = get_standard_logging_object_payload(
kwargs=self.model_call_details,
init_response_obj={},
start_time=start_time,
@ -5214,6 +5215,11 @@ class Logging(LiteLLMLoggingBaseClass):
original_exception=exception,
standard_built_in_tools_params=self.standard_built_in_tools_params,
)
self.model_call_details["standard_logging_object"] = (
redacted_standard_logging_payload(failure_payload)
if failure_payload is not None and should_redact_message_logging(self.model_call_details)
else failure_payload
)
return start_time, end_time
def _should_estimate_failed_prompt(self) -> bool:
@ -5629,7 +5635,12 @@ class Logging(LiteLLMLoggingBaseClass):
return
if isinstance(callback, CustomLogger): # custom logger class
await callback.async_log_failure_event(
kwargs=self.model_call_details,
kwargs=redacted_model_call_details_for_custom_logger(
model_call_details=callback.redact_standard_logging_payload_from_model_call_details(
model_call_details=self.model_call_details
),
custom_logger=callback,
),
response_obj=result,
start_time=start_time,
end_time=end_time,

View file

@ -21,6 +21,7 @@ from litellm.constants import REDACTED_BY_LITELLM
from litellm.integrations.custom_logger import CustomLogger
from litellm.litellm_core_utils.classifier_logging import without_classifier_audit
from litellm.litellm_core_utils.core_helpers import (
as_object_list,
attribute_or_none,
get_metadata_variable_name_from_kwargs,
has_attributes,
@ -33,7 +34,7 @@ from litellm.llms.vertex_ai.common_utils import (
)
from litellm.secret_managers.main import str_to_bool
from litellm.types.router import BaselineRouteStamp
from litellm.types.utils import StandardCallbackDynamicParams
from litellm.types.utils import PROMPT_CARRYING_GUARDRAIL_FIELDS, StandardCallbackDynamicParams
from litellm.types.vector_stores import RETRIEVAL_QUERY_PARAMS
if TYPE_CHECKING:
@ -249,6 +250,42 @@ def _as_mapping(value: object) -> Mapping[str, object] | None:
return value if isinstance(value, Mapping) else None # pyright: ignore[reportUnknownVariableType] # keys are read one by one
_NUMERIC_COMPRESSION_STAT_KEYS: Final = frozenset(
{"tokens_before", "tokens_after", "tokens_saved", "compression_ratio"}
)
def numeric_compression_stats(guardrail_entry: Mapping[str, object]) -> dict[str, int | float] | None:
fields: Final = _as_mapping(guardrail_entry.get("guardrail_response"))
if fields is None:
return None
stats: Final = {
key: value
for key, value in fields.items()
if key in _NUMERIC_COMPRESSION_STAT_KEYS and isinstance(value, (int, float)) and not isinstance(value, bool)
}
return stats or None
def _guardrail_entry_without_prompt_text(entry: object) -> object:
fields: Final = _as_mapping(entry)
if fields is None:
return entry
redacted: Final = {
field: REDACTED_BY_LITELLM if field in PROMPT_CARRYING_GUARDRAIL_FIELDS and value is not None else value
for field, value in fields.items()
}
stats: Final = numeric_compression_stats(fields)
return redacted if stats is None else {**redacted, "guardrail_response": stats}
def _guardrail_information_without_prompt_text(guardrail_information: object) -> object:
entries: Final = as_object_list(guardrail_information)
if entries is None:
return _guardrail_entry_without_prompt_text(guardrail_information)
return [_guardrail_entry_without_prompt_text(entry) for entry in entries]
def _redact_provider_specific_fields(message: object) -> None:
if (fields := _as_mapping(getattr(message, "provider_specific_fields", None))) is not None:
setattr(message, "provider_specific_fields", _redacted_provider_specific_fields(fields)) # noqa: B010 # typed as object
@ -502,32 +539,34 @@ def _redacted_responses_api_response(
def redacted_standard_logging_payload(payload: Mapping[str, object]) -> Mapping[str, object]:
"""
Return a copy of a ``StandardLoggingPayload`` with its messages and response redacted.
The success path redacts through ``perform_redaction`` before a callback ever sees the
payload, but the failure path does not, so a callback that batches both has to redact
the ones it is handed.
Return a copy of a ``StandardLoggingPayload`` with its messages, response and guardrail
prompt text redacted.
"""
return _redact_standard_logging_object(payload)
def _redact_standard_logging_object(
payload: Mapping[str, object], *, redact_instructions: bool = True
payload: Mapping[str, object], *, redact_shared_fields: bool = True
) -> dict[str, object]:
standard_logging_object: Final = copy.deepcopy(without_classifier_audit(payload))
redacted_str: Final = REDACTED_BY_LITELLM
if standard_logging_object.get("messages") is not None:
standard_logging_object["messages"] = [{"role": "user", "content": redacted_str}]
guardrail_information: Final = standard_logging_object.get("guardrail_information")
if guardrail_information is not None and redact_shared_fields:
standard_logging_object["guardrail_information"] = _guardrail_information_without_prompt_text(
guardrail_information
)
model_parameters: Final = _as_mapping(standard_logging_object.get("model_parameters"))
if model_parameters is not None and redact_instructions:
if model_parameters is not None and redact_shared_fields:
standard_logging_object["model_parameters"] = _with_redacted_request_fields(model_parameters)
response: Final = standard_logging_object.get("response")
if response is not None:
if isinstance(response, dict) and "output" in response:
standard_logging_object["response"] = _redacted_responses_api_response(
response, redact_instructions=redact_instructions
response, redact_instructions=redact_shared_fields
)
redact_vertex_ai_metadata_from_logged_object(standard_logging_object["response"])
elif isinstance(response, dict) and "choices" in response:
@ -639,8 +678,8 @@ def perform_redaction(model_call_details: dict[str, object], result, redact_stre
redact_streaming_responses=False skips the in-place redaction of the shared streaming
response entries; per-callback redaction hands each opted-out callback its own redacted
copy via redacted_model_call_details_for_custom_logger instead. It also leaves the shared
request instructions, proxy request body and hidden provider fields as they are, since the
spend log and the other callbacks read them.
request instructions, guardrail prompt text, proxy request body and hidden provider fields
as they are, since the spend log and the other callbacks read them.
"""
# Redact model_call_details
params: Final = _as_mapping(model_call_details.get("litellm_params"))
@ -665,7 +704,7 @@ def perform_redaction(model_call_details: dict[str, object], result, redact_stre
standard_logging_object: Final = model_call_details.get("standard_logging_object")
if isinstance(standard_logging_object, Mapping):
model_call_details["standard_logging_object"] = _redact_standard_logging_object(
standard_logging_object, redact_instructions=redact_streaming_responses
standard_logging_object, redact_shared_fields=redact_streaming_responses
)
redact_vertex_ai_metadata_from_litellm_params(model_call_details)

View file

@ -18,7 +18,13 @@ from pydantic import BaseModel, TypeAdapter, ValidationError
from litellm._logging import verbose_proxy_logger
from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH
from litellm.integrations.custom_guardrail import CustomGuardrail, GuardrailSetupError
from litellm.integrations.custom_guardrail import (
CustomGuardrail,
GuardrailSetupError,
_append_slg_to_litellm_params, # pyright: ignore[reportPrivateUsage, reportUnknownVariableType] # share the guardrail logging bridge, which takes a bare list
_sync_guardrail_info_to_logging_obj, # pyright: ignore[reportPrivateUsage, reportUnknownVariableType] # share the guardrail logging bridge, which takes a bare dict
)
from litellm.litellm_core_utils.core_helpers import as_object_list, as_str_mapping
from litellm.litellm_core_utils.safe_json_dumps import safe_dumps
from litellm.proxy._types import AUDIT_ACTIONS, LitellmTableNames, LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
@ -2528,6 +2534,19 @@ async def _guardrail_response_after_success_hook(
return response
def _record_verdict_for_logging(
request_data: dict[str, object], # mutable-ok: the logging bridge takes the request dict itself
data: dict[str, object], # mutable-ok: the logged request receives the guardrail's verdict
litellm_logging_obj: object,
) -> None:
metadata: Final = as_str_mapping(request_data.get("metadata")) or {}
records: Final = as_object_list(metadata.get("standard_logging_guardrail_information"))
if not records:
return
_append_slg_to_litellm_params(data, list(records))
_sync_guardrail_info_to_logging_obj(request_data, litellm_logging_obj)
async def _emit_guardrail_success_logs(
response_handler: StandardGuardrailResponseHandler,
proxy_logging_obj: _GuardrailProxyLogging,
@ -2586,7 +2605,11 @@ async def apply_guardrail(
proxy_logging_obj,
version,
)
from litellm.proxy.utils import handle_exception_on_proxy
from litellm.proxy.utils import (
GUARDRAIL_ENDPOINT_FAILURE,
GUARDRAIL_ENDPOINT_FAILURE_KEY,
handle_exception_on_proxy,
)
data: dict[str, object] = {
"guardrail_name": request.guardrail_name,
@ -2631,14 +2654,18 @@ async def apply_guardrail(
response_handler: Final = GUARDRAIL_RESPONSE_HANDLERS[request.response_format]
request_data: Final = dict(response_handler.prepare_request_data(request))
input_type: Final = response_handler.resolve_input_type(request, active_guardrail)
guardrailed_inputs: Final = await active_guardrail.apply_guardrail(
inputs={"texts": [request.text]},
request_data=request_data,
input_type=input_type,
)
try:
guardrailed_inputs: Final = await active_guardrail.apply_guardrail(
inputs={"texts": [request.text]},
request_data=request_data,
input_type=input_type,
)
finally:
_record_verdict_for_logging(request_data, data, litellm_logging_obj)
response: Final = response_handler.build_response(request, guardrailed_inputs, request_data)
except Exception as e:
if litellm_logging_obj is not None and not isinstance(e, HTTPException):
if litellm_logging_obj is not None:
data[GUARDRAIL_ENDPOINT_FAILURE_KEY] = GUARDRAIL_ENDPOINT_FAILURE
try:
await litellm_logging_obj.async_failure_handler(
exception=e,

View file

@ -1385,7 +1385,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response=logged_json_response,
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status=self._get_bedrock_guardrail_response_status(response=httpx_response),
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -1415,7 +1415,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response=dict(merged_response),
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status=(
"guardrail_failed_to_respond"
if "Exception" in str((merged_response.get("Output") or {}).get("__type", ""))
@ -1453,7 +1453,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response=json_response,
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status="guardrail_failed_to_respond",
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -1866,7 +1866,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response={"error": detail_message},
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status="guardrail_failed_to_respond",
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -1881,7 +1881,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response={"error": str(e)},
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status="guardrail_failed_to_respond",
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -2009,7 +2009,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response={"error": detail_message},
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status="guardrail_failed_to_respond",
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -2025,7 +2025,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response={"error": str(e)},
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status="guardrail_failed_to_respond",
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),
@ -2043,7 +2043,7 @@ class BedrockGuardrail(CustomGuardrail, BaseAWSLLM):
self.add_standard_logging_guardrail_information_to_request_data(
guardrail_provider=self.guardrail_provider,
guardrail_json_response=self._sanitize_invoke_checks_response_for_logging(json_response),
request_data=request_data or {},
request_data=request_data if request_data is not None else {},
guardrail_status=self._get_invoke_checks_status(bool(violations)),
start_time=start_time.timestamp(),
end_time=datetime.now(timezone.utc).timestamp(),

View file

@ -341,7 +341,7 @@ class GraySwanGuardrail(CustomGuardrail):
status_code: Final = getattr(exc, "status_code", None) or getattr(exc, "exception_status_code", None)
self._log_guardrail_failure(
exc=exc,
request_data=request_data or {},
request_data=request_data,
start_time=start_time,
end_time=end_time,
status_code=status_code,

View file

@ -1831,7 +1831,7 @@ class _OPTIONAL_PresidioPIIMasking(CustomGuardrail):
text=text,
output_parse_pii=self.output_parse_pii,
presidio_config=None,
request_data=request_data or {},
request_data=request_data,
)
new_texts.append(modified_text)
inputs["texts"] = new_texts

View file

@ -27,7 +27,11 @@ class StandardGuardrailResponseHandler:
"""Preserve the endpoint's existing text response and hook behavior."""
def prepare_request_data(self, request: ApplyGuardrailRequest) -> Mapping[str, object]:
return request.model_dump(include={"messages", "metadata"}, exclude_none=True)
return request.model_dump(
include={"messages", "metadata"},
exclude={"metadata": {"standard_logging_guardrail_information"}},
exclude_none=True,
)
def resolve_input_type(
self, request: ApplyGuardrailRequest, guardrail: CustomGuardrail
@ -65,13 +69,6 @@ class _NativeGuardrailMetadata(BaseModel):
class NativeGuardrailResponseHandler(StandardGuardrailResponseHandler):
"""Return structured findings recorded by this guardrail invocation."""
def prepare_request_data(self, request: ApplyGuardrailRequest) -> Mapping[str, object]:
return request.model_dump(
include={"messages", "metadata"},
exclude={"metadata": {"standard_logging_guardrail_information"}},
exclude_none=True,
)
def resolve_input_type(
self, request: ApplyGuardrailRequest, guardrail: CustomGuardrail
) -> Literal["request", "response"]:

View file

@ -72,6 +72,8 @@ from litellm.proxy.spend_tracking.spend_tracking_utils import ( # noqa: F401 #
should_store_prompts_for_call,
)
from litellm.proxy.utils import (
GUARDRAIL_ENDPOINT_FAILURE,
GUARDRAIL_ENDPOINT_FAILURE_KEY,
REJECTED_BEFORE_REQUEST_SETUP,
REJECTED_BEFORE_REQUEST_SETUP_KEY,
BilledFailedAttempt,
@ -493,6 +495,7 @@ class _ProxyDBLogger(CustomLogger):
return
request_route: Final = user_api_key_dict.request_route
request_fields: Final = _str_keyed_fields(request_data)
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import InitPassThroughEndpointHelpers
route_is_trackable: Final = (
@ -500,6 +503,7 @@ class _ProxyDBLogger(CustomLogger):
or RouteChecks.runs_inference_checks(request_route)
or RouteChecks.is_info_route(route=request_route)
or InitPassThroughEndpointHelpers.has_configured_route_ignoring_trailing_slash(route=request_route)
or request_fields.get(GUARDRAIL_ENDPOINT_FAILURE_KEY) is GUARDRAIL_ENDPOINT_FAILURE
)
if (
ProxyDBLogger._should_track_errors_in_db() is False
@ -537,7 +541,6 @@ class _ProxyDBLogger(CustomLogger):
)
)
request_fields: Final = _str_keyed_fields(request_data)
_metadata["used_client_oauth_token"] = _proxy_stamped_used_client_oauth_token(request_fields, request_route)
existing_metadata: Final[dict] = request_data.get("metadata", None) or {}

View file

@ -334,7 +334,7 @@ async def test_policies_and_guardrails(
item_result = await apply_policies(
policy_names=data.policy_names,
inputs=inp,
request_data=data.request_data,
request_data=copy.deepcopy(data.request_data),
input_type=data.input_type,
proxy_logging_obj=logging_obj,
guardrail_names=data.guardrail_names,

View file

@ -72,6 +72,7 @@ from litellm.litellm_core_utils.litellm_logging import (
)
from litellm.litellm_core_utils.prompt_templates.mid_conversation_system import message_field, parts_of
from litellm.litellm_core_utils.ptu_pricing import azure_spillover
from litellm.litellm_core_utils.redact_messages import numeric_compression_stats
from litellm.litellm_core_utils.safe_json_dumps import safe_dumps, strip_null_bytes
from litellm.litellm_core_utils.secret_redaction import redact_tokens
from litellm.litellm_core_utils.sensitive_data_masker import SensitiveDataMasker
@ -1790,27 +1791,6 @@ def _sanitize_guardrail_information_for_spend_logs(
return [_redact_prompt_fields_in_guardrail_entry(entry) for entry in entries if isinstance(entry, dict)]
_NUMERIC_COMPRESSION_STAT_KEYS: Final = (
"tokens_before",
"tokens_after",
"tokens_saved",
"compression_ratio",
)
def _numeric_compression_stats_from_guardrail_response(
guardrail_response: object,
) -> dict[str, int | float] | None:
if not isinstance(guardrail_response, dict):
return None
stats: Final = {
key: value
for key, value in guardrail_response.items()
if key in _NUMERIC_COMPRESSION_STAT_KEYS and isinstance(value, (int, float)) and not isinstance(value, bool)
}
return stats or None
def _redact_prompt_fields_in_guardrail_entry(
entry: StandardLoggingGuardrailInformation,
) -> StandardLoggingGuardrailInformation:
@ -1821,7 +1801,7 @@ def _redact_prompt_fields_in_guardrail_entry(
stats-only dict; spend aggregation reads them via
``extract_compression_saved_tokens``.
"""
preserved_stats: Final = _numeric_compression_stats_from_guardrail_response(entry.get("guardrail_response"))
preserved_stats: Final = numeric_compression_stats(entry)
redacted: Final[StandardLoggingGuardrailInformation] = {
**entry,
**{key: REDACTED_BY_LITELM_STRING for key in PROMPT_CARRYING_GUARDRAIL_FIELDS if key in entry},

View file

@ -1833,6 +1833,11 @@ object, meaning the request died (auth, body parsing, model resolution) before t
object rather than ``True`` because ``request_data`` is the client body: JSON cannot forge this identity, so a
client can neither hide a guardrail block nor force a row by sending the key or a ``litellm_call_id`` itself."""
GUARDRAIL_ENDPOINT_FAILURE_KEY: Final = "litellm_guardrail_endpoint_failure"
GUARDRAIL_ENDPOINT_FAILURE: Final = object()
"""Stored under ``GUARDRAIL_ENDPOINT_FAILURE_KEY`` by ``/apply_guardrail`` when a request it had set up fails, so the
spend logs keep that failure although the route is not an LLM API route. A sentinel for the same reason as above."""
_PROXY_ONLY_LLM_API_ERRORS: Final = (HTTPException, ProxyException, GuardrailRaisedException)
_PROXY_ONLY_ERROR_LOGGED_FIELDS: Final = frozenset(
{"model", "messages", "input", "prompt", "user", "stream", "litellm_call_id"}

View file

@ -2086,6 +2086,59 @@ class TestGuardrailInterventionClassification:
slg = request_data["metadata"]["standard_logging_guardrail_information"][0]
assert slg["guardrail_status"] == "guardrail_intervened"
@pytest.mark.asyncio
async def test_block_is_recorded_on_a_request_dict_that_starts_empty(self) -> None:
from fastapi.exceptions import HTTPException
from litellm.integrations.custom_guardrail import log_guardrail_information
class BlockingGuardrail(CustomGuardrail):
@log_guardrail_information
async def apply_guardrail(
self,
inputs: GenericGuardrailAPIInputs,
request_data: dict,
input_type: Literal["request", "response"],
logging_obj: Optional["LiteLLMLoggingObj"] = None,
) -> GenericGuardrailAPIInputs:
raise HTTPException(status_code=400, detail="blocked by guardrail")
request_data: dict = {}
with pytest.raises(HTTPException):
await BlockingGuardrail(guardrail_name="block-rail").apply_guardrail(
inputs={"texts": ["hello"]}, request_data=request_data, input_type="request"
)
recorded = request_data["metadata"]["standard_logging_guardrail_information"]
assert [record["guardrail_status"] for record in recorded] == ["guardrail_intervened"]
def test_sync_block_is_recorded_on_a_request_dict_that_starts_empty(self) -> None:
from fastapi.exceptions import HTTPException
from litellm.integrations.custom_guardrail import log_guardrail_information
class SyncBlockingGuardrail(CustomGuardrail):
@log_guardrail_information
def apply_guardrail(
self,
inputs: GenericGuardrailAPIInputs,
request_data: dict,
input_type: Literal["request", "response"],
logging_obj: Optional["LiteLLMLoggingObj"] = None,
) -> GenericGuardrailAPIInputs:
raise HTTPException(status_code=400, detail="blocked by guardrail")
request_data: Final[dict[str, object]] = {}
with pytest.raises(HTTPException):
SyncBlockingGuardrail(guardrail_name="block-rail").apply_guardrail(
inputs={"texts": ["hello"]}, request_data=request_data, input_type="request"
)
recorded: Final = request_data["metadata"]["standard_logging_guardrail_information"]
assert [record["guardrail_status"] for record in recorded] == ["guardrail_intervened"]
class _ApplyStyleGuardrail(CustomGuardrail):
"""Overrides only apply_guardrail, like openai_moderation; async_pre_call_hook stays the CustomLogger no-op."""

View file

@ -37,6 +37,7 @@ from litellm.litellm_core_utils.redact_messages import (
should_redact_message_logging,
)
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler, HTTPHandler
from litellm.proxy.spend_tracking.compression_savings import extract_compression_saved_tokens
from litellm.responses.main import mock_responses_api_response
from litellm.types.responses.main import build_web_search_call
from litellm.types.router import BaselineRouteStamp
@ -2434,3 +2435,63 @@ def test_perform_redaction_strips_the_matched_text_from_the_bedrock_guardrail_tr
assert "US_SSN" in redacted.model_dump_json(), "the finding stays, only its matched text goes"
assert "123-45-6789" not in str(redacted_dict)
assert "123-45-6789" in response.model_dump_json(), "the caller's own response is not redacted"
_GUARDRAIL_RECORD: Final = MappingProxyType(
{
"guardrail_name": "bedrock-guard",
"guardrail_status": "guardrail_intervened",
"guardrail_request": {"texts": ["my card is 4111 1111 1111 1111"]},
"guardrail_response": {"outputs": [{"text": "my card is 4111 1111 1111 1111"}]},
"match_details": [{"snippet": "4111 1111 1111 1111"}],
"classification": {"reason": "card 4111 1111 1111 1111"},
"guardrail_cost": 0.00075,
"duration": 0.4,
}
)
@pytest.mark.parametrize(
"guardrail_information",
[[dict(_GUARDRAIL_RECORD)], dict(_GUARDRAIL_RECORD)],
ids=["list", "bare_record"],
)
def test_redaction_keeps_the_guardrail_verdict_and_drops_the_prompt_it_quotes(
guardrail_information: object,
) -> None:
payload: Final = {"messages": [{"role": "user", "content": "x"}], "guardrail_information": guardrail_information}
redacted: Final = redacted_standard_logging_payload(payload)["guardrail_information"]
records: Final = redacted if isinstance(redacted, list) else [redacted]
assert "4111" not in str(records)
assert [
(record["guardrail_name"], record["guardrail_status"], record["guardrail_cost"], record["duration"])
for record in records
] == [("bedrock-guard", "guardrail_intervened", 0.00075, 0.4)]
assert "4111" in str(payload["guardrail_information"]), "the caller's payload is not redacted in place"
def test_redaction_keeps_the_compression_savings_a_guardrail_reports() -> None:
payload: Final = {
"messages": [{"role": "user", "content": "x"}],
"guardrail_information": [
{
"guardrail_name": "headroom",
"guardrail_provider": "headroom",
"guardrail_status": "success",
"guardrail_response": {
"tokens_before": 1000,
"tokens_after": 400,
"tokens_saved": 600,
"compression_ratio": 0.4,
"compressed_text": "my card is 4111 1111 1111 1111",
},
}
],
}
redacted: Final = redacted_standard_logging_payload(payload)
assert "4111" not in str(redacted["guardrail_information"])
assert extract_compression_saved_tokens(redacted) == extract_compression_saved_tokens(payload) == 600

View file

@ -2,9 +2,11 @@
Unit tests for Bedrock Guardrails
"""
import contextlib
import json
import asyncio
import logging
from collections.abc import Callable, Mapping
from typing import Final
from datetime import datetime, timezone
import sys
@ -20,6 +22,7 @@ import litellm
from litellm._logging import verbose_proxy_logger
from litellm.caching.caching import DualCache
from litellm.exceptions import ModifyResponseException
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
from litellm.proxy._types import UserAPIKeyAuth
from litellm.constants import BEDROCK_APPLY_GUARDRAIL_CHUNK_BUDGET_CHARS
from litellm.proxy.guardrails.guardrail_hooks.bedrock_guardrails import (
@ -8168,3 +8171,94 @@ async def test_guardrail_secret_lookups_leave_the_event_loop_free(
assert vault.read.is_set()
assert not vault.read_on_loop.is_set()
assert upstream.calls.last.request.url.host == "bedrock-runtime.us-west-2.amazonaws.com"
_APPLY_GUARDRAIL_API: Final = {"guardrailIdentifier": "gr-1", "guardrailVersion": "1"}
_GUARDRAIL_CHECKS_API: Final = {
"checks": {"contentFilter": {"categories": [{"category": "VIOLENCE"}]}},
"content_filter_threshold": 0.5,
}
_APPLY_GUARDRAIL_BLOCKED: Final = {
"action": "GUARDRAIL_INTERVENED",
"outputs": [{"text": "blocked"}],
"assessments": [{"contentPolicy": {"filters": [{"type": "VIOLENCE", "confidence": "HIGH", "action": "BLOCKED"}]}}],
}
def _answering(status_code: int, body: object) -> Callable[[httpx.Request], httpx.Response]:
return lambda request: httpx.Response(status_code, json=body)
def _violence_scored(severity: float) -> Callable[[httpx.Request], httpx.Response]:
return _answering(
200, {"results": {"contentFilter": {"results": [{"category": "VIOLENCE", "severityScore": severity}]}}}
)
def _unreachable(request: httpx.Request) -> httpx.Response:
raise httpx.ConnectError("connection refused", request=request)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("guardrail_config", "bedrock", "recorded_status"),
[
pytest.param(
_APPLY_GUARDRAIL_API,
_answering(200, {"action": "NONE", "outputs": [], "assessments": []}),
"success",
id="apply_guardrail-allowed",
),
pytest.param(
_APPLY_GUARDRAIL_API,
_answering(200, _APPLY_GUARDRAIL_BLOCKED),
"guardrail_intervened",
id="apply_guardrail-blocked",
),
pytest.param(
_APPLY_GUARDRAIL_API,
_answering(500, {"message": "internal failure"}),
"guardrail_failed_to_respond",
id="apply_guardrail-error",
),
pytest.param(
_APPLY_GUARDRAIL_API, _unreachable, "guardrail_failed_to_respond", id="apply_guardrail-unreachable"
),
pytest.param(_GUARDRAIL_CHECKS_API, _violence_scored(0.1), "success", id="guardrail_checks-allowed"),
pytest.param(
_GUARDRAIL_CHECKS_API, _violence_scored(0.9), "guardrail_intervened", id="guardrail_checks-blocked"
),
pytest.param(
_GUARDRAIL_CHECKS_API,
_answering(500, {"message": "internal failure"}),
"guardrail_failed_to_respond",
id="guardrail_checks-error",
),
pytest.param(
_GUARDRAIL_CHECKS_API,
_answering(200, ["unexpected"]),
"guardrail_failed_to_respond",
id="guardrail_checks-unparseable",
),
],
)
async def test_verdict_is_recorded_on_a_request_dict_that_starts_empty(
guardrail_config: Mapping[str, object],
bedrock: Callable[[httpx.Request], httpx.Response],
recorded_status: str,
) -> None:
guardrail: Final = BedrockGuardrail(
guardrail_name="bedrock-guard",
aws_region_name="us-east-1",
aws_access_key_id="test-access-key",
aws_secret_access_key="test-secret-key",
async_handler=AsyncHTTPHandler(transport=httpx.MockTransport(bedrock)),
**guardrail_config,
)
request_data: Final[dict[str, object]] = {}
with contextlib.suppress(Exception):
await guardrail.apply_guardrail(inputs={"texts": ["hello"]}, request_data=request_data, input_type="request")
recorded: Final = request_data["metadata"]["standard_logging_guardrail_information"]
assert [record["guardrail_status"] for record in recorded] == [recorded_status]

View file

@ -1,10 +1,14 @@
import contextlib
from collections.abc import Mapping
from types import MappingProxyType
from typing import Final
import httpx
import pytest
from fastapi import HTTPException
from litellm.integrations.custom_guardrail import ModifyResponseException
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
from litellm.llms.openai.completion.guardrail_translation.handler import OpenAITextCompletionHandler
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.guardrails.guardrail_hooks.grayswan import grayswan as grayswan_module
@ -912,3 +916,25 @@ async def test_post_call_never_forwards_the_proxy_key_metadata_of_the_request_me
)
assert "litellm_metadata" not in client.calls[0]["json"]
@pytest.mark.asyncio
@pytest.mark.parametrize("fail_open", [True, False])
async def test_unreachable_api_failure_is_recorded_on_a_request_dict_that_starts_empty(fail_open: bool) -> None:
def refuse_connection(request: httpx.Request) -> httpx.Response:
raise httpx.ConnectError("connection refused", request=request)
guardrail: Final = GraySwanGuardrail(
guardrail_name="grayswan-unreachable",
api_key="test-key",
fail_open=fail_open,
event_hook=GuardrailEventHooks.pre_call,
)
guardrail.async_handler = AsyncHTTPHandler(transport=httpx.MockTransport(refuse_connection))
request_data: Final[dict[str, object]] = {}
with contextlib.suppress(Exception):
await guardrail.apply_guardrail(inputs={"texts": ["hello"]}, request_data=request_data, input_type="request")
recorded: Final = request_data["metadata"]["standard_logging_guardrail_information"]
assert [record["guardrail_status"] for record in recorded] == ["guardrail_failed_to_respond"]

View file

@ -5480,3 +5480,18 @@ def test_get_session_iterator_reuses_one_session_per_background_loop(
assert len(sessions) == 10
assert all(session is sessions[0] for session in sessions)
assert presidio_guardrail._http_session is None
@pytest.mark.asyncio
async def test_apply_guardrail_records_its_verdict_on_a_request_dict_that_starts_empty() -> None:
guardrail: Final = OPTIONAL_PresidioPIIMasking(
guardrail_name="presidio-pii",
mock_testing=True,
mock_redacted_text={"text": "my name is <PERSON>"},
)
request_data: Final[dict[str, object]] = {}
await guardrail.apply_guardrail(inputs={"texts": ["my name is Jane"]}, request_data=request_data, input_type="request")
recorded: Final = request_data["metadata"]["standard_logging_guardrail_information"]
assert [record["guardrail_name"] for record in recorded] == ["presidio-pii"]

View file

@ -1,10 +1,11 @@
import json
import time
from collections.abc import Awaitable, Callable, Mapping, Sequence
from datetime import datetime
from functools import partial
from datetime import datetime, timezone
from types import MappingProxyType
from typing import Final, List, Literal, Optional
from unittest.mock import AsyncMock, Mock
from typing import Dict, Final, List, Literal, NamedTuple, Optional
from unittest.mock import AsyncMock, Mock, create_autospec
import httpx
import pytest
@ -13,9 +14,14 @@ from fastapi import FastAPI, HTTPException
from pydantic import JsonValue
from pytest_mock import MockerFixture
import litellm
from litellm.caching.dual_cache import DualCache
from litellm.integrations.custom_guardrail import CustomGuardrail
from litellm.integrations.custom_logger import CustomLogger
from litellm.litellm_core_utils.litellm_logging import Logging
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
from litellm.proxy._types import LitellmUserRoles, ProxyException, UserAPIKeyAuth
from litellm.proxy.db.db_spend_update_writer import DBSpendUpdateWriter
from litellm.proxy.guardrails.content_filter_data import DATA_ROOTS
from litellm.proxy.guardrails.guardrail_endpoints import (
CreateGuardrailRequest,
@ -44,7 +50,9 @@ from litellm.proxy.guardrails.guardrail_endpoints import (
test_custom_code_guardrail as run_custom_code_test_endpoint,
)
from litellm.proxy.guardrails.guardrail_hooks.azure.prompt_shield import AzureContentSafetyPromptShieldGuardrail
from litellm.proxy.guardrails.guardrail_hooks.bedrock_guardrails import BedrockGuardrail
from litellm.proxy.guardrails.guardrail_hooks.litellm_content_filter.content_filter import ContentFilterGuardrail
from litellm.proxy.hooks.proxy_track_cost_callback import ProxyDBLogger
MOCK_ADMIN_USER = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN)
from litellm.proxy.guardrails.guardrail_registry import (
@ -4204,3 +4212,237 @@ async def test_guardrail_success_delivers_sync_callback_once_with_overlapping_wo
assert returned is response
callback.assert_called_once()
assert callback.call_args.args[0] == {"response": {"response_text": "masked"}}
_GUARDRAIL_RECORDS: Final = "standard_logging_guardrail_information"
_BEDROCK_TEXT_ALLOWED: Final = {"action": "NONE", "outputs": [], "assessments": []}
_BEDROCK_BLOCKED: Final = {
"action": "GUARDRAIL_INTERVENED",
"outputs": [{"text": "blocked"}],
"assessments": [{"contentPolicy": {"filters": [{"type": "VIOLENCE", "confidence": "HIGH", "action": "BLOCKED"}]}}],
}
class _BedrockGuardrailCall(NamedTuple):
response: httpx.Response
bedrock_payloads: Sequence[Mapping[str, object]]
logged: Mapping[str, object]
failure_hook_request: Mapping[str, object]
spend_rows: Sequence[Mapping[str, object]]
class _CapturingLogger(CustomLogger):
def __init__(self, message_logging: bool = True, legacy_message_logging: bool = True) -> None:
super().__init__(turn_off_message_logging=not message_logging, message_logging=legacy_message_logging)
self.logged: Final[list[Mapping[str, object]]] = []
self.failure_hook_requests: Final[list[Mapping[str, object]]] = []
async def async_log_success_event(
self, kwargs: dict[str, object], response_obj: object, start_time: datetime, end_time: datetime
) -> None:
self.logged.append(kwargs["standard_logging_object"])
async def async_log_failure_event(
self, kwargs: dict[str, object], response_obj: object, start_time: datetime, end_time: datetime
) -> None:
self.logged.append(kwargs["standard_logging_object"])
async def async_post_call_failure_hook(
self,
request_data: dict,
original_exception: Exception,
user_api_key_dict: UserAPIKeyAuth,
traceback_str: str | None = None,
) -> None:
self.failure_hook_requests.append(request_data)
def _bedrock_guard(handler: AsyncHTTPHandler, latest_user_message_only: bool = False) -> CustomGuardrail:
return BedrockGuardrail(
guardrail_name="bedrock-guard",
guardrailIdentifier="gr-1",
guardrailVersion="1",
aws_region_name="us-east-1",
aws_access_key_id="test-access-key",
aws_secret_access_key="test-secret-key",
async_handler=handler,
experimental_use_latest_role_message_only=latest_user_message_only,
event_hook=GuardrailEventHooks.pre_call,
)
async def _apply_bedrock_guardrail_over_http(
mocker: MockerFixture,
bedrock_answers: Sequence[Mapping[str, object]],
body: Mapping[str, object],
guardrail: Callable[[AsyncHTTPHandler], CustomGuardrail] = _bedrock_guard,
capture_logger: Callable[[], _CapturingLogger] = _CapturingLogger,
headers: Mapping[str, str] = MappingProxyType({}),
other_loggers: Sequence[CustomLogger] = (),
) -> _BedrockGuardrailCall:
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.guardrails.guardrail_endpoints import router
from litellm.proxy.proxy_server import ProxyConfig, openai_exception_handler
from litellm.proxy.utils import ProxyLogging
sent: Final[list[httpx.Request]] = []
def bedrock(request: httpx.Request) -> httpx.Response:
sent.append(request)
return httpx.Response(200, json=bedrock_answers[len(sent) - 1])
capture: Final = capture_logger()
spend_writer: Final = create_autospec(DBSpendUpdateWriter, instance=True)
mocker.patch.object(
litellm,
"callbacks",
[
guardrail(AsyncHTTPHandler(transport=httpx.MockTransport(bedrock))),
*other_loggers,
capture,
ProxyDBLogger(spend_writer=lambda: spend_writer),
],
)
mocker.patch.object(litellm, "_async_success_callback", [])
mocker.patch.object(litellm, "_async_failure_callback", [])
mocker.patch.object(litellm, "success_callback", [])
mocker.patch.object(litellm, "failure_callback", [])
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", ProxyLogging(user_api_key_cache=DualCache()))
mocker.patch("litellm.proxy.proxy_server.general_settings", {})
mocker.patch("litellm.proxy.proxy_server.proxy_config", ProxyConfig())
mocker.patch("litellm.litellm_core_utils.thread_pool_executor.executor")
app: Final = FastAPI()
app.include_router(router)
app.add_exception_handler(ProxyException, openai_exception_handler)
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
api_key="test_api_key", request_route="/guardrails/apply_guardrail"
)
async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://guardrails.test") as client:
response: Final = await client.post(
"/guardrails/apply_guardrail", json={"guardrail_name": "bedrock-guard", **body}, headers=dict(headers)
)
assert len(capture.logged) == 1
return _BedrockGuardrailCall(
response=response,
bedrock_payloads=tuple(json.loads(request.content) for request in sent),
logged=capture.logged[0],
failure_hook_request=capture.failure_hook_requests[0] if capture.failure_hook_requests else {},
spend_rows=tuple(call.kwargs for call in spend_writer.update_database.await_args_list),
)
def _logged_verdicts(call: _BedrockGuardrailCall) -> list[tuple[object, object]]:
return [(record["guardrail_name"], record["guardrail_status"]) for record in call.logged["guardrail_information"]]
@pytest.mark.asyncio
async def test_apply_guardrail_logs_a_blocked_request_with_the_guardrail_verdict(mocker: MockerFixture) -> None:
call: Final = await _apply_bedrock_guardrail_over_http(mocker, (_BEDROCK_BLOCKED,), {"text": "hello"})
assert call.response.status_code == 400
assert call.logged["status"] == "failure"
assert _logged_verdicts(call) == [("bedrock-guard", "guardrail_intervened")]
assert [record["guardrail_status"] for record in call.failure_hook_request["metadata"][_GUARDRAIL_RECORDS]] == [
"guardrail_intervened"
]
assert [row["kwargs"]["litellm_params"]["metadata"]["status"] for row in call.spend_rows] == ["failure"]
assert [
record["guardrail_status"]
for record in call.spend_rows[0]["kwargs"]["litellm_params"]["metadata"][_GUARDRAIL_RECORDS]
] == ["guardrail_intervened"]
@pytest.mark.asyncio
async def test_apply_guardrail_logs_an_allowed_request_with_the_guardrail_verdict(mocker: MockerFixture) -> None:
call: Final = await _apply_bedrock_guardrail_over_http(mocker, (_BEDROCK_TEXT_ALLOWED,), {"text": "hello"})
assert call.response.status_code == 200
assert call.logged["status"] == "success"
assert _logged_verdicts(call) == [("bedrock-guard", "success")]
@pytest.mark.asyncio
async def test_apply_guardrail_never_logs_a_verdict_the_caller_supplied(mocker: MockerFixture) -> None:
forged: Final = {"guardrail_name": "forged", "guardrail_status": "success"}
call: Final = await _apply_bedrock_guardrail_over_http(
mocker, (_BEDROCK_TEXT_ALLOWED,), {"text": "hello", "metadata": {_GUARDRAIL_RECORDS: [forged]}}
)
assert _logged_verdicts(call) == [("bedrock-guard", "success")]
@pytest.mark.asyncio
@pytest.mark.parametrize("bedrock_action", ["ANONYMIZED", "BLOCKED"])
@pytest.mark.parametrize(
("capture_logger", "headers"),
[
pytest.param(
partial(_CapturingLogger, message_logging=False),
MappingProxyType({}),
id="callback-turns-off-message-logging",
),
pytest.param(
partial(_CapturingLogger, legacy_message_logging=False),
MappingProxyType({}),
id="callback-sets-message-logging-false",
),
pytest.param(_CapturingLogger, MappingProxyType({"litellm-enable-message-redaction": "true"}), id="request-header"),
],
)
async def test_apply_guardrail_keeps_the_prompt_out_of_the_verdict_a_redacting_callback_receives(
mocker: MockerFixture, bedrock_action: str, capture_logger: Callable[[], _CapturingLogger], headers: Mapping[str, str]
) -> None:
answer: Final = {
"action": "GUARDRAIL_INTERVENED",
"outputs": [{"text": "please bill my card {CREDIT_DEBIT_CARD_NUMBER}"}],
"assessments": [
{
"sensitiveInformationPolicy": {
"piiEntities": [
{"type": "CREDIT_DEBIT_CARD_NUMBER", "match": "4111111111111111", "action": bedrock_action}
]
}
}
],
}
call: Final = await _apply_bedrock_guardrail_over_http(
mocker,
(answer,),
{"text": "please bill my card 4111111111111111"},
capture_logger=capture_logger,
headers=headers,
)
assert [name for name, _ in _logged_verdicts(call)] == ["bedrock-guard"]
redacted_fields: Final = str({field: call.logged[field] for field in ("messages", "response", "guardrail_information")})
assert "please bill my card" not in redacted_fields
assert "4111111111111111" not in redacted_fields
@pytest.mark.asyncio
async def test_one_callback_opting_out_of_message_logging_leaves_the_guardrail_details_to_the_others(
mocker: MockerFixture,
) -> None:
answer: Final = {
"action": "GUARDRAIL_INTERVENED",
"outputs": [{"text": "please bill my card {CREDIT_DEBIT_CARD_NUMBER}"}],
"assessments": [
{
"sensitiveInformationPolicy": {
"piiEntities": [{"type": "CREDIT_DEBIT_CARD_NUMBER", "match": "4111111111111111", "action": "ANONYMIZED"}]
}
}
],
}
opted_out: Final = _CapturingLogger(legacy_message_logging=False)
call: Final = await _apply_bedrock_guardrail_over_http(
mocker, (answer,), {"text": "please bill my card 4111111111111111"}, other_loggers=(opted_out,)
)
assert "please bill my card" in str(call.logged["guardrail_information"])
assert [record["guardrail_name"] for record in opted_out.logged[0]["guardrail_information"]] == ["bedrock-guard"]
assert "please bill my card" not in str(opted_out.logged[0]["guardrail_information"])

View file

@ -43,6 +43,8 @@ from litellm.proxy.spend_tracking.spend_event import SpendEventDecodeError, buil
from litellm.proxy.spend_tracking.spend_event_producer import SpendEventProducer, UnixAddress
from litellm.proxy.spend_tracking.spend_tracking_utils import get_logging_payload
from litellm.proxy.utils import (
GUARDRAIL_ENDPOINT_FAILURE,
GUARDRAIL_ENDPOINT_FAILURE_KEY,
REJECTED_BEFORE_REQUEST_SETUP,
REJECTED_BEFORE_REQUEST_SETUP_KEY,
BilledFailedAttempt,
@ -984,6 +986,46 @@ async def test_async_post_call_failure_hook_tracks_config_defined_pass_through_r
assert call_args.kwargs["kwargs"]["litellm_params"]["metadata"]["status"] == "failure"
@pytest.mark.asyncio
@pytest.mark.parametrize("route", ["/guardrails/apply_guardrail", "/apply_guardrail"])
async def test_async_post_call_failure_hook_logs_a_failure_the_guardrail_endpoint_marked(route: str) -> None:
verdict: Final = [
{"guardrail_name": "bedrock-guard", "guardrail_status": "guardrail_intervened", "guardrail_cost": 0.00075}
]
spend_writer: Final = create_autospec(DBSpendUpdateWriter, instance=True)
await ProxyDBLogger(spend_writer=lambda: spend_writer).async_post_call_failure_hook(
request_data={
"metadata": {"standard_logging_guardrail_information": verdict},
GUARDRAIL_ENDPOINT_FAILURE_KEY: GUARDRAIL_ENDPOINT_FAILURE,
},
original_exception=HTTPException(status_code=400, detail="Violated guardrail policy"),
user_api_key_dict=UserAPIKeyAuth(api_key="test_api_key", request_route=route),
)
assert spend_writer.update_database.await_count == 1
written: Final = spend_writer.update_database.call_args.kwargs
assert written["response_cost"] == 0.00075
assert written["kwargs"]["litellm_params"]["metadata"]["status"] == "failure"
assert written["kwargs"]["litellm_params"]["metadata"]["standard_logging_guardrail_information"] == verdict
@pytest.mark.asyncio
@pytest.mark.parametrize("marker", [None, True, "litellm_guardrail_endpoint_failure"])
async def test_async_post_call_failure_hook_skips_a_guardrail_endpoint_failure_the_endpoint_did_not_mark( # test-quality-ok: update_database is the DB write boundary, so whether it is awaited is the observable outcome
marker: object,
) -> None:
spend_writer: Final = create_autospec(DBSpendUpdateWriter, instance=True)
await ProxyDBLogger(spend_writer=lambda: spend_writer).async_post_call_failure_hook(
request_data={"guardrail_name": "bedrock-guard", "text": "hello", GUARDRAIL_ENDPOINT_FAILURE_KEY: marker},
original_exception=HTTPException(status_code=401, detail="Authentication Error"),
user_api_key_dict=UserAPIKeyAuth(api_key="test_api_key", request_route="/apply_guardrail"),
)
assert spend_writer.update_database.await_count == 0
@pytest.mark.asyncio
@pytest.mark.parametrize(
("team_id", "route", "written"),

View file

@ -4,11 +4,15 @@ Unit tests for policy management endpoints.
Tests apply_policies: resolving guardrails from policy names and applying them to inputs.
"""
from typing import Final, Literal
from unittest.mock import MagicMock, patch
import pytest
from starlette.requests import Request
import litellm
from litellm.integrations.custom_guardrail import CustomGuardrail
from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
from litellm.proxy.management_endpoints.policy_endpoints import apply_policies
from litellm.types.utils import GenericGuardrailAPIInputs
@ -644,6 +648,44 @@ class TestApplyPoliciesDirectGuardrailNames:
assert result["guardrail_errors"] == []
class _VerdictCountingGuardrail(CustomGuardrail):
verdicts_seen: tuple[int, ...] = ()
async def apply_guardrail(
self,
inputs: GenericGuardrailAPIInputs,
request_data: dict[str, object],
input_type: Literal["request", "response"],
logging_obj: LiteLLMLoggingObj | None = None,
) -> GenericGuardrailAPIInputs:
metadata: Final = request_data.get("metadata")
earlier_verdicts: Final = (
metadata.get("standard_logging_guardrail_information", []) if isinstance(metadata, dict) else []
)
self.verdicts_seen = (*self.verdicts_seen, len(earlier_verdicts))
return inputs
@pytest.mark.asyncio
async def test_each_batch_input_is_checked_without_verdicts_from_earlier_inputs() -> None:
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.policy_endpoints import endpoints
guardrail: Final = _VerdictCountingGuardrail(guardrail_name="counting")
litellm.logging_callback_manager.add_litellm_callback(guardrail)
await endpoints.test_policies_and_guardrails(
request=Request(scope={"type": "http", "method": "POST", "path": "/utils/test_policies_and_guardrails"}),
data=endpoints.TestPoliciesAndGuardrailsRequest(
guardrail_names=["counting"],
inputs_list=[{"texts": ["first input"]}, {"texts": ["second input"]}],
),
user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert guardrail.verdicts_seen == (0, 0)
# ---------------------------------------------------------------------------
# Tests for competitor enrichment helper functions
# ---------------------------------------------------------------------------