Skip to content

~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.

10.6 KB
Raw Blame
"""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()