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()