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)
