This commit is contained in:
paveln83 2026-11-01 10:53:49 -08:00 • committed by GitHub
commit faba7ae0c9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 494 additions and 60 deletions

View file

@ -42,10 +42,12 @@ _EMPTY_ROWS: Final[Mapping[DbRow, Mapping[str, JsonValue]]] = MappingProxyType({
class SettingsStore(MutableMapping[str, JsonValue]):
def __init__(self, section: Section) -> None:
def __init__(self, section: Section, *, managed_db_keys: frozenset[str] | None = None) -> None:
self._section: Final = section
self._managed_db_keys: Final = managed_db_keys
self._yaml_values: Mapping[str, JsonValue] = _EMPTY_VALUES
self._database_rows: Mapping[DbRow, Mapping[str, JsonValue]] = _EMPTY_ROWS
self._unmanaged_db_keys: frozenset[str] = frozenset()
self._runtime_values: Mapping[str, JsonValue] = _EMPTY_VALUES
self._deleted_runtime_keys: frozenset[str] = frozenset()
@ -77,15 +79,24 @@ class SettingsStore(MutableMapping[str, JsonValue]):
return self.owned_by_config(key) and self._db_value_is_shadowed(key)
def apply_db_row(self, row: DbRow, db_row: Mapping[str, JsonValue]) -> None:
applied_row: Final = MappingProxyType({key: db_row[key] for key in db_row if self._db_manages(row, key)})
previous_row: Final = self._database_rows.get(row, _EMPTY_VALUES)
changed: Final = frozenset(
key
for key in (*previous_row, *db_row)
if previous_row.get(key, ABSENT) != db_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare
for key in (*previous_row, *applied_row)
if previous_row.get(key, ABSENT) != applied_row.get(key, ABSENT) # pyright: ignore[reportUnknownArgumentType] # JsonValue vs Absent compare
)
self._database_rows = MappingProxyType({**self._database_rows, row: MappingProxyType(dict(db_row))})
self._database_rows = MappingProxyType({**self._database_rows, row: applied_row})
if row == self._section:
self._unmanaged_db_keys = frozenset(key for key in db_row if key not in applied_row)
self._clear_runtime_keys(changed)
def unmanaged_db_keys(self) -> tuple[str, ...]:
return tuple(sorted(self._unmanaged_db_keys))
def _db_manages(self, row: DbRow, key: str) -> bool:
return row != self._section or self._managed_db_keys is None or key in self._managed_db_keys
def resolved(self) -> Mapping[str, JsonValue]:
return MappingProxyType(dict(self))

View file

@ -5656,6 +5656,14 @@ def _reload_settings_store(section: Section, store: SettingsStore, section_confi
store["pass_through_endpoints"] = serving_pass_throughs
def _general_settings_row_is_readable(row: _ConfigParamValueRow | None) -> bool:
return row is None or row.param_value is None or isinstance(row.param_value, Mapping)
def _db_managed_general_settings_keys() -> frozenset[str]:
return frozenset((*ConfigGeneralSettings.model_fields, *_CLEANUP_SCHEDULE_KEYS, "allowed_ips", "email_settings"))
def _bind_general_settings_store(settings: SettingsStore) -> None:
global general_settings
general_settings = settings # pyright: ignore[reportAssignmentType] # legacy global accepts mappings
@ -5806,7 +5814,9 @@ class ProxyConfig:
# whether an existing request predates the prices it just fetched, and re-serving one
# costs a single fetch where skipping one leaves it priced wrong indefinitely
self.model_cost_map_applied_revision: int = 0
self.settings: Final[SettingsStore] = SettingsStore("general_settings")
self.settings: Final[SettingsStore] = SettingsStore(
"general_settings", managed_db_keys=_db_managed_general_settings_keys()
)
self.router_settings: Final[SettingsStore] = SettingsStore("router_settings")
self.litellm_settings: Final[SettingsStore] = SettingsStore("litellm_settings")
self.environment_variables: Final[SettingsStore] = SettingsStore("environment_variables")
@ -5817,6 +5827,8 @@ class ProxyConfig:
self._db_environment_keys: frozenset[str] = frozenset()
self._sso_environment_removals: frozenset[str] = frozenset()
self._warned_shadowed_keys: frozenset[tuple[Section, str]] = frozenset()
self._warned_unmanaged_keys: frozenset[str] = frozenset()
self._warned_unreadable_db_general_settings: bool = False
self._db_config_callback_entries: Mapping[tuple[str, str], _DbCallbackRegistration] = MappingProxyType({})
self._settings_stores: Final[Mapping[Section, SettingsStore]] = MappingProxyType(
{
@ -8340,15 +8352,20 @@ class ProxyConfig:
general_settings.get("maximum_spend_logs_retention_interval", "1d"),
)
async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | None) -> None:
async def _update_general_settings(self, db_general_settings: Mapping[str, SettingsJsonValue] | str | None) -> None:
global general_settings
if db_general_settings is None:
return
if not isinstance(db_general_settings, Mapping):
self._warn_about_unreadable_db_general_settings()
return
self._warned_unreadable_db_general_settings = False
if not isinstance(general_settings, SettingsStore):
self.settings.load_yaml(_as_settings_mapping(general_settings))
cache_size_was_db: Final = self.settings.source("user_api_key_cache_max_size") == "db"
previous_cleanup_schedule: Final = self._resolved_cleanup_schedule()
self.settings.apply_db_row("general_settings", db_general_settings)
self._warn_about_unmanaged_db_settings()
_bind_general_settings_store(self.settings)
await self._apply_general_settings_side_effects(
db_general_settings,
@ -8566,6 +8583,7 @@ class ProxyConfig:
)
self._warn_about_shadowed_db_settings()
self._warn_about_unmanaged_db_settings()
return self._config_with_resolved_settings(config)
async def _apply_db_environment_variables_row(
@ -8624,6 +8642,30 @@ class ProxyConfig:
)
self._warned_shadowed_keys = shadowed
def _warn_about_unmanaged_db_settings(self) -> None:
unmanaged: Final = frozenset(
key for key in self.settings.unmanaged_db_keys() if key not in _GENERAL_SETTINGS_UI_LITELLM_FIELDS
)
for key in sorted(unmanaged - self._warned_unmanaged_keys):
verbose_proxy_logger.warning(
"general_settings.%s is stored in the database, but the proxy does not apply that stored value, so it "
"is ignored. %s",
key,
"The config file's value applies. Remove the stored copy with POST /config/field/delete."
if self.settings.owned_by_config(key)
else "Set it in the config file to use it, or remove it with POST /config/field/delete.",
)
self._warned_unmanaged_keys = unmanaged
def _warn_about_unreadable_db_general_settings(self) -> None:
if self._warned_unreadable_db_general_settings:
return
verbose_proxy_logger.warning(
"general_settings is stored in the database as something other than a JSON object, so the proxy "
"ignores every stored general setting."
)
self._warned_unreadable_db_general_settings = True
def _prepared_db_settings_values(self, section: Section, value: object) -> Mapping[str, SettingsJsonValue]:
scrubbed: Final = _scrub_db_overlay_remote_module_loads(section=section, db_value=value)
return _as_settings_mapping(scrubbed)
@ -8791,7 +8833,10 @@ class ProxyConfig:
)
# initialize vector stores, guardrails, etc. table in db
await self._init_non_llm_objects_in_db(prisma_client=prisma_client)
await self._init_non_llm_objects_in_db(
prisma_client=prisma_client,
refresh_pass_through_endpoints=_general_settings_row_is_readable(db_general_settings),
)
except Exception as e:
verbose_proxy_logger.exception("litellm.proxy.proxy_server.py::ProxyConfig:add_deployment - %s", e)
@ -8860,7 +8905,9 @@ class ProxyConfig:
except Exception as e: # noqa: BLE001 # best-effort: a failing stop must not break proxy shutdown
verbose_proxy_logger.error("Error stopping auth cache invalidation subscriber: %s", e)
async def _init_non_llm_objects_in_db(self, prisma_client: PrismaClient):
async def _init_non_llm_objects_in_db(
self, prisma_client: PrismaClient, *, refresh_pass_through_endpoints: bool = True
):
"""
Use this to read non-llm objects from the db and initialize them
@ -8884,7 +8931,7 @@ class ProxyConfig:
if self._should_load_db_object(object_type="agents"):
await self._init_agents_in_db(prisma_client=prisma_client)
if self._should_load_db_object(object_type="pass_through_endpoints"):
if refresh_pass_through_endpoints and self._should_load_db_object(object_type="pass_through_endpoints"):
await self._init_pass_through_endpoints_in_db()
if self._should_load_db_object(object_type="prompts"):
@ -20792,53 +20839,56 @@ async def delete_config_general_settings(
if data.field_name in _GENERAL_SETTINGS_UI_LITELLM_FIELDS:
return await _reset_general_settings_ui_litellm_field(data.field_name, user_api_key_dict)
if data.field_name not in ConfigGeneralSettings.model_fields:
config_table: Final[TableActions[_ConfigParamValueRow]] = _config_param_table(prisma_client)
stored_row: Final = await config_table.find_first(where={"param_name": "general_settings"})
stored: Final = (
_SETTINGS_MAPPING.validate_python(stored_row.param_value)
if stored_row is not None and isinstance(stored_row.param_value, Mapping)
else None
)
if not _general_settings_row_is_readable(stored_row):
raise HTTPException(
status_code=400,
detail={
"error": "general_settings is stored in the database as something other than a JSON object, so no "
"field can be removed from it"
},
)
if data.field_name not in ConfigGeneralSettings.model_fields and (stored is None or data.field_name not in stored):
raise HTTPException(
status_code=400,
detail={"error": f"Invalid field={data.field_name} passed in."},
)
proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,))
if data.field_name in _db_managed_general_settings_keys():
proxy_config.reject_config_owned_deletes(section_name="general_settings", keys=(data.field_name,))
## get general settings from db
db_general_settings: Final[_ConfigParamRow | None] = await _config_param_table(prisma_client).find_first(
where={"param_name": "general_settings"}
)
### pop the value
if db_general_settings is None or db_general_settings.param_value is None:
if stored is None:
raise HTTPException(
status_code=400,
detail={"error": f"Field name={data.field_name} not in config"},
)
else:
general_settings = dict(db_general_settings.param_value)
before_general_settings: Final = copy.deepcopy(general_settings)
## update db
general_settings.pop(data.field_name, None)
remaining: Final = {key: value for key, value in stored.items() if key != data.field_name}
response: Final = await ConfigRepository(prisma_client).table.upsert(
where={"param_name": "general_settings"},
data={
"create": {
"param_name": "general_settings",
"param_value": json.dumps(general_settings),
"param_value": json.dumps(remaining),
},
"update": {"param_value": json.dumps(general_settings)},
"update": {"param_value": json.dumps(remaining)},
},
)
await invalidate_config_param("general_settings")
proxy_config.settings.apply_db_row("general_settings", general_settings)
proxy_config.settings.apply_db_row("general_settings", remaining)
if is_resource_list("general_settings", data.field_name):
stored_endpoints: Final = general_settings.get("pass_through_endpoints")
stored_endpoints: Final = remaining.get("pass_through_endpoints")
await proxy_config.serve_pass_through_endpoints(stored_endpoints if isinstance(stored_endpoints, list) else ())
asyncio.create_task(
create_config_audit_log(
"general_settings", "deleted", before_general_settings, general_settings, user_api_key_dict
)
create_config_audit_log("general_settings", "deleted", dict(stored), remaining, user_api_key_dict)
)
return response

View file

@ -20,7 +20,7 @@ from pydantic import BaseModel, JsonValue, TypeAdapter
from tests.integration._support.client import Gateway, eventually, object_value, string_value
from tests.integration._support.database import read_rows, scratch_database
from tests.integration._support.process import owned_proxy
from tests.integration._support.process import owned_proxy, owned_proxy_process
from tests.integration._support.wire import Reply, Request, Wire, wire_server
pytestmark: Final = pytest.mark.shares_worker_state
@ -1701,3 +1701,57 @@ def test_db_environment_variables_saved_from_a_session_outside_the_tables_schema
assert isinstance(first, int) and isinstance(second, int)
assert 0 < first < second
def test_a_stored_general_setting_no_settings_api_manages_stays_off_and_the_rest_of_the_row_applies(
gateway: Gateway, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
alias: Final = "stale-database-setting-" + uuid.uuid4().hex
with scratch_database() as database_url, wire_server(lambda _request: _completion_reply("pong")) as provider:
monkeypatch.setenv("DATABASE_URL", database_url)
_push_schema()
with psycopg.connect(database_url, autocommit=True) as writer:
writer.execute(
'INSERT INTO "LiteLLM_Config" (param_name, param_value) VALUES (%s, %s)',
("general_settings", Jsonb({"enforce_user_param": True, "store_prompts_in_spend_logs": True})),
)
config: Final = tmp_path / "stale-database-setting.yaml"
config.write_text(
json.dumps(
{
"model_list": [
{
"model_name": alias,
"litellm_params": {
"model": "openai/gpt-4o-mini",
"api_base": provider.url + "/v1",
"api_key": "integration-provider-key",
},
}
],
"general_settings": {"master_key": gateway.key, "store_model_in_db": True},
}
)
)
with owned_proxy_process(
gateway,
tmp_path / "stale-database-setting",
{"DATABASE_URL": database_url, "DISABLE_SCHEMA_UPDATE": "true"},
config=config,
database_setup=(),
) as owned:
answer: Final = owned.gateway.request(
"POST", "/v1/chat/completions", {"model": alias, "messages": [{"role": "user", "content": "ping"}]}
)
listed: Final = owned.gateway.request("GET", "/config/list", params={"config_type": "general_settings"})
log: Final = owned.log.read_text()
assert answer.status_code == 200, answer.text
assert listed.status_code == 200, listed.text
stored_prompts: Final = next(
entry
for entry in TypeAdapter(list[dict[str, JsonValue]]).validate_json(listed.content)
if entry["field_name"] == "store_prompts_in_spend_logs"
)
assert (stored_prompts["field_value"], stored_prompts["source"]) == (True, "db")
assert "general_settings.enforce_user_param is stored in the database, but the proxy does not apply" in log

View file

@ -471,3 +471,34 @@ def test_settings_store_truthiness_matches_emptiness() -> None:
assert bool(store) is True
del store["max_parallel_requests"]
assert bool(store) is False
def test_settings_store_ignores_stored_keys_outside_its_managed_db_keys_and_still_applies_them_from_yaml() -> None:
store: Final = SettingsStore("general_settings", managed_db_keys=frozenset({"max_parallel_requests"}))
stored_row: Final[dict[str, JsonValue]] = {"enforce_user_param": True, "max_parallel_requests": 5}
store.apply_db_row("general_settings", stored_row)
assert dict(store) == {"max_parallel_requests": 5}
assert store.source("enforce_user_param") == "unset"
assert store.unmanaged_db_keys() == ("enforce_user_param",)
store.load_yaml({"enforce_user_param": True})
store.apply_db_row("general_settings", stored_row)
assert dict(store) == {"enforce_user_param": True, "max_parallel_requests": 5}
assert store.source("enforce_user_param") == "config"
assert store.unmanaged_db_keys() == ("enforce_user_param",)
def test_settings_store_managed_db_keys_leave_other_rows_and_unrestricted_stores_whole() -> None:
restricted: Final = SettingsStore("general_settings", managed_db_keys=frozenset())
unrestricted: Final = SettingsStore("general_settings")
restricted.apply_db_row("ui_settings", {"disable_custom_api_keys": True})
unrestricted.apply_db_row("general_settings", {"enforce_user_param": True})
assert dict(restricted) == {"disable_custom_api_keys": True}
assert restricted.unmanaged_db_keys() == ()
assert dict(unrestricted) == {"enforce_user_param": True}
assert unrestricted.unmanaged_db_keys() == ()

View file

@ -102,7 +102,9 @@ def test_proxy_config_upserts_existing_deployment_without_duplicating_it(monkeyp
@pytest.mark.asyncio
async def test_proxy_config_preserves_models_when_config_read_fails(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
async def test_proxy_config_preserves_models_when_config_read_fails(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
from litellm.proxy import proxy_server
router = litellm.Router(model_list=[_deployment("config-deployment").to_json(exclude_none=True)])
@ -135,6 +137,8 @@ async def test_proxy_config_keeps_database_models_and_deletes_stale_models(
assert desired == frozenset({"kept-deployment"})
assert router.get_model_ids() == ["kept-deployment"]
from tests._master_key import MASTER_KEY
@ -150,7 +154,6 @@ async def test_proxy_config_loads_lens_store_from_yaml(tmp_path, monkeypatch) ->
assert is_lens_tracing_enabled(settings["tracing"], {}) is True
@pytest.mark.asyncio
@pytest.mark.parametrize("shutdown_error", [False, True])
async def test_tracing_config_automatically_exports_spend_without_a_storage_dependency(
@ -176,7 +179,9 @@ async def test_tracing_config_automatically_exports_spend_without_a_storage_depe
outcome: Final = pytest.raises(RuntimeError, match="shutdown failure") if shutdown_error else nullcontext()
with outcome:
async with manage_tracing(enabled=True, client_factory=client):
logger: Final = next(callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter))
logger: Final = next(
callback for callback in litellm._async_success_callback if isinstance(callback, LensExporter)
)
await logger.async_log_success_event(
{"standard_logging_object": {"id": "response-1", "response_cost": 0.25}}, None, None, None
)
@ -2693,7 +2698,6 @@ async def test_load_config_rejects_non_boolean_deny_by_default(
await ProxyConfig().load_config(router=None, config_file_path=str(config_file))
@pytest.mark.asyncio
@pytest.mark.parametrize(
"yaml_value", ["files-api-2025-04-14", "[files-api-2025-04-14, 7]"], ids=["bare-string", "non-string-entry"]
@ -2713,6 +2717,7 @@ async def test_load_config_rejects_a_malformed_vertex_drop_anthropic_betas_list(
with pytest.raises(ValidationError, match="vertex_ai_pass_through_drop_anthropic_betas"):
await ProxyConfig().load_config(router=None, config_file_path=str(config_file))
@pytest.mark.asyncio
async def test_ProxyConfig_load_config_resolves_router_settings_plugins(tmp_path, monkeypatch):
"""Regression: router_settings.plugins dotted-path strings must be resolved to
@ -4470,6 +4475,86 @@ async def test_ProxyConfig__update_general_settings_updates_health_check_retenti
reschedule.assert_awaited_once()
@pytest.mark.asyncio
async def test_ProxyConfig__update_general_settings_ignores_a_stored_key_no_settings_api_manages_and_warns_once(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {})
pc: Final = ProxyConfig()
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
await pc._update_general_settings(stored_row)
await pc._update_general_settings(stored_row)
from litellm.proxy import proxy_server
assert proxy_server.general_settings["store_prompts_in_spend_logs"] is True
assert "enforce_user_param" not in proxy_server.general_settings
warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()]
assert warnings == [
"general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored "
"value, so it is ignored. Set it in the config file to use it, or remove it with POST /config/field/delete."
]
@pytest.mark.asyncio
async def test_ProxyConfig__update_general_settings_warns_about_an_ignored_stored_key_the_config_file_also_sets(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}})
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
await pc._update_general_settings({"enforce_user_param": True})
from litellm.proxy import proxy_server
assert proxy_server.general_settings["enforce_user_param"] is False
warnings: Final = [record.getMessage() for record in caplog.records if "enforce_user_param" in record.getMessage()]
assert warnings == [
"general_settings.enforce_user_param is stored in the database, but the proxy does not apply that stored "
"value, so it is ignored. The config file's value applies. Remove the stored copy with POST "
"/config/field/delete."
]
@pytest.mark.asyncio
async def test_ProxyConfig__update_general_settings_does_not_warn_about_a_stored_copy_of_an_admin_ui_field(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
await pc._update_general_settings({"budget_rollover": True, "enforce_user_param": True})
warned: Final = [record.getMessage().split(" ")[0] for record in caplog.records if "is ignored" in record.getMessage()]
assert warned == ["general_settings.enforce_user_param"]
@pytest.mark.asyncio
async def test_ProxyConfig__update_general_settings_warns_once_each_time_the_stored_row_stops_being_an_object(
monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
) -> None:
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", pc.settings)
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"):
await pc._update_general_settings(None)
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
await pc._update_general_settings({"store_prompts_in_spend_logs": True})
await pc._update_general_settings('{"store_prompts_in_spend_logs": true}')
warnings: Final = [record.getMessage() for record in caplog.records if "JSON object" in record.getMessage()]
assert warnings == [
"general_settings is stored in the database as something other than a JSON object, so the proxy ignores "
"every stored general setting."
] * 2
def _paused_scheduler(monkeypatch):
from apscheduler.schedulers.asyncio import AsyncIOScheduler
@ -4918,9 +5003,6 @@ async def test_ProxyConfig__update_general_settings_none_input_noop():
# None input returns early.
result = await pc._update_general_settings(db_general_settings=None)
assert result is None
# Error-style: dict() will fail on non-mapping non-None input.
with pytest.raises(TypeError):
await pc._update_general_settings(db_general_settings=12345) # type: ignore[arg-type]
@pytest.mark.asyncio
@ -5080,7 +5162,9 @@ async def test_ProxyConfig__update_config_from_db_keeps_keys_the_config_file_omi
@pytest.mark.asyncio
@pytest.mark.parametrize("ui_settings_already_synced", [False, True])
async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints(monkeypatch, ui_settings_already_synced):
async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endpoints(
monkeypatch: pytest.MonkeyPatch, ui_settings_already_synced: bool
) -> None:
from litellm.proxy import proxy_server
pc = ProxyConfig()
@ -5106,6 +5190,32 @@ async def test_ProxyConfig_add_deployment_continues_after_null_pass_through_endp
assert settings_refresh.await_count == (0 if ui_settings_already_synced else 1)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"stored_row, rebuilds_routes",
[({"pass_through_endpoints": []}, True), ('{"pass_through_endpoints": []}', False), ([], False)],
ids=["object", "json-string", "array"],
)
async def test_ProxyConfig_add_deployment_rebuilds_pass_through_routes_only_from_an_object_general_settings_row(
monkeypatch: pytest.MonkeyPatch, stored_row: object, rebuilds_routes: bool
) -> None:
from litellm.proxy import proxy_server
from litellm.proxy.pass_through_endpoints import pass_through_endpoints
pc: Final = ProxyConfig()
rebuild_routes: Final = AsyncMock()
monkeypatch.setattr(proxy_server, "general_settings", {})
monkeypatch.setattr(proxy_server, "prefetch_config_params", AsyncMock())
monkeypatch.setattr(proxy_server, "get_config_param", AsyncMock(return_value=SimpleNamespace(param_value=stored_row)))
monkeypatch.setattr(pass_through_endpoints, "initialize_pass_through_endpoints_in_db", rebuild_routes)
monkeypatch.setattr(pc, "_should_load_db_object", lambda *, object_type: object_type == "pass_through_endpoints")
monkeypatch.setattr(pc, "get_credentials", AsyncMock())
await pc.add_deployment(prisma_client=MagicMock(), proxy_logging_obj=MagicMock(), ui_settings_already_synced=True)
assert rebuild_routes.await_count == (1 if rebuilds_routes else 0)
# ---------------------------------------------------------------------------
# ProxyConfig._update_config_from_db
# ---------------------------------------------------------------------------
@ -5285,9 +5395,7 @@ def revision_test_environment(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv(key)
def _environment_variables_row(
values: Mapping[str, str | None] | None, revision: int | None
) -> SimpleNamespace | None:
def _environment_variables_row(values: Mapping[str, str | None] | None, revision: int | None) -> SimpleNamespace | None:
if values is None:
return None
return SimpleNamespace(
@ -5473,9 +5581,7 @@ async def test_environment_variables_row_read_before_an_overlapping_newer_sync_i
await newer_sync_finished.wait()
older_sync: Final = asyncio.create_task(
_sync_from(
pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync)
)
_sync_from(pc, _config_database(read_older_row, AsyncMock(return_value=older_row), wait_for_the_newer_sync))
)
await older_environment_row_read.wait()
await _sync_from(pc, _rows_database(newer_row, newer_row))

View file

@ -1804,9 +1804,7 @@ class _DatabaseWithOneStoredCredential:
@pytest.mark.asyncio
@pytest.mark.parametrize(
"encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)]
)
@pytest.mark.parametrize("encrypted_with, asks_to_migrate", [(PUBLICLY_KNOWN_KEY, True), ("sk-some-other-key", False)])
async def test_proxy_startup_asks_to_migrate_only_when_the_database_holds_values_under_the_unsafe_key(
monkeypatch, tmp_path, encrypted_with, asks_to_migrate
):
@ -1924,9 +1922,7 @@ async def test_proxy_startup_names_the_config_file_that_set_the_unsafe_key(monke
from litellm.proxy.auth.master_key_boot_check import UnsafeMasterKeyError
from litellm.proxy.proxy_server import proxy_startup_event
config_path, announced = _boot_with_general_settings(
monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY}
)
config_path, announced = _boot_with_general_settings(monkeypatch, tmp_path, {"master_key": PUBLICLY_KNOWN_KEY})
with pytest.raises(UnsafeMasterKeyError):
async with proxy_startup_event(FastAPI()):
@ -3807,6 +3803,24 @@ async def test_db_reload_keeps_the_resolved_value_of_a_config_owned_env_referenc
assert proxy_server_module.store_model_in_db is True
@pytest.mark.asyncio
async def test_db_reload_of_a_json_string_general_settings_row_reports_no_ignored_keys(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.proxy import proxy_server as proxy_server_module
from litellm.proxy.proxy_server import ProxyConfig
monkeypatch.setattr(proxy_server_module, "user_api_key_cache", MagicMock(), raising=False)
proxy_config: Final = ProxyConfig()
proxy_config.settings.load_yaml({})
monkeypatch.setattr(proxy_server_module, "general_settings", proxy_config.settings, raising=False)
await proxy_config._update_general_settings('{"budget_rollover": true, "master_key": "sk-stored"}')
assert proxy_config.settings.unmanaged_db_keys() == ()
assert proxy_config.settings.source("master_key") != "db"
def test_max_ui_session_budget_default_is_one_dollar():
"""LIT-4662: the dashboard session budget default is a product decision; the
old 0.25 default locked admins out of auto router Test Connection and the
@ -7295,7 +7309,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch):
db_param_value = {
"max_parallel_requests": None,
"allowed_models": [],
"new_key": "new_value",
"store_prompts_in_spend_logs": True,
"nested": {
"key1": "updated_value1",
"key3": "value3",
@ -7308,7 +7322,7 @@ def test_deep_merge_dicts_skips_none_and_empty_lists(monkeypatch):
assert result["max_parallel_requests"] == 10
assert result["allowed_models"] == ["gpt-3.5-turbo", "gpt-4"]
assert result["new_key"] == "new_value"
assert result["store_prompts_in_spend_logs"] is True
assert result["nested"] == {"key1": "value1", "key2": "value2"}
@ -8394,10 +8408,18 @@ async def test_update_general_settings_db_pass_through_endpoint_overrides_yaml_e
request.headers = {}
request.query_params = {}
settings: Final = patch("litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]}) # test-quality-ok: the method reads this module global; no injection seam
yaml_endpoints: Final = patch("litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint]) # test-quality-ok: module global holding the YAML endpoints the fix merges in
initialize: Final = patch("litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock()) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here
master_key: Final = patch("litellm.proxy.proxy_server.master_key", MASTER_KEY) # test-quality-ok: a set master key is what makes a missing Authorization header a 401
settings: Final = patch(
"litellm.proxy.proxy_server.general_settings", {"pass_through_endpoints": [yaml_endpoint]}
) # test-quality-ok: the method reads this module global; no injection seam
yaml_endpoints: Final = patch(
"litellm.proxy.proxy_server.config_passthrough_endpoints", [yaml_endpoint]
) # test-quality-ok: module global holding the YAML endpoints the fix merges in
initialize: Final = patch(
"litellm.proxy.proxy_server.initialize_pass_through_endpoints", AsyncMock()
) # test-quality-ok: route registration needs the FastAPI app; auth is the observable here
master_key: Final = patch(
"litellm.proxy.proxy_server.master_key", MASTER_KEY
) # test-quality-ok: a set master key is what makes a missing Authorization header a 401
with settings, yaml_endpoints, initialize, master_key:
await ProxyConfig()._update_general_settings(db_general_settings={"pass_through_endpoints": [db_endpoint]})
@ -15829,6 +15851,166 @@ async def test_delete_config_general_settings_still_removes_a_key_the_database_o
assert "max_request_size_mb" not in pc.settings
@pytest.mark.asyncio
async def test_delete_config_general_settings_removes_a_stored_key_no_settings_api_manages(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.proxy._types import ConfigFieldDelete
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
pc.settings.apply_db_row("general_settings", stored_row)
fake_prisma: Final = _fake_prisma_with_config(stored_row)
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await delete_config_general_settings(
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
user_api_key_dict=admin,
)
written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"])
assert written == {"store_prompts_in_spend_logs": True}
assert pc.settings.unmanaged_db_keys() == ()
@pytest.mark.asyncio
async def test_delete_config_general_settings_stops_serving_the_removed_pass_through_routes(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from fastapi import FastAPI
from starlette.routing import Route
from litellm.proxy._types import ConfigFieldDelete
from litellm.proxy.pass_through_endpoints.pass_through_endpoints import _registered_pass_through_routes
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
from litellm.types.passthrough_endpoints.pass_through_endpoints import LITELLM_PASS_THROUGH_ENDPOINT_MARKER
endpoint: Final = {"id": "stored-route", "path": "/stored-route", "target": "http://example.com"}
stored_row: Final = {"pass_through_endpoints": [endpoint], "store_prompts_in_spend_logs": True}
app: Final = FastAPI()
monkeypatch.setattr(proxy_server_module, "app", app)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr(proxy_server_module, "config_passthrough_endpoints", None)
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
pc.settings.apply_db_row("general_settings", stored_row)
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
monkeypatch.setattr(proxy_server_module, "prisma_client", _fake_prisma_with_config(stored_row))
def served_paths() -> frozenset[str]:
return frozenset(
route.path
for route in app.router.routes
if isinstance(route, Route) and getattr(route.endpoint, LITELLM_PASS_THROUGH_ENDPOINT_MARKER, False) is True
)
saved_registry: Final = dict(_registered_pass_through_routes)
try:
_registered_pass_through_routes.clear()
await pc.serve_pass_through_endpoints([endpoint])
served_before: Final = served_paths()
await delete_config_general_settings(
data=ConfigFieldDelete(field_name="pass_through_endpoints", config_type="general_settings"),
user_api_key_dict=UserAPIKeyAuth(
api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN
),
)
served_after: Final = served_paths()
finally:
_registered_pass_through_routes.clear()
_registered_pass_through_routes.update(saved_registry)
assert "/stored-route" in served_before
assert "/stored-route" not in served_after
@pytest.mark.asyncio
async def test_delete_config_general_settings_removes_an_ignored_stored_key_the_config_file_also_sets(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.proxy._types import ConfigFieldDelete
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {"enforce_user_param": False}})
stored_row: Final = {"enforce_user_param": True, "store_prompts_in_spend_logs": True}
pc.settings.apply_db_row("general_settings", stored_row)
fake_prisma: Final = _fake_prisma_with_config(stored_row)
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await delete_config_general_settings(
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
user_api_key_dict=admin,
)
written: Final = json.loads(fake_prisma.db.litellm_config.upsert.await_args.kwargs["data"]["update"]["param_value"])
assert written == {"store_prompts_in_spend_logs": True}
assert pc.settings["enforce_user_param"] is False
assert pc.settings.unmanaged_db_keys() == ()
@pytest.mark.asyncio
@pytest.mark.parametrize("stored_row", ['{"max_request_size_mb": 42, "disable_custom_api_keys": true}', "not json"])
@pytest.mark.parametrize("field_name", ["max_request_size_mb", "disable_custom_api_keys", "not_a_setting"])
async def test_delete_config_general_settings_leaves_a_string_row_untouched(
monkeypatch: pytest.MonkeyPatch, stored_row: str, field_name: str
) -> None:
from litellm.proxy._types import ConfigFieldDelete
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
fake_prisma: Final = _fake_prisma_with_config(stored_row)
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(HTTPException) as refused:
await delete_config_general_settings(
data=ConfigFieldDelete(field_name=field_name, config_type="general_settings"),
user_api_key_dict=admin,
)
assert (refused.value.status_code, refused.value.detail) == (
400,
{
"error": "general_settings is stored in the database as something other than a JSON object, so no field "
"can be removed from it"
},
)
fake_prisma.db.litellm_config.upsert.assert_not_awaited()
@pytest.mark.asyncio
async def test_delete_config_general_settings_refuses_a_key_neither_managed_nor_stored(
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.proxy._types import ConfigFieldDelete
from litellm.proxy.proxy_server import ProxyConfig, delete_config_general_settings
pc: Final = ProxyConfig()
pc._load_yaml_settings_stores({"general_settings": {}})
fake_prisma: Final = _fake_prisma_with_config({"store_prompts_in_spend_logs": True})
monkeypatch.setattr(proxy_server_module, "proxy_config", pc)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
admin: Final = UserAPIKeyAuth(api_key="hashed-admin", user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(HTTPException) as refused:
await delete_config_general_settings(
data=ConfigFieldDelete(field_name="enforce_user_param", config_type="general_settings"),
user_api_key_dict=admin,
)
assert refused.value.status_code == 400
fake_prisma.db.litellm_config.upsert.assert_not_awaited()
@pytest.mark.asyncio
async def test_config_field_info_reports_the_declared_value_of_a_config_owned_secret(monkeypatch):
from litellm.proxy.proxy_server import ProxyConfig, get_config_general_settings