def test_if_thundra_is_disabled(mock_reporter, handler, mock_event,
mock_context):
ConfigProvider.set(config_names.THUNDRA_TRACE_DISABLE, 'true')
_, handler = handler
handler(mock_event, mock_context)
assert not mock_reporter.add_report.called
assert not mock_reporter.send_reports.called
def thundra_with_request_response_skip(monkeypatch):
monkeypatch.setitem(os.environ, constants.AWS_REGION, 'region')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_ID, '[]test')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_VERSION, 'version')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
ConfigProvider.set(config_names.THUNDRA_TRACE_REQUEST_SKIP, 'true')
ConfigProvider.set(config_names.THUNDRA_TRACE_RESPONSE_SKIP, 'true')
thundra = Thundra('api key', disable_metric=True)
return thundra
def test_if_enable_trace_plugin_from_environment_variable_is_prior():
ConfigProvider.set(config_names.THUNDRA_TRACE_DISABLE, 'false')
thundra = Thundra('api key', disable_trace=True)
trace_exist = False
for plugin in thundra.plugins:
if isinstance(plugin, TracePlugin):
trace_exist = True
assert trace_exist is True
def test_invocation_support_error_set(handler_with_user_error, mock_context, mock_event):
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
thundra, handler = handler_with_user_error
handler(mock_event, mock_context)
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['erroneous'] is True
assert execution_context.invocation_data['errorType'] == 'Exception'
assert execution_context.invocation_data['errorMessage'] == 'test'
def test_prepare_report_json_batch(mock_report):
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_COMPOSITE_BATCH_SIZE, '1')
reporter = Reporter('api key')
batched_reports = reporter.prepare_report_json([mock_report] * 2)
assert len(batched_reports) == 2
reports = json.loads(batched_reports[0])
assert len(reports) == 1
def test_mongo_command_masked():
ConfigProvider.set(
config_names.THUNDRA_TRACE_INTEGRATIONS_MONGODB_COMMAND_MASK,
'true')
client = MongoClient('localhost', 27017)
db = client.test
db.list_collection_names()
tracer = ThundraTracer.get_instance()
span = tracer.get_spans()[1]
assert span.get_tag(constants.MongoDBTags['MONGODB_COMMAND']) is None
def test_send_report_to_url_async(mock_requests, mock_report):
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_BASEURL, 'different_url/api')
ConfigProvider.set(config_names.THUNDRA_REPORT_CLOUDWATCH_ENABLE, 'true')
test_session = mock_requests.Session()
reporter = Reporter('api key', session=test_session)
responses = reporter.send_reports([mock_report])
reporter.session.post.assert_not_called()
assert responses == []
def test_create_empty_span_listener(empty_span_listener):
sl_env_var = to_json(empty_span_listener)
ConfigProvider.set(config_names.THUNDRA_TRACE_SPAN_LISTENERCONFIG,
sl_env_var)
trace_support._parse_span_listeners()
sl = trace_support.get_span_listeners()[0]
assert type(sl) is FilteringSpanListener
assert type(sl.listener) is ErrorInjectorSpanListener
assert type(sl.filterer) is StandardSpanFilterer
def test_if_error_is_added_to_report(handler_with_exception, mock_context, mock_event):
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
thundra, handler = handler_with_exception
try:
handler(mock_event, mock_context)
except Exception:
pass
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['erroneous'] is True
assert execution_context.invocation_data['errorType'] == 'Exception'
assert execution_context.invocation_data['errorMessage'] == 'hello'
def test_coldstarts(handler, mock_context, mock_event):
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
thundra, handler = handler
handler(mock_event, mock_context)
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['coldStart'] is True
assert execution_context.invocation_data['tags']['aws.lambda.invocation.coldstart'] is True
handler(mock_event, mock_context)
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['coldStart'] is False
assert execution_context.invocation_data['tags']['aws.lambda.invocation.coldstart'] is False
def test_mask_body():
ConfigProvider.set(
config_names.THUNDRA_TRACE_INTEGRATIONS_ELASTICSEARCH_BODY_MASK,
'true')
try:
es = Elasticsearch([{'host': 'test', 'port': 3737}], max_retries=0)
author1 = {"name": "Sidney Sheldon", "novels_count": 18}
es.index(index='authors', doc_type='authors', body=author1, id=1)
except ElasticsearchException:
pass
finally:
tracer = ThundraTracer.get_instance()
span = tracer.get_spans()[1]
assert span.get_tag(constants.ESTags['ES_BODY']) is None
def test_prepare_composite_report_json(mock_report, mock_invocation_report):
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_COMPOSITE_BATCH_SIZE, '2')
reporter = Reporter('api key')
batched_reports = reporter.prepare_composite_report_json([mock_invocation_report, mock_report, mock_report])
composite_report = json.loads(batched_reports[0])
assert composite_report["type"] == "Composite"
assert composite_report["apiKey"] == "api key"
assert len(composite_report["data"]["allMonitoringData"]) == 2
composite_report = json.loads(batched_reports[1])
assert composite_report["type"] == "Composite"
assert composite_report["apiKey"] == "api key"
assert len(composite_report["data"]["allMonitoringData"]) == 1
def test_create_span_listener_with_only_listener(
span_listener_with_one_listener):
sl_env_var = to_json(span_listener_with_one_listener)
ConfigProvider.set(config_names.THUNDRA_TRACE_SPAN_LISTENERCONFIG,
sl_env_var)
trace_support._parse_span_listeners()
sl = trace_support.get_span_listeners()[0]
assert type(sl) is FilteringSpanListener
assert type(sl.listener) is ErrorInjectorSpanListener
assert sl.listener.error_type is NameError
assert sl.listener.error_message == 'foo'
assert type(sl.filterer) is StandardSpanFilterer
def test_create_span_listener_with_only_filterer(
span_listener_with_one_filterer):
sl_env_var = to_json(span_listener_with_one_filterer)
ConfigProvider.set(config_names.THUNDRA_TRACE_SPAN_LISTENERCONFIG,
sl_env_var)
trace_support._parse_span_listeners()
sl = trace_support.get_span_listeners()[0]
f = sl.filterer.span_filters[0]
assert type(sl) is FilteringSpanListener
assert sl.listener is None
assert f.class_name == 'AWS-SQS'
assert f.domain_name == 'Messaging'
assert f.tags == {'foo': 'bar'}
def test_send_report_to_url(mock_requests, mock_report):
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_BASEURL, 'different_url/api')
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_COMPOSITE_ENABLE, 'false')
test_session = mock_requests.Session()
reporter = Reporter('api key', session=test_session)
responses = reporter.send_reports([mock_report])
post_url = 'different_url/api/monitoring-data'
headers = {
'Content-Type': 'application/json',
'Authorization': 'ApiKey api key'
}
reporter.session.post.assert_called_once_with(post_url, data=to_json([mock_report], separators=(',', ':')),
headers=headers, timeout=constants.DEFAULT_REPORT_TIMEOUT)
reporter.session.post.return_value.status_code = 200
for response in responses:
assert response.status_code == 200
def test_create_span_listener_with_filterer_and_listener(
span_listener_with_filterer_and_listener):
sl_env_var = to_json(span_listener_with_filterer_and_listener)
ConfigProvider.set(config_names.THUNDRA_TRACE_SPAN_LISTENERCONFIG,
sl_env_var)
trace_support._parse_span_listeners()
sl = trace_support.get_span_listeners()[0]
f = sl.filterer.span_filters[0]
assert type(sl) is FilteringSpanListener
assert type(sl.listener) is ErrorInjectorSpanListener
assert sl.listener.error_type is NameError
assert sl.listener.error_message == 'foo'
assert sl.listener.inject_on_finish
assert sl.listener.inject_count_freq
assert f.class_name == 'AWS-SQS'
assert f.domain_name == 'Messaging'
assert f.tags == {'foo': 'bar'}
def test_aws_related_tags(handler_with_profile, mock_context, mock_event, monkeypatch):
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
monkeypatch.setitem(os.environ, "_X_AMZN_TRACE_ID",
"Root=1-5759e988-bd862e3fe1be46a994272793;Parent=53995c3f42cd8ad8;Sampled=1")
thundra, handler = handler_with_profile
try:
handler(mock_event, mock_context)
except Exception:
pass
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['tags'][
'aws.lambda.arn'] == 'arn:aws:lambda:us-west-2:123456789123:function:test'
assert execution_context.invocation_data['tags']['aws.account_no'] == '123456789123'
assert execution_context.invocation_data['tags']['aws.lambda.memory_limit'] == 128
assert execution_context.invocation_data['tags']['aws.lambda.log_group_name'] == 'log_group_name'
assert execution_context.invocation_data['tags']['aws.lambda.log_stream_name'] == 'log_stream_name[]id'
assert execution_context.invocation_data['tags']['aws.lambda.invocation.request_id'] == 'aws_request_id'
assert execution_context.invocation_data['tags']['aws.xray.trace.id'] == '1-5759e988-bd862e3fe1be46a994272793'
assert execution_context.invocation_data['tags']['aws.xray.segment.id'] == '53995c3f42cd8ad8'
def test_get_mask_command():
ConfigProvider.set(config_names.THUNDRA_TRACE_INTEGRATIONS_REDIS_COMMAND_MASK, 'true')
try:
r = redis.Redis(host="test", port="12345", password="******")
r.get('foo')
except:
pass
finally:
tracer = ThundraTracer.get_instance()
span = tracer.get_spans()[1]
assert span.class_name == 'Redis'
assert span.domain_name == 'Cache'
assert span.operation_name == 'test'
assert span.get_tag(constants.DBTags['DB_TYPE']) == 'redis'
assert span.get_tag(constants.DBTags['DB_INSTANCE']) == 'test'
assert span.get_tag(constants.DBTags['DB_STATEMENT_TYPE']) == 'READ'
assert span.get_tag(constants.RedisTags['REDIS_HOST']) == 'test'
assert span.get_tag(constants.RedisTags['REDIS_COMMAND_TYPE']) == 'GET'
assert span.get_tag(constants.DBTags['DB_STATEMENT']) is None
assert span.get_tag(constants.RedisTags['REDIS_COMMAND']) is None
tracer.clear()
def thundra_with_profile(reporter, monkeypatch):
monkeypatch.setitem(os.environ, constants.AWS_REGION, 'region')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_ID, '[]test')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_VERSION, 'version')
ConfigProvider.set(config_names.THUNDRA_APPLICATION_STAGE, 'dev')
thundra = Thundra('api key', disable_metric=True)
thundra.reporter = reporter
return thundra
def test_send_report_to_url_composite(mock_requests, mock_report, mock_invocation_report):
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_BASEURL, 'different_url/api')
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_COMPOSITE_ENABLE, 'true')
ConfigProvider.set(config_names.THUNDRA_REPORT_REST_COMPOSITE_BATCH_SIZE, '1')
test_session = mock_requests.Session()
reporter = Reporter('api key', session=test_session)
responses = reporter.send_reports([mock_invocation_report, mock_report])
assert reporter.session.post.call_count == 2
reporter.session.post.return_value.status_code = 200
for response in responses:
assert response.status_code == 200
def test_if_api_key_is_retrieved_from_env_var():
ConfigProvider.set(config_names.THUNDRA_APIKEY, 'api key')
thundra = Thundra()
assert thundra.api_key == 'api key'
def test_retrieving_trace_args():
ConfigProvider.set(config_names.THUNDRA_TRACE_INSTRUMENT_TRACEABLECONFIG, \
"{}.{}*{}".format(target_module_name ,target_function_prefix, target_trace_arguments))
patcher = ImportPatcher()
for arg in patcher.get_trace_arguments(target_module_name):
assert arg in target_trace_arguments_list
def test_freq_from_env():
time_freq = 37
ConfigProvider.set(config_names.THUNDRA_SAMPLER_TIMEAWARE_TIMEFREQ, '{}'.format(time_freq))
tams = TimeAwareSampler()
assert tams.time_freq == time_freq
