# osprofiler.sqlalchemy

# Source code for osprofiler.sqlalchemy

    # Copyright 2014 Mirantis Inc.
    # All Rights Reserved.
    #
    #    Licensed under the Apache License, Version 2.0 (the "License"); you may
    #    not use this file except in compliance with the License. You may obtain
    #    a copy of the License at
    #
    #         http://www.apache.org/licenses/LICENSE-2.0
    #
    #    Unless required by applicable law or agreed to in writing, software
    #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    #    License for the specific language governing permissions and limitations
    #    under the License.

    import contextlib
    import logging as log

    from oslo_utils import reflection

    from osprofiler import profiler

    LOG = log.getLogger(__name__)

    _DISABLED = False

    def disable():
        """Disable tracing of all DB queries. Reduce a lot size of profiles."""
        global _DISABLED
        _DISABLED = True

    def enable():
        """add_tracing adds event listeners for sqlalchemy."""

        global _DISABLED
        _DISABLED = False

    def add_tracing(sqlalchemy, engine, name, hide_result=True):
        """Add tracing to all sqlalchemy calls."""

        if not _DISABLED:
            sqlalchemy.event.listen(engine, "before_cursor_execute",
                                    _before_cursor_execute(name))
            sqlalchemy.event.listen(
                engine, "after_cursor_execute",
                _after_cursor_execute(hide_result=hide_result)
            )
            sqlalchemy.event.listen(engine, "handle_error", handle_error)

    @contextlib.contextmanager
    def wrap_session(sqlalchemy, sess):
        with sess as s:
            if not getattr(s.bind, "traced", False):
                add_tracing(sqlalchemy, s.bind, "db")
                s.bind.traced = True
            yield s

    def _before_cursor_execute(name):
        """Add listener that will send trace info before query is executed."""

        def handler(conn, cursor, statement, params, context, executemany):
            info = {"db": {
                "statement": statement,
                "params": params}
            }
            profiler.start(name, info=info)

        return handler

    def _after_cursor_execute(hide_result=True):
        """Add listener that will send trace info after query is executed.

        :param hide_result: Boolean value to hide or show SQL result in trace.
                            True - hide SQL result (default).
                            False - show SQL result in trace.
        """

        def handler(conn, cursor, statement, params, context, executemany):
            if not hide_result:
                # Add SQL result to trace info in *-stop phase
                info = {
                    "db": {
                        "result": str(cursor._rows)
                    }
                }
                profiler.stop(info=info)
            else:
                profiler.stop()

        return handler

    def handle_error(exception_context):
        """Handle SQLAlchemy errors"""
        exception_class_name = reflection.get_class_name(
            exception_context.original_exception)
        original_exception = str(exception_context.original_exception)
        chained_exception = str(exception_context.chained_exception)

        info = {
            "etype": exception_class_name,
            "message": original_exception,
            "db": {
                "original_exception": original_exception,
                "chained_exception": chained_exception
            }
        }
        profiler.stop(info=info)
        LOG.debug("OSProfiler has handled SQLAlchemy error: %s",
                  original_exception)

this page last updated: 2026-03-27 00:00:00

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.

found an error? report a bug