def register_logging(app): # 文件日志 formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = RotatingFileHandler(filename='./logs/flaskdemo.log', maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) app.logger.setLevel(logging.INFO) default_handler.setLevel(logging.INFO) class RequestFormatter(logging.Formatter): def format(self, record) -> str: record.url = request.url record.remote_addr = request.remote_addr return super(RequestFormatter, self).format(record) request_formatter = RequestFormatter( '[%(asctime)s] %(remote_addr)s requested %(url)s\n%(levelname)s in %(module)s: %(message)s' ) mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'], fromaddr=app.config['MAIL_USERNAME'], toaddrs=app.config['ALBUMY_ADMIN_EMAIL'], subject='Application Error', credentials=(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])) mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter(request_formatter) if not app.debug: app.logger.addHandler(file_handler) app.logger.addHandler(default_handler) app.logger.addHandler(mail_handler)
def register_logging(app): class RequestFormatter(logging.Formatter): def format(self, record): record.url = request.url record.remote_addr = request.remote_addr return super(RequestFormatter, self).format(record) request_formatter = RequestFormatter( '[%(asctime)s] %(remote_addr)s requested %(url)s\n' '%(levelname)s in %(module)s: %(message)s') default_handler.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = RotatingFileHandler(os.path.join(basedir, 'logs/bluelog.log'), maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) default_handler.setFormatter(formatter) mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'], fromaddr=app.config['MAIL_USERNAME'], toaddrs=['ADMIN_EMAIL'], subject='Bluelog Application Error', credentials=(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])) mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter(request_formatter) if not app.debug: app.logger.addHandler(mail_handler) app.logger.addHandler(file_handler) app.logger.addHandler(default_handler)
def create_app(): app = Flask(__name__, instance_path='/opt/flaskapp-instance') # Pull in app settings app.config.from_object(settings) # Configure logging default_handler.setLevel( logging.DEBUG if app.debug else app.config['PROD_LOG_LEVEL']) app.logger.setLevel(logging.DEBUG) # Apply Werkzeug middleware so Flask can correctly deduce # the client request environment when behind a proxy if (app.config['UPSTREAM_PROXY_COUNT'] > 0): app.wsgi_app = ProxyFix(app.wsgi_app, app.config['UPSTREAM_PROXY_COUNT']) # Setup the Flask-JWT-Extended extension if app.debug: jwt_pub_key_file = '.jwt/dummy/pubkey.pem' else: jwt_pub_key_file = '.jwt/pubkey.pem' with app.open_instance_resource(jwt_pub_key_file) as f: app.config['JWT_PUBLIC_KEY'] = f.read() JWTManager(app) # Allow cross origin requests on all endpoints (they will # still need to present a valid JWT to gain access) CORS(app) # Import views from flaskapp.views import auth from flaskapp.views.api_v1 import manage from flaskapp.views.api_v1 import devices from flaskapp.views.api_v1 import station from flaskapp.views.api_v1 import home # Register blueprints app.register_blueprint(auth.bp, url_prefix='/auth') app.register_blueprint(manage.bp, url_prefix='/api/v1/manage') app.register_blueprint(devices.bp, url_prefix='/api/v1/devices') app.register_blueprint(station.bp, url_prefix='/api/v1/station') app.register_blueprint(home.bp, url_prefix='/api/v1/home') # Register app level error handlers app.register_error_handler(HTTPException, app_exception_handler) # Set final actions on outgoing responses @app.after_request def perform_exit_actions(response): response.headers.add('X-Content-Type-Options', 'nosniff') response.headers.add('X-XSS-Protection', '1; mode=block') return response return app
def create_app(): select_default_settings() app = Flask(__name__) app.config.from_object(os.environ.get('MINIFICTION_SETTINGS')) default_handler.setLevel(app.config['LOGLEVEL']) logging.basicConfig(level=app.config['LOGLEVEL'], format=app.config['LOGFORMAT']) app.static_folder = app.config['STATIC_ROOT'] app.extra_css = [] app.extra_js = [] app.session_interface = LazySecureCookieSessionInterface() if app.config['UMASK'] is not None: if isinstance(app.config['UMASK'], str): app.config['UMASK'] = int(app.config['UMASK'], 8) os.umask(app.config['UMASK']) if app.config['TESTING']: if not os.path.isdir(app.config['TESTING_DIRECTORY']): os.makedirs(app.config['TESTING_DIRECTORY']) elif os.listdir(app.config['TESTING_DIRECTORY']): raise RuntimeError('Testing directory %r is not empty' % app.config['TESTING_DIRECTORY']) init_bl() configure_user_agent(app) configure_i18n(app) configure_cache(app) configure_forms(app) configure_users(app) configure_error_handlers(app) configure_views(app) configure_admin_views(app) configure_ajax(app) configure_errorpages(app) configure_templates(app) if not app.config['SPHINX_DISABLED']: configure_search(app) configure_celery(app) configure_captcha(app) configure_story_voting(app) configure_misc(app) configure_development(app) configure_frontend(app) configure_sidebar(app) app.context_processor(templates_context) init_plugins(app) database.configure_for_app(app) return app
def create_app(config_name): app = Flask(__name__) # Config app.config.from_object(config[config_name]) config[config_name].init_app(app) # Extensions db.init_app(app) auth.init_app(app=app) # Middleware / Wrappers if app.config['APP_ENABLE_PROXY_FIX']: ReverseProxyPrefixFix(app) if app.config['APP_ENABLE_REQUEST_ID']: RequestID(app) if app.config['APP_ENABLE_SENTRY']: sentry_sdk.init(**app.config['SENTRY_CONFIG']) # Logging formatter = RequestFormatter( '[%(asctime)s] [%(levelname)s] [%(request_id)s] [%(url)s]: %(message)s' ) default_handler.setFormatter(formatter) default_handler.setLevel(app.config['LOGGING_LEVEL']) # Error handlers app.register_error_handler(BadRequest, error_handler_generic_bad_request) app.register_error_handler(NotFound, error_handler_generic_not_found) app.register_error_handler(UnprocessableEntity, error_handler_generic_unprocessable_entity) app.register_error_handler(InternalServerError, error_handler_generic_internal_server_error) # CLI commands app.cli.add_command(seeding_cli_group) app.cli.add_command(importing_cli_group) # Routes app.add_url_rule('/', 'index', index_route) app.add_url_rule('/meta/health/canary', 'canary_health_check', healthcheck_canary_route, methods=['get', 'options']) # Resource blueprints app.register_blueprint(projects_blueprint) app.register_blueprint(people_blueprint) app.register_blueprint(grants_blueprint) app.register_blueprint(organisations_blueprint) app.register_blueprint(category_schemes_blueprint) app.register_blueprint(category_terms_blueprint) app.register_blueprint(participants_blueprint) app.register_blueprint(allocations_blueprint) app.register_blueprint(categorisations_blueprint) return app
def bootstrap(): del app.logger.handlers[:] logger = logging.getLogger() logger.setLevel(logging.INFO) default_handler.setLevel(logging.INFO) logger.addHandler(default_handler) global prediction_service prediction_service = get_prediction_service( app.config['PREDICTION_SERVICE'])
def create_app(): select_default_settings() app = Flask(__name__) app.config.from_object(os.environ.get('MINIFICTION_SETTINGS')) default_handler.setLevel(app.config['LOGLEVEL']) logging.basicConfig(level=app.config['LOGLEVEL'], format=app.config['LOGFORMAT']) app.static_folder = app.config['STATIC_ROOT'] app.extra_css = [] app.extra_js = [] if app.config['UMASK'] is not None: if isinstance(app.config['UMASK'], str): app.config['UMASK'] = int(app.config['UMASK'], 8) os.umask(app.config['UMASK']) if app.config['TESTING']: if not os.path.isdir(app.config['TESTING_DIRECTORY']): os.makedirs(app.config['TESTING_DIRECTORY']) elif os.listdir(app.config['TESTING_DIRECTORY']): raise RuntimeError('Testing directory %r is not empty' % app.config['TESTING_DIRECTORY']) init_bl() configure_user_agent(app) configure_i18n(app) configure_cache(app) configure_forms(app) configure_users(app) configure_error_handlers(app) configure_views(app) configure_admin_views(app) configure_ajax(app) configure_errorpages(app) configure_templates(app) if not app.config['SPHINX_DISABLED']: configure_search(app) configure_celery(app) configure_captcha(app) configure_story_voting(app) configure_misc(app) configure_development(app) configure_frontend(app) configure_sidebar(app) app.context_processor(templates_context) init_plugins(app) database.configure_for_app(app) return app
def register_logging(app): app.logger.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = RotatingFileHandler('logs/log.txt', maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) default_handler.setLevel(logging.INFO) # 在调试状态下不会添加处理器 if not app.debug: app.logger.addHandler(file_handler) app.logger.addHandler(default_handler)
def init_logger(): """ Utility function to initialise the logger. Use this to set up logging for your server. This should be called just after the app object is intantiated. """ formatter = RequestFormatter( "[%(asctime)s] %(remote_addr)s requested %(url)s\n" "%(levelname)s in %(module)s: %(message)s") default_handler.setLevel(logging.INFO) default_handler.setFormatter(formatter)
def set_log_level(self, log_level): r"""Set the logging level. Args: log_level (int): Logging level. """ super(FlaskService, self).set_log_level(log_level) from flask.logging import default_handler werkzeug_logger = logging.getLogger('werkzeug') default_handler.setLevel(level=log_level) self.app.logger.setLevel(level=log_level) werkzeug_logger.setLevel(level=log_level)
def register_logger(app: Flask): app.logger.setLevel(logging.INFO) formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s " "%(message)s") if app.debug: file_handler = RotatingFileHandler(filename="logs/lsfd202201.log", maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) if not app.debug: default_handler.setLevel(logging.INFO) app.logger.addHandler(default_handler)
def init_app(app): root = logging.getLogger() if app.config.get('LOGGING_HANDLER') == 'syslog': from logging.handlers import SysLogHandler syslog_handler = SysLogHandler( app.config.get('LOGGING_ADDRESS', '/dev/log')) syslog_handler.setFormatter( logging.Formatter( app.config.get( 'LOGGING_FORMAT', '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'))) app.logger.addHandler(syslog_handler) root.addHandler(syslog_handler) if 'LOGGING_LEVEL' in app.config: default_handler.setLevel(app.config['LOGGING_LEVEL']) app.logger.setLevel(app.config['LOGGING_LEVEL']) root.setLevel(app.config['LOGGING_LEVEL'])
def register_logging(app): formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = RotatingFileHandler(os.path.join(basedir, 'logs/myblog.log'), maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) default_handler.setLevel(logging.INFO) if not app.debug: app.logger.addHandler(file_handler) app.logger.addHandler(default_handler)
def configure_logging(app): """Configure file(info) and email(error) logging.""" log_format = app.config.get( "LOGGING_FORMAT", "%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]", ) date_format = "%Y-%m-%dT%H:%M:%SZ" log_levels = { "CRITICAL": logging.CRITICAL, "ERROR": logging.ERROR, "WARNING": logging.WARNING, "INFO": logging.INFO, "DEBUG": logging.DEBUG, "NOTSET": logging.NOTSET, } log_formatter = logging.Formatter(log_format, date_format) log_level = log_levels.get(app.config["LOGGING_LEVEL"], log_levels["INFO"]) if "LOGGING_LOCATION" in app.config: log_file_name = app.config["LOGGING_LOCATION"] parent_dir = os.path.abspath(os.path.join(log_file_name, os.pardir)) if not os.path.exists(parent_dir): os.makedirs(parent_dir) log_handler = RotatingFileHandler(filename=log_file_name, maxBytes=10000, backupCount=5) log_handler.setLevel(log_level) log_handler.setFormatter(log_formatter) app.logger.addHandler(log_handler) app.logger.debug("Logging initialized...") app.logger.debug("... log file location: {}".format( app.config.get("LOGGING_LOCATION"))) else: default_handler.setLevel(log_level) default_handler.setFormatter(log_formatter) log_handler = logging.basicConfig(stream=sys.stdout) app.logger.debug("Logging initialized...") app.logger.debug("... default flask logging handler")
def create_app(config_name): app = Flask(__name__) # Config app.config.from_object(config[config_name]) config[config_name].init_app(app) # Middleware / Wrappers if app.config['APP_ENABLE_SENTRY']: sentry_sdk.init(**app.config['SENTRY_CONFIG']) if app.config['APP_ENABLE_CORS']: CORS(app, **app.config['CORS_CONFIG']) if app.config['APP_ENABLE_REQUEST_ID']: RequestID(app) # Logging class RequestFormatter(logging.Formatter): def format(self, record): record.url = 'NA' record.request_id = 'NA' if has_request_context(): record.url = request.url if app.config['APP_ENABLE_REQUEST_ID']: record.request_id = request.environ.get("HTTP_X_REQUEST_ID") return super().format(record) formatter = RequestFormatter( '[%(asctime)s] [%(levelname)s] [%(request_id)s] [%(url)s] %(module)s: %(message)s' ) default_handler.setFormatter(formatter) default_handler.setLevel(app.config['LOGGING_LEVEL']) # Error handlers app.register_error_handler(400, error_handler_generic_bad_request) app.register_error_handler(404, error_handler_generic_not_found) app.register_error_handler(413, error_handler_request_entity_too_large) app.register_error_handler(500, error_handler_generic_internal_server_error) # App app.register_blueprint(meta_blueprint) app.register_blueprint(main_blueprint) return app
def init_app(cls, app: Flask) -> None: """初始化flask应用对象""" log_level = getenv('LOG_LEVEL') or 'INFO' app.logger.setLevel(log_level) default_handler.setLevel(log_level) default_handler.setFormatter( Formatter( '[%(asctime)s] %(pathname)s:%(lineno)d [%(levelname)s] %(message)s' )) app.before_request(before_app_request) app.teardown_request(teardown_app_request) app.json_encoder = CustomJSONEncoder sub, url = cls.BP_SUB_DOMAIN, cls.BP_URL_PREFIX app.register_blueprint(bp_admin_api, subdomain=sub.get('admin'), url_prefix=url.get('admin_api')) app.register_blueprint(bp_admin_ext, subdomain=sub.get('admin'), url_prefix=url.get('admin_ext'))
def register_logger(app: Flask): app.logger.setLevel(logging.DEBUG) if not (app.testing or app.debug): app.logger.setLevel(logging.INFO) formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s " "%(message)s") if app.debug or app.testing: try: os.mkdir("logs") except: # noqa: E722 pass file_handler = RotatingFileHandler(filename="logs/flog.log", maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) else: default_handler.setLevel(logging.INFO) app.logger.addHandler(default_handler)
def initialize_logger(): """Set up logger format and level""" formatter = logging.Formatter( '[%(asctime)s]:[%(levelname)s]:[%(name)s]: %(message)s') default_handler.setFormatter(formatter) default_handler.setLevel(logging.DEBUG) wsgi_handler = logging.StreamHandler( stream='ext://flask.logging.wsgi_errors_stream') wsgi_handler.setFormatter(formatter) wsgi_handler.setLevel(logging.DEBUG) logger = logging.getLogger() logger.setLevel(logging.DEBUG) logger.addHandler(default_handler) # 3rd party loggers logging.getLogger('botocore').setLevel(logging.INFO) logging.getLogger('urllib3').setLevel(logging.INFO)
def main(): global runner global app logger = logging.getLogger() default_handler.setFormatter(logging.Formatter( '[%(asctime)s] %(levelname)s in %(module)s: %(message)s' )) default_handler.setLevel(logging.DEBUG) logger.addHandler(default_handler) logging.info(HEAD) config = load_env() runner = Runner(config) runner.start() app.run(debug=True, use_reloader=False) runner.stop()
def register_logging(app): logging.getLogger(__name__) app.logger.name = app.name log_dir_name = "logs" log_file_name = app.name + '-' + time.strftime( '%Y-%m-%d', time.localtime(time.time())) + '.log' log_file_folder = os.path.abspath( os.path.dirname(__file__)) + os.sep + log_dir_name make_dir(log_file_folder) log_file_str = log_file_folder + os.sep + log_file_name logging_format = logging.Formatter( '[%(asctime)s][%(levelname)s][%(filename)s][%(funcName)s: %(lineno)s] - %(message)s' ) timeRotatingHandler = logging.handlers.TimedRotatingFileHandler( log_file_str, when="D", interval=1, backupCount=10) timeRotatingHandler.setFormatter(logging_format) timeRotatingHandler.setLevel(logging.DEBUG) app.logger.addHandler(timeRotatingHandler) default_handler.setFormatter(logging_format) default_handler.setLevel(logging.DEBUG)
def register_logging(app): class RequestFormatter(logging.Formatter): def format(self, record): record.url = request.url record.remote_addr = request.remote_addr return super(RequestFormatter, self).format(record) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) file_handler = RotatingFileHandler(os.path.join(basedir, 'app/logs/wuhan.log'), maxBytes=10 * 1024 * 1024, backupCount=10) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) default_handler.setLevel(logging.INFO) if not app.debug: app.logger.addHandler(file_handler) app.logger.addHandler(default_handler)
db = client[mongoconnection.db] db.authenticate(mongoconnection.user, password=mongoconnection.passwd) col = db[mongoconnection.col] expres = col.find_one({'_id': exp}) data = np.array(expres['result']) img = StringIO.StringIO() fig = plt.figure(figsize=(16, 10), dpi=100) axes = fig.add_subplot(1, 1, 1) axes.plot(data[:, 0], data[:, 1], color='r') axes.plot(data[:, 0], data[:, 2], color='r', linestyle='--') axes.plot(data[:, 0], data[:, 3], color='g') axes.plot(data[:, 0], data[:, 4], color='g', linestyle='--') plt.savefig(img, format='png') img.seek(0) plot_url = base64.b64encode(img.getvalue()) plt.close() return render_template('Experiment.html', exp=expres, plot_url=plot_url) if __name__ == '__main__': # The Flask Server is started default_handler.setLevel(logging.WARNING) app.run(host='0.0.0.0', port=port, debug=False)
from logging.handlers import RotatingFileHandler from flask.logging import default_handler from app import app if __name__ == '__main__': handler = RotatingFileHandler(filename='./log/app.log', maxBytes=1048576, backupCount=3) formatter = logging.Formatter( fmt= '%(asctime)s - %(name)s[line:%(lineno)d] - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S') handler.setFormatter(formatter) handler.setLevel(logging.DEBUG) app.logger.addHandler(handler) """ # flask.logging.create_logger logger = logging.getLogger('flask.app') if app.debug and logger.level == logging.NOTSET: logger.setLevel(logging.DEBUG) if not has_level_handler(logger): logger.addHandler(default_handler) return logger """ default_handler.setLevel(logging.INFO) app.logger.addHandler(default_handler) app.run(host='0.0.0.0', port=9000)
def create_app(config_name): app = Flask(__name__) # Config app.config.from_object(config[config_name]) config[config_name].init_app(app) # Logging class RequestFormatter(logging.Formatter): def format(self, record): record.url = 'NA' record.request_id = 'NA' if has_request_context(): record.url = request.url if app.config['APP_ENABLE_REQUEST_ID']: record.request_id = request.environ.get("HTTP_X_REQUEST_ID") return super().format(record) formatter = RequestFormatter( '[%(asctime)s] [%(levelname)s] [%(request_id)s] [%(url)s] %(module)s: %(message)s' ) default_handler.setFormatter(formatter) default_handler.setLevel(app.config['LOGGING_LEVEL']) # Middleware / Wrappers if app.config['APP_ENABLE_PROXY_FIX']: ReverseProxyPrefixFix(app) if app.config['APP_ENABLE_REQUEST_ID']: RequestID(app) if app.config['APP_ENABLE_SENTRY']: sentry_sdk.init(**app.config['SENTRY_CONFIG']) # API client if not app.config['TESTING']: arctic_projects_api_auth = BackendApplicationClient(client_id=app.config['AZURE_OAUTH_APPLICATION_ID']) arctic_projects_api_auth_session = OAuth2Session(client=arctic_projects_api_auth) arctic_projects_api_auth_token = arctic_projects_api_auth_session.fetch_token( token_url=app.config['AZURE_OAUTH_TOKEN_URL'], client_id=app.config['AZURE_OAUTH_APPLICATION_ID'], client_secret=app.config['AZURE_OAUTH_APPLICATION_SECRET'], scope=app.config['AZURE_OAUTH_NERC_ARCTIC_OFFICE_SCOPES'] ) arctic_projects_api = Session( 'https://api.bas.ac.uk/arctic-office-projects/testing', request_kwargs={'headers': {'authorization': f"bearer {arctic_projects_api_auth_token['access_token']}"}}) # Templates app.jinja_loader = PrefixLoader({ 'app': PackageLoader('arctic_office_projects_manager'), 'bas_style_kit': PackageLoader('bas_style_kit_jinja_templates'), }) app.config['bsk_templates'] = BskTemplates() app.config['bsk_templates'].site_styles.append({ 'href': 'https://cdn.web.bas.ac.uk/libs/font-awesome-pro/5.3.1/css/all.min.css' }) app.config['bsk_templates'].site_styles.append({ 'href': 'https://cdn.rawgit.com/jpswalsh/academicons/master/css/academicons.min.css' }) app.config['bsk_templates'].site_styles.append({'href': '/static/css/app.css'}) app.config['bsk_templates'].site_title = 'NERC Arctic Office Projects Manager' app.config['bsk_templates'].bsk_site_nav_brand_text = 'NERC Arctic Office Projects Manager' app.config['bsk_templates'].site_description = 'Management application for projects in the NERC Arctic Office ' \ 'Projects Database' app.config['bsk_templates'].bsk_site_feedback_href = 'mailto:[email protected]' app.config['bsk_templates'].bsk_site_nav_primary.append({ 'value': 'Projects', 'href': '/projects' }) app.config['bsk_templates'].bsk_site_nav_launcher.append({ 'value': 'Arctic Office Website', 'href': 'https://www.arctic.ac.uk' }) # Routes # @app.route('/') def index(): return redirect(url_for('projects_index')) @app.route('/projects') def projects_index(): projects = arctic_projects_api.get('projects') # noinspection PyUnresolvedReferences return render_template(f"app/views/projects_index.j2", projects=projects) @app.route('/projects/<project_id>') def project_details(project_id: str): project = arctic_projects_api.get('projects', project_id) mermaid_asset = False for style in app.config['bsk_templates'].site_scripts: if style['href'] == 'https://unpkg.com/[email protected]/dist/mermaid.min.js': mermaid_asset = True if not mermaid_asset: app.config['bsk_templates'].site_scripts.append({ 'href': 'https://unpkg.com/[email protected]/dist/mermaid.min.js' }) # noinspection PyUnresolvedReferences return render_template(f"app/views/project_details.j2", project=project, active_nav_item='/projects') @app.route('/meta/health/canary', methods=['get', 'options']) def meta_healthcheck_canary(): """ Returns whether this service is healthy This healthcheck checks the application itself (assumed to be healthy if this method can be executed). If healthy a 204 No Content response is returned, if unhealthy a 503 Service Unavailable response is returned. This healthcheck is binary and does not return any details to reduce payload size and prevent leaking sensitive data. Other healthcheck's should be used where more details are required. This healthcheck is intended for use with load balancers to give early indication of a service not being available. """ return '', HTTPStatus.NO_CONTENT return app
def setup_flask(level='DEBUG', formatter_cls=JsonFormatter, **kwargs): default_handler.setLevel(level) default_handler.setFormatter(formatter_cls( **kwargs ))
celery = make_celery(app) # load config and scorer dir_path = os.path.dirname(os.path.realpath(__file__)) with open(dir_path + '/config.json', 'r') as f: config = json.load(f) logging.getLogger('mwapi').setLevel(logging.ERROR) # silence 1.19 warnings scoring_handler = ScoringHandler(config) # Log into scores.log handler = logging.handlers.WatchedFileHandler('scores.log') formatter = logging.Formatter("[%(asctime)s] %(message)s") handler.setFormatter(formatter) app.logger.setLevel(logging.INFO) app.logger.info(app.import_name) default_handler.setLevel(logging.ERROR) app.logger.addHandler(handler) @celery.task(serializer='json', name='process-next-task') def score(wiki, rev_id, model, **kwargs): try: return scoring_handler.perform_scoring('https://' + wiki, str(rev_id), model, time.time()) except Exception as e: app.logger.info('ERROR:' + wiki + ':' + str(rev_id) + ':' + model + ':' + str(repr(e))) raise score.retry(args=[wiki, rev_id, model], exc=e, countdown=2, max_retries=3,