def test_buckets_list(self, mock_requests):
mock_requests.return_value = self._mock_response(
json_content={
"kind": "storage#buckets",
"items": []
},
status_code=http_client.OK)
client = self._client(project='test-project')
with tracer.start_active_span('test'):
buckets = client.list_buckets()
self.assertEqual(
0,
self.recorder.queue_size(),
msg='span has been created before the actual request')
# trigger the iterator
for b in buckets:
pass
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
self.assertIsNone(tracer.active_span)
gcs_span = spans[0]
test_span = spans[1]
self.assertTraceContextPropagated(test_span, gcs_span)
self.assertEqual('gcs', gcs_span.n)
self.assertEqual(2, gcs_span.k)
self.assertIsNone(gcs_span.ec)
self.assertEqual('buckets.list', gcs_span.data["gcs"]["op"])
self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"])
def test_successful_find_query(self):
with tracer.start_active_span("test"):
self.conn.test.records.find_one({"type": "string"})
assert_is_none(tracer.active_span)
spans = self.recorder.queued_spans()
self.assertEqual(len(spans), 2)
db_span = spans[0]
test_span = spans[1]
self.assertEqual(test_span.t, db_span.t)
self.assertEqual(db_span.p, test_span.s)
assert_is_none(db_span.ec)
self.assertEqual(db_span.n, "mongo")
self.assertEqual(db_span.data["mongo"]["service"], "%s:%s" % (testenv['mongodb_host'], testenv['mongodb_port']))
self.assertEqual(db_span.data["mongo"]["namespace"], "test.records")
self.assertEqual(db_span.data["mongo"]["command"], "find")
self.assertEqual(db_span.data["mongo"]["filter"], '{"type": "string"}')
assert_is_none(db_span.data["mongo"]["json"])
def test_server_exception(self):
response = None
with tracer.start_active_span('test'):
try:
response = self.client.service.server_exception()
except Exception:
pass
spans = self.recorder.queued_spans()
assert_equals(5, len(spans))
log_span1 = spans[0]
wsgi_span = spans[1]
log_span2 = spans[2]
soap_span = spans[3]
test_span = spans[4]
assert_equals(None, response)
assert_equals("test", test_span.data.sdk.name)
assert_equals(test_span.t, soap_span.t)
assert_equals(soap_span.p, test_span.s)
assert_equals(wsgi_span.t, soap_span.t)
assert_equals(wsgi_span.p, soap_span.s)
assert_equals(True, soap_span.error)
assert_equals(1, soap_span.ec)
assert ('logs' in soap_span.data.custom.__dict__)
assert_equals(1, len(soap_span.data.custom.logs.keys()))
tskey = list(soap_span.data.custom.logs.keys())[0]
assert ('message' in soap_span.data.custom.logs[tskey])
assert_equals(u"Server raised fault: 'Internal Error'",
soap_span.data.custom.logs[tskey]['message'])
assert_equals('server_exception', soap_span.data.soap.action)
assert_equals(testenv["soap_server"] + '/', soap_span.data.http.url)
def test_s3_upload_file_obj(s3):
object_name = 'aws_key_name'
bucket_name = 'aws_bucket_name'
s3.create_bucket(Bucket=bucket_name)
result = None
with tracer.start_active_span('test'):
with open(upload_filename, "rb") as fd:
s3.upload_fileobj(fd, bucket_name, object_name)
spans = tracer.recorder.queued_spans()
assert len(spans) == 2
filter = lambda span: span.n == "sdk"
test_span = get_first_span_by_filter(spans, filter)
assert (test_span)
filter = lambda span: span.n == "boto3"
boto_span = get_first_span_by_filter(spans, filter)
assert (boto_span)
assert (boto_span.t == test_span.t)
assert (boto_span.p == test_span.s)
assert (test_span.ec is None)
assert (boto_span.ec is None)
assert (boto_span.data['boto3']['op'] == 'upload_fileobj')
assert (boto_span.data['boto3']['ep'] == 'https://s3.amazonaws.com')
assert (boto_span.data['boto3']['reg'] == 'us-east-1')
payload = {'Bucket': 'aws_bucket_name', 'Key': 'aws_key_name'}
assert boto_span.data['boto3']['payload'] == payload
assert boto_span.data['http']['method'] == 'POST'
assert boto_span.data['http'][
'url'] == 'https://s3.amazonaws.com:443/upload_fileobj'
def test_basic_publish_with_headers(self, send_method, _unused):
self.obj._set_state(self.obj.OPEN)
with tracer.start_active_span("testing"):
self.obj.basic_publish(
"test.exchange", "test.queue", "Hello!",
pika.BasicProperties(headers={"X-Custom-1": "test"}))
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
rabbitmq_span = spans[0]
test_span = spans[1]
send_method.assert_called_once_with(
pika.spec.Basic.Publish(exchange="test.exchange",
routing_key="test.queue"),
(pika.spec.BasicProperties(
headers={
"X-Custom-1": "test",
"X-INSTANA-T": rabbitmq_span.t,
"X-INSTANA-S": rabbitmq_span.s,
"X-INSTANA-L": "1"
}), b"Hello!"))
def test_basic_query(self):
with tracer.start_active_span('test'):
self.cursor.execute("""SELECT * from users""")
self.cursor.fetchone()
self.db.commit()
spans = self.recorder.queued_spans()
assert_equals(2, len(spans))
db_span = spans[0]
test_span = spans[1]
assert_equals("test", test_span.data.sdk.name)
assert_equals(test_span.t, db_span.t)
assert_equals(db_span.p, test_span.s)
assert_equals(None, db_span.error)
assert_equals(None, db_span.ec)
assert_equals(db_span.n, "postgres")
assert_equals(db_span.data.pg.db, testenv['postgresql_db'])
assert_equals(db_span.data.pg.user, testenv['postgresql_user'])
assert_equals(db_span.data.pg.stmt, 'SELECT * from users')
assert_equals(db_span.data.pg.host, "%s:5432" % testenv['postgresql_host'])
def test_rget(self):
res = None
try:
with tracer.start_active_span('test'):
res = self.bucket.rget("test-key", replica_index=None)
except CouchbaseTransientError:
pass
self.assertIsNone(res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertEqual(cb_span.ec, 1)
# Just search for the substring of the exception class
found = cb_span.data["couchbase"]["error"].find(
"CouchbaseTransientError")
self.assertFalse(found == -1, "Error substring not found.")
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'rget')
def test_buckets_lock_retention_policy(self, mock_requests):
mock_requests.return_value = self._mock_response(
json_content={
"kind": "storage#bucket",
"metageneration": 1,
"retentionPolicy": {
"isLocked": False
}
},
status_code=http_client.OK)
client = self._client(project='test-project')
bucket = client.bucket('test bucket')
bucket.reload()
with tracer.start_active_span('test'):
bucket.lock_retention_policy()
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
self.assertIsNone(tracer.active_span)
gcs_span = spans[0]
test_span = spans[1]
self.assertTraceContextPropagated(test_span, gcs_span)
self.assertEqual('gcs', gcs_span.n)
self.assertEqual(2, gcs_span.k)
self.assertIsNone(gcs_span.ec)
self.assertEqual('buckets.lockRetentionPolicy',
gcs_span.data["gcs"]["op"])
self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"])
def test_execute_error(self):
res = None
try:
with tracer.start_active_span('test'):
res = session.execute('Not a real query')
except:
pass
self.assertIsNone(res)
time.sleep(0.5)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
self.assertIsNotNone(test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cspan = get_first_span_by_name(spans, 'cassandra')
self.assertIsNotNone(cspan)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cspan.t)
self.assertEqual(cspan.p, test_span.s)
self.assertIsNotNone(cspan.stack)
self.assertEqual(cspan.ec, 1)
self.assertEqual(cspan.data["cassandra"]["cluster"], 'Test Cluster')
self.assertEqual(cspan.data["cassandra"]["query"], 'Not a real query')
self.assertEqual(cspan.data["cassandra"]["keyspace"], 'instana_tests')
self.assertIsNone(cspan.data["cassandra"]["achievedConsistency"])
self.assertIsNotNone(cspan.data["cassandra"]["triedHosts"])
self.assertIsNotNone(cspan.data["cassandra"]["error"])
def test_n1ql_query(self):
res = None
with tracer.start_active_span('test'):
res = self.bucket.n1ql_query(
N1QLQuery(
'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"'
))
assert (res)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
test_span = get_first_span_by_name(spans, 'sdk')
assert (test_span)
self.assertEqual(test_span.data["sdk"]["name"], 'test')
cb_span = get_first_span_by_name(spans, 'couchbase')
assert (cb_span)
# Same traceId and parent relationship
self.assertEqual(test_span.t, cb_span.t)
self.assertEqual(cb_span.p, test_span.s)
assert (cb_span.stack)
self.assertIsNone(cb_span.ec)
self.assertEqual(cb_span.data["couchbase"]["hostname"],
"%s:8091" % testenv['couchdb_host'])
self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample')
self.assertEqual(cb_span.data["couchbase"]["type"], 'n1ql_query')
self.assertEqual(
cb_span.data["couchbase"]["sql"],
'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"'
)
def test_error_capture(self):
result = None
try:
with tracer.start_active_span('test'):
result = self.cursor.execute("""SELECT * from blah""")
self.cursor.fetchone()
except Exception:
pass
assert (result is None)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
db_span = spans[0]
test_span = spans[1]
self.assertEqual("test", test_span.data["sdk"]["name"])
self.assertEqual(test_span.t, db_span.t)
self.assertEqual(db_span.p, test_span.s)
self.assertEqual(1, db_span.ec)
self.assertEqual(
db_span.data["pg"]["error"],
'relation "blah" does not exist\nLINE 1: SELECT * from blah\n ^\n'
)
self.assertEqual(db_span.n, "postgres")
self.assertEqual(db_span.data["pg"]["db"], testenv['postgresql_db'])
self.assertEqual(db_span.data["pg"]["user"],
testenv['postgresql_user'])
self.assertEqual(db_span.data["pg"]["stmt"], 'SELECT * from blah')
self.assertEqual(db_span.data["pg"]["host"],
testenv['postgresql_host'])
self.assertEqual(db_span.data["pg"]["port"],
testenv['postgresql_port'])
def test_buckets_delete(self, mock_requests):
mock_requests.return_value = self._mock_response()
client = self._client(project='test-project')
with tracer.start_active_span('test'):
client.bucket('test bucket').delete()
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
self.assertIsNone(tracer.active_span)
gcs_span = spans[0]
test_span = spans[1]
self.assertTraceContextPropagated(test_span, gcs_span)
self.assertEqual('gcs', gcs_span.n)
self.assertEqual(2, gcs_span.k)
self.assertIsNone(gcs_span.ec)
self.assertEqual('buckets.delete', gcs_span.data["gcs"]["op"])
self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"])
def test_error_capture(self):
result = None
span = None
try:
with tracer.start_active_span('test'):
result = self.cursor.execute("""SELECT * from blah""")
self.cursor.fetchone()
except Exception:
pass
finally:
if span:
span.finish()
assert (result is None)
spans = self.recorder.queued_spans()
self.assertEqual(2, len(spans))
db_span = spans[0]
test_span = spans[1]
self.assertEqual("test", test_span.data["sdk"]["name"])
self.assertEqual(test_span.t, db_span.t)
self.assertEqual(db_span.p, test_span.s)
self.assertEqual(1, db_span.ec)
self.assertEqual(
db_span.data["mysql"]["error"],
'(1146, "Table \'%s.blah\' doesn\'t exist")' % testenv['mysql_db'])
self.assertEqual(db_span.n, "mysql")
self.assertEqual(db_span.data["mysql"]["db"], testenv['mysql_db'])
self.assertEqual(db_span.data["mysql"]["user"], testenv['mysql_user'])
self.assertEqual(db_span.data["mysql"]["stmt"], 'SELECT * from blah')
self.assertEqual(db_span.data["mysql"]["host"], testenv['mysql_host'])
self.assertEqual(db_span.data["mysql"]["port"], testenv['mysql_port'])
def test_streaming_many_to_many(self):
with tracer.start_active_span('test'):
responses = self.server_stub.ManyQuestionsManyReponses(
self.generate_questions())
self.assertIsNone(tracer.active_span)
self.assertIsNotNone(responses)
final_answers = []
for response in responses:
final_answers.append(response)
self.assertEqual(len(final_answers), 6)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
server_span = get_first_span_by_name(spans, 'rpc-server')
client_span = get_first_span_by_name(spans, 'rpc-client')
test_span = get_first_span_by_name(spans, 'sdk')
assert (server_span)
assert (client_span)
assert (test_span)
# Same traceId
self.assertEqual(server_span.t, client_span.t)
self.assertEqual(server_span.t, test_span.t)
# Parent relationships
self.assertEqual(server_span.p, client_span.s)
self.assertEqual(client_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(client_span.error)
self.assertIsNone(client_span.ec)
self.assertFalse(server_span.error)
self.assertIsNone(server_span.ec)
# rpc-server
self.assertEqual(server_span.n, 'rpc-server')
self.assertEqual(server_span.k, 1)
self.assertIsNotNone(server_span.stack)
self.assertEqual(2, len(server_span.stack))
self.assertEqual(server_span.data.rpc.flavor, 'grpc')
self.assertEqual(server_span.data.rpc.call,
'/stan.Stan/ManyQuestionsManyReponses')
self.assertEqual(server_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(server_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertIsNone(server_span.data.rpc.error)
# rpc-client
self.assertEqual(client_span.n, 'rpc-client')
self.assertEqual(client_span.k, 2)
self.assertIsNotNone(client_span.stack)
self.assertEqual(client_span.data.rpc.flavor, 'grpc')
self.assertEqual(client_span.data.rpc.call,
'/stan.Stan/ManyQuestionsManyReponses')
self.assertEqual(client_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(client_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertEqual(client_span.data.rpc.call_type, 'stream')
self.assertIsNone(client_span.data.rpc.error)
# test-span
self.assertEqual(test_span.n, 'sdk')
self.assertEqual(test_span.data.sdk.name, 'test')
def test_no_span(self):
with tracer.start_active_span('test'):
self.logger.info('info message')
spans = self.recorder.queued_spans()
self.assertEqual(1, len(spans))
def test_302_redirect(self):
with tracer.start_active_span('test'):
r = self.http.request('GET', 'http://127.0.0.1:5000/302')
spans = self.recorder.queued_spans()
self.assertEqual(5, len(spans))
wsgi_span2 = spans[0]
urllib3_span2 = spans[1]
wsgi_span1 = spans[2]
urllib3_span1 = spans[3]
test_span = spans[4]
assert (r)
self.assertEqual(200, r.status)
self.assertIsNone(tracer.active_span)
# Same traceId
traceId = test_span.t
self.assertEqual(traceId, urllib3_span1.t)
self.assertEqual(traceId, wsgi_span1.t)
self.assertEqual(traceId, urllib3_span2.t)
self.assertEqual(traceId, wsgi_span2.t)
# Parent relationships
self.assertEqual(urllib3_span1.p, test_span.s)
self.assertEqual(wsgi_span1.p, urllib3_span1.s)
self.assertEqual(urllib3_span2.p, test_span.s)
self.assertEqual(wsgi_span2.p, urllib3_span2.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(urllib3_span1.error)
self.assertIsNone(urllib3_span1.ec)
self.assertFalse(wsgi_span1.error)
self.assertIsNone(wsgi_span1.ec)
self.assertFalse(urllib3_span2.error)
self.assertIsNone(urllib3_span2.ec)
self.assertFalse(wsgi_span2.error)
self.assertIsNone(wsgi_span2.ec)
# wsgi
self.assertEqual("wsgi", wsgi_span1.n)
self.assertEqual('127.0.0.1:5000', wsgi_span1.data.http.host)
self.assertEqual('/', wsgi_span1.data.http.url)
self.assertEqual('GET', wsgi_span1.data.http.method)
self.assertEqual('200', wsgi_span1.data.http.status)
self.assertIsNone(wsgi_span1.data.http.error)
self.assertIsNotNone(wsgi_span1.stack)
self.assertEqual(2, len(wsgi_span1.stack))
self.assertEqual("wsgi", wsgi_span2.n)
self.assertEqual('127.0.0.1:5000', wsgi_span2.data.http.host)
self.assertEqual('/302', wsgi_span2.data.http.url)
self.assertEqual('GET', wsgi_span2.data.http.method)
self.assertEqual('302', wsgi_span2.data.http.status)
self.assertIsNone(wsgi_span2.data.http.error)
self.assertIsNotNone(wsgi_span2.stack)
self.assertEqual(2, len(wsgi_span2.stack))
# urllib3
self.assertEqual("test", test_span.data.sdk.name)
self.assertEqual("urllib3", urllib3_span1.n)
self.assertEqual(200, urllib3_span1.data.http.status)
self.assertEqual("http://127.0.0.1:5000/", urllib3_span1.data.http.url)
self.assertEqual("GET", urllib3_span1.data.http.method)
self.assertIsNotNone(urllib3_span1.stack)
self.assertTrue(type(urllib3_span1.stack) is list)
self.assertTrue(len(urllib3_span1.stack) > 1)
self.assertEqual("urllib3", urllib3_span2.n)
self.assertEqual(302, urllib3_span2.data.http.status)
self.assertEqual("http://127.0.0.1:5000/302",
urllib3_span2.data.http.url)
self.assertEqual("GET", urllib3_span2.data.http.method)
self.assertIsNotNone(urllib3_span2.stack)
self.assertTrue(type(urllib3_span2.stack) is list)
self.assertTrue(len(urllib3_span2.stack) > 1)
question="What did one campfire say to the other?"),
stan_pb2.QuestionRequest(question="Is cereal soup?"),
stan_pb2.QuestionRequest(
question="What is always coming, but never arrives?")
]
for q in questions:
yield q
time.sleep(random.uniform(0.2, 0.5))
channel = grpc.insecure_channel(testenv["grpc_server"])
server_stub = stan_pb2_grpc.StanStub(channel)
# The grpc client apparently needs a second to connect and initialize
time.sleep(1)
with tracer.start_active_span('http-server') as scope:
scope.span.set_tag('http.url', 'https://localhost:8080/grpc-client')
scope.span.set_tag('http.method', 'GET')
scope.span.set_tag('span.kind', 'entry')
response = server_stub.OneQuestionOneResponse(
stan_pb2.QuestionRequest(question="Are you there?"))
with tracer.start_active_span('http-server') as scope:
scope.span.set_tag('http.url',
'https://localhost:8080/grpc-server-streaming')
scope.span.set_tag('http.method', 'GET')
scope.span.set_tag('span.kind', 'entry')
responses = server_stub.OneQuestionManyResponses(
stan_pb2.QuestionRequest(question="Are you there?"))
with tracer.start_active_span('http-server') as scope:
def test_custom_header_capture(self):
# Hack together a manual custom headers list
agent.options.extra_http_headers = [
u'X-Capture-This', u'X-Capture-That'
]
request_headers = {}
request_headers['X-Capture-This'] = 'this'
request_headers['X-Capture-That'] = 'that'
with tracer.start_active_span('test'):
response = self.http.request('GET',
testenv["wsgi_server"] + '/',
headers=request_headers)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
self.assertIsNone(tracer.active_span)
wsgi_span = spans[0]
urllib3_span = spans[1]
test_span = spans[2]
assert response
self.assertEqual(200, response.status)
assert 'X-INSTANA-T' in response.headers
assert (int(response.headers['X-INSTANA-T'], 16))
self.assertEqual(response.headers['X-INSTANA-T'], wsgi_span.t)
assert 'X-INSTANA-S' in response.headers
assert (int(response.headers['X-INSTANA-S'], 16))
self.assertEqual(response.headers['X-INSTANA-S'], wsgi_span.s)
assert 'X-INSTANA-L' in response.headers
self.assertEqual(response.headers['X-INSTANA-L'], '1')
assert 'Server-Timing' in response.headers
server_timing_value = "intid;desc=%s" % wsgi_span.t
self.assertEqual(response.headers['Server-Timing'],
server_timing_value)
# Same traceId
self.assertEqual(test_span.t, urllib3_span.t)
self.assertEqual(urllib3_span.t, wsgi_span.t)
# Parent relationships
self.assertEqual(urllib3_span.p, test_span.s)
self.assertEqual(wsgi_span.p, urllib3_span.s)
# Error logging
self.assertIsNone(test_span.ec)
self.assertIsNone(urllib3_span.ec)
self.assertIsNone(wsgi_span.ec)
# wsgi
self.assertEqual("wsgi", wsgi_span.n)
self.assertEqual('127.0.0.1:' + str(testenv['wsgi_port']),
wsgi_span.data["http"]["host"])
self.assertEqual('/', wsgi_span.data["http"]["url"])
self.assertEqual('GET', wsgi_span.data["http"]["method"])
self.assertEqual(200, wsgi_span.data["http"]["status"])
self.assertIsNone(wsgi_span.data["http"]["error"])
self.assertIsNone(wsgi_span.stack)
assert "X-Capture-This" in wsgi_span.data["http"]["header"]
self.assertEqual("this",
wsgi_span.data["http"]["header"]["X-Capture-This"])
assert "X-Capture-That" in wsgi_span.data["http"]["header"]
self.assertEqual("that",
wsgi_span.data["http"]["header"]["X-Capture-That"])
def test_send_message(sqs):
response = None
# Create the Queue:
response = sqs.create_queue(QueueName='SQS_QUEUE_NAME',
Attributes={
'DelaySeconds': '60',
'MessageRetentionPeriod': '600'
})
assert response['QueueUrl']
queue_url = response['QueueUrl']
with tracer.start_active_span('test'):
response = sqs.send_message(
QueueUrl=queue_url,
DelaySeconds=10,
MessageAttributes={
'Website': {
'DataType': 'String',
'StringValue': 'https://www.instana.com'
},
},
MessageBody=('Monitor any application, service, or request '
'with Instana Application Performance Monitoring'))
assert response['MessageId']
spans = tracer.recorder.queued_spans()
assert len(spans) == 2
filter = lambda span: span.n == "sdk"
test_span = get_first_span_by_filter(spans, filter)
assert (test_span)
filter = lambda span: span.n == "boto3"
boto_span = get_first_span_by_filter(spans, filter)
assert (boto_span)
assert (boto_span.t == test_span.t)
assert (boto_span.p == test_span.s)
assert (test_span.ec is None)
assert (boto_span.ec is None)
assert boto_span.data['boto3']['op'] == 'SendMessage'
assert boto_span.data['boto3']['ep'] == 'https://queue.amazonaws.com'
assert boto_span.data['boto3']['reg'] == 'us-east-1'
payload = {
'QueueUrl':
'https://queue.amazonaws.com/123456789012/SQS_QUEUE_NAME',
'DelaySeconds':
10,
'MessageAttributes': {
'Website': {
'DataType': 'String',
'StringValue': 'https://www.instana.com'
}
},
'MessageBody':
'Monitor any application, service, or request with Instana Application Performance Monitoring'
}
assert boto_span.data['boto3']['payload'] == payload
assert boto_span.data['http']['status'] == 200
assert boto_span.data['http']['method'] == 'POST'
assert boto_span.data['http'][
'url'] == 'https://queue.amazonaws.com:443/SendMessage'
def test_complex_request(self):
with tracer.start_active_span('test'):
response = self.http.request('GET',
'http://127.0.0.1:5000/complex')
spans = self.recorder.queued_spans()
self.assertEqual(5, len(spans))
self.assertIsNone(tracer.active_span)
spacedust_span = spans[0]
asteroid_span = spans[1]
wsgi_span = spans[2]
urllib3_span = spans[3]
test_span = spans[4]
assert response
self.assertEqual(200, response.status)
assert ('X-Instana-T' in response.headers)
assert (int(response.headers['X-Instana-T'], 16))
self.assertEqual(response.headers['X-Instana-T'], wsgi_span.t)
assert ('X-Instana-S' in response.headers)
assert (int(response.headers['X-Instana-S'], 16))
self.assertEqual(response.headers['X-Instana-S'], wsgi_span.s)
assert ('X-Instana-L' in response.headers)
self.assertEqual(response.headers['X-Instana-L'], '1')
assert ('Server-Timing' in response.headers)
server_timing_value = "intid;desc=%s" % wsgi_span.t
self.assertEqual(response.headers['Server-Timing'],
server_timing_value)
# Same traceId
trace_id = test_span.t
self.assertEqual(trace_id, urllib3_span.t)
self.assertEqual(trace_id, wsgi_span.t)
self.assertEqual(trace_id, asteroid_span.t)
self.assertEqual(trace_id, spacedust_span.t)
# Parent relationships
self.assertEqual(urllib3_span.p, test_span.s)
self.assertEqual(wsgi_span.p, urllib3_span.s)
self.assertEqual(asteroid_span.p, wsgi_span.s)
self.assertEqual(spacedust_span.p, asteroid_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(urllib3_span.error)
self.assertIsNone(urllib3_span.ec)
self.assertFalse(wsgi_span.error)
self.assertIsNone(wsgi_span.ec)
self.assertFalse(asteroid_span.error)
self.assertIsNone(asteroid_span.ec)
self.assertFalse(spacedust_span.error)
self.assertIsNone(spacedust_span.ec)
# wsgi
self.assertEqual("wsgi", wsgi_span.n)
self.assertEqual('127.0.0.1:5000', wsgi_span.data.http.host)
self.assertEqual('/complex', wsgi_span.data.http.url)
self.assertEqual('GET', wsgi_span.data.http.method)
self.assertEqual('200', wsgi_span.data.http.status)
self.assertIsNone(wsgi_span.data.http.error)
self.assertIsNotNone(wsgi_span.stack)
self.assertEqual(2, len(wsgi_span.stack))
def launch_gevent_chain(self):
with tracer.start_active_span('test'):
gevent.spawn(self.spawn_calls).join()
def spawn_imap_unordered(self):
igroup = Group()
result = []
with tracer.start_active_span('test'):
for i in igroup.imap_unordered(self.make_http_call, range(3)):
result.append(i)
def test_complex_request(self):
with tracer.start_active_span('test'):
response = self.http.request('GET',
testenv["wsgi_server"] + '/complex')
spans = self.recorder.queued_spans()
self.assertEqual(5, len(spans))
self.assertIsNone(tracer.active_span)
spacedust_span = spans[0]
asteroid_span = spans[1]
wsgi_span = spans[2]
urllib3_span = spans[3]
test_span = spans[4]
assert response
self.assertEqual(200, response.status)
assert 'X-INSTANA-T' in response.headers
assert (int(response.headers['X-INSTANA-T'], 16))
self.assertEqual(response.headers['X-INSTANA-T'], wsgi_span.t)
assert 'X-INSTANA-S' in response.headers
assert (int(response.headers['X-INSTANA-S'], 16))
self.assertEqual(response.headers['X-INSTANA-S'], wsgi_span.s)
assert 'X-INSTANA-L' in response.headers
self.assertEqual(response.headers['X-INSTANA-L'], '1')
assert 'Server-Timing' in response.headers
server_timing_value = "intid;desc=%s" % wsgi_span.t
self.assertEqual(response.headers['Server-Timing'],
server_timing_value)
# Same traceId
trace_id = test_span.t
self.assertEqual(trace_id, urllib3_span.t)
self.assertEqual(trace_id, wsgi_span.t)
self.assertEqual(trace_id, asteroid_span.t)
self.assertEqual(trace_id, spacedust_span.t)
# Parent relationships
self.assertEqual(urllib3_span.p, test_span.s)
self.assertEqual(wsgi_span.p, urllib3_span.s)
self.assertEqual(asteroid_span.p, wsgi_span.s)
self.assertEqual(spacedust_span.p, asteroid_span.s)
# Error logging
self.assertIsNone(test_span.ec)
self.assertIsNone(urllib3_span.ec)
self.assertIsNone(wsgi_span.ec)
self.assertIsNone(asteroid_span.ec)
self.assertIsNone(spacedust_span.ec)
# wsgi
self.assertEqual("wsgi", wsgi_span.n)
self.assertEqual('127.0.0.1:' + str(testenv['wsgi_port']),
wsgi_span.data["http"]["host"])
self.assertEqual('/complex', wsgi_span.data["http"]["url"])
self.assertEqual('GET', wsgi_span.data["http"]["method"])
self.assertEqual(200, wsgi_span.data["http"]["status"])
self.assertIsNone(wsgi_span.data["http"]["error"])
self.assertIsNone(wsgi_span.stack)
def test_streaming_many_to_one_with_call(self):
with tracer.start_active_span('test'):
response = self.server_stub.ManyQuestionsOneResponse.with_call(
self.generate_questions())
self.assertIsNone(tracer.active_span)
self.assertIsNotNone(response)
self.assertEqual('Ok', response[0].answer)
self.assertEqual(True, response[0].was_answered)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
server_span = get_first_span_by_name(spans, 'rpc-server')
client_span = get_first_span_by_name(spans, 'rpc-client')
test_span = get_first_span_by_name(spans, 'sdk')
assert (server_span)
assert (client_span)
assert (test_span)
# Same traceId
self.assertEqual(server_span.t, client_span.t)
self.assertEqual(server_span.t, test_span.t)
# Parent relationships
self.assertEqual(server_span.p, client_span.s)
self.assertEqual(client_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(client_span.error)
self.assertIsNone(client_span.ec)
self.assertFalse(server_span.error)
self.assertIsNone(server_span.ec)
# rpc-server
self.assertEqual(server_span.n, 'rpc-server')
self.assertEqual(server_span.k, 1)
self.assertIsNotNone(server_span.stack)
self.assertEqual(2, len(server_span.stack))
self.assertEqual(server_span.data.rpc.flavor, 'grpc')
self.assertEqual(server_span.data.rpc.call,
'/stan.Stan/ManyQuestionsOneResponse')
self.assertEqual(server_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(server_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertIsNone(server_span.data.rpc.error)
# rpc-client
self.assertEqual(client_span.n, 'rpc-client')
self.assertEqual(client_span.k, 2)
self.assertIsNotNone(client_span.stack)
self.assertEqual(client_span.data.rpc.flavor, 'grpc')
self.assertEqual(client_span.data.rpc.call,
'/stan.Stan/ManyQuestionsOneResponse')
self.assertEqual(client_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(client_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertEqual(client_span.data.rpc.call_type, 'stream')
self.assertIsNone(client_span.data.rpc.error)
# test-span
self.assertEqual(test_span.n, 'sdk')
self.assertEqual(test_span.data.sdk.name, 'test')
def test_set_get(self):
result = None
with tracer.start_active_span('test'):
self.strict_redis.set('foox', 'barX')
self.strict_redis.set('fooy', 'barY')
result = self.strict_redis.get('foox')
spans = self.recorder.queued_spans()
self.assertEqual(4, len(spans))
self.assertEqual(b'barX', result)
rs1_span = spans[0]
rs2_span = spans[1]
rs3_span = spans[2]
test_span = spans[3]
self.assertIsNone(tracer.active_span)
# Same traceId
self.assertEqual(test_span.t, rs1_span.t)
self.assertEqual(test_span.t, rs2_span.t)
self.assertEqual(test_span.t, rs3_span.t)
# Parent relationships
self.assertEqual(rs1_span.p, test_span.s)
self.assertEqual(rs2_span.p, test_span.s)
self.assertEqual(rs3_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(rs1_span.error)
self.assertIsNone(rs1_span.ec)
self.assertFalse(rs2_span.error)
self.assertIsNone(rs2_span.ec)
self.assertFalse(rs3_span.error)
self.assertIsNone(rs3_span.ec)
# Redis span 1
self.assertEqual('redis', rs1_span.n)
self.assertFalse('custom' in rs1_span.data.__dict__)
self.assertTrue('redis' in rs1_span.data.__dict__)
self.assertEqual('redis-py', rs1_span.data.redis.driver)
self.assertEqual("redis://%s/0" % testenv['redis_url'],
rs1_span.data.redis.connection)
self.assertEqual("SET", rs1_span.data.redis.command)
self.assertIsNone(rs1_span.data.redis.error)
self.assertIsNotNone(rs1_span.stack)
self.assertTrue(type(rs1_span.stack) is list)
self.assertGreater(len(rs1_span.stack), 0)
# Redis span 2
self.assertEqual('redis', rs2_span.n)
self.assertFalse('custom' in rs2_span.data.__dict__)
self.assertTrue('redis' in rs2_span.data.__dict__)
self.assertEqual('redis-py', rs2_span.data.redis.driver)
self.assertEqual("redis://%s/0" % testenv['redis_url'],
rs2_span.data.redis.connection)
self.assertEqual("SET", rs2_span.data.redis.command)
self.assertIsNone(rs2_span.data.redis.error)
self.assertIsNotNone(rs2_span.stack)
self.assertTrue(type(rs2_span.stack) is list)
self.assertGreater(len(rs2_span.stack), 0)
# Redis span 3
self.assertEqual('redis', rs3_span.n)
self.assertFalse('custom' in rs3_span.data.__dict__)
self.assertTrue('redis' in rs3_span.data.__dict__)
self.assertEqual('redis-py', rs3_span.data.redis.driver)
self.assertEqual("redis://%s/0" % testenv['redis_url'],
rs3_span.data.redis.connection)
self.assertEqual("GET", rs3_span.data.redis.command)
self.assertIsNone(rs3_span.data.redis.error)
self.assertIsNotNone(rs3_span.stack)
self.assertTrue(type(rs3_span.stack) is list)
self.assertGreater(len(rs3_span.stack), 0)
def test_async_stream(self):
def process_response(future):
result = future.result()
self.assertEqual(type(result), stan_pb2.QuestionResponse)
self.assertTrue(result.was_answered)
self.assertEqual(result.answer, 'Ok')
with tracer.start_active_span('test'):
future = self.server_stub.ManyQuestionsOneResponse.future(
self.generate_questions())
future.add_done_callback(process_response)
# The question generator delays at random intervals between questions so to assure that
# all questions are sent and processed before we start testing the results.
time.sleep(5)
self.assertIsNone(tracer.active_span)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
server_span = get_first_span_by_name(spans, 'rpc-server')
client_span = get_first_span_by_name(spans, 'rpc-client')
test_span = get_first_span_by_name(spans, 'sdk')
assert (server_span)
assert (client_span)
assert (test_span)
# Same traceId
self.assertEqual(server_span.t, client_span.t)
self.assertEqual(server_span.t, test_span.t)
# Parent relationships
self.assertEqual(server_span.p, client_span.s)
self.assertEqual(client_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(client_span.error)
self.assertIsNone(client_span.ec)
self.assertFalse(server_span.error)
self.assertIsNone(server_span.ec)
# rpc-server
self.assertEqual(server_span.n, 'rpc-server')
self.assertEqual(server_span.k, 1)
self.assertIsNotNone(server_span.stack)
self.assertEqual(2, len(server_span.stack))
self.assertEqual(server_span.data.rpc.flavor, 'grpc')
self.assertEqual(server_span.data.rpc.call,
'/stan.Stan/ManyQuestionsOneResponse')
self.assertEqual(server_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(server_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertIsNone(server_span.data.rpc.error)
# rpc-client
self.assertEqual(client_span.n, 'rpc-client')
self.assertEqual(client_span.k, 2)
self.assertIsNotNone(client_span.stack)
self.assertEqual(client_span.data.rpc.flavor, 'grpc')
self.assertEqual(client_span.data.rpc.call,
'/stan.Stan/ManyQuestionsOneResponse')
self.assertEqual(client_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(client_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertEqual(client_span.data.rpc.call_type, 'stream')
self.assertIsNone(client_span.data.rpc.error)
# test-span
self.assertEqual(test_span.n, 'sdk')
self.assertEqual(test_span.data.sdk.name, 'test')
def test_exception_logging(self):
with tracer.start_active_span('test'):
try:
r = self.http.request('GET', 'http://127.0.0.1:5000/exception')
except Exception:
pass
spans = self.recorder.queued_spans()
self.assertEqual(4, len(spans))
log_span = spans[0]
wsgi_span = spans[1]
urllib3_span = spans[2]
test_span = spans[3]
assert (r)
self.assertEqual(500, r.status)
self.assertIsNone(tracer.active_span)
# Same traceId
traceId = test_span.t
self.assertEqual(traceId, urllib3_span.t)
self.assertEqual(traceId, wsgi_span.t)
self.assertEqual(traceId, log_span.t)
# Parent relationships
self.assertEqual(urllib3_span.p, test_span.s)
self.assertEqual(wsgi_span.p, urllib3_span.s)
self.assertEqual(log_span.p, wsgi_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertTrue(urllib3_span.error)
self.assertEqual(1, urllib3_span.ec)
self.assertTrue(wsgi_span.error)
self.assertEqual(1, wsgi_span.ec)
# log span
self.assertEqual('log', log_span.n)
self.assertEqual(3, log_span.k)
self.assertTrue(type(log_span.stack) is list)
self.assertTrue('log' in log_span.data.__dict__)
self.assertTrue('message' in log_span.data.log)
# wsgi
self.assertEqual("wsgi", wsgi_span.n)
self.assertEqual('127.0.0.1:5000', wsgi_span.data.http.host)
self.assertEqual('/exception', wsgi_span.data.http.url)
self.assertEqual('GET', wsgi_span.data.http.method)
self.assertEqual('500', wsgi_span.data.http.status)
self.assertIsNone(wsgi_span.data.http.error)
self.assertIsNotNone(wsgi_span.stack)
self.assertEqual(2, len(wsgi_span.stack))
# urllib3
self.assertEqual("test", test_span.data.sdk.name)
self.assertEqual("urllib3", urllib3_span.n)
self.assertEqual(500, urllib3_span.data.http.status)
self.assertEqual("http://127.0.0.1:5000/exception",
urllib3_span.data.http.url)
self.assertEqual("GET", urllib3_span.data.http.method)
self.assertIsNotNone(urllib3_span.stack)
self.assertTrue(type(urllib3_span.stack) is list)
self.assertTrue(len(urllib3_span.stack) > 1)
def test_unary_one_to_one(self):
with tracer.start_active_span('test'):
response = self.server_stub.OneQuestionOneResponse(
stan_pb2.QuestionRequest(question="Are you there?"))
self.assertIsNone(tracer.active_span)
self.assertIsNotNone(response)
self.assertEqual(
response.answer,
"Invention, my dear friends, is 93% perspiration, 6% electricity, 4% evaporation, and 2% butterscotch ripple. – Willy Wonka"
)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
server_span = get_first_span_by_name(spans, 'rpc-server')
client_span = get_first_span_by_name(spans, 'rpc-client')
test_span = get_first_span_by_name(spans, 'sdk')
assert (server_span)
assert (client_span)
assert (test_span)
# Same traceId
self.assertEqual(server_span.t, client_span.t)
self.assertEqual(server_span.t, test_span.t)
# Parent relationships
self.assertEqual(server_span.p, client_span.s)
self.assertEqual(client_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(client_span.error)
self.assertIsNone(client_span.ec)
self.assertFalse(server_span.error)
self.assertIsNone(server_span.ec)
# rpc-server
self.assertEqual(server_span.n, 'rpc-server')
self.assertEqual(server_span.k, 1)
self.assertIsNotNone(server_span.stack)
self.assertEqual(2, len(server_span.stack))
self.assertEqual(server_span.data.rpc.flavor, 'grpc')
self.assertEqual(server_span.data.rpc.call,
'/stan.Stan/OneQuestionOneResponse')
self.assertEqual(server_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(server_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertIsNone(server_span.data.rpc.error)
# rpc-client
self.assertEqual(client_span.n, 'rpc-client')
self.assertEqual(client_span.k, 2)
self.assertIsNotNone(client_span.stack)
self.assertEqual(client_span.data.rpc.flavor, 'grpc')
self.assertEqual(client_span.data.rpc.call,
'/stan.Stan/OneQuestionOneResponse')
self.assertEqual(client_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(client_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertEqual(client_span.data.rpc.call_type, 'unary')
self.assertIsNone(client_span.data.rpc.error)
# test-span
self.assertEqual(test_span.n, 'sdk')
self.assertEqual(test_span.data.sdk.name, 'test')
def test_custom_header_capture(self):
# Hack together a manual custom headers list
agent.extra_headers = [u'X-Capture-This', u'X-Capture-That']
request_headers = {}
request_headers['X-Capture-This'] = 'this'
request_headers['X-Capture-That'] = 'that'
with tracer.start_active_span('test'):
response = self.http.request('GET',
'http://127.0.0.1:5000/',
headers=request_headers)
spans = self.recorder.queued_spans()
self.assertEqual(3, len(spans))
self.assertIsNone(tracer.active_span)
wsgi_span = spans[0]
urllib3_span = spans[1]
test_span = spans[2]
assert (response)
self.assertEqual(200, response.status)
# Same traceId
self.assertEqual(test_span.t, urllib3_span.t)
self.assertEqual(urllib3_span.t, wsgi_span.t)
# Parent relationships
self.assertEqual(urllib3_span.p, test_span.s)
self.assertEqual(wsgi_span.p, urllib3_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertFalse(urllib3_span.error)
self.assertIsNone(urllib3_span.ec)
self.assertFalse(wsgi_span.error)
self.assertIsNone(wsgi_span.ec)
# wsgi
self.assertEqual("wsgi", wsgi_span.n)
self.assertEqual('127.0.0.1:5000', wsgi_span.data.http.host)
self.assertEqual('/', wsgi_span.data.http.url)
self.assertEqual('GET', wsgi_span.data.http.method)
self.assertEqual('200', wsgi_span.data.http.status)
self.assertIsNone(wsgi_span.data.http.error)
self.assertIsNotNone(wsgi_span.stack)
self.assertEqual(2, len(wsgi_span.stack))
self.assertEqual(
True, "http.X-Capture-This"
in wsgi_span.data.custom.__dict__['tags'])
self.assertEqual(
"this",
wsgi_span.data.custom.__dict__['tags']["http.X-Capture-This"])
self.assertEqual(
True, "http.X-Capture-That"
in wsgi_span.data.custom.__dict__['tags'])
self.assertEqual(
"that",
wsgi_span.data.custom.__dict__['tags']["http.X-Capture-That"])
def test_server_error(self):
try:
response = None
with tracer.start_active_span('test'):
response = self.server_stub.OneQuestionOneErrorResponse(
stan_pb2.QuestionRequest(question="Do u error?"))
except:
pass
self.assertIsNone(tracer.active_span)
self.assertIsNone(response)
spans = self.recorder.queued_spans()
self.assertEqual(4, len(spans))
log_span = get_first_span_by_name(spans, 'log')
server_span = get_first_span_by_name(spans, 'rpc-server')
client_span = get_first_span_by_name(spans, 'rpc-client')
test_span = get_first_span_by_name(spans, 'sdk')
assert (log_span)
assert (server_span)
assert (client_span)
assert (test_span)
# Same traceId
self.assertEqual(server_span.t, client_span.t)
self.assertEqual(server_span.t, test_span.t)
# Parent relationships
self.assertEqual(server_span.p, client_span.s)
self.assertEqual(client_span.p, test_span.s)
# Error logging
self.assertFalse(test_span.error)
self.assertIsNone(test_span.ec)
self.assertTrue(client_span.error)
self.assertEqual(client_span.ec, 1)
self.assertFalse(server_span.error)
self.assertIsNone(server_span.ec)
# rpc-server
self.assertEqual(server_span.n, 'rpc-server')
self.assertEqual(server_span.k, 1)
self.assertIsNotNone(server_span.stack)
self.assertEqual(2, len(server_span.stack))
self.assertEqual(server_span.data.rpc.flavor, 'grpc')
self.assertEqual(server_span.data.rpc.call,
'/stan.Stan/OneQuestionOneErrorResponse')
self.assertEqual(server_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(server_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertIsNone(server_span.data.rpc.error)
# rpc-client
self.assertEqual(client_span.n, 'rpc-client')
self.assertEqual(client_span.k, 2)
self.assertIsNotNone(client_span.stack)
self.assertEqual(client_span.data.rpc.flavor, 'grpc')
self.assertEqual(client_span.data.rpc.call,
'/stan.Stan/OneQuestionOneErrorResponse')
self.assertEqual(client_span.data.rpc.host, testenv["grpc_host"])
self.assertEqual(client_span.data.rpc.port, str(testenv["grpc_port"]))
self.assertEqual(client_span.data.rpc.call_type, 'unary')
self.assertIsNotNone(client_span.data.rpc.error)
# log
self.assertEqual(log_span.n, 'log')
self.assertIsNotNone(log_span.data.log)
self.assertEqual(log_span.data.log['message'],
'Exception calling application: Simulated error')
# test-span
self.assertEqual(test_span.n, 'sdk')
self.assertEqual(test_span.data.sdk.name, 'test')
