ErrorReporterHandler._traceback_culprit() - Code Metrics - Inspection of "Merge branch 'feature/error-reporter-improvements'..." - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — develop ( 20bb73...3c901c )

by Dean

created 2016-03-25 06:13 UTC

ErrorReporterHandler._traceback_culprit() B

↳ Parent: ErrorReporterHandler

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Metric	Value
cc	6
dl	0
loc	38
ccs	0
cts	0
cp	0
crap	42
rs	7.5384

from plugin.core.constants import PLUGIN_VERSION_BASE, PLUGIN_VERSION_BRANCH
from plugin.core.helpers.error import ErrorHasher
from plugin.core.logger.filters import DuplicateReportFilter, ExceptionReportFilter, RequestsReportFilter, TraktReportFilter

from raven import Client
from raven.handlers.logging import SentryHandler, RESERVED
from raven.utils import six
from raven.utils.stacks import iter_stack_frames, label_from_frame
import datetime
import logging
import os
import platform
import re
import sys

log = logging.getLogger(__name__)


VERSION = '.'.join([str(x) for x in PLUGIN_VERSION_BASE])

RE_BUNDLE_PATH = re.compile(r"^.*?(?P<path>\w+\.bundle(?:\\|\/).*?)$", re.IGNORECASE)
RE_TRACEBACK_HEADER = re.compile(r"^Exception (.*?)\(most recent call last\)(.*?)$", re.IGNORECASE | re.DOTALL)

PARAMS = {
    # Message processors + filters
    'processors': [
        'raven.processors.RemoveStackLocalsProcessor',
        'plugin.raven.processors.RelativePathProcessor'
    ],

    'exclude_paths': [
        'Framework.api',
        'Framework.code',
        'Framework.components',
        'urllib2'
    ],

    # Plugin + System details
    'release': VERSION,
    'tags': {
        # Plugin
        'plugin.version': VERSION,
        'plugin.branch': PLUGIN_VERSION_BRANCH,

        # System
        'os.system': platform.system(),
        'os.release': platform.release(),
        'os.version': platform.version()
    }
}


class ErrorReporter(Client):
    server = 'sentry.skipthe.net'
    key = 'cd67f74a7d114f1eb54369a0b1974dfa:a35053b58fc24bc98d7edbf8a440923e'
    project = 1

    def __init__(self, dsn=None, raise_send_errors=False, **options):
        # Build URI
        if dsn is None:
            dsn = self.build_dsn()

        # Construct raven client
        super(ErrorReporter, self).__init__(dsn, raise_send_errors, **options)

    def build_dsn(self, protocol='threaded+requests+http'):
        return '%s://%s@%s/%s' % (
            protocol,
            self.key,
            self.server,
            self.project
        )

    def set_protocol(self, protocol):
        # Build new DSN URI
        dsn = self.build_dsn(protocol)

        # Update client DSN
        self.set_dsn(dsn)


class ErrorReporterHandler(SentryHandler):
    def _emit(self, record, **kwargs):
        data = {
            'user': {'id': self.client.name}
        }

        extra = getattr(record, 'data', None)
        if not isinstance(extra, dict):
            if extra:
                extra = {'data': extra}
            else:
                extra = {}

        for k, v in six.iteritems(vars(record)):
            if k in RESERVED:
                continue
            if k.startswith('_'):
                continue
            if '.' not in k and k not in ('culprit', 'server_name'):
                extra[k] = v
            else:
                data[k] = v

        stack = getattr(record, 'stack', None)
        if stack is True:
            stack = iter_stack_frames()

        if stack:
            stack = self._get_targetted_stack(stack, record)

        date = datetime.datetime.utcfromtimestamp(record.created)
        event_type = 'raven.events.Message'
        handler_kwargs = {
            'params': record.args,
        }
        try:
            handler_kwargs['message'] = six.text_type(record.msg)
        except UnicodeDecodeError:
            # Handle binary strings where it should be unicode...
            handler_kwargs['message'] = repr(record.msg)[1:-1]

        try:
            handler_kwargs['formatted'] = six.text_type(record.message)
        except UnicodeDecodeError:
            # Handle binary strings where it should be unicode...
            handler_kwargs['formatted'] = repr(record.message)[1:-1]

        # If there's no exception being processed, exc_info may be a 3-tuple of None
        # http://docs.python.org/library/sys.html#sys.exc_info
        try:
            exc_info = self._exc_info(record)
        except Exception, ex:
            log.info('Unable to retrieve exception info - %s', ex, exc_info=True)
            exc_info = None

        exception_hash = None

        if exc_info and len(exc_info) == 3 and all(exc_info):
            message = handler_kwargs.get('formatted')

            # Replace exception messages with more helpful details
            if not record.exc_info and message and RE_TRACEBACK_HEADER.match(message):
                # Generate new record title
                handler_kwargs['formatted'] = '%s\n\n%s' % (
                    self._generate_title(record, exc_info),
                    message
                )
            elif not record.exc_info:
                log.debug("Message %r doesn't match traceback header", message)

            # capture the standard message first so that we ensure
            # the event is recorded as an exception, in addition to having our
            # message interface attached
            handler = self.client.get_handler(event_type)
            data.update(handler.capture(**handler_kwargs))

            event_type = 'raven.events.Exception'
            handler_kwargs = {'exc_info': exc_info}

            # Calculate exception hash
            exception_hash = ErrorHasher.hash(exc_info=exc_info)

        # HACK: discover a culprit when we normally couldn't
        elif not (data.get('stacktrace') or data.get('culprit')) and (record.name or record.funcName):
            culprit = label_from_frame({'module': record.name, 'function': record.funcName})
            if culprit:
                data['culprit'] = culprit

        data['level'] = record.levelno
        data['logger'] = record.name

        # Store record `tags` in message
        if hasattr(record, 'tags'):
            kwargs['tags'] = record.tags

        if exception_hash:
            # Store `exception_hash` in message
            if 'tags' not in kwargs:
                kwargs['tags'] = {}

            kwargs['tags']['exception.hash'] = exception_hash

        kwargs.update(handler_kwargs)

        return self.client.capture(
            event_type, stack=stack, data=data,
            extra=extra, date=date, **kwargs
        )

    @classmethod
    def _exc_info(cls, record):
        if record.exc_info and all(record.exc_info):
            return record.exc_info

        # Determine if record is a formatted exception
        message = record.getMessage()

        if message and message.lower().startswith('exception'):
            return cls._extract_exc_info(record)

        return None

    @staticmethod
    def _extract_exc_info(record):
        # Retrieve last exception information
        exc_info = sys.exc_info()

        # Ensure exception information is valid
        if not exc_info or len(exc_info) != 3 or not all(exc_info):
            return None

        # Retrieve exception
        _, ex, _ = exc_info

        if not hasattr(ex, 'message'):
            return None

        # Retrieve last line of log record
        lines = record.message.strip().split('\n')
        last_line = lines[-1].lower()

        # Ensure exception message matches last line of record message
        message = ex.message.lower()

        if message not in last_line:
            log.debug("Ignored exception with message %r, doesn't match line: %r", message, last_line)
            return None

        return exc_info

    @classmethod
    def _traceback_culprit(cls, tb):
        result = None

        found_bundle = False

        while tb is not None:
            frame = tb.tb_frame
            line_num = tb.tb_lineno

            code = frame.f_code
            path = code.co_filename
            function_name = code.co_name

            # Retrieve bundle path
            bundle_path = cls.match_bundle(path)

            if bundle_path and bundle_path.startswith('trakttv.bundle'):
                # Found trace matching the current bundle
                found_bundle = True
            elif found_bundle:
                # Use previous trace matching current bundle
                break

            # Check if there is another trace available
            if tb.tb_next is None:
                # No traces left, use current trace
                result = (path, line_num, function_name)
                break

            # Store current culprit
            result = (path, line_num, function_name)

            # Move to next trace
            tb = tb.tb_next

        # Return "best" culprit match
        return result

    @staticmethod
    def match_bundle(path):
        path = path.lower().replace('\\', '/')
        match = RE_BUNDLE_PATH.match(path)

        if match:
            return match.group('path')

        return None

    @classmethod
    def _generate_title(cls, record, exc_info):
        _, ex, tb = exc_info

        # Try retrieve culprit from traceback
        try:
            culprit = cls._traceback_culprit(tb)
        except Exception, ex:
            log.info('Unable to retrieve traceback culprit - %s', ex, exc_info=True)
            culprit = None

        if culprit and len(culprit) == 3:
            file_path, _, function_name = culprit

            if function_name != '<module>':
                return 'Exception raised in %s(): %s' % (function_name, ex)

            # Build module name from path
            try:
                module = cls._module_name(file_path)
            except Exception, ex:
                log.info('Unable to retrieve module name - %s', ex, exc_info=True)
                module = None

            if not module:
                return 'Exception raised in <unknown>'

            return 'Exception raised in %s: %s' % (module, ex)

        # Try retrieve culprit from log record
        if record.funcName:
            return 'Exception raised in %s()' % (
                record.funcName
            )

        log.debug('Unable to generate title for record %r, exc_info: %r', record, exc_info)
        return 'Exception raised in <unknown>'

    @staticmethod
    def _module_name(file_path):
        # Convert to relative path
        path = file_path.lower()
        path = path[path.index('trakttv.bundle'):]
        path = os.path.splitext(path)[0]

        # Split path into fragments
        fragments = path.split(os.sep)[2:]

        if not fragments or fragments[0] not in ['code', 'libraries']:
            return None

        # Build module name
        module = None

        if fragments[0] == 'code':
            module = '.'.join(fragments)
        elif fragments[0] == 'libraries':
            module = '.'.join(fragments[2:])

        # Verify module name was built
        if not module:
            return None

        return module


# Build client
RAVEN = ErrorReporter(**PARAMS)

# Construct logging handler
ERROR_REPORTER_HANDLER = ErrorReporterHandler(RAVEN, level=logging.WARNING)

ERROR_REPORTER_HANDLER.filters = [
    DuplicateReportFilter(),
    ExceptionReportFilter(),
    RequestsReportFilter(),
    TraktReportFilter()
]


1	1	from plugin.core.constants import PLUGIN_VERSION_BASE, PLUGIN_VERSION_BRANCH
2	1	from plugin.core.helpers.error import ErrorHasher
3	1	from plugin.core.logger.filters import DuplicateReportFilter, ExceptionReportFilter, RequestsReportFilter, TraktReportFilter
4
5	1	from raven import Client
6	1	from raven.handlers.logging import SentryHandler, RESERVED
7	1	from raven.utils import six
8	1	from raven.utils.stacks import iter_stack_frames, label_from_frame
9	1	import datetime
10	1	import logging
11	1	import os
12		import platform
13	1	import re
14		import sys
15
16	1	log = logging.getLogger(__name__)
17
18	1
19		VERSION = '.'.join([str(x) for x in PLUGIN_VERSION_BASE])
20
21		RE_BUNDLE_PATH = re.compile(r"^.?(?P<path>\w+\.bundle(?:\\\|\/).?)$", re.IGNORECASE)
22		RE_TRACEBACK_HEADER = re.compile(r"^Exception (.?)\(most recent call last\)(.?)$", re.IGNORECASE \| re.DOTALL)
23
24		PARAMS = {
25		# Message processors + filters
26		'processors': [
27		'raven.processors.RemoveStackLocalsProcessor',
28		'plugin.raven.processors.RelativePathProcessor'
29		],
30
31		'exclude_paths': [
32		'Framework.api',
33		'Framework.code',
34		'Framework.components',
35		'urllib2'
36		],
37
38		# Plugin + System details
39		'release': VERSION,
40	1	'tags': {
41	1	# Plugin
42	1	'plugin.version': VERSION,
43	1	'plugin.branch': PLUGIN_VERSION_BRANCH,
44
45	1	# System
46		'os.system': platform.system(),
47	1	'os.release': platform.release(),
48	1	'os.version': platform.version()
49		}
50		}
51	1
52
53	1	class ErrorReporter(Client):
54	1	server = 'sentry.skipthe.net'
55		key = 'cd67f74a7d114f1eb54369a0b1974dfa:a35053b58fc24bc98d7edbf8a440923e'
56		project = 1
57
58		def __init__(self, dsn=None, raise_send_errors=False, **options):
59		# Build URI
60		if dsn is None:
61	1	dsn = self.build_dsn()
62
63	1	# Construct raven client
64		super(ErrorReporter, self).__init__(dsn, raise_send_errors, **options)
65
66	1	def build_dsn(self, protocol='threaded+requests+http'):
67		return '%s://%s@%s/%s' % (
68		protocol,
69	1	self.key,
70	1	self.server,
71		self.project
72		)
73
74		def set_protocol(self, protocol):
75		# Build new DSN URI
76		dsn = self.build_dsn(protocol)
77
78		# Update client DSN
79		self.set_dsn(dsn)
80
81
82		class ErrorReporterHandler(SentryHandler):
83		def _emit(self, record, **kwargs):
84		data = {
85		'user': {'id': self.client.name}
86		}
87
88		extra = getattr(record, 'data', None)
89		if not isinstance(extra, dict):
90		if extra:
91		extra = {'data': extra}
92		else:
93		extra = {}
94
95		for k, v in six.iteritems(vars(record)):
96		if k in RESERVED:
97		continue
98		if k.startswith('_'):
99		continue
100		if '.' not in k and k not in ('culprit', 'server_name'):
101		extra[k] = v
102		else:
103		data[k] = v
104
105		stack = getattr(record, 'stack', None)
106		if stack is True:
107		stack = iter_stack_frames()
108
109		if stack:
110		stack = self._get_targetted_stack(stack, record)
111
112		date = datetime.datetime.utcfromtimestamp(record.created)
113		event_type = 'raven.events.Message'
114		handler_kwargs = {
115		'params': record.args,
116		}
117		try:
118		handler_kwargs['message'] = six.text_type(record.msg)
119		except UnicodeDecodeError:
120		# Handle binary strings where it should be unicode...
121		handler_kwargs['message'] = repr(record.msg)[1:-1]
122
123		try:
124		handler_kwargs['formatted'] = six.text_type(record.message)
125		except UnicodeDecodeError:
126		# Handle binary strings where it should be unicode...
127		handler_kwargs['formatted'] = repr(record.message)[1:-1]
128
129		# If there's no exception being processed, exc_info may be a 3-tuple of None
130		# http://docs.python.org/library/sys.html#sys.exc_info
131		try:
132		exc_info = self._exc_info(record)
133		except Exception, ex:
134		log.info('Unable to retrieve exception info - %s', ex, exc_info=True)
135		exc_info = None
136
137		exception_hash = None
138
139		if exc_info and len(exc_info) == 3 and all(exc_info):
140		message = handler_kwargs.get('formatted')
141
142		# Replace exception messages with more helpful details
143		if not record.exc_info and message and RE_TRACEBACK_HEADER.match(message):
144		# Generate new record title
145		handler_kwargs['formatted'] = '%s\n\n%s' % (
146		self._generate_title(record, exc_info),
147		message
148		)
149		elif not record.exc_info:
150		log.debug("Message %r doesn't match traceback header", message)
151
152		# capture the standard message first so that we ensure
153		# the event is recorded as an exception, in addition to having our
154		# message interface attached
155		handler = self.client.get_handler(event_type)
156		data.update(handler.capture(**handler_kwargs))
157
158		event_type = 'raven.events.Exception'
159		handler_kwargs = {'exc_info': exc_info}
160
161		# Calculate exception hash
162	1	exception_hash = ErrorHasher.hash(exc_info=exc_info)
163
164		# HACK: discover a culprit when we normally couldn't
165	1	elif not (data.get('stacktrace') or data.get('culprit')) and (record.name or record.funcName):
166		culprit = label_from_frame({'module': record.name, 'function': record.funcName})
167	1	if culprit:
168		data['culprit'] = culprit
169
170		data['level'] = record.levelno
171		data['logger'] = record.name
172
173		# Store record `tags` in message
174		if hasattr(record, 'tags'):
175		kwargs['tags'] = record.tags
176
177		if exception_hash:
178		# Store `exception_hash` in message
179		if 'tags' not in kwargs:
180		kwargs['tags'] = {}
181
182		kwargs['tags']['exception.hash'] = exception_hash
183
184		kwargs.update(handler_kwargs)
185
186		return self.client.capture(
187		event_type, stack=stack, data=data,
188		extra=extra, date=date, **kwargs
189		)
190
191		@classmethod
192		def _exc_info(cls, record):
193		if record.exc_info and all(record.exc_info):
194		return record.exc_info
195
196		# Determine if record is a formatted exception
197		message = record.getMessage()
198
199		if message and message.lower().startswith('exception'):
200		return cls._extract_exc_info(record)
201
202		return None
203
204		@staticmethod
205		def _extract_exc_info(record):
206		# Retrieve last exception information
207		exc_info = sys.exc_info()
208
209		# Ensure exception information is valid
210		if not exc_info or len(exc_info) != 3 or not all(exc_info):
211		return None
212
213		# Retrieve exception
214		_, ex, _ = exc_info
215
216		if not hasattr(ex, 'message'):
217		return None
218
219		# Retrieve last line of log record
220		lines = record.message.strip().split('\n')
221		last_line = lines[-1].lower()
222
223		# Ensure exception message matches last line of record message
224		message = ex.message.lower()
225
226		if message not in last_line:
227		log.debug("Ignored exception with message %r, doesn't match line: %r", message, last_line)
228		return None
229
230		return exc_info
231
232		@classmethod
233		def _traceback_culprit(cls, tb):
234		result = None
235
236		found_bundle = False
237
238		while tb is not None:
239		frame = tb.tb_frame
240		line_num = tb.tb_lineno
241
242		code = frame.f_code
243		path = code.co_filename
244		function_name = code.co_name
245
246		# Retrieve bundle path
247		bundle_path = cls.match_bundle(path)
248
249		if bundle_path and bundle_path.startswith('trakttv.bundle'):
250		# Found trace matching the current bundle
251		found_bundle = True
252		elif found_bundle:
253		# Use previous trace matching current bundle
254		break
255
256		# Check if there is another trace available
257		if tb.tb_next is None:
258		# No traces left, use current trace
259		result = (path, line_num, function_name)
260		break
261
262		# Store current culprit
263		result = (path, line_num, function_name)
264
265		# Move to next trace
266		tb = tb.tb_next
267
268		# Return "best" culprit match
269		return result
270
271		@staticmethod
272		def match_bundle(path):
273		path = path.lower().replace('\\', '/')
274		match = RE_BUNDLE_PATH.match(path)
275
276		if match:
277		return match.group('path')
278
279		return None
280
281		@classmethod
282		def _generate_title(cls, record, exc_info):
283		_, ex, tb = exc_info
284
285		# Try retrieve culprit from traceback
286		try:
287		culprit = cls._traceback_culprit(tb)
288		except Exception, ex:
289		log.info('Unable to retrieve traceback culprit - %s', ex, exc_info=True)
290		culprit = None
291
292		if culprit and len(culprit) == 3:
293		file_path, _, function_name = culprit
294
295		if function_name != '<module>':
296		return 'Exception raised in %s(): %s' % (function_name, ex)
297
298		# Build module name from path
299		try:
300		module = cls._module_name(file_path)
301		except Exception, ex:
302		log.info('Unable to retrieve module name - %s', ex, exc_info=True)
303		module = None
304
305		if not module:
306		return 'Exception raised in <unknown>'
307
308		return 'Exception raised in %s: %s' % (module, ex)
309
310		# Try retrieve culprit from log record
311		if record.funcName:
312		return 'Exception raised in %s()' % (
313		record.funcName
314		)
315
316		log.debug('Unable to generate title for record %r, exc_info: %r', record, exc_info)
317		return 'Exception raised in <unknown>'
318
319		@staticmethod
320		def _module_name(file_path):
321		# Convert to relative path
322		path = file_path.lower()
323		path = path[path.index('trakttv.bundle'):]
324		path = os.path.splitext(path)[0]
325
326		# Split path into fragments
327		fragments = path.split(os.sep)[2:]
328
329		if not fragments or fragments[0] not in ['code', 'libraries']:
330		return None
331
332		# Build module name
333		module = None
334
335		if fragments[0] == 'code':
336		module = '.'.join(fragments)
337		elif fragments[0] == 'libraries':
338		module = '.'.join(fragments[2:])
339
340		# Verify module name was built
341		if not module:
342		return None
343
344		return module
345
346
347		# Build client
348		RAVEN = ErrorReporter(**PARAMS)
349
350		# Construct logging handler
351		ERROR_REPORTER_HANDLER = ErrorReporterHandler(RAVEN, level=logging.WARNING)
352
353		ERROR_REPORTER_HANDLER.filters = [
354		DuplicateReportFilter(),
355		ExceptionReportFilter(),
356		RequestsReportFilter(),
357		TraktReportFilter()
358		]
359

fuzeman / Plex-Trakt-Scrobbler

Push — develop ( 20bb73...3c901c )

ErrorReporterHandler._traceback_culprit() B

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like