FilesExpand file tree

master

/

sqlalchemy.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

100 lines (76 loc) · 3.04 KB

master

/

sqlalchemy.py

Copy path

Top

File metadata and controls

• Code
• Blame

100 lines (76 loc) · 3.04 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

from __future__ import absolute_import

from sentry_sdk._types import MYPY

from sentry_sdk.hub import Hub

from sentry_sdk.integrations import Integration, DidNotEnable

from sentry_sdk.tracing_utils import record_sql_queries

try:

from sqlalchemy.engine import Engine # type: ignore

from sqlalchemy.event import listen # type: ignore

from sqlalchemy import __version__ as SQLALCHEMY_VERSION # type: ignore

except ImportError:

raise DidNotEnable("SQLAlchemy not installed.")

if MYPY:

from typing import Any

from typing import ContextManager

from typing import Optional

from sentry_sdk.tracing import Span

class SqlalchemyIntegration(Integration):

identifier = "sqlalchemy"

@staticmethod

def setup_once():

# type: () -> None

try:

version = tuple(map(int, SQLALCHEMY_VERSION.split("b")[0].split(".")))

except (TypeError, ValueError):

raise DidNotEnable(

"Unparsable SQLAlchemy version: {}".format(SQLALCHEMY_VERSION)

)

if version < (1, 2):

raise DidNotEnable("SQLAlchemy 1.2 or newer required.")

listen(Engine, "before_cursor_execute", _before_cursor_execute)

listen(Engine, "after_cursor_execute", _after_cursor_execute)

listen(Engine, "handle_error", _handle_error)

def _before_cursor_execute(

conn, cursor, statement, parameters, context, executemany, *args

):

# type: (Any, Any, Any, Any, Any, bool, *Any) -> None

hub = Hub.current

if hub.get_integration(SqlalchemyIntegration) is None:

return

ctx_mgr = record_sql_queries(

hub,

cursor,

statement,

parameters,

paramstyle=context and context.dialect and context.dialect.paramstyle or None,

executemany=executemany,

)

context._sentry_sql_span_manager = ctx_mgr

span = ctx_mgr.__enter__()

if span is not None:

context._sentry_sql_span = span

def _after_cursor_execute(conn, cursor, statement, parameters, context, *args):

# type: (Any, Any, Any, Any, Any, *Any) -> None

ctx_mgr = getattr(

context, "_sentry_sql_span_manager", None

) # type: Optional[ContextManager[Any]]

if ctx_mgr is not None:

context._sentry_sql_span_manager = None

ctx_mgr.__exit__(None, None, None)

def _handle_error(context, *args):

# type: (Any, *Any) -> None

execution_context = context.execution_context

if execution_context is None:

return

span = getattr(execution_context, "_sentry_sql_span", None) # type: Optional[Span]

if span is not None:

span.set_status("internal_error")

# _after_cursor_execute does not get called for crashing SQL stmts. Judging

# from SQLAlchemy codebase it does seem like any error coming into this

# handler is going to be fatal.

ctx_mgr = getattr(

execution_context, "_sentry_sql_span_manager", None

) # type: Optional[ContextManager[Any]]

if ctx_mgr is not None:

execution_context._sentry_sql_span_manager = None

ctx_mgr.__exit__(None, None, None)