From e7e861f104e1c8a797474670365dde9b3ee928df Mon Sep 17 00:00:00 2001 From: Frazer McLean Date: Tue, 10 Nov 2026 00:24:57 +0100 Subject: [PATCH] Reuse the ticket when concurrent writers create it Two writers logging from the same new call site could both find no ticket and both insert one. The second insert failed on the unique record hash, and its occurrence was lost. --- newsfragments/744.fixed.rst | 1 + src/logbook/ticketing.py | 10 ++++++ tests/test_ticketing.py | 64 ++++++++++++++++++++++++++++++++++++- 3 files changed, 74 insertions(+), 1 deletion(-) create mode 100644 newsfragments/744.fixed.rst diff --git a/newsfragments/744.fixed.rst b/newsfragments/744.fixed.rst new file mode 100644 index 00000000..d912aa79 --- /dev/null +++ b/newsfragments/744.fixed.rst @@ -0,0 +1 @@ +:class:`~logbook.ticketing.SQLAlchemyBackend` no longer loses an occurrence when two writers create the same ticket at once. diff --git a/src/logbook/ticketing.py b/src/logbook/ticketing.py index d959dae9..c85fbeec 100644 --- a/src/logbook/ticketing.py +++ b/src/logbook/ticketing.py @@ -201,6 +201,16 @@ def _order(self, q, table, order_by): def record_ticket(self, record, data, hash, app_id): """Records a log record as ticket.""" + from sqlalchemy.exc import IntegrityError + + try: + self._record_ticket(record, data, hash, app_id) + except IntegrityError: + # Another writer may have created this ticket after the select. + # A new transaction sees it; any other conflict raises again. + self._record_ticket(record, data, hash, app_id) + + def _record_ticket(self, record, data, hash, app_id): with self.engine.begin() as conn: q = self.tickets.select().where(self.tickets.c.record_hash == hash) row = conn.execute(q).one_or_none() diff --git a/tests/test_ticketing.py b/tests/test_ticketing.py index 8f3879a5..f1e4d5b4 100644 --- a/tests/test_ticketing.py +++ b/tests/test_ticketing.py @@ -1,7 +1,7 @@ import json import os from datetime import datetime, timezone -from threading import get_ident +from threading import Barrier, Thread, get_ident import pytest @@ -81,6 +81,68 @@ def test_engine_ticketing(): engine.dispose() +@require_module("sqlalchemy") +def test_concurrent_ticket_creation(tmp_path): + """Two writers can both find no ticket for a new call site. The one whose + insert then fails must record its occurrence on the other's ticket. + """ + from sqlalchemy import create_engine, event + + from logbook.ticketing import TicketingHandler + + engine = create_engine("sqlite:///" + str(tmp_path / "tickets.db")) + handler = TicketingHandler(engine) + barrier = Barrier(2, timeout=10) + + @event.listens_for(engine, "before_cursor_execute") + def before_cursor_execute(conn, cursor, statement, *args): + if statement.startswith("INSERT INTO logbook_tickets"): + barrier.wait() + + def emit(message): + record = logbook.LogRecord("test", logbook.WARNING, message) + record.heavy_init() + handler.emit(record) + + threads = [Thread(target=emit, args=(message,)) for message in ("1", "2")] + try: + for thread in threads: + thread.start() + for thread in threads: + thread.join() + [ticket] = handler.db.get_tickets() + assert ticket.occurrence_count == 2 + messages = {occurrence.message for occurrence in ticket.get_occurrences()} + assert messages == {"1", "2"} + finally: + engine.dispose() + + +@require_module("sqlalchemy") +def test_ticket_insert_unrelated_integrity_error(): + from sqlalchemy import Index + from sqlalchemy.exc import IntegrityError + + from logbook.ticketing import TicketingHandler + + handler = TicketingHandler("sqlite:///") + try: + tickets = handler.db.tickets + Index("unique_channel", tickets.c.channel, unique=True).create( + handler.db.engine + ) + warning = logbook.LogRecord("test", logbook.WARNING, "first") + warning.heavy_init() + handler.emit(warning) + error = logbook.LogRecord("test", logbook.ERROR, "second") + error.heavy_init() + with pytest.raises(IntegrityError): + handler.emit(error) + finally: + handler.close() + handler.db.engine.dispose() + + @pytest.fixture def couchdb_backend(): from logbook.more import CouchDBBackend