def create_app():
app = Flask(__name__, static_folder='static')
CORS(app, supports_credentials=True)
app.config.from_object(Config)
# APM 设定相关
# Application Performance Management 应用程序运行时管理
if app.config['APM_ENABLE']:
from elasticapm.contrib.flask import ElasticAPM
app.config['ELASTIC_APM'] = {
# 应用名字，用于指定APM 上的应用名称，如
'SERVICE_NAME': app.config['APM_SERVICE_NAME'],
# 用于安全验证（暂时没用）
'SECRET_TOKEN': app.config['APM_SERVICE_TOKEN'],
# APM Server URL (e.g.: http://localhost:8200)
'SERVER_URL': app.config['APM_SERVER_URL'],
# 一般置为True, 详见文档
'DEBUG': bool(app.config['APM_DEBUG']),
}
apm = ElasticAPM(app)
# APM end
with app.app_context():
from cmdb import v1
app.register_blueprint(v1.bp, url_prefix='/v1')
return app
def get_app(config=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
config["APP_ABSPATH"] = os.path.abspath(os.path.dirname(__file__))
for key in dir(settings):
if key.isupper():
config.setdefault(key, getattr(settings, key))
app = superdesk_app(config)
app.config["BABEL_TRANSLATION_DIRECTORIES"] = (
app.config.get("BABEL_TRANSLATION_DIRECTORIES") + ";" +
os.path.join(SUPERDESK_PATH, "server/translations"))
if os.environ.get("APM_SERVER_URL") and os.environ.get("APM_SECRET_TOKEN"):
app.config["ELASTIC_APM"] = {
"DEBUG": app.debug,
"TRANSACTIONS_IGNORE_PATTERNS": ["^OPTIONS "],
"SERVICE_NAME": app.config.get("APM_SERVICE_NAME")
or "superdesk-cp",
"SERVER_URL": os.environ["APM_SERVER_URL"],
"SECRET_TOKEN": os.environ["APM_SECRET_TOKEN"],
}
ElasticAPM(app)
return app
def get_app(config=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
config['APP_ABSPATH'] = os.path.abspath(os.path.dirname(__file__))
for key in dir(settings):
if key.isupper():
config.setdefault(key, getattr(settings, key))
app = superdesk_app(config)
app.config['BABEL_TRANSLATION_DIRECTORIES'] = app.config.get('BABEL_TRANSLATION_DIRECTORIES') + \
';' + os.path.join(SUPERDESK_PATH, 'server/translations')
if os.environ.get('APM_SERVER_URL') and os.environ.get('APM_SECRET_TOKEN'):
app.config['ELASTIC_APM'] = {
'DEBUG': app.debug,
'TRANSACTIONS_IGNORE_PATTERNS': ['^OPTIONS '],
'SERVICE_NAME': app.config.get('APM_SERVICE_NAME')
or 'superdesk-cp',
'SERVER_URL': os.environ['APM_SERVER_URL'],
'SECRET_TOKEN': os.environ['APM_SECRET_TOKEN'],
}
ElasticAPM(app)
return app
def registerExtentions(app: Flask):
CORS(app, resources={
r"*": {"origin": "*"},
})
JWTManager().init_app(app)
connect(**_localDatabaseSetting)
ElasticAPM().init_app(app, **app.config['ELASTIC_APM'])
def configure_apm_agent(app):
"""Configura e inicia o agente de introspecção do APM."""
from .utils import asbool
if not app.config.get("APM_ENABLED"):
logger.debug(
"APM Agent is disabled. To enable it configure the APM_ENABLED option."
)
return
APM_CONFIG_KEYS_INFO = (
("SERVER_URL", True, str),
("SERVICE_NAME", False, str),
("SECRET_TOKEN", False, str),
("ENVIRONMENT", False, str),
("SERVICE_VERSION", False, str),
("FILTER_EXCEPTION_TYPES", False, str),
("TRANSACTIONS_IGNORE_PATTERNS", False, str),
("SERVER_TIMEOUT", False, str),
("HOSTNAME", False, str),
("COLLECT_LOCAL_VARIABLES", False, str),
("LOCAL_VAR_MAX_LENGTH", False, int),
("CAPTURE_BODY", False, str),
("CAPTURE_HEADERS", False, asbool),
("TRANSACTION_MAX_SPANS", False, int),
("STACK_TRACE_LIMIT", False, int),
("DEBUG", False, asbool),
("DISABLE_SEND", False, asbool),
("INSTRUMENT", False, asbool),
("VERIFY_SERVER_CERT", False, asbool),
)
apm_config = {}
for apm_key, required, cast in APM_CONFIG_KEYS_INFO:
key = "APM_%s" % apm_key
value = app.config.get(key)
if value is None or (isinstance(value, str) and len(value) == 0):
if required:
raise ValueError(
"Could not setup APM Agent. The key '%s' is required, "
"please configure it." % key
) from None
continue
try:
_value = cast(value)
except (ValueError, TypeError) as exc:
raise ValueError(
"Could not set the key '%s' with value '%s'. "
"The cast function raise the exception '%s'." % (key, value, exc)
)
apm_config[apm_key] = _value
app.config["ELASTIC_APM"] = apm_config
logger.debug("APM Agent enabled.")
return ElasticAPM(app)
def flask_wsgi_server(request, flask_app, elasticapm_client):
server = WSGIServer(application=flask_app)
apm_client = ElasticAPM(app=flask_app, client=elasticapm_client)
flask_app.apm_client = apm_client
server.start()
yield server
server.stop()
apm_client.client.close()
def init(app):
apm = None
if get_config_value('ENABLE_APM') is not None and 'Y' in str(
get_config_value('ENABLE_APM')):
app.config['ELASTIC_APM'] = {
'SERVICE_NAME':
'rootservice',
'SERVER_URL':
get_config_value('APM_SERVER_URL').decode(encoding="utf-8"),
'DEBUG':
True
}
apm = ElasticAPM(app)
return apm
def setup_apm(app, name="Superdesk"):
in_celery = sys.argv and "worker" in sys.argv
if getattr(app, "apm", None) is None and app.config.get("APM_SERVER_URL") and app.config.get("APM_SECRET_TOKEN"):
app.config["ELASTIC_APM"] = {
"SERVER_URL": app.config["APM_SERVER_URL"],
"SECRET_TOKEN": app.config["APM_SECRET_TOKEN"],
"TRANSACTIONS_IGNORE_PATTERNS": ["^OPTIONS "],
"SERVICE_NAME": "{name} {service}".format(
name=name,
service="Celery" if in_celery else "Web",
),
}
app.apm = ElasticAPM(app)
def init_log_handlers():
"""init log handlers and print current configuration to log"""
from everyclass.server.utils.logbook_logstash.handler import LogstashHandler
from elasticapm.contrib.flask import ElasticAPM
from everyclass.server.config import print_config
ElasticAPM.request_finished = monkey_patch.ElasticAPM.request_finished(
ElasticAPM.request_finished)
global __app, __first_spawn
# Elastic APM
if __app.config['CONFIG_NAME'] in __app.config['APM_AVAILABLE_IN']:
ElasticAPM(__app)
print('APM is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# Logstash centralized log
if __app.config['CONFIG_NAME'] in __app.config[
'LOGSTASH_AVAILABLE_IN']:
logstash_handler = LogstashHandler(
host=__app.config['LOGSTASH']['HOST'],
port=__app.config['LOGSTASH']['PORT'],
release=__app.config['GIT_DESCRIBE'],
bubble=True,
logger=logger,
filter=lambda r, h: r.level >= 11) # do not send DEBUG
logger.handlers.append(logstash_handler)
print(
'LogstashHandler is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# Sentry
if __app.config['CONFIG_NAME'] in __app.config['SENTRY_AVAILABLE_IN']:
sentry.init_app(app=__app)
sentry_handler = SentryHandler(sentry.client,
level='INFO') # Sentry 只处理 INFO 以上的
logger.handlers.append(sentry_handler)
print('Sentry is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# print current configuration
import uwsgi
if uwsgi.worker_id() == 1 and __first_spawn:
# set to warning level because we want to monitor restarts
logger.warning('App (re)started in `{0}` environment'.format(
__app.config['CONFIG_NAME']),
stack=False)
print_config(__app)
__first_spawn = False
def flask_apm_client(request, flask_app, elasticapm_client):
client_config = getattr(request, "param", {})
client_config.setdefault("app", flask_app)
client_config.setdefault("client", elasticapm_client)
client = ElasticAPM(**client_config)
try:
yield client
finally:
signals.request_started.disconnect(client.request_started)
signals.request_finished.disconnect(client.request_finished)
# remove logging handler if it was added
logger = logging.getLogger()
for handler in list(logger.handlers):
if getattr(handler, "client", None) is client.client:
logger.removeHandler(handler)
def configure_app(flask_app):
flask_app.config.SWAGGER_UI_DOC_EXPANSION = settings.RESTPLUS_SWAGGER_UI_DOC_EXPANSION
flask_app.config.RESTPLUS_VALIDATE = settings.RESTPLUS_VALIDATE
flask_app.config.RESTPLUS_MASK_SWAGGER = settings.RESTPLUS_MASK_SWAGGER
flask_app.config.ERROR_404_HELP = settings.RESTPLUS_ERROR_404_HELP
if settings.APM_SERVICE_NAME and settings.APM_SERVICE_URL and settings.APM_SECRET:
flask_app.config['ELASTIC_APM'] = {
'SERVICE_NAME': settings.APM_SERVICE_NAME,
'SERVER_URL': settings.APM_SERVICE_URL,
'SECRET_TOKEN': settings.APM_SECRET
}
apm = ElasticAPM(flask_app, logging=logging.INFO)
log.info("ElasticAPM enabled")
else:
log.info("ElasticAPM is disabled")
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
use_ssl = app.config['ELASTICSEARCH_URL'].startswith("https")
verify_certs = app.config['ELASTICSEARCH_VALIDATE_CERTS'].lower() == "true"
app.elasticsearch = Elasticsearch(
hosts=[app.config['ELASTICSEARCH_URL']],
http_auth=(app.config['ELASTICSEARCH_USER'],
app.config['ELASTICSEARCH_PASSWORD']),
timeout=60,
use_ssl=use_ssl,
verify_certs=verify_certs)
app.register_blueprint(api_bp, url_prefix='/api')
apm = ElasticAPM(app)
return app
def init_log_handlers():
"""初始化 log handlers 并将当前配置信息打 log"""
from everyclass.server.utils.logbook_logstash.handler import LogstashHandler
from elasticapm.contrib.flask import ElasticAPM
from everyclass.server.config import print_config
ElasticAPM.request_finished = monkey_patch.ElasticAPM.request_finished(
ElasticAPM.request_finished)
# Elastic APM
if __app.config['CONFIG_NAME'] in __app.config['APM_AVAILABLE_IN']:
ElasticAPM(__app)
print('APM is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# Logstash centralized log
if __app.config['CONFIG_NAME'] in __app.config[
'LOGSTASH_AVAILABLE_IN']:
logstash_handler = LogstashHandler(
host=__app.config['LOGSTASH']['HOST'],
port=__app.config['LOGSTASH']['PORT'],
release=__app.config['GIT_DESCRIBE'],
bubble=True,
logger=logger,
filter=lambda r, h: r.level >= 11) # do not send DEBUG
logger.handlers.append(logstash_handler)
print(
'LogstashHandler is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# Sentry
if __app.config['CONFIG_NAME'] in __app.config['SENTRY_AVAILABLE_IN']:
sentry.init_app(app=__app)
sentry_handler = SentryHandler(sentry.client,
level='INFO') # Sentry 只处理 INFO 以上的
logger.handlers.append(sentry_handler)
print('Sentry is inited because you are in {} mode.'.format(
__app.config['CONFIG_NAME']))
# 如果当前时间与模块加载时间相差一分钟之内，认为是第一次 spawn（进程随着时间的推移可能会被 uwsgi 回收），
# 在 1 号 worker 里打印当前配置
import uwsgi
if uwsgi.worker_id() == 1 and (datetime.datetime.now() - __load_time
) < datetime.timedelta(minutes=1):
# 这里设置等级为 warning 因为我们希望在 sentry 里监控重启情况
logger.warning('App (re)started in `{0}` environment'.format(
__app.config['CONFIG_NAME']),
stack=False)
print_config(__app)
def init_log_handlers():
"""init log handlers"""
from everyclass.api_server.util.logbook_logstash.handler import LogstashHandler
from elasticapm.contrib.flask import ElasticAPM
global __app, __first_spawn, __sentry_available
# Sentry
if __app.config['CONFIG_NAME'] in __app.config['SENTRY_AVAILABLE_IN']:
sentry.init_app(app=__app)
sentry_handler = SentryHandler(
sentry.client, level='WARNING') # Sentry 只处理 WARNING 以上的
logger.handlers.append(sentry_handler)
__sentry_available = True
logger.info('You are in {} mode, so Sentry is inited.'.format(
__app.config['CONFIG_NAME']))
# Elastic APM
if __app.config['CONFIG_NAME'] in __app.config['APM_AVAILABLE_IN']:
ElasticAPM(__app)
logger.info('You are in {} mode, so APM is inited.'.format(
__app.config['CONFIG_NAME']))
# Logstash centralized log
if __app.config['CONFIG_NAME'] in __app.config[
'LOGSTASH_AVAILABLE_IN']:
logstash_handler = LogstashHandler(
host=__app.config['LOGSTASH']['HOST'],
port=__app.config['LOGSTASH']['PORT'],
release=__app.config['GIT_DESCRIBE'],
bubble=True,
logger=logger,
filter=lambda r, h: r.level >= 11) # do not send DEBUG
logger.handlers.append(logstash_handler)
logger.info(
'You are in {} mode, so LogstashHandler is inited.'.format(
__app.config['CONFIG_NAME']))
import uwsgi
if uwsgi.worker_id() == 1 and __first_spawn:
from everyclass.api_server.util import mysql_connect, get_semester_list
logger.info('数据库可用学期：' +
';'.join(get_semester_list(__app.mongo_pool)))
__first_spawn = False
def init(app):
apm = None
logger.info("ENABLE_APM" + str(get_config_value('ENABLE_APM')))
logger.info("APM_SERVER_URL" + str(get_config_value('APM_SERVER_URL')))
if get_config_value('ENABLE_APM') is not None and 'Y' in str(
get_config_value('ENABLE_APM')):
logger.info("APM Enabled")
app.config['ELASTIC_APM'] = {
'SERVICE_NAME':
'performancefilter',
'SERVER_URL':
get_config_value('APM_SERVER_URL').decode(encoding="utf-8"),
'DEBUG':
True
}
apm = ElasticAPM(app)
return apm
def configure_app(flask_app):
flask_app.config.SWAGGER_UI_DOC_EXPANSION = settings.RESTPLUS_SWAGGER_UI_DOC_EXPANSION
flask_app.config.RESTPLUS_VALIDATE = settings.RESTPLUS_VALIDATE
flask_app.config.RESTPLUS_MASK_SWAGGER = settings.RESTPLUS_MASK_SWAGGER
flask_app.config.ERROR_404_HELP = settings.RESTPLUS_ERROR_404_HELP
if settings.APM_SERVICE_NAME and settings.APM_SERVICE_URL and settings.APM_SECRET:
flask_app.config['ELASTIC_APM'] = {
'SERVICE_NAME': settings.APM_SERVICE_NAME,
'SERVER_URL': settings.APM_SERVICE_URL,
'SECRET_TOKEN': settings.APM_SECRET,
'COLLECT_LOCAL_VARIABLES': 'off'
}
apm = ElasticAPM(flask_app, logging=logging.INFO)
log.info("ElasticAPM enabled")
log.debug("APM details: %s" % str(apm))
else:
log.info("ElasticAPM is disabled")
def main():
app = connexion.App(__name__, specification_dir='./swagger/')
app.app.json_encoder = encoder.JSONEncoder
app.add_api('swagger.yaml', arguments={'title': 'DeRegNet REST API'})
app.app.config['ELASTIC_APM'] = {
# Set required service name. Allowed characters:
# a-z, A-Z, 0-9, -, _, and space
'SERVICE_NAME': 'deregnet-rest',
# Set custom APM Server URL (default: http://localhost:8200)
'SERVER_URL': 'http://apm-server:8200',
'DEBUG': DEBUG,
}
apm = ElasticAPM(app.app)
app.run(host=Config.host(),
port=Config.port(),
debug=DEBUG,
server=Config.server_backend())
def create_app(config_name='DevelopmentConfig'):
"""Create Brazil Data Cube application from config object.
Args:
config_name (string) Config instance name
Returns:
Flask Application with config instance scope
"""
app = Flask(__name__)
conf = config.get_settings(config_name)
app.config.from_object(conf)
app.config['REDOC'] = {
'title': 'Web service to authentication (Oauth 2) - OBT',
'spec_route': '/oauth/docs'
}
if app.config.get('APM_APP_NAME') and app.config.get('APM_SECRET_TOKEN'):
from elasticapm.contrib.flask import ElasticAPM
app.config['ELASTIC_APM'] = {
'SERVICE_NAME': app.config['APM_APP_NAME'],
'SECRET_TOKEN': app.config['APM_SECRET_TOKEN'],
'SERVER_URL': app.config['APM_HOST']
}
ElasticAPM(app)
with app.app_context():
CORS(app, resources={r"/*": {"origins": "*"}})
_ = Redoc('./spec/openapi.yaml', app)
# DB
from bdc_oauth.utils.base_mongo import mongo
mongo.init_app(app)
mongo.app = app
# DB Cache
from bdc_oauth.utils.base_redis import redis
redis.init_app(app)
flask_bcrypt.init_app(app)
# Setup blueprint
from bdc_oauth.blueprint import bp
app.register_blueprint(bp)
return app
def get_server():
if SENTRY_DSN:
sentry_sdk.init(
dsn=SENTRY_DSN,
integrations=[FlaskIntegration()],
)
@app.after_request
def add_x_robots(response): # pylint: disable=W0612
response.headers['X-Robots-Tag'] = 'noindex, nofollow'
response.headers[
'Strict-Transport-Security'] = "max-age=31536000; includeSubDomains"
if GA_TRACKING_ID:
gevent.spawn(
_send_to_google_analytics,
request.remote_addr,
request.host_url,
request.path,
request.headers,
)
return response
elastic_apm_url = ELASTIC_APM_URL
elastic_apm_secret_token = ELASTIC_APM_TOKEN
elastic_apm = ({
'SERVICE_NAME': 'public-tariffs-api',
'SECRET_TOKEN': elastic_apm_secret_token,
'SERVER_URL': elastic_apm_url,
'ENVIRONMENT': ENVIRONMENT,
} if elastic_apm_url and elastic_apm_secret_token else {})
if elastic_apm:
app.config['ELASTIC_APM'] = elastic_apm
ElasticAPM(app)
server = WSGIServer(("0.0.0.0", PORT), app, log=app.logger)
return server
def flask_apm_client(flask_app, elasticapm_client):
client = ElasticAPM(app=flask_app, client=elasticapm_client)
yield client
signals.request_started.disconnect(client.request_started)
signals.request_finished.disconnect(client.request_finished)
from elasticapm.contrib.flask import ElasticAPM
app = Flask(__name__)
app.config['ELASTIC_APM'] = {
# allowed app_name chars: a-z, A-Z, 0-9, -, _, and space from elasticapm.contrib.flask
'DEBUG': True,
'SERVER_URL':
'http://xxxxxxxxxxx.xxxxxxxxxxx.xxxxxxxxxxxxxx.xxxxxxxxxxxxxxxx:8200',
'SERVICE_NAME': 'pythonpoc',
'TRACES_SEND_FREQ': 5,
'FLUSH_INTERVAL': 1, # 2.x
'MAX_QUEUE_SIZE': 1, # 2.x
}
apm = ElasticAPM(app)
@app.route('/hello_world')
def hello_world():
#target = os.environ.get('TARGET', 'World')
#return 'Hello {}!\n'.format(target)
return 'TYT-IA POC Observability'
#def show_import():
# im = Image.Open('images/logo.jpg')
# im.show()
@app.route('/health')
def getSaludRND():
i = random.randint(0, 100)
from flask import Flask, render_template, request
from search import *
from adapters import *
from elasticapm.contrib.flask import ElasticAPM
import os
search_index = os.environ['ELASTICSEARCH_INDEX']
app = Flask(__name__)
apm = ElasticAPM(app, logging=True)
@app.route('/')
def index():
input_parms = QueryAdapter().url_to_query(request.args)
search_results = Search(search_index).search(input_parms)
paging = PagingAdapter().get_paging(request.args, search_results)
return render_template("index.j2",
hits=search_results['hits'],
aggregations=search_results['aggregations'],
paging=paging)
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')
# Elastic or Opensearch
if os.getenv('REFLEX_ES_DISTRO') == 'opensearch':
from opensearch_dsl import connections
from opensearchpy.exceptions import RequestError
else:
from elasticsearch_dsl import connections
from elasticsearch.exceptions import RequestError
from config import app_config
FLASK_BCRYPT = Bcrypt()
cors = CORS()
mail = Mail()
cache = Cache(config={'CACHE_TYPE': 'simple'})
scheduler = BackgroundScheduler()
apm = ElasticAPM()
ep = EventProcessor()
memcached_client = MemcachedClient()
def migrate(app, ALIAS, move_data=True, update_alias=True):
'''
Upgrades all the indices in the system when a new version is released
that requires a schema change
'''
es = connections.get_connection()
new_index = ALIAS + f"-{REFLEX_VERSION}"
# Check to make sure the index hasn't already been upgraded
from flask import Flask, jsonify
from elasticapm.contrib.flask import ElasticAPM
from elasticapm.handlers.logging import LoggingHandler
app = Flask(__name__)
apm = ElasticAPM(app,
server_url='http://*****:*****@app.route('/')
def index():
return jsonify({"message": "Elastic APM succussfully configured"}), 200
if __name__ == '__main__':
app.run(host='0.0.0.0', port=4000)
"""
A simple web application; return the number of time it has been visited and also the amount of time that took to
run the difficult function.
"""
from flask import Flask
from redis import Redis
from elasticapm.handlers.logging import LoggingHandler
from elasticapm.contrib.flask import ElasticAPM
import random
import time
app = Flask(__name__)
redis = Redis(host='redis', port=6379)
apm = ElasticAPM(app,
server_url='http://<YOUR URL>:8200',
service_name='elasticwebapp',
logging=True)
def difficult_function():
output = 1
t0 = time.time()
difficulty = random.randint(1000000, 2000000)
for i in range(difficulty):
output = output * difficulty
output = output / (difficulty - 1)
t1 = time.time()
compute_time = t1 - t0
return compute_time
from flask import Flask
from flask import jsonify
from flask import request
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'SQLALCHEMY_DATABASE_URI')
db = SQLAlchemy(app)
# NOTE: Initial elastic apm
# https://www.elastic.co/guide/en/apm/agent/python/2.x/flask-support.html
# https://www.elastic.co/guide/en/apm/agent/python/2.x/configuration.html
from elasticapm.contrib.flask import ElasticAPM
apm = ElasticAPM()
apm.init_app(
app,
server_url=os.environ.get('APM_SERVER_URL'),
service_name=os.environ.get('APM_SEVICE_NAME'),
secret_token=os.environ.get('APM_SECRET_TOKEN'),
capture_body='all', # Just for demo
)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
app.register_blueprint(healthz)
app.register_blueprint(file_api)
app.register_blueprint(service_api)
app.register_blueprint(task_api)
app.register_blueprint(safelist_api)
# Setup logging
app.logger.setLevel(LOGGER.getEffectiveLevel())
app.logger.removeHandler(default_handler)
for ph in LOGGER.parent.handlers:
app.logger.addHandler(ph)
# Setup APMs
if config.core.metrics.apm_server.server_url is not None:
app.logger.info(
f"Exporting application metrics to: {config.core.metrics.apm_server.server_url}"
)
ElasticAPM(app,
server_url=config.core.metrics.apm_server.server_url,
service_name="al_svc_server")
if __name__ == '__main__':
wlog = logging.getLogger('werkzeug')
wlog.setLevel(LOGGER.getEffectiveLevel())
for h in LOGGER.parent.handlers:
wlog.addHandler(h)
app.run(host='0.0.0.0',
port=5003,
debug=config.logging.log_level == 'DEBUG')
def test_framework_name(flask_app):
elasticapm = ElasticAPM(app=flask_app, metrics_interval="0ms")
assert elasticapm.client.config.framework_name == "flask"
app_info = elasticapm.client.get_service_info()
assert app_info["framework"]["name"] == "flask"
def initialise_apm(app):
if app.config.get('ENABLE_APM', False):
from elasticapm.contrib.flask import ElasticAPM
app.logger.info("Configuring Elastic APM")
apm = ElasticAPM(app, logging=True)
import json
import logging
import os
from elasticapm.contrib.flask import ElasticAPM
from flask import Flask
from flask_swagger_ui import get_swaggerui_blueprint
from .views import healthcheck, postcode
app = Flask(__name__)
apm = ElasticAPM(app, logging=logging.ERROR)
SWAGGER_URL = '/api/docs' # URL for exposing Swagger UI
API_URL = ''
# Call factory function to create our blueprint
swagger_file_dir = os.path.abspath('./docs/api.json')
swaggerui_blueprint = get_swaggerui_blueprint(
SWAGGER_URL,
API_URL,
config={'spec': json.load(open(swagger_file_dir))},
)
app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)
app.add_url_rule('/healthcheck', view_func=healthcheck, methods=['GET'])
app.add_url_rule('/v1/postcode', view_func=postcode, methods=['GET'])
