ErrorReporterHandler._emit() - Code Metrics - Inspection of "Bumped version to 1.1.0.2-beta" - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — beta ( 72a57d...7d0ef0 )

by Dean

created 2016-06-12 12:37 UTC

ErrorReporterHandler._emit() F

↳ Parent: ErrorReporterHandler

Complexity

Conditions

Size

Total Lines

106

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	774.7391

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	106
ccs	1
cts	62
cp	0.0161
rs	2
cc	28
crap	774.7391

How to fix Long Method Complexity

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 plugin.core.logger.filters.events import EventsReportFilter

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

fuzeman / Plex-Trakt-Scrobbler

Push — beta ( 72a57d...7d0ef0 )

ErrorReporterHandler._emit() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like