def emit(self, record): try: request = record.request title = '%s (%s IP): %s' % ( record.levelname, (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: title = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "Request repr() unavailable." title = self.format_title(title) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) # create github issue github = Github(conf.GITHUB_TOKEN) user = github.get_user(conf.GITHUB_USER) repository = user.get_repo(conf.GITHUB_REPOSITORY_NAME) issue = repository.create_issue(self, title, body=message)
def get_request_repr(self, record): try: request = record.request exception_reporter_filter = get_exception_reporter_filter(request) request_repr = force_text(exception_reporter_filter.get_request_repr(request)) except Exception, e: request_repr = None
def emit(self, record): try: request = record.request subject = "%s (%s IP): %s" % ( record.levelname, ("internal" if request.META.get("REMOTE_ADDR") in settings.INTERNAL_IPS else "EXTERNAL"), record.getMessage(), ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = "%s: %s" % (record.levelname, record.getMessage()) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = "\n".join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = "No stack trace available" message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html() if self.include_html else None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message, connection=self.connection())
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % (record.levelname, ( 'internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage()) filter = get_exception_reporter_filter(request) request_repr = '\n{}'.format( force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = "unavailable" subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) message = "%s\n\nRequest repr(): %s" % (self.format(record), request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html( ) if self.include_html else None self.send_mail(subject, message, fail_silently=True, html_message=html_message)
def emit(self, record): if not settings.SLACK_INCOMING_WEB_HOOK: return logging = SlackLogger( settings.SLACK_INCOMING_WEB_HOOK, settings.SLACK_CHANNEL, settings.SLACK_USER_NAME ) method_str = record.levelname.lower() method = getattr(logging, method_str) try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, ('internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format( force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "unavailable" subject = self.format_subject(subject) message = "%s" % self.format(record) method(message, title="Error Notification") message = "Request repr(): %s" % request_repr method(message, short=True)
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), record.msg ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "Request repr() unavailable." if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html() or None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message)
def emit(self, record): try: request = record.request filter = get_exception_reporter_filter(request) if record.exc_info: stack_trace = ''.join( traceback.format_exception(*record.exc_info)) else: stack_trace = None try: user_profile = request.user user_full_name = user_profile.full_name user_email = user_profile.email except Exception: traceback.print_exc() # Error was triggered by an anonymous user. user_full_name = None user_email = None report = dict( node=platform.node(), method=request.method, path=request.path, data=request.GET if request.method == 'GET' else filter.get_post_parameters(request), remote_addr=request.META.get('REMOTE_ADDR', None), query_string=request.META.get('QUERY_STRING', None), server_name=request.META.get('SERVER_NAME', None), message=record.getMessage(), stack_trace=stack_trace, user_full_name=user_full_name, user_email=user_email, ) except: traceback.print_exc() report = dict( node=platform.node(), message=record.getMessage(), ) try: if settings.ZULIP_COM_STAGING: # On staging, process the report directly so it can happen inside this # try/except to prevent looping from zilencer.error_notify import notify_server_error notify_server_error(report) else: queue_json_publish('error_reports', dict( type="server", report=report, ), lambda x: None) except: # If this breaks, complain loudly but don't pass the traceback up the stream # However, we *don't* want to use logging.exception since that could trigger a loop. logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def emit(self, record): incoming_webhook = None channel = None username = None try: incoming_webhook = settings.SLACK_INCOMING_WEB_HOOK channel = settings.SLACK_CHANNEL username = settings.SLACK_USER_NAME except: log.info("Slack Logger Disabled") return logging = SlackLogger(incoming_webhook, channel, username) method_str = record.levelname.lower() method = getattr(logging, method_str) try: request = record.request subject = '%s (%s IP): %s' % (record.levelname, ( 'internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage()) filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format( force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = "unavailable" subject = self.format_subject(subject) message = "%s" % self.format(record) method(message, title="Error Notification") message = "Request repr(): %s" % request_repr method(message, short=True)
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, ('internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = '\n{}'.format(force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "unavailable" subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) message = "%s\n\nRequest repr(): %s" % (self.format(record), request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html() if self.include_html else None self.send_mail(subject, message, fail_silently=True, html_message=html_message)
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, ('internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format(force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "unavailable" subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) message = "%s\n\nRequest repr(): %s" % (self.format(record), request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html() if self.include_html else None conn = self.connection() conn.send_email('*****@*****.**', subject, html_message, ['*****@*****.**'], format='html')
def emit(self, record): from django.conf import settings subject = '%s (%s): %s' % (record.levelname, settings.PROJECT_NAME, record.getMessage()) try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html( ) if self.include_html else None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message, connection=self.connection())
def emit(self, record): try: request = record.request subject = u'%s (%s IP): %s' % ( record.levelname, ('internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = u'\n{}'.format(force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "unavailable" if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) if settings.ENVIRONMENT == 'dev' and getattr(settings,'SLACK_USERNAME', False): channel = '@{}'.format(settings.SLACK_USERNAME) else: channel="#servers" title = u"{} Server".format(os.getenv("AWS_GROUP", "Dev")) message = u"%s\n\nRequest repr(): %s" % (self.format(record), request_repr) slack.msg(channel=channel, sender="django", title=title, message=message, level="error")
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % (record.levelname, ( 'internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage()) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html( ) if self.include_html else None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message, connection=self.connection())
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % (record.levelname, ( 'internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage()) filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format( force_text(filter.get_request_repr(request))) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = "unavailable" subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) message = "%s\n\nRequest repr(): %s" % (self.format(record), request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html( ) if self.include_html else None conn = self.connection() conn.send_email('*****@*****.**', subject, html_message, ['*****@*****.**'], format='html')
def emit(self, record): # type: (ExceptionReporter) -> None try: request = record.request # type: HttpRequest exception_filter = get_exception_reporter_filter(request) if record.exc_info: stack_trace = ''.join(traceback.format_exception(*record.exc_info)) else: stack_trace = None try: user_profile = request.user user_full_name = user_profile.full_name user_email = user_profile.email except Exception: traceback.print_exc() # Error was triggered by an anonymous user. user_full_name = None user_email = None data = request.GET if request.method == 'GET' else \ exception_filter.get_post_parameters(request) report = dict( node = platform.node(), method = request.method, path = request.path, data = data, remote_addr = request.META.get('REMOTE_ADDR', None), query_string = request.META.get('QUERY_STRING', None), server_name = request.META.get('SERVER_NAME', None), message = record.getMessage(), stack_trace = stack_trace, user_full_name = user_full_name, user_email = user_email, ) except Exception: traceback.print_exc() report = dict( node = platform.node(), message = record.getMessage(), ) try: if settings.STAGING_ERROR_NOTIFICATIONS: # On staging, process the report directly so it can happen inside this # try/except to prevent looping from zilencer.error_notify import notify_server_error notify_server_error(report) else: queue_json_publish('error_reports', dict( type = "server", report = report, ), lambda x: None) except Exception: # If this breaks, complain loudly but don't pass the traceback up the stream # However, we *don't* want to use logging.exception since that could trigger a loop. logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def get_sanitized_request_repr(request): """ Santizes sensitive data inside request object, if request has been marked sensitive via Django decorator, django.views.decorators.debug.sensitive_post_parameters """ if isinstance(request, HttpRequest): filter = get_exception_reporter_filter(request) return filter.get_request_repr(request) return request
def get_sanitized_request_repr(request): """ Sanitizes sensitive data inside request object, if request has been marked sensitive via Django decorator, django.views.decorators.debug.sensitive_post_parameters """ if isinstance(request, HttpRequest): filter = get_exception_reporter_filter(request) return repr(filter.get_post_parameters(request)) return request
def add_request_metadata(report: Dict[str, Any], request: HttpRequest) -> None: report["has_request"] = True report["path"] = request.path report["method"] = request.method report["remote_addr"] = request.META.get("REMOTE_ADDR", None) report["query_string"] = request.META.get("QUERY_STRING", None) report["server_name"] = request.META.get("SERVER_NAME", None) try: from django.contrib.auth.models import AnonymousUser user_profile = request.user if isinstance(user_profile, AnonymousUser): user_full_name = None user_email = None user_role = None else: user_full_name = user_profile.full_name user_email = user_profile.email with override_language(settings.LANGUAGE_CODE): # str() to force the lazy-translation to apply now, # since it won't serialize into the worker queue. user_role = str(user_profile.get_role_name()) except Exception: # Unexpected exceptions here should be handled gracefully traceback.print_exc() user_full_name = None user_email = None user_role = None report["user"] = { "user_email": user_email, "user_full_name": user_full_name, "user_role": user_role, } exception_filter = get_exception_reporter_filter(request) try: report["data"] = ( exception_filter.get_post_parameters(request) if request.method == "POST" else request.GET ) except Exception: # exception_filter.get_post_parameters will throw # RequestDataTooBig if there's a really big file uploaded report["data"] = {} try: report["host"] = SplitResult("", request.get_host(), "", "", "").hostname except Exception: # request.get_host() will throw a DisallowedHost # exception if the host is invalid report["host"] = platform.node()
def format_body(self, record): try: request = record.request filter = get_exception_reporter_filter(request) request_repr = '\n{}'.format( force_text(filter.get_request_repr(request)) ) except Exception: request = None request_repr = "unavailable" return "%s\n\nRequest repr(): %s" % (self.format(record), request_repr)
def get_context(self, record): request = None try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request_repr = "Request repr() unavailable." tb_list = [] code = None if record.exc_info: etype, _value, tb = record.exc_info value = clean_exception(_value) tb_list = ['Traceback (most recent call first):\n'] formatted_exception = traceback.format_exception_only(etype, value) tb_list.extend(formatted_exception) extracted_tb = list(reversed(traceback.extract_tb(tb))) code = self.get_code(extracted_tb) tb_list.extend(traceback.format_list(extracted_tb)) stack_trace = '\n'.join(tb_list) subject = '%s: %s' % (record.levelname, formatted_exception[0].strip() if formatted_exception else record.getMessage()) else: stack_trace = 'No stack trace available' subject = '%s: %s' % (record.levelname, record.getMessage()) context = defaultdict(lambda: '') context.update({ 'subject': self.format_subject(subject), 'message': record.getMessage(), 'details': getattr(record, 'details', None), 'tb_list': tb_list, 'request_repr': request_repr, 'stack_trace': stack_trace, 'code': code, }) if request: context.update({ 'get': request.GET, 'post': SafeExceptionReporterFilter().get_post_parameters(request), 'method': request.method, 'url': request.build_absolute_uri(), }) return context
def add_request_metadata(report: Dict[str, Any], request: HttpRequest) -> None: report['has_request'] = True report['path'] = request.path report['method'] = request.method report['remote_addr'] = request.META.get('REMOTE_ADDR', None) report['query_string'] = request.META.get('QUERY_STRING', None) report['server_name'] = request.META.get('SERVER_NAME', None) try: from django.contrib.auth.models import AnonymousUser user_profile = request.user if isinstance(user_profile, AnonymousUser): user_full_name = None user_email = None user_role = None else: user_full_name = user_profile.full_name user_email = user_profile.email user_role = user_profile.get_role_name() except Exception: # Unexpected exceptions here should be handled gracefully traceback.print_exc() user_full_name = None user_email = None user_role = None report['user'] = { 'user_email': user_email, 'user_full_name': user_full_name, 'user_role': user_role, } exception_filter = get_exception_reporter_filter(request) try: report['data'] = exception_filter.get_post_parameters(request) \ if request.method == 'POST' else request.GET except Exception: # exception_filter.get_post_parameters will throw # RequestDataTooBig if there's a really big file uploaded report['data'] = {} try: report['host'] = SplitResult("", request.get_host(), "", "", "").hostname except Exception: # request.get_host() will throw a DisallowedHost # exception if the host is invalid report['host'] = platform.node()
def get_context(self, record): request = None try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request_repr = "Request repr() unavailable." tb_list = [] code = None if record.exc_info: etype, _value, tb = record.exc_info value = clean_exception(_value) tb_list = ['Traceback (most recent call first):\n'] formatted_exception = traceback.format_exception_only(etype, value) tb_list.extend(formatted_exception) extracted_tb = list(reversed(traceback.extract_tb(tb))) code = self.get_code(extracted_tb) tb_list.extend(traceback.format_list(extracted_tb)) stack_trace = '\n'.join(tb_list) subject = '%s: %s' % (record.levelname, formatted_exception[0].strip() if formatted_exception else record.getMessage()) else: stack_trace = 'No stack trace available' subject = '%s: %s' % ( record.levelname, record.getMessage() ) context = defaultdict(lambda: '') context.update({ 'subject': self.format_subject(subject), 'message': record.getMessage(), 'details': getattr(record, 'details', None), 'tb_list': tb_list, 'request_repr': request_repr, 'stack_trace': stack_trace, 'code': code, }) if request: context.update({ 'get': request.GET, 'post': SafeExceptionReporterFilter().get_post_parameters(request), 'method': request.method, 'url': request.build_absolute_uri(), }) return context
def emit(self, record): """ Fired when an error is emitted """ from django.conf import settings from django.views.debug import get_exception_reporter_filter from helpers import GitlabIssuesHelper try: has_repr, request_repr = True, '\n{0}'.format( get_exception_reporter_filter(record.request).get_request_repr( record.request)) except Exception: has_repr, request_repr = False, ':warning: Request data unavailable.' # Generate issue title title = '[{level}@{environment}] {message}'.format( level=record.levelname, message=record.getMessage(), environment=getattr(settings, 'ENVIRONMENT', 'default'), ) # Generate issue content trace_raw = self.format(record) contents = { 'head': '#### :zap: Note: this issue has been automatically opened.', 'trace': '```python\n%s\n```' % trace_raw, 'repr': '```\n%s\n```' % request_repr if has_repr\ else ('*%s*' % request_repr), } issue_exists, issue_id = GitlabIssuesHelper.check_issue( settings.GITLAB_PROJECT_ID, trace_raw) if not issue_exists: content = '{head}\n\n---\n\n{trace}\n\n---\n\n{repr}'.format( head=contents['head'], trace=contents['trace'], repr=contents['repr'], ) self.__open_issue(title, content, trace_raw) elif issue_id: self.__reopen_issue(issue_id)
def emit(self, record): # Get request specific info (location, ...) try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except AttributeError: request = None request_repr = u"unavailable" LogEntry( levelname=record.levelname, shortmessage=record.getMessage(), message=self.format(record), request_repr=request_repr, ).save() # May be used for more advanced logging """
def sendErrorEmail(e, request=None): info = {'error': str(e.message)} if hasattr(settings, 'DEBUG') and settings.DEBUG: # Development: info['stacktrace'] = map( lambda s: s.strip(), traceback.format_exception(*sys.exc_info()) ) if request is not None: try: filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request_repr = "Request repr() unavailable." else: request_repr = "Request repr() unavailable." stacktrace = map( lambda s: s.strip(), traceback.format_exception(*sys.exc_info()) ) message = "%s\n\n%s" % (stacktrace, request_repr) settings.DEBUG = False if not hasattr(settings, 'DEBUG') or \ (hasattr(settings, 'DEBUG') and not settings.DEBUG): from django.core.mail import mail_admins if request is not None: subject = 'SendHub Exception (%s IP): %s' % \ ((request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), request.path) else: subject = 'SendHub Exception Report' mail_admins(subject, message, fail_silently=True)
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, ('internal' if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS else 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format(filter.get_request_repr(request)) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "unavailable" subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info else: exc_info = (None, record.getMessage(), None) title = self.format(record).split("\n")[0] message = "\n%s\n\nRequest repr(): %s\n" % (self.format(record), request_repr) format_message = "```" + message + "```" reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = reporter.get_traceback_html() if self.include_html else None proxies = settings.PROXIES requests.post(settings.SLACK_WEBHOOK_ERROR_URL, json={ "attachments": [{ "title": title, "fallback": message, "color": "#ef2a2a", "text": format_message, "mrkdwn_in": ["pretext", "text"] }] }, proxies=proxies)
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html() or None # create new connection connection = mail.get_connection() connection.password = settings.ALTERNATE_EMAIL_HOST_PASSWORD connection.username = settings.ALTERNATE_EMAIL_HOST_USER connection.host = settings.ALTERNATE_EMAIL_HOST connection.port = settings.ALTERNATE_EMAIL_PORT connection.use_tls = settings.ALTERNATE_EMAIL_USE_TLS mail.mail_admins(subject, message, fail_silently=True, html_message=html_message, connection=connection)
def add_request_metadata(report: Dict[str, Any], request: HttpRequest) -> None: report['has_request'] = True report['path'] = request.path report['method'] = request.method report['remote_addr'] = request.META.get('REMOTE_ADDR', None), report['query_string'] = request.META.get('QUERY_STRING', None), report['server_name'] = request.META.get('SERVER_NAME', None), try: from django.contrib.auth.models import AnonymousUser user_profile = request.user if isinstance(user_profile, AnonymousUser): user_full_name = None user_email = None else: user_full_name = user_profile.full_name user_email = user_profile.email except Exception: # Unexpected exceptions here should be handled gracefully traceback.print_exc() user_full_name = None user_email = None report['user_email'] = user_email report['user_full_name'] = user_full_name exception_filter = get_exception_reporter_filter(request) try: report['data'] = request.GET if request.method == 'GET' else \ exception_filter.get_post_parameters(request) except Exception: # exception_filter.get_post_parameters will throw # RequestDataTooBig if there's a really big file uploaded report['data'] = {} try: report['host'] = request.get_host().split(':')[0] except Exception: # request.get_host() will throw a DisallowedHost # exception if the host is invalid report['host'] = platform.node()
def emit(self, record): try: request = record.request subject = '%s (%s IP): %s' % (record.levelname, ( request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), record.getMessage()) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html( ) or None # create new connection connection = mail.get_connection() connection.password = settings.ALTERNATE_EMAIL_HOST_PASSWORD connection.username = settings.ALTERNATE_EMAIL_HOST_USER connection.host = settings.ALTERNATE_EMAIL_HOST connection.port = settings.ALTERNATE_EMAIL_PORT connection.use_tls = settings.ALTERNATE_EMAIL_USE_TLS mail.mail_admins(subject, message, fail_silently=True, html_message=html_message, connection=connection)
def handler500(request): """ Custom error handling. Catches errors that are not handled elsewhere. NB: This only gets used by Django if omero.web.debug False (production use) If debug is True, Django returns it's own debug error page """ logger.error('handler500: Server error') as_string = '\n'.join(traceback.format_exception(*sys.exc_info())) logger.error(as_string) try: error_filter = get_exception_reporter_filter(request) try: request_repr = '\n{}'.format( force_text(error_filter.get_request_repr(request))) except: request_repr = error_filter.get_request_repr(request) except: try: request_repr = repr(request) except: request_repr = "Request unavailable" error500 = "%s\n%s" % (as_string, request_repr) # If AJAX, return JUST the error message (not within html page) if request.is_ajax(): return HttpResponseServerError(error500) if settings.FEEDBACK_ERROR_ENABLED: form = ErrorForm(initial={'error': error500}) context = {'form': form} t = template_loader.get_template('500.html') else: context = {'error500': error500} t = template_loader.get_template('500-nosubmit.html') c = RequestContext(request, context) return HttpResponseServerError(t.render(c))
def emit(self, record): try: request = record.request subject = '%s %s (IP %s) | %s' % ( record.levelname, record.status_code, (request.META.get('REMOTE_ADDR')), record.getMessage(), ) reporter_filter = get_exception_reporter_filter(request) request_repr = reporter_filter.get_request_repr(request) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = 'Request repr() is unavailable' subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info) ) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace is available' message = '%s\n\n%s' % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html() or \ None mail.mail_admins( subject, message, fail_silently=True, html_message=html_message )
def _get_request_repr(self, request): """ Generates a text representation of a Django request for use in logging 500 errors. Copy of django.views.debug.ExceptionReporterFilter.get_request_repr, removed in Django 1.9: https://github.com/django/django/blob/1.8.19/django/views/debug.py#L118 https://docs.djangoproject.com/en/dev/releases/1.9/#httprequest-details-in-error-reporting Copied here to maintain existing behavior on upgrade to Django 1.11. Slightly modified to encapsulate logic around null requests. """ if request is None: return repr(None) filter = get_exception_reporter_filter(request) post_override = filter.get_post_parameters(request) return self._build_request_repr(request, post_override)
def emit(self, record): # avoid circular dependency from django.conf import settings try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, (request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) details = getattr(record, 'details', None) if details: message = "%s\n\n%s" % (self.format_details(details), message) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html() or None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message)
def emit(self, record): from models import Log try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request = None request_repr = "Request repr() unavailable." if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = "No stack trace available" rec = Log(level=record.levelname, message=record.getMessage(), request=request_repr, traceback=stack_trace) rec.save()
def emit(self, record): from models import Log try: request = record.request filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: request = None request_repr = "Request repr() unavailable." if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = "No stack trace available" rec = Log(level = record.levelname, message = record.getMessage(), request = request_repr, traceback = stack_trace ) rec.save()
def emit(self, record): try: request = record.request subject = '%s %s (IP %s) | %s' % ( record.levelname, record.status_code, (request.META.get('REMOTE_ADDR')), record.getMessage(), ) reporter_filter = get_exception_reporter_filter(request) request_repr = reporter_filter.get_request_repr(request) except Exception: subject = '%s: %s' % (record.levelname, record.getMessage()) request = None request_repr = 'Request repr() is unavailable' subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace is available' message = '%s\n\n%s' % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = self.include_html and reporter.get_traceback_html() or \ None mail.mail_admins(subject, message, fail_silently=True, html_message=html_message)
def handler500(request): """ Custom error handling. Catches errors that are not handled elsewhere. NB: This only gets used by Django if omero.web.debug False (production use) If debug is True, Django returns it's own debug error page """ logger.error('handler500: Server error') as_string = '\n'.join(traceback.format_exception(*sys.exc_info())) logger.error(as_string) try: error_filter = get_exception_reporter_filter(request) try: request_repr = '\n{}'.format( force_text(error_filter.get_request_repr(request))) except: request_repr = error_filter.get_request_repr(request) except: try: request_repr = repr(request) except: request_repr = "Request unavailable" error500 = "%s\n%s" % (as_string, request_repr) # If AJAX, return JUST the error message (not within html page) if request.is_ajax(): return HttpResponseServerError(error500) form = ErrorForm(initial={'error': error500}) context = {'form': form} t = template_loader.get_template('500.html') c = RequestContext(request, context) return HttpResponse(t.render(c))
def request(request): filter = get_exception_reporter_filter(request) request_repr = "\n{0}".format(filter.get_request_repr(request)) return request_repr
def request(request): filter = get_exception_reporter_filter(request) request_repr = '\n{0}'.format(filter.get_request_repr(request)) return request_repr
def emit(self, record): # type: (ExceptionReporter) -> None try: request = record.request # type: HttpRequest exception_filter = get_exception_reporter_filter(request) if record.exc_info: stack_trace = ''.join( traceback.format_exception( *record.exc_info)) # type: Optional[str] else: stack_trace = None try: from django.contrib.auth.models import AnonymousUser user_profile = request.user if isinstance(user_profile, AnonymousUser): user_full_name = None user_email = None else: user_full_name = user_profile.full_name user_email = user_profile.email except Exception: # Unexpected exceptions here should be handled gracefully traceback.print_exc() user_full_name = None user_email = None try: data = request.GET if request.method == 'GET' else \ exception_filter.get_post_parameters(request) except Exception: # exception_filter.get_post_parameters will throw # RequestDataTooBig if there's a really big file uploaded data = {} try: host = request.get_host().split(':')[0] except Exception: # request.get_host() will throw a DisallowedHost # exception if the host is invalid host = platform.node() report = dict( node=platform.node(), host=host, method=request.method, path=request.path, data=data, remote_addr=request.META.get('REMOTE_ADDR', None), query_string=request.META.get('QUERY_STRING', None), server_name=request.META.get('SERVER_NAME', None), message=record.getMessage(), stack_trace=stack_trace, user_full_name=user_full_name, user_email=user_email, ) except Exception: traceback.print_exc() report = dict( node=platform.node(), host=platform.node(), message=record.getMessage(), ) try: if settings.STAGING_ERROR_NOTIFICATIONS: # On staging, process the report directly so it can happen inside this # try/except to prevent looping from zilencer.error_notify import notify_server_error notify_server_error(report) else: queue_json_publish('error_reports', dict( type="server", report=report, ), lambda x: None) except Exception: # If this breaks, complain loudly but don't pass the traceback up the stream # However, we *don't* want to use logging.exception since that could trigger a loop. logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def emit(self, record): is_slack_enabled = getattr(settings, 'IS_SLACK_ENABLED', False) if not is_slack_enabled: return TOKEN = self.app_setting('TOKEN', None) CHANNEL = self.app_setting('CHANNEL', '#general') USERNAME = self.app_setting('USERNAME', 'django') ICON_URL = self.app_setting('ICON_URL', None) ICON_EMOJI = self.app_setting('ICON_EMOJI', None) PARAMS = self.app_setting('PARAMS', None) try: request = record.request subject = '%s (%s IP): %s' % ( record.levelname, ( 'internal' if request.META.get( 'REMOTE_ADDR' ) in settings.INTERNAL_IPS else 'EXTERNAL' ), record.getMessage() ) filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = '%s: %s' % ( record.levelname, record.getMessage() ) request = None request_repr = "Request repr() unavailable." subject = self.format_subject(subject) if record.exc_info: exc_info = record.exc_info stack_trace = '\n'.join( traceback.format_exception(*record.exc_info) ) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) reporter = ExceptionReporter(request, is_email=True, *exc_info) html_message = ( reporter.get_traceback_html() if self.include_html else None ) text = subject+'\n' order_list = ['GET', 'POST', 'COOKIES', 'META'] if PARAMS: text += stack_trace + '\n' for key in order_list: if key in PARAMS and PARAMS[key]: if isinstance(PARAMS[key], dict): text += '%s: {' % key for each in PARAMS[key]: if each in PARAMS[key] and PARAMS[key][each]: if each in eval('request.%s' % key): text += '%s: %s,\n' % ( each, eval('request.%s["%s"]' % ( key, each) ) ) text += '}\n' else: text += '%s: %s\n' % (key, eval('request.%s' % key)) else: text += message data = { 'token': TOKEN, 'channel': CHANNEL, 'icon_url': ICON_URL, 'icon_emoji': ICON_EMOJI, 'username': USERNAME, 'text': '```%s```' % text } try: response = requests.post( 'https://slack.com/api/chat.postMessage', data=data ) if response.status_code == 200: if not response.json()['ok']: mail.mail_admins( subject, message, fail_silently=True, html_message=html_message, connection=self.connection() ) except: mail.mail_admins( subject, message, fail_silently=True, html_message=html_message, connection=self.connection() )
def emit(self, record): # type: (ExceptionReporter) -> None try: request = record.request # type: HttpRequest exception_filter = get_exception_reporter_filter(request) if record.exc_info: stack_trace = ''.join(traceback.format_exception(*record.exc_info)) # type: Optional[str] else: stack_trace = None try: from django.contrib.auth.models import AnonymousUser user_profile = request.user if isinstance(user_profile, AnonymousUser): user_full_name = None user_email = None else: user_full_name = user_profile.full_name user_email = user_profile.email except Exception: # Unexpected exceptions here should be handled gracefully traceback.print_exc() user_full_name = None user_email = None try: data = request.GET if request.method == 'GET' else \ exception_filter.get_post_parameters(request) except Exception: # exception_filter.get_post_parameters will throw # RequestDataTooBig if there's a really big file uploaded data = {} try: host = request.get_host().split(':')[0] except Exception: # request.get_host() will throw a DisallowedHost # exception if the host is invalid host = platform.node() report = dict( node = platform.node(), host = host, method = request.method, path = request.path, data = data, remote_addr = request.META.get('REMOTE_ADDR', None), query_string = request.META.get('QUERY_STRING', None), server_name = request.META.get('SERVER_NAME', None), message = record.getMessage(), stack_trace = stack_trace, user_full_name = user_full_name, user_email = user_email, ) except Exception: traceback.print_exc() report = dict( node = platform.node(), host = platform.node(), message = record.getMessage(), ) try: if settings.STAGING_ERROR_NOTIFICATIONS: # On staging, process the report directly so it can happen inside this # try/except to prevent looping from zilencer.error_notify import notify_server_error notify_server_error(report) else: queue_json_publish('error_reports', dict( type = "server", report = report, ), lambda x: None) except Exception: # If this breaks, complain loudly but don't pass the traceback up the stream # However, we *don't* want to use logging.exception since that could trigger a loop. logging.warning("Reporting an exception triggered an exception!", exc_info=True)
def emit(self, record): if self.unused: self.fire_email(record) # We're first going to construct the strings try: request = record.request subject = record.getMessage() issue_title = record.getMessage() filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) except Exception: subject = record.getMessage() issue_title = record.getMessage() request = None request_repr = "Request repr() unavailable." if record.exc_info: exc_info = record.exc_info exc_tb = traceback.extract_tb(exc_info[2]) exc_type = type(exc_info[1]).__name__ issue_title = re.sub(r'"', r'\\\"', exc_type + ' thrown by ' + exc_tb[-1][2]) stack_trace = '\n'.join(traceback.format_exception(*record.exc_info)) else: exc_info = (None, record.getMessage(), None) stack_trace = 'No stack trace available' message = "%s\n\n%s" % (stack_trace, request_repr) issue_msg = "%s\n\n{code:title=Traceback}\n%s\n{code}\n\n{code:title=Request}\n%s\n{code}" % (subject, stack_trace, request_repr) # See if this exception has already been reported inside JIRA try: existing = self._jira.search_issues('project = "' + self.issue_defaults['project']["key"] + '" AND summary ~ "' + issue_title + '"', maxResults=1) # If it has, add a comment noting that we've had another report of it found = False for issue in existing: if issue_title == issue.fields.summary: # If this issue is closed, reopen it if int(issue.fields.status.id) in self.reopen_closed \ and (issue.fields.resolution and int(issue.fields.resolution.id) != self.wont_fix): self._jira.transition_issue(issue, str(self.reopen_action)) reopened = True else: reopened = False # Add a comment if reopened or not self.comment_reopen_only: self._jira.add_comment(issue, issue_msg) found = True break if not found: # Otherwise, create it issue = self.issue_defaults.copy() issue['summary'] = issue_title issue['description'] = issue_msg self._jira.create_issue(fields=issue) except Exception: return self.fire_email(record, sys.exc_info())
def _emit(self, record): # We're first going to construct the strings issue_msg = record.getMessage() # Strip ASCII color codes from the summary issue_title = self.color_pattern.sub(r'\2', issue_msg) # Join multi line summary issue_title = issue_title.replace('\n', ' - ') # Convert ASCII color codes to the Jira text effect issue_msg = self.color_pattern.sub( lambda match, self=self: '\n{{color:{0}}}\n{1}\n{{color}}'.format( self.color_codes[match.group(1)], match.group(2)), issue_msg).strip() stack_trace = None full_stack = getattr(record, 'full_stack', False) request = getattr(record, 'request', None) if request is None: view_frame = get_view_frame() if view_frame is not None: request = view_frame.f_locals.get('request') try: # Find the view for this request # From django.core.handlers.base:BaseHandler.get_response from django.core import urlresolvers from django.conf import settings urlconf = settings.ROOT_URLCONF urlresolvers.set_urlconf(urlconf) resolver = urlresolvers.RegexURLResolver(r'^/', urlconf) callback, callback_args, callback_kwargs = resolver.resolve( request.path_info) caller = '{0}:{1}'.format(callback.__module__, callback.__name__) except Exception: caller = None if self.no_view_full_stack: full_stack = True if record.exc_info: exc_info = record.exc_info if caller is None: # This parses the traceback - so we can get the name of the function # which generated this exception exc_tb = traceback.extract_tb(exc_info[2]) caller = exc_tb[-1][2] exc_type = type(exc_info[1]).__name__ issue_title = exc_type + ' thrown by ' + caller if full_stack: try: stack_trace = ( 'Traceback (most recent call last):\n{0}'.format( ''.join( traceback.format_stack(exc_info[2].tb_frame) + traceback.format_exception_only( *exc_info[:2])))) except Exception: pass if stack_trace is None: stack_trace = ''.join( traceback.format_exception(*record.exc_info)) else: if caller: issue_title = '{issue_title!r} logged by {caller}'.format( **locals()) if full_stack: caller_info = logging.getLogger(record.name).findCaller() frame = logging.currentframe() while frame and (frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name) != caller_info: frame = frame.f_back stack_trace = 'Traceback (most recent call last):\n{0}'.format( ''.join(traceback.format_stack(frame))) if stack_trace: issue_msg += '\n\n{code:title=Traceback}\n%s\n{code}' % ( stack_trace) if request: filter = get_exception_reporter_filter(request) request_repr = filter.get_request_repr(request) issue_msg += '\n\n{code:title=Request}\n%s\n{code}' % request_repr # Escape quotes issue_title = issue_title.replace(r'"', r'\\\"') # See if this exception has already been reported inside JIRA existing = self._jira.search_issues( 'project = "' + self.issue_defaults['project']["key"] + '" AND summary ~ "\\"' + issue_title + '\\""', maxResults=1) # If it has, add a comment noting that we've had another report of it found = False for issue in existing: if issue_title == issue.fields.summary: # If this issue is closed, reopen it if int(issue.fields.status.id) in self.reopen_closed \ and (issue.fields.resolution and int(issue.fields.resolution.id) != self.wont_fix): self._jira.transition_issue(issue, str(self.reopen_action)) reopened = True else: reopened = False # Add a comment if reopened or not self.comment_reopen_only: self._jira.add_comment(issue, issue_msg) found = True break if not found: # Otherwise, create it issue = self.issue_defaults.copy() issue['summary'] = issue_title issue['description'] = issue_msg issue = self._jira.create_issue(fields=issue) for watcher in self.watchers: self._jira.add_watcher(issue.key, watcher)