def force_text(s, encoding=u'utf-8', strings_only=False, errors=u'strict'): if isinstance(s, text_type): return s if strings_only and is_protected_type(s): return s try: if not isinstance(s, string_types): if hasattr(s, u'__unicode__'): s = s.__unicode__() elif not PY2: if isinstance(s, bytes): s = text_type(s, encoding, errors) else: s = text_type(s) else: s = text_type(bytes(s), encoding, errors) else: s = s.decode(encoding, errors) except UnicodeDecodeError as e: if not isinstance(s, Exception): raise UnicodeDecodeError(*e.args) else: s = u' '.join( [force_text(arg, encoding, strings_only, errors) for arg in s]) return s
def fetch_git_sha(path, head=None): """ >>> fetch_git_sha(os.path.dirname(__file__)) """ if not head: head_path = os.path.join(path, '.git', 'HEAD') if not os.path.exists(head_path): raise InvalidGitRepository( 'Cannot identify HEAD for git repository at %s' % (path,)) with open(head_path, 'r') as fp: head = text_type(fp.read()).strip() if head.startswith('ref: '): revision_file = os.path.join( path, '.git', *head.rsplit(' ', 1)[-1].split('/') ) else: return head else: revision_file = os.path.join(path, '.git', 'refs', 'heads', head) if not os.path.exists(revision_file): if not os.path.exists(os.path.join(path, '.git')): raise InvalidGitRepository( '%s does not seem to be the root of a git repository' % (path,)) raise InvalidGitRepository( 'Unable to find ref to head "%s" in repository' % (head,)) fh = open(revision_file, 'r') try: return text_type(fh.read()).strip() finally: fh.close()
def transform(self, value, **kwargs): """ Primary function which handles recursively transforming values via their serializers """ if value is None: return None objid = id(value) if objid in self.context: return "<...>" self.context.add(objid) try: for serializer in self.serializers: if serializer.can(value): try: return serializer.serialize(value, **kwargs) except Exception as e: logger.exception(e) return text_type(type(value)) # if all else fails, lets use the repr of the object try: return repr(value) except Exception as e: logger.exception(e) # It's common case that a model's __unicode__ definition # may try to query the database which if it was not # cleaned up correctly, would hit a transaction aborted # exception return text_type(type(value)) finally: self.context.remove(objid)
def transform(self, value, **kwargs): """ Primary function which handles recursively transforming values via their serializers """ if value is None: return None objid = id(value) if objid in self.context: return '<...>' self.context.add(objid) try: for serializer in self.serializers: if serializer.can(value): try: return serializer.serialize(value, **kwargs) except Exception as e: logger.exception(e) return text_type(type(value)) # if all else fails, lets use the repr of the object try: return repr(value) except Exception as e: logger.exception(e) # It's common case that a model's __unicode__ definition # may try to query the database which if it was not # cleaned up correctly, would hit a transaction aborted # exception return text_type(type(value)) finally: self.context.remove(objid)
def _emit(self, record, **kwargs): data, extra = extract_extra(record) 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'] = 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'] = 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 if record.exc_info and all(record.exc_info): # 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': record.exc_info} data['level'] = record.levelno data['logger'] = record.name if hasattr(record, 'tags'): kwargs['tags'] = record.tags elif self.tags: kwargs['tags'] = self.tags kwargs.update(handler_kwargs) return self.client.capture(event_type, stack=stack, data=data, extra=extra, date=date, **kwargs)
def fetch_git_sha(path, head=None): """ >>> fetch_git_sha(os.path.dirname(__file__)) """ if not head: head_path = os.path.join(path, '.git', 'HEAD') if not os.path.exists(head_path): raise InvalidGitRepository( 'Cannot identify HEAD for git repository at %s' % (path,)) with open(head_path, 'r') as fp: head = text_type(fp.read()).strip() if head.startswith('ref: '): head = head[5:] revision_file = os.path.join( path, '.git', *head.split('/') ) else: return head else: revision_file = os.path.join(path, '.git', 'refs', 'heads', head) if not os.path.exists(revision_file): if not os.path.exists(os.path.join(path, '.git')): raise InvalidGitRepository( '%s does not seem to be the root of a git repository' % (path,)) # Check for our .git/packed-refs' file since a `git gc` may have run # https://git-scm.com/book/en/v2/Git-Internals-Maintenance-and-Data-Recovery packed_file = os.path.join(path, '.git', 'packed-refs') if os.path.exists(packed_file): with open(packed_file, 'r') as fh: for line in fh: line = line.rstrip() if not line: continue if line[:1] in ('#', '^'): continue try: revision, ref = line.split(' ', 1) except ValueError: continue if ref == head: return text_type(revision) raise InvalidGitRepository( 'Unable to find ref to head "%s" in repository' % (head,)) fh = open(revision_file, 'r') try: return text_type(fh.read()).strip() finally: fh.close()
def _emit(self, record, **kwargs): data, extra = extract_extra(record) 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'] = 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'] = 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 if record.exc_info and all(record.exc_info): # 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': record.exc_info} data['level'] = record.levelno data['logger'] = record.name if hasattr(record, 'tags'): kwargs['tags'] = record.tags elif self.tags: kwargs['tags'] = self.tags kwargs.update(handler_kwargs) return self.client.capture( event_type, stack=stack, data=data, extra=extra, date=date, **kwargs)
def recurse(self, value, max_depth=6, _depth=0, **kwargs): string_max_length = kwargs.get('string_max_length', None) _depth += 1 if _depth >= max_depth: try: value = text_type(repr(value))[:string_max_length] except Exception as e: import traceback traceback.print_exc() self.manager.logger.exception(e) return text_type(type(value)) return self.manager.transform(value, max_depth=max_depth, _depth=_depth, **kwargs)
def __init__(self, dsn=None, raise_send_errors=False, transport=None, install_sys_hook=True, **options): global Raven o = options self.configure_logging() self.raise_send_errors = raise_send_errors # configure loggers first cls = self.__class__ self.state = ClientState() self.logger = logging.getLogger( '%s.%s' % (cls.__module__, cls.__name__)) self.error_logger = logging.getLogger('sentry.errors') self.uncaught_logger = logging.getLogger('sentry.errors.uncaught') self._transport_cache = {} self.set_dsn(dsn, transport) self.include_paths = set(o.get('include_paths') or []) self.exclude_paths = set(o.get('exclude_paths') or []) self.name = text_type(o.get('name') or o.get('machine') or defaults.NAME) self.auto_log_stacks = bool( o.get('auto_log_stacks') or defaults.AUTO_LOG_STACKS) self.capture_locals = bool( o.get('capture_locals', defaults.CAPTURE_LOCALS)) self.string_max_length = int( o.get('string_max_length') or defaults.MAX_LENGTH_STRING) self.list_max_length = int( o.get('list_max_length') or defaults.MAX_LENGTH_LIST) self.site = o.get('site') self.include_versions = o.get('include_versions', True) self.processors = o.get('processors') if self.processors is None: self.processors = defaults.PROCESSORS context = o.get('context') if context is None: context = {'sys.argv': sys.argv[:]} self.extra = context self.tags = o.get('tags') or {} self.environment = o.get('environment') or None self.release = o.get('release') or os.environ.get('HEROKU_SLUG_COMMIT') self.module_cache = ModuleProxyCache() if not self.is_enabled(): self.logger.info( 'Raven is not configured (logging is disabled). Please see the' ' documentation for more information.') if Raven is None: Raven = self self._context = Context() if install_sys_hook: self.install_sys_hook()
def processor(data): formatted_msg = msg # If people log bad things, this can happen. Then just don't do # anything. try: formatted_msg = text_type(msg) if args: formatted_msg = msg % args except Exception: pass # We do not want to include exc_info as argument because it often # lies (set to a constant value like 1 or True) or even if it's a # tuple it will not be particularly useful for us as we cannot # process it anyways. kwargs.pop("exc_info", None) data.update( { "message": formatted_msg, "category": logger.name, "level": logging.getLevelName(level).lower(), "data": kwargs, } )
def serialize(self, value, **kwargs): # try to return a reasonable string that can be decoded # correctly by the server so it doesn't show up as \uXXX for each # unicode character # e.g. we want the output to be like: "u'רונית מגן'" string_max_length = kwargs.get('string_max_length', None) return repr(text_type('%s')) % (value[:string_max_length],)
def serialize(self, value, **kwargs): # try to return a reasonable string that can be decoded # correctly by the server so it doesn't show up as \uXXX for each # unicode character # e.g. we want the output to be like: "u'רונית מגן'" string_max_length = kwargs.get('string_max_length', None) return repr(text_type('%s')) % (value[:string_max_length], )
def serialize(self, value, **kwargs): pre = value.__class__.__name__[1:] if hasattr(value, u'%s__func' % pre): value = getattr(value, u'%s__func' % pre)(*getattr( value, u'%s__args' % pre), **getattr(value, u'%s__kw' % pre)) else: return self.recurse(text_type(value)) return self.recurse(value, **kwargs)
def recurse(self, value, max_depth=6, _depth=0, **kwargs): """ Given ``value``, recurse (using the parent serializer) to handle coercing of newly defined values. """ string_max_length = kwargs.get('string_max_length', None) _depth += 1 if _depth >= max_depth: try: value = text_type(repr(value))[:string_max_length] except Exception as e: import traceback traceback.print_exc() self.manager.logger.exception(e) return text_type(type(value)) return self.manager.transform(value, max_depth=max_depth, _depth=_depth, **kwargs)
def fetch_git_sha(path, head=None): if not head: head_path = os.path.join(path, '.git', 'HEAD') if not os.path.exists(head_path): raise InvalidGitRepository( 'Cannot identify HEAD for git repository at %s' % (path, )) with open(head_path, 'r') as fp: head = text_type(fp.read()).strip() if head.startswith('ref: '): head = head[5:] revision_file = os.path.join(path, '.git', *head.split('/')) else: return head else: revision_file = os.path.join(path, '.git', 'refs', 'heads', head) if not os.path.exists(revision_file): if not os.path.exists(os.path.join(path, '.git')): raise InvalidGitRepository( '%s does not seem to be the root of a git repository' % (path, )) packed_file = os.path.join(path, '.git', 'packed-refs') if os.path.exists(packed_file): with open(packed_file, 'r') as fh: for line in fh: line = line.rstrip() if not line: continue if line[:1] in ('#', '^'): continue try: revision, ref = line.split(' ', 1) except ValueError: continue if ref == head: return text_type(revision) raise InvalidGitRepository( 'Unable to find ref to head "%s" in repository' % (head, )) fh = open(revision_file, 'r') try: return text_type(fh.read()).strip() finally: fh.close()
def force_text(s, encoding='utf-8', strings_only=False, errors='strict'): """ Similar to smart_text, except that lazy instances are resolved to strings, rather than kept as lazy objects. If strings_only is True, don't convert (some) non-string-like objects. """ # Handle the common case first, saves 30-40% when s is an instance of # text_type. This function gets called often in that setting. if isinstance(s, text_type): return s if strings_only and is_protected_type(s): return s try: if not isinstance(s, string_types): if hasattr(s, '__unicode__'): s = s.__unicode__() else: if not PY2: if isinstance(s, bytes): s = text_type(s, encoding, errors) else: s = text_type(s) else: s = text_type(bytes(s), encoding, errors) else: # Note: We use .decode() here, instead of text_type(s, encoding, # errors), so that if s is a SafeBytes, it ends up being a # SafeText at the end. s = s.decode(encoding, errors) except UnicodeDecodeError as e: if not isinstance(s, Exception): raise UnicodeDecodeError(*e.args) else: # If we get to here, the caller has passed in an Exception # subclass populated with non-ASCII bytestring data without a # working unicode method. Try to handle this without raising a # further exception by individually forcing the exception args # to unicode. s = ' '.join( [force_text(arg, encoding, strings_only, errors) for arg in s]) return s
class ProxyClient(object): __members__ = property(lambda x: x.__dir__()) __class__ = property(lambda x: get_client().__class__) __dict__ = property(lambda o: get_client().__dict__) __repr__ = lambda x: repr(get_client()) __getattr__ = lambda x, o: getattr(get_client(), o) __setattr__ = lambda x, o, v: setattr(get_client(), o, v) __delattr__ = lambda x, o: delattr(get_client(), o) __lt__ = lambda x, o: get_client() < o __le__ = lambda x, o: get_client() <= o __eq__ = lambda x, o: get_client() == o __ne__ = lambda x, o: get_client() != o __gt__ = lambda x, o: get_client() > o __ge__ = lambda x, o: get_client() >= o if PY2: __cmp__ = lambda x, o: cmp(get_client(), o) __hash__ = lambda x: hash(get_client()) __nonzero__ = lambda x: bool(get_client()) __len__ = lambda x: len(get_client()) __getitem__ = lambda x, i: get_client()[i] __iter__ = lambda x: iter(get_client()) __contains__ = lambda x, i: i in get_client() __getslice__ = lambda x, i, j: get_client()[i:j] __add__ = lambda x, o: get_client() + o __sub__ = lambda x, o: get_client() - o __mul__ = lambda x, o: get_client() * o __floordiv__ = lambda x, o: get_client() // o __mod__ = lambda x, o: get_client() % o __divmod__ = lambda x, o: get_client().__divmod__(o) __pow__ = lambda x, o: get_client() ** o __lshift__ = lambda x, o: get_client() << o __rshift__ = lambda x, o: get_client() >> o __and__ = lambda x, o: get_client() & o __xor__ = lambda x, o: get_client() ^ o __or__ = lambda x, o: get_client() | o __div__ = lambda x, o: get_client().__div__(o) __truediv__ = lambda x, o: get_client().__truediv__(o) __neg__ = lambda x: -get_client() __pos__ = lambda x: +get_client() __abs__ = lambda x: abs(get_client()) __invert__ = lambda x: ~get_client() __complex__ = lambda x: complex(get_client()) __int__ = lambda x: int(get_client()) if PY2: __long__ = lambda x: long(get_client()) __float__ = lambda x: float(get_client()) __str__ = lambda x: binary_type(get_client()) __unicode__ = lambda x: text_type(get_client()) __oct__ = lambda x: oct(get_client()) __hex__ = lambda x: hex(get_client()) __index__ = lambda x: get_client().__index__() __coerce__ = lambda x, o: x.__coerce__(x, o) __enter__ = lambda x: x.__enter__() __exit__ = lambda x, *a, **kw: x.__exit__(*a, **kw)
def to_unicode(value): try: value = text_type(force_text(value)) except (UnicodeEncodeError, UnicodeDecodeError): value = '(Error decoding value)' except Exception: # in some cases we get a different exception try: value = binary_type(repr(type(value))) except Exception: value = '(Error decoding value)' return value
def to_unicode(value): try: value = text_type(force_text(value)) except (UnicodeEncodeError, UnicodeDecodeError): value = "(Error decoding value)" except Exception: # in some cases we get a different exception try: value = binary_type(repr(type(value))) except Exception: value = "(Error decoding value)" return value
def force_text(s, encoding="utf-8", strings_only=False, errors="strict"): """ Similar to smart_text, except that lazy instances are resolved to strings, rather than kept as lazy objects. If strings_only is True, don't convert (some) non-string-like objects. """ # Handle the common case first, saves 30-40% when s is an instance of # text_type. This function gets called often in that setting. if isinstance(s, text_type): return s if strings_only and is_protected_type(s): return s try: if not isinstance(s, string_types): if hasattr(s, "__unicode__"): s = s.__unicode__() else: if not PY2: if isinstance(s, bytes): s = text_type(s, encoding, errors) else: s = text_type(s) else: s = text_type(bytes(s), encoding, errors) else: # Note: We use .decode() here, instead of text_type(s, encoding, # errors), so that if s is a SafeBytes, it ends up being a # SafeText at the end. s = s.decode(encoding, errors) except UnicodeDecodeError as e: if not isinstance(s, Exception): raise UnicodeDecodeError(*e.args) else: # If we get to here, the caller has passed in an Exception # subclass populated with non-ASCII bytestring data without a # working unicode method. Try to handle this without raising a # further exception by individually forcing the exception args # to unicode. s = " ".join([force_text(arg, encoding, strings_only, errors) for arg in s]) return s
def serialize(self, value, **kwargs): # EPIC HACK # handles lazy model instances (which are proxy values that don't # easily give you the actual function) pre = value.__class__.__name__[1:] if hasattr(value, '%s__func' % pre): value = getattr(value, '%s__func' % pre)( *getattr(value, '%s__args' % pre), **getattr(value, '%s__kw' % pre)) else: return self.recurse(text_type(value)) return self.recurse(value, **kwargs)
def to_unicode(value): try: value = text_type(force_text(value)) except (UnicodeEncodeError, UnicodeDecodeError): value = u'(Error decoding value)' except Exception: try: value = binary_type(repr(type(value))) except Exception: value = u'(Error decoding value)' return value
def transform(self, value, **kwargs): if value is None: return objid = id(value) if objid in self.context: return '<...>' self.context.add(objid) try: for serializer in self.serializers: if serializer.can(value): try: return serializer.serialize(value, **kwargs) except Exception as e: logger.exception(e) return text_type(type(value)) try: return repr(value) except Exception as e: logger.exception(e) return text_type(type(value)) finally: self.context.remove(objid)
def sanitize(self, key, value): if value is None: return if isinstance(value, string_types) and self.VALUES_RE.match(value): return self.MASK if not key: # key can be a NoneType return value key = text_type(key).lower() for field in self.FIELDS: if field in key: # store mask as a fixed length for security return self.MASK return value
def processor(data): formatted_msg = msg try: formatted_msg = text_type(msg) if args: formatted_msg = msg % args except Exception: pass kwargs.pop('exc_info', None) data.update({ 'message': formatted_msg, 'category': logger.name, 'level': logging.getLevelName(level).lower(), 'data': kwargs })
def sanitize(self, key, value): if value is None: return if isinstance(value, string_types) and self.VALUES_RE.match(value): return self.MASK if not key: return value if isinstance(key, bytes): key = key.decode('utf-8', 'replace') else: key = text_type(key) key = key.lower() for field in self.FIELDS: if field in key: return self.MASK return value
def gethostname(): if not hasattr(socket, 'gethostname'): return None hostname = socket.gethostname() if isinstance(hostname, text_type): return hostname try: return text_type(hostname) except UnicodeError: pass try: return hostname.decode('unicode-escape') except UnicodeError: pass return None
def sanitize(self, key, value): if value is None: return if isinstance(value, string_types) and self.VALUES_RE.match(value): return self.MASK if not key: # key can be a NoneType return value # key can contain non-ascii symbols if PY2 and isinstance(key, str): key = key.decode('utf8') key = text_type(key).lower() for field in self.FIELDS: if field in key: # store mask as a fixed length for security return self.MASK return value
def sanitize(self, key, value): if value is None: return if isinstance(value, string_types) and self.VALUES_RE.match(value): return self.MASK if not key: # key can be a NoneType return value # Just in case we have bytes here, we want to make them into text # properly without failing so we can perform our check. if isinstance(key, bytes): key = key.decode('utf-8', 'replace') else: key = text_type(key) key = key.lower() for field in self.FIELDS: if field in key: # store mask as a fixed length for security return self.MASK return value
def processor(data): formatted_msg = msg # If people log bad things, this can happen. Then just don't do # anything. try: formatted_msg = text_type(msg) if args: formatted_msg = msg % args except Exception: pass # We do not want to include exc_info as argument because it often # lies (set to a constant value like 1 or True) or even if it's a # tuple it will not be particularly useful for us as we cannot # process it anyways. kwargs.pop('exc_info', None) data.update({ 'message': formatted_msg, 'category': logger.name, 'level': logging.getLevelName(level).lower(), 'data': kwargs, })
def serialize(self, value, **kwargs): string_max_length = kwargs.get('string_max_length', None) return repr(text_type('%s')) % (value[:string_max_length], )
def _emit(self, record, **kwargs): data, extra = extract_extra(record) # Use client name as default user id data.setdefault('user', {'id': self.client.name}) # Retrieve stack stack = getattr(record, 'stack', None) if stack is True: stack = iter_stack_frames() if stack: stack = self._get_targetted_stack(stack, record) # Build message date = datetime.datetime.utcfromtimestamp(record.created) event_type = 'raven.events.Message' handler_kwargs = { 'params': record.args, } try: handler_kwargs['message'] = 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'] = text_type(record.message) except UnicodeDecodeError: # Handle binary strings where it should be unicode... handler_kwargs['formatted'] = repr(record.message)[1:-1] # Retrieve exception information from record try: exc_info = self._exc_info(record) except Exception as ex: log.info('Unable to retrieve exception info - %s', ex, exc_info=True) exc_info = None # Parse exception information exception_hash = None # 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 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 = self._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 elif self.tags: kwargs['tags'] = self.tags # Store `exception_hash` in message (if defined) if exception_hash: 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)
def _emit(self, record, **kwargs): data = {} extra = getattr(record, 'data', None) if not isinstance(extra, dict): if extra: extra = {'data': extra} else: extra = {} for k, v in iteritems(vars(record)): if k in RESERVED: continue if k.startswith('_'): continue if '.' not in k and k not in ('culprit', 'server_name', 'fingerprint'): 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'] = 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'] = 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 if record.exc_info and all(record.exc_info): # 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': record.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 if hasattr(record, 'tags'): kwargs['tags'] = record.tags elif self.tags: kwargs['tags'] = self.tags kwargs.update(handler_kwargs) return self.client.capture(event_type, stack=stack, data=data, extra=extra, date=date, **kwargs)
def __unicode__(self): return text_type(self.base_url)
def _emit(self, record, **kwargs): data = {} extra = getattr(record, 'data', None) if not isinstance(extra, dict): if extra: extra = {'data': extra} else: extra = {} for k, v in iteritems(vars(record)): if k in RESERVED: continue if k.startswith('_'): continue if '.' not in k and k not in ('culprit', 'server_name', 'fingerprint'): 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'] = text_type(record.msg) except UnicodeDecodeError: handler_kwargs['message'] = repr(record.msg)[1:-1] try: handler_kwargs['formatted'] = text_type(record.message) except UnicodeDecodeError: handler_kwargs['formatted'] = repr(record.message)[1:-1] if record.exc_info and all(record.exc_info): handler = self.client.get_handler(event_type) data.update(handler.capture(**handler_kwargs)) event_type = 'raven.events.Exception' handler_kwargs = {'exc_info': record.exc_info} 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 if hasattr(record, 'tags'): kwargs['tags'] = record.tags elif self.tags: kwargs['tags'] = self.tags kwargs.update(handler_kwargs) return self.client.capture(event_type, stack=stack, data=data, extra=extra, date=date, **kwargs)
def _emit(self, record, **kwargs): data, extra = extract_extra(record) # Use client name as default user id data.setdefault('user', {'id': self.client.name}) # Retrieve stack stack = getattr(record, 'stack', None) if stack is True: stack = iter_stack_frames() if stack: stack = self._get_targetted_stack(stack, record) # Build message date = datetime.datetime.utcfromtimestamp(record.created) event_type = 'raven.events.Message' handler_kwargs = { 'params': record.args, } try: handler_kwargs['message'] = 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'] = text_type(record.message) except UnicodeDecodeError: # Handle binary strings where it should be unicode... handler_kwargs['formatted'] = repr(record.message)[1:-1] # Retrieve exception information from record try: exc_info = self._exc_info(record) except Exception as ex: log.info('Unable to retrieve exception info - %s', ex, exc_info=True) exc_info = None # Parse exception information exception_hash = None # 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 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 = self._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 elif self.tags: kwargs['tags'] = self.tags # Store `exception_hash` in message (if defined) if exception_hash: 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 )
class ProxyClient(object): """ A proxy which represents the currently client at all times. """ # introspection support: __members__ = property(lambda x: x.__dir__()) # Need to pretend to be the wrapped class, for the sake of objects that care # about this (especially in equality tests) __class__ = property(lambda x: get_client().__class__) __dict__ = property(lambda o: get_client().__dict__) __repr__ = lambda x: repr(get_client()) __getattr__ = lambda x, o: getattr(get_client(), o) __setattr__ = lambda x, o, v: setattr(get_client(), o, v) __delattr__ = lambda x, o: delattr(get_client(), o) __lt__ = lambda x, o: get_client() < o __le__ = lambda x, o: get_client() <= o __eq__ = lambda x, o: get_client() == o __ne__ = lambda x, o: get_client() != o __gt__ = lambda x, o: get_client() > o __ge__ = lambda x, o: get_client() >= o if PY2: __cmp__ = lambda x, o: cmp(get_client(), o) # NOQA __hash__ = lambda x: hash(get_client()) # attributes are currently not callable # __call__ = lambda x, *a, **kw: get_client()(*a, **kw) __nonzero__ = lambda x: bool(get_client()) __len__ = lambda x: len(get_client()) __getitem__ = lambda x, i: get_client()[i] __iter__ = lambda x: iter(get_client()) __contains__ = lambda x, i: i in get_client() __getslice__ = lambda x, i, j: get_client()[i:j] __add__ = lambda x, o: get_client() + o __sub__ = lambda x, o: get_client() - o __mul__ = lambda x, o: get_client() * o __floordiv__ = lambda x, o: get_client() // o __mod__ = lambda x, o: get_client() % o __divmod__ = lambda x, o: get_client().__divmod__(o) __pow__ = lambda x, o: get_client()**o __lshift__ = lambda x, o: get_client() << o __rshift__ = lambda x, o: get_client() >> o __and__ = lambda x, o: get_client() & o __xor__ = lambda x, o: get_client() ^ o __or__ = lambda x, o: get_client() | o __div__ = lambda x, o: get_client().__div__(o) __truediv__ = lambda x, o: get_client().__truediv__(o) __neg__ = lambda x: -(get_client()) __pos__ = lambda x: +(get_client()) __abs__ = lambda x: abs(get_client()) __invert__ = lambda x: ~(get_client()) __complex__ = lambda x: complex(get_client()) __int__ = lambda x: int(get_client()) if PY2: __long__ = lambda x: long(get_client()) # NOQA __float__ = lambda x: float(get_client()) __str__ = lambda x: binary_type(get_client()) __unicode__ = lambda x: text_type(get_client()) __oct__ = lambda x: oct(get_client()) __hex__ = lambda x: hex(get_client()) __index__ = lambda x: get_client().__index__() __coerce__ = lambda x, o: x.__coerce__(x, o) __enter__ = lambda x: x.__enter__() __exit__ = lambda x, *a, **kw: x.__exit__(*a, **kw)
def __unicode__(self): return text_type("%s: %s" % (self.message, self.code))
def __init__(self, dsn=None, raise_send_errors=False, transport=None, install_sys_hook=True, install_logging_hook=True, hook_libraries=None, enable_breadcrumbs=True, **options): global Raven o = options self._local_state = local() self.raise_send_errors = raise_send_errors # configure loggers first cls = self.__class__ self.state = ClientState() self.logger = logging.getLogger('%s.%s' % (cls.__module__, cls.__name__)) self.error_logger = logging.getLogger('sentry.errors') self.uncaught_logger = logging.getLogger('sentry.errors.uncaught') self._transport_cache = {} self.set_dsn(dsn, transport) self.include_paths = set(o.get('include_paths') or []) self.exclude_paths = set(o.get('exclude_paths') or []) self.name = text_type( o.get('name') or o.get('machine') or defaults.NAME) self.auto_log_stacks = bool( o.get('auto_log_stacks') or defaults.AUTO_LOG_STACKS) self.capture_locals = bool( o.get('capture_locals', defaults.CAPTURE_LOCALS)) self.string_max_length = int( o.get('string_max_length') or defaults.MAX_LENGTH_STRING) self.list_max_length = int( o.get('list_max_length') or defaults.MAX_LENGTH_LIST) self.site = o.get('site') self.include_versions = o.get('include_versions', True) self.processors = o.get('processors') if self.processors is None: self.processors = defaults.PROCESSORS context = o.get('context') if context is None: context = {'sys.argv': getattr(sys, 'argv', [])[:]} self.extra = context self.tags = o.get('tags') or {} self.environment = o.get('environment') or None self.release = o.get('release') or os.environ.get('HEROKU_SLUG_COMMIT') self.transaction = TransactionStack() self.ignore_exceptions = set(o.get('ignore_exceptions') or ()) self.module_cache = ModuleProxyCache() if not self.is_enabled(): self.logger.info( 'Raven is not configured (logging is disabled). Please see the' ' documentation for more information.') if Raven is None: Raven = self # We want to remember the creating thread id here because this # comes in useful for the context special handling self.main_thread_id = get_thread_ident() self.enable_breadcrumbs = enable_breadcrumbs from raven.context import Context self._context = Context(self) if install_sys_hook: self.install_sys_hook() if install_logging_hook: self.install_logging_hook() self.hook_libraries(hook_libraries)