def test_trace_requests_span_extractor(monkeypatch):
resp = Response()
resp.status_code = 200
resp.url = "http://example.com/"
recorder = Recorder()
t = BasicTracer(recorder=recorder)
t.register_required_propagators()
opentracing.tracer = t
top_span = opentracing.tracer.start_span(operation_name='top_span')
def span_extractor(*args, **kwargs):
return top_span
trace_requests(span_extractor=span_extractor)
monkeypatch.setattr(
'opentracing_utils.libs._requests.__requests_http_send',
assert_send_request_mock(resp))
# disable getting the span from stack
monkeypatch.setattr('opentracing_utils.span.inspect_span_from_stack',
lambda: None)
response = requests.get("http://example.com/")
top_span.finish()
assert len(recorder.spans) == 2
assert recorder.spans[0].context.trace_id == top_span.context.trace_id
assert recorder.spans[0].parent_id == recorder.spans[1].context.span_id
assert recorder.spans[0].operation_name == 'http_send_get'
assert recorder.spans[-1].operation_name == 'top_span'
assert response.status_code == resp.status_code
def test_trace_requests_no_error_tag(monkeypatch):
resp = Response()
resp.status_code = 400
resp.url = URL
trace_requests(set_error_tag=False)
monkeypatch.setattr('opentracing_utils.libs._requests.__requests_http_send', assert_send_request_mock(resp))
recorder = Recorder()
t = BasicTracer(recorder=recorder)
t.register_required_propagators()
opentracing.tracer = t
top_span = opentracing.tracer.start_span(operation_name='top_span')
with top_span:
response = requests.get(URL, headers={CUSTOM_HEADER: CUSTOM_HEADER_VALUE})
assert len(recorder.spans) == 2
assert recorder.spans[0].context.trace_id == top_span.context.trace_id
assert recorder.spans[0].parent_id == recorder.spans[-1].context.span_id
assert response.status_code == resp.status_code
assert recorder.spans[0].tags[tags.HTTP_STATUS_CODE] == resp.status_code
assert recorder.spans[0].tags[tags.HTTP_URL] == URL
assert recorder.spans[0].tags[tags.HTTP_METHOD] == 'GET'
assert recorder.spans[0].tags[tags.SPAN_KIND] == tags.SPAN_KIND_RPC_CLIENT
assert recorder.spans[0].tags[tags.PEER_HOSTNAME] == 'example.com'
assert recorder.spans[0].tags['timeout'] is None
assert recorder.spans[0].tags[tags.COMPONENT] == 'requests'
assert recorder.spans[0].operation_name == '{}_get'.format(OPERATION_NAME_PREFIX)
assert 'error' not in recorder.spans[0].tags
def test_trace_requests_with_ignore_url_pattern_prune_kwargs(monkeypatch):
""" In case there is a parent span already, the ignore url pattern must
still be respected """
resp = Response()
resp.status_code = 200
resp.url = URL
trace_requests(ignore_url_patterns=[r".*{}.*".format(URL)])
monkeypatch.setattr('opentracing_utils.libs._requests.__requests_http_send',
assert_send_request_mock_no_traces(resp))
@trace()
def f1():
pass
recorder = Recorder()
t = BasicTracer(recorder=recorder)
t.register_required_propagators()
opentracing.tracer = t
top_span = opentracing.tracer.start_span(operation_name='top_span')
with top_span:
response = requests.get(URL, headers={CUSTOM_HEADER: CUSTOM_HEADER_VALUE})
f1()
# Top span, and @trace for f1() create spans. With the ignore pattern
# in place, the call to requests.get should not add a span
assert len(recorder.spans) == 2
assert recorder.spans[0].context.trace_id == top_span.context.trace_id
assert recorder.spans[0].operation_name == 'f1'
assert recorder.spans[1].operation_name == 'top_span'
assert response.status_code == resp.status_code
def test_trace_requests_do_not_ignore_if_no_match(monkeypatch):
resp = Response()
resp.status_code = 200
resp.url = URL
trace_requests(ignore_url_patterns=[r".*{}.*".format(URL)])
monkeypatch.setattr('opentracing_utils.libs._requests.__requests_http_send', assert_send_request_mock(resp))
response = requests.get("http://I-do-not-match.com", headers={CUSTOM_HEADER: CUSTOM_HEADER_VALUE})
assert response.status_code == resp.status_code
def test_trace_requests_with_tags(monkeypatch):
resp = Response()
resp.status_code = 200
resp.url = URL
trace_requests(default_tags={'tag1': 'value1'})
monkeypatch.setattr('opentracing_utils.libs._requests.__requests_http_send', assert_send_request_mock(resp))
@trace()
def f1():
pass
recorder = Recorder()
t = BasicTracer(recorder=recorder)
t.register_required_propagators()
opentracing.tracer = t
top_span = opentracing.tracer.start_span(operation_name='top_span')
with top_span:
response = requests.get(URL, headers={CUSTOM_HEADER: CUSTOM_HEADER_VALUE})
f1()
assert len(recorder.spans) == 3
assert recorder.spans[0].context.trace_id == top_span.context.trace_id
assert recorder.spans[0].parent_id == recorder.spans[-1].context.span_id
assert recorder.spans[-1].operation_name == 'top_span'
# ``requests`` default tags do not leak to other unrelated spans!
assert recorder.spans[1].tags == {}
assert recorder.spans[1].operation_name == 'f1'
assert response.status_code == resp.status_code
assert recorder.spans[0].tags[tags.HTTP_STATUS_CODE] == resp.status_code
assert recorder.spans[0].tags[tags.HTTP_URL] == URL
assert recorder.spans[0].tags[tags.HTTP_METHOD] == 'GET'
assert recorder.spans[0].tags[tags.SPAN_KIND] == tags.SPAN_KIND_RPC_CLIENT
assert recorder.spans[0].tags[tags.PEER_HOSTNAME] == 'example.com'
assert recorder.spans[0].tags['timeout'] is None
assert recorder.spans[0].tags[tags.COMPONENT] == 'requests'
assert recorder.spans[0].operation_name == '{}_get'.format(OPERATION_NAME_PREFIX)
assert recorder.spans[0].tags['tag1'] == 'value1'
def test_trace_requests_with_use_scope_manager(monkeypatch):
resp = Response()
resp.status_code = 200
resp.url = URL
recorder = Recorder()
t = BasicTracer(recorder=recorder)
t.register_required_propagators()
opentracing.tracer = t
trace_requests(use_scope_manager=True)
monkeypatch.setattr(
'opentracing_utils.libs._requests.__requests_http_send',
assert_send_request_mock_scope_active(resp)
)
response = requests.get(URL, headers={CUSTOM_HEADER: CUSTOM_HEADER_VALUE})
assert response.status_code == resp.status_code
assert len(recorder.spans) == 1
from opentracing_utils import trace_requests
trace_requests() # noqa
import os
import sys
import time
import argparse
import logging
import json
import traceback
import requests
import tokens
import opentracing
from zmon_cli.client import Zmon, compare_entities
from opentracing_utils import init_opentracing_tracer, trace, extract_span_from_kwargs
# TODO: Load dynamically
from zmon_agent.discovery.kubernetes import get_discovery_agent_class
BUILTIN_DISCOVERY = ('kubernetes', )
AGENT_TYPE = 'zmon-agent'
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s')
logger = logging.getLogger(__name__)
logger.addHandler(logging.StreamHandler(stream=sys.stdout))
logger.setLevel(logging.INFO)
class GbcMachineLearningService(Resource):
from api import api
logger = loggerElk(__name__, True)
nlp = None
machineLearningService = api.model('MachineLearningService', {
'source': fields.String(required=True, description='Source of the data (PLAINTEXT | FILE | IMAGE | S3)'),
'data': fields.String(required=True, description='Repo resource identifier (url)'),
'domain': fields.String(required=True, description='Repo resource identifier (domain name)'),
'model': fields.String(required=True, description='Source of classifier '
'(BAGGING | BOOSTING_ADA | BOOSTING_SGD '
'| DECISION_TREE | EXTRA_TREES | NAIVE_BAYES_MULTI '
'| NAIVE_BAYES_COMPLEMENT | RANDOM_FOREST | VOTING '
'| CNN_NETWORK)'),
'lang': fields.String(required=True, description='Language (es, en)'),
})
def __init__(self, *args, **kwargs):
# start - JAEGER
config = Config(config={'sampler': {'type': 'const', 'param': 1},
'logging': True
},
service_name=__name__)
config.initialize_tracer()
super().__init__(*args, **kwargs)
trace_requests() # noqa
# end - JAEGER
@api.doc(
description='Machine Learning Service',
responses={
200: 'OK',
400: 'Invalid Argument',
500: 'Internal Error'})
@api.expect(machineLearningService)
def post(self):
root_span = None
try:
self.logger.Information('GbcMachineLearningService::POST - init')
# start - JAEGER
root_span = opentracing.tracer.start_span(operation_name=inspect.currentframe().f_code.co_name)
# end - JAEGER
request_payload = request.get_json()
# self.logger.LogInput('GbcMachineLearningService::POST: ', request_payload)
source = request_payload['source']
data = request_payload['data']
domain = request_payload['domain']
model = request_payload['model']
lang = request_payload['lang']
if source == 'PLAINTEXT':
response = 'PLAINTEXT'
elif source == 'FILE':
response = 'FILE'
elif source == 'IMAGE':
response = 'IMAGE'
elif source == 'S3':
s3 = self.getS3Session()
return {'result': 'not implemented'}
else:
response = ''
raise Exception('No valid source provided')
res = {
'result': 'ok',
'response': response
}
return jsonify(res)
except Exception as e:
self.logger.Error('ERROR - GbcMachineLearningService::POST' + str(e.args), sys.exc_info())
return {'message': 'Something went wrong: ' + str(e)}, 500
finally:
root_span.finish()
class Student(object):
def __init__(self, first_name: str, last_name: str):
self.first_name = first_name
self.last_name = last_name
@classmethod
def getS3Session(cls):
session = boto3.Session(
aws_access_key_id=os.environ['ENV_ACCESS_KEY_ID'],
aws_secret_access_key=os.environ['ENV_SECRET_ACCESS_KEY']
)
s3 = session.client(u's3')
return s3
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import argparse
import logging
import json
from opentracing_utils import init_opentracing_tracer, trace_requests, trace, extract_span_from_kwargs
from zmon_aws_agent import elastigroup
trace_requests() # noqa
import opentracing
import requests
import tokens
import os
import traceback
from zmon_cli.client import Zmon, compare_entities
import zmon_aws_agent.aws as aws
import zmon_aws_agent.postgresql as postgresql
from zmon_aws_agent.common import get_user_agent
logging.getLogger('urllib3.connectionpool').setLevel(logging.WARN)
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARN)
logging.getLogger('botocore.vendored.requests.packages').setLevel(logging.WARN)
