def do_request(self, *args, **kwargs):
store = {}
tear_down_ = partial(tear_down, store)
request_started.connect(set_up)
request_finished.connect(tear_down_)
template_rendered.connect(store_rendered_template)
if message_flashed:
message_flashed.connect(store_flashed_message)
if self.use_session_scopes:
scope = SessionScope(self.db)
scope.push()
try:
response = super(TestApp, self).do_request(*args, **kwargs)
finally:
if self.use_session_scopes:
scope.pop()
template_rendered.disconnect(store_rendered_template)
request_finished.disconnect(tear_down_)
request_started.disconnect(set_up)
if message_flashed:
message_flashed.disconnect(store_flashed_message)
response.session = store.get('session', {})
response.flashes = store.get('flashes', [])
response.contexts = dict(store.get('contexts', []))
return response
def do_request(self, *args, **kwargs):
store = {}
tear_down_ = partial(tear_down, store)
request_started.connect(set_up)
request_finished.connect(tear_down_)
template_rendered.connect(store_rendered_template)
if message_flashed:
message_flashed.connect(store_flashed_message)
if self.use_session_scopes:
scope = SessionScope(self.db)
scope.push()
try:
response = super(TestApp, self).do_request(*args, **kwargs)
finally:
if self.use_session_scopes:
scope.pop()
template_rendered.disconnect(store_rendered_template)
request_finished.disconnect(tear_down_)
request_started.disconnect(set_up)
if message_flashed:
message_flashed.disconnect(store_flashed_message)
response.session = store.get('session', {})
response.flashes = store.get('flashes', [])
response.contexts = dict(store.get('contexts', []))
return response
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_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, 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 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):
app.extensions["upstream"] = self
request_started.connect(self.request_started, sender=app)
request_finished.connect(self.request_finished, sender=app)
user_loaded.connect(self.user_loaded, sender=app)
config = app.config
config.setdefault("ABILIAN_UPSTREAM_INFO_ENABLED", False)
for key in ("ABILIAN_UPSTREAM_INFO_DISCARD", "ABILIAN_UPSTREAM_INFO_INCLUDE"):
val = config.get(key, ())
if val is not None:
val = frozenset(val)
config[key] = val
def init_app(self, app):
app.extensions["upstream"] = self
request_started.connect(self.request_started, sender=app)
request_finished.connect(self.request_finished, sender=app)
user_loaded.connect(self.user_loaded, sender=app)
config = app.config
config.setdefault("ABILIAN_UPSTREAM_INFO_ENABLED", False)
for key in ("ABILIAN_UPSTREAM_INFO_DISCARD", "ABILIAN_UPSTREAM_INFO_INCLUDE"):
val = config.get(key, ())
if val is not None:
val = frozenset(val)
config[key] = val
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, 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 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)
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)
Notification.uid).filter_by(uid=login.current_user.get_id()).order_by(
Notification.updated_on.desc())
return dict(notif=query.filter_by(type=0).limit(10).all(),
tasks=query.filter_by(type=1).limit(10).all(),
acc=accList)
""" no cache so we can see the latest info """
def expire_session(sender, response, **extra):
db_session.expire_all()
request_finished.connect(expire_session, app)
""" Pass account list to template """
def accList_inject(sender):
if not session.get('accSelect'):
session['accSelect'] = [
r.usern for r in db.session.query(eBayAccount.usern).filter_by(
uid=login.current_user.get_id()).distinct()
]
request_started.connect(accList_inject, app)
# @app.after_request
# def add_header(r):
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)
