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'])