def test_run(): logger = setup_custom_logger(__name__) os.environ['_HANDLER'] = 'test_lambda.example_lambda' agent = Agent() agent.instrument(None) memory_exporter = configure_inmemory_span_exporter(agent) logger.info('Running test calls.') lamb = boto.awslambda.connect_to_region("us-east-2") # multiple calls try: lamb.list_functions() except: pass spans = memory_exporter.get_finished_spans() assert spans assert len(spans) == 1 span = spans[0] assert span.attributes['endpoint'] == 'lambda' assert span.attributes['http.method'] == 'GET' assert span.attributes['aws.region'] == 'us-east-2' assert span.attributes['aws.operation'] == 'list_functions' memory_exporter.clear()
def test_run(agent_with_filter, exporter): logger = setup_custom_logger(__name__) app = Flask(__name__) @app.route("/route1") def api_1(): logger.info('Serving request for /route1.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response agent_with_filter.instrument(app) server = FlaskServer(app) logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get('http://localhost:5000/route1', headers={'tester1': 'tester1', 'tester2': 'tester2'}) assert r1.status_code == 403 span_list = exporter.get_finished_spans() assert span_list assert len(span_list) == 1 flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes']['http.status_code'] == 403
def test_run(agent, exporter): logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route1") def api_1(): logger.info('Serving request for /route1.') return send_file("./app.py") @app.route("/unicode") def api_2(): response = flask.Response(mimetype='application/x-www-form-urlencoded') response.data = b'\x80abc' return response agent.instrument(app) logger.info('Agent initialized.') logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get('http://localhost:5000/route1', headers={'tester1': 'tester1', 'tester2': 'tester2'}) assert r1.status_code == 200 span_list = exporter.get_finished_spans() assert span_list assert len(span_list) == 1 flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 body_message = "" try: body_message = flaskSpanAsObject['attributes']['http.response.body'] except KeyError: body_message = "key does not exist" print("key does not exist") assert body_message == "key does not exist" exporter.clear() r2 = app.test_client().get('http://localhost:5000/unicode') assert r2.status_code == 200 span_list = exporter.get_finished_spans() assert span_list assert len(span_list) == 1 flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/unicode' assert flaskSpanAsObject['attributes']['http.response.body'] == "\\x80abc"
def test_run(agent, exporter): logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route1") def api_1(): logger.info('Serving request for /route1.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response @app.route("/route2") def api_2(): logger.info('Serving request for /route2.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response agent.instrument(app) server = FlaskServer(app) server.start() logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get('http://localhost:5000/route1', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) logger.info('Making test call to /route2') r2 = app.test_client().get('http://localhost:5000/route2', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) logger.info('Reading /route1 response.') a1 = r1.get_json()['a'] logger.info('Reading /route2 response.') a2 = r2.get_json()['a'] assert a1 == 'a' assert a2 == 'a' logger.info('r1 result: ' + str(a1)) logger.info('r2 result: ' + str(a2)) logger.info('Exiting from flask instrumentation test.') server.shutdown()
def test_run(agent, exporter): logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route1") def testAPI1(): logger.info('Serving request for /route1.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response agent.instrument(app) server = FlaskServer(app) server.start() logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get('http://localhost:5000/route1', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Get all of the in memory spans that were recorded for this iteration span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester1'] == 'tester1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester2'] == 'tester2' assert flaskSpanAsObject['attributes'][ 'http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['attributes'][ 'http.response.header.tester3'] == 'tester3' exporter.clear() server.shutdown()
def test_run(): logger = setup_custom_logger(__name__) agent = Agent() agent.instrument(None) # Setup In-Memory Span Exporter logger.info('Agent initialized.') logger.info('Adding in-memory span exporter.') memoryExporter = InMemorySpanExporter() simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter) agent.register_processor(simpleExportSpanProcessor) logger.info('Added in-memory span exporter') logger.info('Running test calls.') try: session = botocore.session.get_session() session.set_credentials(access_key="access-key", secret_key="secret-key") region = "us-west-2" client = session.create_client("lambda", region_name=region) iam_client = session.create_client("iam", region_name=region) arn = _create_role_and_get_arn(iam_client) result = _create_lambda_function('some_function', return_headers_lambda_str(), client, arn) memoryExporter.clear() response = client.invoke( Payload=json.dumps({}), FunctionName=result['FunctionArn'], InvocationType="RequestResponse", ) spans = memoryExporter.get_finished_spans() invoke_span = spans[-1] assert invoke_span.attributes['faas.invoked_name'] == 'some_function' assert invoke_span.attributes['http.status_code'] == 200 assert invoke_span.attributes['rpc.service'] == 'Lambda' memoryExporter.clear() return 0 except: logger.error( 'Failed to test boto instrumentation wrapper: exception=%s, stacktrace=%s', sys.exc_info()[0], traceback.format_exc()) raise sys.exc_info()[0]
def test_multiple_queries_3(agent, exporter): agent.instrument() logger = setup_custom_logger(__name__) cnx = mysql.connector.connect(database='hypertrace', username='******', password='******', host='localhost', port=3306) cursor = cnx.cursor() insert_sql = "INSERT INTO hypertrace_data (col1, col2) VALUES (321, '123456789')" cursor.execute(insert_sql) delete_sql = "DELETE FROM hypertrace_data WHERE col1 = 321 AND col2='123456789'" cursor.execute(delete_sql) cursor.fetchall() select_sql = "SELECT * FROM hypertrace_data WHERE col1 = 432 AND col2= '0303456'" cursor.execute(select_sql) result = cursor.fetchall() assert result == [] cursor.close() cnx.close() span_list = exporter.get_finished_spans() assert span_list logger.debug('len(span_list): ' + str(len(span_list))) expected_sql_statements = [insert_sql, delete_sql, select_sql] for i in range(len(expected_sql_statements)): span = json.loads(span_list[i].to_json()) assert span['attributes']['db.system'] == 'mysql' assert span['attributes']['db.name'] == 'hypertrace' assert span['attributes']['db.statement'] == expected_sql_statements[i] assert span['attributes']['db.user'] == 'hypertrace' assert span['attributes']['net.peer.name'] == 'localhost' assert span['attributes']['net.peer.port'] == 3306
async def test_aiohttp_post(agent, exporter): logger = setup_custom_logger(__name__) app = Flask(__name__) app.use_reloader = False @app.route("/route1", methods=["POST"]) def api_example(): response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response server = FlaskServer(app) server.start() agent.instrument(app) # Make test call async with aiohttp.ClientSession() as session: async with session.post(f'http://localhost:{server.port}/route1', data='{ "a":"b", "c": "d" }', headers={'tester1': 'tester1', 'tester2': 'tester2'}) as response: response_body = await response.json() logger.info('Received: %s', str(response_body)) a = response_body['a'] assert a == 'a' span_list = exporter.get_finished_spans() assert span_list assert len(span_list) == 3 aiohttpSpanAsObject = json.loads(span_list[0].to_json()) assert aiohttpSpanAsObject['attributes']['http.method'] == 'POST' assert aiohttpSpanAsObject['attributes']['http.url'] == f'http://localhost:{server.port}/route1' assert aiohttpSpanAsObject['attributes']['http.request.header.tester1'] == 'tester1' assert aiohttpSpanAsObject['attributes']['http.request.header.tester2'] == 'tester2' assert aiohttpSpanAsObject['attributes']['http.response.header.content-type'] == 'application/json' assert aiohttpSpanAsObject['attributes']['http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert aiohttpSpanAsObject['attributes']['http.status_code'] == 200 server.shutdown()
def test_request_client(agent, exporter): try: logger = setup_custom_logger(__name__) app = Flask(__name__) app.use_reloader = False @app.route("/route1") def api_example(): response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response agent.instrument(app) server = FlaskServer(app) server.start() url = f'http://localhost:{server.port}/route1' response = requests.get(url) spans = exporter.get_finished_spans() assert spans assert len(spans) == 2 client_span = json.loads(spans[0].to_json()) assert client_span['attributes']['http.method'] == 'GET' assert client_span['attributes'][ 'http.url'] == f'http://localhost:{server.port}/route1' assert client_span['attributes']['http.request.header.accept'] == '*/*' assert client_span['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert client_span['attributes']['http.status_code'] == 200 assert client_span['attributes'][ 'http.response.header.tester3'] == 'tester3' assert client_span['attributes']['http.request.header.traceparent'] assert client_span['attributes']['http.method'] == 'GET' finally: server.shutdown()
def test_multiple_mysql_queries_2(agent, exporter): agent.instrument() logger = setup_custom_logger(__name__) cnx = get_connection(exporter) cursor = cnx.cursor() insert_sql = "INSERT INTO hypertrace_data (col1, col2) VALUES (321, '123456789')" cursor.execute(insert_sql) update_sql = "UPDATE hypertrace_data SET col1=432, col2 = '0303456' WHERE col1 = 321 AND col2='123456789'" cursor.execute(update_sql) cursor.fetchall() logger.info('Running SELECT statement.') select_sql = "SELECT * FROM hypertrace_data WHERE col1 = 432 AND col2= '0303456'" cursor.execute(select_sql) result = cursor.fetchall() assert result[0][0] == 432 assert result[0][1] == '0303456' cursor.close() cnx.close() span_list = exporter.get_finished_spans() assert span_list assert len(span_list) == 3 expected_sql_statements = [insert_sql, update_sql, select_sql] for i in range(len(expected_sql_statements)): span = json.loads(span_list[i].to_json()) assert span['attributes']['db.system'] == 'mysql' assert span['attributes']['db.name'] == 'hypertrace' assert span['attributes']['db.statement'] == expected_sql_statements[i] assert span['attributes']['db.user'] == 'hypertrace' assert span['attributes']['net.peer.name'] == 'localhost' assert span['attributes']['net.peer.port'] == 3306
import flask import json from flask import request, Flask from tests import setup_custom_logger from tests.hypertrace.agent.instrumentation.flask.app import FlaskServer logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) logger.info('Flask app initialized.') @app.route('/test/postdata', methods=['POST']) def post_api(): data = request.get_json() logger.info('Serving request for /test/postdata') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' sum1 = data['d1'] sum2 = data['d2'] response.data = str(sum1 + sum2) return response server = FlaskServer(app) def test_run(agent, exporter): agent.instrument(app)
def test_request_propagation(agent, exporter): try: logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route2") def api_example_2(): headers = {'tester1': 'tester1', 'tester2': 'tester2'} if flask.request.args.get("a") is None: requests.get( url=f'http://localhost:{server.port}/route2?a=foo', headers=headers) response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response agent.instrument(app) server = FlaskServer(app) server.start() logger.info('Agent initialized.') r1 = app.test_client().get(f'http://localhost:{server.port}/route2', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Get all of the in memory spans that were recorded for this iteration spans = exporter.get_finished_spans() # Confirm something was returned. assert spans # 3 spans => server => requests => server assert len(spans) == 3 server_1_span = json.loads(spans[0].to_json()) request_span = json.loads(spans[1].to_json()) # Check that the expected results are in the flask extended span attributes assert server_1_span["kind"] == "SpanKind.SERVER" assert server_1_span['attributes']['http.method'] == 'GET' assert server_1_span['attributes']['http.route'] == '/route2' assert server_1_span['attributes'][ 'http.response.header.content-type'] == 'application/json' assert server_1_span['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert server_1_span['attributes']['http.status_code'] == 200 assert server_1_span['attributes'][ 'http.response.header.tester3'] == 'tester3' assert request_span["kind"] == "SpanKind.CLIENT" assert request_span['attributes']['http.request.header.traceparent'] assert request_span['attributes']['http.method'] == 'GET' assert request_span['attributes'][ 'http.url'] == f'http://localhost:{server.port}/route2?a=foo' assert request_span['attributes']['http.status_code'] == 200 exporter.clear() a1 = r1.get_json()['a'] assert a1 == 'a' finally: server.shutdown()
def test_run(agent, exporter): logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route1", methods=['GET']) def api_1(): logger.info('Serving request for /route1.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response @app.route("/route2", methods=['GET']) def api_2(): logger.info('Serving request for /route2.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response @app.route('/home/<name>', methods=['GET']) def api_3(name): logger.info('Serving request for /home.') return "hello," + name agent.instrument(app) server = FlaskServer(app) server.start() with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get('http://localhost:5000/route1', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Get all of the in memory spans that were recorded for this iteration span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester1'] == 'tester1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester2'] == 'tester2' assert flaskSpanAsObject['attributes'][ 'http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['attributes'][ 'http.response.header.tester3'] == 'tester3' exporter.clear() logger.info('Making test call to /route2') r2 = app.test_client().get('http://localhost:5000/route2', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Confirm something was returned. assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester1'] == 'tester1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester2'] == 'tester2' assert flaskSpanAsObject['attributes'][ 'http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['attributes'][ 'http.response.header.tester3'] == 'tester3' exporter.clear() logger.info('Making test call to /home') r3 = app.test_client().get('http://localhost:5000/home/test') span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/home/test' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['name'] == 'GET /home/<name>' exporter.clear() logger.info('Reading /route1 response.') a1 = r1.get_json()['a'] logger.info('Reading /route2 response.') a2 = r2.get_json()['a'] assert a1 == 'a' assert a2 == 'a' logger.info('r1 result: ' + str(a1)) logger.info('r2 result: ' + str(a2)) logger.info('Exiting from flask instrumentation test.') server.shutdown()
def test_run(agent, exporter): logger = setup_custom_logger(__name__) logger.info('Initializing flask app.') # Create Flask app app = Flask(__name__) @app.route("/route1") def testAPI1(): logger.info('Serving request for /route1.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' response.data = str('{ "a": "a", "xyz": "xyz" }') return response @app.route("/route2") def testAPI2(): logger.info('Serving request for /route2.') response = flask.Response(mimetype='application/json') response.headers['tester3'] = 'tester3' json_data = {"message": "Hello [('mysql.infoschema', 'localhost')]"} response.data = json.dumps(json_data) return response logger.info('Flask app initialized.') # # Code snippet here represents the current initialization logic # logger.info('Initializing agent.') agent.instrument(app) logger.info('Agent initialized.') server = FlaskServer(app) server.start() logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /route1') r1 = app.test_client().get(f'http://localhost:{server.port}/route1', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Get all of the in memory spans that were recorded for this iteration span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester1'] == 'tester1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester2'] == 'tester2' assert flaskSpanAsObject['attributes'][ 'http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['attributes'][ 'http.response.header.tester3'] == 'tester3' exporter.clear() logger.info('Making test call to /route2') r2 = app.test_client().get('http://localhost:5000/route2', headers={ 'tester1': 'tester1', 'tester2': 'tester2' }) # Confirm something was returned. span_list = exporter.get_finished_spans() assert span_list # Confirm there are three spans logger.debug('len(span_list): ' + str(len(span_list))) assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) flaskSpanAsObject = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/route2' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester1'] == 'tester1' assert flaskSpanAsObject['attributes'][ 'http.request.header.tester2'] == 'tester2' assert flaskSpanAsObject['attributes'][ 'http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{"message": "Hello [(\'mysql.infoschema\', \'localhost\')]"}' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert flaskSpanAsObject['attributes'][ 'http.response.header.tester3'] == 'tester3' exporter.clear() logger.info('Reading /route1 response.') a1 = r1.get_json()['a'] logger.info('Reading /route2 response.') a2 = r2.get_json()['message'] assert a1 == 'a' assert a2 == 'Hello [(\'mysql.infoschema\', \'localhost\')]' logger.info('r1 result: ' + str(a1)) logger.info('r2 result: ' + str(a2)) logger.info('Exiting from flask instrumentation test.') server.shutdown()
def test_run(agent, exporter): logger = setup_custom_logger(__name__) os.environ[ '_HANDLER'] = 'tests.hypertrace.agent.instrumentation.lambda.lambda_test.example_lambda' agent.instrument() logger.info('Running test calls.') mockEventData = { 'version': '2.0', 'routeKey': 'POST /test-function', 'rawPath': '/default/test-function', 'rawQueryString': '', 'headers': { 'accept': '*/*', 'content-length': '23', 'content-type': 'application/json', 'host': 'something.foo.bar', 'user-agent': 'insomnia/2021.6.0', 'x-amzn-trace-id': 'Root=1-61bc2935-0d71070e0218146e5683cd7e', 'x-forwarded-for': '202.87.208.0, 207.255.222.177', 'x-forwarded-port': '443', 'x-forwarded-proto': 'https' }, 'cookies': ["name=123", "anothercookie=456"], 'multiValueHeaders': { 'accept': ['*/*'], 'Host': ['something.foo.bar'], 'User-Agent': ['insomnia/2021.7.2'], 'X-Amzn-Trace-Id': ['Root=1-61bc2935-0d71070e0218146e5683cd7e'], 'X-Forwarded-For': ['202.87.208.0, 207.255.222.177'], 'X-Forwarded-Port': ['443'], 'X-Forwarded-Proto': ['https'] }, 'requestContext': { 'accountId': '286278240186', 'apiId': 'brz7ycf4q7', 'domainName': 'something.foo.bar', 'domainPrefix': 'brz7ycf4q7', 'http': { 'method': 'POST', 'path': '/default/test-function', 'protocol': 'HTTP/1.1', 'sourceIp': '207.255.222.177', 'userAgent': 'insomnia/2021.6.0' }, 'requestId': 'Ketgdj-vCYcEMHw=', 'routeKey': 'POST /test-function', 'stage': 'default', 'time': '17/Dec/2021:06:07:49 +0000', 'timeEpoch': 1639721269962 }, 'body': '{\n\t"name": "sample body data"\n}', 'isBase64Encoded': False } cntxt = ContextStub() example_lambda(mockEventData, cntxt) # Get all of the in memory spans that were recorded for this iteration span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list assert len(span_list) == 1 logger.debug('span_list: ' + str(span_list[0].attributes)) span = json.loads(span_list[0].to_json()) # Check that the expected results are in the flask extended span attributes assert span['attributes']['http.method'] == 'POST' assert span['attributes']['http.host'] == 'something.foo.bar' assert span['attributes']['http.target'] == '/default/test-function' assert span['attributes']['http.scheme'] == 'https' assert span['attributes'][ 'http.request.header.x-forwarded-for'] == '202.87.208.0, 207.255.222.177' assert span['attributes'][ 'http.request.header.x-amzn-trace-id'] == 'Root=1-61bc2935-0d71070e0218146e5683cd7e' assert span['attributes'][ 'http.request.header.cookie'] == 'name=123;anothercookie=456' assert span['attributes'][ 'http.response.header.content-type'] == 'application/json' assert span['attributes'][ 'http.request.body'] == '{\n\t"name": "sample body data"\n}' assert span['attributes'][ 'http.response.body'] == '{"test_key": "test_value"}' assert span['attributes']['http.status_code'] == 200 assert span['attributes'][ 'http.response.header.content-type'] == 'application/json'
def test_mysql_within_application(agent, exporter): logger = setup_custom_logger(__name__) app = Flask(__name__) agent.instrument(app) conn = get_connection(exporter) @app.route("/dbtest") def api(): cnx = get_connection(exporter) cursor = cnx.cursor() cursor.execute( "INSERT INTO hypertrace_data (col1, col2) VALUES (123, 'abcdefghijklmnopqrstuvwxyz')") cursor.execute( "INSERT INTO hypertrace_data (col1, col2) VALUES (456, 'abcdefghijklmnopqrstuvwxyz')") cursor.close() cnx.close() response = flask.Response(mimetype='application/json') response.data = str('{ "a": "a", "xyz": "xyz" }') return response server = FlaskServer(app) logger.info('Running test calls.') with app.test_client() as c: logger.info('Making test call to /dbtest') for x in range(10): # Run 10 requests r1 = app.test_client().get(f'http://localhost:{server.port}/dbtest') logger.info('Reading /dbtest response.') a1 = r1.get_json()['a'] assert a1 == 'a' # Get all of the in memory spans that were recorded for this iteration span_list = exporter.get_finished_spans() # Confirm something was returned. assert span_list assert len(span_list) == 3 flaskSpanAsObject = json.loads(span_list[2].to_json()) sql1SpanAsObject = json.loads(span_list[1].to_json()) sql2SpanAsObject = json.loads(span_list[0].to_json()) assert flaskSpanAsObject['attributes']['http.method'] == 'GET' assert flaskSpanAsObject['attributes']['http.target'] == '/dbtest' assert flaskSpanAsObject['attributes']['http.response.header.content-type'] == 'application/json' assert flaskSpanAsObject['attributes'][ 'http.response.body'] == '{ "a": "a", "xyz": "xyz" }' assert flaskSpanAsObject['attributes']['http.status_code'] == 200 assert sql1SpanAsObject['attributes']['db.system'] == 'mysql' assert sql1SpanAsObject['attributes']['db.name'] == 'hypertrace' assert sql1SpanAsObject['attributes']['db.user'] == 'hypertrace' assert sql1SpanAsObject['attributes']['net.peer.name'] == 'localhost' assert sql1SpanAsObject['attributes']['net.peer.port'] == 3306 assert sql1SpanAsObject['attributes'][ 'db.statement'] == "INSERT INTO hypertrace_data (col1, col2) VALUES (456, 'abcdefghijklmnopqrstuvwxyz')" assert sql2SpanAsObject['attributes']['db.system'] == 'mysql' assert sql2SpanAsObject['attributes']['db.name'] == 'hypertrace' assert sql2SpanAsObject['attributes']['db.user'] == 'hypertrace' assert sql2SpanAsObject['attributes']['net.peer.name'] == 'localhost' assert sql2SpanAsObject['attributes']['net.peer.port'] == 3306 assert sql2SpanAsObject['attributes'][ 'db.statement'] == "INSERT INTO hypertrace_data (col1, col2) VALUES (123, 'abcdefghijklmnopqrstuvwxyz')"