def __init__(self,
*,
plugin_executor=None,
api_key=None,
disable_trace=False,
disable_metric=True,
disable_log=True,
opts=None,
**ignored):
super(TestWrapper, self).__init__(api_key, disable_trace,
disable_metric, disable_log, opts)
ExecutionContextManager.set_provider(
TracingExecutionContextProvider()) #TODO
self.application_info_provider = GlobalApplicationInfoProvider()
self._set_application_info("Foresight", "TestSuite", "TestSuite")
self.plugin_context = PluginContext(
application_info=self.application_info_provider.
get_application_info(),
request_count=0,
executor=plugin_executor,
api_key=self.api_key)
max_test_log_count = ConfigProvider.get(
config_names.THUNDRA_TEST_LOG_COUNT_MAX)
self.config.log_config = LogConfig(
sampler=MaxCountAwareSampler(max_test_log_count))
self.plugins = wrapper_utils.initialize_plugins(self.plugin_context,
disable_trace,
disable_metric,
disable_log,
config=self.config)
TestWrapper.__instance = self
def test_blueprint(finish_trace):
blueprint = Blueprint('test', __name__)
@blueprint.route('/api/test', methods=('GET', ))
def test():
return 'test'
app.register_blueprint(blueprint)
response = client.get('/api/test')
execution_context = ExecutionContextManager.get()
assert execution_context.root_span.operation_name == '/api/test'
assert execution_context.root_span.get_tag('http.method') == 'GET'
assert execution_context.root_span.get_tag('http.host') == 'localhost'
assert execution_context.root_span.get_tag('http.path') == '/api/test'
assert execution_context.root_span.class_name == constants.ClassNames[
'FLASK']
assert execution_context.root_span.domain_name == 'API'
assert execution_context.tags.get(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'localhost/api/test'
]
assert execution_context.tags.get(
constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'API'
assert execution_context.tags.get(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'HTTP'
assert execution_context.response.data == response.data
assert execution_context.response.status_code == 200
ExecutionContextManager.clear()
def __init__(self,
api_key=None,
disable_trace=False,
disable_metric=True,
disable_log=True,
opts=None):
super(TornadoWrapper, self).__init__(api_key, disable_trace,
disable_metric, disable_log, opts)
self.application_info_provider = GlobalApplicationInfoProvider()
ExecutionContextManager.set_provider(TracingExecutionContextProvider())
self.plugin_context = PluginContext(
application_info=self.application_info_provider.
get_application_info(),
request_count=0,
executor=tornado_executor,
api_key=self.api_key)
self.plugins = wrapper_utils.initialize_plugins(self.plugin_context,
disable_trace,
disable_metric,
disable_log,
config=self.config)
web_wrapper_utils.update_application_info(
self.application_info_provider,
self.plugin_context.application_info,
constants.ClassNames['TORNADO'])
def start_test_span(cls, name, test_suite_name, test_case_id, app_info):
try:
test_wrapper = TestWrapper.get_instance()
test_wrapper.change_app_info(app_info)
current_context = ExecutionContextManager.get()
parent_transaction_id = current_context.invocation_data.get("transactionId")
context = test_wrapper.create_test_case_execution_context(name, test_suite_name, test_case_id, app_info, parent_transaction_id)
ExecutionContextManager.set(context)
test_wrapper.before_test_process(context)
except Exception as e:
logger.error("Handler_utils start_test_span error: {}".format(e))
pass
def start_after_all_span(cls, app_info, span_tags):
"""after all executed after test cases. That is why context should be getting from TestRunnerSupport and
set into ExecutionContextManager.
"""
try:
context = TestRunnerSupport.test_suite_execution_context
ExecutionContextManager.set(context)
return cls.create_span(cls.TEST_AFTER_ALL_OPERATION_NAME, app_info, span_tags)
except Exception as e:
logger.error("Handler_utils start_after_all_span error: {}".format(e))
pass
return None
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 finish_test_span():
"""Setup TestRunnerSupport for test suite. It's executed after all process has been done
for test case such as before_each, after each etc.
"""
try:
test_wrapper = TestWrapper.get_instance()
context = ExecutionContextManager.get()
test_wrapper.after_test_process(context)
app_info = TestRunnerSupport.test_suite_application_info
context = TestRunnerSupport.test_suite_execution_context
test_wrapper.change_app_info(app_info)
ExecutionContextManager.set(context)
except Exception as e:
logger.error("Handler_utils finish_test_span error: {}".format(e))
def test_apigateway_trigger(tracer_and_invocation_support, handler,
mock_apigateway_event, mock_context):
_, handler = handler
tracer, invocation_support, _ = tracer_and_invocation_support
handler(mock_apigateway_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_apigateway_event,
mock_context) == lambda_event_utils.LambdaEventType.APIGateway
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'API'
assert span.get_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-APIGateway'
assert span.get_tag(constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'random.execute-api.us-west-2.amazonaws.com/dev{}'
]
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'API'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-APIGateway'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'random.execute-api.us-west-2.amazonaws.com/dev{}'
]
def test_firehose_trigger(tracer_and_invocation_support, handler,
mock_firehose_event, mock_context):
thundra, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
assert lambda_event_utils.get_lambda_event_type(
mock_firehose_event,
mock_context) == lambda_event_utils.LambdaEventType.Firehose
handler(mock_firehose_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STREAM']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['FIREHOSE']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['exampleStream']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STREAM']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['FIREHOSE']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['exampleStream']
links = [
"eu-west-2:exampleStream:1495072948:75c5afa1146857f64e92e6bb6e561ded",
"eu-west-2:exampleStream:1495072949:75c5afa1146857f64e92e6bb6e561ded",
"eu-west-2:exampleStream:1495072950:75c5afa1146857f64e92e6bb6e561ded",
]
assert sorted(invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks')) == sorted(links)
def test_cloudwatch_logs_trigger(tracer_and_invocation_support, handler,
mock_cloudwatch_logs_event, mock_context):
_, handler = handler
tracer, invocation_support, _ = tracer_and_invocation_support
handler(mock_cloudwatch_logs_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_cloudwatch_logs_event,
mock_context) == lambda_event_utils.LambdaEventType.CloudWatchLogs
compressed_data = base64.b64decode(
mock_cloudwatch_logs_event['awslogs']['data'])
decompressed_data = json.loads(
str(GzipFile(fileobj=BytesIO(compressed_data)).read(), 'utf-8'))
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'Log'
assert span.get_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-CloudWatch-Log'
assert span.get_tag(constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
decompressed_data['logGroup']
]
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'Log'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-CloudWatch-Log'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
decompressed_data['logGroup']
]
def test_eventbridge_trigger(tracer_and_invocation_support, handler,
mock_eventbridge_event, mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
assert lambda_event_utils.get_lambda_event_type(
mock_eventbridge_event,
mock_context) == lambda_event_utils.LambdaEventType.EventBridge
handler(mock_eventbridge_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['EVENTBRIDGE']
assert span.get_tag(constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'EC2 Command Status-change Notification'
]
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['EVENTBRIDGE']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'EC2 Command Status-change Notification'
]
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == ["51c0891d-0e34-45b1-83d6-95db273d1602"]
def test_sqs_trigger(tracer_and_invocation_support, handler, mock_sqs_event,
mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
handler(mock_sqs_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_sqs_event, mock_context) == lambda_event_utils.LambdaEventType.SQS
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['SQS']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['MyQueue']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['SQS']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['MyQueue']
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == ["19dd0b57-b21e-4ac1-bd88-01bbb068cb78"]
def create_span(operation_name, app_info={}, span_tags=None):
try:
tracer = ThundraTracer().get_instance()
execution_context = ExecutionContextManager.get()
parent_transaction_id = execution_context.transaction_id if execution_context.transaction_id else None
trace_id = execution_context.trace_id if execution_context.trace_id else utils.create_uuid4()
transaction_id = parent_transaction_id or utils.create_uuid4()
scope = tracer.start_active_span(
span_id=utils.create_uuid4(),
operation_name=operation_name,
trace_id=trace_id,
transaction_id=transaction_id,
start_time=utils.current_milli_time(),
execution_context = execution_context
)
span = scope.span
span.domain_name = app_info.get("applicationDomainName")
span.class_name = app_info.get("applicationClassName")
span.service_name = app_info.get("applicationName")
if span_tags:
for key in span_tags.keys():
span.set_tag(key, span_tags[key])
return scope
except Exception as e:
logger.error("Handler_utils create_span error: {}".format(e))
pass
return None
def start_test_suite_span(cls, test_suite_id, app_info):
"""For now, TestRunnerSupport not support concurrency. Only one test suite info is kept there.
It should be changed for concurrent python test framework.
"""
try:
if not TestRunnerSupport.test_suite_execution_context:
test_wrapper = TestWrapper.get_instance()
context = test_wrapper.create_test_suite_execution_context(test_suite_id)
ExecutionContextManager.set(context)
test_wrapper.change_app_info(app_info)
TestRunnerSupport.set_test_suite_application_info(app_info)
TestRunnerSupport.set_test_suite_execution_context(context)
test_wrapper.before_test_process(context)
except Exception as e:
logger.error("Handler_utils start_test_suite_span error: {}".format(e))
pass
def pytest_runtest_makereport(item, call):
"""Called to create a _pytest.reports.TestReport for each of the setup,
call and teardown runtest phases of a test item. Check test case span started or not and
its marked skipped or not. Then, update test status according to test result.
Args:
item (pytest.Item): Current running item(test case).
call (pytest.CallInfo): The CallInfo for the phase.
"""
try:
outcome = yield
if not PytestHelper.check_pytest_started():
return
if call.when == "setup":
PytestHelper.start_test_span(item)
status, exception = check_test_status_state(item, call)
if not status:
return
result = outcome.get_result()
execution_context = ExecutionContextManager.get()
# After Function call report to get test status(success, failed, aborted, skipped , ignored)
test_status = check_test_case_result(item, execution_context, result,
exception)
update_test_status(item, test_status, execution_context)
except Exception as e:
logger.error("Pytest runtest_makereport error: {}".format(e))
pass
def test_lambda_trigger(tracer_and_invocation_support, handler, mock_event,
mock_lambda_context):
thundra, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
assert lambda_event_utils.get_lambda_event_type(
mock_event,
mock_lambda_context) == lambda_event_utils.LambdaEventType.Lambda
handler(mock_event, mock_lambda_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['API']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['LAMBDA']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['Sample Context']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['API']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['LAMBDA']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['Sample Context']
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == ["aws_request_id"]
def test_sns_trigger(tracer_and_invocation_support, handler, mock_sns_event,
mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
handler(mock_sns_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_sns_event, mock_context) == lambda_event_utils.LambdaEventType.SNS
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['SNS']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['ExampleTopic']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['MESSAGING']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['SNS']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['ExampleTopic']
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == ["95df01b4-ee98-5cb9-9903-4c221d41eb5e"]
def test_kinesis_trigger(tracer_and_invocation_support, handler,
mock_kinesis_event, mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
handler(mock_kinesis_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_kinesis_event,
mock_context) == lambda_event_utils.LambdaEventType.Kinesis
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STREAM']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['KINESIS']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['example_stream']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STREAM']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['KINESIS']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['example_stream']
links = [
"eu-west-2:example_stream:shardId-000000000000:49545115243490985018280067714973144582180062593244200961"
]
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == links
def test_cloudwatch_schedule_trigger(tracer_and_invocation_support, handler,
mock_cloudwatch_schedule_event,
mock_context):
_, handler = handler
tracer, invocation_support, _ = tracer_and_invocation_support
handler(mock_cloudwatch_schedule_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
event_type = lambda_event_utils.get_lambda_event_type(
mock_cloudwatch_schedule_event, mock_context)
assert event_type == lambda_event_utils.LambdaEventType.CloudWatchSchedule
assert span.get_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'Schedule'
assert span.get_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-CloudWatch-Schedule'
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['ExampleRule']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']) == 'Schedule'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == 'AWS-CloudWatch-Schedule'
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['ExampleRule']
def test_when_app_stage_not_exists(handler, mock_context, mock_event):
thundra, handler = handler
handler(mock_event, mock_context)
execution_context = ExecutionContextManager.get()
assert execution_context.invocation_data['applicationStage'] is ''
def test_s3_trigger(tracer_and_invocation_support, handler, mock_s3_event,
mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
assert lambda_event_utils.get_lambda_event_type(
mock_s3_event, mock_context) == lambda_event_utils.LambdaEventType.S3
handler(mock_s3_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STORAGE']
assert span.get_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == constants.ClassNames['S3']
assert span.get_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['example-bucket']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['STORAGE']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']) == constants.ClassNames['S3']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == ['example-bucket']
assert invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks') == ["EXAMPLE123456789"]
def test_if_exception_is_handled(handler_with_exception, mock_context,
mock_event):
thundra, handler = handler_with_exception
with pytest.raises(Exception):
handler(mock_event, mock_context)
assert ExecutionContextManager.get().error
def get_resources():
try:
resources = {}
execution_context = ExecutionContextManager.get()
spans = execution_context.recorder.get_spans()
root_span_id = execution_context.root_span.context.span_id
for span in spans:
if (not span.get_tag(constants.SpanTags['TOPOLOGY_VERTEX'])
or span.span_id == root_span_id):
continue
resource_names = span.get_tag(constants.SpanTags['RESOURCE_NAMES'])
if resource_names:
for resource_name in resource_names:
rid = _resource_id(span, resource_name)
if rid:
if not rid in resources:
resources[rid] = Resource(span)
resources[rid].name = resource_name
else:
resources[rid].merge(span)
else:
rid = _resource_id(span)
if rid:
if not rid in resources:
resources[rid] = Resource(span)
else:
resources[rid].merge(span)
return {'resources': [r.to_dict() for r in resources.values()]}
except Exception as e:
logger.error(
"error while creating the resources data for invocation: %s", e)
return {}
def test_when_thundra_log_handler_is_not_added_to_logger(
handler, mock_context, mock_event):
_, handler = handler
handler(mock_event, mock_context)
execution_context = ExecutionContextManager.get()
assert len(execution_context.logs) == 0
def mock_error_handler(self, error):
execution_context = ExecutionContextManager.get()
if error:
execution_context.error = error
self.prepare_and_send_reports_async(execution_context)
assert error.type == "RuntimeError"
assert error.message == "Test Error"
def start_root_span():
tracer = ThundraTracer.get_instance()
execution_context = ExecutionContextManager.get()
tracer.start_active_span(operation_name="test",
finish_on_close=False,
trace_id="test-trace-id",
transaction_id="test-transaction-id",
execution_context=execution_context)
def test_successful_view(self, finish_trace):
query_string={'foo': 'baz'}
response = self.fetch(url_concat("/query", query_string))
execution_context = ExecutionContextManager.get()
self.assertEqual(execution_context.root_span.operation_name, '/query')
self.assertEqual(execution_context.root_span.get_tag('http.method'), 'GET')
self.assertEqual(execution_context.root_span.get_tag('http.host'), '127.0.0.1')
self.assertEqual(execution_context.root_span.get_tag('http.query_params'), 'foo=baz')
self.assertEqual(execution_context.root_span.get_tag('http.path'), '/query')
self.assertEqual(execution_context.root_span.class_name, constants.ClassNames['TORNADO'])
self.assertEqual(execution_context.root_span.domain_name, 'API')
self.assertEqual(execution_context.tags.get(constants.SpanTags['TRIGGER_OPERATION_NAMES']), ['127.0.0.1/query'])
self.assertEqual(execution_context.tags.get(constants.SpanTags['TRIGGER_DOMAIN_NAME']), 'API')
self.assertEqual(execution_context.tags.get(constants.SpanTags['TRIGGER_CLASS_NAME']), 'HTTP')
self.assertEqual(execution_context.response.status_code, 200)
self.assertEqual(response.body, b'baz')
ExecutionContextManager.clear()
def get_incoming_trace_links():
if ConfigProvider.get(config_names.THUNDRA_DISABLE, False):
return {}
execution_context = ExecutionContextManager.get()
incoming_trace_links = list(set(execution_context.incoming_trace_links)
)[:constants.MAX_INCOMING_TRACE_LINKS]
return {"incomingTraceLinks": incoming_trace_links}
def test_dynamodb_trigger(tracer_and_invocation_support, handler,
mock_dynamodb_event, mock_context):
_, handler = handler
tracer, invocation_support, invocation_trace_support = tracer_and_invocation_support
handler(mock_dynamodb_event, mock_context)
execution_context = ExecutionContextManager.get()
span = execution_context.recorder.get_spans()[0]
assert lambda_event_utils.get_lambda_event_type(
mock_dynamodb_event,
mock_context) == lambda_event_utils.LambdaEventType.DynamoDB
assert span.get_tag(constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['DB']
assert span.get_tag(constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['DYNAMODB']
assert span.get_tag(constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'ExampleTableWithStream'
]
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_DOMAIN_NAME']
) == constants.DomainNames['DB']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_CLASS_NAME']
) == constants.ClassNames['DYNAMODB']
assert invocation_support.get_agent_tag(
constants.SpanTags['TRIGGER_OPERATION_NAMES']) == [
'ExampleTableWithStream'
]
md5_key = hashlib.md5("Id={N: 101}".encode()).hexdigest()
md5_image_1 = hashlib.md5(
"Id={N: 101}, Message={S: New item!}".encode()).hexdigest()
md5_image_2 = hashlib.md5(
"Id={N: 101}, Message={S: This item has changed}".encode()).hexdigest(
)
region = 'eu-west-2'
table_name = 'ExampleTableWithStream'
timestamp = 1480642019
links = [
region + ':' + table_name + ':' + str(timestamp) + ':' + 'SAVE' + ':' +
md5_key, region + ':' + table_name + ':' + str(timestamp + 1) + ':' +
'SAVE' + ':' + md5_key, region + ':' + table_name + ':' +
str(timestamp + 2) + ':' + 'SAVE' + ':' + md5_key, region + ':' +
table_name + ':' + str(timestamp) + ':' + 'SAVE' + ':' + md5_image_1,
region + ':' + table_name + ':' + str(timestamp + 1) + ':' + 'SAVE' +
':' + md5_image_1, region + ':' + table_name + ':' +
str(timestamp + 2) + ':' + 'SAVE' + ':' + md5_image_1, region + ':' +
table_name + ':' + str(timestamp) + ':' + 'SAVE' + ':' + md5_image_2,
region + ':' + table_name + ':' + str(timestamp + 1) + ':' + 'SAVE' +
':' + md5_image_2, region + ':' + table_name + ':' +
str(timestamp + 2) + ':' + 'SAVE' + ':' + md5_image_2
]
assert sorted(invocation_trace_support.get_incoming_trace_links().get(
'incomingTraceLinks')) == sorted(links)
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'