def test_trace_all_requests(self):
app = Flask('dummy_app')
tracing = FlaskTracing(app=app)
assert tracing._trace_all_requests is True
tracing = FlaskTracing(app=app, trace_all_requests=False)
assert tracing._trace_all_requests is False
def create_app(run_mode=os.getenv('FLASK_ENV', 'production')):
"""Return a configured Flask App using the Factory method."""
app = Flask(__name__)
app.config.from_object(config.CONFIGURATION[run_mode])
# start tracer
tracer = init_tracer(__name__)
FlaskTracing(tracer)
from auth_api import models
from auth_api.resources import API_BLUEPRINT, OPS_BLUEPRINT
db.init_app(app)
ma.init_app(app)
app.register_blueprint(API_BLUEPRINT)
app.register_blueprint(OPS_BLUEPRINT)
setup_jwt_manager(app, jwt)
@app.after_request
def add_version(response): # pylint: disable=unused-variable
version = get_run_version()
response.headers['API'] = f'auth_api/{version}'
return response
register_shellcontext(app)
return app
def init_tracer():
if (jaeger_logging):
app.logger.info("Report log on {}:{} with app name {}".format(
jaeger_host, jaeger_port, jaeger_service_name))
else:
app.logger.info("Jaeger is not activated")
config = Config(
config={ # usually read from some yaml config
'sampler': {
'type': 'const',
'param': 1,
},
'local_agent': {
'reporting_host': jaeger_host,
'reporting_port': jaeger_port,
},
'logging': jaeger_logging,
'propagation': 'b3'
},
service_name=jaeger_service_name,
validate=True)
opentracing_tracer = config.initialize_tracer()
tracing = FlaskTracing(opentracing_tracer, True, app)
return opentracing_tracer
def create_tracer(service_name,
flask_app,
jaeger_host="localhost",
sample_type="const",
sample_param=1):
"""Create global flask trace instance
:param service_name: current service name
:param flask_app: flask app instance
:param jaeger_host: jaeger agent host, default localhost
:param sample_type: work with sample param
reference: https://www.jaegertracing.io/docs/1.15/sampling/
:param sample_param:
:return:
"""
config = Config(config={
'sampler': {
'type': sample_type,
'param': sample_param
},
'local_agent': {
'reporting_host': jaeger_host
}
},
service_name=service_name,
validate=True)
jaeger_tracer = config.initialize_tracer()
tracer = FlaskTracing(jaeger_tracer, True, flask_app)
logging.info("Create trace {} on flask_app {} as service_name {}".format(
tracer, flask_app, service_name))
return tracer
def load(env):
# Flag parsing with wsgi runners is a major pain
# We identify a flag break '--' and consume only flags after it
if env != 'dev':
if '--' in sys.argv:
separator = sys.argv.index('--')
args = sys.argv[separator:]
logging.debug(
'Prod mode, loading args the hard way: {args}'.format(
args=args))
else:
args = sys.argv
FLAGS(args)
else:
FLAGS(sys.argv)
# Init sentry as early as possible to catch as much as possible
if FLAGS.sentry:
sentry_sdk.init(dsn=FLAGS.sentry,
integrations=[FlaskIntegration()],
environment=env,
release=__version__)
app = Flask(__name__)
app.config.from_object('websiteconfig')
# gRPC channel init
global channels
kwargs = {}
if FLAGS.consul:
kwargs['consul'] = True
if FLAGS.jaeger:
tracer = init_tracer()
kwargs['tracer'] = tracer
flask_tracer = FlaskTracing(tracer, True, app)
logging.info('Flask tracing enabled')
channels = Channels(**kwargs)
channels.refresh_all()
lm.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
flask_static_digest.init_app(app)
from app import user, maintenance, asset, pwa
app.register_blueprint(user.bp)
app.register_blueprint(maintenance.bp)
app.register_blueprint(asset.bp)
app.register_blueprint(pwa.bp)
@app.route('/')
def root():
return render_template('index.html')
@app.route('/favicon.ico')
def favicon():
return send_from_directory('static', 'img/icons/favicon.ico')
return app
def init_tracer(self) -> None:
"""Set attribute in flask `tracer`. See in `pyms.flask.services.tracer` how it works
:return: None
"""
if self._exists_service("tracer"):
client = self.tracer.get_client()
self.application.tracer = FlaskTracing(client, True,
self.application)
def init():
config = Config(service_name='test',
config={
'trace_id_header': 'Trace_ID',
'baggage_header_prefix': 'Trace-Attr-',
})
reporter = InMemoryReporter()
tracer = config.create_tracer(
reporter=reporter,
sampler=ConstSampler(True),
)
tracing = FlaskTracing(tracer, True, app)
def rest_prediction_server():
app = seldon_microservice.get_rest_microservice(user_object)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
if args.tracing:
logger.info("Tracing branch is active")
from flask_opentracing import FlaskTracing
logger.info("Set JAEGER_EXTRA_TAGS %s", jaeger_extra_tags)
tracing = FlaskTracing(tracer, True, app, jaeger_extra_tags)
app.run(host="0.0.0.0", port=port)
def test_error(self):
def start_span_cb(span, request):
raise RuntimeError('Should not happen')
tracing = FlaskTracing(MockTracer(),
True,
app,
start_span_cb=start_span_cb)
rv = test_app.get('/test')
assert '200' in str(rv.status_code)
spans = tracing.tracer.finished_spans()
assert len(spans) == 1
assert spans[0].tags.get(tags.ERROR, None) is None
def test_simple(self):
def start_span_cb(span, request):
span.set_tag('component', 'not-flask')
span.set_tag('mytag', 'myvalue')
tracing = FlaskTracing(MockTracer(),
True,
app,
start_span_cb=start_span_cb)
rv = test_app.get('/test')
assert '200' in str(rv.status_code)
spans = tracing.tracer.finished_spans()
assert len(spans) == 1
assert spans[0].tags.get(tags.COMPONENT, None) == 'not-flask'
assert spans[0].tags.get('mytag', None) == 'myvalue'
def load(self):
if self.jaeger_extra_tags is not None:
logger.info("Tracing branch is active")
from flask_opentracing import FlaskTracing
tracer = setup_tracing(self.interface_name)
logger.info("Set JAEGER_EXTRA_TAGS %s", self.jaeger_extra_tags)
FlaskTracing(tracer, True, self.application, self.jaeger_extra_tags)
logger.debug("LOADING APP %d", os.getpid())
try:
logger.debug("Calling user load method")
self.user_object.load()
except (NotImplementedError, AttributeError):
logger.debug("No load method in user model")
return self.application
def rest_prediction_server():
app = seldon_microservice.get_rest_microservice(user_object, seldon_metrics)
try:
user_object.load()
except (NotImplementedError, AttributeError):
pass
if args.tracing:
logger.info("Tracing branch is active")
from flask_opentracing import FlaskTracing
tracer = setup_tracing(args.interface_name)
logger.info("Set JAEGER_EXTRA_TAGS %s", jaeger_extra_tags)
FlaskTracing(tracer, True, app, jaeger_extra_tags)
app.run(
host="0.0.0.0",
port=http_port,
threaded=False if args.single_threaded else True,
)
import traceback
from flask import request
from flask_restplus import Resource, Namespace
from auth_api.services.keycloak import KeycloakService
import opentracing
from flask_opentracing import FlaskTracing
from ..utils.trace_tags import TraceTags as tags
from auth_api.utils.util import cors_preflight
API = Namespace('user', description='Keycloak Admin - user')
KEYCLOAK_SERVICE = KeycloakService()
tracer = opentracing.tracer
tracing = FlaskTracing(tracer)
@cors_preflight('GET, POST, DELETE, OPTIONS')
@API.route('', methods=['GET', 'POST', 'DELETE', 'OPTIONS'])
class User(Resource):
"""End point resource to manage users."""
@staticmethod
@tracing.trace()
def post():
"""Add user, return a new/existing user."""
current_span = tracer.active_span
data = request.get_json()
if not data:
application = Flask(__name__)
config = Config(config={
'sampler': {
'type': 'const',
'param': 1
},
'logging': True,
'local_agent': {
'reporting_host': getenv('JAEGER_HOST', 'localhost')
}
},
service_name=getenv('JAEGER_SERVICE_NAME', __name__))
jaeger_tracer = config.initialize_tracer()
tracing = FlaskTracing(jaeger_tracer, True, application, [])
api = swagger.docs(Api(application),
apiVersion='0.1',
basePath='http://*****:*****@application.route("/")
def index():
return render_template('index.html', title='Home')
'type': 'const',
'param': 1,
},
'local_agent': {
'reporting_host': 'jaeger',
# 'reporting_port': 'your-reporting-port',
},
'logging': True,
},
service_name=service_name,
validate=True
)
return config.initialize_tracer()
tracer = FlaskTracing(init_jaeger_tracer, True, app)
@api_usuarios.route("/")
class UserList(Resource):
@api_usuarios.expect(UserModel.model, validate=True)
def post(self):
payload = json.loads(request.data)
with opentracing.tracer.start_span('Adicionando o Usuario') as span:
span.set_tag("add_user.request_data", payload)
custom_erros = validate_payload(payload)
if custom_erros:
with opentracing.tracer.start_span(
'Dados de Telefone Invalido',
def __init__(
self,
pathfinding_service: PathfindingService,
one_to_n_address: Address,
operator: str,
info_message: str = DEFAULT_INFO_MESSAGE,
service_fee: TokenAmount = TokenAmount(0),
debug_mode: bool = False,
enable_tracing: bool = False,
) -> None:
flask_app = Flask(__name__)
if enable_tracing:
FlaskTracing(opentracing.tracer, trace_all_requests=True, app=flask_app)
self.flask_app = DispatcherMiddleware(
NotFound(),
{
"/metrics": make_wsgi_app(registry=metrics.REGISTRY),
API_PATH: flask_app.wsgi_app,
},
)
self.api = ApiWithErrorHandler(flask_app)
self.rest_server: Optional[WSGIServer] = None
self.one_to_n_address = one_to_n_address
self.pathfinding_service = pathfinding_service
self.service_fee = service_fee
self.operator = operator
self.info_message = info_message
# Enable cross origin requests
@flask_app.after_request
def after_request(response: Response) -> Response: # pylint: disable=unused-variable
response.headers.add("Access-Control-Allow-Origin", "*")
response.headers.add("Access-Control-Allow-Headers", "Origin, Content-Type, Accept")
response.headers.add("Access-Control-Allow-Methods", "GET,POST,OPTIONS")
return response
resources: List[Tuple[str, Resource, Dict, str]] = [
(
"/v1/<token_network_address>/paths",
PathsResource,
dict(debug_mode=debug_mode),
"paths",
),
("/v1/<token_network_address>/payment/iou", IOUResource, {}, "payments"),
("/v1/<token_network_address>/feedback", FeedbackResource, {}, "feedback"),
(
"/v1/<token_network_address>/suggest_partner",
SuggestPartnerResource,
{},
"suggest_partner",
),
("/v1/online_addresses", OnlineAddressesResource, {}, "online_addresses"),
("/v1/info", InfoResource, {}, "info"),
("/v2/info", InfoResource2, {}, "info2"),
(
"/v1/address/<checksummed_address>/metadata",
AddressMetadataResource,
{},
"address_metadata",
),
]
if debug_mode:
log.warning("The debug REST API is enabled. Don't do this on public nodes.")
resources.extend(
[
(
"/v1/_debug/routes/<token_network_address>/<source_address>",
cast(Resource, DebugPathResource),
{},
"debug1",
),
(
"/v1/_debug/routes/<token_network_address>/<source_address>/<target_address>", # noqa
DebugPathResource,
{},
"debug2",
),
("/v1/_debug/ious/<source_address>", DebugIOUResource, {}, "debug3"),
("/v1/_debug/stats", DebugStatsResource, {}, "debug4"),
]
)
for endpoint_url, resource, kwargs, endpoint in resources:
kwargs.update({"pathfinding_service": pathfinding_service, "api": self})
self.api.add_resource(
resource, endpoint_url, resource_class_kwargs=kwargs, endpoint=f"rest-{endpoint}"
)
})
upload_parser = api.parser()
upload_parser.add_argument('file', location='files',
type=FileStorage, required=True)
# Create configuration object with enabled logging and sampling of all requests.
config = Config(config={'sampler': {'type': 'const', 'param': 1},
'logging': True,
'local_agent':
# Also, provide a hostname of Jaeger instance to send traces to.
{'reporting_host': app.config['JAEGER_HOST']}},
# Service name can be arbitrary string describing this particular web service.
service_name=app.config['APP_NAME'])
jaeger_tracer = config.initialize_tracer()
tracing = FlaskTracing(tracer=jaeger_tracer, app=app)
createPermissions = lambda f: admin_required(f, roles=['ROLE_ADMIN', 'ROLE_PRODUCTS_CREATE', 'SCOPE_openid'])
ALLOWED_EXTENSIONS = app.config['ALLOWED_EXTENSIONS']
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@traced(log)
@logged(log)
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Endpoints to check and manage payments."""
import opentracing
from flask_opentracing import FlaskTracing
from flask_restplus import Namespace, Resource
API = Namespace('payments', description='Service - Payments')
TRACER = opentracing.tracer
TRACING = FlaskTracing(TRACER)
@API.route('')
class Payment(Resource):
"""Payment endpoint resource."""
@staticmethod
@TRACING.trace()
def get():
"""Get payment."""
return {'message': 'pay'}, 200
},
"local_agent": {
"reporting_host": "jaeger-agent",
"reporting_port": 5775,
},
"logging": True,
}
config = jConfig(
config=tracer_config,
service_name=f"RDSWebConnexionPlus",
metrics_factory=PrometheusMetricsFactory(namespace=f"RDSWebConnexionPlus"),
)
tracer_obj = config.initialize_tracer()
tracing = FlaskTracing(tracer_obj, True, app)
install_all_patches()
# add a TracingHandler for Logging
gunicorn_logger = logging.getLogger("gunicorn.error")
app.logger.handlers.extend(gunicorn_logger.handlers)
app.logger.addHandler(TracingHandler(tracer_obj))
app.logger.setLevel(gunicorn_logger.level)
### Tracing end ###
app.config.update(flask_config)
try:
from prometheus_flask_exporter.multiprocess import GunicornPrometheusMetrics
metrics = GunicornPrometheusMetrics(app)
except Exception as e:
import mock
import unittest
from flask import (Flask, request)
import opentracing
from opentracing.ext import tags
from opentracing.mocktracer import MockTracer
from flask_opentracing import FlaskTracing
app = Flask(__name__)
test_app = app.test_client()
tracing_all = FlaskTracing(MockTracer(), True, app, ['url'])
tracing = FlaskTracing(MockTracer())
tracing_deferred = FlaskTracing(lambda: MockTracer(), True, app, ['url'])
def flush_spans(tcr):
for req in tcr._current_scopes:
tcr._current_scopes[req].close()
tcr._current_scopes = {}
@app.route('/test')
def check_test_works():
return 'Success'
@app.route('/another_test')
@tracing.trace('url', 'url_rule')
def decorated_fn():
host_ip = get_ip()
if __name__ == '__main__':
debugmode = os.getenv('DEBUG_MODE', False)
log_level = logging.DEBUG
logging.getLogger('').handlers = []
logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)
# Create configuration object with enabled logging and sampling of all requests.
config = Config(
config={
'sampler': {
'type': 'const',
'param': 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="markf_vmworld_frontend")
jaeger_tracer = config.initialize_tracer()
tracing = FlaskTracing(jaeger_tracer, trace_all_requests=True, app=app)
install_all_patches()
app.run(host='0.0.0.0', debug=bool(debugmode), port=int(port))
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 ---")
import schedule
import time
import threading
from flask import Flask, request
from flask_cors import CORS
from api_management.jaeger import initializejaeger
from flask_opentracing import FlaskTracing
import implementation as implementation
app = Flask(__name__)
CORS(app)
jaeger_tracer = initializejaeger()
tracing = FlaskTracing(jaeger_tracer)
@app.route('/notificationscheduler/')
@tracing.trace()
def test_thread():
with jaeger_tracer.start_active_span(
'Notification-scheduler-API endpoint /notificationscheduler/') as scope:
scope.span.log_kv({'event': 'Calling endpoint /notificationscheduler/', 'request_method': request.method})
return implementation.getUsersWithFlowers()
def job():
with app.app_context():
implementation.getUsersWithFlowers()
sched = schedule
import jaeger_client
from flask import Flask
def initialize_tracer():
log_level = logging.DEBUG
logging.getLogger('').handlers = []
logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)
config = jaeger_client.Config(
config={ # usually read from some yaml config
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
},
service_name='flask-tracing-app',
validate=True,
)
# return config.initialize_tracer(io_loop=ioloop.IOLoop.current())
return config.initialize_tracer()
app = Flask(__name__)
tracing = FlaskTracing(initialize_tracer, True, app)
@app.route('/')
def hello():
return f'Hello, world!\n'
import registrator
from JaegerInjectAPI import TestInject
app = Flask(__name__)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
# Connection to models
JaegerInjectAPI_Provider = TestInject()
# Distributed Tracing
import jaegerTracing
tracer = jaegerTracing.getTracerInstance()
from flask_opentracing import FlaskTracing
tracing = FlaskTracing(tracer, True, app)
@app.route('/inject', methods=['GET'])
def testjaegerInject():
try:
application_status = JaegerInjectAPI_Provider.injectSpan()
return str(application_status)
except Exception as ex:
return jsonify(str(ex)), 500
if __name__ == '__main__':
app.run(host='0.0.0.0')
from interfaces import ViewsStorageBackend
import di
app = Flask(__name__)
tracer = Config(
config={
'sampler': {
'type': 'const',
'param': 1
}
},
service_name="pixel-tracking",
).initialize_tracer()
redis_opentracing.init_tracing(tracer)
FlaskTracing(tracer, app=app)
PIXEL = (b"GIF89a\x01\x00\x01\x00\x80\x00\x00\x00"
b"\x00\x00\xff\xff\xff!\xf9\x04\x01\x00"
b"\x00\x00\x00,\x00\x00\x00\x00\x01\x00"
b"\x01\x00\x00\x02\x01D\x00;")
REQUEST_TIME = Summary("request_processing_seconds",
"Time spent processing requests")
AVARAGE_TOP_HITS = Gauge("average_top_hits",
"Average number of top-10 page counts ")
TOP_PAGE = Info("top_page", "Most popular referrer")
@app.route("/track")
@REQUEST_TIME.time()
},
'handlers': {
'wsgi': {
'class': 'logging.StreamHandler',
'stream': 'ext://flask.logging.wsgi_errors_stream',
'formatter': 'default'
}
},
'root': {
'level': os.getenv('LOG_LEVEL', logging.INFO),
'handlers': ['wsgi']
}
})
logging.getLogger('werkzeug').disabled = True
app = Flask(__name__)
FlaskTracing(tracer=init_tracer(), trace_all_requests=True, app=app)
# TODO: 別モジュール化
@app.before_request
def before_request() -> NoReturn:
app.logger.info(f'[START] {request.method} {request.url}')
# TODO: 別モジュール化
@app.after_request
def after_request(response: flask.Response) -> flask.Response:
app.logger.info(f'[END] {response.status_code}')
return response
def test_start_span_invalid(self):
with pytest.raises(ValueError):
FlaskTracing(start_span_cb=0)
if JAEGER_AGENT != "":
config = Config(config={
'sampler': {
'type': 'const',
'param': 1
},
'local_agent': {
'reporting_host': JAEGER_AGENT,
'reporting_port': 6831
},
'logging': True,
'reporter_batch_size': 1
},
service_name="utilities")
jaeger_tracer = config.initialize_tracer()
tracing = FlaskTracing(jaeger_tracer, True, app)
else:
jaeger_tracer = None
tracing = None
def get_tracing_headers(req):
"""
receives a requests object, returns headers suitable for RPC and ID for logging
"""
new_headers = {}
if JAEGER_AGENT != "":
try:
jaeger_tracer.inject(tracing.get_span(req),
opentracing.Format.TEXT_MAP, new_headers)
except Exception as e:
def init_tracer(self):
self.application.opentracing_tracer = init_lightstep_tracer(
self.application.config["APP_NAME"])
self.application.tracer = FlaskTracing(
self.application.opentracing_tracer, True, self.application)