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):
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 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):
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.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 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, 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 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 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 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)
