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)
