~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
fix(security): sweep logger.exception() out of provider/engine paths (#4183) (#4888)
Dongping Guo (Donny)eb03a85dc18c
diff --git a/.pre-commit-hooks/check-env-vars.py b/.pre-commit-hooks/check-env-vars.pyindex 7677f542f8..2fa2383222 100755--- a/.pre-commit-hooks/check-env-vars.py+++ b/.pre-commit-hooks/check-env-vars.py@@ -48,6 +48,7 @@ ALLOWED_NAMES = {# reliably.ALLOWED_PATH_ENDINGS = ("security/rate_limiter.py", # Module-level RATE_LIMIT_FAIL_CLOSED at decorator time+ "security/secure_logging.py", # Diagnose-mode gate must work before/without SettingsManager (same rationale as log_utils.py))# System environment variables that are always alloweddiff --git a/.pre-commit-hooks/check-sensitive-logging.py b/.pre-commit-hooks/check-sensitive-logging.pyindex ba019a39a8..e1335545a6 100755--- a/.pre-commit-hooks/check-sensitive-logging.py+++ b/.pre-commit-hooks/check-sensitive-logging.py@@ -118,6 +118,18 @@ ALLOWED_LOGGING = []+# Directories where ``logger.exception()`` routes through the diagnose-gated+# ``security.secure_logging`` wrapper: the message is production-visible at+# ERROR level (only the traceback is gated), so interpolating the raw+# exception variable leaks error details there just like any other level+# (#4183). Elsewhere, plain loguru ``.exception()`` output remains dev-only.+SECURE_LOGGING_DIRS = (+ "src/local_deep_research/llm/providers/",+ "src/local_deep_research/embeddings/providers/",+ "src/local_deep_research/web_search_engines/",+)++class SensitiveLoggingChecker(ast.NodeVisitor):"""AST visitor to detect sensitive data in logging statements."""@@ -210,8 +222,16 @@ class SensitiveLoggingChecker(ast.NodeVisitor):configured for dev-only output."""level = self._get_log_level(node)- # logger.exception() and logger.debug() are fine — not visible in production- if level in {"exception", "debug"}:+ # logger.debug() is fine — not visible in production+ if level == "debug":+ return+ # Plain loguru logger.exception() output is dev-only — but in the+ # secure_logging dirs the wrapper makes the message production-visible+ # at ERROR, so the exception variable must not be interpolated there.+ in_secure_dir = any(+ d in self.filename.replace("\\", "/") for d in SECURE_LOGGING_DIRS+ )+ if level == "exception" and not in_secure_dir:return# Collect current except variable names@@ -222,11 +242,38 @@ class SensitiveLoggingChecker(ast.NodeVisitor):# Check positional args (f-strings and %-style args)for arg in node.args:if self._expr_references_vars(arg, except_vars):- self.errors.append(- f"{self.filename}:{node.lineno}: "- f"Exception variable in logger.{level}() leaks error details — "- f"use logger.exception() or remove the variable"- )+ if level == "exception":+ self.errors.append(+ f"{self.filename}:{node.lineno}: "+ f"Exception variable in logger.exception() — this message is "+ f"production-visible at ERROR (secure_logging wrapper) — "+ f"log a scrubbed message (sanitize_error_message/redact_secrets) instead"+ )+ else:+ self.errors.append(+ f"{self.filename}:{node.lineno}: "+ f"Exception variable in logger.{level}() leaks error details — "+ f"use logger.exception() or remove the variable"+ )+ return++ # Check keyword args: loguru-style logger.exception("msg: {err}", err=e) bypasses+ # the positional check above since the exception variable is in a keyword value.+ for kw in node.keywords:+ if self._expr_references_vars(kw.value, except_vars):+ if level == "exception":+ self.errors.append(+ f"{self.filename}:{node.lineno}: "+ f"Exception variable in logger.exception() keyword arg — this message is "+ f"production-visible at ERROR (secure_logging wrapper) — "+ f"log a scrubbed message (sanitize_error_message/redact_secrets) instead"+ )+ else:+ self.errors.append(+ f"{self.filename}:{node.lineno}: "+ f"Exception variable in logger.{level}() keyword arg leaks error details — "+ f"use logger.exception() or remove the variable"+ )returndef _expr_references_vars(self, expr: ast.AST, var_names: set) -> bool:@@ -444,9 +491,18 @@ def main():print(f" {error}")print("\nPlease ensure sensitive data is not logged directly.")print("Consider:")- print(" - Removing sensitive data from log messages")- print(" - Using sanitized versions of data structures")- print(" - Logging only necessary non-sensitive information")+ print(+ " - In llm/providers/, embeddings/providers/, web_search_engines/:"+ )+ print(+ " use sanitize_error_message()/redact_secrets() and log the safe_msg"+ )+ print(+ " - Elsewhere: use logger.exception() (traceback is dev-only) or remove the variable"+ )+ print(+ " - Using sanitized versions of sensitive data structures before logging"+ )return 1return 0diff --git a/changelog.d/4888.security.md b/changelog.d/4888.security.mdnew file mode 100644index 0000000000..b72c2f23bc--- /dev/null+++ b/changelog.d/4888.security.md@@ -0,0 +1 @@+Raw exception variables (`e`, `exc`, etc.) are no longer interpolated directly into `logger.exception()` messages across all LLM provider, embedding provider, and web search engine paths; each catch site now scrubs the message through `sanitize_error_message()`/`redact_secrets()` before logging, preventing error text from leaking API keys, credentials, or internal URL structure into production logs. Scrubbed exception log lines now include the exception class name so exceptions that stringify to an empty message still produce useful diagnostics. A new `check-sensitive-logging` pre-commit hook enforces this rule going forward, rejecting direct exception-variable interpolation in the secure-logging directories and flagging `exc_info=True` on `warning`/`error`/`critical` calls.diff --git a/src/local_deep_research/embeddings/providers/implementations/ollama.py b/src/local_deep_research/embeddings/providers/implementations/ollama.pyindex 804fecb545..48c8b3a749 100644--- a/src/local_deep_research/embeddings/providers/implementations/ollama.py+++ b/src/local_deep_research/embeddings/providers/implementations/ollama.py@@ -5,15 +5,16 @@ from typing import Any, Dict, List, Optionalfrom langchain_ollama import OllamaEmbeddingsfrom langchain_core.embeddings import Embeddings-from loguru import loggerfrom ....config.thread_settings import get_setting_from_snapshot+from ....security.secure_logging import loggerfrom ....utilities.llm_utils import (_close_inner_ollama_clients,get_ollama_base_url,)from ..base import BaseEmbeddingProvider, Exposure-from ....security import safe_get, safe_post+from ....security import redact_url_for_log, safe_get, safe_post+from ....security.log_sanitizer import redact_secrets, sanitize_error_messageclass OllamaEmbeddingsProvider(BaseEmbeddingProvider):@@ -74,7 +75,7 @@ class OllamaEmbeddingsProvider(BaseEmbeddingProvider):logger.info(f"Creating OllamaEmbeddings with model={model}, "- f"base_url={base_url}, num_ctx={num_ctx}"+ f"base_url={redact_url_for_log(base_url)}, num_ctx={num_ctx}")ollama_kwargs: Dict[str, Any] = {@@ -134,8 +135,11 @@ class OllamaEmbeddingsProvider(BaseEmbeddingProvider):except requests.exceptions.RequestException:return False- except Exception:- logger.exception("Error checking Ollama availability")+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))+ logger.exception(+ f"Error checking Ollama availability ({type(e).__name__}): {safe_msg}"+ )return False@classmethoddiff --git a/src/local_deep_research/llm/providers/auto_discovery.py b/src/local_deep_research/llm/providers/auto_discovery.pyindex febd2e475c..03af0f49af 100644--- a/src/local_deep_research/llm/providers/auto_discovery.py+++ b/src/local_deep_research/llm/providers/auto_discovery.py@@ -5,11 +5,11 @@ import inspectfrom pathlib import Pathfrom typing import Dict, List, Optional-from loguru import logger-+from ...security.secure_logging import loggerfrom .base import BaseLLMProvider, normalize_providerfrom .openai_base import OpenAICompatibleProviderfrom ..llm_registry import register_llm+from ...security.log_sanitizer import redact_secrets, sanitize_error_messageclass ProviderInfo:@@ -155,8 +155,11 @@ class ProviderDiscovery:f"Discovered provider: {provider_info.provider_key} from {module_name}.py")- except Exception:- logger.exception(f"Error loading provider from {module_name}")+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))+ logger.exception(+ f"Error loading provider from {module_name} ({type(e).__name__}): {safe_msg}"+ )self._discovered = Truelogger.info(f"Discovered {len(self._providers)} providers")diff --git a/src/local_deep_research/security/secure_logging.py b/src/local_deep_research/security/secure_logging.pynew file mode 100644index 0000000000..355420e009--- /dev/null+++ b/src/local_deep_research/security/secure_logging.py@@ -0,0 +1,107 @@+"""Loguru wrapper whose ``.exception()`` gates tracebacks behind diagnose mode.++Provider and search-engine exception handlers must stay observable at+ERROR level, but plain ``loguru.logger.exception()`` always attaches the+active exception to the record — every sink (stderr, database, frontend)+then renders or persists the traceback, including the ``__cause__`` /+``__context__`` chain, which has leaked Authorization headers and full+URLs embedded in wrapped exceptions (#4183).++:data:`logger` exported here is a :class:`SecureLogger` proxy around the+real loguru logger. Its ``.exception()`` is equivalent to::++ logger.opt(exception=is_diagnose_mode()).error(...)++so in normal operation the record carries *no* exception object — no sink+can render a traceback — while the event itself still lands at ERROR.+Developers opt into full tracebacks by setting **both** ``LDR_APP_DEBUG``+and ``LDR_LOGURU_DIAGNOSE`` to a truthy value ("1", "true", "yes").++Usage — a drop-in replacement for the loguru import::++ from ..security.secure_logging import logger++ try:+ ...+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))+ logger.exception(f"Engine request failed: {safe_msg}")++Caveats:++* **Messages are production-visible at ERROR.** The wrapper only strips+ the traceback; the message string itself reaches every sink. Call sites+ must still pass scrubbed text (``sanitize_error_message`` /+ ``redact_secrets``), never raw ``str(e)``.+* **Known bypass routes.** ``logger.opt(exception=True).error(...)`` and+ ``@logger.catch`` delegate to plain loguru and are NOT gated. No call+ site under ``llm/providers/``, ``embeddings/providers/`` or+ ``web_search_engines/`` uses them today; the #4183 step-2 pre-commit+ hook should detect them.+* **Env-gated only.** ``config_logger()`` in ``utilities/log_utils.py``+ gates its per-sink ``diagnose`` flag on its ``debug`` argument, which+ may come from the ``app.debug`` DB setting — this wrapper reads only+ the environment, so a DB-enabled debug mode does not enable wrapper+ tracebacks. See the cross-reference comment in ``config_logger``.+"""++import os++from loguru import logger as _loguru_logger+++def env_truthy(name: str) -> bool:+ """Return True if env var *name* is set to a truthy value ("1", "true", "yes")."""+ return os.environ.get(name, "").strip().lower() in ("1", "true", "yes")+++def is_diagnose_mode() -> bool:+ """Return True when the operator explicitly opted into traceback output.++ Requires BOTH ``LDR_APP_DEBUG`` and ``LDR_LOGURU_DIAGNOSE`` to be+ truthy, mirroring the two-flag opt-in that ``config_logger()`` uses+ for loguru's frame-locals ``diagnose`` rendering.+ """+ return env_truthy("LDR_APP_DEBUG") and env_truthy("LDR_LOGURU_DIAGNOSE")+++class SecureLogger:+ """Thin proxy over the loguru logger with a diagnose-gated ``exception()``.++ Everything except ``exception()``, ``bind()`` and ``patch()``+ delegates straight to loguru. Not a ``loguru._logger.Logger``+ subclass: its ``__init__`` takes ~10 positional private arguments+ that shift between releases, so a proxy is the version-stable shape.+ """++ __slots__ = ("_logger",)++ def __init__(self, wrapped=None):+ self._logger = wrapped if wrapped is not None else _loguru_logger++ def exception(__self, __message, *args, **kwargs): # noqa: N805+ """Log at ERROR; attach the active exception only in diagnose mode.++ Positional-only ``__self`` / ``__message`` mirror loguru's own+ signature so ``str.format`` keyword fields (e.g. ``msg=``) cannot+ collide with parameter names. ``depth=1`` attributes the record+ to the caller's module/function/line, keeping+ ``logger.enable()`` / ``logger.disable()`` namespace semantics.+ """+ __self._logger.opt(exception=is_diagnose_mode(), depth=1).error(+ __message, *args, **kwargs+ )++ def bind(self, *args, **kwargs):+ """Like loguru's ``bind()`` but the result keeps the gated ``exception()``."""+ return SecureLogger(self._logger.bind(*args, **kwargs))++ def patch(self, *args, **kwargs):+ """Like loguru's ``patch()`` but the result keeps the gated ``exception()``."""+ return SecureLogger(self._logger.patch(*args, **kwargs))++ def __getattr__(self, name):+ return getattr(self._logger, name)+++logger = SecureLogger()diff --git a/src/local_deep_research/security/url_builder.py b/src/local_deep_research/security/url_builder.pyindex eafffde766..5c0d9c7320 100644--- a/src/local_deep_research/security/url_builder.py+++ b/src/local_deep_research/security/url_builder.py@@ -10,6 +10,8 @@ from typing import Optional, Unionfrom urllib.parse import urlparsefrom loguru import logger+from .ssrf_validator import redact_url_for_log+class URLBuilderError(Exception):"""Raised when URL construction fails."""@@ -61,7 +63,9 @@ def build_base_url_from_settings(# Try external URL first (highest priority)if external_url and external_url.strip():base_url = external_url.strip().rstrip("/")- logger.debug(f"Using configured external URL: {base_url}")+ logger.debug(+ f"Using configured external URL: {redact_url_for_log(base_url)}"+ )return base_url# Try to construct from host and port@@ -71,12 +75,14 @@ def build_base_url_from_settings(# Use HTTP for host/port combinations (typically internal server addresses)# For external URLs, users should configure external_url setting insteadbase_url = f"http://{normalized_host}:{int(port)}" # DevSkim: ignore DS137138- logger.debug(f"Constructed URL from host/port: {base_url}")+ logger.debug(+ f"Constructed URL from host/port: {redact_url_for_log(base_url)}"+ )return base_url# Final fallbackbase_url = fallback_base.rstrip("/")- logger.debug(f"Using fallback URL: {base_url}")+ logger.debug(f"Using fallback URL: {redact_url_for_log(base_url)}")return base_urlexcept Exception as e:diff --git a/src/local_deep_research/utilities/log_utils.py b/src/local_deep_research/utilities/log_utils.pyindex 2e9393392d..60178f7833 100644--- a/src/local_deep_research/utilities/log_utils.py+++ b/src/local_deep_research/utilities/log_utils.py@@ -574,6 +574,15 @@ def config_logger(name: str, debug: bool = False) -> None:# Authorization headers) into every sink. Gate diagnose behind a separate# explicit opt-in so enabling LDR_APP_DEBUG for general debug output does# not also enable localvar dumps. Default OFF even when debug is on.+ #+ # security/secure_logging.py gates provider/engine exception tracebacks+ # on the same two flags (its is_diagnose_mode()). Deliberate divergence:+ # the wrapper reads LDR_APP_DEBUG from the environment only, while the+ # ``debug`` argument here may also come from the app.debug DB setting /+ # legacy server_config.json — so DB-enabled debug affects this sink's+ # diagnose but never the wrapper's traceback gate. Kept inline (not+ # env_truthy) because log_utils must not import security at module+ # level: security/__init__.py runs install_audit_hook() on import.diagnose = debug and os.environ.get("LDR_LOGURU_DIAGNOSE", "").strip().lower() in ("1", "true", "yes")diff --git a/src/local_deep_research/web_search_engines/engines/full_search.py b/src/local_deep_research/web_search_engines/engines/full_search.pyindex 108914ccda..8cf13ee408 100644--- a/src/local_deep_research/web_search_engines/engines/full_search.py+++ b/src/local_deep_research/web_search_engines/engines/full_search.py@@ -1,4 +1,3 @@-from loguru import loggerfrom datetime import datetime, UTCfrom typing import Any, Dict, List, Optional, Protocol, runtime_checkable@@ -9,6 +8,8 @@ from ...research_library.downloaders.extraction import (batch_fetch_and_extract,)from ...security.egress.policy import PolicyDeniedError+from ...security.log_sanitizer import redact_secrets, sanitize_error_message+from ...security.secure_logging import loggerfrom ...security.ssrf_validator import redact_url_for_log, validate_urlfrom ...utilities.js_rendering import (read_js_rendering_setting as _read_js_rendering_setting,@@ -84,8 +85,11 @@ class FullSearchResults:# the unfiltered-results fallback below — that would let the run# proceed despite the user's policy refusing the LLM. Fail closed.raise- except Exception:- logger.exception("URL filtering error")+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))+ logger.exception(+ f"URL filtering error ({type(e).__name__}): {safe_msg}"+ )logger.warning("URL quality filter unavailable — returning {} unfiltered ""results as fallback",@@ -221,8 +225,11 @@ class FullSearchResults:self.settings_snapshot),)- except Exception:- logger.exception("Error fetching full content")+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))+ logger.exception(+ f"Error fetching full content ({type(e).__name__}): {safe_msg}"+ )for item in relevant_items:item["full_content"] = Nonereturn relevant_itemsdiff --git a/src/local_deep_research/web_search_engines/engines/local_embedding_manager.py b/src/local_deep_research/web_search_engines/engines/local_embedding_manager.pyindex 15af4e55b0..8a4eed52bc 100644--- a/src/local_deep_research/web_search_engines/engines/local_embedding_manager.py+++ b/src/local_deep_research/web_search_engines/engines/local_embedding_manager.py@@ -5,10 +5,11 @@ from datetime import UTC, datetimefrom typing import Any, Dict, List, Optionalfrom langchain_core.documents import Document-from loguru import loggerfrom ...database.models.library import DocumentChunkfrom ...database.session_context import get_user_db_session+from ...security.log_sanitizer import redact_secrets, sanitize_error_message+from ...security.secure_logging import loggerfrom ...utilities.url_utils import normalize_url@@ -142,9 +143,9 @@ class LocalEmbeddingManager:# DNS hiccup, provider validation, policy denial) must# propagate so we don't silently fetch from huggingface.co# when the user has explicitly opted into local embeddings.+ safe_msg = redact_secrets(sanitize_error_message(str(exc)))logger.exception(- "Embedding provider import failed — falling back to local SBERT",- exc_info=exc,+ f"Embedding provider import failed ({type(exc).__name__}) — falling back to local SBERT: {safe_msg}")# Route the fallback through get_embeddings(sentence_transformers)# rather than constructing HuggingFaceEmbeddings directly: the SBERT@@ -258,9 +259,12 @@ class LocalEmbeddingManager:f"Stored {len(chunk_ids)} chunks to database for collection '{collection_name}'")- except Exception:+ except Exception as e:+ safe_msg = redact_secrets(+ sanitize_error_message(str(e)), self.db_password+ )logger.exception(- f"Error storing chunks to database for collection '{collection_name}'"+ f"Error storing chunks to database for collection '{collection_name}' ({type(e).__name__}): {safe_msg}")return []@@ -310,8 +314,11 @@ class LocalEmbeddingManager:)return count- except Exception:+ except Exception as e:+ safe_msg = redact_secrets(+ sanitize_error_message(str(e)), self.db_password+ )logger.exception(- f"Error deleting chunks from database for collection '{collection_name}'"+ f"Error deleting chunks from database for collection '{collection_name}' ({type(e).__name__}): {safe_msg}")return 0diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_arxiv.py b/src/local_deep_research/web_search_engines/engines/search_engine_arxiv.pyindex d5f118c9bf..6a43bad162 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_arxiv.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_arxiv.py@@ -2,9 +2,9 @@ from typing import Any, Dict, List, Optionalimport arxivfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import SNIPPET_LENGTH_SHORT+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -172,7 +172,10 @@ class ArXivSearchEngine(BaseSearchEngine):except Exception as e:error_msg = str(e)- logger.exception("Error getting arXiv previews")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting arXiv previews ({type(e).__name__}): {safe_msg}"+ )# Check for rate limiting patternsif (@@ -309,20 +312,26 @@ class ArXivSearchEngine(BaseSearchEngine):"Successfully extracted text from PDF using pdfplumber")except (ImportError, Exception) as e2:+ safe_e1 = self._scrub_error(e1)+ safe_e2 = self._scrub_error(e2)logger.exception(- f"PDF text extraction failed: {e1!s}, then {e2!s}"+ f"PDF text extraction failed ({type(e1).__name__}, then {type(e2).__name__}): {safe_e1}, then {safe_e2}")logger.info("Using paper summary as content instead")- except Exception:- logger.exception("Error extracting text from PDF")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error extracting text from PDF ({type(e).__name__}): {safe_msg}"+ )logger.info("Using paper summary as content instead")- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error downloading paper {paper.title}"+ f"Error downloading paper {paper.title} ({type(e).__name__}): {safe_msg}")result["pdf_path"] = Nonepdf_count -= 1 # Decrement counter if download fails@@ -444,13 +453,19 @@ class ArXivSearchEngine(BaseSearchEngine):# Download the paperpaper_path = paper.download_pdf(dirpath=self.download_dir)result["pdf_path"] = str(paper_path)- except Exception:- logger.exception("Error downloading paper")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error downloading paper ({type(e).__name__}): {safe_msg}"+ )return result- except Exception:- logger.exception("Error getting paper details")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting paper details ({type(e).__name__}): {safe_msg}"+ )return {}def search_by_author(diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_collection.py b/src/local_deep_research/web_search_engines/engines/search_engine_collection.pyindex e5b2e439af..600c2fbff2 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_collection.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_collection.py@@ -6,8 +6,8 @@ Provides semantic search within a specific document collection using RAG.import osfrom typing import List, Dict, Any, Optional-from loguru import logger+from ...security.secure_logging import loggerfrom .search_engine_library import LibraryRAGSearchEnginefrom ...constants import SNIPPET_LENGTH_LONGfrom ...research_library.services.library_rag_service import LibraryRAGService@@ -112,9 +112,10 @@ class CollectionSearchEngine(LibraryRAGSearchEngine):f"{self.embedding_provider}/{self.embedding_model}")- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error loading collection {self.collection_id} settings"+ f"Error loading collection {self.collection_id} settings ({type(e).__name__}): {safe_msg}")def search(@@ -253,12 +254,13 @@ class CollectionSearchEngine(LibraryRAGSearchEngine):return results- except Exception:+ except Exception as e:# Re-raise instead of returning [] so a failed search is not# indistinguishable from "no matching documents": run() records# the failure in metrics, and API callers can report the error.+ safe_msg = self._scrub_error(e)logger.exception(- f"Error searching collection '{self.collection_name}'"+ f"Error searching collection '{self.collection_name}' ({type(e).__name__}): {safe_msg}")raisediff --git a/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py b/src/local_deep_research/web_search_engines/engines/search_engine_ddg.pyindex 5c2631f3cc..6b31ec3fd7 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py@@ -2,8 +2,8 @@ from typing import Any, Dict, List, Optionalfrom langchain_community.utilities import DuckDuckGoSearchAPIWrapperfrom langchain_core.language_models import BaseLLM-from loguru import logger+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -104,7 +104,9 @@ class DuckDuckGoSearchEngine(BaseSearchEngine):except Exception as e:error_msg = str(e)sanitized = self._sanitize_error_message(error_msg)- logger.exception("Error getting DuckDuckGo previews: {}", sanitized)+ logger.exception(+ f"Error getting DuckDuckGo previews ({type(e).__name__}): {sanitized}"+ )# Check for known rate limit patternsif "202 Ratelimit" in error_msg or "ratelimit" in error_msg.lower():diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_gutenberg.py b/src/local_deep_research/web_search_engines/engines/search_engine_gutenberg.pyindex 929d7faaf8..27c3de9e1e 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_gutenberg.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_gutenberg.py@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Optionalimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -318,14 +318,20 @@ class GutenbergSearchEngine(BaseSearchEngine):previews.append(preview)- except Exception:- logger.exception("Error parsing Gutenberg book")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error parsing Gutenberg book ({type(e).__name__}): {safe_msg}"+ )continuereturn previewsexcept (requests.RequestException, ValueError) as e:- logger.exception("Gutendex API request failed")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Gutendex API request failed ({type(e).__name__}): {safe_msg}"+ )self._raise_if_rate_limit(e)return []@@ -442,8 +448,11 @@ class GutenbergSearchEngine(BaseSearchEngine):return response.json() # type: ignore[no-any-return]except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching Gutenberg book {book_id}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching Gutenberg book {book_id} ({type(e).__name__}): {safe_msg}"+ )return Nonedef search_by_topic(self, topic: str) -> List[Dict[str, Any]]:diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_library.py b/src/local_deep_research/web_search_engines/engines/search_engine_library.pyindex 131a0575af..600f266204 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_library.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_library.py@@ -6,9 +6,9 @@ Provides semantic search over the user's personal research library using RAG.import osfrom typing import List, Dict, Any, Optional-from loguru import loggerfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity+from ...security.secure_logging import loggerfrom ...constants import SNIPPET_LENGTH_LONGfrom ...research_library.services.library_rag_service import LibraryRAGServicefrom ...research_library.services.library_service import LibraryService@@ -257,12 +257,13 @@ class LibraryRAGSearchEngine(BaseSearchEngine):)all_docs_with_scores.append((doc, score))- except Exception:+ except Exception as e:# One broken collection must not abort the others, but# record the failure so it is not silently equated with# "no matching documents" below.+ safe_msg = self._scrub_error(e)logger.exception(- f"Error searching collection {collection_id}"+ f"Error searching collection {collection_id} ({type(e).__name__}): {safe_msg}")failed_collections.append(collection.get("name") or str(collection_id)@@ -373,10 +374,13 @@ class LibraryRAGSearchEngine(BaseSearchEngine):)return results- except Exception:+ except Exception as e:# Re-raise so run() records the failure in metrics instead of# treating a failed search as "no matching documents".- logger.exception("Error searching library RAG")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error searching library RAG ({type(e).__name__}): {safe_msg}"+ )raise@staticmethod@@ -444,8 +448,11 @@ class LibraryRAGSearchEngine(BaseSearchEngine):return relevant_items- except Exception:- logger.exception("Error retrieving full content from library")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error retrieving full content from library ({type(e).__name__}): {safe_msg}"+ )return relevant_itemsdef close(self):diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py b/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.pyindex d30b927255..26c1f1f797 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py@@ -1,9 +1,9 @@from typing import Any, Dict, List, Optionalfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -183,7 +183,9 @@ class MojeekSearchEngine(BaseSearchEngine):raiseexcept Exception as e:safe_msg = self._scrub_error(e)- logger.warning(f"Error when searching using Mojeek: {safe_msg}")+ logger.warning(+ f"Error when searching using Mojeek ({type(e).__name__}): {safe_msg}"+ )return []def _get_previews(self, query: str) -> List[Dict[str, Any]]:@@ -234,7 +236,10 @@ class MojeekSearchEngine(BaseSearchEngine):logger.info("Retrieving full webpage content")try:return self.full_search._get_full_content(relevant_items)- except Exception:- logger.exception("Error retrieving full content")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error retrieving full content ({type(e).__name__}): {safe_msg}"+ )return relevant_itemsdiff --git a/src/local_deep_research/web_search_engines/engines/search_engine_openalex.py b/src/local_deep_research/web_search_engines/engines/search_engine_openalex.pyindex 71dcc7679b..43b73b8cd5 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_openalex.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_openalex.py@@ -3,10 +3,10 @@from typing import Any, Dict, List, Optionalfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import SNIPPET_LENGTH_LONG, USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -245,8 +245,11 @@ class OpenAlexSearchEngine(BaseSearchEngine):except RateLimitError:# Re-raise rate limit errors for base class retry handlingraise- except Exception:- logger.exception("Error searching OpenAlex")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error searching OpenAlex ({type(e).__name__}): {safe_msg}"+ )return []def _format_work_preview(@@ -417,9 +420,10 @@ class OpenAlexSearchEngine(BaseSearchEngine):"type": "academic_paper",}- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error formatting OpenAlex work: {work.get('id', 'unknown')}"+ f"Error formatting OpenAlex work: {work.get('id', 'unknown')} ({type(e).__name__}): {safe_msg}")return Nonediff --git a/src/local_deep_research/web_search_engines/engines/search_engine_openlibrary.py b/src/local_deep_research/web_search_engines/engines/search_engine_openlibrary.pyindex 825e5c714d..c401ea5dd9 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_openlibrary.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_openlibrary.py@@ -5,10 +5,10 @@ from typing import Any, Dict, List, Optionalimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -243,14 +243,20 @@ class OpenLibrarySearchEngine(BaseSearchEngine):previews.append(preview)- except Exception:- logger.exception("Error parsing Open Library item")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error parsing Open Library item ({type(e).__name__}): {safe_msg}"+ )continuereturn previewsexcept (requests.RequestException, ValueError) as e:- logger.exception("Open Library API request failed")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Open Library API request failed ({type(e).__name__}): {safe_msg}"+ )self._raise_if_rate_limit(e)return []@@ -400,8 +406,11 @@ class OpenLibrarySearchEngine(BaseSearchEngine):return response.json() # type: ignore[no-any-return]except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching book by ISBN {isbn}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching book by ISBN {isbn} ({type(e).__name__}): {safe_msg}"+ )return Nonedef get_author(self, author_key: str) -> Optional[Dict[str, Any]]:@@ -427,6 +436,9 @@ class OpenLibrarySearchEngine(BaseSearchEngine):return response.json() # type: ignore[no-any-return]except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching author {author_key}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching author {author_key} ({type(e).__name__}): {safe_msg}"+ )return Nonediff --git a/src/local_deep_research/web_search_engines/engines/search_engine_paperless.py b/src/local_deep_research/web_search_engines/engines/search_engine_paperless.pyindex eb8c644def..92379a63c7 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_paperless.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_paperless.py@@ -15,7 +15,7 @@ from langchain_core.language_models import BaseLLMfrom loguru import loggerfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity-from ...security import safe_get+from ...security import redact_url_for_log, safe_getclass PaperlessSearchEngine(BaseSearchEngine):@@ -120,7 +120,7 @@ class PaperlessSearchEngine(BaseSearchEngine):self.headers["Authorization"] = f"Token {self.api_token}"logger.info(- f"Initialized Paperless-ngx search engine for {self.api_url}"+ f"Initialized Paperless-ngx search engine for {redact_url_for_log(self.api_url)}")def _make_request(@@ -138,7 +138,7 @@ class PaperlessSearchEngine(BaseSearchEngine):"""url = urljoin(self.api_url or "", endpoint)- logger.debug(f"Making request to: {url}")+ logger.debug(f"Making request to: {redact_url_for_log(url)}")logger.debug(f"Request params: {params}")logger.debug(f"Headers: {self.headers.keys() if self.headers else 'None'}"@@ -181,7 +181,9 @@ class PaperlessSearchEngine(BaseSearchEngine):except requests.exceptions.RequestException as e:safe_msg = self._scrub_error(e)logger.warning(f"Error making request to Paperless-ngx: {safe_msg}")- logger.debug(f"Failed URL: {url}, params: {params}")+ logger.debug(+ f"Failed URL: {redact_url_for_log(url)}, params: {params}"+ )return {}def _expand_query_with_llm(self, query: str) -> str:@@ -409,7 +411,9 @@ IMPORTANT: Output ONLY the search query. No explanations, no additional text."""# Build URL - use the web interface URL for user accessurl = f"{self.api_url}/documents/{doc_id}/details"- logger.debug(f"Generated URL for doc {doc_id}: {url}")+ logger.debug(+ f"Generated URL for doc {doc_id}: {redact_url_for_log(url)}"+ )# Extract snippet - prefer highlighted content from searchsnippet = ""diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_pubchem.py b/src/local_deep_research/web_search_engines/engines/search_engine_pubchem.pyindex 7e89388018..c73cd967ff 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_pubchem.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_pubchem.py@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Optionalfrom urllib.parse import quotefrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -87,8 +87,11 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception("PubChem autocomplete search failed")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"PubChem autocomplete search failed ({type(e).__name__}): {safe_msg}"+ )return []def _get_compound_by_name(self, name: str) -> Optional[Dict[str, Any]]:@@ -127,8 +130,11 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching PubChem compound: {name}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching PubChem compound: {name} ({type(e).__name__}): {safe_msg}"+ )return Nonedef _get_compound_properties(self, cid: int) -> Dict[str, Any]:@@ -164,8 +170,11 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching PubChem properties for CID {cid}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching PubChem properties for CID {cid} ({type(e).__name__}): {safe_msg}"+ )return {}def _get_compound_description(self, cid: int) -> str:@@ -193,9 +202,10 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error fetching PubChem description for CID {cid}"+ f"Error fetching PubChem description for CID {cid} ({type(e).__name__}): {safe_msg}")return ""@@ -221,8 +231,11 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching PubChem synonyms for CID {cid}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching PubChem synonyms for CID {cid} ({type(e).__name__}): {safe_msg}"+ )return []def _get_previews(self, query: str) -> List[Dict[str, Any]]:@@ -342,8 +355,11 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception(f"Error processing PubChem compound: {name}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error processing PubChem compound: {name} ({type(e).__name__}): {safe_msg}"+ )continuereturn previews@@ -457,8 +473,11 @@ class PubChemSearchEngine(BaseSearchEngine):}except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching PubChem compound {cid}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching PubChem compound {cid} ({type(e).__name__}): {safe_msg}"+ )return Nonedef search_by_formula(self, formula: str) -> List[Dict[str, Any]]:@@ -493,6 +512,9 @@ class PubChemSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception(f"Error searching by formula: {formula}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error searching by formula: {formula} ({type(e).__name__}): {safe_msg}"+ )return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py b/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.pyindex 4b4b2ae2af..f5c435a2c4 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Optional, Tuplefrom defusedxml import ElementTree as ETfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import SNIPPET_LENGTH_LONGfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -164,7 +164,9 @@ class PubMedSearchEngine(BaseSearchEngine):except Exception as e:safe_msg = self._scrub_error(e)- logger.warning(f"Error getting result count: {safe_msg}")+ logger.warning(+ f"Error getting result count ({type(e).__name__}): {safe_msg}"+ )return 0def _extract_core_terms(self, query: str) -> str:@@ -398,8 +400,11 @@ Return ONLY the search query without any explanations.return optimized_query- except Exception:- logger.exception("Error optimizing query")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error optimizing query ({type(e).__name__}): {safe_msg}"+ )logger.debug(f"Falling back to original query: '{query}'")return query # Fall back to original query on error@@ -511,8 +516,11 @@ The default assumption should be that medical and scientific queries want RECENTreturn "yes" in answer- except Exception:- logger.exception("Error determining historical focus")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error determining historical focus ({type(e).__name__}): {safe_msg}"+ )# Fall back to basic keyword checkhistorical_terms = ["history",@@ -674,7 +682,7 @@ The default assumption should be that medical and scientific queries want RECENTexcept Exception as e:safe_msg = self._scrub_error(e)logger.warning(- f"Error searching PubMed for query '{query}': {safe_msg}"+ f"Error searching PubMed for query '{query}' ({type(e).__name__}): {safe_msg}")return []@@ -788,7 +796,7 @@ The default assumption should be that medical and scientific queries want RECENTerror_msg = str(e)safe_msg = self._scrub_error(error_msg)logger.warning(- f"Error getting article summaries for {len(id_list)} articles: {safe_msg}"+ f"Error getting article summaries for {len(id_list)} articles ({type(e).__name__}): {safe_msg}")# Check for rate limiting patterns@@ -911,7 +919,7 @@ The default assumption should be that medical and scientific queries want RECENTexcept Exception as e:safe_msg = self._scrub_error(e)logger.warning(- f"Error getting article abstracts for {len(id_list)} articles: {safe_msg}"+ f"Error getting article abstracts for {len(id_list)} articles ({type(e).__name__}): {safe_msg}")return {}@@ -1032,7 +1040,7 @@ The default assumption should be that medical and scientific queries want RECENTexcept Exception as e:safe_msg = self._scrub_error(e)logger.warning(- f"Error getting detailed article metadata: {safe_msg}"+ f"Error getting detailed article metadata ({type(e).__name__}): {safe_msg}")return {}@@ -1214,7 +1222,9 @@ The default assumption should be that medical and scientific queries want RECENTexcept Exception as e:safe_msg = self._scrub_error(e)- logger.warning(f"Error finding PMC IDs: {safe_msg}")+ logger.warning(+ f"Error finding PMC IDs ({type(e).__name__}): {safe_msg}"+ )return {}def _get_pmc_full_text(self, pmcid: str) -> str:@@ -1291,7 +1301,9 @@ The default assumption should be that medical and scientific queries want RECENTexcept Exception as e:safe_msg = self._scrub_error(e)- logger.warning(f"Error getting PMC full text: {safe_msg}")+ logger.warning(+ f"Error getting PMC full text ({type(e).__name__}): {safe_msg}"+ )return ""def _get_previews(self, query: str) -> List[Dict[str, Any]]:diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_retriever.py b/src/local_deep_research/web_search_engines/engines/search_engine_retriever.pyindex fc17fb432f..6e56bc0773 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_retriever.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_retriever.py@@ -6,9 +6,9 @@ This allows using vector stores, databases, or any custom retriever as a searchfrom typing import Any, Dict, List, Optionalfrom langchain_core.retrievers import BaseRetriever, Document-from loguru import loggerfrom ...constants import SNIPPET_LENGTH_LONG+from ...security.secure_logging import loggerfrom ..search_engine_base import BaseSearchEngine@@ -73,8 +73,11 @@ class RetrieverSearchEngine(BaseSearchEngine):)return results- except Exception:- logger.exception("Error in retriever search")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error in retriever search ({type(e).__name__}): {safe_msg}"+ )return []def _convert_document_to_result(@@ -142,8 +145,11 @@ class RetrieverSearchEngine(BaseSearchEngine):)return previews- except Exception:- logger.exception("Error getting previews from retriever")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting previews from retriever ({type(e).__name__}): {safe_msg}"+ )return []def _get_full_content(@@ -197,6 +203,9 @@ class RetrieverSearchEngine(BaseSearchEngine):)return results- except Exception:- logger.exception("Error in async retriever search")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error in async retriever search ({type(e).__name__}): {safe_msg}"+ )return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py b/src/local_deep_research/web_search_engines/engines/search_engine_searxng.pyindex 3647e60400..48c46278fa 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py@@ -5,10 +5,12 @@ from typing import Any, Dict, List, Optionalimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import logger+from ...security import redact_url_for_logfrom ...security.safe_requests import safe_get+from ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity+from ...security.secure_logging import logger@enum.unique@@ -137,7 +139,7 @@ class SearXNGSearchEngine(BaseSearchEngine):# Validate and normalize the instance URL if providedself.instance_url = instance_url.rstrip("/")logger.info(- f"SearXNG initialized with instance URL: {self.instance_url}"+ f"SearXNG initialized with instance URL: {redact_url_for_log(self.instance_url)}")try:# Make sure it's accessible.@@ -151,12 +153,13 @@ class SearXNGSearchEngine(BaseSearchEngine):else:self.is_available = Falselogger.error(- f"Failed to access SearXNG instance at {self.instance_url}. Status code: {response.status_code}"+ f"Failed to access SearXNG instance at {redact_url_for_log(self.instance_url)}. Status code: {response.status_code}")- except (requests.RequestException, ValueError):+ except (requests.RequestException, ValueError) as e:self.is_available = False+ safe_msg = self._scrub_error(e)logger.exception(- f"Error while trying to access SearXNG instance at {self.instance_url}"+ f"Error while trying to access SearXNG instance at {redact_url_for_log(self.instance_url)} ({type(e).__name__}): {safe_msg}")# Add debug logging for all parameters@@ -177,10 +180,10 @@ class SearXNGSearchEngine(BaseSearchEngine):self.safe_search = SafeSearchSetting(int(safe_search))else:self.safe_search = SafeSearchSetting[safe_search]- except (ValueError, KeyError):+ except (ValueError, KeyError) as e:+ safe_msg = self._scrub_error(e)logger.exception(- "'{}' is not a valid safe search setting. Disabling safe search",- safe_search,+ f"'{safe_search}' is not a valid safe search setting ({type(e).__name__}). Disabling safe search: {safe_msg}")self.safe_search = SafeSearchSetting.OFFself.time_range = time_range@@ -190,7 +193,7 @@ class SearXNGSearchEngine(BaseSearchEngine):if self.is_available:self.search_url = f"{self.instance_url}/search"logger.info(- f"SearXNG engine initialized with instance: {self.instance_url}"+ f"SearXNG engine initialized with instance: {redact_url_for_log(self.instance_url)}")logger.info(f"Rate limiting set to {self.delay_between_requests} seconds between requests"@@ -254,8 +257,11 @@ class SearXNGSearchEngine(BaseSearchEngine):allow_private_ips=True,)cookies = initial_response.cookies- except Exception:- logger.exception("Failed to get initial cookies")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Failed to get initial cookies ({type(e).__name__}): {safe_msg}"+ )cookies = Noneparams = {@@ -285,7 +291,7 @@ class SearXNGSearchEngine(BaseSearchEngine):}logger.info(- f"Sending request to SearXNG instance at {self.instance_url}"+ f"Sending request to SearXNG instance at {redact_url_for_log(self.instance_url)}")response = safe_get(self.search_url,@@ -371,7 +377,7 @@ class SearXNGSearchEngine(BaseSearchEngine):url = self._clean_result_url(title_element["href"])logger.debug(- f"Extracted result {idx}: title={title[:30]}..., url={url[:30]}..., content={content[:30]}..."+ f"Extracted result {idx}: title={title[:30]}..., url={redact_url_for_log(url)}, content={content[:30]}...")# Add to results only if it's a valid search result@@ -399,7 +405,7 @@ class SearXNGSearchEngine(BaseSearchEngine):except (IndexError, AttributeError):pass # Couldn't parse engine namelogger.debug(- f"Filtered invalid SearXNG result: title={title!r}, url={url!r}"+ f"Filtered invalid SearXNG result: title={title!r}, url={redact_url_for_log(url)}")if results:@@ -413,13 +419,17 @@ class SearXNGSearchEngine(BaseSearchEngine):)return results- except ImportError:+ except ImportError as e:+ safe_msg = self._scrub_error(e)logger.exception(- "BeautifulSoup not available for HTML parsing"+ f"BeautifulSoup not available for HTML parsing ({type(e).__name__}): {safe_msg}")return []- except Exception:- logger.exception("Error parsing HTML results")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error parsing HTML results ({type(e).__name__}): {safe_msg}"+ )return []else:logger.error(@@ -427,8 +437,11 @@ class SearXNGSearchEngine(BaseSearchEngine):)return []- except Exception:- logger.exception("Error getting SearXNG results")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting SearXNG results ({type(e).__name__}): {safe_msg}"+ )return []def _get_previews(self, query: str) -> List[Dict[str, Any]]:@@ -497,8 +510,11 @@ class SearXNGSearchEngine(BaseSearchEngine):try:return self.full_search._get_full_content(relevant_items)- except Exception:- logger.exception("Error retrieving full content")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error retrieving full content ({type(e).__name__}): {safe_msg}"+ )return relevant_itemsdef invoke(self, query: str) -> List[Dict[str, Any]]:@@ -611,14 +627,19 @@ https://searxng.github.io/searxng/admin/installation.html)return []- logger.info(f"SearXNG instance URL: {self.instance_url}")+ logger.info(+ f"SearXNG instance URL: {redact_url_for_log(self.instance_url)}"+ )try:# Call the parent class's run methodresults = super().run(query, research_context=research_context)logger.info(f"SearXNG search completed with {len(results)} results")return results- except Exception:- logger.exception("Error in SearXNG run method")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error in SearXNG run method ({type(e).__name__}): {safe_msg}"+ )# Return empty results on errorreturn []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_stackexchange.py b/src/local_deep_research/web_search_engines/engines/search_engine_stackexchange.pyindex ad633db4b8..973eb1620b 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_stackexchange.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_stackexchange.py@@ -7,10 +7,10 @@ from typing import Any, Dict, List, Optionalimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -323,14 +323,20 @@ class StackExchangeSearchEngine(BaseSearchEngine):previews.append(preview)- except Exception:- logger.exception("Error parsing Stack Exchange question")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error parsing Stack Exchange question ({type(e).__name__}): {safe_msg}"+ )continuereturn previewsexcept (requests.RequestException, ValueError) as e:- logger.exception("Stack Exchange API request failed")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Stack Exchange API request failed ({type(e).__name__}): {safe_msg}"+ )self._raise_if_rate_limit(e)return []@@ -476,9 +482,10 @@ class StackExchangeSearchEngine(BaseSearchEngine):return items[0] if items else Noneexcept RateLimitError:raise- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error fetching Stack Exchange question {question_id}"+ f"Error fetching Stack Exchange question {question_id} ({type(e).__name__}): {safe_msg}")return None@@ -510,9 +517,10 @@ class StackExchangeSearchEngine(BaseSearchEngine):return data.get("items", []) # type: ignore[no-any-return]except RateLimitError:raise- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Error fetching answers for question {question_id}"+ f"Error fetching answers for question {question_id} ({type(e).__name__}): {safe_msg}")return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_tinyfish.py b/src/local_deep_research/web_search_engines/engines/search_engine_tinyfish.pyindex 2b72cca5e5..a5ef5f136c 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_tinyfish.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_tinyfish.py@@ -3,9 +3,9 @@ from urllib.parse import urlparseimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...security import safe_get, safe_post+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -181,8 +181,11 @@ class TinyFishSearchEngine(BaseSearchEngine):)self._raise_request_exception_if_rate_limited(e)return []- except Exception:- logger.exception("Unexpected error getting TinyFish search results")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Unexpected error getting TinyFish search results ({type(e).__name__}): {safe_msg}"+ )return []def _get_full_content(@@ -259,7 +262,10 @@ class TinyFishSearchEngine(BaseSearchEngine):f"Error fetching TinyFish page content (status={status_code})")self._raise_request_exception_if_rate_limited(e)- except Exception:- logger.exception("Unexpected error fetching TinyFish page content")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Unexpected error fetching TinyFish page content ({type(e).__name__}): {safe_msg}"+ )return resultsdiff --git a/src/local_deep_research/web_search_engines/engines/search_engine_wayback.py b/src/local_deep_research/web_search_engines/engines/search_engine_wayback.pyindex 6e0bf78472..f22c2ec66a 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_wayback.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_wayback.py@@ -2,10 +2,11 @@ import refrom typing import Any, Dict, List, Optional, Tuplefrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...research_library.downloaders.extraction import extract_content+from ...security import redact_url_for_logfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -107,8 +108,11 @@ class WaybackSearchEngine(BaseSearchEngine):f"Found {len(ddg_urls)} URLs from DuckDuckGo search")return ddg_urls- except Exception:- logger.exception("Error using DuckDuckGo for URL discovery")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error using DuckDuckGo for URL discovery ({type(e).__name__}): {safe_msg}"+ )# Fallback: treat the query as a potential domain or pathif "/" in query and "." in query:@@ -232,8 +236,11 @@ class WaybackSearchEngine(BaseSearchEngine):except RateLimitError:# Re-raise rate limit errors for base class retry handlingraise- except Exception:- logger.exception(f"Error getting Wayback snapshots for {url}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting Wayback snapshots for {redact_url_for_log(url)} ({type(e).__name__}): {safe_msg}"+ )return snapshots@@ -289,8 +296,11 @@ class WaybackSearchEngine(BaseSearchEngine):return ""try:return extract_content(html, language=self.language) or ""- except Exception:- logger.exception("Error removing boilerplate")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error removing boilerplate ({type(e).__name__}): {safe_msg}"+ )return htmldef _get_wayback_content(self, url: str) -> Tuple[str, str]:@@ -315,8 +325,11 @@ class WaybackSearchEngine(BaseSearchEngine):return raw_html, cleaned_textexcept Exception as e:- logger.exception(f"Error retrieving content from {url}")- return "", f"Error retrieving content: {e!s}"+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error retrieving content from {redact_url_for_log(url)} ({type(e).__name__}): {safe_msg}"+ )+ return "", f"Error retrieving content: {safe_msg}"def _get_full_content(self, relevant_items: List[Dict[str, Any]]@@ -341,7 +354,9 @@ class WaybackSearchEngine(BaseSearchEngine):results.append(item)continue- logger.info(f"Retrieving content from {wayback_url}")+ logger.info(+ f"Retrieving content from {redact_url_for_log(wayback_url)}"+ )try:# Retrieve content@@ -356,8 +371,11 @@ class WaybackSearchEngine(BaseSearchEngine):# Apply rate limitingself.rate_tracker.apply_rate_limit(self.engine_type)- except Exception:- logger.exception(f"Error processing {wayback_url}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error processing {redact_url_for_log(wayback_url)} ({type(e).__name__}): {safe_msg}"+ )results.append(item)return results@@ -452,8 +470,11 @@ class WaybackSearchEngine(BaseSearchEngine):return self._get_full_content(snapshots)- except Exception:- logger.exception(f"Error searching date range for {url}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error searching date range for {redact_url_for_log(url)} ({type(e).__name__}): {safe_msg}"+ )return []def get_latest_snapshot(self, url: str) -> Optional[Dict[str, Any]]:@@ -496,6 +517,9 @@ class WaybackSearchEngine(BaseSearchEngine):return None- except Exception:- logger.exception(f"Error getting latest snapshot for {url}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting latest snapshot for {redact_url_for_log(url)} ({type(e).__name__}): {safe_msg}"+ )return Nonediff --git a/src/local_deep_research/web_search_engines/engines/search_engine_wikinews.py b/src/local_deep_research/web_search_engines/engines/search_engine_wikinews.pyindex a9946b6800..4bd5994227 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_wikinews.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_wikinews.py@@ -6,9 +6,9 @@ import htmlimport reimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENT+from ...security.secure_logging import loggerfrom ...utilities.json_utils import extract_json, get_llm_response_textfrom ...utilities.search_utilities import remove_think_tags, LANGUAGE_CODE_MAPfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -248,10 +248,11 @@ Respond with ONE WORD ONLY: CURRENT, HISTORICAL, or UNCLEAR"""f"Query '{query}' classified as UNCLEAR - keeping original date range")- except (AttributeError, TypeError, ValueError, RuntimeError):+ except (AttributeError, TypeError, ValueError, RuntimeError) as e:# Keep original date parameters on error+ safe_msg = self._scrub_error(e)logger.exception(- "Error adapting date range for query: . Keeping original date range."+ f"Error adapting date range for query '{query}' ({type(e).__name__}): keeping original date range: {safe_msg}")def _fetch_search_results(diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_wikipedia.py b/src/local_deep_research/web_search_engines/engines/search_engine_wikipedia.pyindex 7b8a3f2a97..b45aaa61b5 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_wikipedia.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_wikipedia.py@@ -4,9 +4,9 @@ from typing import Any, Dict, List, Optionalimport requestsimport wikipediafrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity+from ...security.secure_logging import logger# Wikipedia / MediaWiki returns a non-JSON HTML body with HTTP 429 when a@@ -135,8 +135,9 @@ class WikipediaSearchEngine(BaseSearchEngine):)title = e.options[0] # Use the new titleexcept Exception as inner_e:+ safe_msg = self._scrub_error(inner_e)logger.exception(- f"Error with disambiguation option: {inner_e}"+ f"Error with disambiguation option ({type(inner_e).__name__}): {safe_msg}")continueelse:@@ -175,8 +176,11 @@ class WikipediaSearchEngine(BaseSearchEngine):len(previews),)break- except Exception:- logger.exception(f"Unexpected error for '{title}'")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Unexpected error for '{title}' ({type(e).__name__}): {safe_msg}"+ )continuelogger.info(@@ -193,8 +197,11 @@ class WikipediaSearchEngine(BaseSearchEngine):query,)return []- except Exception:- logger.exception("Error getting Wikipedia previews")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error getting Wikipedia previews ({type(e).__name__}): {safe_msg}"+ )return []def _get_full_content(@@ -257,9 +264,10 @@ class WikipediaSearchEngine(BaseSearchEngine):# If error, use the previewlogger.warning(f"Error getting full content for '{title}'")results.append(item)- except Exception:+ except Exception as e:+ safe_msg = self._scrub_error(e)logger.exception(- f"Unexpected error getting full content for '{title}'"+ f"Unexpected error getting full content for '{title}' ({type(e).__name__}): {safe_msg}")results.append(item)diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_zenodo.py b/src/local_deep_research/web_search_engines/engines/search_engine_zenodo.pyindex 826a82f3de..4dd948315b 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_zenodo.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_zenodo.py@@ -6,10 +6,10 @@ from typing import Any, Dict, List, Optionalimport requestsfrom langchain_core.language_models import BaseLLM-from loguru import loggerfrom ...constants import USER_AGENTfrom ...security.safe_requests import safe_get+from ...security.secure_logging import loggerfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine, Exposure, Sensitivity@@ -243,14 +243,20 @@ class ZenodoSearchEngine(BaseSearchEngine):previews.append(preview)- except Exception:- logger.exception("Error parsing Zenodo record")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error parsing Zenodo record ({type(e).__name__}): {safe_msg}"+ )continuereturn previewsexcept (requests.RequestException, ValueError) as e:- logger.exception("Zenodo API request failed")+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Zenodo API request failed ({type(e).__name__}): {safe_msg}"+ )self._raise_if_rate_limit(e)return []@@ -359,8 +365,11 @@ class ZenodoSearchEngine(BaseSearchEngine):return response.json() # type: ignore[no-any-return]except RateLimitError:raise- except Exception:- logger.exception(f"Error fetching Zenodo record {record_id}")+ except Exception as e:+ safe_msg = self._scrub_error(e)+ logger.exception(+ f"Error fetching Zenodo record {record_id} ({type(e).__name__}): {safe_msg}"+ )return Nonedef search_datasets(self, query: str) -> List[Dict[str, Any]]:diff --git a/src/local_deep_research/web_search_engines/relevance_filter.py b/src/local_deep_research/web_search_engines/relevance_filter.pyindex 1656511c41..1f62bd0956 100644--- a/src/local_deep_research/web_search_engines/relevance_filter.py+++ b/src/local_deep_research/web_search_engines/relevance_filter.py@@ -36,11 +36,11 @@ from concurrent.futures import (from datetime import UTC, datetimefrom typing import Any, Dict, List, Optional-from loguru import logger-from langchain_ollama import ChatOllamafrom ..config.constants import DEFAULT_MAX_FILTERED_RESULTS+from ..security.log_sanitizer import redact_secrets, sanitize_error_message+from ..security.secure_logging import logger# Real wrapper chains (RateLimitedLLMWrapper -> ProcessingLLMWrapper -> base)# are at most 2-3 levels deep. A depth limit avoids spurious infinite chains@@ -239,9 +239,10 @@ def filter_previews_for_relevance(engine_name,prompt_template,)- except Exception:+ except Exception as e:+ safe_msg = redact_secrets(sanitize_error_message(str(e)))logger.exception(- f"[{engine_name}] batch {i} failed — skipping its results"+ f"[{engine_name}] batch {i} failed — skipping its results ({type(e).__name__}): {safe_msg}")else:# Not using ``with ThreadPoolExecutor(...) as pool:`` on purpose.@@ -273,9 +274,12 @@ def filter_previews_for_relevance(i = futures_to_idx[fut]try:results_per_batch[i] = fut.result()- except Exception:+ except Exception as e:+ safe_msg = redact_secrets(+ sanitize_error_message(str(e))+ )logger.exception(- f"[{engine_name}] batch {i} failed — skipping"+ f"[{engine_name}] batch {i} failed — skipping ({type(e).__name__}): {safe_msg}")except FuturesTimeoutError:pending = [diff --git a/src/local_deep_research/web_search_engines/search_engine_factory.py b/src/local_deep_research/web_search_engines/search_engine_factory.pyindex 6958717279..7519c9b606 100644--- a/src/local_deep_research/web_search_engines/search_engine_factory.py+++ b/src/local_deep_research/web_search_engines/search_engine_factory.py@@ -1,10 +1,10 @@import inspectfrom typing import Any, Dict, Optional-from loguru import logger-from ..security.egress.policy import PolicyDeniedError+from ..security.log_sanitizer import redact_secrets, sanitize_error_messagefrom ..security.module_whitelist import get_safe_module_class+from ..security.secure_logging import loggerfrom .retriever_registry import retriever_registryfrom .search_engine_base import BaseSearchEnginefrom .search_engines_config import search_config@@ -259,9 +259,13 @@ def create_search_engine(# Check for API key requirementsrequires_api_key = engine_config.get("requires_api_key", False)+ # Bound here (not just inside ``if requires_api_key``) so the except+ # handler below can pass the in-scope key to redact_secrets() — without+ # the hoist, the no-key path would hit a NameError when scrubbing.+ api_key = None+if requires_api_key:# Check the settings snapshot for the API key- api_key = Noneapi_key_path = f"search.engine.web.{engine_name}.api_key"if settings_snapshot:@@ -464,8 +468,13 @@ def create_search_engine(# rather than being downgraded to a generic "failed to create"# None — which would fail OPEN from an enforcement standpoint.raise- except Exception:- logger.exception(f"Failed to create search engine '{engine_name}'")+ except Exception as e:+ safe_msg = redact_secrets(+ sanitize_error_message(str(e)), api_key and str(api_key)+ )+ logger.exception(+ f"Failed to create search engine '{engine_name}' ({type(e).__name__}): {safe_msg}"+ )return None@@ -480,6 +489,12 @@ def _create_full_search_wrapper() -> Optional[BaseSearchEngine]:"""Create a full search wrapper for the base engine if supported"""try:+ # Bound up here (re-populated below) so the except handler can+ # always pull credential values out of it for redact_secrets() —+ # without the hoist, an exception before the dict is rebuilt would+ # hit a NameError when trying to scrub the keys.+ wrapper_params: Dict[str, Any] = {}+# Get full search class details from engine_config (already has# registry-injected values from search_config()).module_path = engine_config.get("full_search_module")@@ -593,9 +608,22 @@ def _create_full_search_wrapper(service: BaseSearchEngine = full_search_class(**wrapper_params)return service- except Exception:+ except Exception as e:+ # Extract any credential values the wrapper was going to receive+ # so a constructor exception echoing them gets literal-redacted.+ wrapper_secrets = [+ v+ for v in (+ wrapper_params.get("api_key"),+ wrapper_params.get("serpapi_api_key"),+ )+ if isinstance(v, str) and v+ ]+ safe_msg = redact_secrets(+ sanitize_error_message(str(e)), *wrapper_secrets+ )logger.exception(- f"Failed to create full search wrapper for {engine_name}"+ f"Failed to create full search wrapper for {engine_name} ({type(e).__name__}): {safe_msg}")return base_enginediff --git a/tests/security/test_factory_secret_redaction.py b/tests/security/test_factory_secret_redaction.pynew file mode 100644index 0000000000..093d440980--- /dev/null+++ b/tests/security/test_factory_secret_redaction.py@@ -0,0 +1,266 @@+"""Regression tests for in-scope API-key redaction in factory exception logs.++A third-party review of issue #4183 found that ``create_search_engine`` and+``_create_full_search_wrapper`` called ``redact_secrets(str(e))`` with NO+secret arguments. ``redact_secrets`` does literal-substring replacement, so+with an empty secret list it's a no-op: an exception message echoing the+API key (e.g. a constructor validation error) survived into logs verbatim.++The fix passes the in-scope key(s) — ``api_key`` in ``create_search_engine``,+and ``api_key`` / ``serpapi_api_key`` from ``wrapper_params`` in+``_create_full_search_wrapper`` — and wraps with ``sanitize_error_message``+for the shape-based pass too.++These tests use a credential with NO distinctive prefix (not ``sk-``, not+``AIza``, etc.) so that ``sanitize_error_message``'s regexes won't catch it+on shape alone — proving the literal-substring pass is what closes the leak.++The factory logs these failures via the diagnose-gated+``security.secure_logging`` wrapper at ERROR level; the levelname+assertions below guard against a re-downgrade to WARNING.+"""++from unittest.mock import Mock, patch++import pytest++from local_deep_research.web_search_engines.search_engine_factory import (+ _create_full_search_wrapper,+)++FACTORY_MODULE = "local_deep_research.web_search_engines.search_engine_factory"++# 24 chars, no sk-/pk-/AIza/ghp_ prefix — survives sanitize_error_message,+# so only the literal redact_secrets(..., api_key) pass catches it.+_BARE_KEY = "test-brave-key-XYZ789"+++class _RaisingWrapperBrave:+ """Mock full-search wrapper whose init echoes the brave api_key."""++ def __init__(self, api_key=None, **kwargs):+ raise ValueError(f"Brave wrapper rejected key: {api_key}")+++class _RaisingWrapperSerpAPI:+ """Mock full-search wrapper whose init echoes the serpapi key."""++ def __init__(self, serpapi_api_key=None, **kwargs):+ raise ValueError(f"SerpAPI wrapper rejected key: {serpapi_api_key}")++[email protected](autouse=True)+def _bypass_engine_pdp():+ """Bypass the egress PEP so mock engine names aren't rejected.++ The PEP itself is exercised in tests/security/test_egress_policy.py.+ """+ from local_deep_research.security.egress.policy import Decision++ with (+ patch(+ "local_deep_research.security.egress.policy.evaluate_engine",+ return_value=Decision(True, "test_bypass"),+ ),+ patch(+ "local_deep_research.security.egress.policy.evaluate_retriever",+ return_value=Decision(True, "test_bypass"),+ ),+ ):+ yield+++class TestCreateSearchEngineRedactsApiKey:+ def test_constructor_exception_does_not_leak_api_key(self, loguru_caplog):+ """``api_key`` resolved from settings must be literal-redacted."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ class _RaisingEngine:+ def __init__(self, api_key=None, **kwargs):+ raise ValueError(f"Bad key received: {api_key}")++ settings_snapshot = {+ "search.engine.web.test_engine.api_key": {"value": _BARE_KEY}+ }++ with (+ patch(f"{FACTORY_MODULE}.retriever_registry") as mock_registry,+ patch(f"{FACTORY_MODULE}.search_config") as mock_config,+ patch(+ f"{FACTORY_MODULE}.get_safe_module_class",+ return_value=_RaisingEngine,+ ),+ ):+ mock_registry.get.return_value = None+ mock_config.return_value = {+ "test_engine": {+ "module_path": ".engines.test",+ "class_name": "TestEngine",+ "requires_api_key": True,+ }+ }+ with loguru_caplog.at_level("ERROR"):+ result = create_search_engine(+ engine_name="test_engine",+ settings_snapshot=settings_snapshot,+ )++ assert result is None+ assert _BARE_KEY not in loguru_caplog.text+ assert "Bad key received" in loguru_caplog.text+ assert "***REDACTED***" in loguru_caplog.text+ # Regression guard: the factory failure must stay at ERROR, not be+ # re-downgraded to WARNING. Filter by message so an unrelated+ # record can't satisfy (or break) the assertion.+ matching = [+ r+ for r in loguru_caplog.records+ if "Bad key received" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)+++class TestCreateFullSearchWrapperRedactsKeys:+ def test_brave_wrapper_exception_does_not_leak_api_key(self, loguru_caplog):+ base_engine = Mock()+ engine_config = {+ "full_search_module": ".engines.full_search",+ "full_search_class": "FullSearchResults",+ }+ settings_snapshot = {+ "search.engine.web.brave.api_key": {"value": _BARE_KEY}+ }++ with patch(+ f"{FACTORY_MODULE}.get_safe_module_class",+ return_value=_RaisingWrapperBrave,+ ):+ with loguru_caplog.at_level("ERROR"):+ result = _create_full_search_wrapper(+ "brave",+ base_engine,+ engine_config,+ Mock(),+ {},+ settings_snapshot=settings_snapshot,+ )++ assert result is base_engine+ assert _BARE_KEY not in loguru_caplog.text+ assert "Brave wrapper rejected key" in loguru_caplog.text+ assert "***REDACTED***" in loguru_caplog.text+ matching = [+ r+ for r in loguru_caplog.records+ if "Brave wrapper rejected key" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)++ def test_serpapi_wrapper_exception_does_not_leak_key(self, loguru_caplog):+ base_engine = Mock()+ engine_config = {+ "full_search_module": ".engines.full_search",+ "full_search_class": "FullSearchResults",+ }+ settings_snapshot = {+ "search.engine.web.serpapi.api_key": {"value": _BARE_KEY}+ }++ with patch(+ f"{FACTORY_MODULE}.get_safe_module_class",+ return_value=_RaisingWrapperSerpAPI,+ ):+ with loguru_caplog.at_level("ERROR"):+ result = _create_full_search_wrapper(+ "serpapi",+ base_engine,+ engine_config,+ Mock(),+ {},+ settings_snapshot=settings_snapshot,+ )++ assert result is base_engine+ assert _BARE_KEY not in loguru_caplog.text+ assert "SerpAPI wrapper rejected key" in loguru_caplog.text+ assert "***REDACTED***" in loguru_caplog.text+ matching = [+ r+ for r in loguru_caplog.records+ if "SerpAPI wrapper rejected key" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)+++class TestHoistedApiKeyHandlesNoKeyRequiredEngines:+ def test_no_key_required_engine_exception_does_not_nameerror(+ self, loguru_caplog+ ):+ """``api_key = None`` hoist must keep the scrub call safe on the+ no-key path.++ Before the hoist, ``api_key`` was only bound inside+ ``if requires_api_key:``. The except handler at the end of+ ``create_search_engine`` references ``api_key`` unconditionally —+ so a constructor exception for a ``requires_api_key=False`` engine+ would have raised ``NameError`` instead of logging the fallback+ error. This test pins the hoist: the error log fires and the+ engine returns ``None``.+ """++ class _RaisingEngineNoKey:+ def __init__(self, **kwargs):+ raise RuntimeError("engine init blew up")++ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ # Non-empty snapshot — the factory rejects empty/falsy snapshots in+ # thread context. The engine_config mock below is what actually+ # drives the requires_api_key=False path; the snapshot just needs to+ # be truthy to clear the thread-context guard.+ settings_snapshot = {"_test_marker": True}+ with (+ patch(f"{FACTORY_MODULE}.retriever_registry") as mock_registry,+ patch(f"{FACTORY_MODULE}.search_config") as mock_config,+ patch(+ f"{FACTORY_MODULE}.get_safe_module_class",+ return_value=_RaisingEngineNoKey,+ ),+ ):+ mock_registry.get.return_value = None+ mock_config.return_value = {+ "test_engine_no_key": {+ "module_path": ".engines.test",+ "class_name": "TestEngineNoKey",+ "requires_api_key": False,+ }+ }+ with loguru_caplog.at_level("ERROR"):+ result = create_search_engine(+ engine_name="test_engine_no_key",+ settings_snapshot=settings_snapshot,+ )++ assert result is None+ # The error log fired (no NameError swallowed it) and carries the+ # exception message — tie them together so the assertion can't+ # false-pass on an unrelated ERROR line.+ assert any(+ "Failed to create search engine" in line+ and "engine init blew up" in line+ for line in loguru_caplog.text.splitlines()+ )+ matching = [+ r+ for r in loguru_caplog.records+ if "engine init blew up" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)diff --git a/tests/security/test_secure_logging.py b/tests/security/test_secure_logging.pynew file mode 100644index 0000000000..f396769151--- /dev/null+++ b/tests/security/test_secure_logging.py@@ -0,0 +1,214 @@+"""Tests for the diagnose-gated ``SecureLogger`` wrapper.++``security.secure_logging.logger.exception()`` must log at ERROR level+while attaching the active exception to the record ONLY when both+``LDR_APP_DEBUG`` and ``LDR_LOGURU_DIAGNOSE`` are truthy. With the+exception stripped, no sink can render the traceback or the+``__cause__`` chain — the #4183 leak class (headers/URLs embedded in+wrapped exceptions) cannot reach any log output.+"""++import pytest++from local_deep_research.security.secure_logging import (+ SecureLogger,+ env_truthy,+ is_diagnose_mode,+ logger,+)++_DEBUG_VAR = "LDR_APP_DEBUG"+_DIAGNOSE_VAR = "LDR_LOGURU_DIAGNOSE"+++def _set_env(monkeypatch, debug, diagnose):+ """Set/unset both gating vars. ``None`` means unset."""+ for var, value in ((_DEBUG_VAR, debug), (_DIAGNOSE_VAR, diagnose)):+ if value is None:+ monkeypatch.delenv(var, raising=False)+ else:+ monkeypatch.setenv(var, value)+++def _log_wrapped_exception(message="request failed: scrubbed"):+ """Log *message* from inside a handler for a cause-chained exception.++ The inner ``ValueError`` carries a fake credential — the same shape+ as the #4183 leak, where the secret lived only in the ``__cause__``+ chain, not in the logged message.+ """+ try:+ try:+ raise ValueError("api_key=sk-LEAK-0123456789abcdef")+ except ValueError as inner:+ raise RuntimeError("wrapped") from inner+ except RuntimeError:+ logger.exception(message)+++class TestEnvTruthy:+ @pytest.mark.parametrize("value", ["1", "true", "TRUE", "yes", " YES "])+ def test_truthy_values(self, monkeypatch, value):+ monkeypatch.setenv(_DEBUG_VAR, value)+ assert env_truthy(_DEBUG_VAR) is True++ @pytest.mark.parametrize("value", ["", "0", "false", "no", "on", "2"])+ def test_falsy_values(self, monkeypatch, value):+ monkeypatch.setenv(_DEBUG_VAR, value)+ assert env_truthy(_DEBUG_VAR) is False++ def test_unset_is_falsy(self, monkeypatch):+ monkeypatch.delenv(_DEBUG_VAR, raising=False)+ assert env_truthy(_DEBUG_VAR) is False+++class TestIsDiagnoseMode:+ @pytest.mark.parametrize(+ ("debug", "diagnose", "expected"),+ [+ (None, None, False),+ ("1", None, False),+ (None, "1", False),+ ("0", "1", False),+ ("1", "0", False),+ ("1", "1", True),+ ("true", "yes", True),+ ("YES ", "TRUE", True),+ ],+ )+ def test_truth_table(self, monkeypatch, debug, diagnose, expected):+ _set_env(monkeypatch, debug, diagnose)+ assert is_diagnose_mode() is expected+++class TestExceptionDefaultMode:+ """Both flags unset — production behaviour."""++ def test_logs_at_error_level_without_traceback(+ self, monkeypatch, loguru_caplog_full+ ):+ _set_env(monkeypatch, None, None)+ with loguru_caplog_full.at_level("ERROR"):+ _log_wrapped_exception()++ records = [+ r+ for r in loguru_caplog_full.records+ if "request failed: scrubbed" in r.getMessage()+ ]+ assert records, "the event must still be logged"+ assert all(r.levelname == "ERROR" for r in records)+ assert all(r.exc_info is None for r in records)+ assert "Traceback" not in loguru_caplog_full.text++ def test_cause_chain_secret_never_reaches_output(+ self, monkeypatch, loguru_caplog_full+ ):+ """#4183 regression: the fixture renders ``{exception}`` with+ ``backtrace=True``, so if the exception were attached the+ ``__cause__`` chain (holding the credential) WOULD appear here."""+ _set_env(monkeypatch, None, None)+ with loguru_caplog_full.at_level("ERROR"):+ _log_wrapped_exception()++ assert "request failed: scrubbed" in loguru_caplog_full.text+ assert "sk-LEAK" not in loguru_caplog_full.text+ assert "api_key" not in loguru_caplog_full.text++ @pytest.mark.parametrize(+ ("debug", "diagnose"),+ [("1", None), (None, "1"), ("1", "0"), ("0", "1")],+ )+ def test_single_flag_does_not_enable_traceback(+ self, monkeypatch, loguru_caplog_full, debug, diagnose+ ):+ _set_env(monkeypatch, debug, diagnose)+ with loguru_caplog_full.at_level("ERROR"):+ _log_wrapped_exception()++ assert "request failed: scrubbed" in loguru_caplog_full.text+ assert "Traceback" not in loguru_caplog_full.text+ assert "sk-LEAK" not in loguru_caplog_full.text+++class TestExceptionDiagnoseMode:+ def test_both_flags_render_traceback(self, monkeypatch, loguru_caplog_full):+ _set_env(monkeypatch, "1", "1")+ with loguru_caplog_full.at_level("ERROR"):+ _log_wrapped_exception()++ records = [+ r+ for r in loguru_caplog_full.records+ if "request failed: scrubbed" in r.getMessage()+ ]+ assert records+ assert all(r.levelname == "ERROR" for r in records)+ assert "Traceback" in loguru_caplog_full.text+ assert "RuntimeError" in loguru_caplog_full.text+++class TestRecordAttribution:+ def test_record_points_at_caller_not_wrapper(self, monkeypatch):+ """``depth=1`` must attribute the record to the calling module so+ log locations stay useful and ``logger.disable()`` namespacing+ keys off the caller, not ``secure_logging``."""+ _set_env(monkeypatch, None, None)+ captured = []+ handler_id = logger.add(+ lambda message: captured.append(message.record),+ format="{message}",+ level="ERROR",+ )+ try:+ try:+ raise RuntimeError("boom")+ except RuntimeError:+ logger.exception("attribution check")+ finally:+ logger.remove(handler_id)++ records = [r for r in captured if r["message"] == "attribution check"]+ assert records+ record = records[-1]+ assert record["module"] == "test_secure_logging"+ assert record["function"] == "test_record_points_at_caller_not_wrapper"+ assert record["exception"] is None+++class TestWrapperChaining:+ def test_bind_keeps_gated_exception(self, monkeypatch, loguru_caplog_full):+ _set_env(monkeypatch, None, None)+ bound = logger.bind(component="test")+ assert isinstance(bound, SecureLogger)+ with loguru_caplog_full.at_level("ERROR"):+ try:+ try:+ raise ValueError("api_key=sk-LEAK-0123456789abcdef")+ except ValueError as inner:+ raise RuntimeError("wrapped") from inner+ except RuntimeError:+ bound.exception("bound scrubbed message")++ assert "bound scrubbed message" in loguru_caplog_full.text+ assert "Traceback" not in loguru_caplog_full.text+ assert "sk-LEAK" not in loguru_caplog_full.text++ def test_patch_returns_wrapper(self):+ patched = logger.patch(lambda record: None)+ assert isinstance(patched, SecureLogger)++ def test_no_active_exception_does_not_raise(+ self, monkeypatch, loguru_caplog_full+ ):+ _set_env(monkeypatch, None, None)+ with loguru_caplog_full.at_level("ERROR"):+ logger.exception("called outside except block")+ assert "called outside except block" in loguru_caplog_full.text++ def test_delegates_other_methods_to_loguru(+ self, monkeypatch, loguru_caplog_full+ ):+ with loguru_caplog_full.at_level("INFO"):+ logger.info("plain info via wrapper")+ assert "plain info via wrapper" in loguru_caplog_full.textdiff --git a/tests/security/test_url_context_redaction.py b/tests/security/test_url_context_redaction.pynew file mode 100644index 0000000000..a5ab61781e--- /dev/null+++ b/tests/security/test_url_context_redaction.py@@ -0,0 +1,246 @@+"""Regression tests for URL-context redaction in engine log lines.++Comparison review of issue #4183 found that even after ``_scrub_error(e)``+scrubs the exception message, the URL interpolated into the *same* log line+(``url``, ``wayback_url``, ``self.instance_url``) was written to logs raw.+URLs can carry HTTP basic-auth userinfo (``https://user:pass@host``) or+credential-bearing query params (``?api_key=...``), both of which leaked.++These tests pin the fix: every URL interpolation in a log line goes through+``redact_url_for_log`` so only ``scheme://host:port`` reaches the log sink.++Uses ``loguru_caplog`` (not ``loguru_caplog_full``) because these engines+log exceptions through the diagnose-gated ``security.secure_logging``+wrapper: at ERROR level, but with no exception attached to the record+outside diagnose mode — so there is no rendered exception block to+capture, only the formatted message. (The wrapper's own gating is pinned+in ``test_secure_logging.py``.) The levelname assertions guard against a+re-downgrade to WARNING.+"""++from unittest.mock import Mock, patch++import requests++from local_deep_research.web_search_engines.engines.search_engine_paperless import (+ PaperlessSearchEngine,+)+from local_deep_research.web_search_engines.engines.search_engine_searxng import (+ SearXNGSearchEngine,+)+from local_deep_research.web_search_engines.engines.search_engine_wayback import (+ WaybackSearchEngine,+)++WAYBACK_MODULE = (+ "local_deep_research.web_search_engines.engines.search_engine_wayback"+)+SEARXNG_MODULE = (+ "local_deep_research.web_search_engines.engines.search_engine_searxng"+)+PAPERLESS_MODULE = (+ "local_deep_research.web_search_engines.engines.search_engine_paperless"+)+OLLAMA_MODULE = (+ "local_deep_research.embeddings.providers.implementations.ollama"+)+++def _mock_response(status=200, json_body=None, text=""):+ resp = Mock()+ resp.status_code = status+ resp.json.return_value = json_body if json_body is not None else {}+ resp.text = text+ return resp+++class TestWaybackUrlRedaction:+ def test_snapshots_warning_redacts_userinfo(self, loguru_caplog):+ """``url`` with ``user:pass@`` must not leak the password."""+ engine = WaybackSearchEngine()+ cred_url = "https://user:[email protected]/page"+ with patch(f"{WAYBACK_MODULE}.safe_get", side_effect=OSError("boom")):+ with loguru_caplog.at_level("ERROR"):+ engine._get_wayback_snapshots(cred_url)+ assert "hunter2" not in loguru_caplog.text+ assert "user:hunter2@" not in loguru_caplog.text+ # The error log fired AND carries the redacted form — tie the two+ # together so the assertion can't false-pass on an unrelated log line+ # that happens to mention the host.+ assert any(+ "Error getting Wayback snapshots for" in line+ and "https://example.com" in line+ for line in loguru_caplog.text.splitlines()+ )+ matching = [+ r+ for r in loguru_caplog.records+ if "Error getting Wayback snapshots for" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)++ def test_snapshots_warning_redacts_query_token(self, loguru_caplog):+ """Line 236: credential-bearing query params must not leak."""+ engine = WaybackSearchEngine()+ cred_url = "https://example.com/page?api_key=xyz12345abcde"+ with patch(f"{WAYBACK_MODULE}.safe_get", side_effect=OSError("boom")):+ with loguru_caplog.at_level("ERROR"):+ engine._get_wayback_snapshots(cred_url)+ assert "xyz12345abcde" not in loguru_caplog.text+ assert "api_key=" not in loguru_caplog.text++ def test_full_content_redacts_wayback_url(self, loguru_caplog):+ """``wayback_url`` carrying embedded creds must not leak.++ Covers the info log on the happy path ("Retrieving content from …")+ and the error log when ``_get_wayback_content`` then raises ("Error+ processing …"). The wayback_url embeds the original target in its+ path; if that target had basic-auth userinfo, the raw log line+ would leak it.+ """+ engine = WaybackSearchEngine()+ cred_wayback_url = (+ "https://web.archive.org/web/20240101/"+ "https://user:[email protected]/page"+ )+ items = [{"link": cred_wayback_url, "title": "X"}]+ with patch(f"{WAYBACK_MODULE}.safe_get", side_effect=OSError("boom")):+ with loguru_caplog.at_level("INFO"):+ engine._get_full_content(items)+ assert "hunter2" not in loguru_caplog.text+ assert "user:hunter2@" not in loguru_caplog.text+ matching = [+ r+ for r in loguru_caplog.records+ if "Error retrieving content from" in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)+++class TestSearXNGUrlRedaction:+ def test_init_redacts_basic_auth_instance_url(self, loguru_caplog):+ """All ``self.instance_url`` log sites must redact basic-auth creds.++ Self-hosted SearXNG behind HTTP basic auth is a common deployment+ (``https://user:pass@host``); the init path logs the instance URL at+ info, and on connection failure the warning fires with it too.+ """+ cred_url = "https://admin:[email protected]"+ with patch(+ f"{SEARXNG_MODULE}.safe_get",+ side_effect=requests.ConnectionError("nope"),+ ):+ with loguru_caplog.at_level("INFO"):+ SearXNGSearchEngine(instance_url=cred_url)+ assert "s3cret-pw" not in loguru_caplog.text+ assert "admin:s3cret-pw@" not in loguru_caplog.text+ # The connection-failure error log fired AND carries the redacted+ # host — tie the two together so the assertion can't false-pass on+ # the init info log alone.+ assert any(+ "Error while trying to access SearXNG instance at" in line+ and "searxng.example.com" in line+ for line in loguru_caplog.text.splitlines()+ )+ matching = [+ r+ for r in loguru_caplog.records+ if "Error while trying to access SearXNG instance at"+ in r.getMessage()+ ]+ assert matching+ assert all(r.levelname == "ERROR" for r in matching)++ def test_debug_logs_redact_scraped_result_url(self, loguru_caplog):+ """Result-href debug logs (extracted + filtered) must redact too.++ Scraped result hrefs come from the internet, not operator config, so+ the leak vector is a malicious result with a credential-bearing URL —+ lower severity than the instance_url vector but same leak class.+ """+ cred_result_url = "https://user:[email protected]/path"+ # Build a result element whose href carries basic-auth creds. The+ # ``_is_valid_search_result`` check rejects URLs starting with the+ # instance URL, so use an instance URL that doesn't prefix-match.+ html = (+ '<html><body><article class="result">'+ f'<a class="result-title" href="{cred_result_url}">title</a>'+ '<a class="result-url" href="{cred}">link</a>'+ '<div class="result-content">snippet</div>'+ "</article></body></html>"+ ).format(cred=cred_result_url)+ resp = _mock_response(status=200, text=html)+ with patch(f"{SEARXNG_MODULE}.safe_get", return_value=resp):+ engine = SearXNGSearchEngine(+ instance_url="http://searxng-invalid-host-99999.local:8080",+ )+ engine.is_available = True+ engine.search_url = (+ "http://searxng-invalid-host-99999.local:8080/search"+ )+ with loguru_caplog.at_level("DEBUG"):+ engine._get_search_results("anything")+ assert "hunter2" not in loguru_caplog.text+ assert "user:hunter2@" not in loguru_caplog.text+++class TestPaperlessUrlRedaction:+ """Paperless-ngx ``api_url`` carries HTTP basic-auth creds in many+ self-hosted deployments (``https://user:pass@host``). Every log site+ that interpolates it — init info, per-request debug, failed-request+ debug — must go through ``redact_url_for_log``."""++ def test_init_and_request_logs_redact_basic_auth(self, loguru_caplog):+ cred_url = "https://admin:[email protected]"+ with (+ patch(f"{PAPERLESS_MODULE}.safe_get") as mock_get,+ patch(f"{PAPERLESS_MODULE}.requests.get") as mock_requests_get,+ ):+ mock_get.side_effect = requests.ConnectionError("nope")+ mock_requests_get.side_effect = requests.ConnectionError("nope")+ with loguru_caplog.at_level("DEBUG"):+ engine = PaperlessSearchEngine(api_url=cred_url, api_key="x")+ engine._make_request("/api/documents/")++ assert "s3cret-pw" not in loguru_caplog.text+ assert "admin:s3cret-pw@" not in loguru_caplog.text+ # The init info log fired AND carries the redacted host — tie them+ # together so the assertion can't false-pass on an unrelated log.+ assert any(+ "Initialized Paperless-ngx search engine for" in line+ and "paperless.example.com" in line+ for line in loguru_caplog.text.splitlines()+ )+ # The per-request debug log also fired with the redacted URL.+ assert any(+ "Making request to:" in line and "paperless.example.com" in line+ for line in loguru_caplog.text.splitlines()+ )+++class TestOllamaBaseUrlRedaction:+ """Ollama ``base_url`` is operator-configured (settings/env) and may+ sit behind a reverse proxy with HTTP basic auth. The init info log+ that announces the resolved base_url must redact it."""++ def test_create_embeddings_info_redacts_basic_auth(self, loguru_caplog):+ cred_url = "https://user:[email protected]"+ with patch(f"{OLLAMA_MODULE}.OllamaEmbeddings") as mock_inner:+ mock_inner.return_value = Mock()+ from local_deep_research.embeddings.providers.implementations.ollama import (+ OllamaEmbeddingsProvider,+ )++ with loguru_caplog.at_level("INFO"):+ OllamaEmbeddingsProvider.create_embeddings(+ model="nomic-embed-text", base_url=cred_url+ )+ assert "hunter2" not in loguru_caplog.text+ assert "user:hunter2@" not in loguru_caplog.text+ assert any(+ "Creating OllamaEmbeddings with model=" in line+ and "ollama.example.com" in line+ for line in loguru_caplog.text.splitlines()+ )diff --git a/tests/web/test_app_factory_middleware.py b/tests/web/test_app_factory_middleware.pyindex c1f2bd4c01..11139e7d84 100644--- a/tests/web/test_app_factory_middleware.py+++ b/tests/web/test_app_factory_middleware.py@@ -50,31 +50,24 @@ class TestIsPrivateIp:"""Unit tests for security.network_utils.is_private_ip."""def test_loopback_ipv4(self):-assert is_private_ip("127.0.0.1") is Truedef test_loopback_ipv6(self):-assert is_private_ip("::1") is Truedef test_class_a_private(self):-assert is_private_ip("10.0.0.1") is Truedef test_class_b_private(self):-assert is_private_ip("172.16.0.1") is Truedef test_class_c_private(self):-assert is_private_ip("192.168.1.1") is Truedef test_public_google_dns(self):-assert is_private_ip("8.8.8.8") is Falsedef test_public_cloudflare_dns(self):-assert is_private_ip("1.1.1.1") is Falsedef test_public_documentation_range(self):@@ -88,24 +81,19 @@ class TestIsPrivateIp:assert result == (ip.is_private or ip.is_loopback)def test_invalid_string(self):-assert is_private_ip("not-an-ip") is Falsedef test_empty_string(self):-assert is_private_ip("") is Falsedef test_invalid_octet_values(self):-assert is_private_ip("256.256.256.256") is Falsedef test_ipv6_private(self):-# fc00::/7 is unique local address (private)assert is_private_ip("fc00::1") is Truedef test_ipv6_public(self):-# 2001:4860:4860::8888 is Google Public DNS IPv6assert is_private_ip("2001:4860:4860::8888") is False