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)",
)
