def install_plugins(settings):
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
installed_apps = list(settings.INSTALLED_APPS)
for ep in pkg_resources.iter_entry_points('sentry.apps'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
print >> sys.stderr, "Failed to load app %r:\n%s" % (
ep.name, traceback.format_exc())
else:
installed_apps.append(ep.module_name)
settings.INSTALLED_APPS = tuple(installed_apps)
for ep in pkg_resources.iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
print >> sys.stderr, "Failed to load plugin %r:\n%s" % (
ep.name, traceback.format_exc())
else:
register(plugin)
def install_plugins(settings):
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
installed_apps = list(settings.INSTALLED_APPS)
for ep in pkg_resources.iter_entry_points('sentry.apps'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
print >> sys.stderr, "Failed to load app %r:\n%s" % (ep.name, traceback.format_exc())
else:
installed_apps.append(ep.module_name)
settings.INSTALLED_APPS = tuple(installed_apps)
for ep in pkg_resources.iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
print >> sys.stderr, "Failed to load plugin %r:\n%s" % (ep.name, traceback.format_exc())
else:
register(plugin)
def register_plugins(settings):
from pkg_resources import iter_entry_points
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
for ep in iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import traceback
click.echo("Failed to load plugin %r:\n%s" % (ep.name, traceback.format_exc()), err=True)
else:
register(plugin)
def register_plugins(settings):
from pkg_resources import iter_entry_points
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
for ep in iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import traceback
click.echo("Failed to load plugin %r:\n%s" % (ep.name, traceback.format_exc()), err=True)
else:
register(plugin)
def register_plugins(settings):
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
for ep in pkg_resources.iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
sys.stderr.write("Failed to load plugin %r:\n%s\n" % (ep.name, traceback.format_exc()))
else:
register(plugin)
def register_plugins(settings):
from sentry.plugins import register
# entry_points={
# 'sentry.plugins': [
# 'phabricator = sentry_phabricator.plugins:PhabricatorPlugin'
# ],
# },
for ep in pkg_resources.iter_entry_points('sentry.plugins'):
try:
plugin = ep.load()
except Exception:
import sys
import traceback
sys.stderr.write("Failed to load plugin %r:\n%s\n" % (ep.name, traceback.format_exc()))
else:
register(plugin)
threshold = self.condition_rate / TIME_PERIODS[self.condition_rate_period]
logger.debug("current throughput is %f/s" % throughput)
try:
condition = 5 - min(int(throughput / threshold), 4)
except ZeroDivisionError:
condition = 5
if condition == COCKED_PISTOL:
self.set_cocked()
logger.debug("current condition is %r" % condition)
return condition
def post_process(self, group, event, is_new, is_sample, **kwargs):
self.update_throughput_per_second()
self.condition()
register(Defcon)
def notify_defcon_one(sender, **kwargs):
emails = sender.get_option('send_to') or []
if isinstance(emails, basestring):
emails = [s.strip() for s in emails.split(',')]
msg = EmailMultiAlternatives(
'Defcon 1 reached!',
'We reached DEFCON 1, error rate reached errors per seconds!',
settings.SENTRY_SERVER_EMAIL,
emails
)
msg.send(fail_silently=True)
signals.defcon_one_reached.connect(notify_defcon_one)
:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import sentry
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class SitesPlugin(TagPlugin):
"""
Automatically adds the 'site' tag from events.
"""
slug = 'sites'
title = _('Sites')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'site'
tag_label = _('Site')
def get_tag_values(self, event):
if not event.site:
return []
return [event.site]
register(SitesPlugin)
from sentry.interfaces import Message
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class ArgsPlugin(TagPlugin):
slug = 'args'
title = 'Auto Tag: Args'
author = "Hiroki KIYOHARA"
tag = 'args'
tag_label = 'Args'
project_default_enabled = True
def get_tag_values(self, event):
tags_list = []
d = event.interfaces
for interface in d.values():
if isinstance(interface, Message):
tags_list.extend(interface.params)
return tags_list
register(ArgsPlugin)
from __future__ import absolute_import from sentry.plugins import register from .plugin import PopoPlugin register(PopoPlugin)
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class UrlsPlugin(TagPlugin):
"""
Automatically adds the 'url' tag from events containing interface data
from ``sentry.interfaes.Http``.
"""
slug = 'urls'
title = _('URLs')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'url'
tag_label = _('URL')
def get_tag_values(self, event):
http = event.interfaces.get('sentry.interfaces.Http')
if not http:
return []
if not http.url:
return []
return [http.url]
register(UrlsPlugin)
from __future__ import absolute_import from sentry.plugins import register from .plugin import NativePlugin register(NativePlugin)
ua = ua['user_agent']
if not ua['family']:
return
version = '.'.join(value for value in [
ua['major'],
ua['minor'],
] if value)
tag = ua['family']
if version:
tag += ' ' + version
return tag
register(BrowserPlugin)
class OsPlugin(UserAgentPlugin):
"""
Automatically adds the 'os' tag from events containing interface data
from ``sentry.interfaces.Http``.
"""
slug = 'os'
title = _('Auto Tag: Operating Systems')
tag = 'os'
tag_label = _('Operating System')
def get_tag_from_ua(self, ua):
ua = ua['os']
title = _('Browsers')
tag = 'browser'
tag_label = _('Browser Name')
def get_tag_from_ua(self, ua):
if 'browser' not in ua:
return
tag = ua['browser']['name']
if 'version' in ua['browser']:
tag += ' ' + ua['browser']['version']
return tag
register(BrowserPlugin)
class OsPlugin(UserAgentPlugin):
"""
Adds additional support for showing information about operating systems including:
* A panel which shows all operating systems a message was seen on.
* A sidebar module which shows the operating systems most actively seen on.
"""
slug = 'os'
title = _('Operating Systems')
tag = 'os'
tag_label = _('Operating System')
def get_tag_from_ua(self, ua):
def get_unique_servers(self, group):
return group.messagefiltervalue_set.filter(key='server_name')\
.values_list('value')\
.annotate(times_seen=Sum('times_seen'))\
.values_list('value', 'times_seen', 'first_seen', 'last_seen')\
.order_by('-times_seen')
def panels(self, request, group, panel_list, **kwargs):
panel_list.append((self.get_title(), self.get_url(group)))
return panel_list
def view(self, request, group, **kwargs):
return self.render('sentry/plugins/sentry_servers/index.html', {
'unique_servers': self.get_unique_servers(group),
'group': group,
})
def widget(self, request, group, **kwargs):
return self.render(
'sentry/plugins/sentry_servers/widget.html', {
'unique_servers': list(self.get_unique_servers(group)[:10]),
'group': group,
})
def get_filters(self, project=None, **kwargs):
return [ServerNameFilter]
register(ServersPlugin)
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class UserEmailsPlugin(TagPlugin):
"""
Adds additional support for showing information about users including:
* A panel which shows all users a message was created by.
* A sidebar module which shows the users most actively seeing event.
"""
slug = 'user-emails'
title = _('Auto Tag: User Emails')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'user_email'
tag_label = _('User Email')
def get_tag_values(self, event):
user = event.interfaces.get('sentry.interfaces.User')
if not user:
return []
if not getattr(user, 'email', None):
return []
return [user.email]
register(UserEmailsPlugin)
def ready(self):
from .plugin import NativePlugin
from sentry.plugins import register
register(NativePlugin)
from __future__ import absolute_import
from django.conf import settings
__version__ = '0.0.1'
if settings.configured:
from sentry.plugins import plugins, register
from sentry_telegraf.plugin import TelegrafPlugin
if TelegrafPlugin.slug not in [plugin.slug for plugin in plugins.all()]:
register(TelegrafPlugin)
base_fields = [RULES_DATA_KEY]
def __init__(self, *args, **kwargs):
initial = kwargs.get('initial', {}).get(RULES_DATA_KEY)
if initial:
kwargs['initial'] = pickle.loads(initial)
super(PatchedGroupRuleFormSet, self).__init__(*args, **kwargs)
@property
def cleaned_data(self):
data = getattr(super(PatchedGroupRuleFormSet, self), 'cleaned_data', {})
return {RULES_DATA_KEY: pickle.dumps(data)}
class GrouperPlugin(Plugin):
slug = 'group_rules'
conf_key = 'group_rules'
conf_key_rules = RULES_DATA_KEY
title = _('Grouping Rules')
version = sentry_grouper.VERSION
author = "Tommaso Barbugli"
author_url = "https://github.com/tbarbugli/sentry_grouper"
project_conf_template = 'sentry/plugins/sentry_grouper/project_configuration.html'
project_conf_form = PatchedGroupRuleFormSet
def get_project_rules(self, project):
rules = self.get_option(RULES_DATA_KEY, project)
unpickled = rules and pickle.loads(rules) or {RULES_DATA_KEY: []}
return unpickled
register(GrouperPlugin)
# coding: utf-8
"""
Plugin for Sentry which allows sending notification via Telegram messenger.
"""
from django.conf import settings
__version__ = '0.2.1'
if settings.configured:
from sentry.plugins import plugins, register
from plugin import TelegramNotificationsPlugin
if TelegramNotificationsPlugin.slug not in [
plugin.slug for plugin in plugins.all()
]:
register(TelegramNotificationsPlugin)
from __future__ import absolute_import from sentry.plugins import register from .plugin import SlackPlugin register(SlackPlugin)
from __future__ import absolute_import from sentry.plugins import register from .plugin import WebHooksPlugin register(WebHooksPlugin)
title = 'JSON Mailer'
conf_title = title
conf_key = 'jsonmailprocessor'
# We want all events, not just new ones, so we override
# this method to remove the is_new check.
def post_process(self, group, event, is_new, is_sample, **kwargs):
if not self.should_notify(group, event):
return
self.notify_users(group, event)
# Overrides the method from MailProcessor
def get_plaintext_body(self, group, event, link, interface_list):
header = "SENTRY_EVENT_MAIL"
event.data['date_local_tz'] = str(timezone.localtime(event.datetime))
data = {
'server_name' : event.server_name,
'culprit' : event.culprit,
'level' : event.level,
'event_id' : event.event_id,
'message' : event.message,
'date' : str(event.datetime),
'data': event.data
}
return " ".join([header, json.dumps(data, separators=(',', ':'))])
register(JsonMailProcessor)
from sentry.plugins import Plugin, register
class FacebookPlugin(Plugin):
title = 'Facebook'
slug = 'facebook'
version = '0.1'
author = 'George Marshall'
register(FacebookPlugin)
def setUp(self):
super(JIRAPluginTest, self).setUp()
register(self.plugin_cls)
self.group = self.create_group(message='Hello world', culprit='foo.bar')
self.event = self.create_event(group=self.group, message='Hello world')
# coding: utf-8
"""
sentry_zabbix
"""
from __future__ import absolute_import
try:
VERSION = __import__('pkg_resources').get_distribution(__name__).version
except Exception, e:
VERSION = 'unknown'
from sentry.plugins import register
from .plugin import ZabbixPlugin
register(ZabbixPlugin)
slug = 'sentry_smart_mailer'
conf_key = 'sentry_smart_mailer'
version = sentry_smart_mailer.VERSION
author = "Tommaso Barbugli"
author_url = "https://github.com/tbarbugli/sentry_smart_mailer"
def should_notify(self, group):
return SwitchManager.send_email(group=group, logger_name=group.logger)
def post_process(self, group, event, is_new, is_sample, **kwargs):
lock_key = 'lock_mail:%s' % group.id
try:
with Lock(lock_key, timeout=0.5):
self._post_process(group, event, is_new, is_sample, **kwargs)
except UnableToGetLock:
pass
def _post_process(self, group, event, is_new, is_sample, **kwargs):
if not self.should_notify(group):
return
try:
email_sent_at = list(get_last_email_sent_at(group))
except:
email_sent_at = []
self.notify_users(group, event)
email_sent_at.append((datetime.now(), group.times_seen or 1))
set_last_email_sent_at(group, email_sent_at[-5:])
register(SmartMailer)
unregister(MailProcessor)
def setUp(self):
super(TrelloPluginTest, self).setUp()
register(self.plugin_cls)
self.group = self.create_group(message='Hello world',
culprit='foo.bar')
self.event = self.create_event(group=self.group, message='Hello world')
def should_record(self, group, event):
project = group.project
host = self.get_option('host', project) or self.host
if not host:
return False
port = self.get_option('port', project) or self.port
if not port:
return False
prefix = self.get_option('prefix', project) or self.prefix
if not prefix:
return False
min_level = self.get_option('min_level', project) or self.min_level
if min_level is not None and int(group.level) < min_level:
return False
include_loggers = self.get_option('include_loggers', project) or self.include_loggers
if include_loggers is not None and group.logger not in include_loggers:
return False
exclude_loggers = self.get_option('exclude_loggers', project) or self.exclude_loggers
if exclude_loggers and group.logger in exclude_loggers:
return False
return True
def post_process(self, group, event, is_new, is_sample, **kwargs):
if not self.should_record(group, event):
return
self.record_event(group, event)
register(GraphiteProcessor)
initial = kwargs.get('initial', {}).get(RULES_DATA_KEY)
if initial:
kwargs['initial'] = pickle.loads(initial)
super(PatchedGroupRuleFormSet, self).__init__(*args, **kwargs)
@property
def cleaned_data(self):
data = getattr(super(PatchedGroupRuleFormSet, self), 'cleaned_data',
{})
return {RULES_DATA_KEY: pickle.dumps(data)}
class GrouperPlugin(Plugin):
slug = 'group_rules'
conf_key = 'group_rules'
conf_key_rules = RULES_DATA_KEY
title = _('Grouping Rules')
version = sentry_grouper.VERSION
author = "Tommaso Barbugli"
author_url = "https://github.com/tbarbugli/sentry_grouper"
project_conf_template = 'sentry/plugins/sentry_grouper/project_configuration.html'
project_conf_form = PatchedGroupRuleFormSet
def get_project_rules(self, project):
rules = self.get_option(RULES_DATA_KEY, project)
unpickled = rules and pickle.loads(rules) or {RULES_DATA_KEY: []}
return unpickled
register(GrouperPlugin)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import sentry
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class InterfaceTypePlugin(TagPlugin):
"""
Automatically adds the 'interface_type' tag from events containing referencing
the class name of each interface (e.g. Http, Stacktrace, Exception).
"""
descrption = __doc__
title = _('Auto Tag: Interface Types')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'interface_type'
project_default_enabled = False
def get_tag_values(self, event):
return [i.rsplit('.', 1)[-1] for i in event.interfaces.iterkeys()]
register(InterfaceTypePlugin)
from __future__ import absolute_import
import six
import sentry
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class InterfaceTypePlugin(TagPlugin):
"""
Automatically adds the 'interface_type' tag from events containing referencing
the class name of each interface (e.g. Http, Stacktrace, Exception).
"""
descrption = __doc__
slug = 'interface_types'
title = 'Auto Tag: Interface Types'
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'interface_type'
project_default_enabled = False
def get_tag_values(self, event):
return [i.rsplit('.', 1)[-1] for i in six.iterkeys(event.interfaces)]
register(InterfaceTypePlugin)
'link': link,
'interfaces': interface_list,
})).run()
headers = {
'X-Sentry-Logger': event.logger,
'X-Sentry-Logger-Level': event.get_level_display(),
'X-Sentry-Project': project.name,
'X-Sentry-Server': event.server_name,
}
self._send_mail(
subject=subject,
body=body,
html_body=html_body,
project=project,
fail_silently=fail_silently,
headers=headers,
)
def get_option(self, key, *args, **kwargs):
value = super(MailProcessor, self).get_option(key, *args, **kwargs)
if value is None and key in ('min_level', 'include_loggers',
'exclude_loggers', 'send_to_members',
'send_to_admins', 'send_to',
'subject_prefix'):
value = getattr(self, key)
return value
register(MailProcessor)
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class UserEmailsPlugin(TagPlugin):
"""
Adds additional support for showing information about users including:
* A panel which shows all users a message was created by.
* A sidebar module which shows the users most actively seeing event.
"""
slug = 'user-emails'
title = _('Auto Tag: User Emails')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'user_email'
tag_label = _('User Email')
def get_tag_values(self, event):
user = event.interfaces.get('sentry.interfaces.User')
if not user:
return []
if not getattr(user, 'email', None):
return []
return [user.email]
register(UserEmailsPlugin)
interface_list = []
for interface in event.interfaces.itervalues():
body = interface.to_email_html(event)
if not body:
continue
text_body = interface.to_string(event)
interface_list.append(
(interface.get_title(), mark_safe(body), text_body)
)
title = '[%s]: %s' % (project.team.name,
event.message)
link = group.get_absolute_url()
context = {
'project_label': project.team.name,
'group': group,
'event': event,
'tags': event.get_tags(),
'link': link,
'interfaces': interface_list,
}
text = Template(ERROR_TEMPLATE).render(Context(context))
self._send_datadog_event(title, text, context, project)
register(DatadogPlugin)
if queryset.model == Event:
return queryset.filter(server_name=self.get_value()).distinct()
else:
return queryset.filter(event_set__server_name=self.get_value()).distinct()
class ServersPlugin(TagPlugin):
"""
Adds additional support for showing information about servers including:
* A panel which shows all servers a message was seen on.
* A sidebar module which shows the servers most actively seen on.
"""
slug = 'servers'
title = _('Servers')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/dcramer/sentry"
tag = 'server_name'
tag_label = _('Server Name')
def get_tag_values(self, event):
if not event.server_name:
return []
return [event.server_name]
def get_filters(self, project=None, **kwargs):
return [ServerNameFilter]
register(ServersPlugin)
:copyright: (c) 2010-2012 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import sentry
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class SitesPlugin(TagPlugin):
"""
Automatically adds the 'site' tag from events.
"""
slug = 'sites'
title = _('Sites')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'site'
tag_label = _('Site')
def get_tag_values(self, event):
if not event.site:
return []
return [event.site]
register(SitesPlugin)
version = sentry_smart_mailer.VERSION
author = "Tommaso Barbugli"
author_url = "https://github.com/tbarbugli/sentry_smart_mailer"
def should_notify(self, group):
return SwitchManager.send_email(group=group, logger_name=group.logger)
def post_process(self, group, event, is_new, is_sample, **kwargs):
lock_key = 'lock_mail:%s' % group.id
try:
with Lock(lock_key, timeout=0.5):
group = Group.objects.get(pk=group.pk)
self._post_process(group, event, is_new, is_sample, **kwargs)
except UnableToGetLock:
pass
def _post_process(self, group, event, is_new, is_sample, **kwargs):
if not self.should_notify(group):
return
try:
email_sent_at = list(group.last_email_sent)
except:
email_sent_at = []
self.notify_users(group, event)
email_sent_at.append((datetime.now(), group.times_seen or 1))
group.last_email_sent = email_sent_at[-5:]
group.save()
register(SmartMailer)
unregister(MailProcessor)
from __future__ import absolute_import, print_function from sentry.plugins import register from .plugin import JavascriptPlugin register(JavascriptPlugin)
self._send_mail(
subject=subject,
template=template,
html_template=html_template,
project=project,
group=group,
headers=headers,
context=context,
)
def notify_digest(self, project, digest):
context = {
'project': project,
'digest': digest,
}
self._send_mail(
subject=render_to_string('sentry/emails/digests/subject.txt', context).rstrip(),
template='sentry/emails/digests/body.txt',
html_template='sentry/emails/digests/body.html',
project=project,
context=context,
)
# Legacy compatibility
MailProcessor = MailPlugin
register(MailPlugin)
# coding: utf-8
"""
Plugin for Sentry which allows sending notification via Skype messenger.
"""
from django.conf import settings
__version__ = '0.1.2'
if settings.configured:
from sentry.plugins import plugins, register
from plugin import SkypeNotificationsPlugin
if SkypeNotificationsPlugin.slug not in [plugin.slug for plugin in plugins.all()]:
register(SkypeNotificationsPlugin)
project = group.project
interface_list = []
for interface in event.interfaces.itervalues():
body = interface.to_email_html(event)
if not body:
continue
text_body = interface.to_string(event)
interface_list.append(
(interface.get_title(), mark_safe(body), text_body))
title = '[%s]: %s' % (project.team.name, event.message)
link = group.get_absolute_url()
context = {
'project_label': project.team.name,
'group': group,
'event': event,
'tags': event.get_tags(),
'link': link,
'interfaces': interface_list,
}
text = Template(ERROR_TEMPLATE).render(Context(context))
self._send_datadog_event(title, text, context, project)
register(DatadogPlugin)
def ready(self):
from .plugin import JavascriptPlugin
from sentry.plugins import register
register(JavascriptPlugin)
'group': group,
'event': event,
'link': link,
'interfaces': interface_list,
})).run()
headers = {
'X-Sentry-Logger': event.logger,
'X-Sentry-Logger-Level': event.get_level_display(),
'X-Sentry-Project': project.name,
'X-Sentry-Server': event.server_name,
}
self._send_mail(
subject=subject,
body=body,
html_body=html_body,
project=project,
fail_silently=fail_silently,
headers=headers,
)
def get_option(self, key, *args, **kwargs):
value = super(MailProcessor, self).get_option(key, *args, **kwargs)
if value is None and key in ('min_level', 'include_loggers', 'exclude_loggers',
'send_to_members', 'send_to_admins', 'send_to',
'subject_prefix'):
value = getattr(self, key)
return value
register(MailProcessor)
from __future__ import absolute_import from sentry.plugins import register from .plugin import JavaPlugin register(JavaPlugin)
from django.utils.translation import ugettext_lazy as _
from sentry.plugins import register
from sentry.plugins.bases.tag import TagPlugin
class UrlsPlugin(TagPlugin):
"""
Automatically adds the 'url' tag from events containing interface data
from ``sentry.interfaces.Http``.
"""
slug = 'urls'
title = _('Auto Tag: URLs')
version = sentry.VERSION
author = "Sentry Team"
author_url = "https://github.com/getsentry/sentry"
tag = 'url'
tag_label = _('URL')
project_default_enabled = True
def get_tag_values(self, event):
http = event.interfaces.get('sentry.interfaces.Http')
if not http:
return []
if not http.url:
return []
return [http.url]
register(UrlsPlugin)
title = _('Auto Tag: Browsers')
tag = 'browser'
tag_label = _('Browser Name')
def get_tag_from_ua(self, ua):
if 'browser' not in ua:
return
tag = ua['browser']['name']
if 'version' in ua['browser']:
tag += ' ' + ua['browser']['version']
return tag
register(BrowserPlugin)
class OsPlugin(UserAgentPlugin):
"""
Automatically adds the 'os' tag from events containing interface data
from ``sentry.interfaes.Http``.
"""
slug = 'os'
title = _('Auto Tag: Operating Systems')
tag = 'os'
tag_label = _('Operating System')
def get_tag_from_ua(self, ua):
if 'flavor' in ua:
tag = ua['flavor']['name']
subject = self.get_digest_subject(project, counts, start)
for user_id in self.get_send_to(project):
self.add_unsubscribe_link(context, user_id, project)
self._send_mail(
subject=subject,
template='sentry/emails/digests/body.txt',
html_template='sentry/emails/digests/body.html',
project=project,
type='notify.digest',
context=context,
send_to=[user_id],
)
def notify_about_activity(self, activity):
email_cls = emails.get(activity.type)
if not email_cls:
logger.debug('No email associated with activity type `{}`'.format(
activity.get_type_display(),
))
return
email = email_cls(activity)
email.send()
# Legacy compatibility
MailProcessor = MailPlugin
register(MailPlugin)
def view(self, request, group, **kwargs):
try:
note = group.notation
except Notation.DoesNotExist:
note = Notation(group=group)
if request.method == 'POST' and request.user.is_authenticated():
note.note = request.POST['note']
note.modified_by = request.user
note.save()
return self.render('sentry_notes/index.html', {
'notation': note,
})
def before_events(self, request, event_list, **kwargs):
# Called before tags are applied
notes = Notation.objects.filter(group__in=event_list)
self._tagged = set(x.group_id for x in notes if x.note.strip())
def tags(self, request, group, tag_list, **kwargs):
# "group" can be an Event, not just a Group
if isinstance(group, Group) and group.pk in self._tagged:
tag_list.append(u"\u270D")
return tag_list
register(NotesPlugin)
