diff --git a/instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py b/instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py index 0649d62893..1e2ec11580 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py @@ -112,7 +112,14 @@ def response_hook(span, service_name, operation_name, result): from opentelemetry.semconv._incubating.attributes.cloud_attributes import ( CLOUD_REGION, ) -from opentelemetry.semconv.trace import SpanAttributes +from opentelemetry.semconv._incubating.attributes.http_attributes import ( + HTTP_STATUS_CODE, +) +from opentelemetry.semconv._incubating.attributes.rpc_attributes import ( + RPC_METHOD, + RPC_SERVICE, + RPC_SYSTEM, +) from opentelemetry.trace import get_tracer from opentelemetry.trace.span import Span @@ -276,9 +283,9 @@ def _patched_api_call(self, original_func, instance, args, kwargs): return original_func(*args, **kwargs) attributes = { - SpanAttributes.RPC_SYSTEM: "aws-api", - SpanAttributes.RPC_SERVICE: call_context.service_id, - SpanAttributes.RPC_METHOD: call_context.operation, + RPC_SYSTEM: "aws-api", + RPC_SERVICE: call_context.service_id, + RPC_METHOD: call_context.operation, CLOUD_REGION: call_context.region, **get_server_attributes(call_context.endpoint_url), } @@ -375,7 +382,7 @@ def _apply_response_attributes(span: Span, result): status_code = metadata.get("HTTPStatusCode") if status_code is not None: - span.set_attribute(SpanAttributes.HTTP_STATUS_CODE, status_code) + span.set_attribute(HTTP_STATUS_CODE, status_code) def _determine_call_context( diff --git a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_dynamodb.py b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_dynamodb.py index de4fc72153..8fe5bc6dc6 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_dynamodb.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_dynamodb.py @@ -23,7 +23,37 @@ _BotocoreInstrumentorContext, _DynamoDbExtension, ) -from opentelemetry.semconv.trace import SpanAttributes +from opentelemetry.semconv._incubating.attributes.aws_attributes import ( + AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, + AWS_DYNAMODB_ATTRIBUTES_TO_GET, + AWS_DYNAMODB_CONSISTENT_READ, + AWS_DYNAMODB_CONSUMED_CAPACITY, + AWS_DYNAMODB_COUNT, + AWS_DYNAMODB_EXCLUSIVE_START_TABLE, + AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, + AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, + AWS_DYNAMODB_INDEX_NAME, + AWS_DYNAMODB_ITEM_COLLECTION_METRICS, + AWS_DYNAMODB_LIMIT, + AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, + AWS_DYNAMODB_PROJECTION, + AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, + AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, + AWS_DYNAMODB_SCAN_FORWARD, + AWS_DYNAMODB_SCANNED_COUNT, + AWS_DYNAMODB_SEGMENT, + AWS_DYNAMODB_SELECT, + AWS_DYNAMODB_TABLE_COUNT, + AWS_DYNAMODB_TABLE_NAMES, + AWS_DYNAMODB_TOTAL_SEGMENTS, +) +from opentelemetry.semconv.attributes.db_attributes import ( + DB_OPERATION_NAME, + DB_SYSTEM_NAME, +) +from opentelemetry.semconv.attributes.server_attributes import ( + SERVER_ADDRESS, +) from opentelemetry.test.test_base import TestBase from opentelemetry.trace.span import Span @@ -101,24 +131,22 @@ def assert_span(self, operation: str) -> Span: self.assertEqual(1, len(spans)) span = spans[0] - self.assertEqual("dynamodb", span.attributes[SpanAttributes.DB_SYSTEM]) - self.assertEqual( - operation, span.attributes[SpanAttributes.DB_OPERATION] - ) + self.assertEqual("dynamodb", span.attributes[DB_SYSTEM_NAME]) + self.assertEqual(operation, span.attributes[DB_OPERATION_NAME]) self.assertEqual( "dynamodb.us-west-2.amazonaws.com", - span.attributes[SpanAttributes.NET_PEER_NAME], + span.attributes[SERVER_ADDRESS], ) return span def assert_table_names(self, span: Span, *table_names): self.assertEqual( tuple(table_names), - span.attributes[SpanAttributes.AWS_DYNAMODB_TABLE_NAMES], + span.attributes[AWS_DYNAMODB_TABLE_NAMES], ) def assert_consumed_capacity(self, span: Span, *table_names): - cap = span.attributes[SpanAttributes.AWS_DYNAMODB_CONSUMED_CAPACITY] + cap = span.attributes[AWS_DYNAMODB_CONSUMED_CAPACITY] self.assertEqual(len(cap), len(table_names)) cap_tables = set() for item in cap: @@ -129,52 +157,40 @@ def assert_consumed_capacity(self, span: Span, *table_names): self.assertIn(table_name, cap_tables) def assert_item_col_metrics(self, span: Span): - actual = span.attributes[ - SpanAttributes.AWS_DYNAMODB_ITEM_COLLECTION_METRICS - ] + actual = span.attributes[AWS_DYNAMODB_ITEM_COLLECTION_METRICS] self.assertIsNotNone(actual) json.loads(actual) def assert_provisioned_read_cap(self, span: Span, expected: int): - actual = span.attributes[ - SpanAttributes.AWS_DYNAMODB_PROVISIONED_READ_CAPACITY - ] + actual = span.attributes[AWS_DYNAMODB_PROVISIONED_READ_CAPACITY] self.assertEqual(expected, actual) def assert_provisioned_write_cap(self, span: Span, expected: int): - actual = span.attributes[ - SpanAttributes.AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY - ] + actual = span.attributes[AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY] self.assertEqual(expected, actual) def assert_consistent_read(self, span: Span, expected: bool): - actual = span.attributes[SpanAttributes.AWS_DYNAMODB_CONSISTENT_READ] + actual = span.attributes[AWS_DYNAMODB_CONSISTENT_READ] self.assertEqual(expected, actual) def assert_projection(self, span: Span, expected: str): - actual = span.attributes[SpanAttributes.AWS_DYNAMODB_PROJECTION] + actual = span.attributes[AWS_DYNAMODB_PROJECTION] self.assertEqual(expected, actual) def assert_attributes_to_get(self, span: Span, *attrs): self.assertEqual( tuple(attrs), - span.attributes[SpanAttributes.AWS_DYNAMODB_ATTRIBUTES_TO_GET], + span.attributes[AWS_DYNAMODB_ATTRIBUTES_TO_GET], ) def assert_index_name(self, span: Span, expected: str): - self.assertEqual( - expected, span.attributes[SpanAttributes.AWS_DYNAMODB_INDEX_NAME] - ) + self.assertEqual(expected, span.attributes[AWS_DYNAMODB_INDEX_NAME]) def assert_limit(self, span: Span, expected: int): - self.assertEqual( - expected, span.attributes[SpanAttributes.AWS_DYNAMODB_LIMIT] - ) + self.assertEqual(expected, span.attributes[AWS_DYNAMODB_LIMIT]) def assert_select(self, span: Span, expected: str): - self.assertEqual( - expected, span.attributes[SpanAttributes.AWS_DYNAMODB_SELECT] - ) + self.assertEqual(expected, span.attributes[AWS_DYNAMODB_SELECT]) def assert_extension_item_col_metrics(self, operation: str): span = self.tracer_provider.get_tracer("test").start_span("test") @@ -259,15 +275,11 @@ def test_create_table(self): self.assert_table_names(span, self.default_table_name) self.assertEqual( (json.dumps(global_sec_idx),), - span.attributes[ - SpanAttributes.AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES - ], + span.attributes[AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES], ) self.assertEqual( (json.dumps(local_sec_idx),), - span.attributes[ - SpanAttributes.AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES - ], + span.attributes[AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES], ) self.assert_provisioned_read_cap(span, 42) @@ -365,12 +377,10 @@ def test_list_tables(self): span = self.assert_span("ListTables") self.assertEqual( "my_table", - span.attributes[SpanAttributes.AWS_DYNAMODB_EXCLUSIVE_START_TABLE], - ) - self.assertEqual( - 1, span.attributes[SpanAttributes.AWS_DYNAMODB_TABLE_COUNT] + span.attributes[AWS_DYNAMODB_EXCLUSIVE_START_TABLE], ) - self.assertEqual(5, span.attributes[SpanAttributes.AWS_DYNAMODB_LIMIT]) + self.assertEqual(1, span.attributes[AWS_DYNAMODB_TABLE_COUNT]) + self.assertEqual(5, span.attributes[AWS_DYNAMODB_LIMIT]) @mock_aws def test_put_item(self): @@ -417,9 +427,7 @@ def test_query(self): span = self.assert_span("Query") self.assert_table_names(span, self.default_table_name) - self.assertTrue( - span.attributes[SpanAttributes.AWS_DYNAMODB_SCAN_FORWARD] - ) + self.assertTrue(span.attributes[AWS_DYNAMODB_SCAN_FORWARD]) self.assert_attributes_to_get(span, "id") self.assert_consistent_read(span, True) self.assert_index_name(span, "lsi") @@ -447,16 +455,10 @@ def test_scan(self): span = self.assert_span("Scan") self.assert_table_names(span, self.default_table_name) - self.assertEqual( - 21, span.attributes[SpanAttributes.AWS_DYNAMODB_SEGMENT] - ) - self.assertEqual( - 17, span.attributes[SpanAttributes.AWS_DYNAMODB_TOTAL_SEGMENTS] - ) - self.assertEqual(1, span.attributes[SpanAttributes.AWS_DYNAMODB_COUNT]) - self.assertEqual( - 1, span.attributes[SpanAttributes.AWS_DYNAMODB_SCANNED_COUNT] - ) + self.assertEqual(21, span.attributes[AWS_DYNAMODB_SEGMENT]) + self.assertEqual(17, span.attributes[AWS_DYNAMODB_TOTAL_SEGMENTS]) + self.assertEqual(1, span.attributes[AWS_DYNAMODB_COUNT]) + self.assertEqual(1, span.attributes[AWS_DYNAMODB_SCANNED_COUNT]) self.assert_attributes_to_get(span, "id", "idl") self.assert_consistent_read(span, True) self.assert_index_name(span, "lsi") @@ -517,11 +519,9 @@ def test_update_table(self): self.assert_provisioned_write_cap(span, 19) self.assertEqual( (json.dumps(attr_definition),), - span.attributes[SpanAttributes.AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS], + span.attributes[AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS], ) self.assertEqual( (json.dumps(global_sec_idx_updates),), - span.attributes[ - SpanAttributes.AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES - ], + span.attributes[AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES], ) diff --git a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_instrumentation.py b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_instrumentation.py index 6ebb074deb..45152f57c1 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_instrumentation.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_instrumentation.py @@ -30,7 +30,23 @@ from opentelemetry.semconv._incubating.attributes.cloud_attributes import ( CLOUD_REGION, ) -from opentelemetry.semconv.trace import SpanAttributes +from opentelemetry.semconv._incubating.attributes.http_attributes import ( + HTTP_STATUS_CODE, +) +from opentelemetry.semconv._incubating.attributes.rpc_attributes import ( + RPC_METHOD, + RPC_SERVICE, + RPC_SYSTEM, +) +from opentelemetry.semconv.attributes.exception_attributes import ( + EXCEPTION_MESSAGE, + EXCEPTION_STACKTRACE, + EXCEPTION_TYPE, +) +from opentelemetry.semconv.attributes.server_attributes import ( + SERVER_ADDRESS, + SERVER_PORT, +) from opentelemetry.test.mock_textmap import MockTextMapPropagator from opentelemetry.test.test_base import TestBase from opentelemetry.trace.span import format_span_id, format_trace_id @@ -61,15 +77,15 @@ def _make_client(self, service: str): def _default_span_attributes(self, service: str, operation: str): return { - SpanAttributes.RPC_SYSTEM: "aws-api", - SpanAttributes.RPC_SERVICE: service, - SpanAttributes.RPC_METHOD: operation, + RPC_SYSTEM: "aws-api", + RPC_SERVICE: service, + RPC_METHOD: operation, CLOUD_REGION: self.region, "retry_attempts": 0, - SpanAttributes.HTTP_STATUS_CODE: 200, + HTTP_STATUS_CODE: 200, # Some services like IAM or STS have a global endpoint and exclude specified region. - SpanAttributes.SERVER_ADDRESS: f"{service.lower()}.{'' if self.region == 'aws-global' else self.region + '.'}amazonaws.com", - SpanAttributes.SERVER_PORT: 443, + SERVER_ADDRESS: f"{service.lower()}.{'' if self.region == 'aws-global' else self.region + '.'}amazonaws.com", + SERVER_PORT: 443, } def assert_only_span(self): @@ -150,16 +166,16 @@ def test_exception(self): span = spans[0] expected = self._default_span_attributes("S3", "ListObjects") - expected.pop(SpanAttributes.HTTP_STATUS_CODE) + expected.pop(HTTP_STATUS_CODE) expected.pop("retry_attempts") self.assertEqual(expected, span.attributes) self.assertIs(span.status.status_code, trace_api.StatusCode.ERROR) self.assertEqual(1, len(span.events)) event = span.events[0] - self.assertIn(SpanAttributes.EXCEPTION_STACKTRACE, event.attributes) - self.assertIn(SpanAttributes.EXCEPTION_TYPE, event.attributes) - self.assertIn(SpanAttributes.EXCEPTION_MESSAGE, event.attributes) + self.assertIn(EXCEPTION_STACKTRACE, event.attributes) + self.assertIn(EXCEPTION_TYPE, event.attributes) + self.assertIn(EXCEPTION_MESSAGE, event.attributes) @mock_aws def test_s3_client(self): @@ -337,7 +353,7 @@ def test_sts_client(self): span = self.assert_only_span() expected = self._default_span_attributes("STS", "GetCallerIdentity") expected["aws.request_id"] = ANY - expected[SpanAttributes.SERVER_ADDRESS] = "sts.amazonaws.com" + expected[SERVER_ADDRESS] = "sts.amazonaws.com" # check for exact attribute set to make sure not to leak any sts secrets self.assertEqual(expected, dict(span.attributes)) @@ -515,8 +531,8 @@ def test_server_attributes(self): "EC2", "DescribeInstances", attributes={ - SpanAttributes.SERVER_ADDRESS: f"ec2.{self.region}.amazonaws.com", - SpanAttributes.SERVER_PORT: 443, + SERVER_ADDRESS: f"ec2.{self.region}.amazonaws.com", + SERVER_PORT: 443, }, ) self.memory_exporter.clear() @@ -528,8 +544,8 @@ def test_server_attributes(self): "IAM", "ListUsers", attributes={ - SpanAttributes.SERVER_ADDRESS: "iam.amazonaws.com", - SpanAttributes.SERVER_PORT: 443, + SERVER_ADDRESS: "iam.amazonaws.com", + SERVER_PORT: 443, CLOUD_REGION: "aws-global", }, ) @@ -552,7 +568,7 @@ def test_server_attributes_with_custom_endpoint(self): "S3", "ListBuckets", attributes={ - SpanAttributes.SERVER_ADDRESS: "proxy.amazon.org", - SpanAttributes.SERVER_PORT: 2025, + SERVER_ADDRESS: "proxy.amazon.org", + SERVER_PORT: 2025, }, ) diff --git a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_lambda.py b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_lambda.py index 098edfc896..323e946657 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_lambda.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_lambda.py @@ -27,7 +27,16 @@ _LambdaExtension, ) from opentelemetry.propagate import get_global_textmap, set_global_textmap -from opentelemetry.semconv.trace import SpanAttributes +from opentelemetry.semconv._incubating.attributes.faas_attributes import ( + FAAS_INVOKED_NAME, + FAAS_INVOKED_PROVIDER, + FAAS_INVOKED_REGION, +) +from opentelemetry.semconv._incubating.attributes.rpc_attributes import ( + RPC_METHOD, + RPC_SERVICE, + RPC_SYSTEM, +) from opentelemetry.test.mock_textmap import MockTextMapPropagator from opentelemetry.test.test_base import TestBase from opentelemetry.trace.span import Span @@ -73,22 +82,16 @@ def assert_span(self, operation: str) -> Span: self.assertEqual(1, len(spans)) span = spans[0] - self.assertEqual(operation, span.attributes[SpanAttributes.RPC_METHOD]) - self.assertEqual("Lambda", span.attributes[SpanAttributes.RPC_SERVICE]) - self.assertEqual("aws-api", span.attributes[SpanAttributes.RPC_SYSTEM]) + self.assertEqual(operation, span.attributes[RPC_METHOD]) + self.assertEqual("Lambda", span.attributes[RPC_SERVICE]) + self.assertEqual("aws-api", span.attributes[RPC_SYSTEM]) return span def assert_invoke_span(self, function_name: str) -> Span: span = self.assert_span("Invoke") - self.assertEqual( - "aws", span.attributes[SpanAttributes.FAAS_INVOKED_PROVIDER] - ) - self.assertEqual( - self.region, span.attributes[SpanAttributes.FAAS_INVOKED_REGION] - ) - self.assertEqual( - function_name, span.attributes[SpanAttributes.FAAS_INVOKED_NAME] - ) + self.assertEqual("aws", span.attributes[FAAS_INVOKED_PROVIDER]) + self.assertEqual(self.region, span.attributes[FAAS_INVOKED_REGION]) + self.assertEqual(function_name, span.attributes[FAAS_INVOKED_NAME]) return span @staticmethod @@ -182,6 +185,4 @@ def test_invoke_parse_arn(self): attributes = {} extension.extract_attributes(attributes) - self.assertEqual( - function_name, attributes[SpanAttributes.FAAS_INVOKED_NAME] - ) + self.assertEqual(function_name, attributes[FAAS_INVOKED_NAME]) diff --git a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sns.py b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sns.py index 38bdfc28a3..bfa7cc269f 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sns.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sns.py @@ -21,9 +21,9 @@ from moto import mock_aws from opentelemetry.instrumentation.botocore import BotocoreInstrumentor -from opentelemetry.semconv.trace import ( - MessagingDestinationKindValues, - SpanAttributes, +from opentelemetry.semconv._incubating.attributes.messaging_attributes import ( + MESSAGING_DESTINATION_NAME, + MESSAGING_SYSTEM, ) from opentelemetry.test.test_base import TestBase from opentelemetry.trace import SpanKind @@ -80,9 +80,7 @@ def assert_span(self, name: str) -> Span: self.assertEqual(SpanKind.PRODUCER, span.kind) self.assertEqual(name, span.name) - self.assertEqual( - "aws.sns", span.attributes[SpanAttributes.MESSAGING_SYSTEM] - ) + self.assertEqual("aws.sns", span.attributes[MESSAGING_SYSTEM]) return span @@ -113,17 +111,13 @@ def _test_publish_to_arn(self, arg_name: str): ) span = self.assert_span(f"{self.topic_name} send") - self.assertEqual( - MessagingDestinationKindValues.TOPIC.value, - span.attributes[SpanAttributes.MESSAGING_DESTINATION_KIND], - ) self.assertEqual( self.topic_arn, - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], ) self.assertEqual( target_arn, - span.attributes[SpanAttributes.MESSAGING_DESTINATION_NAME], + span.attributes[MESSAGING_DESTINATION_NAME], ) @mock_aws @@ -137,7 +131,7 @@ def test_publish_to_phone_number(self): span = self.assert_span("phone_number send") self.assertEqual( "phone_number:**", - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], ) @mock_aws @@ -184,17 +178,13 @@ def test_publish_batch_to_topic(self): ) span = self.assert_span(f"{self.topic_name} send") - self.assertEqual( - MessagingDestinationKindValues.TOPIC.value, - span.attributes[SpanAttributes.MESSAGING_DESTINATION_KIND], - ) self.assertEqual( topic_arn, - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], ) self.assertEqual( topic_arn, - span.attributes[SpanAttributes.MESSAGING_DESTINATION_NAME], + span.attributes[MESSAGING_DESTINATION_NAME], ) self.assert_injected_span(message1_attrs, span) diff --git a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sqs.py b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sqs.py index cdf39e4ece..740fe278eb 100644 --- a/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sqs.py +++ b/instrumentation/opentelemetry-instrumentation-botocore/tests/test_botocore_sqs.py @@ -2,7 +2,14 @@ from moto import mock_aws from opentelemetry.instrumentation.botocore import BotocoreInstrumentor -from opentelemetry.semconv.trace import SpanAttributes +from opentelemetry.semconv._incubating.attributes.messaging_attributes import ( + MESSAGING_DESTINATION_NAME, + MESSAGING_MESSAGE_ID, + MESSAGING_SYSTEM, +) +from opentelemetry.semconv.attributes.server_attributes import ( + SERVER_ADDRESS, +) from opentelemetry.test.test_base import TestBase @@ -36,18 +43,14 @@ def test_sqs_messaging_send_message(self): assert spans self.assertEqual(len(spans), 2) span = spans[1] + self.assertEqual(span.attributes[MESSAGING_SYSTEM], "aws.sqs") + self.assertEqual(span.attributes[SERVER_ADDRESS], queue_url) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_SYSTEM], "aws.sqs" - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_URL], queue_url - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], "test_queue_name", ) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_MESSAGE_ID], + span.attributes[MESSAGING_MESSAGE_ID], response["MessageId"], ) @@ -70,18 +73,14 @@ def test_sqs_messaging_send_message_batch(self): self.assertEqual(len(spans), 2) span = spans[1] self.assertEqual(span.attributes["rpc.method"], "SendMessageBatch") + self.assertEqual(span.attributes[MESSAGING_SYSTEM], "aws.sqs") + self.assertEqual(span.attributes[SERVER_ADDRESS], queue_url) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_SYSTEM], "aws.sqs" - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_URL], queue_url - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], "test_queue_name", ) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_MESSAGE_ID], + span.attributes[MESSAGING_MESSAGE_ID], response["Successful"][0]["MessageId"], ) @@ -101,18 +100,14 @@ def test_sqs_messaging_receive_message(self): self.assertEqual(len(spans), 3) span = spans[-1] self.assertEqual(span.attributes["rpc.method"], "ReceiveMessage") + self.assertEqual(span.attributes[MESSAGING_SYSTEM], "aws.sqs") + self.assertEqual(span.attributes[SERVER_ADDRESS], queue_url) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_SYSTEM], "aws.sqs" - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_URL], queue_url - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_DESTINATION], + span.attributes[MESSAGING_DESTINATION_NAME], "test_queue_name", ) self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_MESSAGE_ID], + span.attributes[MESSAGING_MESSAGE_ID], message_result["Messages"][0]["MessageId"], ) @@ -128,9 +123,5 @@ def test_sqs_messaging_failed_operation(self): self.assertEqual(len(spans), 1) span = spans[0] self.assertEqual(span.attributes["rpc.method"], "SendMessage") - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_SYSTEM], "aws.sqs" - ) - self.assertEqual( - span.attributes[SpanAttributes.MESSAGING_URL], "non-existing" - ) + self.assertEqual(span.attributes[MESSAGING_SYSTEM], "aws.sqs") + self.assertEqual(span.attributes[SERVER_ADDRESS], "non-existing")