FilesExpand file tree

master

/

threading.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

90 lines (70 loc) · 2.77 KB

master

/

threading.py

Copy path

Top

File metadata and controls

• Code
• Blame

90 lines (70 loc) · 2.77 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

from __future__ import absolute_import

import sys

from threading import Thread, current_thread

from sentry_sdk import Hub

from sentry_sdk._compat import reraise

from sentry_sdk._types import MYPY

from sentry_sdk.integrations import Integration

from sentry_sdk.utils import event_from_exception, capture_internal_exceptions

if MYPY:

from typing import Any

from typing import TypeVar

from typing import Callable

from typing import Optional

from sentry_sdk._types import ExcInfo

F = TypeVar("F", bound=Callable[..., Any])

class ThreadingIntegration(Integration):

identifier = "threading"

def __init__(self, propagate_hub=False):

# type: (bool) -> None

self.propagate_hub = propagate_hub

@staticmethod

def setup_once():

# type: () -> None

old_start = Thread.start

def sentry_start(self, *a, **kw):

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

hub = Hub.current

integration = hub.get_integration(ThreadingIntegration)

if integration is not None:

if not integration.propagate_hub:

hub_ = None

else:

hub_ = Hub(hub)

# Patching instance methods in `start()` creates a reference cycle if

# done in a naive way. See

# https://github.com/getsentry/sentry-python/pull/434

#

# In threading module, using current_thread API will access current thread instance

# without holding it to avoid a reference cycle in an easier way.

with capture_internal_exceptions():

new_run = _wrap_run(hub_, getattr(self.run, "__func__", self.run))

self.run = new_run # type: ignore

return old_start(self, *a, **kw)

Thread.start = sentry_start # type: ignore

def _wrap_run(parent_hub, old_run_func):

# type: (Optional[Hub], F) -> F

def run(*a, **kw):

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

hub = parent_hub or Hub.current

with hub:

try:

self = current_thread()

return old_run_func(self, *a, **kw)

except Exception:

reraise(*_capture_exception())

return run # type: ignore

def _capture_exception():

# type: () -> ExcInfo

hub = Hub.current

exc_info = sys.exc_info()

if hub.get_integration(ThreadingIntegration) is not None:

# If an integration is there, a client has to be there.

client = hub.client # type: Any

event, hint = event_from_exception(

exc_info,

client_options=client.options,

mechanism={"type": "threading", "handled": False},

)

hub.capture_event(event, hint=hint)

return exc_info