from sqlalchemy import create_engine, event from sqlalchemy.orm import Session, declarative_base, sessionmaker from .config import settings from .logging_setup import db_operation, db_query, log_query_error, query_origin def install_engine_logging(engine): if getattr(engine, '_gc_logging', False): return engine._gc_logging = True @event.listens_for(engine, 'before_cursor_execute') def executing(conn, cursor, statement, parameters, context, executemany): context._gc_operation = 'execute' @event.listens_for(engine, 'after_cursor_execute') def executed(conn, cursor, statement, parameters, context, executemany): context._gc_operation = 'fetch' @event.listens_for(engine, 'handle_error') def query_failed(context): # Observational only: never replace exceptions or affect connection invalidation. error = context.sqlalchemy_exception or context.original_exception options = getattr(context.execution_context, 'execution_options', {}) or {} active = db_query.get() or {} statement = context.statement if context.statement is not None else active.get('statement') log_query_error(error, statement, options.get('query_name') or active.get('query_name'), db_operation.get() or getattr(context.execution_context, '_gc_operation', 'connect_or_transaction'), parameters=context.parameters) class LoggingSession(Session): def execute(self, statement, params=None, *, execution_options=None, **kwargs): options = dict(execution_options or {}) origin = options.setdefault('query_name', getattr(statement, '_execution_options', {}).get('query_name') or query_origin()) token = db_operation.set('execute') query_token = db_query.set({'statement': statement, 'query_name': origin}) try: return super().execute(statement, params, execution_options=options, **kwargs) except Exception as error: log_query_error(error, statement, origin, 'execute', parameters=params) raise finally: db_query.reset(query_token) db_operation.reset(token) def _transaction_operation(self, operation): token = db_operation.set(operation) try: return getattr(super(), operation)() except Exception as error: log_query_error(error, operation=operation) raise finally: db_operation.reset(token) def commit(self): return self._transaction_operation('commit') def rollback(self): return self._transaction_operation('rollback') def flush(self, objects=None): token = db_operation.set('flush') try: return super().flush(objects) except Exception as error: log_query_error(error, operation='flush') raise finally: db_operation.reset(token) engine = create_engine( settings.DATABASE_URL, connect_args={"check_same_thread": False} if settings.DATABASE_URL.startswith("sqlite") else {}, hide_parameters=True, ) install_engine_logging(engine) SessionLocal = sessionmaker(bind=engine, class_=LoggingSession, autoflush=False, autocommit=False) Base = declarative_base() def get_session(): db = SessionLocal() try: yield db finally: db.close()