~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
"""Token telemetry must respect an enclosing worker's SQLite transaction."""
from __future__ import annotations
from concurrent.futures import ThreadPoolExecutor
from unittest.mock import patch
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from local_deep_research.database.encrypted_db import db_manager
from local_deep_research.database.models import (
Base,
ModelUsage,
SearchCall,
TokenUsage,
)
from local_deep_research.database.session_context import get_user_db_session
from local_deep_research.database.thread_local_session import (
cleanup_current_thread,
thread_session_manager,
)
from local_deep_research.database.thread_metrics import metrics_writer
from local_deep_research.metrics.token_counter import TokenCountingCallback
@pytest.fixture
def sqlite_metrics(tmp_path, monkeypatch):
"""Route only session provisioning to a file-backed WAL database."""
engine = create_engine(
f"sqlite:///{tmp_path / 'token_metrics.db'}",
connect_args={"timeout": 0.05, "check_same_thread": False},
)
with engine.connect() as connection:
assert (
connection.exec_driver_sql("PRAGMA journal_mode=WAL").scalar()
== "wal"
)
Base.metadata.create_all(engine)
session_factory = sessionmaker(bind=engine)
created_for = []
def create_session(username, _password):
created_for.append(username)
return session_factory()
monkeypatch.setattr(db_manager, "open_user_database", lambda *_: engine)
monkeypatch.setattr(
db_manager, "create_thread_safe_session_for_metrics", create_session
)
try:
yield session_factory, created_for
finally:
engine.dispose()
def _callback(owner="alice"):
callback = TokenCountingCallback(
research_id="research-1",
research_context={
"username": owner,
"user_password": "test-password",
"research_query": "transaction test",
},
)
callback.current_model = "test-model"
callback.current_provider = "test-provider"
return callback
def _run_worker(action):
def work():
try:
return action()
finally:
cleanup_current_thread()
with ThreadPoolExecutor(max_workers=1) as executor:
return executor.submit(work).result(timeout=10)
@pytest.fixture(params=["worker", "main"])
def run_callback(request):
if request.param == "worker":
return _run_worker
def run_main(action):
cleanup_current_thread()
try:
return action()
finally:
cleanup_current_thread()
return run_main
def _caller_row(query):
return SearchCall(
research_id="research-1", search_engine="test", query=query
)
@pytest.mark.parametrize("finish", ["commit", "rollback"])
def test_in_scope_callback_uses_caller_transaction(
sqlite_metrics, run_callback, finish
):
session_factory, created_for = sqlite_metrics
query = f"caller-{finish}"
def action():
with get_user_db_session("alice", "test-password") as session:
session.add(_caller_row(query))
session.flush() # Own the SQLite write lock before the callback.
assert thread_session_manager.in_scope()
_callback()._save_to_db(3, 2)
# The callback neither creates a second session nor commits the
# caller's transaction before the caller chooses what to do.
assert created_for == ["alice"]
with session_factory() as observer:
assert observer.query(SearchCall).count() == 0
assert observer.query(TokenUsage).count() == 0
getattr(session, finish)()
run_callback(action)
expected = 1 if finish == "commit" else 0
with session_factory() as observer:
assert (
observer.query(SearchCall).filter_by(query=query).count()
== expected
)
assert observer.query(TokenUsage).count() == expected
assert observer.query(ModelUsage).count() == expected
def test_pending_orm_work_is_not_flushed_for_telemetry(
sqlite_metrics, run_callback
):
session_factory, created_for = sqlite_metrics
def action():
with get_user_db_session("alice", "test-password") as session:
row = _caller_row("pending-caller")
session.add(row)
with patch.object(session, "flush", wraps=session.flush) as flush:
_callback()._save_to_db(3, 2)
flush.assert_not_called()
assert row in session.new
assert created_for == ["alice"]
session.commit()
run_callback(action)
with session_factory() as observer:
assert (
observer.query(SearchCall).filter_by(query="pending-caller").count()
== 1
)
assert observer.query(TokenUsage).count() == 0
def test_metrics_failure_does_not_rollback_caller(sqlite_metrics, run_callback):
session_factory, created_for = sqlite_metrics
def action():
with get_user_db_session("alice", "test-password") as session:
session.add(_caller_row("caller-survives"))
session.flush()
with patch.object(
metrics_writer,
"add_token_metrics_to_session",
side_effect=RuntimeError("telemetry failed"),
):
_callback()._save_to_db(3, 2)
assert session.is_active
assert created_for == ["alice"]
session.commit()
run_callback(action)
with session_factory() as observer:
assert (
observer.query(SearchCall)
.filter_by(query="caller-survives")
.count()
== 1
)
assert observer.query(TokenUsage).count() == 0
def test_database_metrics_failure_does_not_rollback_caller(
sqlite_metrics, run_callback
):
session_factory, created_for = sqlite_metrics
def action():
with get_user_db_session("alice", "test-password") as session:
session.add(_caller_row("caller-survives-sql-error"))
session.flush()
callback = _callback()
callback.current_provider = None # Violates token_usage NOT NULL.
callback._save_to_db(3, 2)
assert session.is_active
assert created_for == ["alice"]
session.commit()
run_callback(action)
with session_factory() as observer:
assert (
observer.query(SearchCall)
.filter_by(query="caller-survives-sql-error")
.count()
== 1
)
assert observer.query(TokenUsage).count() == 0
assert observer.query(ModelUsage).count() == 0
def test_different_research_owner_cannot_borrow_caller_session(
sqlite_metrics, run_callback, loguru_caplog
):
session_factory, created_for = sqlite_metrics
def action():
with get_user_db_session("alice", "test-password") as session:
session.add(_caller_row("alice-caller"))
session.flush()
_callback(owner="bob")._save_to_db(3, 2)
assert created_for == ["alice"]
session.commit()
run_callback(action)
with session_factory() as observer:
assert (
observer.query(SearchCall).filter_by(query="alice-caller").count()
== 1
)
assert observer.query(TokenUsage).count() == 0
# An owner mismatch is an anomaly, so the skipped write is a warning.
levels = [
r.levelname
for r in loguru_caplog.records
if "matching owner session" in r.getMessage()
]
assert levels == ["WARNING"]
def test_standalone_callback_still_commits_telemetry(
sqlite_metrics, run_callback
):
session_factory, created_for = sqlite_metrics
run_callback(lambda: _callback()._save_to_db(3, 2))
assert created_for == ["alice"]
with session_factory() as observer:
token = observer.query(TokenUsage).one()
model = observer.query(ModelUsage).one()
assert (
token.prompt_tokens,
token.completion_tokens,
token.total_tokens,
) == (
3,
2,
5,
)
assert (model.total_calls, model.total_tokens) == (1, 5)
@pytest.mark.parametrize("finish", ["commit", "rollback", "scope_exit"])
@pytest.mark.parametrize("read_first", [False, True])
def test_callback_in_scope_without_writes_commits_on_its_own(
sqlite_metrics, run_callback, finish, read_first
):
session_factory, created_for = sqlite_metrics
def action():
with get_user_db_session("alice", "test-password") as session:
if read_first:
assert session.query(SearchCall).count() == 0
_callback()._save_to_db(3, 2)
assert created_for == ["alice"]
with session_factory() as observer:
assert observer.query(TokenUsage).count() == 1
assert observer.query(ModelUsage).count() == 1
# No writer lock outlives the telemetry's own transaction.
observer.add(_caller_row("concurrent writer"))
observer.commit()
if finish != "scope_exit":
getattr(session, finish)()
run_callback(action)
with session_factory() as observer:
assert observer.query(TokenUsage).count() == 1
assert observer.query(ModelUsage).count() == 1
assert (
observer.query(SearchCall)
.filter_by(query="concurrent writer")
.count()
== 1
)
@pytest.mark.parametrize("explicit_owner", [False, True])
def test_synchronous_callback_borrows_established_session_without_password(
sqlite_metrics, explicit_owner
):
session_factory, created_for = sqlite_metrics
cleanup_current_thread()
try:
with get_user_db_session("alice", "test-password") as session:
callback = _callback()
callback.research_context = (
{"username": "alice"} if explicit_owner else {}
)
with patch(
"local_deep_research.metrics.token_counter.get_current_username",
return_value="alice",
):
callback._save_to_db(3, 2)
assert created_for == ["alice"]
# The scope has not written, so the borrowed session committed
# the telemetry on its own.
with session_factory() as observer:
assert observer.query(TokenUsage).count() == 1
session.commit()
with session_factory() as observer:
assert observer.query(TokenUsage).count() == 1
finally:
cleanup_current_thread()