def init(application):
global flask_tracer
global rpc
flask_tracer = FlaskTracer(init_tracer("item rental"), True, application)
rpc = FlaskPooledClusterRpcProxy()
def create_app():
rpc_app = Flask(__name__)
rpc_app.config.update(
dict(NAMEKO_AMQP_URI='pyamqp://{}:{}@{}'.format(
os.getenv('RABBITMQ_USER', "guest"),
os.getenv('RABBITMQ_PASSWORD', "guest"),
os.getenv('RABBITMQ_HOST', "localhost"))))
rpc.init_app(rpc_app)
create_app()
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from time import sleep
from opentracing.ext import tags
from opentracing.propagation import Format
from random import randint
app = Flask(__name__)
tracer = init_tracer('db2')
@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('end-chain', child_of=span_ctx, tags=span_tags) as scope:
hello_to = request.args.get('helloTo')
bug = request.args.get('bug')
app.logger.debug("Hello from db2!!!")
if bug == "True":
bug = False
elif bug == "False":
bug = False
scope.span.log_kv({'event': 'db2 read bug', 'bug status': str(bug), 'bug taIp': str(type(bug))})
app.logger.debug("bug is: " + str(bug))
if bug:
app.logger.debug("bug is true, sleeping")
scope.span.log_kv({'event': 'db2-bug true', 'bug status': str(bug)})
sleep(.1)
import json
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
import opentracing
from opentracing.ext import tags
app = Flask('py-4-hello')
init_tracer('py-4-hello')
@app.route("/sayHello/<name>")
def say_hello(name):
span_ctx = opentracing.tracer.extract(
opentracing.Format.HTTP_HEADERS,
request.headers,
)
with opentracing.tracer.start_active_span(
'say-hello',
child_of=span_ctx,
tags={tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER},
) as scope:
person = get_person(name)
resp = format_greeting(person)
scope.span.set_tag('response', resp)
return resp
def get_person(name):
with opentracing.tracer.start_active_span('get-person', ) as scope:
from flask import Flask
from flask import request
import requests
import opentracing
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing_instrumentation.client_hooks import install_all_patches
from flask_opentracing import FlaskTracer
app = Flask('profanity-svc')
init_tracer('profanity-svc')
install_all_patches()
flask_tracer = FlaskTracer(opentracing.tracer, True, app)
def censor(story):
with opentracing.tracer.start_active_span(
'censor',
) as scope:
res = requests.get(
'https://www.purgomalum.com/service/plain', params={"text": story})
scope.span.log_kv({'story': story, 'censored_story': res.text})
return res.text
@app.route('/profanity', methods=['POST'])
@flask_tracer.trace()
def handle_profanity():
story = request.json['story']
censored_story = censor(story)
return censored_story
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
from random import randint
app = Flask(__name__)
tracer = init_tracer('search')
def http_get(port, path, param, value, bug):
url = 'http://app-db:%s/%s' % (port, path)
if not randint(1, 3) == 2:
url = 'http://app-db2:%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,
'bug': bug
},
headers=headers,
timeout=1)
import sys
import json
import requests
from flask import Flask
from flask import request
from lib.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('py-6-hello')
init_tracer('py-6-hello')
install_all_patches()
flask_tracer = FlaskTracer(opentracing.tracer, True, app)
@app.route("/sayHello/<name>")
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:
url = 'http://localhost:8081/getPerson/%s' % name
res = _get(url)
person = json.loads(res)
import json
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
import opentracing
from opentracing.ext import tags
app = Flask('py-5-hello')
init_tracer('py-5-hello')
@app.route("/sayHello/<name>")
def say_hello(name):
span_ctx = opentracing.tracer.extract(
opentracing.Format.HTTP_HEADERS,
request.headers,
)
with opentracing.tracer.start_active_span(
'say-hello',
child_of=span_ctx,
tags={tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER},
) as scope:
person = get_person(name)
resp = format_greeting(person)
scope.span.set_tag('response', resp)
return resp
def get_person(name):
from flask import Flask
from flask import request
import sys
import time
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
import requests
app = Flask(__name__)
tracer = init_tracer('hello')
@app.route('/<name>')
def hello(name):
with tracer.start_active_span('hello') as scope:
scope.span.set_tag('hello_to', name)
hello_str = format_string(name)
print_hello(hello_str)
return hello_str
def format_string(hello_to):
with tracer.start_active_span('format') as scope:
hello_str = http_get(8081, 'format', 'helloTo', hello_to)
scope.span.log_kv({'event': 'string-format', 'value': hello_str})
return hello_str
def print_hello(hello_str):
with tracer.start_active_span('println') as scope:
from flask import Flask
from flask import request
from lib.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)
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
import time
app = Flask(__name__)
tracer = init_tracer('yserv')
def http_get(port, path, param, value):
url = 'http://*****:*****@app.route("/format")
def format():
print("can't print")
print("its a daist")
print("more stuff")
from flask import Flask
from .database import Person
from lib.tracing import init_tracer
import opentracing
app = Flask('py-3-hello')
init_tracer('py-3-hello')
@app.route("/sayHello/<name>")
def say_hello(name):
with opentracing.tracer.start_active_span('say-hello') as scope:
person = get_person(name)
resp = format_greeting(
name=person.name,
title=person.title,
description=person.description,
)
scope.span.set_tag('response', resp)
return resp
def get_person(name):
with opentracing.tracer.start_active_span('get-person', ) as scope:
person = Person.get(name)
if person is None:
person = Person()
person.name = name
scope.span.log_kv({
'name': person.name,
'title': person.title,
from flask import Flask, render_template
from flask import request, redirect, jsonify
import requests
import opentracing
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing_instrumentation.client_hooks import install_all_patches
from flask_opentracing import FlaskTracer
app = Flask('game-svc', template_folder='templates')
init_tracer('game-svc')
install_all_patches()
flask_tracer = FlaskTracer(opentracing.tracer, True, app)
games = {
'1': {
"player1": "aswin",
"player2": "prabhu",
"curr_turn": "aswin"
}
}
game_count = 1
def get_story(id):
with opentracing.tracer.start_active_span(
'get_story',
) as scope:
story = requests.get('http://localhost:8001/story/' + str(id))
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
import time
app = Flask(__name__)
tracer = init_tracer('api')
def http_get(port, path, param, value):
url = 'http://*****:*****@app.route("/format")
def format():
start = time.time()
from flask import Flask
from .database import Person
from lib.tracing import init_tracer
import opentracing
app = Flask('py-2-hello')
init_tracer('py-2-hello')
@app.route("/sayHello/<name>")
def say_hello(name):
with opentracing.tracer.start_span('say-hello') as span:
person = get_person(name, span)
resp = format_greeting(
name=person.name,
title=person.title,
description=person.description,
)
span.set_tag('response', resp)
return resp
def get_person(name, span):
person = Person.get(name)
if person is None:
person = Person()
person.name = name
span.log_kv({
'name': person.name,
'title': person.title,
'description': person.description,
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
from random import randint
app = Flask(__name__)
tracer = init_tracer('android')
def http_get(url, param, value):
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, timeout=1)
assert r.status_code == 200
return r.text
@app.route("/")
def format():
service = 'android'
span_ctx = tracer.extract(Format.HTTP_HEADERS, request.headers)
span_tags = {tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER}
from flask import Flask
from flask import request
from lib.tracing import init_tracer
import opentracing
app = Flask('py-4-formatter')
init_tracer('py-4-formatter')
@app.route("/formatGreeting")
def handle_format_greeting():
with opentracing.tracer.start_active_span('/formatGreeting') 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', ):
greeting = 'Hello, '
if title:
greeting += title + ' '
greeting += name + '!'
if description:
greeting += ' ' + description
return greeting
from flask import Flask
from flask import request
import requests
import opentracing
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing_instrumentation.client_hooks import install_all_patches
from flask_opentracing import FlaskTracer
app = Flask('story-svc')
init_tracer('story-svc')
install_all_patches()
flask_tracer = FlaskTracer(opentracing.tracer, True, app)
games = {'1': "this is story 1"}
def get_story_for_game(id):
global games
if id in games:
return games[id]
else:
games[id] = ""
return ""
def censor_story(story):
with opentracing.tracer.start_active_span('censor_story', ) as scope:
censored_story = requests.post('http://localhost:8002/profanity',
json={
"story": story
#initializing flask
from flask import Flask, render_template, jsonify, flash, request
from flask import g, request
from flask_httpauth import HTTPTokenAuth
from sentry_sdk.integrations.flask import FlaskIntegration
app = Flask(__name__)
app.debug = True
auth = HTTPTokenAuth('Bearer')
sentry_sdk.init(
dsn="https://[email protected]/1722363",
integrations=[FlaskIntegration()])
cart_tracer = init_tracer('cart')
#flask_tracer = FlaskTracing(opentracing_tracer, True, app)
# set variables with env variables
from os import environ
if environ.get('REDIS_HOST') is not None:
if os.environ['REDIS_HOST'] != "":
redishost = os.environ['REDIS_HOST']
else:
redishost = 'localhost'
else:
redishost = 'localhost'
if environ.get('REDIS_PORT') is not None:
if os.environ['REDIS_PORT'] != "":
def print_hello(hello_str, parent_span):
with tracer.start_span('println', child_of=parent_span) as span:
http_get(8082, 'publish', 'helloStr', hello_str, span)
span.log_kv({'event': 'println'})
def http_get(port, path, param, value, span):
url = 'http://localhost:%s/%s' % (port, path)
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()
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
app = Flask(__name__)
tracer = init_tracer('model')
def http_get(port, path, param, value, bug):
url = 'http://app-db:%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,
'bug': bug
},
headers=headers,
timeout=1)
assert r.status_code == 200
return r.text
# maxudpsize=512)
#initializing requests
from requests.auth import HTTPBasicAuth
#initializing flask
from flask import Flask, render_template, jsonify, flash, request
from flask import g,request
from flask_httpauth import HTTPTokenAuth
app = Flask(__name__)
app.debug=True
auth = HTTPTokenAuth('Bearer')
order_tracer = init_tracer('order')
@app.errorhandler(FoundIssue)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
#initializing postgres on localhost and port 27017
#If error terminates process- entire order is shut down
from os import environ
if environ.get('ORDER_DB_USERNAME') is not None:
if os.environ['ORDER_DB_USERNAME'] != "":
orderDbUser=os.environ['ORDER_DB_USERNAME']
else:
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
import time
app = Flask(__name__)
tracer = init_tracer('web')
def http_get(port, path, param, value):
url = 'http://*****:*****@app.route("/format")
def format():
print("format function in web is executing")
from flask import Flask
from flask import request
from lib.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 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('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)
from flask import Flask
from flask import request
import json
from .database import Person
from lib.tracing import init_tracer
import opentracing
from opentracing.ext import tags
app = Flask('py-5-bigbrother')
init_tracer('py-5-bigbrother')
@app.route("/getPerson/<name>")
def get_person_http(name):
span_ctx = opentracing.tracer.extract(
opentracing.Format.HTTP_HEADERS,
request.headers,
)
with opentracing.tracer.start_active_span(
'/getPerson',
child_of=span_ctx,
tags={tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER},
) as scope:
person = Person.get(name)
if person is None:
person = Person()
person.name = name
scope.span.log_kv({
'name': person.name,
'title': person.title,
import requests
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from opentracing.ext import tags
from opentracing.propagation import Format
from random import randint
app = Flask(__name__)
tracer = init_tracer('ios')
def http_get(url, param, value):
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,
timeout=1)
assert r.status_code == 200
return r.text
@app.route("/")
def format():
from flask import Flask
from flask import request
from lib.tracing import init_tracer
from time import sleep
from opentracing.ext import tags
from opentracing.propagation import Format
from random import randint
app = Flask(__name__)
tracer = init_tracer('db')
@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('end-chain',
child_of=span_ctx,
tags=span_tags) as scope:
hello_to = request.args.get('helloTo')
bug = request.args.get('bug')
if bug == "True":
bug = True
elif bug == "False":
bug = False
scope.span.log_kv({
'event': 'db read bug',
'bug status': str(bug),
'bug taIp': str(type(bug))
})
if bug:
