def __init__(self, flaskApp, apiKey): self.flaskApp = flaskApp self.apiKey = apiKey got_request_exception.connect(self.send_exception, sender=flaskApp) flaskApp.extensions['raygun'] = self
def setup_once(): # type: () -> None try: version = tuple(map(int, FLASK_VERSION.split(".")[:3])) except (ValueError, TypeError): raise DidNotEnable("Unparsable Flask version: {}".format(FLASK_VERSION)) if version < (0, 10): raise DidNotEnable("Flask 0.10 or newer is required.") request_started.connect(_request_started) got_request_exception.connect(_capture_exception) old_app = Flask.__call__ def sentry_patched_wsgi_app(self, environ, start_response): # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse if Hub.current.get_integration(FlaskIntegration) is None: return old_app(self, environ, start_response) return SentryWsgiMiddleware(lambda *a, **kw: old_app(self, *a, **kw))( environ, start_response ) Flask.__call__ = sentry_patched_wsgi_app # type: ignore
def init_app(self, app, dsn = None, logging = None, level = None, logging_exclusions = None, wrap_wsgi = None, register_signal = None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi elif self.wrap_wsgi is None: if app and app.debug: self.wrap_wsgi = False else: self.wrap_wsgi = True if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if logging_exclusions is not None: self.logging_exclusions = logging_exclusions if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: kwargs = {} if self.logging_exclusions is not None: kwargs['exclude'] = self.logging_exclusions setup_logging(SentryHandler(self.client, level=self.level), **kwargs) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) request_finished.connect(self.after_request, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def __init__(self, flaskApp, apiKey): self.flaskApp = flaskApp self.apiKey = apiKey got_request_exception.connect(self.send_exception, sender=flaskApp) flaskApp.extensions["raygun"] = self
def setup_once(): # type: () -> None # This version parsing is absolutely naive but the alternative is to # import pkg_resources which slows down the SDK a lot. try: version = tuple(map(int, FLASK_VERSION.split(".")[:3])) except (ValueError, TypeError): # It's probably a release candidate, we assume it's fine. pass else: if version < (0, 10): raise DidNotEnable("Flask 0.10 or newer is required.") before_render_template.connect(_add_sentry_trace) request_started.connect(_request_started) got_request_exception.connect(_capture_exception) old_app = Flask.__call__ def sentry_patched_wsgi_app(self, environ, start_response): # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse if Hub.current.get_integration(FlaskIntegration) is None: return old_app(self, environ, start_response) return SentryWsgiMiddleware(lambda *a, **kw: old_app(self, *a, **kw))( environ, start_response ) Flask.__call__ = sentry_patched_wsgi_app # type: ignore
def init_app(self, app): if self.name in app.extensions: return app.extensions[self.name] = self request_started.connect(self.reset_request, app) got_request_exception.connect(self.reset_request, app)
def init_app(self, app, dsn=None, logging=None, level=None, wrap_wsgi=None, register_signal=None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client, level=self.level)) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) request_finished.connect(self.add_sentry_id_header, sender=app) if not hasattr(app, "extensions"): app.extensions = {} app.extensions["sentry"] = self
def init_app(self, app, dsn=None, logging=None, level=None, logging_exclusions=None, wrap_wsgi=None, register_signal=None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi elif self.wrap_wsgi is None: # Fix https://github.com/getsentry/raven-python/issues/412 # the gist is that we get errors twice in debug mode if we don't do this if app and app.debug: self.wrap_wsgi = False else: self.wrap_wsgi = True if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if logging_exclusions is not None: self.logging_exclusions = logging_exclusions if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: kwargs = {} if self.logging_exclusions is not None: kwargs['exclude'] = self.logging_exclusions handler = SentryHandler(self.client, level=self.level) setup_logging(handler, **kwargs) logging_configured.send(self, sentry_handler=SentryHandler, **kwargs) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) request_finished.connect(self.after_request, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def test_handle_error_signal(self): if not signals_available: # This test requires the blinker lib to run. print("Can't test signals without signal support") return app = Flask(__name__) api = flask_restful.Api(app) exception = Mock() exception.code = 400 exception.data = {'foo': 'bar'} recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, app) try: with app.test_request_context("/foo"): api.handle_error(exception) self.assertEquals(len(recorded), 1) self.assertTrue(exception is recorded[0]) finally: got_request_exception.disconnect(record, app)
def init_app(self, app, dsn=None, logging=None, level=None, wrap_wsgi=None, register_signal=None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client, level=self.level)) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) request_finished.connect(self.add_sentry_id_header, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def init_app(self, app): self.app = app if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client)) got_request_exception.connect(self.handle_exception, sender=app, weak=False)
def init_app(self, app): self.app = app if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client)) got_request_exception.connect(self.handle_exception, sender=app)
def init_app(self, app, dsn=None, logging=None, level=None, logging_exclusions=None, wrap_wsgi=None, register_signal=None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi elif self.wrap_wsgi is None: # Fix https://github.com/getsentry/raven-python/issues/412 # the gist is that we get errors twice in debug mode if we don't do this if app and app.debug: self.wrap_wsgi = False else: self.wrap_wsgi = True if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if logging_exclusions is not None: self.logging_exclusions = logging_exclusions if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: kwargs = {} if self.logging_exclusions is not None: kwargs['exclude'] = self.logging_exclusions handler = SentryHandler(self.client, level=self.level) setup_logging(handler, **kwargs) if app.logger.propagate is False: app.logger.addHandler(handler) logging_configured.send( self, sentry_handler=SentryHandler, **kwargs) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) request_finished.connect(self.after_request, sender=app) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def init_app(self, app): self.app = app if not self.client: self.client = make_client( self.client_cls, app, self.organization_id, self.app_id, self.secret_token ) if self.logging: setup_logging(OpbeatHandler(self.client)) got_request_exception.connect(self.handle_exception, sender=app, weak=False)
def init_app(self, app): self.app = app if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client)) got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def install(self): appcontext_pushed.connect(_push_appctx) appcontext_tearing_down.connect(_pop_appctx) request_started.connect(_request_started) got_request_exception.connect(_capture_exception) old_app = Flask.__call__ def sentry_patched_wsgi_app(self, environ, start_response): return run_wsgi_app(lambda *a, **kw: old_app(self, *a, **kw), environ, start_response) Flask.__call__ = sentry_patched_wsgi_app
def add_errormator(app, config=None): """ Adds Errormator to Flask, first looks at config var,then tries to read ERRORMATOR from app.config """ if not config: config = app.config.get("ERRORMATOR") if not config: config = get_config() app.wsgi_app = make_errormator_middleware(app.wsgi_app, config) request_started.connect(populate_post_vars, app) got_request_exception.connect(log_exception, app) return app
def add_errormator(app, config=None): """ Adds Errormator to Flask, first looks at config var,then tries to read ERRORMATOR from app.config """ if not config and app.config.get('ERRORMATOR'): config = app.config.get('ERRORMATOR') else: config = {} app.wsgi_app = make_errormator_middleware(app.wsgi_app, config) request_started.connect(populate_post_vars, app) got_request_exception.connect(log_exception, app) return app
def init_app(self, app, options): self.app = app if self.client is None: datadog.initialize(**options) self.client = datadog.api if self.register_signal and self.client: got_request_exception.connect(self.handle_exception, self.app) request_finished.connect(self.after_request, self.app) if not hasattr(self.app, 'extensions'): self.app.extensions = {} self.app.extensions['breathalyzer'] = self
def init_app(self, app): if not self.client: if not app.config.get('SENTRY_SERVERS'): raise TypeError('The SENTRY_SERVERS config variable is required.') client = self.client_cls( include_paths=app.config.get('SENTRY_INCLUDE_PATHS'), exclude_paths=app.config.get('SENTRY_EXCLUDE_PATHS'), servers=app.config.get('SENTRY_SERVERS'), name=app.config.get('SENTRY_NAME'), key=app.config.get('SENTRY_KEY'), ) else: client = self.client got_request_exception.connect(self.handle_exception(client), sender=app, weak=False)
def add_appenlight(app, config=None): """ Adds Appenlight to Flask, first looks at config var,then tries to read APPENLIGHT from app.config """ if not config and app.config.get('APPENLIGHT'): config = app.config.get('APPENLIGHT') if config: pass else: config = {} app.wsgi_app = make_appenlight_middleware(app.wsgi_app, config) request_started.connect(populate_post_vars, app) got_request_exception.connect(log_exception, app) return app
def setup_once(): appcontext_pushed.connect(_push_appctx) appcontext_tearing_down.connect(_pop_appctx) request_started.connect(_request_started) got_request_exception.connect(_capture_exception) old_app = Flask.__call__ def sentry_patched_wsgi_app(self, environ, start_response): if Hub.current.get_integration(FlaskIntegration) is None: return old_app(self, environ, start_response) return run_wsgi_app(lambda *a, **kw: old_app(self, *a, **kw), environ, start_response) Flask.__call__ = sentry_patched_wsgi_app
def init_app(self, app, dsn=None): self.app = app if dsn is not None: self.dsn = dsn if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client)) got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, "extensions"): app.extensions = {} app.extensions["sentry"] = self
def init_app(self, app, logging=None, level=None, logging_exclusions=None, wrap_wsgi=None, register_signal=None): self.app = app if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi elif self.wrap_wsgi is None: if app and app.debug: self.wrap_wsgi = False else: self.wrap_wsgi = True if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if logging_exclusions is not None: self.logging_exclusions = logging_exclusions if self.logging: kwargs = {} if self.logging_exclusions is not None: kwargs['exclude'] = self.logging_exclusions setup_logging(AirbrakeHandler(self.client, level=self.level), **kwargs) if self.wrap_wsgi: app.wsgi_app = None # TODO: if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['airbrake'] = self
def init_app(self, app): if not self.client: if not app.config.get('SENTRY_SERVERS'): raise TypeError('The SENTRY_SERVERS config variable is required.') if not app.config.get('SENTRY_KEY'): raise TypeError('The SENTRY_KEY config variable is required.') client = self.client_cls( include_paths=set(app.config.get('SENTRY_INCLUDE_PATHS', [])) | set([app.import_name]), exclude_paths=app.config.get('SENTRY_EXCLUDE_PATHS'), servers=app.config.get('SENTRY_SERVERS'), name=app.config.get('SENTRY_NAME'), key=app.config.get('SENTRY_KEY'), site=app.config.get('SENTRY_SITE_NAME'), ) else: client = self.client got_request_exception.connect(self.handle_exception(client), sender=app, weak=False)
def test_handle_error_signal(self): api = restplus.Api(self.app) exception = BadRequest() recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, self.app) try: with self.app.test_request_context("/foo"): api.handle_error(exception) self.assertEquals(len(recorded), 1) self.assertTrue(exception is recorded[0]) finally: got_request_exception.disconnect(record, self.app)
def test_handle_error_signal(self, app): api = restplus.Api(app) exception = BadRequest() recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, app) try: # with self.app.test_request_context("/foo"): api.handle_error(exception) assert len(recorded) == 1 assert exception is recorded[0] finally: got_request_exception.disconnect(record, app)
def setup_once(): # type: () -> None appcontext_pushed.connect(_push_appctx) appcontext_tearing_down.connect(_pop_appctx) request_started.connect(_request_started) got_request_exception.connect(_capture_exception) old_app = Flask.__call__ def sentry_patched_wsgi_app(self, environ, start_response): # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse if Hub.current.get_integration(FlaskIntegration) is None: return old_app(self, environ, start_response) return SentryWsgiMiddleware( lambda *a, **kw: old_app(self, *a, **kw))(environ, start_response) Flask.__call__ = sentry_patched_wsgi_app # type: ignore
def init_app(self, app): if not self.client: if not app.config.get('SENTRY_SERVERS'): raise TypeError('The SENTRY_SERVERS config variable is required.') client = self.client_cls( include_paths=set(app.config.get('SENTRY_INCLUDE_PATHS', [])) | set([app.import_name]), exclude_paths=app.config.get('SENTRY_EXCLUDE_PATHS'), servers=app.config.get('SENTRY_SERVERS'), name=app.config.get('SENTRY_NAME'), key=app.config.get('SENTRY_KEY'), public_key=app.config.get('SENTRY_PUBLIC_KEY'), secret_key=app.config.get('SENTRY_SECRET_KEY'), project=app.config.get('SENTRY_PROJECT'), site=app.config.get('SENTRY_SITE_NAME'), ) self.client = client else: client = self.client got_request_exception.connect(self.handle_exception(client), sender=app, weak=False)
def init_app(self, app, dsn=None, logging=None, level=None, wrap_wsgi=None, register_signal=None): if dsn is not None: self.dsn = dsn if level is not None: self.level = level if wrap_wsgi is not None: self.wrap_wsgi = wrap_wsgi else: # Fix https://github.com/getsentry/raven-python/issues/412 # the gist is that we get errors twice in debug mode if we don't do this if app and app.debug: self.wrap_wsgi = False else: self.wrap_wsgi = True if register_signal is not None: self.register_signal = register_signal if logging is not None: self.logging = logging if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client, level=self.level)) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) request_finished.connect(self.after_request, sender=app) if not hasattr(app, "extensions"): app.extensions = {} app.extensions["sentry"] = self
def test_handle_error_signal(self): if not signals_available: # This test requires the blinker lib to run. print("Can't test signals without signal support") return exception = BadRequest() recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, self.app) try: with self.app.test_request_context("/foo"): self.api.handle_error(exception) self.assertEquals(len(recorded), 1) self.assertTrue(exception is recorded[0]) finally: got_request_exception.disconnect(record, self.app)
def init_app(self, app, dsn=None): if dsn is not None: self.dsn = dsn if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client, level=self.level)) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
def test_handle_error_signal(self): if not signals_available: # This test requires the blinker lib to run. print("Can't test signals without signal support") return api = restplus.Api(self.app) exception = BadRequest() recorded = [] def record(sender, exception): recorded.append(exception) got_request_exception.connect(record, self.app) try: with self.app.test_request_context("/foo"): api.handle_error(exception) self.assertEqual(len(recorded), 1) self.assertTrue(exception is recorded[0]) finally: got_request_exception.disconnect(record, self.app)
def init_app(self, app, dsn=None): self.app = app if dsn is not None: self.dsn = dsn if not self.client: self.client = make_client(self.client_cls, app, self.dsn) if self.logging: setup_logging(SentryHandler(self.client, level=self.level)) if self.wrap_wsgi: app.wsgi_app = SentryMiddleware(app.wsgi_app, self.client) app.before_request(self.before_request) if self.register_signal: got_request_exception.connect(self.handle_exception, sender=app) if not hasattr(app, 'extensions'): app.extensions = {} app.extensions['sentry'] = self
""" log all exceptions not caught before """ logger = logging.getLogger(__name__) message = "" if hasattr(exception, "data"): message = exception.data error = "{ex} {data} {url}".format(ex=exception.__class__.__name__, data=message, url=request.url) if must_never_log(exception): logger.debug(error) else: logger.exception(error) # must filter on ALL exceptions (including flask's ones) if allow_apm_logging(exception): record_exception() got_request_exception.connect(log_exception, app) @app.after_request def access_log(response, *args, **kwargs): logger = logging.getLogger("kirin.access") logger.info('"%s %s" %s', request.method, request.full_path, response.status_code) return response
def init_app(self, app): app.add_url_rule(self.metrics_path, 'metrics', self.metrics_endpoint) app.before_request(self.before_request) request_finished.connect(self.teardown_request, sender=app) got_request_exception.connect(self.handle_exception, sender=app)
'/status', endpoint='status') api.add_resource(ire.Ire, '/ire', endpoint='ire') def log_exception(sender, exception): """ log all exceptions not catch before """ logger = logging.getLogger(__name__) message = "" if hasattr(exception, "data"): message = exception.data error = "{ex} {data} {url}".format(ex=exception.__class__.__name__, data=message, url=request.url) if isinstance(exception, HTTPException): logger.debug(error) else: logger.exception(error) got_request_exception.connect(log_exception, app) @app.after_request def access_log(response, *args, **kwargs): logger = logging.getLogger('kirin.access') logger.info('"%s %s" %s', request.method, request.full_path, response.status_code) return response
def apply_middlewares(app): request_started.connect(_before_request, sender=app) request_finished.connect(_after_request, sender=app) got_request_exception.connect(_after_exception, sender=app)
def init_app(self, app): if self.logging: setup_logging(SentryHandler(self.client)) got_request_exception.connect(self.handle_exception(self.client), sender=app, weak=False)
def configure(app): config_file = os.environ.get('GRAPHITE_API_CONFIG', '/etc/graphite-api.yaml') if os.path.exists(config_file): with open(config_file) as f: config = yaml.safe_load(f) config['path'] = config_file else: warnings.warn("Unable to find configuration file at {0}, using " "default config.".format(config_file)) config = {} configure_logging(config) got_request_exception.connect(log_exception, app) for key, value in list(default_conf.items()): config.setdefault(key, value) app.statsd = None if 'statsd' in config: try: from statsd import StatsClient except ImportError: warnings.warn("'statsd' is provided in the configuration but " "the statsd client is not installed. Please `pip " "install statsd`.") else: c = config['statsd'] app.statsd = StatsClient(c['host'], c.get('port', 8125)) app.cache = None if 'cache' in config: try: from flask.ext.cache import Cache except ImportError: warnings.warn("'cache' is provided in the configuration but " "Flask-Cache is not installed. Please `pip install " "Flask-Cache`.") else: cache_conf = {'CACHE_DEFAULT_TIMEOUT': 60, 'CACHE_KEY_PREFIX': 'graphite-api:'} for key, value in config['cache'].items(): cache_conf['CACHE_{0}'.format(key.upper())] = value app.cache = Cache(app, config=cache_conf) loaded_config = {'functions': {}, 'finders': []} for functions in config['functions']: loaded_config['functions'].update(load_by_path(functions)) finders = [] for finder in config['finders']: finders.append(load_by_path(finder)(config)) loaded_config['store'] = Store(finders) loaded_config['searcher'] = IndexSearcher(config['search_index']) app.config['GRAPHITE'] = loaded_config app.config['TIME_ZONE'] = config['time_zone'] logger.info("configured timezone", timezone=app.config['TIME_ZONE']) if 'sentry_dsn' in config: try: from raven.contrib.flask import Sentry except ImportError: warnings.warn("'sentry_dsn' is provided in the configuration but " "the sentry client is not installed. Please `pip " "install raven[flask]`.") else: Sentry(app, dsn=config['sentry_dsn']) app.wsgi_app = TrailingSlash(CORS(app.wsgi_app, config.get('allowed_origins')))
def init_app(self, app): app.before_request(self.before_request) request_finished.connect(self.teardown_request, sender=app) got_request_exception.connect(self.handle_exception, sender=app)