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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
from __future__ import absolute_import
import celery
import logging
from raven.contrib.celery import (
SentryCeleryHandler,
register_logger_signal,
CeleryFilter
)
from raven.handlers.logging import SentryHandler
from raven.utils.testutils import InMemoryClient, TestCase
class CeleryTestCase(TestCase):
def setUp(self):
super(CeleryTestCase, self).setUp()
self.celery = celery.Celery(__name__)
self.celery.conf.CELERY_ALWAYS_EAGER = True
self.client = InMemoryClient()
self.handler = SentryCeleryHandler(self.client, ignore_expected=True)
self.handler.install()
self.addCleanup(self.handler.uninstall)
def test_simple(self):
@self.celery.task(name='dummy_task')
def dummy_task(x, y):
return x / y
dummy_task.delay(1, 2)
dummy_task.delay(1, 0)
assert len(self.client.events) == 1
event = self.client.events[0]
exception = event['exception']['values'][-1]
assert event['culprit'] == 'dummy_task'
assert exception['type'] == 'ZeroDivisionError'
def test_ignore_expected(self):
@self.celery.task(name='dummy_task', throws=(ZeroDivisionError,))
def dummy_task(x, y):
return x / y
dummy_task.delay(1, 2)
dummy_task.delay(1, 0)
assert len(self.client.events) == 0
class CeleryLoggingHandlerTestCase(TestCase):
def setUp(self):
super(CeleryLoggingHandlerTestCase, self).setUp()
self.client = InMemoryClient()
# register the logger signal
# and unregister the signal when the test is done
register_logger_signal(self.client)
receiver = celery.signals.after_setup_logger.receivers[0][1]
self.addCleanup(celery.signals.after_setup_logger.disconnect, receiver)
# remove any existing handlers and restore
# them when complete
self.root = logging.getLogger()
for handler in self.root.handlers:
self.root.removeHandler(handler)
self.addCleanup(self.root.addHandler, handler)
def test_handler_added(self):
# Given: there are no handlers configured
assert not self.root.handlers
# When: the after_setup_logger signal is sent
celery.signals.after_setup_logger.send(
sender=None, logger=self.root,
loglevel=logging.WARNING, logfile=None,
format=u'', colorize=False,
)
# Then: there is 1 new handler
assert len(self.root.handlers) == 1
# Then: the new handler is an instance of
# `raven.handlers.logging.SentryHandler`
handler = self.root.handlers[0]
assert isinstance(handler, SentryHandler)
# Then: the handler has 1 filter
assert len(handler.filters) == 1
# Then: the filter is a CeleryFilter
_filter = handler.filters[0]
assert isinstance(_filter, CeleryFilter)
# set up the handler to be removed once the test is done
self.addCleanup(self.root.removeHandler, handler)
def test_handler_updated(self):
# Given: there is 1 preconfigured SentryHandler
# with no filters
handler = SentryHandler(self.client)
assert not handler.filters
self.root.addHandler(handler)
# set up the handler to be removed once the test is done
self.addCleanup(self.root.removeHandler, handler)
# When: the after_setup_logger signal is sent
celery.signals.after_setup_logger.send(
sender=None, logger=self.root,
loglevel=logging.WARNING, logfile=None,
format=u'', colorize=False,
)
# Then: there is still just 1 handler
assert len(self.root.handlers) == 1
# Then: the existing handler is an instance of
# `raven.handlers.logging.SentryHandler`
handler = self.root.handlers[0]
assert isinstance(handler, SentryHandler)
# Then: the existing handler has 1 filter
assert len(handler.filters) == 1
# Then: the filter is a CeleryFilter
_filter = handler.filters[0]
assert isinstance(_filter, CeleryFilter)
def test_subclassed_handler_updated(self):
# Given: there is 1 preconfigured CustomHandler
# with no filters
class CustomHandler(SentryHandler):
pass
handler = CustomHandler(self.client)
assert not handler.filters
self.root.addHandler(handler)
# set up the handler to be removed once the test is done
self.addCleanup(self.root.removeHandler, handler)
# When: the after_setup_logger signal is sent
celery.signals.after_setup_logger.send(
sender=None, logger=self.root,
loglevel=logging.WARNING, logfile=None,
format=u'', colorize=False,
)
# Then: there is still just 1 handler
assert len(self.root.handlers) == 1
# Then: the existing handler is an instance of
# `CustomHandler`
handler = self.root.handlers[0]
assert isinstance(handler, CustomHandler)
# Then: the existing handler has 1 filter
assert len(handler.filters) == 1
# Then: the filter is a CeleryFilter
_filter = handler.filters[0]
assert isinstance(_filter, CeleryFilter)
|
