def __exit__(self, exctype: Type[Exception], excinst: Exception,
exctb: Traceback):
if captured := exctype is not None and issubclass(
exctype, self._exceptions):
log_warning(self._log, exec_info=True, **self._kwargs)
if span := tracer.current_span(): # pragma: no cover
span.set_exc_info(exctype, excinst, exctb)
async def safe_create_category_channel(
client: discord.Client,
guild_xid: int,
name: str,
) -> Optional[discord.CategoryChannel]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({"guild_xid": str(guild_xid), "name": name})
async def safe_ensure_voice_category(
client: discord.Client,
guild_xid: int,
prefix: str,
) -> Optional[discord.CategoryChannel]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({"guild_xid": str(guild_xid), "prefix": prefix})
def think(subject):
tracer.current_span().set_tag('subject', subject)
sleep(0.5)
quote = Thought.query.filter_by(subject=subject).first()
return quote
def call_generate_requests():
payload = flask_request.get_json()
span = tracer.current_span()
app.logger.info(f"Looking at {span}")
app.logger.info(f"with span id {span.span_id}")
span = tracer.current_span()
span.set_tags({
'requests': payload['total'],
'concurrent': payload['concurrent']
})
output = subprocess.check_output([
'/app/traffic_generator.py',
str(payload['concurrent']),
str(payload['total']),
str(payload['url'])
])
app.logger.info(f"Result for subprocess call: {output}")
return jsonify({
'traffic':
str(payload['concurrent']) + ' concurrent requests generated, ' +
str(payload['total']) + ' requests total.',
'url':
payload['url']
})
def test_template(self):
start = time.time()
rv = client.get('/tmpl')
end = time.time()
# ensure request worked
eq_(rv.status_code, 200)
eq_(rv.data, b'hello earth')
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 2)
by_name = {s.name:s for s in spans}
s = by_name["flask.request"]
eq_(s.service, service)
eq_(s.resource, "tmpl")
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '200')
t = by_name["flask.template"]
eq_(t.get_tag("flask.template"), "test.html")
eq_(t.parent_id, s.span_id)
eq_(t.trace_id, s.trace_id)
assert s.start < t.start < t.start + t.duration < end
async def safe_update_embed(
message: Union[discord.Message, discord.PartialMessage],
*args: Any,
**kwargs: Any,
) -> bool:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({"messsage_xid": str(message.id)})
def dog_fact():
dog_fact = requests.get(DOG_FACT_SERVICE).json()
fact = dog_fact.get('facts')[0]
app.logger.info("Important dog fact - %s" % fact)
# set the dog fact on this span as a tag
tracer.current_span().set_tag('dog.fact', fact)
return fact
def test_template(self):
start = time.time()
rv = client.get('/tmpl')
end = time.time()
# ensure request worked
eq_(rv.status_code, 200)
eq_(rv.data, b'hello earth')
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 2)
by_name = {s.name: s for s in spans}
s = by_name["flask.request"]
eq_(s.service, service)
eq_(s.resource, "tmpl")
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '200')
t = by_name["flask.template"]
eq_(t.get_tag("flask.template"), "test.html")
eq_(t.parent_id, s.span_id)
eq_(t.trace_id, s.trace_id)
assert s.start < t.start < t.start + t.duration < end
async def safe_send_user(
user: Union[discord.User, discord.Member],
*args: Any,
**kwargs: Any,
) -> None:
user_xid = getattr(user, "id", None)
if span := tracer.current_span(): # pragma: no cover
span.set_tags({"user_xid": str(user_xid)})
async def safe_fetch_text_channel(
client: discord.Client,
guild_xid: int,
channel_xid: int,
) -> Optional[discord.TextChannel]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({
"guild_xid": str(guild_xid),
"channel_xid": str(channel_xid)
})
async def safe_create_invite(
channel: discord.VoiceChannel,
guild_xid: int,
max_age: int = 0,
) -> Optional[str]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({
"guild_xid": str(guild_xid),
"channel_xid": str(channel.id)
})
def safe_get_partial_message(
channel: MessageableChannel,
guild_xid: int,
message_xid: int,
) -> Optional[discord.PartialMessage]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags({
"guild_xid": str(guild_xid),
"message_xid": str(message_xid)
})
async def safe_update_embed_origin(
interaction: discord.Interaction,
*args: Any,
**kwargs: Any,
) -> bool:
assert hasattr(interaction, "message")
assert interaction.message
if span := tracer.current_span(): # pragma: no cover
span.set_tags({"interaction.message.id": str(interaction.message.id)})
def lambda_endpoint():
app.logger.info('getting lambda endpoint')
q = {'TableName': 'kikeyama-dynamodb'}
r = requests.get('https://8m92rdlm25.execute-api.us-east-1.amazonaws.com/demo/lambda', headers={
'x-datadog-trace-id': str(tracer.current_span().trace_id),
'x-datadog-parent-id': str(tracer.current_span().span_id),
}, params=q)
dict_r = json.loads(r.text)
if dict_r['ResponseMetadata']['HTTPStatusCode'] == 200:
app.logger.info('lambda call: Returned ' + str(dict_r['Count']) + ' results with RequestId: ' + dict_r['ResponseMetadata']['RequestId'])
return 'Lambda Traces'
async def safe_followup_channel(
interaction: discord.Interaction,
*args: Any,
**kwargs: Any,
) -> Optional[discord.Message]:
if span := tracer.current_span(): # pragma: no cover
span.set_tags(
{
"guild_xid": str(interaction.guild_id),
"channel_xid": str(interaction.channel_id),
}, )
def think(subject):
tracer.current_span().set_tag('subject', subject)
sleep(0.5)
quote = Thought.query.filter_by(subject=subject).first()
if quote is None:
return Thought(
quote='Hmmm, that\'s something I\'ll need to think about.',
author='The Machine',
subject=subject)
return quote
async def safe_channel_reply(
channel: discord.TextChannel,
*args: Any,
**kwargs: Any,
) -> Optional[discord.Message]:
guild_xid = channel.guild.id
channel_xid = channel.id
if span := tracer.current_span(): # pragma: no cover
span.set_tags({
"guild_xid": str(guild_xid),
"channel_xid": str(channel_xid)
})
def think_handler():
thoughts = requests.get('http://thinker:5001/',
headers={
'x-datadog-trace-id':
str(tracer.current_span().trace_id),
'x-datadog-parent-id':
str(tracer.current_span().span_id),
},
params={
'subject':
flask_request.args.getlist('subject', str),
}).content
return Response(thoughts, mimetype='application/json')
def _disable_apm():
# New Relic
try:
import newrelic.agent
newrelic.agent.ignore_transaction(flag=True)
except ImportError:
pass
# Datadog
try:
from ddtrace import tracer
from ddtrace.constants import MANUAL_DROP_KEY
tracer.current_span().set_tag(MANUAL_DROP_KEY)
except (AttributeError, ImportError):
pass
async def safe_add_role(
user_or_member: Union[discord.User, discord.Member],
guild: discord.Guild,
role: str,
remove: Optional[bool] = False,
) -> None:
if span := tracer.current_span(): # pragma: no cover
span.set_tags(
{
"user_xid": str(getattr(user_or_member, "id", None)),
"guild_xid": str(guild.id),
"role": role,
"remove": str(remove),
}, )
async def think(subject):
#redis_client.incr('hits')
#aiohttp_logger.info('Number of hits is {}' .format(redis_client.get('hits').decode('utf-8')))
tracer.current_span().set_tag('subject', subject)
cached_thought = redis_client.get(subject)
if cached_thought:
return pickle.loads(cached_thought)
await asyncio.sleep(0.5)
thought = thoughts[subject]
redis_client.set(subject, pickle.dumps(thought))
return thought
def best_match(beer):
# find our optimal sugar level Donuts above or below this level
# will certainly not be a good match
db = DonutStats.instance()
optimal_sugar_level = db.get_optimal_sugar_level(beer.hops)
candidates = db.get_by_sugar_level(optimal_sugar_level, limit=10)
try:
# propagate the trace context between the two services
span = tracer.current_span()
headers = {
"X-Datadog-Trace-Id": str(span.trace_id),
"X-Datadog-Parent-Id": str(span.span_id),
}
resp = requests.get(
"http://taster:5001/taste",
params={
"beer": beer.name,
"donuts": candidates
},
timeout=2,
headers=headers,
)
except requests.exceptions.Timeout:
# log the error
return "not available"
return resp.json()["candidate"]
def best_match(beer):
"""
returns a single donut matched to the hops level of a beer
"""
# get a list of donuts that match sugar content for beer
candidates = get_candidates(beer)
span = tracer.current_span()
span.set_tag('donuts.candidates', candidates)
# send the remaining candidates to our taster and pick the best
max_score = -1
best_match = None
for candidate in candidates:
try:
resp = requests.get(
"http://taster:5001/taste",
params={
"beer": beer.name,
"donut": candidate
},
timeout=2,
)
except requests.exceptions.Timeout:
continue
score = resp.json()["score"]
if score > max_score:
max_score = score
best_match = candidate
return best_match
def test_fatal(self):
# if not app.use_signals:
# return
#
start = time.time()
try:
client.get('/fatal')
except ZeroDivisionError:
pass
else:
assert 0
end = time.time()
# ensure the request was traced.
assert not tracer.current_span()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, "fatal")
assert s.start >= start
assert s.duration <= end - start
eq_(s.meta.get(http.STATUS_CODE), '500')
assert "ZeroDivisionError" in s.meta.get(errors.ERROR_TYPE)
msg = s.meta.get(errors.ERROR_MSG)
assert "by zero" in msg, msg
def Test_Function_A(Parm_A):
span = tracer.current_span()
span.set_tag('Parm_Tag_A', Parm_A)
output_str = 'Testing, %s!' % Parm_A
randomnum = random.randint(1, 31)
time.sleep(randomnum)
print(output_str)
def test_fatal(self):
# if not app.use_signals:
# return
#
start = time.time()
try:
client.get('/fatal')
except ZeroDivisionError:
pass
else:
assert 0
end = time.time()
# ensure the request was traced.
assert not tracer.current_span()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, "fatal")
assert s.start >= start
assert s.duration <= end - start
eq_(s.meta.get(http.STATUS_CODE), '500')
assert "ZeroDivisionError" in s.meta.get(errors.ERROR_TYPE)
msg = s.meta.get(errors.ERROR_MSG)
assert "by zero" in msg, msg
def best_match(beer):
"""
returns a single donut matched to the hops level of a beer
"""
# get a list of donuts that match sugar content for beer
candidates = get_candidates(beer)
try:
# propagate the trace context between the two services
span = tracer.current_span()
headers = {
"X-Datadog-Trace-Id": str(span.trace_id),
"X-Datadog-Parent-Id": str(span.span_id),
}
resp = requests.get(
"http://taster:5001/taste",
params={
"beer": beer.name,
"donuts": candidates
},
timeout=2,
headers=headers,
)
except requests.exceptions.Timeout:
# log the error
return "not available"
return resp.json()["candidate"]
def update_scraper():
global totalMessages
params = request.get_json()
span = tracer.current_span()
span.set_tags({'request_json': params})
totalMessages.append(params['message'])
return '{"status": "ok", "totalMessages": %s}' % str(totalMessages)
def api():
response = requests.get('https://api.github.com')
current_span = tracer.current_span()
if current_span:
current_span.set_tag('important_response_value', len(response.text))
text_length = len(response.text)
return "This is the API Response of length: {}".format(text_length)
def test_404(self):
start = time.time()
rv = client.get(u'/404/üŋïĉóđē')
end = time.time()
# ensure that we hit a 404
eq_(rv.status_code, 404)
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, u'404')
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '404')
eq_(s.meta.get(http.URL), u'http://localhost/404/üŋïĉóđē')
def test_404(self):
start = time.time()
rv = client.get(u'/404/üŋïĉóđē')
end = time.time()
# ensure that we hit a 404
eq_(rv.status_code, 404)
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, u'404')
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '404')
eq_(s.meta.get(http.URL), u'http://localhost/404/üŋïĉóđē')
def test_unicode(self):
start = time.time()
rv = client.get(u'/üŋïĉóđē')
end = time.time()
# ensure request worked
eq_(rv.status_code, 200)
eq_(rv.data, b'\xc3\xbc\xc5\x8b\xc3\xaf\xc4\x89\xc3\xb3\xc4\x91\xc4\x93')
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, u'üŋïĉóđē')
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '200')
eq_(s.meta.get(http.URL), u'http://localhost/üŋïĉóđē')
def taste():
# continue the trace
trace_id = request.headers.get("X-Datadog-Trace-Id")
parent_id = request.headers.get("X-Datadog-Parent-Id")
if trace_id and parent_id:
span = tracer.current_span()
span.trace_id = int(trace_id)
span.parent_id = int(parent_id)
beer = request.args.get("beer")
score = 10 if beer == 'stout' else random.randint(1, 10)
return jsonify(score=score)
def test_template_err(self):
start = time.time()
try:
client.get('/tmpl/err')
except Exception:
pass
else:
assert 0
end = time.time()
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 1)
by_name = {s.name:s for s in spans}
s = by_name["flask.request"]
eq_(s.service, service)
eq_(s.resource, "tmpl_err")
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 1)
eq_(s.meta.get(http.STATUS_CODE), '500')
def test_success(self):
start = time.time()
rv = client.get('/')
end = time.time()
# ensure request worked
eq_(rv.status_code, 200)
eq_(rv.data, b'hello')
# ensure trace worked
assert not tracer.current_span(), tracer.current_span().pprint()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, "index")
assert s.start >= start
assert s.duration <= end - start
eq_(s.error, 0)
eq_(s.meta.get(http.STATUS_CODE), '200')
services = writer.pop_services()
expected = {"app":"flask", "app_type":"web"}
eq_(services[service], expected)
def test_error(self):
start = time.time()
rv = client.get('/error')
end = time.time()
# ensure the request itself worked
eq_(rv.status_code, 500)
eq_(rv.data, b'error')
# ensure the request was traced.
assert not tracer.current_span()
spans = writer.pop()
eq_(len(spans), 1)
s = spans[0]
eq_(s.service, service)
eq_(s.resource, "error")
assert s.start >= start
assert s.duration <= end - start
eq_(s.meta.get(http.STATUS_CODE), '500')
