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 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)
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)