Instrument SQLAlchemy engine connection phase

[shahargl]

** Is your feature request related to a problem? **
The SQLAlchemy instrumentation does not trace the actual connection to the database

Describe the solution you'd like
I want that connect function will also be traced

Describe alternatives you've considered
Which alternative solutions or features have you considered?

Additional context
We are working with SQLAlchemy (snowflake db) and we implemented a solution where we can see the connect span also as attached in the screenshot (the span is database-connect)

[shahargl]

I've created a PR adding this functionality - #1134
I've tested this only for our infrastructure so I'll be happy if you will help me with testing this (or tell me how to do the tests my self)

[theobouwman]

Does this suggest that it creates a connection for each query?
Because if thats the case then I probably found out why with multiple request our API responses are around 1second right?

[shahargl]

From your image it looks like there is a connect before SELECT but I don't have the full context to say if that's the reason.

[theobouwman]

@shahargl so it creates a connection for each select here right? Because then my FastAPI SQLAlchemy implementation is not right. Should just have a share connection pool i guess.

[shahargl]

Do you use session factory?

[theobouwman]

I use this example: https://github.com/ets-labs/python-dependency-injector/blob/master/examples/miniapps/fastapi-sqlalchemy/webapp/database.py

class Database:

    def __init__(self, db_url: str) -> None:
        self._engine = create_engine(
            db_url,
            echo=get_config().QUERY_ECHO,
            json_serializer=_custom_json_serializer,
            pool_pre_ping=True,
            pool_size=get_config().DB_POOL_SIZE,
        )
        self._session_factory = orm.scoped_session(
            orm.sessionmaker(
                autocommit=False,
                autoflush=False,
                bind=self._engine,
            ),
        )

    def create_database(self) -> None:
        Base.metadata.create_all(self._engine)

    @contextmanager
    def session(self) -> Callable[..., AbstractContextManager[Session]]:
        session: Session = self._session_factory()
        try:
            yield session
        except Exception as e:
            # logger.exception("Session rollback because of exception")
            session.rollback()
            raise e
        finally:
            session.close()

and our dependency injector:

from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer):

    wiring_config = containers.WiringConfiguration(packages=[
        "api.routes",
        "tasks.routes",
        "common.observability"
    ])

    config = providers.Configuration()

    db = providers.Singleton(Database, db_url=get_config().DB_URL())

And then our Repository uses:

event_repository = providers.Factory(EventRepository, session_factory=db.provided.session)