def initializejaeger():
# Connection to use when deploying in local
# jaegerdata = load_config('../config/config.yml')
# Connection to use when deploying on docker
jaegerdata = load_config('config/config.yml')
print(jaegerdata)
config = Config(config={
'sampler': {
'type': 'const',
'param': 1
},
'logging': True,
'local_agent': {
'reporting_host': str(jaegerdata['jaeger']['host']),
'reporting_port': jaegerdata['jaeger']['port']
}
},
service_name=str(jaegerdata['jaeger']['service_name']))
tracer = config.initialize_tracer()
install_all_patches()
return tracer
def test_missing_modules_handling():
install_all_patches()
for name in HOOKS_WITH_PATCHERS:
hook_module = import_module(
'opentracing_instrumentation.client_hooks.' + name
)
assert not hook_module.patcher.applicable
def info_get():
with Configuration.tracer.start_span("info_get") as span:
span.log_kv({"event": "info_get", "stub_api_version": __version__})
# Automatically trace all requests made with 'requests' library.
install_all_patches()
with Configuration.tracer.start_span(
"google_query", child_of=span) as google_query_span:
google_query_span.log_kv({"event": "query_google"})
url = "http://google.com/"
# Make the actual request to webserver.
requests.get(url)
return info_response(), 200, {"x-thoth-stub-api-version": __version__}
def init_jaeger(app):
config = jaeger_client.Config(config={
'sampler': {
'type': 'const',
'param': 1
},
'logging': True,
'local_agent': {
'reporting_host': settings.JAEGER_HOST
}
},
service_name='books')
jaeger_tracer = config.initialize_tracer()
flask_opentracing.FlaskTracing(jaeger_tracer, app=app)
install_all_patches()
def initializejaeger():
jaegerdata = getConfig()
print(jaegerdata)
config = Config(config={'sampler': {'type': 'const', 'param': 1},
'logging': True,
'local_agent':
{'reporting_host': str(jaegerdata['jaeger']['host']), 'reporting_port': jaegerdata['jaeger']['port']}},
service_name=str(jaegerdata['jaeger']['service_name']))
tracer = config.initialize_tracer()
install_all_patches()
return tracer
def initialize_jaeger(service_name):
install_all_patches()
config = Config(
config={
"sampler": {
"type": "const",
"param": 1,
},
"logging": True,
},
service_name=service_name,
validate=True,
scope_manager=ContextVarsScopeManager(),
metrics_factory=PrometheusMetricsFactory(namespace=service_name),
)
return config.initialize_tracer()
def initialize_tracer():
install_all_patches()
jaeger_config = JaegerConfig(
config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
'local_agent': {
'reporting_host': ConfigEnv.JAEGER_HOST,
'reporting_port': ConfigEnv.JAEGER_PORT,
}
},
service_name=ConfigEnv.JAEGER_SERVICE_NAME,
)
return jaeger_config.initialize_tracer()
def initialize_tracer():
install_all_patches()
config = jaeger_client.Config(
config={
'sampler': {
'type': 'const',
'param': 1
},
'logging': True,
'local_agent': {
'reporting_host': JAEGER_REPORTING_HOST,
}
},
service_name='tracebacks',
validate=True,
metrics_factory=PrometheusMetricsFactory(namespace='tracebacks'),
)
return config.initialize_tracer() # also sets opentracing.tracer
def tracing_postfork():
if JAEGER_ENABLED:
init_jaeger_tracer()
install_all_patches()
install_custom_patches()
def init_tracing():
if JAEGER_ENABLED:
init_jaeger_tracer()
init_django_tracer()
install_all_patches()
install_custom_patches()
from peewee import *
from opentracing_instrumentation.client_hooks import install_all_patches
install_all_patches()
psql_db = PostgresqlDatabase('peewee',
user='******',
password='******',
host='127.0.0.1',
port=5432)
class DemoModel(Model):
class Meta:
database = psql_db
demo = CharField()
psql_db.create_tables([DemoModel])
import requests
import time
from opentracing_instrumentation.client_hooks import install_all_patches
from jaeger_client import Config
from os import getenv
JAEGER_HOST = getenv('JAEGER_HOST', 'localhost')
WEBSERVER_HOST = getenv('WEBSERVER_HOST', 'localhost')
# Create configuration object with enabled logging and sampling of all requests.
config = Config(config={'sampler': {'type': 'const', 'param': 1},
'logging': True,
'local_agent': {'reporting_host': JAEGER_HOST}},
service_name="jaeger_opentracing_example")
tracer = config.initialize_tracer()
# Automatically trace all requests made with 'requests' library.
install_all_patches()
url = "http://{}:5000/log".format(WEBSERVER_HOST)
# Make the actual request to webserver.
requests.get(url)
# allow tracer to flush the spans - https://github.com/jaegertracing/jaeger-client-python/issues/50
time.sleep(2)
tracer.close()
def tracing_postfork():
if JAEGER_ENABLED:
init_jaeger_tracer()
install_all_patches()
install_custom_patches()
def init_tracing():
if JAEGER_ENABLED:
init_jaeger_tracer()
init_django_tracer()
install_all_patches()
install_custom_patches()
def create_app():
# instantiate the app
swagger_config = {
"headers": [],
"specs": [{
"endpoint": 'swagger',
"route": '/swagger.json',
"rule_filter": lambda rule: True, # all in
"model_filter": lambda tag: True, # all in
}],
"static_url_path":
"/flasgger_static",
# "static_folder": "static", # must be set by user
"specs_route":
"/swagger/"
}
app = Flask(__name__)
app.config['SWAGGER'] = {
"swagger": "3.0",
'uiversion': "3",
"info": {
"title": "BevRand Playlist Api",
"version": "1.0"
}
}
Swagger(app, config=swagger_config)
log_level = logging.DEBUG
logging.getLogger('').handlers = []
logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)
# set config
env = getenv('APP_SETTINGS')
if env is None:
env = 'Test'
app_settings = 'api.config.' + env
app.config.from_object(app_settings)
config = Config(
config={
'sampler': {
'type': 'probabilistic',
'param': 0.1
},
'logging': True,
'local_agent':
# Also, provide a hostname of Jaeger instance to send traces to.
{
'reporting_host': JAEGER_HOST
}
},
# Service name can be arbitrary string describing this particular web service.
service_name="PlaylistApi")
jaeger_tracer = config.initialize_tracer()
tracer = FlaskTracer(jaeger_tracer)
global FLASK_TRACER
FLASK_TRACER = tracer
install_all_patches()
# register blueprints
# coverage needs to be started as soon as possible to include more lines
if env == 'Coverage':
api.cov = coverage.Coverage(config_file=".coveragerc")
api.cov.start()
from api.controllers.coverage_controller import coverage_blueprint
app.register_blueprint(coverage_blueprint,
url_prefix='/api/v1/coverage')
from api.controllers.private_controller import private_blueprint
app.register_blueprint(private_blueprint, url_prefix='/api/v1/private')
from api.controllers.public_controller import public_blueprint
app.register_blueprint(public_blueprint, url_prefix='/api/v1/public')
return app
def __init__(
self,
name,
use_tracer=None,
use_metric=False,
use_logging_level=logging.DEBUG,
use_optimizer=None,
use_cors=None,
use_default_error=None,
use_scheduler=None,
all=None,
flaskName=None,
*args,
**kwargs,
):
# TODO: Add more text here for current situation
"""
Initialize Flask App with multiple microservice-related and usability features.
None is for deactivating, so it equals to False.
*use_tracer* must be of type: bool (True for defaults, False for deactivating),
opentracing.Tracer (use it for configuration), dict (use default opentracing.Tracer and the given dict as config) or defaults: None
*use_metric* must be of type: bool (True for defaults, False for deactivating) or defaults: None
*use_logging_level* must be of type: logging.{INFO, WARNING, ERROR, DEBUG}, defaults: DEBUG
*use_optimizer* must be of type: bool (True for defaults, False for deactivating) or defaults: None
*use_cors* must be of type: bool (True for defaults, False for deactivating) or defaults: None
*use_default_error* must be of type: bool (True for defaults, False for deactivating) or defaults: None
*use_scheduler* must be of type: bool (True for defaults, False for deactivating) or defaults: None
*all* must be of type: bool (True for use all functions with defaults, False for deactivating all functions) or defaults: None
"""
if flaskName is None:
flaskName = __name__
super().__init__(flaskName, *args, **kwargs)
logger = logging.getLogger("")
self.name = name
self.metrics = None
self.tracing = None
self.optimize = None
self.cors = None
self.default_errorhandler = None
self.scheduler = None
if all is not None and all is not False:
use_tracer = True
use_metric = True
use_optimizer = True
use_cors = True
use_default_error = True
use_scheduler = True
logger.info("--- Start Connexion-Plus ---")
if not isinstance(self.app, (Flask, FlaskApp)):
logger.warning(
"Given App is not flask, so it cannot get any functionality added from this lib currently."
)
return
# add default error
if use_default_error is not None and use_default_error is not False:
from werkzeug.exceptions import HTTPException
from werkzeug.exceptions import default_exceptions
logger.info("Add default error handler to Flask...")
if callable(use_default_error):
self.default_errorhandler = use_default_error
logger.info("use given handler.")
else:
def handle_error(e):
code = 500
if isinstance(e, HTTPException):
code = e.code
error = {
"error": e.__class__.__name__,
"http_code": code,
"description": str(e),
}
logger.exception(error)
return jsonify(error), code
self.default_errorhandler = handle_error
logger.info("use default one")
# register for all json exceptions
self.app.register_error_handler(Exception,
self.default_errorhandler)
# register handler for all http exceptions
for ex in default_exceptions:
self.app.register_error_handler(ex, self.default_errorhandler)
if use_scheduler is not None and use_scheduler is not False:
logger.info("Add background scheduler to Flask")
from flask_apscheduler import APScheduler
self.scheduler = APScheduler()
self.scheduler.init_app(self.app)
self.scheduler.start()
# add optimizer
if use_optimizer is not None and use_optimizer is not False:
logger.info("Add optimizer to Flask...")
from .Optimizer import FlaskOptimize
config = {"compress": False, "minify": False}
if isinstance(use_optimizer, dict):
config.update(use_optimizer)
if isinstance(use_optimizer, bool) and use_optimizer:
config.update({"compress": True, "minify": True})
logger.info("use config {}.".format(config))
self.optimize = FlaskOptimize(self.app, config)
# add CORS
if use_cors is not None and use_cors is not False:
logger.info("Add cors to Flask...")
from flask_cors import CORS
if isinstance(use_cors, dict):
logger.info("use given settings.")
self.cors = CORS(self.app, resources=use_cors)
else:
logger.info("use default ones.")
self.cors = CORS(self.app)
logger.info("CORS added.")
# add prometheus
if use_metric is not None and use_metric is not False:
# TODO: add configuration https://github.com/rycus86/prometheus_flask_exporter#configuration
from prometheus_flask_exporter import PrometheusMetrics
self.metrics = PrometheusMetrics(self.app)
logger.info("Add prometheus to Flask")
# add tracing
if use_tracer is not None and use_tracer is not False:
logger.info("Add opentracing to Flask...")
# add tracing to all routes in flaskApp
from flask_opentracing import FlaskTracing
import opentracing
from functools import wraps
from flask import request
def wrapper(fn):
@wraps(fn)
def request_func(*args, **kwargs):
if request.path != "/metrics":
return fn(*args, **kwargs)
return request_func
FlaskTracing._before_request_fn = wrapper(
FlaskTracing._before_request_fn)
FlaskTracing._after_request_fn = wrapper(
FlaskTracing._after_request_fn)
config = None
if not isinstance(use_tracer, opentracing.Tracer):
logger.info("use default one.")
from jaeger_client import Config as jConfig
tracer_config = {
"sampler": {
"type": "const",
"param": 1,
},
"local_agent": {
"reporting_host": "jaeger-agent",
"reporting_port": 5775,
},
"logging": True,
}
if isinstance(use_tracer, dict):
tracer_config = use_tracer
if isinstance(use_metric, bool) and use_metric is True:
logger.info("Use metrics for tracer.")
from jaeger_client.metrics.prometheus import (
PrometheusMetricsFactory, )
config = jConfig(
config=tracer_config,
service_name=f"{name}ConnexionPlus",
metrics_factory=PrometheusMetricsFactory(
namespace=f"{name}ConnexionPlus"),
)
else:
logger.info("no metrics for tracer configured.")
config = jConfig(
config=tracer_config,
service_name=f"{name}ConnexionPlus",
)
else:
logger.info("use given tracer config.")
tracer_obj = use_tracer if config is None else config.initialize_tracer(
)
self.tracing = FlaskTracing(tracer_obj, True, self.app)
# add tracer to everything to support spans through multiple microservices via rpc-calls
from opentracing_instrumentation.client_hooks import install_all_patches
install_all_patches()
logger.info("All tracing relevant libs patched.")
# add a TracingHandler for Logging
from .TracingHandler import TracingHandler
th = TracingHandler(use_tracer)
th.setLevel(use_logging_level)
logging.getLogger("").addHandler(th)
logger.info("Finished Tracer adding.")
logger.info("--- Finished Connexion-Plus ---")
def apply_patches(cls):
install_all_patches(
requests_response_handler_hook=cls.requests_response_handler_hook)
def __init__(self, app, config=None):
self.service_name = app.name
self.config = config or default_config(app.name)
install_all_patches()
self.wsgi_app = create_wsgi_middleware(app.wsgi_app)
self.init_tracer()
