def _init_tracer(self): """ get global tracer callable function from Django settings. :return: """ assert settings.SERVICE_NAME assert settings.OPENTRACING_TRACER_CONFIG self.tracer = init_tracer(settings.SERVICE_NAME, settings.OPENTRACING_TRACER_CONFIG)
from flask import Flask from flask import request from tracing import init_tracer from opentracing.ext import tags from opentracing.propagation import Format app = Flask(__name__) tracer = init_tracer('formatter') @app.route("/format") def format(): span_ctx = tracer.extract(Format.HTTP_HEADERS, request.headers) span_tags = {tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER} with tracer.start_active_span('format', child_of=span_ctx, tags=span_tags): hello_to = request.args.get('helloTo') return 'Hello, %s!' % hello_to if __name__ == "__main__": app.run(port=8081)
app = Flask(__name__) trace_config = { 'sampler': { 'type': 'const', 'param': 1, }, 'local_agent': { 'reporting_host': 'jaeger', # 'reporting_port': 'your-reporting-port', }, 'logging': True, } tracer = init_tracer('service_c', trace_config) install_patches() @app.before_request def start_trace(): before_request_trace(tracer) @app.after_request def end_trace(response): after_request_trace(response) return response @app.teardown_request
from flask_restful import Resource, reqparse from tracing import init_tracer from ..dao.voucher import VoucherDAO _dao = VoucherDAO() parser = reqparse.RequestParser() parser.add_argument('type', type=str, required=True) parser.add_argument('code', type=str, required=True) parser.add_argument('amount', type=int, required=True) parser.add_argument('available', type=bool, required=True) tracing = init_tracer('voucher route') class VoucherRoute(Resource): @tracing.trace('get voucher') def get(self, _id): return _dao.get(_id) @tracing.trace('put voucher') def put(self, _id): args = parser.parse_args() return _dao.update(_id, args) @tracing.trace('delete voucher') def delete(self, _id): return _dao.delete(_id) class VoucherListRoute(Resource):
from flask_restful import Resource, reqparse from bson.objectid import ObjectId from tracing import init_tracer from ..dao.user import UserDAO from ..dao.product import ProductDAO from ..dao.voucher import VoucherDAO user_dao = UserDAO() product_dao = ProductDAO() voucher_dao = VoucherDAO() parser = reqparse.RequestParser() tracing = init_tracer('checkout route') class CheckoutRoute(Resource): @tracing.trace('post checkout') def post(self, user_id, order_id): order_dict = user_dao.get_order(user_id, order_id) # Subtotal subtotal = 0 quantity = 0 for item in order_dict['products']: product = product_dao.get(item['product_id']) subtotal += product['price'] * item['amount'] quantity += item['amount'] # Shipping shipping = 0
import sys import json import requests from flask import Flask, jsonify from flask import request from tracing import init_tracer, flask_to_scope import opentracing from opentracing.ext import tags from opentracing_instrumentation.client_hooks import install_all_patches from flask_opentracing import FlaskTracer from flask_cors import CORS, cross_origin app = Flask('garden-quizz') init_tracer('garden-quizz') install_all_patches() CORS(app) flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/quizz", methods=['GET', 'POST']) @cross_origin() def garden_quizz(): with flask_to_scope(flask_tracer, request) as scope: if request.method == 'POST': params = json.loads(request.data) garden_size = params['selected_garden_size'] flowers = params['selected_flowers'] score = calculate_score(garden_size, flowers) opentracing.tracer.active_span.set_tag('response', score) return jsonify({"score": score})
from flask import Flask from flask import request import json from database import Person from tracing import init_tracer, flask_to_scope import opentracing from opentracing.ext import tags from opentracing_instrumentation.client_hooks import install_all_patches from flask_opentracing import FlaskTracer app = Flask('users') init_tracer('users') install_all_patches() flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/getPerson/<name>") def get_person_http(name): with flask_to_scope(flask_tracer, request) as scope: person = Person.get(name) if person is None: if name in ["Neonicotinoid", "Insecticide", "DDT"]: raise Exception(f"{name}s are not kind to bees.") person = Person() person.name = name else: person.description response = { 'name': person.name, 'title': person.title, 'description': person.description,
import json import logging import aiohttp import asyncio from aiohttp import web from opentracing.ext import tags from opentracing.propagation import Format from opentracing.scope_managers.asyncio import AsyncioScopeManager from tracing import init_tracer tracer = init_tracer('gateway', scope_manager=AsyncioScopeManager) async def fetch(session, url, span): span.set_tag(tags.HTTP_METHOD, 'GET') span.set_tag(tags.HTTP_URL, url) span.set_tag(tags.SPAN_KIND, tags.SPAN_KIND_RPC_CLIENT) headers = {} tracer.inject(span, Format.HTTP_HEADERS, headers) async with session.get(url, headers=headers) as response: return await response.json() async def handle_favicon(request): return web.Response(text='')
from flask import Flask from flask import jsonify import requests from opentracing.ext import tags from opentracing.propagation import Format from tracing import init_tracer from decorators import trace tracer = init_tracer('assets') app = Flask(__name__) def http_get(url): span = tracer.active_span span.set_tag(tags.HTTP_METHOD, 'GET') span.set_tag(tags.HTTP_URL, url) span.set_tag(tags.SPAN_KIND, tags.SPAN_KIND_RPC_CLIENT) headers = {} tracer.inject(span, Format.HTTP_HEADERS, headers) return requests.get(url, headers=headers) @app.route('/assets/<int:asset_id>/') @trace(tracer, 'check_token') def hello(asset_id):
from flask import Flask from flask import request from tracing import init_tracer from opentracing.ext import tags from opentracing.propagation import Format app = Flask(__name__) tracer = init_tracer('publisher') @app.route("/publish") def publish(): span_ctx = tracer.extract(Format.HTTP_HEADERS, request.headers) span_tags = {tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER} from ipdb import set_trace set_trace() with tracer.start_active_span( 'publish', child_of=span_ctx, tags=span_tags ): hello_str = request.args.get('helloStr') print(hello_str) return 'published' if __name__ == "__main__": app.run(port=8082)
import sys import json import requests from flask import Flask, jsonify from flask import request from tracing import init_tracer, flask_to_scope, parse_baggage import opentracing from opentracing_instrumentation.client_hooks import install_all_patches from flask_opentracing import FlaskTracer from flask_cors import CORS, cross_origin app = Flask('garden-scorer') init_tracer('garden-scorer') CORS(app) install_all_patches() flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/flower_scorer", methods=['GET', 'POST']) @cross_origin() def flower_scorer(): with flask_to_scope(flask_tracer, request) as scope: #parse_baggage(request.headers, scope) if request.method == 'POST': params = json.loads(request.data) print(f"got form data {params.keys()}") garden_size = params['selected_garden_size'] flowers = params['selected_flowers'] score = calculate_score(garden_size, flowers) opentracing.tracer.active_span.set_tag('response', score) return jsonify({"score": score})
from flask_restful import Resource, reqparse from tracing import init_tracer from ..dao.product import ProductDAO _dao = ProductDAO() parser = reqparse.RequestParser() parser.add_argument('name', type=str, required=True) parser.add_argument('price', type=float, required=True) parser.add_argument('available', type=int, required=True) tracing = init_tracer('product route') class ProductRoute(Resource): @tracing.trace('get product') def get(self, _id): return _dao.get(_id) @tracing.trace('put product') def put(self, _id): args = parser.parse_args() return _dao.update(_id, args) @tracing.trace('delete product') def delete(self, _id): return _dao.delete(_id) class ProductListRoute(Resource): @tracing.trace('get products')
from flask import Flask from flask import request from tracing import init_tracer, flask_to_scope import opentracing from opentracing.ext import tags from flask_opentracing import FlaskTracer app = Flask('greeting') init_tracer('greeting') flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/formatGreeting") def handle_format_greeting(): with flask_to_scope(flask_tracer, request) as scope: name = request.args.get('name') title = request.args.get('title') descr = request.args.get('description') return format_greeting( name=name, title=title, description=descr, ) def format_greeting(name, title, description): with opentracing.tracer.start_active_span('format-greeting', ) as scope: greeting = scope.span.get_baggage_item('greeting') or 'Hello' greeting += ', ' if title: greeting += title + ' '
from flask import Flask, jsonify, request from tracing import init_tracer from opentracing.ext import tags from opentracing.propagation import Format app = Flask(__name__) tracer = init_tracer('eval-service') evalresults = [{ 'item': u'Item1', 'reason': u'Reason1', 'isCompliant': False }, { 'item': u'Item2', 'reason': u'Reason2', 'isCompliant': False }] @app.route('/') def ping_api(): return 'evaluate is up!' @app.route('/api/evalresults', methods=['GET']) def get_evalresults(): return jsonify({'evalresults': evalresults})
from flask_restful import Resource, reqparse from tracing import init_tracer from ..dao.user import UserDAO _dao = UserDAO() parser = reqparse.RequestParser() parser.add_argument('products', type=dict, action='append') parser.add_argument('voucher_id', type=str, required=True) parser.add_argument('date', type=str, required=True) tracing = init_tracer('order route') class OrderListRoute(Resource): @tracing.trace('get orders') def get(self, user_id): return _dao.get_orders(user_id) @tracing.trace('post orders') def post(self, user_id): args = parser.parse_args() return _dao.save_order(user_id, args), 201
from flask import Flask from flask import request import json from tracing import init_tracer, flask_to_scope from database import Flower import opentracing #from opentracing_instrumentation.client_hooks import install_all_patches from flask_opentracing import FlaskTracer app = Flask('flower-service') init_tracer('flower-service') #install_all_patches() flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/getFlower/<name>") def get_flower_http(name): with flask_to_scope(flask_tracer, request) as scope: flower = Flower.get(name) if flower is None: flower = Flower() flower.name = name flower.flowering_months = "june" result = { 'name': flower.name, 'flowering_months': flower.flowering_months.split(","), 'description': flower.description, }
import sys import json import requests from flask import Flask from flask import request from tracing import init_tracer, flask_to_scope import opentracing from opentracing.ext import tags from opentracing_instrumentation.client_hooks import install_all_patches from flask_opentracing import FlaskTracer from flask_cors import CORS, cross_origin app = Flask('newsletter') init_tracer('newsletter') install_all_patches() CORS(app) flask_tracer = FlaskTracer(opentracing.tracer, True, app) @app.route("/sayHello/<name>") @cross_origin() def say_hello(name): with flask_to_scope(flask_tracer, request) as scope: person = get_person(name) resp = format_greeting(person) opentracing.tracer.active_span.set_tag('response', resp) return resp def get_person(name): with opentracing.tracer.start_active_span('get-person', ) as scope:
import logging from flask import Flask from flask import jsonify from tracing import init_tracer from decorators import trace tracer = init_tracer('users') app = Flask(__name__) @app.route('/users/<string:user_id>/') @trace(tracer, 'get_user') def get_user(user_id): return jsonify({'id': user_id, 'name': 'User {}'.format(user_id)}) if __name__ == '__main__': app.run(port=5004)
from mongoengine.errors import (FieldDoesNotExist, NotUniqueError, ValidationError) from apps.responses import (resp_data_invalid, resp_ok, resp_exception, resp_already_exists) from apps.messages import (MSG_RESOURCE_FETCHED_PAGINATED, MSG_RESOURCE_FETCHED, MSG_NO_DATA, MSG_ALREADY_EXISTS, MSG_INVALID_DATA, MSG_RESOURCE_UPDATED, MSG_RESOURCE_DELETED) from .models import User from .schemas import UserSchema, UserUpdateSchema from .utils import get_user_by_id, exists_email_in_users tracer = init_tracer('users_page_list') class AdminUserPageList(Resource): @trace(tracer, 'get_users') def get(self, page_id=1): schema = UserSchema(many=True) page_size = 10 if 'page_size' in request.args: if int(request.args.get('page_size')) < 1: page_size = 10 else: page_size = int(request.args.get('page_size')) try:
import random import time from flask import Flask from flask import jsonify from tracing import init_tracer from decorators import trace app = Flask(__name__) tracer = init_tracer('acls') @app.route('/acls/<string:permission>/') @trace(tracer, 'check_permission') def check_permissions(permission): time.sleep(random.randint(1, 5) / 10) return jsonify({'access': 'granted', 'permission': permission}) @app.route('/roles/<string:role>/') @trace(tracer, 'check_role') def check_roles(role): time.sleep(random.randint(1, 5) / 10) return jsonify({'role': role, 'access': 'granted'}) if __name__ == '__main__': app.run(port=5002)
import logging import requests from flask import Flask from flask import jsonify from opentracing.ext import tags from opentracing.propagation import Format from tracing import init_tracer from decorators import trace app = Flask(__name__) tracer = init_tracer('auth') def http_get(url): span = tracer.active_span span.set_tag(tags.HTTP_METHOD, 'GET') span.set_tag(tags.HTTP_URL, url) span.set_tag(tags.SPAN_KIND, tags.SPAN_KIND_RPC_CLIENT) headers = {} tracer.inject(span, Format.HTTP_HEADERS, headers) return requests.get(url, headers=headers) @app.route('/token/<string:token>/') @trace(tracer, 'check_token') def hello(token):
http_get(8082, 'publish', 'helloStr', hello_str) scope.span.log_kv({'event': 'println'}) def http_get(port, path, param, value): url = 'http://localhost:%s/%s' % (port, path) span = tracer.active_span span.set_tag(tags.HTTP_METHOD, 'GET') span.set_tag(tags.HTTP_URL, url) span.set_tag(tags.SPAN_KIND, tags.SPAN_KIND_RPC_CLIENT) headers = {} tracer.inject(span, Format.HTTP_HEADERS, headers) r = requests.get(url, params={param: value}, headers=headers) assert r.status_code == 200 return r.text # main assert len(sys.argv) == 2 tracer = init_tracer('hello-world') hello_to = sys.argv[1] say_hello(hello_to) # yield to IOLoop to flush the spans time.sleep(2) tracer.close()
from flask_restful import Resource, reqparse import bcrypt from tracing import init_tracer from ..dao.user import UserDAO _dao = UserDAO() parser = reqparse.RequestParser() parser.add_argument('name', type=str, required=True) parser.add_argument('email', type=str, required=True) parser.add_argument('password', type=str, required=True) tracing = init_tracer('user route') class UserRoute(Resource): @tracing.trace('get user') def get(self, _id): return _dao.get(_id) @tracing.trace('put user') def put(self, _id): args = parser.parse_args() return _dao.update(_id, args) @tracing.trace('delete user') def delete(self, _id): return _dao.delete(_id) class UserListRoute(Resource): @tracing.trace('get users')
import logging from datetime import datetime from flask import Flask from flask import jsonify from tracing import init_tracer from decorators import trace tracer = init_tracer('metadata') app = Flask(__name__) @app.route('/metadata/assets/<string:asset_id>/') @trace(tracer, 'get_asset_metadata') def get_asset_metadata(asset_id): return jsonify({ 'title': 'Asset {}'.format(asset_id), 'status': 'CLOSED', 'date_created': datetime.now().isoformat(), }) if __name__ == '__main__': app.run(port=5005)