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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
"""
raven.contrib.awslambda
~~~~~~~~~~~~~~~~~~~~
Raven wrapper for AWS Lambda handlers.
:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
# flake8: noqa
from __future__ import absolute_import
import os
import logging
import functools
from types import FunctionType
from raven.base import Client
from raven.transport.http import HTTPTransport
logger = logging.getLogger('sentry.errors.client')
def get_default_tags():
return {
'lambda': 'AWS_LAMBDA_FUNCTION_NAME',
'version': 'AWS_LAMBDA_FUNCTION_VERSION',
'memory_size': 'AWS_LAMBDA_FUNCTION_MEMORY_SIZE',
'log_group': 'AWS_LAMBDA_LOG_GROUP_NAME',
'log_stream': 'AWS_LAMBDA_LOG_STREAM_NAME',
'region': 'AWS_REGION'
}
class LambdaClient(Client):
"""
Raven decorator for AWS Lambda.
By default, the lambda integration will capture unhandled exceptions and instrument logging.
Usage:
>>> from raven.contrib.awslambda import LambdaClient
>>>
>>>
>>> client = LambdaClient()
>>>
>>> @client.capture_exceptions
>>> def handler(event, context):
>>> ...
>>> raise Exception('I will be sent to sentry!')
"""
def __init__(self, *args, **kwargs):
transport = kwargs.pop('transport', HTTPTransport)
super(LambdaClient, self).__init__(*args, transport=transport, **kwargs)
def capture(self, *args, **kwargs):
if 'data' not in kwargs:
kwargs['data'] = data = {}
else:
data = kwargs['data']
event = kwargs.get('event', None)
context = kwargs.get('context', None)
if event:
http_info = self._get_http_interface(event)
user_info = self._get_user_interface(event)
if http_info:
data.update(http_info)
if user_info:
data.update(user_info)
if event and context:
data['extra'] = self._get_extra_data(event, context)
return super(LambdaClient, self).capture(*args, **kwargs)
def build_msg(self, *args, **kwargs):
data = super(LambdaClient, self).build_msg(*args, **kwargs)
for option, default in get_default_tags().items():
data['tags'].setdefault(option, os.environ.get(default))
data.setdefault('release', os.environ.get('SENTRY_RELEASE'))
data.setdefault('environment', os.environ.get('SENTRY_ENVIRONMENT'))
return data
def capture_exceptions(self, f=None, exceptions=None): # TODO: Ash fix kwargs in base
"""
Wrap a function or code block in try/except and automatically call
``.captureException`` if it raises an exception, then the exception
is reraised.
By default, it will capture ``Exception``
>>> @client.capture_exceptions
>>> def foo():
>>> raise Exception()
>>> with client.capture_exceptions():
>>> raise Exception()
You can also specify exceptions to be caught specifically
>>> @client.capture_exceptions((IOError, LookupError))
>>> def bar():
>>> ...
``kwargs`` are passed through to ``.captureException``.
"""
if not isinstance(f, FunctionType):
# when the decorator has args which is not a function we except
# f to be the exceptions tuple
return functools.partial(self.capture_exceptions, exceptions=f)
exceptions = exceptions or (Exception,)
@functools.wraps(f)
def wrapped(event, context, *args, **kwargs):
try:
return f(event, context, *args, **kwargs)
except exceptions:
self.captureException(event=event, context=context, **kwargs)
self.context.clear()
raise
return wrapped
@staticmethod
def _get_user_interface(event):
if event.get('requestContext'):
identity = event['requestContext']['identity']
if identity:
user = {
'id': identity.get('cognitoIdentityId', None) or identity.get('user', None),
'username': identity.get('user', None),
'ip_address': identity.get('sourceIp', None),
'cognito_identity_pool_id': identity.get('cognitoIdentityPoolId', None),
'cognito_authentication_type': identity.get('cognitoAuthenticationType', None),
'user_agent': identity.get('userAgent')
}
return {'user': user}
@staticmethod
def _get_http_interface(event):
if event.get('path') and event.get('httpMethod'):
request = {
"url": event.get('path'),
"method": event.get('httpMethod'),
"query_string": event.get('queryStringParameters', None),
"headers": event.get('headers', None) or [],
}
return {'request': request}
@staticmethod
def _get_extra_data(event, context):
extra_context = {
'event': event,
'aws_request_id': context.aws_request_id,
'context': vars(context),
}
if context.client_context:
extra_context['client_context'] = {
'client.installation_id': context.client_context.client.installation_id,
'client.app_title': context.client_context.client.app_title,
'client.app_version_name': context.client_context.client.app_version_name,
'client.app_version_code': context.client_context.client.app_version_code,
'client.app_package_name': context.client_context.client.app_package_name,
'custom': context.client_context.custom,
'env': context.client_context.env,
}
return extra_context
|
