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__( self, # The Flask application to analyze app: Flask, # The HowFast app ID to use app_id: str = None, # Endpoints not to monitor endpoints_blacklist: List[str] = None, # Other configuration parameters passed to the CoreAPM constructor **kwargs, ): super().__init__(**kwargs) self.app = app self.wsgi_app = app.wsgi_app # We need to store thread local information, let's use Werkzeug's context locals # (see https://werkzeug.palletsprojects.com/en/1.0.x/local/) self.local = local.Local() self.local_manager = local.LocalManager([self.local]) # Overwrite the passed WSGI application app.wsgi_app = self.local_manager.make_middleware(self) if endpoints_blacklist: self.endpoints_blacklist = compile_endpoints(*endpoints_blacklist) else: self.endpoints_blacklist = [] # Setup the queue and the background thread self.setup(app_id) request_started.connect(self._request_started)
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): 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 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): if 'csrf' not in app.extensions: raise RuntimeError( 'Please install flask_wtf.csrf.CsrfProtect() as "csrf" in extensions' ' before AbilianCsrf()') app.extensions['csrf'].error_handler(self.csrf_error_handler) app.extensions['csrf-handler'] = self request_started.connect(self.request_started, sender=app) app.before_request(self.before_request)
def init_app(self, app): if "csrf" not in app.extensions: raise RuntimeError( 'Please install flask_wtf.csrf.CsrfProtect() as "csrf" in ' "extensions before AbilianCsrf()" ) app.extensions["csrf"].error_handler(self.csrf_error_handler) app.extensions["csrf-handler"] = self request_started.connect(self.request_started, sender=app) app.before_request(self.before_request)
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 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 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 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 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 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(): # 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 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)
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): # """ # Add headers to both force latest IE rendering engine or Chrome Frame, # and also to cache the rendered page for 10 minutes. # """ # r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate" # r.headers["Pragma"] = "no-cache" # r.headers["Expires"] = "0" # r.headers['Cache-Control'] = 'public, max-age=0' # return r # import abay.views #db.session.rollback()