def setup_logging(app):
"""
Skip /healthz and /metrics records from log (either plain
text or structured)
"""
class HealthCheckFilter(logging.Filter):
def filter(self, record):
if "healthz" in record.getMessage():
return False
if 'request_info' in record.__dict__:
req = record.__dict__['request_info'].request
return "healthz" not in req.path
return True
class MetricsFilter(logging.Filter):
def filter(self, record):
if "metrics" in record.getMessage():
return False
if 'request_info' in record.__dict__:
req = record.__dict__['request_info'].request
return "metrics" not in req.path
return True
json_logging.init_request_instrument(app)
hdlr = logging.getLogger('connexion-request-logger')
hdlr.propagate = False
for h in hdlr.handlers:
h.addFilter(HealthCheckFilter())
h.addFilter(MetricsFilter())
def __init__(self, app, name="flask-logger", level="info", suppress_app_logs=True):
"""
Initialize a new flask logger.
:param app: The flask application object.
:param name: The name of the logger (printed with each output).
:param level: Minimum log level to output (see FlaskLogger.levels).
"""
if level not in FlaskLogger.levels.keys():
raise Exception("invalid log level (see FlaskLogger.levels)")
jl.ENABLE_JSON_LOGGING = True
jl.init_flask(custom_formatter=Format)
jl.init_request_instrument(app)
if suppress_app_logs:
logging.getLogger("flask-request-logger").disabled = True
app.logger.disabled = True
logging.getLogger('werkzeug').disabled = True
os.environ['WERKZEUG_RUN_MAIN'] = 'true'
self.name = name
self.lg = BaseLogger(name)
self.lg.setLevel(Logger.levels[level])
self.lg.addHandler(logging.StreamHandler(sys.stdout))
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_by_name[config_name])
app.wsgi_app = ProxyFix(app.wsgi_app)
if config_name == 'prod':
@property
def specs_url(self):
return url_for(self.endpoint('specs'),
_external=True,
_scheme='https')
Api.specs_url = specs_url
db.init_app(app)
flask_bcrypt.init_app(app)
migrate.init_app(app, db)
# Init JSON logging, only once to avoid exceptions during tests
if json_logging._current_framework is None:
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(app)
with app.app_context():
if app.config['PYBRAKE']['project_key']:
pybrake.flask.init_app(app)
app.logger.addHandler(
pybrake.LoggingHandler(notifier=app.extensions['pybrake'],
level=logging.ERROR))
return app
def __init__(
self,
import_name,
static_url_path=None,
static_folder="static",
static_host=None,
host_matching=False,
subdomain_matching=False,
template_folder="templates",
instance_path=None,
instance_relative_config=False,
root_path=None,
):
super().__init__(
import_name,
static_url_path,
static_folder,
static_host,
host_matching,
subdomain_matching,
template_folder,
instance_path,
instance_relative_config,
root_path
)
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(self)
self.logger = logging.getLogger(self.name)
self.logger.setLevel(int(os.environ.get("LOGGING_LEVEL", logging.INFO)))
self.logger.addHandler(logging.StreamHandler(sys.stdout))
self.logger.propagate = False
self.logger_core = logging.getLogger("__core__")
self.logger_core.setLevel(int(os.environ.get("CORE_LOGGING_LEVEL", logging.ERROR)))
self.logger_core.addHandler(logging.StreamHandler(sys.stdout))
self.logger_core.propagate = False
self.logger_router = logging.getLogger("__router__")
self.logger_router.setLevel(int(os.environ.get("ROUTER_LOGGING_LEVEL", logging.ERROR)))
self.logger_router.addHandler(logging.StreamHandler(sys.stdout))
self.logger_router.propagate = False
self.req_logger = logging.getLogger("flask-request-logger")
self.req_logger.setLevel(logging.ERROR)
self.req_logger.propagate = False
init()
try:
import env
env.init()
except ImportError:
self.logger.warning("No app env defined!")
subject_factory.override(providers.Factory(lambda *args, **kw: g_wrap(subject_factory.cls, *args, **kw)))
self.router = event_router_factory()
def create():
app = connexion.FlaskApp(__name__, port=9090, specification_dir='openapi/')
json_logging.init_connexion(enable_json=True)
json_logging.init_request_instrument(app)
app.add_api('helloworld-api.yaml',
arguments={'title': 'Hello World Example'})
return app
def create():
app = connexion.FlaskApp(__name__, port=9090, specification_dir='openapi/')
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init(framework_name='connexion')
json_logging.init_request_instrument(app)
app.add_api('helloworld-api.yaml',
arguments={'title': 'Hello World Example'})
return app
def get_logger(app):
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init_flask()
json_logging.init_request_instrument(app)
# init the logger as usual
logger = logging.getLogger("test-logger")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
return logger
def __configure_logger(app: Flask):
if not json_logging.ENABLE_JSON_LOGGING:
"Prevent to call json_logging.init_flask() more than once."
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init_flask()
json_logging.init_request_instrument(app)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(app.config["LOGS_LEVEL"])
app.logger.addHandler(ch)
def configure_logger(app):
"""Configure loggers."""
enable_json = True if app.config.get(
"JSON_LOGGING") == 'true' or app.config.get(
"JSON_LOGGING") == True else False
json_logging.init_flask(enable_json=enable_json)
json_logging.init_request_instrument(app)
handler = logging.StreamHandler(sys.stdout)
if not app.logger.handlers:
app.logger.addHandler(handler)
def create_app():
app = Flask(__name__)
setup_metrics(app)
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init(framework_name='flask')
json_logging.init_request_instrument(app)
logger = logging.getLogger("app-logger")
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(sys.stdout))
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
api = Api(app)
@app.route('/ping')
def ping():
logger.info("pinged", extra={'tags': ['role:web', 'env:prod']})
return jsonify(ping='pong')
@app.route("/healthz", methods=["GET"])
def healthz():
logger.info("health-checked", extra={'tags': ['role:web', 'env:prod']})
return jsonify({"status": "SUCCESS"})
@app.route('/metrics')
def metrics():
return Response(prometheus_client.generate_latest(),
mimetype=CONTENT_TYPE_LATEST)
api.add_resource(TaskList, "/tasks")
api.add_resource(Task, "/tasks/<int:id>")
def initialize_tracer():
config = Config(config={
'sampler': {
'type': 'const',
'param': 1
},
'local_agent': {
'reporting_host': "cicdnode-0.vdigital.io",
'reporting_port': 6831
}
},
service_name='task-service')
return config.initialize_tracer() # also sets opentracing.tracer
flask_tracer = FlaskTracer(initialize_tracer, True, app)
return app
def startup_event():
json_logging.CREATE_CORRELATION_ID_IF_NOT_EXISTS = True
json_logging.CORRELATION_ID_GENERATOR = lambda: "data-service-" + str(
uuid.uuid1())
json_logging.init_fastapi(enable_json=True, custom_formatter=CustomJSONLog)
json_logging.init_request_instrument(
data_service_app, custom_formatter=CustomJSONRequestLogFormatter)
logging.basicConfig(level=logging.INFO)
json_logging.config_root_logger()
log = logging.getLogger(__name__)
log.info('Started data-service')
log.info(config.get_settings().print())
def create_app(config_class: Type[Config] = Config) -> Flask:
app = Flask(__name__)
if os.environ["FLASK_ENV"] == "production":
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(app)
app.config.from_object(config_class)
app.register_blueprint(bp)
configure_openapi_with_flask(app)
@app.teardown_appcontext
def cleanup(resp_or_exc):
session.remove()
return app
def create_app():
_app = Flask(__name__)
CORS(_app, resources={r"/api/*": {"origin": "*"}})
_app.register_blueprint(bp_excel)
_app.config['JWT_SECRET_KEY'] = JWT_SECRET_KEY
json_logging.ENABLE_JSON_LOGGING = True
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(_app)
request_logger = json_logging.get_request_logger()
handler = RotatingFileHandler(filename='samoyed/log/log.json',
maxBytes=5000000,
backupCount=10)
handler.setFormatter(json_logging.JSONRequestLogFormatter())
request_logger.addHandler(handler)
JWTManager(app=_app)
return _app
logger.error("Error occurred", exc_info=e)
logger.exception("Error occurred", exc_info=e)
return "Error occurred, check log for detail"
@app.get('/exclude_from_request_instrumentation')
def exclude_from_request_instrumentation():
return "this request wont log request instrumentation information"
if __name__ == "__main__":
import uvicorn
logging_config = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'default_handler': {
'class': 'logging.StreamHandler',
'level': 'DEBUG',
},
},
'loggers': {
'': {
'handlers': ['default_handler'],
}
}
}
json_logging.init_fastapi(enable_json=True)
json_logging.init_request_instrument(app, exclude_url_patterns=[r'^/exclude_from_request_instrumentation'])
uvicorn.run(app, host='0.0.0.0', port=5000, log_level="debug", log_config=logging_config)
"""
def __init__(self, request, **kwargs):
super(CustomDefaultRequestResponseDTO,
self).__init__(request, **kwargs)
def on_request_complete(self, response):
super(CustomDefaultRequestResponseDTO,
self).on_request_complete(response)
self.status = response.status
app = flask.Flask(__name__)
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(
app,
exclude_url_patterns=[r'/exclude_from_request_instrumentation'],
custom_formatter=CustomRequestJSONLog,
request_response_data_extractor_class=CustomDefaultRequestResponseDTO)
# init the logger as usual
logger = logging.getLogger("test logger")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
@app.route('/')
def home():
logger.info("test log statement")
logger.info("test log statement with extra props",
extra={'props': {
"extra_property": 'extra_value'
def client_and_log_handler():
import json_logging
# Init app
app = fastapi.FastAPI()
# Init std logging
logger = logging.getLogger(LOGGER_NAME)
logger.setLevel(logging.DEBUG)
handler = FormattedMessageCollectorHandler()
logger.addHandler(handler)
# Add json_logging
json_logging.init_fastapi(enable_json=True)
json_logging.init_request_instrument(
app, exclude_url_patterns=["^/no-request-instrumentation"])
# Prepare test endpoints
@app.get("/log/levels/debug")
async def log_debug():
logger.debug("debug message")
return {}
@app.get("/log/levels/info")
async def log_info():
logger.info("info message")
return {}
@app.get("/log/levels/error")
async def log_error():
logger.error("error message")
return {}
@app.get("/log/extra_property")
async def extra_property():
logger.info(
"test log statement with extra props",
extra={
"props": {
"extra_property": "extra_value"
},
"tags": ["app:name"],
"extra_property": "extra_value2"
},
)
return {}
@app.get("/log/extra_property_no_props")
async def extra_property_no_props():
logger.info(
"test log statement with extra and no 'props' property",
extra={
"tags": ["app:name"],
"extra_property": "extra_value2"
},
)
return {}
@app.get("/log/exception")
async def log_exception():
try:
raise RuntimeError()
except BaseException as e:
logger.exception("Error occurred", exc_info=e)
return {}
@app.get("/get-correlation-id")
async def get_correlation_id():
return {'correlation_id': json_logging.get_correlation_id()}
@app.get('/no-request-instrumentation')
async def excluded_from_request_instrumentation():
return {}
test_client = fastapi.testclient.TestClient(app)
yield test_client, handler
# Tear down test environment
logger.removeHandler(handler)
undo_imports_from_package(
"json_logging") # Necessary because of json-logging's global state
class CustomRequestJSONLog(json_logging.JSONLogWebFormatter):
"""
Customized logger
"""
def format(self, record):
json_customized_log_object = ({
"customized_prop": "customized value",
"correlation_id": json_logging.get_correlation_id(),
})
return json.dumps(json_customized_log_object)
app = flask.Flask(__name__)
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(app, exclude_url_patterns=[r'/exclude_from_request_instrumentation'],
custom_formatter=CustomRequestJSONLog)
# init the logger as usual
logger = logging.getLogger("test logger")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
@app.route('/')
def home():
logger.info("test log statement")
logger.info("test log statement with extra props", extra={'props': {"extra_property": 'extra_value'}})
correlation_id = json_logging.get_correlation_id()
return "hello world" \
"\ncorrelation_id : " + correlation_id
import datetime, logging, sys, json_logging, flask
app = flask.Flask(__name__)
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(app)
# init the logger as usual
logger = logging.getLogger("test-logger")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
@app.route('/')
def home():
logger.info("test log statement")
logger.info("test log statement with extra props", extra={'props': {"extra_property": 'extra_value'}})
correlation_id = json_logging.get_correlation_id()
return "Hello world : " + str(datetime.datetime.now())
if __name__ == "__main__":
app.run(host='0.0.0.0', port=int(5000), use_reloader=False)
app.registry.register(app.request_counter)
app.scan_counter = Counter('scans', 'Number of overall virus scans.')
app.registry.register(app.scan_counter)
app.infection_counter = Counter('infections',
'Number of infected files found.')
app.registry.register(app.infection_counter)
app.scan_duration_histogram = Histogram('scan_duration',
'Histogram over virus scan duration.')
app.registry.register(app.scan_duration_histogram)
# Configure logging
if app.config['LOGJSON']:
do_not_log = ['/health', '/metrics']
json_logging.init_quart(enable_json=True)
json_logging.init_request_instrument(app, exclude_url_patterns=do_not_log)
logger = logging.getLogger('clamav-rest')
logger.setLevel(app.config['LOGLEVEL'])
logger.addHandler(logging.StreamHandler(sys.stdout))
# Configure clamd
try:
cd = clamd.ClamdAsyncNetworkSocket(host=app.config['CLAMD_HOST'],
port=app.config['CLAMD_PORT'])
except BaseException:
logger.exception('error bootstrapping clamd for network socket')
# https://gitlab.com/pgjones/quart-auth/-/issues/6#note_460844029
def auth_required(func):
