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 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 send_debug(): file_list = glob.glob(logger.get_logfile(config.config_logfile) + '*') file_list.extend( glob.glob( logger.get_accesslogfile(config.config_access_logfile) + '*')) for element in [logger.LOG_TO_STDOUT, logger.LOG_TO_STDERR]: if element in file_list: file_list.remove(element) memory_zip = BytesIO() with zipfile.ZipFile(memory_zip, 'w', compression=zipfile.ZIP_DEFLATED) as zf: zf.writestr('settings.txt', json.dumps(config.toDict(), sort_keys=True, indent=2)) zf.writestr( 'libs.txt', json.dumps(collect_stats(), sort_keys=True, indent=2, cls=lazyEncoder)) for fp in file_list: zf.write(fp, os.path.basename(fp)) memory_zip.seek(0) if int(__version__.split('.')[0]) < 2: return send_file(memory_zip, as_attachment=True, attachment_filename="Calibre-Web-debug-pack.zip") else: return send_file(memory_zip, as_attachment=True, download_name="Calibre-Web-debug-pack.zip")
def assemble_logfiles(file_name): log_list = sorted(glob.glob(file_name + '*'), reverse=True) wfd = BytesIO() for f in log_list: with open(f, 'rb') as fd: shutil.copyfileobj(fd, wfd) wfd.seek(0) if int(__version__.split('.')[0]) < 2: return send_file(wfd, as_attachment=True, attachment_filename=os.path.basename(file_name)) else: return send_file(wfd, as_attachment=True, download_name=os.path.basename(file_name))
def test_api_same_endpoint(self): """API reuse endpoint. You can't use the same endpoint, it should throw an error.""" app = Flask(__name__) api = Api(app, prefix='/v1') api.add_resource(make_foo(), '/foo', endpoint='baz') class Bar(Resource): def get(self): return 'bar' major, minor = tuple(map(int, flask_version.split(".")))[:2] if major == 0 and minor > 10: with pytest.raises(AssertionError) as err: api.add_resource(Bar, '/bar', endpoint='baz') assert err.value.args[0].endswith("existing endpoint function: baz") else: with pytest.raises(ValueError) as err: api.add_resource(Bar, '/bar', endpoint='baz') assert err.value.args[0].startswith("Endpoint 'baz' is already")
def pytest_namespace(): return { 'flask_ver': tuple(int(x) for x in flask_ver.split('.')) }
def pytest_configure(config): pytest.flask_ver = tuple(int(x) for x in flask_ver.split('.'))
{% cache 60*5 'myform' %} <div> <form> {% render_form_field form.username %} {% render_submit %} </form> </div> {% endcache %} """ from jinja2 import nodes from jinja2.ext import Extension from flask import __version__ if tuple( map(int, __version__.split("."))) >= (0,11,0): from flask_cache import make_template_fragment_key else: from flask.ext.cache import make_template_fragment_key JINJA_CACHE_ATTR_NAME = '_template_fragment_cache' class CacheExtension(Extension): tags = set(['cache']) def parse(self, parser): lineno = next(parser.stream).lineno #: Parse timeout
def is_flask_legacy(): # pragma: no cover v = flask_version.split(".") return int(v[0]) == 0 and int(v[1]) < 11
def pytest_namespace(): return {'flask_ver': tuple(int(x) for x in flask_ver.split('.'))}
from testing_support.fixtures import (validate_transaction_metrics, validate_transaction_errors, override_application_settings, validate_tt_parenting) from testing_support.validators.validate_code_level_metrics import validate_code_level_metrics from newrelic.packages import six from conftest import async_handler_support, skip_if_not_async_handler_support try: # The __version__ attribute was only added in 0.7.0. # Flask team does not use semantic versioning during development. from flask import __version__ as flask_version flask_version = tuple([int(v) for v in flask_version.split('.')]) is_gt_flask060 = True is_dev_version = False except ValueError: is_gt_flask060 = True is_dev_version = True except ImportError: is_gt_flask060 = False is_dev_version = False requires_endpoint_decorator = pytest.mark.skipif( not is_gt_flask060, reason="The endpoint decorator is not supported.") def target_application(): # We need to delay Flask application creation because of ordering
def is_flask_legacy(): v = flask_version.split(".") return int(v[0]) == 0 and int(v[1]) < 11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest from testing_support.fixtures import (validate_transaction_metrics, validate_transaction_errors, override_application_settings) try: # The __version__ attribute was only added in 0.7.0. # Flask team does not use semantic versioning during development. from flask import __version__ as flask_version is_gt_flask080 = 'dev' in flask_version or tuple( map(int, flask_version.split('.')))[:2] > (0, 8) except ValueError: is_gt_flask080 = True except ImportError: is_gt_flask080 = False # Technically parts of before/after support is available in older # versions, but just check with latest versions. The instrumentation # always checks for presence of required functions before patching. requires_before_after = pytest.mark.skipif( not is_gt_flask080, reason="Not all before/after methods are supported.") def target_application(): # We need to delay Flask application creation because of ordering
def is_flask_legacy(): v = flask_version.split(".") return int(v[0]) == 0 and int(v[1]) < 11
from testing_support.fixtures import (code_coverage_fixture, collector_agent_registration_fixture, collector_available_fixture) _coverage_source = [ 'newrelic.hooks.framework_flask', ] code_coverage = code_coverage_fixture(source=_coverage_source) _default_settings = { 'transaction_tracer.explain_threshold': 0.0, 'transaction_tracer.transaction_threshold': 0.0, 'transaction_tracer.stack_trace_threshold': 0.0, 'debug.log_data_collector_payloads': True, 'debug.record_transaction_failure': True, 'debug.log_autorum_middleware': True, } collector_agent_registration = collector_agent_registration_fixture( app_name='Python Agent Test (framework_flask)', default_settings=_default_settings) is_flask_v2 = int(flask_version.split('.')[0]) >= 2 is_pypy = platform.python_implementation() == "PyPy" async_handler_support = is_flask_v2 and not is_pypy skip_if_not_async_handler_support = pytest.mark.skipif( not async_handler_support, reason="Requires async handler support. (Flask >=v2.0.0)", )