From b70cbc11154056312e6e48cc89349013183ffb67 Mon Sep 17 00:00:00 2001 From: Trask Stalnaker Date: Sun, 17 Sep 2023 13:46:20 -0700 Subject: [PATCH 01/17] Upload java agent jar to PR builds (#9477) --- .github/workflows/build-common.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/build-common.yml b/.github/workflows/build-common.yml index e628395535a2..410c5a76b239 100644 --- a/.github/workflows/build-common.yml +++ b/.github/workflows/build-common.yml @@ -172,6 +172,11 @@ jobs: exit 1 fi + - name: Upload agent jar + uses: actions/upload-artifact@v3 + with: + path: javaagent/build/libs/opentelemetry-javaagent-*-SNAPSHOT.jar + test: name: test${{ matrix.test-partition }} (${{ matrix.test-java-version }}, ${{ matrix.vm }}) runs-on: ubuntu-latest From 27a14e12a8efa5829c70e11f8cf4ae3c718346e5 Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Mon, 18 Sep 2023 13:08:21 +0300 Subject: [PATCH 02/17] Rename loop variable (#9487) --- .../instrumentationannotations/SpanAttributeUtil.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/instrumentation/kotlinx-coroutines/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/SpanAttributeUtil.java b/instrumentation/kotlinx-coroutines/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/SpanAttributeUtil.java index 217443619357..f67fe3434272 100644 --- a/instrumentation/kotlinx-coroutines/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/SpanAttributeUtil.java +++ b/instrumentation/kotlinx-coroutines/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/SpanAttributeUtil.java @@ -83,9 +83,9 @@ private static String getParameterName(MethodNode methodNode, int parameter) { private static Object getAnnotationValue(AnnotationNode annotationNode) { if (annotationNode.values != null && !annotationNode.values.isEmpty()) { List values = annotationNode.values; - for (int j = 0; j < values.size(); j += 2) { - String attributeName = (String) values.get(j); - Object attributeValue = values.get(j + 1); + for (int i = 0; i < values.size(); i += 2) { + String attributeName = (String) values.get(i); + Object attributeValue = values.get(i + 1); if ("value".equals(attributeName)) { return attributeValue; } From 331aa04e351b46c57181fd28d0a3e6aabd15d880 Mon Sep 17 00:00:00 2001 From: LMarkie Date: Mon, 18 Sep 2023 13:39:34 +0100 Subject: [PATCH 03/17] Convert JMS Groovy tests to Java (#9476) --- .../src/jms2Test/groovy/Jms2Test.groovy | 317 -------------- .../jms/v1_1/Jms2InstrumentationTest.java | 320 ++++++++++++++ .../javaagent/src/test/groovy/Jms1Test.groovy | 382 ---------------- .../jms/v1_1/Jms1InstrumentationTest.java | 409 ++++++++++++++++++ 4 files changed, 729 insertions(+), 699 deletions(-) delete mode 100644 instrumentation/jms/jms-1.1/javaagent/src/jms2Test/groovy/Jms2Test.groovy create mode 100644 instrumentation/jms/jms-1.1/javaagent/src/jms2Test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms2InstrumentationTest.java delete mode 100644 instrumentation/jms/jms-1.1/javaagent/src/test/groovy/Jms1Test.groovy create mode 100644 instrumentation/jms/jms-1.1/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms1InstrumentationTest.java diff --git a/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/groovy/Jms2Test.groovy b/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/groovy/Jms2Test.groovy deleted file mode 100644 index c36d674e3e5c..000000000000 --- a/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/groovy/Jms2Test.groovy +++ /dev/null @@ -1,317 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -import io.opentelemetry.instrumentation.test.AgentInstrumentationSpecification -import io.opentelemetry.instrumentation.test.asserts.TraceAssert -import io.opentelemetry.sdk.trace.data.SpanData -import io.opentelemetry.semconv.SemanticAttributes -import org.hornetq.api.core.TransportConfiguration -import org.hornetq.api.core.client.HornetQClient -import org.hornetq.api.jms.HornetQJMSClient -import org.hornetq.api.jms.JMSFactoryType -import org.hornetq.core.config.Configuration -import org.hornetq.core.config.CoreQueueConfiguration -import org.hornetq.core.config.impl.ConfigurationImpl -import org.hornetq.core.remoting.impl.invm.InVMAcceptorFactory -import org.hornetq.core.remoting.impl.invm.InVMConnectorFactory -import org.hornetq.core.server.HornetQServer -import org.hornetq.core.server.HornetQServers -import org.hornetq.jms.client.HornetQTextMessage -import spock.lang.Shared - -import javax.jms.Message -import javax.jms.MessageListener -import javax.jms.Session -import javax.jms.TextMessage -import java.nio.file.Files -import java.util.concurrent.CountDownLatch -import java.util.concurrent.atomic.AtomicReference - -import static io.opentelemetry.api.trace.SpanKind.CONSUMER -import static io.opentelemetry.api.trace.SpanKind.PRODUCER - -class Jms2Test extends AgentInstrumentationSpecification { - @Shared - HornetQServer server - @Shared - String messageText = "a message" - @Shared - Session session - - HornetQTextMessage message = session.createTextMessage(messageText) - - def setupSpec() { - def tempDir = Files.createTempDirectory("jmsTempDir").toFile() - tempDir.deleteOnExit() - - Configuration config = new ConfigurationImpl() - config.bindingsDirectory = tempDir.path - config.journalDirectory = tempDir.path - config.createBindingsDir = false - config.createJournalDir = false - config.securityEnabled = false - config.persistenceEnabled = false - config.setQueueConfigurations([new CoreQueueConfiguration("someQueue", "someQueue", null, true)]) - config.setAcceptorConfigurations([new TransportConfiguration(InVMAcceptorFactory.name)].toSet()) - - server = HornetQServers.newHornetQServer(config) - server.start() - - def serverLocator = HornetQClient.createServerLocatorWithoutHA(new TransportConfiguration(InVMConnectorFactory.name)) - def sf = serverLocator.createSessionFactory() - def clientSession = sf.createSession(false, false, false) - clientSession.createQueue("jms.queue.someQueue", "jms.queue.someQueue", true) - clientSession.createQueue("jms.topic.someTopic", "jms.topic.someTopic", true) - clientSession.close() - sf.close() - serverLocator.close() - - def connectionFactory = HornetQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, - new TransportConfiguration(InVMConnectorFactory.name)) - - def connection = connectionFactory.createConnection() - connection.start() - session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE) - session.run() - } - - def cleanupSpec() { - server.stop() - } - - def "sending a message to #destinationName generates spans"() { - setup: - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - - runWithSpan("producer parent") { - producer.send(message) - } - - TextMessage receivedMessage = runWithSpan("consumer parent") { - return consumer.receive() as TextMessage - } - String messageId = receivedMessage.getJMSMessageID() - - expect: - receivedMessage.text == messageText - assertTraces(2) { - SpanData producerSpanData - trace(0, 2) { - span(0) { - name "producer parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0)) - - producerSpanData = span(1) - } - trace(1, 2) { - span(0) { - name "consumer parent" - hasNoParent() - } - consumerSpan(it, 1, destinationName, messageId, "receive", span(0), producerSpanData) - } - } - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "sending to a MessageListener on #destinationName generates a span"() { - setup: - def lock = new CountDownLatch(1) - def messageRef = new AtomicReference() - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - consumer.setMessageListener new MessageListener() { - @Override - void onMessage(Message message) { - lock.await() // ensure the producer trace is reported first. - messageRef.set(message as TextMessage) - } - } - - runWithSpan("parent") { - producer.send(message) - } - lock.countDown() - - expect: - assertTraces(1) { - trace(0, 3) { - span(0) { - name "parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0)) - consumerSpan(it, 2, destinationName, messageRef.get().getJMSMessageID(), "process", span(1)) - } - } - // This check needs to go after all traces have been accounted for - messageRef.get().text == messageText - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "failing to receive message with receiveNoWait on #destinationName works"() { - setup: - def consumer = session.createConsumer(destination) - - // Receive with timeout - Message receivedMessage = consumer.receiveNoWait() - - expect: - receivedMessage == null - // span is not created if no message is received - assertTraces(0) {} - - cleanup: - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - } - - def "failing to receive message with wait(timeout) on #destinationName works"() { - setup: - def consumer = session.createConsumer(destination) - - // Receive with timeout - Message receivedMessage = consumer.receive(100) - - expect: - receivedMessage == null - // span is not created if no message is received - assertTraces(0) {} - - cleanup: - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - } - - def "sending a message to #destinationName with explicit destination propagates context"() { - given: - def producer = session.createProducer(null) - def consumer = session.createConsumer(destination) - - def lock = new CountDownLatch(1) - def messageRef = new AtomicReference() - consumer.setMessageListener new MessageListener() { - @Override - void onMessage(Message message) { - lock.await() // ensure the producer trace is reported first. - messageRef.set(message as TextMessage) - } - } - - when: - runWithSpan("parent") { - producer.send(destination, message) - } - lock.countDown() - - then: - assertTraces(1) { - trace(0, 3) { - span(0) { - name "parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0)) - consumerSpan(it, 2, destinationName, messageRef.get().getJMSMessageID(), "process", span(1)) - } - } - // This check needs to go after all traces have been accounted for - messageRef.get().text == messageText - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - static producerSpan(TraceAssert trace, int index, String destinationName, SpanData parentSpan = null) { - trace.span(index) { - name destinationName + " publish" - kind PRODUCER - if (parentSpan == null) { - hasNoParent() - } else { - childOf(parentSpan) - } - attributes { - "$SemanticAttributes.MESSAGING_SYSTEM" "jms" - "$SemanticAttributes.MESSAGING_DESTINATION_NAME" destinationName - if (destinationName == "(temporary)") { - "$SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY" true - } - "$SemanticAttributes.MESSAGING_MESSAGE_ID" String - } - } - } - - // passing messageId = null will verify message.id is not captured, - // passing messageId = "" will verify message.id is captured (but won't verify anything about the value), - // any other value for messageId will verify that message.id is captured and has that same value - static consumerSpan(TraceAssert trace, int index, String destinationName, String messageId, String operation, SpanData parentSpan, SpanData linkedSpan = null) { - trace.span(index) { - name destinationName + " " + operation - kind CONSUMER - if (parentSpan == null) { - hasNoParent() - } else { - childOf(parentSpan) - } - if (linkedSpan == null) { - hasNoLinks() - } else { - hasLink(linkedSpan) - } - attributes { - "$SemanticAttributes.MESSAGING_SYSTEM" "jms" - "$SemanticAttributes.MESSAGING_DESTINATION_NAME" destinationName - "$SemanticAttributes.MESSAGING_OPERATION" operation - if (messageId != null) { - //In some tests we don't know exact messageId, so we pass "" and verify just the existence of the attribute - "$SemanticAttributes.MESSAGING_MESSAGE_ID" { it == messageId || messageId == "" } - } - if (destinationName == "(temporary)") { - "$SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY" true - } - } - } - } -} diff --git a/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms2InstrumentationTest.java b/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms2InstrumentationTest.java new file mode 100644 index 000000000000..bf7e6d1bf0e5 --- /dev/null +++ b/instrumentation/jms/jms-1.1/javaagent/src/jms2Test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms2InstrumentationTest.java @@ -0,0 +1,320 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.jms.v1_1; + +import static io.opentelemetry.api.trace.SpanKind.CONSUMER; +import static io.opentelemetry.api.trace.SpanKind.PRODUCER; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.sdk.testing.assertj.AttributeAssertion; +import io.opentelemetry.sdk.trace.data.LinkData; +import io.opentelemetry.sdk.trace.data.SpanData; +import io.opentelemetry.semconv.SemanticAttributes; +import java.io.File; +import java.nio.file.Files; +import java.util.Collections; +import java.util.HashSet; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; +import javax.jms.Connection; +import javax.jms.Destination; +import javax.jms.JMSException; +import javax.jms.Message; +import javax.jms.MessageConsumer; +import javax.jms.MessageProducer; +import javax.jms.Session; +import javax.jms.TextMessage; +import org.assertj.core.api.AbstractAssert; +import org.hornetq.api.core.TransportConfiguration; +import org.hornetq.api.core.client.ClientSession; +import org.hornetq.api.core.client.ClientSessionFactory; +import org.hornetq.api.core.client.HornetQClient; +import org.hornetq.api.core.client.ServerLocator; +import org.hornetq.api.jms.HornetQJMSClient; +import org.hornetq.api.jms.JMSFactoryType; +import org.hornetq.core.config.Configuration; +import org.hornetq.core.config.CoreQueueConfiguration; +import org.hornetq.core.config.impl.ConfigurationImpl; +import org.hornetq.core.remoting.impl.invm.InVMAcceptorFactory; +import org.hornetq.core.remoting.impl.invm.InVMConnectorFactory; +import org.hornetq.core.server.HornetQServer; +import org.hornetq.core.server.HornetQServers; +import org.hornetq.jms.client.HornetQConnectionFactory; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +public class Jms2InstrumentationTest { + + @RegisterExtension + static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); + + @RegisterExtension static final AutoCleanupExtension cleanup = AutoCleanupExtension.create(); + + static HornetQServer server; + static HornetQConnectionFactory connectionFactory; + static Session session; + static Connection connection; + + @BeforeAll + static void setUp() throws Exception { + File tempDir = Files.createTempDirectory("jmsTempDir").toFile(); + tempDir.deleteOnExit(); + + Configuration config = new ConfigurationImpl(); + config.setBindingsDirectory(tempDir.getPath()); + config.setJournalDirectory(tempDir.getPath()); + config.setCreateBindingsDir(false); + config.setCreateJournalDir(false); + config.setSecurityEnabled(false); + config.setPersistenceEnabled(false); + config.setQueueConfigurations( + Collections.singletonList( + new CoreQueueConfiguration("someQueue", "someQueue", null, true))); + config.setAcceptorConfigurations( + new HashSet<>( + Collections.singletonList( + new TransportConfiguration(InVMAcceptorFactory.class.getName())))); + + server = HornetQServers.newHornetQServer(config); + server.start(); + + ServerLocator serverLocator = + HornetQClient.createServerLocatorWithoutHA( + new TransportConfiguration(InVMConnectorFactory.class.getName())); + ClientSessionFactory sf = serverLocator.createSessionFactory(); + ClientSession clientSession = sf.createSession(false, false, false); + clientSession.createQueue("jms.queue.someQueue", "jms.queue.someQueue", true); + clientSession.createQueue("jms.topic.someTopic", "jms.topic.someTopic", true); + clientSession.close(); + sf.close(); + serverLocator.close(); + + connectionFactory = + HornetQJMSClient.createConnectionFactoryWithoutHA( + JMSFactoryType.CF, new TransportConfiguration(InVMConnectorFactory.class.getName())); + connection = connectionFactory.createConnection(); + connection.start(); + session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); + session.run(); + } + + @AfterAll + static void tearDown() throws Exception { + if (session != null) { + session.close(); + } + if (connection != null) { + connection.close(); + } + if (connectionFactory != null) { + connectionFactory.close(); + } + if (server != null) { + server.stop(); + } + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void testMessageConsumer( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws JMSException { + + // given + Destination destination = destinationFactory.create(session); + TextMessage sentMessage = session.createTextMessage("a message"); + + MessageProducer producer = session.createProducer(destination); + cleanup.deferCleanup(producer); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer); + + // when + testing.runWithSpan("producer parent", () -> producer.send(sentMessage)); + + TextMessage receivedMessage = + testing.runWithSpan("consumer parent", () -> (TextMessage) consumer.receive()); + + // then + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + AtomicReference producerSpan = new AtomicReference<>(); + testing.waitAndAssertTraces( + trace -> { + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary))); + + producerSpan.set(trace.getSpan(1)); + }, + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("consumer parent").hasNoParent(), + span -> + span.hasName(destinationName + " receive") + .hasKind(CONSUMER) + .hasParent(trace.getSpan(0)) + .hasLinks(LinkData.create(producerSpan.get().getSpanContext())) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "receive"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)))); + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void testMessageListener( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws Exception { + + // given + Destination destination = destinationFactory.create(session); + TextMessage sentMessage = session.createTextMessage("a message"); + + MessageProducer producer = session.createProducer(null); + cleanup.deferCleanup(producer); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer); + + CompletableFuture receivedMessageFuture = new CompletableFuture<>(); + consumer.setMessageListener( + message -> + testing.runWithSpan( + "consumer", () -> receivedMessageFuture.complete((TextMessage) message))); + + // when + testing.runWithSpan("producer parent", () -> producer.send(destination, sentMessage)); + + // then + TextMessage receivedMessage = receivedMessageFuture.get(10, TimeUnit.SECONDS); + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + testing.waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)), + span -> + span.hasName(destinationName + " process") + .hasKind(CONSUMER) + .hasParent(trace.getSpan(1)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "process"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)), + span -> span.hasName("consumer").hasParent(trace.getSpan(2)))); + } + + @ArgumentsSource(EmptyReceiveArgumentsProvider.class) + @ParameterizedTest + void shouldNotEmitTelemetryOnEmptyReceive( + DestinationFactory destinationFactory, MessageReceiver receiver) throws JMSException { + + // given + Destination destination = destinationFactory.create(session); + + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer); + + // when + Message message = receiver.receive(consumer); + + // then + assertThat(message).isNull(); + + testing.waitForTraces(0); + } + + private static AttributeAssertion messagingTempDestination(boolean isTemporary) { + return isTemporary + ? equalTo(SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY, true) + : satisfies(SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY, AbstractAssert::isNull); + } + + static final class EmptyReceiveArgumentsProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) { + DestinationFactory topic = session -> session.createTopic("someTopic"); + DestinationFactory queue = session -> session.createQueue("someQueue"); + MessageReceiver receive = consumer -> consumer.receive(100); + MessageReceiver receiveNoWait = MessageConsumer::receiveNoWait; + + return Stream.of( + arguments(topic, receive), + arguments(queue, receive), + arguments(topic, receiveNoWait), + arguments(queue, receiveNoWait)); + } + } + + static final class DestinationsProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) { + DestinationFactory topic = session -> session.createTopic("someTopic"); + DestinationFactory queue = session -> session.createQueue("someQueue"); + DestinationFactory tempTopic = Session::createTemporaryTopic; + DestinationFactory tempQueue = Session::createTemporaryQueue; + + return Stream.of( + arguments(topic, "someTopic", false), + arguments(queue, "someQueue", false), + arguments(tempTopic, "(temporary)", true), + arguments(tempQueue, "(temporary)", true)); + } + } + + @FunctionalInterface + interface DestinationFactory { + + Destination create(Session session) throws JMSException; + } + + @FunctionalInterface + interface MessageReceiver { + + Message receive(MessageConsumer consumer) throws JMSException; + } +} diff --git a/instrumentation/jms/jms-1.1/javaagent/src/test/groovy/Jms1Test.groovy b/instrumentation/jms/jms-1.1/javaagent/src/test/groovy/Jms1Test.groovy deleted file mode 100644 index 7672517cbfec..000000000000 --- a/instrumentation/jms/jms-1.1/javaagent/src/test/groovy/Jms1Test.groovy +++ /dev/null @@ -1,382 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -import io.opentelemetry.instrumentation.test.AgentInstrumentationSpecification -import io.opentelemetry.instrumentation.test.asserts.TraceAssert -import io.opentelemetry.sdk.trace.data.SpanData -import io.opentelemetry.semconv.SemanticAttributes -import org.apache.activemq.ActiveMQConnectionFactory -import org.apache.activemq.command.ActiveMQTextMessage -import org.slf4j.Logger -import org.slf4j.LoggerFactory -import org.testcontainers.containers.GenericContainer -import org.testcontainers.containers.output.Slf4jLogConsumer -import spock.lang.Shared -import spock.lang.Unroll - -import javax.jms.Connection -import javax.jms.Message -import javax.jms.MessageListener -import javax.jms.Session -import javax.jms.TextMessage -import java.util.concurrent.CountDownLatch -import java.util.concurrent.atomic.AtomicReference - -import static io.opentelemetry.api.trace.SpanKind.CONSUMER -import static io.opentelemetry.api.trace.SpanKind.PRODUCER - -@Unroll -class Jms1Test extends AgentInstrumentationSpecification { - - private static final Logger logger = LoggerFactory.getLogger(Jms1Test) - - private static final GenericContainer broker = new GenericContainer("rmohr/activemq:latest") - .withExposedPorts(61616, 8161) - .withLogConsumer(new Slf4jLogConsumer(logger)) - - @Shared - String messageText = "a message" - @Shared - Session session - - ActiveMQTextMessage message = session.createTextMessage(messageText) - - def setupSpec() { - broker.start() - ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:" + broker.getMappedPort(61616)) - - Connection connection = connectionFactory.createConnection() - connection.start() - session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE) - } - - def cleanupSpec() { - broker.stop() - } - - def "sending a message to #destinationName generates spans"() { - setup: - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - - runWithSpan("producer parent") { - producer.send(message) - } - - TextMessage receivedMessage = runWithSpan("consumer parent") { - return consumer.receive() as TextMessage - } - String messageId = receivedMessage.getJMSMessageID() - - expect: - receivedMessage.text == messageText - assertTraces(2) { - SpanData producerSpanData - trace(0, 2) { - span(0) { - name "producer parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0)) - - producerSpanData = span(1) - } - trace(1, 2) { - span(0) { - name "consumer parent" - hasNoParent() - } - consumerSpan(it, 1, destinationName, messageId, "receive", span(0), producerSpanData) - } - } - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "sending to a MessageListener on #destinationName generates a span"() { - setup: - def lock = new CountDownLatch(1) - def messageRef = new AtomicReference() - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - consumer.setMessageListener new MessageListener() { - @Override - void onMessage(Message message) { - lock.await() // ensure the producer trace is reported first. - messageRef.set(message as TextMessage) - } - } - - producer.send(message) - lock.countDown() - - expect: - assertTraces(1) { - trace(0, 2) { - producerSpan(it, 0, destinationName) - consumerSpan(it, 1, destinationName, messageRef.get().getJMSMessageID(), "process", span(0)) - } - } - // This check needs to go after all traces have been accounted for - messageRef.get().text == messageText - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "failing to receive message with receiveNoWait on #destinationName works"() { - setup: - def consumer = session.createConsumer(destination) - - // Receive with timeout - Message receivedMessage = consumer.receiveNoWait() - - expect: - receivedMessage == null - // span is not created if no message is received - assertTraces(0) {} - - cleanup: - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - } - - def "failing to receive message with wait(timeout) on #destinationName works"() { - setup: - def consumer = session.createConsumer(destination) - - // Receive with timeout - Message receivedMessage = consumer.receive(100) - - expect: - receivedMessage == null - // span is not created if no message is received - assertTraces(0) {} - - cleanup: - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - } - - def "sending a read-only message to #destinationName fails"() { - setup: - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - - expect: - !message.isReadOnlyProperties() - - when: - message.setReadOnlyProperties(true) - and: - producer.send(message) - - TextMessage receivedMessage = consumer.receive() as TextMessage - - then: - receivedMessage.text == messageText - - // This will result in a logged failure because we tried to - // write properties in MessagePropertyTextMap when readOnlyProperties = true. - // The consumer span will also not be linked to the parent. - assertTraces(2) { - trace(0, 1) { - producerSpan(it, 0, destinationName) - } - trace(1, 1) { - consumerSpan(it, 0, destinationName, "", "receive", null) - } - } - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "sending a message to #destinationName with explicit destination propagates context"() { - given: - def producer = session.createProducer(null) - def consumer = session.createConsumer(destination) - - def lock = new CountDownLatch(1) - def messageRef = new AtomicReference() - consumer.setMessageListener new MessageListener() { - @Override - void onMessage(Message message) { - lock.await() // ensure the producer trace is reported first. - messageRef.set(message as TextMessage) - } - } - - when: - runWithSpan("parent") { - producer.send(destination, message) - } - lock.countDown() - - then: - assertTraces(1) { - trace(0, 3) { - span(0) { - name "parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0)) - consumerSpan(it, 2, destinationName, messageRef.get().getJMSMessageID(), "process", span(1)) - } - } - // This check needs to go after all traces have been accounted for - messageRef.get().text == messageText - - cleanup: - producer.close() - consumer.close() - - where: - destination | destinationName - session.createQueue("someQueue") | "someQueue" - session.createTopic("someTopic") | "someTopic" - session.createTemporaryQueue() | "(temporary)" - session.createTemporaryTopic() | "(temporary)" - } - - def "capture message header as span attribute"() { - setup: - def destinationName = "someQueue" - def destination = session.createQueue(destinationName) - def producer = session.createProducer(destination) - def consumer = session.createConsumer(destination) - - def message = session.createTextMessage(messageText) - message.setStringProperty("test-message-header", "test") - message.setIntProperty("test-message-int-header", 1234) - runWithSpan("producer parent") { - producer.send(message) - } - - TextMessage receivedMessage = runWithSpan("consumer parent") { - return consumer.receive() as TextMessage - } - String messageId = receivedMessage.getJMSMessageID() - - expect: - receivedMessage.text == messageText - assertTraces(2) { - SpanData producerSpanData - trace(0, 2) { - span(0) { - name "producer parent" - hasNoParent() - } - producerSpan(it, 1, destinationName, span(0), true) - - producerSpanData = span(1) - } - trace(1, 2) { - span(0) { - name "consumer parent" - hasNoParent() - } - consumerSpan(it, 1, destinationName, messageId, "receive", span(0), producerSpanData, true) - } - } - - cleanup: - producer.close() - consumer.close() - } - - static producerSpan(TraceAssert trace, int index, String destinationName, SpanData parentSpan = null, boolean testHeaders = false) { - trace.span(index) { - name destinationName + " publish" - kind PRODUCER - if (parentSpan == null) { - hasNoParent() - } else { - childOf(parentSpan) - } - attributes { - "$SemanticAttributes.MESSAGING_SYSTEM" "jms" - "$SemanticAttributes.MESSAGING_DESTINATION_NAME" destinationName - if (destinationName == "(temporary)") { - "$SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY" true - } - "$SemanticAttributes.MESSAGING_MESSAGE_ID" String - if (testHeaders) { - "messaging.header.test_message_header" { it == ["test"] } - "messaging.header.test_message_int_header" { it == ["1234"] } - } - } - } - } - - // passing messageId = null will verify message.id is not captured, - // passing messageId = "" will verify message.id is captured (but won't verify anything about the value), - // any other value for messageId will verify that message.id is captured and has that same value - static consumerSpan(TraceAssert trace, int index, String destinationName, String messageId, String operation, SpanData parentSpan, SpanData linkedSpan = null, boolean testHeaders = false) { - trace.span(index) { - name destinationName + " " + operation - kind CONSUMER - if (parentSpan == null) { - hasNoParent() - } else { - childOf(parentSpan) - } - if (linkedSpan == null) { - hasNoLinks() - } else { - hasLink(linkedSpan) - } - attributes { - "$SemanticAttributes.MESSAGING_SYSTEM" "jms" - "$SemanticAttributes.MESSAGING_DESTINATION_NAME" destinationName - "$SemanticAttributes.MESSAGING_OPERATION" operation - if (messageId != null) { - //In some tests we don't know exact messageId, so we pass "" and verify just the existence of the attribute - "$SemanticAttributes.MESSAGING_MESSAGE_ID" { it == messageId || messageId == "" } - } - if (destinationName == "(temporary)") { - "$SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY" true - } - if (testHeaders) { - "messaging.header.test_message_header" { it == ["test"] } - "messaging.header.test_message_int_header" { it == ["1234"] } - } - } - } - } -} diff --git a/instrumentation/jms/jms-1.1/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms1InstrumentationTest.java b/instrumentation/jms/jms-1.1/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms1InstrumentationTest.java new file mode 100644 index 000000000000..9c6c828649ed --- /dev/null +++ b/instrumentation/jms/jms-1.1/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/jms/v1_1/Jms1InstrumentationTest.java @@ -0,0 +1,409 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.jms.v1_1; + +import static io.opentelemetry.api.common.AttributeKey.stringArrayKey; +import static io.opentelemetry.api.trace.SpanKind.CONSUMER; +import static io.opentelemetry.api.trace.SpanKind.PRODUCER; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; +import static java.util.Collections.singletonList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.sdk.testing.assertj.AttributeAssertion; +import io.opentelemetry.sdk.trace.data.LinkData; +import io.opentelemetry.sdk.trace.data.SpanData; +import io.opentelemetry.semconv.SemanticAttributes; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; +import javax.jms.Connection; +import javax.jms.Destination; +import javax.jms.JMSException; +import javax.jms.Message; +import javax.jms.MessageConsumer; +import javax.jms.MessageProducer; +import javax.jms.Session; +import javax.jms.TextMessage; +import org.apache.activemq.ActiveMQConnectionFactory; +import org.apache.activemq.command.ActiveMQTextMessage; +import org.assertj.core.api.AbstractAssert; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testcontainers.containers.GenericContainer; +import org.testcontainers.containers.output.Slf4jLogConsumer; + +public class Jms1InstrumentationTest { + + static final Logger logger = LoggerFactory.getLogger(Jms1InstrumentationTest.class); + + @RegisterExtension + static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); + + @RegisterExtension static final AutoCleanupExtension cleanup = AutoCleanupExtension.create(); + + static GenericContainer broker; + static ActiveMQConnectionFactory connectionFactory; + static Connection connection; + static Session session; + + @BeforeAll + static void setUp() throws JMSException { + broker = + new GenericContainer<>("rmohr/activemq:latest") + .withExposedPorts(61616, 8161) + .withLogConsumer(new Slf4jLogConsumer(logger)); + broker.start(); + + connectionFactory = + new ActiveMQConnectionFactory("tcp://localhost:" + broker.getMappedPort(61616)); + Connection connection = connectionFactory.createConnection(); + connection.start(); + session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); + } + + @AfterAll + static void tearDown() throws JMSException { + if (session != null) { + session.close(); + } + if (connection != null) { + connection.close(); + } + if (broker != null) { + broker.close(); + } + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void testMessageConsumer( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws JMSException { + + // given + Destination destination = destinationFactory.create(session); + TextMessage sentMessage = session.createTextMessage("a message"); + + MessageProducer producer = session.createProducer(destination); + cleanup.deferCleanup(producer::close); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer::close); + + // when + testing.runWithSpan("producer parent", () -> producer.send(sentMessage)); + + TextMessage receivedMessage = + testing.runWithSpan("consumer parent", () -> (TextMessage) consumer.receive()); + + // then + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + AtomicReference producerSpan = new AtomicReference<>(); + testing.waitAndAssertTraces( + trace -> { + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary))); + + producerSpan.set(trace.getSpan(1)); + }, + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("consumer parent").hasNoParent(), + span -> + span.hasName(destinationName + " receive") + .hasKind(CONSUMER) + .hasParent(trace.getSpan(0)) + .hasLinks(LinkData.create(producerSpan.get().getSpanContext())) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "receive"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)))); + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void testMessageListener( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws Exception { + + // given + Destination destination = destinationFactory.create(session); + TextMessage sentMessage = session.createTextMessage("a message"); + + MessageProducer producer = session.createProducer(null); + cleanup.deferCleanup(producer::close); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer::close); + + CompletableFuture receivedMessageFuture = new CompletableFuture<>(); + consumer.setMessageListener( + message -> + testing.runWithSpan( + "consumer", () -> receivedMessageFuture.complete((TextMessage) message))); + + // when + testing.runWithSpan("producer parent", () -> producer.send(destination, sentMessage)); + + // then + TextMessage receivedMessage = receivedMessageFuture.get(10, TimeUnit.SECONDS); + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + testing.waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)), + span -> + span.hasName(destinationName + " process") + .hasKind(CONSUMER) + .hasParent(trace.getSpan(1)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "process"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)), + span -> span.hasName("consumer").hasParent(trace.getSpan(2)))); + } + + @ArgumentsSource(EmptyReceiveArgumentsProvider.class) + @ParameterizedTest + void shouldNotEmitTelemetryOnEmptyReceive( + DestinationFactory destinationFactory, MessageReceiver receiver) throws JMSException { + + // given + Destination destination = destinationFactory.create(session); + + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer::close); + + // when + Message message = receiver.receive(consumer); + + // then + assertThat(message).isNull(); + + testing.waitForTraces(0); + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void shouldCaptureMessageHeaders( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws Exception { + + // given + Destination destination = destinationFactory.create(session); + TextMessage sentMessage = session.createTextMessage("a message"); + sentMessage.setStringProperty("test_message_header", "test"); + sentMessage.setIntProperty("test_message_int_header", 1234); + + MessageProducer producer = session.createProducer(destination); + cleanup.deferCleanup(producer::close); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer::close); + + CompletableFuture receivedMessageFuture = new CompletableFuture<>(); + consumer.setMessageListener( + message -> + testing.runWithSpan( + "consumer", () -> receivedMessageFuture.complete((TextMessage) message))); + + // when + testing.runWithSpan("producer parent", () -> producer.send(sentMessage)); + + // then + TextMessage receivedMessage = receivedMessageFuture.get(10, TimeUnit.SECONDS); + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + testing.waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary), + equalTo( + stringArrayKey("messaging.header.test_message_header"), + singletonList("test")), + equalTo( + stringArrayKey("messaging.header.test_message_int_header"), + singletonList("1234"))), + span -> + span.hasName(destinationName + " process") + .hasKind(CONSUMER) + .hasParent(trace.getSpan(1)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "process"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary), + equalTo( + stringArrayKey("messaging.header.test_message_header"), + singletonList("test")), + equalTo( + stringArrayKey("messaging.header.test_message_int_header"), + singletonList("1234"))), + span -> span.hasName("consumer").hasParent(trace.getSpan(2)))); + } + + @ArgumentsSource(DestinationsProvider.class) + @ParameterizedTest + void shouldFailWhenSendingReadOnlyMessage( + DestinationFactory destinationFactory, String destinationName, boolean isTemporary) + throws Exception { + + // given + Destination destination = destinationFactory.create(session); + ActiveMQTextMessage sentMessage = (ActiveMQTextMessage) session.createTextMessage("a message"); + + MessageProducer producer = session.createProducer(destination); + cleanup.deferCleanup(producer::close); + MessageConsumer consumer = session.createConsumer(destination); + cleanup.deferCleanup(consumer::close); + + sentMessage.setReadOnlyProperties(true); + + // when + testing.runWithSpan("producer parent", () -> producer.send(sentMessage)); + + TextMessage receivedMessage = (TextMessage) consumer.receive(); + + // then + assertThat(receivedMessage.getText()).isEqualTo(sentMessage.getText()); + + String messageId = receivedMessage.getJMSMessageID(); + + // This will result in a logged failure because we tried to + // write properties in MessagePropertyTextMap when readOnlyProperties = true. + // As a result, the consumer span will not be linked to the producer span as we are unable to + // propagate the trace context as a message property. + testing.waitAndAssertTraces( + trace -> + trace.hasSpansSatisfyingExactly( + span -> span.hasName("producer parent").hasNoParent(), + span -> + span.hasName(destinationName + " publish") + .hasKind(PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary))), + trace -> + trace.hasSpansSatisfyingExactly( + span -> + span.hasName(destinationName + " receive") + .hasKind(CONSUMER) + .hasNoParent() + .hasTotalRecordedLinks(0) + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.MESSAGING_SYSTEM, "jms"), + equalTo(SemanticAttributes.MESSAGING_DESTINATION_NAME, destinationName), + equalTo(SemanticAttributes.MESSAGING_OPERATION, "receive"), + equalTo(SemanticAttributes.MESSAGING_MESSAGE_ID, messageId), + messagingTempDestination(isTemporary)))); + } + + private static AttributeAssertion messagingTempDestination(boolean isTemporary) { + return isTemporary + ? equalTo(SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY, true) + : satisfies(SemanticAttributes.MESSAGING_DESTINATION_TEMPORARY, AbstractAssert::isNull); + } + + static final class EmptyReceiveArgumentsProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) { + DestinationFactory topic = session -> session.createTopic("someTopic"); + DestinationFactory queue = session -> session.createQueue("someQueue"); + MessageReceiver receive = consumer -> consumer.receive(100); + MessageReceiver receiveNoWait = MessageConsumer::receiveNoWait; + + return Stream.of( + arguments(topic, receive), + arguments(queue, receive), + arguments(topic, receiveNoWait), + arguments(queue, receiveNoWait)); + } + } + + static final class DestinationsProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) { + DestinationFactory topic = session -> session.createTopic("someTopic"); + DestinationFactory queue = session -> session.createQueue("someQueue"); + DestinationFactory tempTopic = Session::createTemporaryTopic; + DestinationFactory tempQueue = Session::createTemporaryQueue; + + return Stream.of( + arguments(topic, "someTopic", false), + arguments(queue, "someQueue", false), + arguments(tempTopic, "(temporary)", true), + arguments(tempQueue, "(temporary)", true)); + } + } + + @FunctionalInterface + interface DestinationFactory { + + Destination create(Session session) throws JMSException; + } + + @FunctionalInterface + interface MessageReceiver { + + Message receive(MessageConsumer consumer) throws JMSException; + } +} From 403e133446aabca04e1e465de6f372a2bc0dda32 Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Mon, 18 Sep 2023 19:45:20 +0300 Subject: [PATCH 04/17] Improve hibernate reactive instrumentation (#9486) --- .../javaagent/build.gradle.kts | 1 + .../reactive/v1_0/HibernateReactiveTest.java | 162 ++++++++++++++++-- .../reactive/v2_0/HibernateReactiveTest.java | 127 ++++++++++++++ .../reactive/v1_0/CompletionStageWrapper.java | 40 +++++ ...ibernateReactiveInstrumentationModule.java | 4 +- .../StageSessionFactoryInstrumentation.java | 13 ++ .../v1_0/StageSessionImplInstrumentation.java | 50 ++++++ 7 files changed, 379 insertions(+), 18 deletions(-) create mode 100644 instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/CompletionStageWrapper.java create mode 100644 instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionImplInstrumentation.java diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/build.gradle.kts b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/build.gradle.kts index 25525d148498..9831c0b4d04f 100644 --- a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/build.gradle.kts +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/build.gradle.kts @@ -52,6 +52,7 @@ testing { implementation("org.hibernate.reactive:hibernate-reactive-core:2.0.0.Final") implementation("io.vertx:vertx-pg-client:4.4.2") } + compileOnly("io.vertx:vertx-codegen:4.4.2") } } } diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive1Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveTest.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive1Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveTest.java index d52500d76b48..c5acf36cdddc 100644 --- a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive1Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveTest.java +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive1Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveTest.java @@ -123,28 +123,156 @@ void testStage() throws Exception { testing.runWithSpan( "parent", () -> - Vertx.vertx() - .getOrCreateContext() - .runOnContext( - event -> - stageSessionFactory - .withSession( - session -> { - if (!Span.current().getSpanContext().isValid()) { - throw new IllegalStateException("missing parent span"); - } - - return session - .find(Value.class, 1L) - .thenAccept( - value -> testing.runWithSpan("callback", () -> {})); - }) - .thenAccept(unused -> latch.countDown()))); + runWithVertx( + () -> + stageSessionFactory + .withSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .find(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageWithStatelessSession() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .withStatelessSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .get(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageSessionWithTransaction() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .withSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .withTransaction(transaction -> session.find(Value.class, 1L)) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageStatelessSessionWithTransaction() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .withStatelessSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .withTransaction(transaction -> session.get(Value.class, 1L)) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); latch.await(30, TimeUnit.SECONDS); assertTrace(); } + @Test + void testStageOpenSession() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .openSession() + .thenApply( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .find(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageOpenStatelessSession() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .openStatelessSession() + .thenApply( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .get(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + private static void runWithVertx(Runnable runnable) { + Vertx.vertx().getOrCreateContext().runOnContext(event -> runnable.run()); + } + @SuppressWarnings("deprecation") // until old http semconv are dropped in 2.0 private static void assertTrace() { testing.waitAndAssertTraces( diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive2Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v2_0/HibernateReactiveTest.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive2Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v2_0/HibernateReactiveTest.java index 091691d081d5..dc506f3bf108 100644 --- a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive2Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v2_0/HibernateReactiveTest.java +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/hibernateReactive2Test/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v2_0/HibernateReactiveTest.java @@ -18,9 +18,11 @@ import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.vertx.core.Vertx; import jakarta.persistence.EntityManagerFactory; import jakarta.persistence.Persistence; import java.time.Duration; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import org.hibernate.reactive.mutiny.Mutiny; import org.hibernate.reactive.stage.Stage; @@ -138,6 +140,131 @@ void testStage() throws Exception { assertTrace(); } + @Test + void testStageWithStatelessSession() throws Exception { + testing + .runWithSpan( + "parent", + () -> + stageSessionFactory + .withStatelessSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .get(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .toCompletableFuture()) + .get(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageSessionWithTransaction() throws Exception { + testing + .runWithSpan( + "parent", + () -> + stageSessionFactory + .withSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .withTransaction(transaction -> session.find(Value.class, 1L)) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .toCompletableFuture()) + .get(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageStatelessSessionWithTransaction() throws Exception { + testing + .runWithSpan( + "parent", + () -> + stageSessionFactory + .withStatelessSession( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .withTransaction(transaction -> session.get(Value.class, 1L)) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .toCompletableFuture()) + .get(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageOpenSession() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .openSession() + .thenApply( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .find(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + @Test + void testStageOpenStatelessSession() throws Exception { + CountDownLatch latch = new CountDownLatch(1); + testing.runWithSpan( + "parent", + () -> + runWithVertx( + () -> + stageSessionFactory + .openStatelessSession() + .thenApply( + session -> { + if (!Span.current().getSpanContext().isValid()) { + throw new IllegalStateException("missing parent span"); + } + + return session + .get(Value.class, 1L) + .thenAccept(value -> testing.runWithSpan("callback", () -> {})); + }) + .thenAccept(unused -> latch.countDown()))); + latch.await(30, TimeUnit.SECONDS); + + assertTrace(); + } + + private static void runWithVertx(Runnable runnable) { + Vertx.vertx().getOrCreateContext().runOnContext(event -> runnable.run()); + } + @SuppressWarnings("deprecation") // until old http semconv are dropped in 2.0 private static void assertTrace() { testing.waitAndAssertTraces( diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/CompletionStageWrapper.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/CompletionStageWrapper.java new file mode 100644 index 000000000000..d9ab3cb667f2 --- /dev/null +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/CompletionStageWrapper.java @@ -0,0 +1,40 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.hibernate.reactive.v1_0; + +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; + +public final class CompletionStageWrapper { + + private CompletionStageWrapper() {} + + public static CompletionStage wrap(CompletionStage future) { + Context context = Context.current(); + if (context != Context.root()) { + return wrap(future, context); + } + return future; + } + + private static CompletionStage wrap(CompletionStage completionStage, Context context) { + CompletableFuture result = new CompletableFuture<>(); + completionStage.whenComplete( + (T value, Throwable throwable) -> { + try (Scope ignored = context.makeCurrent()) { + if (throwable != null) { + result.completeExceptionally(throwable); + } else { + result.complete(value); + } + } + }); + + return result; + } +} diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveInstrumentationModule.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveInstrumentationModule.java index 3e032e91e16f..ae3d953c5af3 100644 --- a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveInstrumentationModule.java +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/HibernateReactiveInstrumentationModule.java @@ -22,6 +22,8 @@ public HibernateReactiveInstrumentationModule() { @Override public List typeInstrumentations() { return asList( - new StageSessionFactoryInstrumentation(), new MutinySessionFactoryInstrumentation()); + new StageSessionFactoryInstrumentation(), + new StageSessionImplInstrumentation(), + new MutinySessionFactoryInstrumentation()); } } diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionFactoryInstrumentation.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionFactoryInstrumentation.java index e578c8e939b1..96e55ce81e51 100644 --- a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionFactoryInstrumentation.java +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionFactoryInstrumentation.java @@ -7,10 +7,12 @@ import static net.bytebuddy.matcher.ElementMatchers.named; import static net.bytebuddy.matcher.ElementMatchers.namedOneOf; +import static net.bytebuddy.matcher.ElementMatchers.returns; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import java.util.concurrent.CompletionStage; import java.util.function.Function; import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; @@ -30,6 +32,9 @@ public void transform(TypeTransformer transformer) { transformer.applyAdviceToMethod( namedOneOf("withSession", "withStatelessSession").and(takesArgument(1, Function.class)), this.getClass().getName() + "$Function1Advice"); + transformer.applyAdviceToMethod( + namedOneOf("openSession", "openStatelessSession").and(returns(CompletionStage.class)), + this.getClass().getName() + "$OpenSessionAdvice"); } @SuppressWarnings("unused") @@ -49,4 +54,12 @@ public static void onEnter( function = FunctionWrapper.wrap(function); } } + + @SuppressWarnings("unused") + public static class OpenSessionAdvice { + @Advice.OnMethodExit(suppress = Throwable.class) + public static void onExit(@Advice.Return(readOnly = false) CompletionStage completionStage) { + completionStage = CompletionStageWrapper.wrap(completionStage); + } + } } diff --git a/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionImplInstrumentation.java b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionImplInstrumentation.java new file mode 100644 index 000000000000..26d7d1cd1c53 --- /dev/null +++ b/instrumentation/hibernate/hibernate-reactive-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/hibernate/reactive/v1_0/StageSessionImplInstrumentation.java @@ -0,0 +1,50 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.hibernate.reactive.v1_0; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.namedOneOf; +import static net.bytebuddy.matcher.ElementMatchers.returns; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import java.util.concurrent.CompletionStage; +import java.util.function.Function; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; + +public class StageSessionImplInstrumentation implements TypeInstrumentation { + @Override + public ElementMatcher typeMatcher() { + return namedOneOf( + "org.hibernate.reactive.stage.impl.StageSessionImpl", + "org.hibernate.reactive.stage.impl.StageStatelessSessionImpl"); + } + + @Override + public void transform(TypeTransformer transformer) { + transformer.applyAdviceToMethod( + named("withTransaction") + .and(takesArgument(0, Function.class).and(returns(CompletionStage.class))), + this.getClass().getName() + "$WithTransactionAdvice"); + } + + @SuppressWarnings("unused") + public static class WithTransactionAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static void onEnter( + @Advice.Argument(value = 0, readOnly = false) Function function) { + function = FunctionWrapper.wrap(function); + } + + @Advice.OnMethodExit(suppress = Throwable.class) + public static void onExit(@Advice.Return(readOnly = false) CompletionStage completionStage) { + completionStage = CompletionStageWrapper.wrap(completionStage); + } + } +} From 952b6ec39445e05f43da84fce175b86764d5d4e3 Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Tue, 19 Sep 2023 12:36:27 +0300 Subject: [PATCH 05/17] Fix typo (#9496) --- instrumentation/jdbc/bootstrap/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/jdbc/bootstrap/build.gradle.kts b/instrumentation/jdbc/bootstrap/build.gradle.kts index 6fa135bb7283..eac175c2d0a7 100644 --- a/instrumentation/jdbc/bootstrap/build.gradle.kts +++ b/instrumentation/jdbc/bootstrap/build.gradle.kts @@ -3,7 +3,7 @@ plugins { } /* -JDDC instrumentation uses VirtualField. Add DbInfo, that is used as the value of +JDBC instrumentation uses VirtualField. Add DbInfo, that is used as the value of VirtualField, to boot loader. We do this because when JDBC instrumentation is started in multiple class loaders in the same hierarchy, each would define their own version of DbInfo. It is possible that the value read from virtual field would be from the wrong class loader and could produce a From 4deb6529348eff9e92d1fe04b0dc8b26db6f89a0 Mon Sep 17 00:00:00 2001 From: Jay DeLuca Date: Tue, 19 Sep 2023 07:18:46 -0400 Subject: [PATCH 06/17] Convert logback-mdc-1.0 tests from groovy to java (#9490) --- .../v1_0/LogbackWithBaggageTest.groovy | 12 -- .../logback/v1_0/LogbackWithBaggageTest.java | 27 ++++ .../logback/v1_0/LogbackTest.groovy | 12 -- .../logback/v1_0/LogbackTest.java | 22 +++ .../mdc/v1_0/LogbackWithBaggageTest.groovy | 12 -- .../mdc/v1_0/LogbackWithBaggageTest.java | 26 ++++ .../logback/mdc/v1_0/LogbackTest.groovy | 11 -- .../mdc/v1_0/internal/UnionMapTest.groovy | 81 ----------- .../logback/mdc/v1_0/LogbackTest.java | 21 +++ .../mdc/v1_0/internal/UnionMapTest.java | 104 ++++++++++++++ .../logback-mdc-1.0/testing/build.gradle.kts | 3 - .../mdc/v1_0/AbstractLogbackTest.groovy | 120 ---------------- .../AbstractLogbackWithBaggageTest.groovy | 13 -- .../logback/mdc/v1_0/AbstractLogbackTest.java | 134 ++++++++++++++++++ .../mdc/v1_0/LogbackInstrumentationTest.java | 17 +++ 15 files changed, 351 insertions(+), 264 deletions(-) delete mode 100644 instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.groovy create mode 100644 instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.java delete mode 100644 instrumentation/logback/logback-mdc-1.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.groovy create mode 100644 instrumentation/logback/logback-mdc-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.java delete mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.groovy create mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.java delete mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.groovy delete mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.groovy create mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.java create mode 100644 instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.java delete mode 100644 instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.groovy delete mode 100644 instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackWithBaggageTest.groovy create mode 100644 instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.java create mode 100644 instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackInstrumentationTest.java diff --git a/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.groovy b/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.groovy deleted file mode 100644 index e2468e46cc9a..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.groovy +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.javaagent.instrumentation.logback.v1_0 - -import io.opentelemetry.instrumentation.logback.mdc.v1_0.AbstractLogbackWithBaggageTest -import io.opentelemetry.instrumentation.test.AgentTestTrait - -class LogbackWithBaggageTest extends AbstractLogbackWithBaggageTest implements AgentTestTrait { -} diff --git a/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.java b/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.java new file mode 100644 index 000000000000..ada86492a46a --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/javaagent/src/addBaggageTest/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackWithBaggageTest.java @@ -0,0 +1,27 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.logback.v1_0; + +import io.opentelemetry.instrumentation.logback.mdc.v1_0.AbstractLogbackTest; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; + +class LogbackWithBaggageTest extends AbstractLogbackTest { + + @RegisterExtension + static InstrumentationExtension agentTesting = AgentInstrumentationExtension.create(); + + @Override + public InstrumentationExtension getInstrumentationExtension() { + return agentTesting; + } + + @Override + protected boolean expectBaggage() { + return true; + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.groovy b/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.groovy deleted file mode 100644 index a666d5f99a91..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/groovy/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.groovy +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.javaagent.instrumentation.logback.v1_0 - -import io.opentelemetry.instrumentation.logback.mdc.v1_0.AbstractLogbackTest -import io.opentelemetry.instrumentation.test.AgentTestTrait - -class LogbackTest extends AbstractLogbackTest implements AgentTestTrait { -} diff --git a/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.java b/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.java new file mode 100644 index 000000000000..f59a2bcf9ad0 --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/logback/v1_0/LogbackTest.java @@ -0,0 +1,22 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.logback.v1_0; + +import io.opentelemetry.instrumentation.logback.mdc.v1_0.AbstractLogbackTest; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; + +class LogbackTest extends AbstractLogbackTest { + + @RegisterExtension + static InstrumentationExtension agentTesting = AgentInstrumentationExtension.create(); + + @Override + public InstrumentationExtension getInstrumentationExtension() { + return agentTesting; + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.groovy b/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.groovy deleted file mode 100644 index b1ddcc750212..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.groovy +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.logback.mdc.v1_0 - - -import io.opentelemetry.instrumentation.test.LibraryTestTrait - -class LogbackWithBaggageTest extends AbstractLogbackWithBaggageTest implements LibraryTestTrait { -} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.java b/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.java new file mode 100644 index 000000000000..dd964a7458db --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/library/src/addBaggageTest/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackWithBaggageTest.java @@ -0,0 +1,26 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.logback.mdc.v1_0; + +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; + +class LogbackWithBaggageTest extends AbstractLogbackTest { + + @RegisterExtension + static InstrumentationExtension testing = LibraryInstrumentationExtension.create(); + + @Override + public InstrumentationExtension getInstrumentationExtension() { + return testing; + } + + @Override + protected boolean expectBaggage() { + return true; + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.groovy b/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.groovy deleted file mode 100644 index 3bd3f72f39cc..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.groovy +++ /dev/null @@ -1,11 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.logback.mdc.v1_0 - -import io.opentelemetry.instrumentation.test.LibraryTestTrait - -class LogbackTest extends AbstractLogbackTest implements LibraryTestTrait { -} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.groovy b/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.groovy deleted file mode 100644 index 6c8709bb93f4..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/library/src/test/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.groovy +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.logback.mdc.v1_0.internal - -import spock.lang.Specification - -class UnionMapTest extends Specification { - - def "maps"() { - when: - def union = new UnionMap(first, second) - - then: - union['cat'] == 'meow' - union['dog'] == 'bark' - union['foo'] == 'bar' - union['hello'] == 'world' - union['giraffe'] == null - - !union.isEmpty() - union.size() == 4 - union.containsKey('cat') - union.containsKey('dog') - union.containsKey('foo') - union.containsKey('hello') - !union.containsKey('giraffe') - - def set = union.entrySet() - !set.isEmpty() - set.size() == 4 - def copy = new ArrayList(set) - copy.size() == 4 - - where: - first | second - [cat: 'meow', dog: 'bark'] | [foo: 'bar', hello: 'world'] - // Overlapping entries in second does not affect the union. - [cat: 'meow', dog: 'bark'] | [foo: 'bar', hello: 'world', cat: 'moo'] - } - - def "both empty"() { - when: - def union = new UnionMap(Collections.emptyMap(), Collections.emptyMap()) - - then: - union.isEmpty() - union.size() == 0 - union['cat'] == null - - def set = union.entrySet() - set.isEmpty() - set.size() == 0 - def copy = new ArrayList(set) - copy.size() == 0 - } - - def "one empty"() { - when: - def union = new UnionMap(first, second) - - then: - !union.isEmpty() - union.size() == 1 - union['cat'] == 'meow' - union['dog'] == null - - def set = union.entrySet() - !set.isEmpty() - set.size() == 1 - def copy = new ArrayList(set) - copy.size() == 1 - - where: - first | second - [cat: 'meow'] | Collections.emptyMap() - Collections.emptyMap() | [cat: 'meow'] - } -} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.java b/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.java new file mode 100644 index 000000000000..d0de1c10e672 --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackTest.java @@ -0,0 +1,21 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.logback.mdc.v1_0; + +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; + +class LogbackTest extends AbstractLogbackTest { + + @RegisterExtension + static InstrumentationExtension testing = LibraryInstrumentationExtension.create(); + + @Override + public InstrumentationExtension getInstrumentationExtension() { + return testing; + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.java b/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.java new file mode 100644 index 000000000000..1656c55f41c1 --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/library/src/test/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/internal/UnionMapTest.java @@ -0,0 +1,104 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.logback.mdc.v1_0.internal; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.common.collect.ImmutableMap; +import java.util.Collections; +import java.util.Map; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class UnionMapTest { + + @ParameterizedTest + @MethodSource("providesMapsArguments") + void testMaps(Map first, Map second) { + UnionMap union = new UnionMap<>(first, second); + + assertThat(union.get("cat")).isEqualTo("meow"); + assertThat(union.get("dog")).isEqualTo("bark"); + assertThat(union.get("foo")).isEqualTo("bar"); + assertThat(union.get("hello")).isEqualTo("world"); + assertThat(union.get("giraffe")).isNull(); + + assertThat(union.isEmpty()).isFalse(); + assertThat(union.size()).isEqualTo(4); + assertThat(union.containsKey("cat")).isTrue(); + assertThat(union.containsKey("dog")).isTrue(); + assertThat(union.containsKey("foo")).isTrue(); + assertThat(union.containsKey("hello")).isTrue(); + assertThat(union.containsKey("giraffe")).isFalse(); + + Set> set = union.entrySet(); + assertThat(set.isEmpty()).isFalse(); + assertThat(set.size()).isEqualTo(4); + assertThat(set.toArray().length).isEqualTo(4); + } + + private static Stream providesMapsArguments() { + ImmutableMap firstArg = + ImmutableMap.of( + "cat", "meow", + "dog", "bark"); + + return Stream.of( + Arguments.of( + firstArg, + ImmutableMap.of( + "foo", "bar", + "hello", "world")), + Arguments.of( + firstArg, + ImmutableMap.of( + "foo", "bar", + "hello", "world", + "cat", "moo"))); + } + + @Test + void testBothEmpty() { + UnionMap union = new UnionMap<>(Collections.emptyMap(), Collections.emptyMap()); + + assertThat(union.isEmpty()).isTrue(); + assertThat(union.size()).isEqualTo(0); + assertThat(union.get("cat")).isNull(); + + Set> set = union.entrySet(); + assertThat(set.isEmpty()).isTrue(); + assertThat(set.size()).isEqualTo(0); + + assertThat(set.toArray().length).isEqualTo(0); + } + + @ParameterizedTest + @MethodSource("providesOneEmptyArguments") + void testOneEmpty(Map first, Map second) { + UnionMap union = new UnionMap<>(first, second); + + assertThat(union.isEmpty()).isFalse(); + assertThat(union.size()).isEqualTo(1); + assertThat(union.get("cat")).isEqualTo("meow"); + assertThat(union.get("dog")).isNull(); + + Set> set = union.entrySet(); + assertThat(set.isEmpty()).isFalse(); + assertThat(set.size()).isEqualTo(1); + + assertThat(set.toArray().length).isEqualTo(1); + } + + private static Stream providesOneEmptyArguments() { + return Stream.of( + Arguments.of(ImmutableMap.of("cat", "meow"), Collections.emptyMap()), + Arguments.of(Collections.emptyMap(), ImmutableMap.of("cat", "meow"))); + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/testing/build.gradle.kts b/instrumentation/logback/logback-mdc-1.0/testing/build.gradle.kts index c6c0d80341ec..31b6162f0acd 100644 --- a/instrumentation/logback/logback-mdc-1.0/testing/build.gradle.kts +++ b/instrumentation/logback/logback-mdc-1.0/testing/build.gradle.kts @@ -10,8 +10,5 @@ dependencies { api("ch.qos.logback:logback-classic:1.0.0") implementation("com.google.guava:guava") - - implementation("org.apache.groovy:groovy") implementation("io.opentelemetry:opentelemetry-api") - implementation("org.spockframework:spock-core") } diff --git a/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.groovy b/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.groovy deleted file mode 100644 index 93212d192bef..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.groovy +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.logback.mdc.v1_0 - -import ch.qos.logback.classic.spi.ILoggingEvent -import ch.qos.logback.core.read.ListAppender -import io.opentelemetry.api.baggage.Baggage -import io.opentelemetry.api.trace.Span -import io.opentelemetry.instrumentation.test.InstrumentationSpecification -import org.slf4j.Logger -import org.slf4j.LoggerFactory -import spock.lang.Shared - -abstract class AbstractLogbackTest extends InstrumentationSpecification { - - private static final Logger logger = LoggerFactory.getLogger("test") - - @Shared - ListAppender listAppender - - def setupSpec() { - ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) logger - def topLevelListAppender = logbackLogger.getAppender("LIST") - if (topLevelListAppender != null) { - // Auto instrumentation test. - listAppender = topLevelListAppender as ListAppender - } else { - // Library instrumentation test. - listAppender = (logbackLogger.getAppender("OTEL") as OpenTelemetryAppender) - .getAppender("LIST") as ListAppender - } - } - - def setup() { - listAppender.list.clear() - } - - def "no ids when no span"() { - when: - Baggage baggage = Baggage.empty().toBuilder().put("baggage_key", "baggage_value").build() - - runWithBaggage(baggage) { - AbstractLogbackTest.logger.info("log message 1") - AbstractLogbackTest.logger.info("log message 2") - } - - def events = listAppender.list - - then: - events.size() == 2 - events[0].message == "log message 1" - events[0].getMDCPropertyMap().get("trace_id") == null - events[0].getMDCPropertyMap().get("span_id") == null - events[0].getMDCPropertyMap().get("trace_flags") == null - events[0].getMDCPropertyMap().get("baggage.baggage_key") == (expectBaggage() ? "baggage_value" : null) - - events[1].message == "log message 2" - events[1].getMDCPropertyMap().get("trace_id") == null - events[1].getMDCPropertyMap().get("span_id") == null - events[1].getMDCPropertyMap().get("trace_flags") == null - events[1].getMDCPropertyMap().get("baggage.baggage_key") == (expectBaggage() ? "baggage_value" : null) - } - - def "ids when span"() { - when: - Baggage baggage = Baggage.empty().toBuilder().put("baggage_key", "baggage_value").build() - - Span span1 = runWithSpanAndBaggage("test", baggage) { - AbstractLogbackTest.logger.info("log message 1") - } - - logger.info("log message 2") - - Span span2 = runWithSpanAndBaggage("test 2", baggage) { - AbstractLogbackTest.logger.info("log message 3") - } - - def events = listAppender.list - - then: - events.size() == 3 - events[0].message == "log message 1" - events[0].getMDCPropertyMap().get("trace_id") == span1.spanContext.traceId - events[0].getMDCPropertyMap().get("span_id") == span1.spanContext.spanId - events[0].getMDCPropertyMap().get("trace_flags") == "01" - events[0].getMDCPropertyMap().get("baggage.baggage_key") == (expectBaggage() ? "baggage_value" : null) - - events[1].message == "log message 2" - events[1].getMDCPropertyMap().get("trace_id") == null - events[1].getMDCPropertyMap().get("span_id") == null - events[1].getMDCPropertyMap().get("trace_flags") == null - events[1].getMDCPropertyMap().get("baggage.baggage_key") == null - - events[2].message == "log message 3" - events[2].getMDCPropertyMap().get("trace_id") == span2.spanContext.traceId - events[2].getMDCPropertyMap().get("span_id") == span2.spanContext.spanId - events[2].getMDCPropertyMap().get("trace_flags") == "01" - events[2].getMDCPropertyMap().get("baggage.baggage_key") == (expectBaggage() ? "baggage_value" : null) - } - - Span runWithSpanAndBaggage(String spanName, Baggage baggage, Closure callback) { - return runWithSpan(spanName) { - runWithBaggage(baggage, callback) - Span.current() - } - } - - void runWithBaggage(Baggage baggage, Closure callback) { - try (var unusedScope = baggage.makeCurrent()) { - callback.call() - } - } - - boolean expectBaggage() { - return false - } -} diff --git a/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackWithBaggageTest.groovy b/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackWithBaggageTest.groovy deleted file mode 100644 index 66762efeac06..000000000000 --- a/instrumentation/logback/logback-mdc-1.0/testing/src/main/groovy/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackWithBaggageTest.groovy +++ /dev/null @@ -1,13 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.logback.mdc.v1_0 - -abstract class AbstractLogbackWithBaggageTest extends AbstractLogbackTest { - @Override - boolean expectBaggage() { - return true - } -} diff --git a/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.java b/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.java new file mode 100644 index 000000000000..4979ff95d66b --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/AbstractLogbackTest.java @@ -0,0 +1,134 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.logback.mdc.v1_0; + +import static org.assertj.core.api.Assertions.assertThat; + +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.Appender; +import ch.qos.logback.core.read.ListAppender; +import io.opentelemetry.api.baggage.Baggage; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Scope; +import java.util.List; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public abstract class AbstractLogbackTest implements LogbackInstrumentationTest { + + protected static final Logger logger = LoggerFactory.getLogger("test"); + + protected static ListAppender listAppender = new ListAppender<>(); + + protected final Baggage baggage = + Baggage.empty().toBuilder().put("baggage_key", "baggage_value").build(); + + @BeforeAll + static void setUp() { + ch.qos.logback.classic.Logger logbackLogger = (ch.qos.logback.classic.Logger) logger; + Appender topLevelListAppender = logbackLogger.getAppender("LIST"); + if (topLevelListAppender != null) { + // Auto instrumentation test + listAppender = (ListAppender) topLevelListAppender; + } else { + // Library instrumentation test. + OpenTelemetryAppender otelAppender = + (OpenTelemetryAppender) logbackLogger.getAppender("OTEL"); + listAppender = (ListAppender) otelAppender.getAppender("LIST"); + } + } + + @BeforeEach + void setUpData() { + listAppender.list.clear(); + } + + @Test + void testNoIdsWhenNoSpan() { + runWithBaggage( + baggage, + () -> { + logger.info("log message 1"); + logger.info("log message 2"); + }); + + List events = listAppender.list; + + assertThat(events.size()).isEqualTo(2); + assertThat(events.get(0).getMessage()).isEqualTo("log message 1"); + assertThat(events.get(0).getMDCPropertyMap().get("trace_id")).isNull(); + assertThat(events.get(0).getMDCPropertyMap().get("span_id")).isNull(); + assertThat(events.get(0).getMDCPropertyMap().get("trace_flags")).isNull(); + assertThat(events.get(0).getMDCPropertyMap().get("baggage.baggage_key")) + .isEqualTo(expectBaggage() ? "baggage_value" : null); + + assertThat(events.get(1).getMessage()).isEqualTo("log message 2"); + assertThat(events.get(1).getMDCPropertyMap().get("trace_id")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("span_id")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("trace_flags")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("baggage.baggage_key")) + .isEqualTo(expectBaggage() ? "baggage_value" : null); + } + + @Test + void testIdsWhenSpan() { + Span span1 = runWithSpanAndBaggage("test", baggage, () -> logger.info("log message 1")); + + logger.info("log message 2"); + + Span span2 = runWithSpanAndBaggage("test 2", baggage, () -> logger.info("log message 3")); + + List events = listAppender.list; + + assertThat(events.size()).isEqualTo(3); + assertThat(events.get(0).getMessage()).isEqualTo("log message 1"); + assertThat(events.get(0).getMDCPropertyMap().get("trace_id")) + .isEqualTo(span1.getSpanContext().getTraceId()); + assertThat(events.get(0).getMDCPropertyMap().get("span_id")) + .isEqualTo(span1.getSpanContext().getSpanId()); + assertThat(events.get(0).getMDCPropertyMap().get("trace_flags")).isEqualTo("01"); + assertThat(events.get(0).getMDCPropertyMap().get("baggage.baggage_key")) + .isEqualTo(expectBaggage() ? "baggage_value" : null); + + assertThat(events.get(1).getMessage()).isEqualTo("log message 2"); + assertThat(events.get(1).getMDCPropertyMap().get("trace_id")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("span_id")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("trace_flags")).isNull(); + assertThat(events.get(1).getMDCPropertyMap().get("baggage.baggage_key")).isNull(); + + assertThat(events.get(2).getMessage()).isEqualTo("log message 3"); + assertThat(events.get(2).getMDCPropertyMap().get("trace_id")) + .isEqualTo(span2.getSpanContext().getTraceId()); + assertThat(events.get(2).getMDCPropertyMap().get("span_id")) + .isEqualTo(span2.getSpanContext().getSpanId()); + assertThat(events.get(2).getMDCPropertyMap().get("trace_flags")).isEqualTo("01"); + assertThat(events.get(2).getMDCPropertyMap().get("baggage.baggage_key")) + .isEqualTo(expectBaggage() ? "baggage_value" : null); + } + + void runWithBaggage(Baggage baggage, Runnable runnable) { + try (Scope unusedScope = baggage.makeCurrent()) { + runnable.run(); + } + } + + Span runWithSpanAndBaggage(String spanName, Baggage baggage, Runnable runnable) { + return getInstrumentationExtension() + .runWithSpan( + spanName, + () -> { + runWithBaggage(baggage, runnable); + return Span.current(); + }); + } + + protected boolean expectBaggage() { + return false; + } +} diff --git a/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackInstrumentationTest.java b/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackInstrumentationTest.java new file mode 100644 index 000000000000..dd22c3be7e10 --- /dev/null +++ b/instrumentation/logback/logback-mdc-1.0/testing/src/main/java/io/opentelemetry/instrumentation/logback/mdc/v1_0/LogbackInstrumentationTest.java @@ -0,0 +1,17 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.logback.mdc.v1_0; + +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; + +public interface LogbackInstrumentationTest { + InstrumentationExtension agentTesting = AgentInstrumentationExtension.create(); + + default InstrumentationExtension getInstrumentationExtension() { + return agentTesting; + } +} From 8d1f3d2606c0c151480467b96a8267c63c129853 Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Wed, 20 Sep 2023 13:42:08 +0300 Subject: [PATCH 07/17] Disable link checker for http://logback.qos.ch (#9510) --- .github/scripts/markdown-link-check-config.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/scripts/markdown-link-check-config.json b/.github/scripts/markdown-link-check-config.json index 791cf1e6f9c2..98ff9a08f247 100644 --- a/.github/scripts/markdown-link-check-config.json +++ b/.github/scripts/markdown-link-check-config.json @@ -13,6 +13,9 @@ }, { "pattern": "^https://kotlinlang\\.org/docs/coroutines-overview\\.html$" + }, + { + "pattern": "^http://logback\\.qos\\.ch" } ] } From df05d207765759f24cce2b4a22565cb0ba49990c Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Wed, 20 Sep 2023 14:14:51 +0300 Subject: [PATCH 08/17] Also ignore https://logback.qos.ch links (#9512) --- .github/scripts/markdown-link-check-config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/scripts/markdown-link-check-config.json b/.github/scripts/markdown-link-check-config.json index 98ff9a08f247..88a18a4db2d0 100644 --- a/.github/scripts/markdown-link-check-config.json +++ b/.github/scripts/markdown-link-check-config.json @@ -15,7 +15,7 @@ "pattern": "^https://kotlinlang\\.org/docs/coroutines-overview\\.html$" }, { - "pattern": "^http://logback\\.qos\\.ch" + "pattern": "^http(s)?://logback\\.qos\\.ch" } ] } From d90485d2b807afa362ff5d34e1328bc8784c907b Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Wed, 20 Sep 2023 14:53:18 +0300 Subject: [PATCH 09/17] Fix project.buildDir deprecation warning (#9509) --- .../kotlin/io.opentelemetry.instrumentation.base.gradle.kts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conventions/src/main/kotlin/io.opentelemetry.instrumentation.base.gradle.kts b/conventions/src/main/kotlin/io.opentelemetry.instrumentation.base.gradle.kts index ec47814c6998..01300ea7344f 100644 --- a/conventions/src/main/kotlin/io.opentelemetry.instrumentation.base.gradle.kts +++ b/conventions/src/main/kotlin/io.opentelemetry.instrumentation.base.gradle.kts @@ -143,11 +143,11 @@ tasks { inputs.property("instrumentation.name", name) inputs.property("instrumentation.version", version) - val propertiesDir = File(project.buildDir, "generated/instrumentationVersion/META-INF/io/opentelemetry/instrumentation/") + val propertiesDir = layout.buildDirectory.dir("generated/instrumentationVersion/META-INF/io/opentelemetry/instrumentation/") outputs.dir(propertiesDir) doLast { - File(propertiesDir, "$name.properties").writeText("version=$version") + File(propertiesDir.get().asFile, "$name.properties").writeText("version=$version") } } } From ae25d481ff6e9f9496dd25111249311e58cd1bea Mon Sep 17 00:00:00 2001 From: Trask Stalnaker Date: Wed, 20 Sep 2023 04:53:40 -0700 Subject: [PATCH 10/17] Use new semconv constants (#9504) --- .../http/HttpClientAttributesExtractor.java | 3 +- .../http/HttpCommonAttributesExtractor.java | 13 ++-- .../http/HttpMessageBodySizeUtil.java | 5 +- .../instrumenter/http/HttpMetricsAdvice.java | 55 +++++++------- .../http/internal/HttpAttributes.java | 36 ---------- .../InternalClientAttributesExtractor.java | 8 +-- .../InternalNetworkAttributesExtractor.java | 8 +-- .../InternalServerAttributesExtractor.java | 10 +-- .../network/internal/NetworkAttributes.java | 53 -------------- .../instrumenter/rpc/RpcMetricsAdvice.java | 25 ++++--- .../InternalUrlAttributesExtractor.java | 6 +- .../url/internal/UrlAttributes.java | 30 -------- .../url/UrlAttributesExtractorTest.java | 8 +-- ...entAttributesExtractorBothSemconvTest.java | 25 +++---- ...verAttributesExtractorBothSemconvTest.java | 29 ++++---- ...entAttributesExtractorBothSemconvTest.java | 19 +++-- ...verAttributesExtractorBothSemconvTest.java | 21 +++--- ...tAttributesExtractorStableSemconvTest.java | 49 ++++++------- ...tExperimentalMetricsStableSemconvTest.java | 66 ++++++++--------- .../HttpClientMetricsStableSemconvTest.java | 50 ++++++------- ...rAttributesExtractorStableSemconvTest.java | 53 +++++++------- ...rExperimentalMetricsStableSemconvTest.java | 72 +++++++++---------- .../HttpServerMetricsStableSemconvTest.java | 54 +++++++------- ...tAttributesExtractorStableSemconvTest.java | 20 +++--- ...rAttributesExtractorStableSemconvTest.java | 22 +++--- ...ributesExtractorInetSocketAddressTest.java | 6 +- .../ClientAttributesExtractorTest.java | 14 ++-- .../NetworkAttributesExtractorTest.java | 10 +-- ...ributesExtractorInetSocketAddressTest.java | 8 +-- .../ServerAttributesExtractorTest.java | 20 +++--- .../ApiGatewayProxyAttributesExtractor.java | 12 ++-- .../decorators/HttpSpanDecorator.java | 12 ++-- ...ElasticsearchClientAttributeExtractor.java | 15 ++-- .../HttpMethodAttributeExtractor.java | 9 ++- .../test/groovy/Netty40ClientSslTest.groovy | 42 +++++------ .../groovy/Netty40ConnectionSpanTest.groovy | 22 +++--- .../test/groovy/Netty41ClientSslTest.groovy | 50 ++++++------- .../groovy/Netty41ConnectionSpanTest.groovy | 30 ++++---- .../src/test/groovy/UndertowServerTest.groovy | 56 +++++++-------- .../junit/http/AbstractHttpClientTest.java | 12 ++-- .../junit/http/AbstractHttpServerTest.java | 26 ++++--- .../junit/http/SemconvStabilityUtil.java | 39 +++++----- 42 files changed, 485 insertions(+), 638 deletions(-) delete mode 100644 instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/internal/HttpAttributes.java delete mode 100644 instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/NetworkAttributes.java delete mode 100644 instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/UrlAttributes.java diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractor.java index 03f8c965cb9a..23efcb67593e 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractor.java @@ -13,7 +13,6 @@ import io.opentelemetry.instrumentation.api.instrumenter.net.internal.InternalNetClientAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.network.internal.InternalNetworkAttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.network.internal.InternalServerAttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.instrumentation.api.internal.SpanKey; import io.opentelemetry.instrumentation.api.internal.SpanKeyProvider; @@ -109,7 +108,7 @@ public void onStart(AttributesBuilder attributes, Context parentContext, REQUEST String fullUrl = stripSensitiveData(getter.getUrlFull(request)); if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, UrlAttributes.URL_FULL, fullUrl); + internalSet(attributes, SemanticAttributes.URL_FULL, fullUrl); } if (SemconvStability.emitOldHttpSemconv()) { internalSet(attributes, SemanticAttributes.HTTP_URL, fullUrl); diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpCommonAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpCommonAttributesExtractor.java index 926e1f580483..cea9dc1ea50f 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpCommonAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpCommonAttributesExtractor.java @@ -14,7 +14,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashSet; @@ -53,10 +52,10 @@ public void onStart(AttributesBuilder attributes, Context parentContext, REQUEST String method = getter.getHttpRequestMethod(request); if (SemconvStability.emitStableHttpSemconv()) { if (method == null || knownMethods.contains(method)) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, method); } else { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, _OTHER); - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, _OTHER); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); } } if (SemconvStability.emitOldHttpSemconv()) { @@ -83,7 +82,7 @@ public void onEnd( Long requestBodySize = requestBodySize(request); if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_BODY_SIZE, requestBodySize); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_BODY_SIZE, requestBodySize); } if (SemconvStability.emitOldHttpSemconv()) { internalSet(attributes, SemanticAttributes.HTTP_REQUEST_CONTENT_LENGTH, requestBodySize); @@ -93,7 +92,7 @@ public void onEnd( Integer statusCode = getter.getHttpResponseStatusCode(request, response, error); if (statusCode != null && statusCode > 0) { if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, HttpAttributes.HTTP_RESPONSE_STATUS_CODE, (long) statusCode); + internalSet(attributes, SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, (long) statusCode); } if (SemconvStability.emitOldHttpSemconv()) { internalSet(attributes, SemanticAttributes.HTTP_STATUS_CODE, (long) statusCode); @@ -102,7 +101,7 @@ public void onEnd( Long responseBodySize = responseBodySize(request, response); if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, HttpAttributes.HTTP_RESPONSE_BODY_SIZE, responseBodySize); + internalSet(attributes, SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, responseBodySize); } if (SemconvStability.emitOldHttpSemconv()) { internalSet(attributes, SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH, responseBodySize); diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMessageBodySizeUtil.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMessageBodySizeUtil.java index b739cad60e25..15d8d38a9f7f 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMessageBodySizeUtil.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMessageBodySizeUtil.java @@ -7,7 +7,6 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; import javax.annotation.Nullable; @@ -18,13 +17,13 @@ final class HttpMessageBodySizeUtil { private static final AttributeKey HTTP_REQUEST_BODY_SIZE = SemconvStability.emitOldHttpSemconv() ? SemanticAttributes.HTTP_REQUEST_CONTENT_LENGTH - : HttpAttributes.HTTP_REQUEST_BODY_SIZE; + : SemanticAttributes.HTTP_REQUEST_BODY_SIZE; @SuppressWarnings("deprecation") // until old http semconv are dropped in 2.0 private static final AttributeKey HTTP_RESPONSE_BODY_SIZE = SemconvStability.emitOldHttpSemconv() ? SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH - : HttpAttributes.HTTP_RESPONSE_BODY_SIZE; + : SemanticAttributes.HTTP_RESPONSE_BODY_SIZE; @Nullable static Long getHttpRequestBodySize(Attributes... attributesList) { diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsAdvice.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsAdvice.java index e18a3e87e9ad..032801d89880 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsAdvice.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsAdvice.java @@ -13,9 +13,6 @@ import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder; import io.opentelemetry.extension.incubator.metrics.ExtendedLongHistogramBuilder; import io.opentelemetry.extension.incubator.metrics.ExtendedLongUpDownCounterBuilder; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.semconv.SemanticAttributes; final class HttpMetricsAdvice { @@ -29,13 +26,13 @@ static void applyStableClientDurationAdvice(DoubleHistogramBuilder builder) { advice -> advice.setAttributes( asList( - HttpAttributes.HTTP_REQUEST_METHOD, - HttpAttributes.HTTP_RESPONSE_STATUS_CODE, - NetworkAttributes.NETWORK_PROTOCOL_NAME, - NetworkAttributes.NETWORK_PROTOCOL_VERSION, - NetworkAttributes.SERVER_ADDRESS, - NetworkAttributes.SERVER_PORT, - NetworkAttributes.SERVER_SOCKET_ADDRESS))); + SemanticAttributes.HTTP_REQUEST_METHOD, + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, + SemanticAttributes.NETWORK_PROTOCOL_NAME, + SemanticAttributes.NETWORK_PROTOCOL_VERSION, + SemanticAttributes.SERVER_ADDRESS, + SemanticAttributes.SERVER_PORT, + SemanticAttributes.SERVER_SOCKET_ADDRESS))); } @SuppressWarnings("deprecation") // until old http semconv are dropped in 2.0 @@ -68,13 +65,13 @@ static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { advice.setAttributes( asList( // stable attributes - HttpAttributes.HTTP_REQUEST_METHOD, - HttpAttributes.HTTP_RESPONSE_STATUS_CODE, - NetworkAttributes.NETWORK_PROTOCOL_NAME, - NetworkAttributes.NETWORK_PROTOCOL_VERSION, - NetworkAttributes.SERVER_ADDRESS, - NetworkAttributes.SERVER_PORT, - NetworkAttributes.SERVER_SOCKET_ADDRESS, + SemanticAttributes.HTTP_REQUEST_METHOD, + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, + SemanticAttributes.NETWORK_PROTOCOL_NAME, + SemanticAttributes.NETWORK_PROTOCOL_VERSION, + SemanticAttributes.SERVER_ADDRESS, + SemanticAttributes.SERVER_PORT, + SemanticAttributes.SERVER_SOCKET_ADDRESS, // old attributes SemanticAttributes.HTTP_METHOD, SemanticAttributes.HTTP_STATUS_CODE, @@ -95,11 +92,11 @@ static void applyStableServerDurationAdvice(DoubleHistogramBuilder builder) { advice.setAttributes( asList( SemanticAttributes.HTTP_ROUTE, - HttpAttributes.HTTP_REQUEST_METHOD, - HttpAttributes.HTTP_RESPONSE_STATUS_CODE, - NetworkAttributes.NETWORK_PROTOCOL_NAME, - NetworkAttributes.NETWORK_PROTOCOL_VERSION, - UrlAttributes.URL_SCHEME))); + SemanticAttributes.HTTP_REQUEST_METHOD, + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, + SemanticAttributes.NETWORK_PROTOCOL_NAME, + SemanticAttributes.NETWORK_PROTOCOL_VERSION, + SemanticAttributes.URL_SCHEME))); } @SuppressWarnings("deprecation") // until old http semconv are dropped in 2.0 @@ -134,11 +131,11 @@ static void applyServerRequestSizeAdvice(LongHistogramBuilder builder) { asList( // stable attributes SemanticAttributes.HTTP_ROUTE, - HttpAttributes.HTTP_REQUEST_METHOD, - HttpAttributes.HTTP_RESPONSE_STATUS_CODE, - NetworkAttributes.NETWORK_PROTOCOL_NAME, - NetworkAttributes.NETWORK_PROTOCOL_VERSION, - UrlAttributes.URL_SCHEME, + SemanticAttributes.HTTP_REQUEST_METHOD, + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, + SemanticAttributes.NETWORK_PROTOCOL_NAME, + SemanticAttributes.NETWORK_PROTOCOL_VERSION, + SemanticAttributes.URL_SCHEME, // old attributes SemanticAttributes.HTTP_SCHEME, SemanticAttributes.HTTP_ROUTE, @@ -166,8 +163,8 @@ static void applyServerActiveRequestsAdvice(LongUpDownCounterBuilder builder) { SemanticAttributes.NET_HOST_NAME, SemanticAttributes.NET_HOST_PORT, // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-metrics.md#metric-httpserveractive_requests - HttpAttributes.HTTP_REQUEST_METHOD, - UrlAttributes.URL_SCHEME))); + SemanticAttributes.HTTP_REQUEST_METHOD, + SemanticAttributes.URL_SCHEME))); } private HttpMetricsAdvice() {} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/internal/HttpAttributes.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/internal/HttpAttributes.java deleted file mode 100644 index 9de03953d3be..000000000000 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/internal/HttpAttributes.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.api.instrumenter.http.internal; - -import static io.opentelemetry.api.common.AttributeKey.longKey; -import static io.opentelemetry.api.common.AttributeKey.stringKey; - -import io.opentelemetry.api.common.AttributeKey; - -/** - * This class is internal and is hence not for public use. Its APIs are unstable and can change at - * any time. - */ -public final class HttpAttributes { - - // FIXME: remove this class and replace its usages with SemanticAttributes once schema 1.21 is - // released - - public static final AttributeKey HTTP_REQUEST_METHOD = stringKey("http.request.method"); - - public static final AttributeKey HTTP_REQUEST_METHOD_ORIGINAL = - stringKey("http.request.method_original"); - - public static final AttributeKey HTTP_REQUEST_BODY_SIZE = longKey("http.request.body.size"); - - public static final AttributeKey HTTP_RESPONSE_BODY_SIZE = - longKey("http.response.body.size"); - - public static final AttributeKey HTTP_RESPONSE_STATUS_CODE = - longKey("http.response.status_code"); - - private HttpAttributes() {} -} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalClientAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalClientAttributesExtractor.java index c96f2e653dcc..1a39f7c22139 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalClientAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalClientAttributesExtractor.java @@ -39,9 +39,9 @@ public void onStart(AttributesBuilder attributes, REQUEST request) { AddressAndPort clientAddressAndPort = extractClientAddressAndPort(request); if (emitStableUrlAttributes) { - internalSet(attributes, NetworkAttributes.CLIENT_ADDRESS, clientAddressAndPort.address); + internalSet(attributes, SemanticAttributes.CLIENT_ADDRESS, clientAddressAndPort.address); if (clientAddressAndPort.port != null && clientAddressAndPort.port > 0) { - internalSet(attributes, NetworkAttributes.CLIENT_PORT, (long) clientAddressAndPort.port); + internalSet(attributes, SemanticAttributes.CLIENT_PORT, (long) clientAddressAndPort.port); } } if (emitOldHttpAttributes) { @@ -57,7 +57,7 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO if (clientSocketAddress != null && !clientSocketAddress.equals(clientAddressAndPort.address)) { if (emitStableUrlAttributes) { - internalSet(attributes, NetworkAttributes.CLIENT_SOCKET_ADDRESS, clientSocketAddress); + internalSet(attributes, SemanticAttributes.CLIENT_SOCKET_ADDRESS, clientSocketAddress); } if (emitOldHttpAttributes) { internalSet(attributes, SemanticAttributes.NET_SOCK_PEER_ADDR, clientSocketAddress); @@ -66,7 +66,7 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO if (clientSocketPort != null && clientSocketPort > 0) { if (emitStableUrlAttributes) { if (!clientSocketPort.equals(clientAddressAndPort.port)) { - internalSet(attributes, NetworkAttributes.CLIENT_SOCKET_PORT, (long) clientSocketPort); + internalSet(attributes, SemanticAttributes.CLIENT_SOCKET_PORT, (long) clientSocketPort); } } if (emitOldHttpAttributes) { diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalNetworkAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalNetworkAttributesExtractor.java index cfd2a74887f5..3a43fd3c9e7f 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalNetworkAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalNetworkAttributesExtractor.java @@ -44,14 +44,14 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO String transport = lowercase(getter.getNetworkTransport(request, response)); if (networkTransportFilter.shouldAddNetworkTransport( protocolName, protocolVersion, transport)) { - internalSet(attributes, NetworkAttributes.NETWORK_TRANSPORT, transport); + internalSet(attributes, SemanticAttributes.NETWORK_TRANSPORT, transport); } internalSet( attributes, - NetworkAttributes.NETWORK_TYPE, + SemanticAttributes.NETWORK_TYPE, lowercase(getter.getNetworkType(request, response))); - internalSet(attributes, NetworkAttributes.NETWORK_PROTOCOL_NAME, protocolName); - internalSet(attributes, NetworkAttributes.NETWORK_PROTOCOL_VERSION, protocolVersion); + internalSet(attributes, SemanticAttributes.NETWORK_PROTOCOL_NAME, protocolName); + internalSet(attributes, SemanticAttributes.NETWORK_PROTOCOL_VERSION, protocolVersion); } if (emitOldHttpAttributes) { // net.transport and net.sock.family are not 1:1 convertible with network.transport and diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalServerAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalServerAttributesExtractor.java index 60cf2590eeef..b00fd5c7f5d5 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalServerAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/InternalServerAttributesExtractor.java @@ -49,7 +49,7 @@ public void onStart(AttributesBuilder attributes, REQUEST request) { AddressAndPort serverAddressAndPort = extractServerAddressAndPort(request); if (emitStableUrlAttributes) { - internalSet(attributes, NetworkAttributes.SERVER_ADDRESS, serverAddressAndPort.address); + internalSet(attributes, SemanticAttributes.SERVER_ADDRESS, serverAddressAndPort.address); } if (emitOldHttpAttributes) { internalSet(attributes, oldSemconvMode.address, serverAddressAndPort.address); @@ -59,7 +59,7 @@ public void onStart(AttributesBuilder attributes, REQUEST request) { && serverAddressAndPort.port > 0 && captureServerPortCondition.test(serverAddressAndPort.port, request)) { if (emitStableUrlAttributes) { - internalSet(attributes, NetworkAttributes.SERVER_PORT, (long) serverAddressAndPort.port); + internalSet(attributes, SemanticAttributes.SERVER_PORT, (long) serverAddressAndPort.port); } if (emitOldHttpAttributes) { internalSet(attributes, oldSemconvMode.port, (long) serverAddressAndPort.port); @@ -73,7 +73,7 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO String serverSocketAddress = getter.getServerSocketAddress(request, response); if (serverSocketAddress != null && !serverSocketAddress.equals(serverAddressAndPort.address)) { if (emitStableUrlAttributes && captureServerSocketAttributes) { - internalSet(attributes, NetworkAttributes.SERVER_SOCKET_ADDRESS, serverSocketAddress); + internalSet(attributes, SemanticAttributes.SERVER_SOCKET_ADDRESS, serverSocketAddress); } if (emitOldHttpAttributes) { internalSet(attributes, oldSemconvMode.socketAddress, serverSocketAddress); @@ -85,7 +85,7 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO && serverSocketPort > 0 && !serverSocketPort.equals(serverAddressAndPort.port)) { if (emitStableUrlAttributes && captureServerSocketAttributes) { - internalSet(attributes, NetworkAttributes.SERVER_SOCKET_PORT, (long) serverSocketPort); + internalSet(attributes, SemanticAttributes.SERVER_SOCKET_PORT, (long) serverSocketPort); } if (emitOldHttpAttributes) { internalSet(attributes, oldSemconvMode.socketPort, (long) serverSocketPort); @@ -95,7 +95,7 @@ public void onEnd(AttributesBuilder attributes, REQUEST request, @Nullable RESPO String serverSocketDomain = getter.getServerSocketDomain(request, response); if (serverSocketDomain != null && !serverSocketDomain.equals(serverAddressAndPort.address)) { if (emitStableUrlAttributes && captureServerSocketAttributes) { - internalSet(attributes, NetworkAttributes.SERVER_SOCKET_DOMAIN, serverSocketDomain); + internalSet(attributes, SemanticAttributes.SERVER_SOCKET_DOMAIN, serverSocketDomain); } if (emitOldHttpAttributes && oldSemconvMode.socketDomain != null) { internalSet(attributes, oldSemconvMode.socketDomain, serverSocketDomain); diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/NetworkAttributes.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/NetworkAttributes.java deleted file mode 100644 index 1d8c57a30cfc..000000000000 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/network/internal/NetworkAttributes.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.api.instrumenter.network.internal; - -import static io.opentelemetry.api.common.AttributeKey.longKey; -import static io.opentelemetry.api.common.AttributeKey.stringKey; - -import io.opentelemetry.api.common.AttributeKey; - -/** - * This class is internal and is hence not for public use. Its APIs are unstable and can change at - * any time. - */ -public final class NetworkAttributes { - - // FIXME: remove this class and replace its usages with SemanticAttributes once schema 1.20 is - // released - - public static final AttributeKey NETWORK_TRANSPORT = stringKey("network.transport"); - - public static final AttributeKey NETWORK_TYPE = stringKey("network.type"); - - public static final AttributeKey NETWORK_PROTOCOL_NAME = - stringKey("network.protocol.name"); - - public static final AttributeKey NETWORK_PROTOCOL_VERSION = - stringKey("network.protocol.version"); - - public static final AttributeKey SERVER_ADDRESS = stringKey("server.address"); - - public static final AttributeKey SERVER_PORT = longKey("server.port"); - - public static final AttributeKey SERVER_SOCKET_DOMAIN = stringKey("server.socket.domain"); - - public static final AttributeKey SERVER_SOCKET_ADDRESS = - stringKey("server.socket.address"); - - public static final AttributeKey SERVER_SOCKET_PORT = longKey("server.socket.port"); - - public static final AttributeKey CLIENT_ADDRESS = stringKey("client.address"); - - public static final AttributeKey CLIENT_PORT = longKey("client.port"); - - public static final AttributeKey CLIENT_SOCKET_ADDRESS = - stringKey("client.socket.address"); - - public static final AttributeKey CLIENT_SOCKET_PORT = longKey("client.socket.port"); - - private NetworkAttributes() {} -} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcMetricsAdvice.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcMetricsAdvice.java index 856938aa8421..180365598115 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcMetricsAdvice.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcMetricsAdvice.java @@ -8,7 +8,6 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.metrics.DoubleHistogramBuilder; import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; import java.util.ArrayList; @@ -31,12 +30,12 @@ static void applyClientDurationAdvice(DoubleHistogramBuilder builder) { attributes.add(SemanticAttributes.RPC_METHOD); attributes.add(SemanticAttributes.RPC_GRPC_STATUS_CODE); if (SemconvStability.emitStableHttpSemconv()) { - attributes.add(NetworkAttributes.NETWORK_TYPE); - attributes.add(NetworkAttributes.NETWORK_TRANSPORT); - attributes.add(NetworkAttributes.SERVER_ADDRESS); - attributes.add(NetworkAttributes.SERVER_PORT); - attributes.add(NetworkAttributes.SERVER_SOCKET_ADDRESS); - attributes.add(NetworkAttributes.SERVER_SOCKET_PORT); + attributes.add(SemanticAttributes.NETWORK_TYPE); + attributes.add(SemanticAttributes.NETWORK_TRANSPORT); + attributes.add(SemanticAttributes.SERVER_ADDRESS); + attributes.add(SemanticAttributes.SERVER_PORT); + attributes.add(SemanticAttributes.SERVER_SOCKET_ADDRESS); + attributes.add(SemanticAttributes.SERVER_SOCKET_PORT); } if (SemconvStability.emitOldHttpSemconv()) { attributes.add(SemanticAttributes.NET_PEER_NAME); @@ -63,12 +62,12 @@ static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { attributes.add(SemanticAttributes.RPC_METHOD); attributes.add(SemanticAttributes.RPC_GRPC_STATUS_CODE); if (SemconvStability.emitStableHttpSemconv()) { - attributes.add(NetworkAttributes.NETWORK_TYPE); - attributes.add(NetworkAttributes.NETWORK_TRANSPORT); - attributes.add(NetworkAttributes.SERVER_ADDRESS); - attributes.add(NetworkAttributes.SERVER_PORT); - attributes.add(NetworkAttributes.SERVER_SOCKET_ADDRESS); - attributes.add(NetworkAttributes.SERVER_SOCKET_PORT); + attributes.add(SemanticAttributes.NETWORK_TYPE); + attributes.add(SemanticAttributes.NETWORK_TRANSPORT); + attributes.add(SemanticAttributes.SERVER_ADDRESS); + attributes.add(SemanticAttributes.SERVER_PORT); + attributes.add(SemanticAttributes.SERVER_SOCKET_ADDRESS); + attributes.add(SemanticAttributes.SERVER_SOCKET_PORT); } if (SemconvStability.emitOldHttpSemconv()) { attributes.add(SemanticAttributes.NET_HOST_NAME); diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/InternalUrlAttributesExtractor.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/InternalUrlAttributesExtractor.java index 018e5eb1b8a4..ace4bd8d1147 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/InternalUrlAttributesExtractor.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/InternalUrlAttributesExtractor.java @@ -42,9 +42,9 @@ public void onStart(AttributesBuilder attributes, REQUEST request) { String urlQuery = getter.getUrlQuery(request); if (emitStableUrlAttributes) { - internalSet(attributes, UrlAttributes.URL_SCHEME, urlScheme); - internalSet(attributes, UrlAttributes.URL_PATH, urlPath); - internalSet(attributes, UrlAttributes.URL_QUERY, urlQuery); + internalSet(attributes, SemanticAttributes.URL_SCHEME, urlScheme); + internalSet(attributes, SemanticAttributes.URL_PATH, urlPath); + internalSet(attributes, SemanticAttributes.URL_QUERY, urlQuery); } if (emitOldHttpAttributes) { internalSet(attributes, SemanticAttributes.HTTP_SCHEME, urlScheme); diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/UrlAttributes.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/UrlAttributes.java deleted file mode 100644 index 01b8eb37c550..000000000000 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/url/internal/UrlAttributes.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.api.instrumenter.url.internal; - -import static io.opentelemetry.api.common.AttributeKey.stringKey; - -import io.opentelemetry.api.common.AttributeKey; - -/** - * This class is internal and is hence not for public use. Its APIs are unstable and can change at - * any time. - */ -public final class UrlAttributes { - - // FIXME: remove this class and replace its usages with SemanticAttributes once schema 1.21 is - // released - - public static final AttributeKey URL_FULL = stringKey("url.full"); - - public static final AttributeKey URL_SCHEME = stringKey("url.scheme"); - - public static final AttributeKey URL_PATH = stringKey("url.path"); - - public static final AttributeKey URL_QUERY = stringKey("url.query"); - - private UrlAttributes() {} -} diff --git a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlAttributesExtractorTest.java b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlAttributesExtractorTest.java index 3e0ab4446456..bf6eebe6ecda 100644 --- a/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlAttributesExtractorTest.java +++ b/instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/url/UrlAttributesExtractorTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -56,9 +56,9 @@ void allAttributes() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(UrlAttributes.URL_SCHEME, "https"), - entry(UrlAttributes.URL_PATH, "/test"), - entry(UrlAttributes.URL_QUERY, "q=Java")); + entry(SemanticAttributes.URL_SCHEME, "https"), + entry(SemanticAttributes.URL_PATH, "/test"), + entry(SemanticAttributes.URL_QUERY, "q=Java")); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); diff --git a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorBothSemconvTest.java b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorBothSemconvTest.java index 85fa031ee0a7..7a98494dad46 100644 --- a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorBothSemconvTest.java +++ b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorBothSemconvTest.java @@ -16,9 +16,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.List; @@ -138,37 +135,37 @@ void normal() { assertThat(startAttributes.build()) .containsOnly( entry(SemanticAttributes.HTTP_METHOD, "POST"), - entry(HttpAttributes.HTTP_REQUEST_METHOD, "POST"), + entry(SemanticAttributes.HTTP_REQUEST_METHOD, "POST"), entry(SemanticAttributes.HTTP_URL, "http://github.com"), - entry(UrlAttributes.URL_FULL, "http://github.com"), + entry(SemanticAttributes.URL_FULL, "http://github.com"), entry(SemanticAttributes.USER_AGENT_ORIGINAL, "okhttp 3.x"), entry( AttributeKey.stringArrayKey("http.request.header.custom_request_header"), asList("123", "456")), entry(SemanticAttributes.NET_PEER_NAME, "github.com"), entry(SemanticAttributes.NET_PEER_PORT, 123L), - entry(NetworkAttributes.SERVER_ADDRESS, "github.com"), - entry(NetworkAttributes.SERVER_PORT, 123L)); + entry(SemanticAttributes.SERVER_ADDRESS, "github.com"), + entry(SemanticAttributes.SERVER_PORT, 123L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, response, null); assertThat(endAttributes.build()) .containsOnly( entry(SemanticAttributes.HTTP_REQUEST_CONTENT_LENGTH, 10L), - entry(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 10L), + entry(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 10L), entry(SemanticAttributes.HTTP_STATUS_CODE, 202L), - entry(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), + entry(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), entry(SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH, 20L), - entry(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), + entry(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), entry(SemanticAttributes.HTTP_RESEND_COUNT, 2L), entry( AttributeKey.stringArrayKey("http.response.header.custom_response_header"), asList("654", "321")), entry(SemanticAttributes.NET_PROTOCOL_NAME, "http"), entry(SemanticAttributes.NET_PROTOCOL_VERSION, "1.1"), - entry(NetworkAttributes.NETWORK_TRANSPORT, "udp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv4"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); + entry(SemanticAttributes.NETWORK_TRANSPORT, "udp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv4"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); } } diff --git a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorBothSemconvTest.java b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorBothSemconvTest.java index 42991c27b9ac..d8d854207f19 100644 --- a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorBothSemconvTest.java +++ b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorBothSemconvTest.java @@ -16,9 +16,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.List; @@ -159,18 +156,18 @@ void normal() { assertThat(startAttributes.build()) .containsOnly( entry(SemanticAttributes.NET_HOST_NAME, "github.com"), - entry(NetworkAttributes.SERVER_ADDRESS, "github.com"), + entry(SemanticAttributes.SERVER_ADDRESS, "github.com"), entry(SemanticAttributes.HTTP_METHOD, "POST"), - entry(HttpAttributes.HTTP_REQUEST_METHOD, "POST"), + entry(SemanticAttributes.HTTP_REQUEST_METHOD, "POST"), entry(SemanticAttributes.HTTP_SCHEME, "http"), entry(SemanticAttributes.HTTP_TARGET, "/repositories/1?details=true"), - entry(UrlAttributes.URL_SCHEME, "http"), - entry(UrlAttributes.URL_PATH, "/repositories/1"), - entry(UrlAttributes.URL_QUERY, "details=true"), + entry(SemanticAttributes.URL_SCHEME, "http"), + entry(SemanticAttributes.URL_PATH, "/repositories/1"), + entry(SemanticAttributes.URL_QUERY, "details=true"), entry(SemanticAttributes.USER_AGENT_ORIGINAL, "okhttp 3.x"), entry(SemanticAttributes.HTTP_ROUTE, "/repositories/{id}"), entry(SemanticAttributes.HTTP_CLIENT_IP, "1.1.1.1"), - entry(NetworkAttributes.CLIENT_ADDRESS, "1.1.1.1"), + entry(SemanticAttributes.CLIENT_ADDRESS, "1.1.1.1"), entry( AttributeKey.stringArrayKey("http.request.header.custom_request_header"), asList("123", "456"))); @@ -181,17 +178,17 @@ void normal() { .containsOnly( entry(SemanticAttributes.NET_PROTOCOL_NAME, "http"), entry(SemanticAttributes.NET_PROTOCOL_VERSION, "2.0"), - entry(NetworkAttributes.NETWORK_TRANSPORT, "udp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv4"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + entry(SemanticAttributes.NETWORK_TRANSPORT, "udp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv4"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), entry(SemanticAttributes.HTTP_ROUTE, "/repositories/{repoId}"), entry(SemanticAttributes.HTTP_REQUEST_CONTENT_LENGTH, 10L), - entry(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 10L), + entry(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 10L), entry(SemanticAttributes.HTTP_STATUS_CODE, 202L), - entry(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), + entry(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), entry(SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH, 20L), - entry(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), + entry(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), entry( AttributeKey.stringArrayKey("http.response.header.custom_response_header"), asList("654", "321"))); diff --git a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorBothSemconvTest.java b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorBothSemconvTest.java index 33d97cf3f0ad..2bb799eaee0a 100644 --- a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorBothSemconvTest.java +++ b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorBothSemconvTest.java @@ -13,7 +13,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; @@ -126,24 +125,24 @@ void normal() { .containsOnly( entry(SemanticAttributes.NET_PEER_NAME, "opentelemetry.io"), entry(SemanticAttributes.NET_PEER_PORT, 42L), - entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.SERVER_PORT, 42L)); + entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.SERVER_PORT, 42L)); assertThat(endAttributes.build()) .containsOnly( entry(SemanticAttributes.NET_TRANSPORT, IP_TCP), entry(SemanticAttributes.NET_PROTOCOL_NAME, "http"), entry(SemanticAttributes.NET_PROTOCOL_VERSION, "1.1"), - entry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv6"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), + entry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv6"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), entry(SemanticAttributes.NET_SOCK_FAMILY, "inet6"), entry(SemanticAttributes.NET_SOCK_PEER_ADDR, "1:2:3:4::"), entry(SemanticAttributes.NET_SOCK_PEER_NAME, "proxy.opentelemetry.io"), entry(SemanticAttributes.NET_SOCK_PEER_PORT, 123L), - entry(NetworkAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1:2:3:4::"), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 123L)); + entry(SemanticAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1:2:3:4::"), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 123L)); } } diff --git a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorBothSemconvTest.java b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorBothSemconvTest.java index ee89adceb098..f1301379eedc 100644 --- a/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorBothSemconvTest.java +++ b/instrumentation-api-semconv/src/testBothHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorBothSemconvTest.java @@ -13,7 +13,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; @@ -134,24 +133,24 @@ void normal() { entry(SemanticAttributes.NET_TRANSPORT, IP_TCP), entry(SemanticAttributes.NET_HOST_NAME, "opentelemetry.io"), entry(SemanticAttributes.NET_HOST_PORT, 80L), - entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.SERVER_PORT, 80L), + entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.SERVER_PORT, 80L), entry(SemanticAttributes.NET_SOCK_FAMILY, "inet6")); assertThat(endAttributes.build()) .containsOnly( entry(SemanticAttributes.NET_SOCK_HOST_ADDR, "4:3:2:1::"), entry(SemanticAttributes.NET_SOCK_HOST_PORT, 8080L), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "4:3:2:1::"), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 8080L), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "4:3:2:1::"), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 8080L), entry(SemanticAttributes.NET_SOCK_PEER_ADDR, "1:2:3:4::"), entry(SemanticAttributes.NET_SOCK_PEER_PORT, 42L), - entry(NetworkAttributes.CLIENT_SOCKET_ADDRESS, "1:2:3:4::"), - entry(NetworkAttributes.CLIENT_SOCKET_PORT, 42L), - entry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv6"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), + entry(SemanticAttributes.CLIENT_SOCKET_ADDRESS, "1:2:3:4::"), + entry(SemanticAttributes.CLIENT_SOCKET_PORT, 42L), + entry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv6"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), entry(SemanticAttributes.NET_PROTOCOL_NAME, "http"), entry(SemanticAttributes.NET_PROTOCOL_VERSION, "1.1")); } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorStableSemconvTest.java index 98e450dc0b46..fa9e6e2eef54 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientAttributesExtractorStableSemconvTest.java @@ -18,9 +18,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.HttpConstants; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; @@ -148,30 +145,30 @@ void normal() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(HttpAttributes.HTTP_REQUEST_METHOD, "POST"), - entry(UrlAttributes.URL_FULL, "http://github.com"), + entry(SemanticAttributes.HTTP_REQUEST_METHOD, "POST"), + entry(SemanticAttributes.URL_FULL, "http://github.com"), entry(SemanticAttributes.USER_AGENT_ORIGINAL, "okhttp 3.x"), entry( AttributeKey.stringArrayKey("http.request.header.custom_request_header"), asList("123", "456")), - entry(NetworkAttributes.SERVER_ADDRESS, "github.com"), - entry(NetworkAttributes.SERVER_PORT, 123L)); + entry(SemanticAttributes.SERVER_ADDRESS, "github.com"), + entry(SemanticAttributes.SERVER_PORT, 123L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, response, null); assertThat(endAttributes.build()) .containsOnly( - entry(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 10L), - entry(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), - entry(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), + entry(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 10L), + entry(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), + entry(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), entry(SemanticAttributes.HTTP_RESEND_COUNT, 2L), entry( AttributeKey.stringArrayKey("http.response.header.custom_response_header"), asList("654", "321")), - entry(NetworkAttributes.NETWORK_TRANSPORT, "udp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv4"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); + entry(SemanticAttributes.NETWORK_TRANSPORT, "udp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv4"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); } @ParameterizedTest @@ -195,9 +192,9 @@ void skipNetworkTransportIfDefaultForProtocol( if (extractedTransport != null) { assertThat(attributes.build()) - .containsEntry(NetworkAttributes.NETWORK_TRANSPORT, extractedTransport); + .containsEntry(SemanticAttributes.NETWORK_TRANSPORT, extractedTransport); } else { - assertThat(attributes.build()).doesNotContainKey(NetworkAttributes.NETWORK_TRANSPORT); + assertThat(attributes.build()).doesNotContainKey(SemanticAttributes.NETWORK_TRANSPORT); } } @@ -231,8 +228,8 @@ void shouldExtractKnownMethods(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, requestMethod) - .doesNotContainKey(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, requestMethod) + .doesNotContainKey(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL); } @ParameterizedTest @@ -249,8 +246,8 @@ void shouldTreatMethodsAsCaseSensitive(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } @ParameterizedTest @@ -267,8 +264,8 @@ void shouldUseOtherForUnknownMethods(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } @ParameterizedTest @@ -287,8 +284,8 @@ void shouldExtractKnownMethods_override(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, requestMethod) - .doesNotContainKey(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, requestMethod) + .doesNotContainKey(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL); } @ParameterizedTest @@ -307,7 +304,7 @@ void shouldUseOtherForUnknownMethods_override(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientExperimentalMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientExperimentalMetricsStableSemconvTest.java index 6b22eabc2bbe..c3def5c219bc 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientExperimentalMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientExperimentalMetricsStableSemconvTest.java @@ -15,11 +15,9 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; @@ -36,25 +34,25 @@ void collectsMetrics() { Attributes requestAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_REQUEST_METHOD, "GET") - .put(UrlAttributes.URL_FULL, "https://localhost:1234/") - .put(UrlAttributes.URL_SCHEME, "https") - .put(UrlAttributes.URL_PATH, "/") - .put(UrlAttributes.URL_QUERY, "q=a") - .put(NetworkAttributes.SERVER_ADDRESS, "localhost") - .put(NetworkAttributes.SERVER_PORT, 1234) + .put(SemanticAttributes.HTTP_REQUEST_METHOD, "GET") + .put(SemanticAttributes.URL_FULL, "https://localhost:1234/") + .put(SemanticAttributes.URL_SCHEME, "https") + .put(SemanticAttributes.URL_PATH, "/") + .put(SemanticAttributes.URL_QUERY, "q=a") + .put(SemanticAttributes.SERVER_ADDRESS, "localhost") + .put(SemanticAttributes.SERVER_PORT, 1234) .build(); Attributes responseAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200) - .put(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 100) - .put(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 200) - .put(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http") - .put(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0") - .put(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4") - .put(NetworkAttributes.SERVER_SOCKET_DOMAIN, "somehost20") - .put(NetworkAttributes.SERVER_SOCKET_PORT, 8080) + .put(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200) + .put(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 100) + .put(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 200) + .put(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http") + .put(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0") + .put(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4") + .put(SemanticAttributes.SERVER_SOCKET_DOMAIN, "somehost20") + .put(SemanticAttributes.SERVER_SOCKET_PORT, 8080) .build(); Context parent = @@ -90,16 +88,18 @@ void collectsMetrics() { point .hasSum(100 /* bytes */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(NetworkAttributes.SERVER_ADDRESS, "localhost"), - equalTo(NetworkAttributes.SERVER_PORT, 1234), + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), equalTo( - NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4")) + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.SERVER_ADDRESS, "localhost"), + equalTo(SemanticAttributes.SERVER_PORT, 1234), + equalTo( + SemanticAttributes.SERVER_SOCKET_ADDRESS, + "1.2.3.4")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -116,16 +116,18 @@ void collectsMetrics() { point .hasSum(200 /* bytes */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), + equalTo( + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(NetworkAttributes.SERVER_ADDRESS, "localhost"), - equalTo(NetworkAttributes.SERVER_PORT, 1234), + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.SERVER_ADDRESS, "localhost"), + equalTo(SemanticAttributes.SERVER_PORT, 1234), equalTo( - NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4")) + SemanticAttributes.SERVER_SOCKET_ADDRESS, + "1.2.3.4")) .hasExemplarsSatisfying( exemplar -> exemplar diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java index a843fd3017b6..abe819dd15fb 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java @@ -15,11 +15,9 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; @@ -38,25 +36,25 @@ void collectsMetrics() { Attributes requestAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_REQUEST_METHOD, "GET") - .put(UrlAttributes.URL_FULL, "https://localhost:1234/") - .put(UrlAttributes.URL_SCHEME, "https") - .put(UrlAttributes.URL_PATH, "/") - .put(UrlAttributes.URL_QUERY, "q=a") - .put(NetworkAttributes.SERVER_ADDRESS, "localhost") - .put(NetworkAttributes.SERVER_PORT, 1234) + .put(SemanticAttributes.HTTP_REQUEST_METHOD, "GET") + .put(SemanticAttributes.URL_FULL, "https://localhost:1234/") + .put(SemanticAttributes.URL_SCHEME, "https") + .put(SemanticAttributes.URL_PATH, "/") + .put(SemanticAttributes.URL_QUERY, "q=a") + .put(SemanticAttributes.SERVER_ADDRESS, "localhost") + .put(SemanticAttributes.SERVER_PORT, 1234) .build(); Attributes responseAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200) - .put(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 100) - .put(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 200) - .put(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http") - .put(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0") - .put(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4") - .put(NetworkAttributes.SERVER_SOCKET_DOMAIN, "somehost20") - .put(NetworkAttributes.SERVER_SOCKET_PORT, 8080) + .put(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200) + .put(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 100) + .put(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 200) + .put(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http") + .put(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0") + .put(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4") + .put(SemanticAttributes.SERVER_SOCKET_DOMAIN, "somehost20") + .put(SemanticAttributes.SERVER_SOCKET_PORT, 8080) .build(); Context parent = @@ -92,16 +90,18 @@ void collectsMetrics() { point .hasSum(0.15 /* seconds */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(NetworkAttributes.SERVER_ADDRESS, "localhost"), - equalTo(NetworkAttributes.SERVER_PORT, 1234), + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), equalTo( - NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4")) + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.SERVER_ADDRESS, "localhost"), + equalTo(SemanticAttributes.SERVER_PORT, 1234), + equalTo( + SemanticAttributes.SERVER_SOCKET_ADDRESS, + "1.2.3.4")) .hasExemplarsSatisfying( exemplar -> exemplar diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorStableSemconvTest.java index 10bd0bd800d0..6722784a6917 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerAttributesExtractorStableSemconvTest.java @@ -18,9 +18,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.HttpConstants; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; @@ -186,14 +183,14 @@ void normal() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_ADDRESS, "github.com"), - entry(HttpAttributes.HTTP_REQUEST_METHOD, "POST"), - entry(UrlAttributes.URL_SCHEME, "http"), - entry(UrlAttributes.URL_PATH, "/repositories/1"), - entry(UrlAttributes.URL_QUERY, "details=true"), + entry(SemanticAttributes.SERVER_ADDRESS, "github.com"), + entry(SemanticAttributes.HTTP_REQUEST_METHOD, "POST"), + entry(SemanticAttributes.URL_SCHEME, "http"), + entry(SemanticAttributes.URL_PATH, "/repositories/1"), + entry(SemanticAttributes.URL_QUERY, "details=true"), entry(SemanticAttributes.USER_AGENT_ORIGINAL, "okhttp 3.x"), entry(SemanticAttributes.HTTP_ROUTE, "/repositories/{id}"), - entry(NetworkAttributes.CLIENT_ADDRESS, "1.1.1.1"), + entry(SemanticAttributes.CLIENT_ADDRESS, "1.1.1.1"), entry( AttributeKey.stringArrayKey("http.request.header.custom_request_header"), asList("123", "456"))); @@ -202,14 +199,14 @@ void normal() { extractor.onEnd(endAttributes, Context.root(), request, response, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.NETWORK_TRANSPORT, "udp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv4"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + entry(SemanticAttributes.NETWORK_TRANSPORT, "udp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv4"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), entry(SemanticAttributes.HTTP_ROUTE, "/repositories/{repoId}"), - entry(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 10L), - entry(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), - entry(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), + entry(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 10L), + entry(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 202L), + entry(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 20L), entry( AttributeKey.stringArrayKey("http.response.header.custom_response_header"), asList("654", "321"))); @@ -236,9 +233,9 @@ void skipNetworkTransportIfDefaultForProtocol( if (extractedTransport != null) { assertThat(attributes.build()) - .containsEntry(NetworkAttributes.NETWORK_TRANSPORT, extractedTransport); + .containsEntry(SemanticAttributes.NETWORK_TRANSPORT, extractedTransport); } else { - assertThat(attributes.build()).doesNotContainKey(NetworkAttributes.NETWORK_TRANSPORT); + assertThat(attributes.build()).doesNotContainKey(SemanticAttributes.NETWORK_TRANSPORT); } } @@ -272,8 +269,8 @@ void shouldExtractKnownMethods(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, requestMethod) - .doesNotContainKey(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, requestMethod) + .doesNotContainKey(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL); } @ParameterizedTest @@ -290,8 +287,8 @@ void shouldTreatMethodsAsCaseSensitive(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } @ParameterizedTest @@ -308,8 +305,8 @@ void shouldUseOtherForUnknownMethods(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } @ParameterizedTest @@ -328,8 +325,8 @@ void shouldExtractKnownMethods_override(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, requestMethod) - .doesNotContainKey(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, requestMethod) + .doesNotContainKey(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL); } @ParameterizedTest @@ -348,7 +345,7 @@ void shouldUseOtherForUnknownMethods_override(String requestMethod) { extractor.onEnd(attributes, Context.root(), request, emptyMap(), null); assertThat(attributes.build()) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) - .containsEntry(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD, HttpConstants._OTHER) + .containsEntry(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, requestMethod); } } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerExperimentalMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerExperimentalMetricsStableSemconvTest.java index a3562317ba23..16c719c38e74 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerExperimentalMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerExperimentalMetricsStableSemconvTest.java @@ -15,11 +15,9 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; @@ -36,27 +34,27 @@ void collectsMetrics() { Attributes requestAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_REQUEST_METHOD, "GET") - .put(UrlAttributes.URL_SCHEME, "https") - .put(UrlAttributes.URL_PATH, "/") - .put(UrlAttributes.URL_QUERY, "q=a") - .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") - .put(NetworkAttributes.NETWORK_TYPE, "ipv4") - .put(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http") - .put(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0") - .put(NetworkAttributes.SERVER_ADDRESS, "localhost") - .put(NetworkAttributes.SERVER_PORT, 1234) + .put(SemanticAttributes.HTTP_REQUEST_METHOD, "GET") + .put(SemanticAttributes.URL_SCHEME, "https") + .put(SemanticAttributes.URL_PATH, "/") + .put(SemanticAttributes.URL_QUERY, "q=a") + .put(SemanticAttributes.NETWORK_TRANSPORT, "tcp") + .put(SemanticAttributes.NETWORK_TYPE, "ipv4") + .put(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http") + .put(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0") + .put(SemanticAttributes.SERVER_ADDRESS, "localhost") + .put(SemanticAttributes.SERVER_PORT, 1234) .build(); Attributes responseAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200) - .put(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 100) - .put(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 200) - .put(NetworkAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4") - .put(NetworkAttributes.CLIENT_SOCKET_PORT, 8080) - .put(NetworkAttributes.SERVER_SOCKET_ADDRESS, "4.3.2.1") - .put(NetworkAttributes.SERVER_SOCKET_PORT, 9090) + .put(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200) + .put(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 100) + .put(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 200) + .put(SemanticAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4") + .put(SemanticAttributes.CLIENT_SOCKET_PORT, 8080) + .put(SemanticAttributes.SERVER_SOCKET_ADDRESS, "4.3.2.1") + .put(SemanticAttributes.SERVER_SOCKET_PORT, 9090) .build(); SpanContext spanContext1 = @@ -90,8 +88,8 @@ void collectsMetrics() { point .hasValue(1) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -113,8 +111,8 @@ void collectsMetrics() { point .hasValue(2) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -135,8 +133,8 @@ void collectsMetrics() { point .hasValue(1) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -153,13 +151,14 @@ void collectsMetrics() { point .hasSum(100 /* bytes */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + equalTo( + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -176,13 +175,14 @@ void collectsMetrics() { point .hasSum(200 /* bytes */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), + equalTo( + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java index 6f8a132ed4aa..e2ed2cb950be 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java @@ -15,9 +15,6 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.SemanticAttributes; @@ -39,27 +36,27 @@ void collectsMetrics() { Attributes requestAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_REQUEST_METHOD, "GET") - .put(UrlAttributes.URL_SCHEME, "https") - .put(UrlAttributes.URL_PATH, "/") - .put(UrlAttributes.URL_QUERY, "q=a") - .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") - .put(NetworkAttributes.NETWORK_TYPE, "ipv4") - .put(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http") - .put(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0") - .put(NetworkAttributes.SERVER_ADDRESS, "localhost") - .put(NetworkAttributes.SERVER_PORT, 1234) + .put(SemanticAttributes.HTTP_REQUEST_METHOD, "GET") + .put(SemanticAttributes.URL_SCHEME, "https") + .put(SemanticAttributes.URL_PATH, "/") + .put(SemanticAttributes.URL_QUERY, "q=a") + .put(SemanticAttributes.NETWORK_TRANSPORT, "tcp") + .put(SemanticAttributes.NETWORK_TYPE, "ipv4") + .put(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http") + .put(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0") + .put(SemanticAttributes.SERVER_ADDRESS, "localhost") + .put(SemanticAttributes.SERVER_PORT, 1234) .build(); Attributes responseAttributes = Attributes.builder() - .put(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200) - .put(HttpAttributes.HTTP_REQUEST_BODY_SIZE, 100) - .put(HttpAttributes.HTTP_RESPONSE_BODY_SIZE, 200) - .put(NetworkAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4") - .put(NetworkAttributes.CLIENT_SOCKET_PORT, 8080) - .put(NetworkAttributes.SERVER_SOCKET_ADDRESS, "4.3.2.1") - .put(NetworkAttributes.SERVER_SOCKET_PORT, 9090) + .put(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200) + .put(SemanticAttributes.HTTP_REQUEST_BODY_SIZE, 100) + .put(SemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 200) + .put(SemanticAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4") + .put(SemanticAttributes.CLIENT_SOCKET_PORT, 8080) + .put(SemanticAttributes.SERVER_SOCKET_ADDRESS, "4.3.2.1") + .put(SemanticAttributes.SERVER_SOCKET_PORT, 9090) .build(); SpanContext spanContext1 = @@ -96,13 +93,14 @@ void collectsMetrics() { point .hasSum(0.15 /* seconds */) .hasAttributesSatisfying( - equalTo(HttpAttributes.HTTP_REQUEST_METHOD, "GET"), - equalTo(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, 200), + equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200), equalTo( - NetworkAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), - equalTo(UrlAttributes.URL_SCHEME, "https")) + SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + equalTo( + SemanticAttributes.NETWORK_PROTOCOL_VERSION, "2.0"), + equalTo(SemanticAttributes.URL_SCHEME, "https")) .hasExemplarsSatisfying( exemplar -> exemplar @@ -141,8 +139,8 @@ void collectsHttpRouteFromEndAttributes() { Attributes requestAttributes = Attributes.builder() - .put(NetworkAttributes.SERVER_ADDRESS, "host") - .put(UrlAttributes.URL_SCHEME, "https") + .put(SemanticAttributes.SERVER_ADDRESS, "host") + .put(SemanticAttributes.URL_SCHEME, "https") .build(); Attributes responseAttributes = @@ -168,7 +166,7 @@ void collectsHttpRouteFromEndAttributes() { point .hasSum(0.100 /* seconds */) .hasAttributesSatisfying( - equalTo(UrlAttributes.URL_SCHEME, "https"), + equalTo(SemanticAttributes.URL_SCHEME, "https"), equalTo( SemanticAttributes.HTTP_ROUTE, "/test/{id}"))))); } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorStableSemconvTest.java index e7c5b158f5cd..b27fdbe9bb96 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetClientAttributesExtractorStableSemconvTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -123,17 +123,17 @@ void normal() { // then assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.SERVER_PORT, 42L)); + entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.SERVER_PORT, 42L)); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv6"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), - entry(NetworkAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1:2:3:4::"), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 123L)); + entry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv6"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), + entry(SemanticAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1:2:3:4::"), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 123L)); } } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorStableSemconvTest.java index 8cadd0bdfc7b..c44698dae7f1 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/net/NetServerAttributesExtractorStableSemconvTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -130,18 +130,18 @@ void normal() { // then assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.SERVER_PORT, 80L)); + entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.SERVER_PORT, 80L)); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv6"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "4:3:2:1::"), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 8080L), - entry(NetworkAttributes.CLIENT_SOCKET_ADDRESS, "1:2:3:4::"), - entry(NetworkAttributes.CLIENT_SOCKET_PORT, 42L)); + entry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv6"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "4:3:2:1::"), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 8080L), + entry(SemanticAttributes.CLIENT_SOCKET_ADDRESS, "1:2:3:4::"), + entry(SemanticAttributes.CLIENT_SOCKET_PORT, 42L)); } } diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorInetSocketAddressTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorInetSocketAddressTest.java index 0fffabab012a..70ecb02d7c00 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorInetSocketAddressTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorInetSocketAddressTest.java @@ -12,7 +12,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.net.InetSocketAddress; import javax.annotation.Nullable; import org.junit.jupiter.api.Test; @@ -61,8 +61,8 @@ void fullAddress() { extractor.onEnd(endAttributes, Context.root(), address, null, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.CLIENT_SOCKET_ADDRESS, address.getAddress().getHostAddress()), - entry(NetworkAttributes.CLIENT_SOCKET_PORT, 456L)); + entry(SemanticAttributes.CLIENT_SOCKET_ADDRESS, address.getAddress().getHostAddress()), + entry(SemanticAttributes.CLIENT_SOCKET_PORT, 456L)); } @Test diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorTest.java index d42f97a31e0f..170d70fcc6c9 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ClientAttributesExtractorTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -66,15 +66,15 @@ void allAttributes() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.CLIENT_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.CLIENT_PORT, 80L)); + entry(SemanticAttributes.CLIENT_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.CLIENT_PORT, 80L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4"), - entry(NetworkAttributes.CLIENT_SOCKET_PORT, 8080L)); + entry(SemanticAttributes.CLIENT_SOCKET_ADDRESS, "1.2.3.4"), + entry(SemanticAttributes.CLIENT_SOCKET_PORT, 8080L)); } @Test @@ -124,8 +124,8 @@ void doesNotSetDuplicates() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.CLIENT_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.CLIENT_PORT, 80L)); + entry(SemanticAttributes.CLIENT_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.CLIENT_PORT, 80L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/NetworkAttributesExtractorTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/NetworkAttributesExtractorTest.java index 937031406651..4bc8edbf2c64 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/NetworkAttributesExtractorTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/NetworkAttributesExtractorTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -68,10 +68,10 @@ void allAttributes() { extractor.onEnd(endAttributes, Context.root(), request, null, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), - entry(NetworkAttributes.NETWORK_TYPE, "ipv4"), - entry(NetworkAttributes.NETWORK_PROTOCOL_NAME, "http"), - entry(NetworkAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); + entry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"), + entry(SemanticAttributes.NETWORK_TYPE, "ipv4"), + entry(SemanticAttributes.NETWORK_PROTOCOL_NAME, "http"), + entry(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1")); } @Test diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorInetSocketAddressTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorInetSocketAddressTest.java index 42fe2a2336da..4926fd4a23fb 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorInetSocketAddressTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorInetSocketAddressTest.java @@ -12,7 +12,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.net.InetSocketAddress; import javax.annotation.Nullable; import org.junit.jupiter.api.Test; @@ -61,9 +61,9 @@ void fullAddress() { extractor.onEnd(endAttributes, Context.root(), address, null, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_SOCKET_DOMAIN, "api.github.com"), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, address.getAddress().getHostAddress()), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 456L)); + entry(SemanticAttributes.SERVER_SOCKET_DOMAIN, "api.github.com"), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, address.getAddress().getHostAddress()), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 456L)); } @Test diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorTest.java index 8f2806514c39..96d43e3b91d8 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/network/ServerAttributesExtractorTest.java @@ -13,7 +13,7 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; +import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; import java.util.Map; import javax.annotation.Nullable; @@ -73,16 +73,16 @@ void allAttributes() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io"), - entry(NetworkAttributes.SERVER_PORT, 80L)); + entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io"), + entry(SemanticAttributes.SERVER_PORT, 80L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); assertThat(endAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), - entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4"), - entry(NetworkAttributes.SERVER_SOCKET_PORT, 8080L)); + entry(SemanticAttributes.SERVER_SOCKET_DOMAIN, "proxy.opentelemetry.io"), + entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4"), + entry(SemanticAttributes.SERVER_SOCKET_PORT, 8080L)); } @Test @@ -113,12 +113,12 @@ void doesNotSetNegativePortValues() { AttributesBuilder startAttributes = Attributes.builder(); extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) - .containsOnly(entry(NetworkAttributes.SERVER_ADDRESS, "opentelemetry.io")); + .containsOnly(entry(SemanticAttributes.SERVER_ADDRESS, "opentelemetry.io")); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); assertThat(endAttributes.build()) - .containsOnly(entry(NetworkAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4")); + .containsOnly(entry(SemanticAttributes.SERVER_SOCKET_ADDRESS, "1.2.3.4")); } @Test @@ -137,8 +137,8 @@ void doesNotSetDuplicates() { extractor.onStart(startAttributes, Context.root(), request); assertThat(startAttributes.build()) .containsOnly( - entry(NetworkAttributes.SERVER_ADDRESS, "1.2.3.4"), - entry(NetworkAttributes.SERVER_PORT, 80L)); + entry(SemanticAttributes.SERVER_ADDRESS, "1.2.3.4"), + entry(SemanticAttributes.SERVER_PORT, 80L)); AttributesBuilder endAttributes = Attributes.builder(); extractor.onEnd(endAttributes, Context.root(), request, null, null); diff --git a/instrumentation/aws-lambda/aws-lambda-events-2.2/library/src/main/java/io/opentelemetry/instrumentation/awslambdaevents/v2_2/internal/ApiGatewayProxyAttributesExtractor.java b/instrumentation/aws-lambda/aws-lambda-events-2.2/library/src/main/java/io/opentelemetry/instrumentation/awslambdaevents/v2_2/internal/ApiGatewayProxyAttributesExtractor.java index d0c3e5424fa6..bdb42099cbd6 100644 --- a/instrumentation/aws-lambda/aws-lambda-events-2.2/library/src/main/java/io/opentelemetry/instrumentation/awslambdaevents/v2_2/internal/ApiGatewayProxyAttributesExtractor.java +++ b/instrumentation/aws-lambda/aws-lambda-events-2.2/library/src/main/java/io/opentelemetry/instrumentation/awslambdaevents/v2_2/internal/ApiGatewayProxyAttributesExtractor.java @@ -5,12 +5,12 @@ package io.opentelemetry.instrumentation.awslambdaevents.v2_2.internal; -import static io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes.HTTP_RESPONSE_STATUS_CODE; import static io.opentelemetry.instrumentation.api.internal.AttributesExtractorUtil.internalSet; import static io.opentelemetry.instrumentation.api.internal.HttpConstants._OTHER; import static io.opentelemetry.instrumentation.awslambdacore.v1_0.internal.MapUtils.emptyIfNull; import static io.opentelemetry.instrumentation.awslambdacore.v1_0.internal.MapUtils.lowercaseMap; import static io.opentelemetry.semconv.SemanticAttributes.FAAS_TRIGGER; +import static io.opentelemetry.semconv.SemanticAttributes.HTTP_RESPONSE_STATUS_CODE; import static io.opentelemetry.semconv.SemanticAttributes.HTTP_STATUS_CODE; import static io.opentelemetry.semconv.SemanticAttributes.USER_AGENT_ORIGINAL; @@ -19,8 +19,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.instrumentation.awslambdacore.v1_0.AwsLambdaRequest; import io.opentelemetry.semconv.SemanticAttributes; @@ -54,10 +52,10 @@ void onRequest(AttributesBuilder attributes, APIGatewayProxyRequestEvent request String method = request.getHttpMethod(); if (SemconvStability.emitStableHttpSemconv()) { if (method == null || knownMethods.contains(method)) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, method); } else { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, _OTHER); - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, _OTHER); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); } } if (SemconvStability.emitOldHttpSemconv()) { @@ -73,7 +71,7 @@ void onRequest(AttributesBuilder attributes, APIGatewayProxyRequestEvent request String httpUrl = getHttpUrl(request, headers); if (httpUrl != null) { if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, UrlAttributes.URL_FULL, httpUrl); + internalSet(attributes, SemanticAttributes.URL_FULL, httpUrl); } if (SemconvStability.emitOldHttpSemconv()) { diff --git a/instrumentation/camel-2.20/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachecamel/decorators/HttpSpanDecorator.java b/instrumentation/camel-2.20/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachecamel/decorators/HttpSpanDecorator.java index 56a27e534261..30a354844090 100644 --- a/instrumentation/camel-2.20/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachecamel/decorators/HttpSpanDecorator.java +++ b/instrumentation/camel-2.20/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/apachecamel/decorators/HttpSpanDecorator.java @@ -30,8 +30,6 @@ import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerRoute; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerRouteSource; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.javaagent.bootstrap.internal.CommonConfig; import io.opentelemetry.javaagent.instrumentation.apachecamel.CamelDirection; @@ -102,7 +100,7 @@ public void pre( String httpUrl = getHttpUrl(exchange, endpoint); if (httpUrl != null) { if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, UrlAttributes.URL_FULL, httpUrl); + internalSet(attributes, SemanticAttributes.URL_FULL, httpUrl); } if (SemconvStability.emitOldHttpSemconv()) { @@ -113,10 +111,10 @@ public void pre( String method = getHttpMethod(exchange, endpoint); if (SemconvStability.emitStableHttpSemconv()) { if (method == null || knownMethods.contains(method)) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, method); } else { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, _OTHER); - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, _OTHER); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); } } if (SemconvStability.emitOldHttpSemconv()) { @@ -185,7 +183,7 @@ public void post(AttributesBuilder attributes, Exchange exchange, Endpoint endpo Object responseCode = exchange.getOut().getHeader(Exchange.HTTP_RESPONSE_CODE); if (responseCode instanceof Integer) { if (SemconvStability.emitStableHttpSemconv()) { - attributes.put(HttpAttributes.HTTP_RESPONSE_STATUS_CODE, (Integer) responseCode); + attributes.put(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, (Integer) responseCode); } if (SemconvStability.emitOldHttpSemconv()) { attributes.put(SemanticAttributes.HTTP_STATUS_CODE, (Integer) responseCode); diff --git a/instrumentation/elasticsearch/elasticsearch-rest-common/library/src/main/java/io/opentelemetry/instrumentation/elasticsearch/rest/internal/ElasticsearchClientAttributeExtractor.java b/instrumentation/elasticsearch/elasticsearch-rest-common/library/src/main/java/io/opentelemetry/instrumentation/elasticsearch/rest/internal/ElasticsearchClientAttributeExtractor.java index b747f85c1572..0d81b3c705a0 100644 --- a/instrumentation/elasticsearch/elasticsearch-rest-common/library/src/main/java/io/opentelemetry/instrumentation/elasticsearch/rest/internal/ElasticsearchClientAttributeExtractor.java +++ b/instrumentation/elasticsearch/elasticsearch-rest-common/library/src/main/java/io/opentelemetry/instrumentation/elasticsearch/rest/internal/ElasticsearchClientAttributeExtractor.java @@ -12,9 +12,6 @@ import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.instrumentation.api.internal.cache.Cache; import io.opentelemetry.semconv.SemanticAttributes; @@ -46,8 +43,8 @@ private static void setServerAttributes(AttributesBuilder attributes, Response r HttpHost host = response.getHost(); if (host != null) { if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, NetworkAttributes.SERVER_ADDRESS, host.getHostName()); - internalSet(attributes, NetworkAttributes.SERVER_PORT, (long) host.getPort()); + internalSet(attributes, SemanticAttributes.SERVER_ADDRESS, host.getHostName()); + internalSet(attributes, SemanticAttributes.SERVER_PORT, (long) host.getPort()); } if (SemconvStability.emitOldHttpSemconv()) { internalSet(attributes, SemanticAttributes.NET_PEER_NAME, host.getHostName()); @@ -63,7 +60,7 @@ private static void setUrlAttribute(AttributesBuilder attributes, Response respo String fullUrl = response.getHost().toURI() + uri; if (SemconvStability.emitStableHttpSemconv()) { - internalSet(attributes, UrlAttributes.URL_FULL, fullUrl); + internalSet(attributes, SemanticAttributes.URL_FULL, fullUrl); } if (SemconvStability.emitOldHttpSemconv()) { @@ -95,10 +92,10 @@ public void onStart( String method = request.getMethod(); if (SemconvStability.emitStableHttpSemconv()) { if (method == null || knownMethods.contains(method)) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, method); } else { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, _OTHER); - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, _OTHER); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); } } if (SemconvStability.emitOldHttpSemconv()) { diff --git a/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpMethodAttributeExtractor.java b/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpMethodAttributeExtractor.java index 05ff16027243..fc988d4eeed8 100644 --- a/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpMethodAttributeExtractor.java +++ b/instrumentation/http-url-connection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/httpurlconnection/HttpMethodAttributeExtractor.java @@ -12,7 +12,6 @@ import io.opentelemetry.api.trace.Span; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; import java.net.HttpURLConnection; @@ -54,11 +53,11 @@ public void onEnd( // The getOutputStream() has transformed "GET" into "POST" if (SemconvStability.emitStableHttpSemconv()) { if (knownMethods.contains(method)) { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, method); - attributes.remove(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, method); + attributes.remove(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL); } else { - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD, _OTHER); - internalSet(attributes, HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD, _OTHER); + internalSet(attributes, SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method); } } if (SemconvStability.emitOldHttpSemconv()) { diff --git a/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ClientSslTest.groovy b/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ClientSslTest.groovy index 1a52fc9ad071..de637ac052a9 100644 --- a/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ClientSslTest.groovy +++ b/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ClientSslTest.groovy @@ -18,7 +18,7 @@ import io.netty.handler.codec.http.HttpHeaders import io.netty.handler.codec.http.HttpMethod import io.netty.handler.codec.http.HttpVersion import io.netty.handler.ssl.SslHandler -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes + import io.opentelemetry.instrumentation.api.internal.SemconvStability import io.opentelemetry.instrumentation.test.AgentInstrumentationSpecification import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestServer @@ -100,11 +100,11 @@ class Netty40ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -125,11 +125,11 @@ class Netty40ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_SOCKET_DOMAIN" uri.host - "$NetworkAttributes.SERVER_SOCKET_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_SOCKET_DOMAIN" uri.host + "$SemanticAttributes.SERVER_SOCKET_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -178,11 +178,11 @@ class Netty40ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -200,11 +200,11 @@ class Netty40ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_SOCKET_DOMAIN" uri.host - "$NetworkAttributes.SERVER_SOCKET_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_SOCKET_DOMAIN" uri.host + "$SemanticAttributes.SERVER_SOCKET_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } diff --git a/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ConnectionSpanTest.groovy b/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ConnectionSpanTest.groovy index 321aa799a827..b2bba7eb52b2 100644 --- a/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ConnectionSpanTest.groovy +++ b/instrumentation/netty/netty-4.0/javaagent/src/test/groovy/Netty40ConnectionSpanTest.groovy @@ -16,7 +16,7 @@ import io.netty.handler.codec.http.HttpClientCodec import io.netty.handler.codec.http.HttpHeaders import io.netty.handler.codec.http.HttpMethod import io.netty.handler.codec.http.HttpVersion -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes + import io.opentelemetry.instrumentation.api.internal.SemconvStability import io.opentelemetry.instrumentation.test.AgentTestTrait import io.opentelemetry.instrumentation.test.InstrumentationSpecification @@ -116,11 +116,11 @@ class Netty40ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -175,11 +175,11 @@ class Netty40ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" { it == "ipv4" || it == null } - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" { it == "127.0.0.1" || it == null } + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" { it == "ipv4" || it == null } + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" { it == "127.0.0.1" || it == null } } } } diff --git a/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ClientSslTest.groovy b/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ClientSslTest.groovy index 4828bde3e987..84860ba077a7 100644 --- a/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ClientSslTest.groovy +++ b/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ClientSslTest.groovy @@ -20,7 +20,7 @@ import io.netty.handler.codec.http.HttpVersion import io.netty.handler.ssl.SslContext import io.netty.handler.ssl.SslContextBuilder import io.netty.handler.ssl.SslHandler -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes + import io.opentelemetry.instrumentation.api.internal.SemconvStability import io.opentelemetry.instrumentation.netty.v4_1.ClientHandler import io.opentelemetry.instrumentation.test.AgentInstrumentationSpecification @@ -104,8 +104,8 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port } } } @@ -123,11 +123,11 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -148,11 +148,11 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_SOCKET_DOMAIN" uri.host - "$NetworkAttributes.SERVER_SOCKET_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_SOCKET_DOMAIN" uri.host + "$SemanticAttributes.SERVER_SOCKET_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -202,8 +202,8 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port } } } @@ -221,11 +221,11 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -243,11 +243,11 @@ class Netty41ClientSslTest extends AgentInstrumentationSpecification { } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_SOCKET_DOMAIN" uri.host - "$NetworkAttributes.SERVER_SOCKET_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_SOCKET_DOMAIN" uri.host + "$SemanticAttributes.SERVER_SOCKET_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } diff --git a/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ConnectionSpanTest.groovy b/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ConnectionSpanTest.groovy index 425d5626948a..016ef996204b 100644 --- a/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ConnectionSpanTest.groovy +++ b/instrumentation/netty/netty-4.1/javaagent/src/test/groovy/Netty41ConnectionSpanTest.groovy @@ -16,7 +16,7 @@ import io.netty.handler.codec.http.HttpClientCodec import io.netty.handler.codec.http.HttpHeaderNames import io.netty.handler.codec.http.HttpMethod import io.netty.handler.codec.http.HttpVersion -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes + import io.opentelemetry.instrumentation.api.internal.SemconvStability import io.opentelemetry.instrumentation.netty.v4_1.ClientHandler import io.opentelemetry.instrumentation.test.AgentTestTrait @@ -118,8 +118,8 @@ class Netty41ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port } } } @@ -137,11 +137,11 @@ class Netty41ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" "127.0.0.1" } } } @@ -195,8 +195,8 @@ class Netty41ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port } } } @@ -216,11 +216,11 @@ class Netty41ConnectionSpanTest extends InstrumentationSpecification implements } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.NETWORK_TRANSPORT" "tcp" - "$NetworkAttributes.NETWORK_TYPE" { it == "ipv4" || it == null } - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.SERVER_SOCKET_ADDRESS" { it == "127.0.0.1" || it == null } + "$SemanticAttributes.NETWORK_TRANSPORT" "tcp" + "$SemanticAttributes.NETWORK_TYPE" { it == "ipv4" || it == null } + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.SERVER_SOCKET_ADDRESS" { it == "127.0.0.1" || it == null } } } } diff --git a/instrumentation/undertow-1.4/javaagent/src/test/groovy/UndertowServerTest.groovy b/instrumentation/undertow-1.4/javaagent/src/test/groovy/UndertowServerTest.groovy index a3f544770ab5..e6050d7c9c2b 100644 --- a/instrumentation/undertow-1.4/javaagent/src/test/groovy/UndertowServerTest.groovy +++ b/instrumentation/undertow-1.4/javaagent/src/test/groovy/UndertowServerTest.groovy @@ -7,9 +7,7 @@ import io.opentelemetry.api.common.AttributeKey import io.opentelemetry.api.trace.Span import io.opentelemetry.api.trace.SpanKind import io.opentelemetry.api.trace.StatusCode -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes + import io.opentelemetry.instrumentation.api.internal.SemconvStability import io.opentelemetry.instrumentation.test.AgentTestTrait import io.opentelemetry.instrumentation.test.base.HttpServerTest @@ -166,20 +164,20 @@ class UndertowServerTest extends HttpServerTest implements AgentTestTr } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.CLIENT_ADDRESS" TEST_CLIENT_IP - "$UrlAttributes.URL_SCHEME" uri.getScheme() - "$UrlAttributes.URL_PATH" uri.getPath() - "$HttpAttributes.HTTP_REQUEST_METHOD" "GET" - "$HttpAttributes.HTTP_RESPONSE_STATUS_CODE" 200 + "$SemanticAttributes.CLIENT_ADDRESS" TEST_CLIENT_IP + "$SemanticAttributes.URL_SCHEME" uri.getScheme() + "$SemanticAttributes.URL_PATH" uri.getPath() + "$SemanticAttributes.HTTP_REQUEST_METHOD" "GET" + "$SemanticAttributes.HTTP_RESPONSE_STATUS_CODE" 200 "$SemanticAttributes.USER_AGENT_ORIGINAL" TEST_USER_AGENT - "$HttpAttributes.HTTP_RESPONSE_BODY_SIZE" Long - "$NetworkAttributes.NETWORK_PROTOCOL_NAME" "http" - "$NetworkAttributes.NETWORK_PROTOCOL_VERSION" "1.1" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.CLIENT_SOCKET_ADDRESS" "127.0.0.1" - "$NetworkAttributes.CLIENT_SOCKET_PORT" Long + "$SemanticAttributes.HTTP_RESPONSE_BODY_SIZE" Long + "$SemanticAttributes.NETWORK_PROTOCOL_NAME" "http" + "$SemanticAttributes.NETWORK_PROTOCOL_VERSION" "1.1" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.CLIENT_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.CLIENT_SOCKET_PORT" Long } } } @@ -238,20 +236,20 @@ class UndertowServerTest extends HttpServerTest implements AgentTestTr } if (SemconvStability.emitStableHttpSemconv()) { attributes { - "$NetworkAttributes.CLIENT_ADDRESS" TEST_CLIENT_IP - "$UrlAttributes.URL_SCHEME" uri.getScheme() - "$UrlAttributes.URL_PATH" uri.getPath() - "$HttpAttributes.HTTP_REQUEST_METHOD" "GET" - "$HttpAttributes.HTTP_RESPONSE_STATUS_CODE" 200 + "$SemanticAttributes.CLIENT_ADDRESS" TEST_CLIENT_IP + "$SemanticAttributes.URL_SCHEME" uri.getScheme() + "$SemanticAttributes.URL_PATH" uri.getPath() + "$SemanticAttributes.HTTP_REQUEST_METHOD" "GET" + "$SemanticAttributes.HTTP_RESPONSE_STATUS_CODE" 200 "$SemanticAttributes.USER_AGENT_ORIGINAL" TEST_USER_AGENT - "$HttpAttributes.HTTP_RESPONSE_BODY_SIZE" Long - "$NetworkAttributes.NETWORK_PROTOCOL_NAME" "http" - "$NetworkAttributes.NETWORK_PROTOCOL_VERSION" "1.1" - "$NetworkAttributes.NETWORK_TYPE" "ipv4" - "$NetworkAttributes.SERVER_ADDRESS" uri.host - "$NetworkAttributes.SERVER_PORT" uri.port - "$NetworkAttributes.CLIENT_SOCKET_ADDRESS" "127.0.0.1" - "$NetworkAttributes.CLIENT_SOCKET_PORT" Long + "$SemanticAttributes.HTTP_RESPONSE_BODY_SIZE" Long + "$SemanticAttributes.NETWORK_PROTOCOL_NAME" "http" + "$SemanticAttributes.NETWORK_PROTOCOL_VERSION" "1.1" + "$SemanticAttributes.NETWORK_TYPE" "ipv4" + "$SemanticAttributes.SERVER_ADDRESS" uri.host + "$SemanticAttributes.SERVER_PORT" uri.port + "$SemanticAttributes.CLIENT_SOCKET_ADDRESS" "127.0.0.1" + "$SemanticAttributes.CLIENT_SOCKET_PORT" Long } } } diff --git a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpClientTest.java b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpClientTest.java index 062aa5a07682..50d4ef081ea2 100644 --- a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpClientTest.java +++ b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpClientTest.java @@ -17,8 +17,6 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.SpanKind; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.instrumentation.api.internal.HttpConstants; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.instrumentation.test.utils.PortUtils; @@ -137,7 +135,7 @@ void requestWithNonStandardHttpMethod() throws Exception { span -> assertClientSpan(span, uri, HttpConstants._OTHER, responseCode, null) .hasNoParent() - .hasAttribute(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method))); + .hasAttribute(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method))); } @ParameterizedTest @@ -999,12 +997,12 @@ SpanDataAssert assertClientSpan( assertThat(attrs).containsEntry(SemanticAttributes.NET_TRANSPORT, IP_TCP); } if (SemconvStability.emitStableHttpSemconv() - && attrs.get(NetworkAttributes.NETWORK_TRANSPORT) != null) { - assertThat(attrs).containsEntry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"); + && attrs.get(SemanticAttributes.NETWORK_TRANSPORT) != null) { + assertThat(attrs).containsEntry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"); } if (SemconvStability.emitStableHttpSemconv() - && attrs.get(NetworkAttributes.NETWORK_TYPE) != null) { - assertThat(attrs).containsEntry(NetworkAttributes.NETWORK_TYPE, "ipv4"); + && attrs.get(SemanticAttributes.NETWORK_TYPE) != null) { + assertThat(attrs).containsEntry(SemanticAttributes.NETWORK_TYPE, "ipv4"); } AttributeKey netProtocolKey = getAttributeKey(SemanticAttributes.NET_PROTOCOL_NAME); diff --git a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java index c3dba18bff42..ac2544fac4ec 100644 --- a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java +++ b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java @@ -27,9 +27,6 @@ import io.opentelemetry.context.Context; import io.opentelemetry.context.propagation.TextMapPropagator; import io.opentelemetry.context.propagation.TextMapSetter; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.HttpConstants; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.instrumentation.testing.GlobalTraceUtil; @@ -523,7 +520,7 @@ void requestWithNonStandardHttpMethod() throws InterruptedException { HttpConstants._OTHER, SUCCESS, options.responseCodeOnNonStandardHttpMethod) - .hasAttribute(HttpAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method))); + .hasAttribute(SemanticAttributes.HTTP_REQUEST_METHOD_ORIGINAL, method))); } finally { eventLoopGroup.shutdownGracefully().await(10, TimeUnit.SECONDS); } @@ -746,12 +743,12 @@ protected SpanDataAssert assertServerSpan( assertThat(attrs).containsEntry(SemanticAttributes.NET_TRANSPORT, IP_TCP); } if (SemconvStability.emitStableHttpSemconv() - && attrs.get(NetworkAttributes.NETWORK_TRANSPORT) != null) { - assertThat(attrs).containsEntry(NetworkAttributes.NETWORK_TRANSPORT, "tcp"); + && attrs.get(SemanticAttributes.NETWORK_TRANSPORT) != null) { + assertThat(attrs).containsEntry(SemanticAttributes.NETWORK_TRANSPORT, "tcp"); } if (SemconvStability.emitStableHttpSemconv() - && attrs.get(NetworkAttributes.NETWORK_TYPE) != null) { - assertThat(attrs).containsEntry(NetworkAttributes.NETWORK_TYPE, "ipv4"); + && attrs.get(SemanticAttributes.NETWORK_TYPE) != null) { + assertThat(attrs).containsEntry(SemanticAttributes.NETWORK_TYPE, "ipv4"); } assertThat(attrs) @@ -794,10 +791,10 @@ protected SpanDataAssert assertServerSpan( value -> assertThat(value).isNull(), value -> assertThat(value).isEqualTo(TEST_CLIENT_IP))); if (SemconvStability.emitStableHttpSemconv() - && attrs.get(NetworkAttributes.CLIENT_PORT) != null) { + && attrs.get(SemanticAttributes.CLIENT_PORT) != null) { assertThat(attrs) .hasEntrySatisfying( - NetworkAttributes.CLIENT_PORT, port -> assertThat(port).isGreaterThan(0)); + SemanticAttributes.CLIENT_PORT, port -> assertThat(port).isGreaterThan(0)); } assertThat(attrs).containsEntry(getAttributeKey(SemanticAttributes.HTTP_METHOD), method); assertThat(attrs) @@ -828,9 +825,10 @@ protected SpanDataAssert assertServerSpan( } if (SemconvStability.emitStableHttpSemconv()) { assertThat(attrs) - .containsEntry(UrlAttributes.URL_PATH, endpoint.resolvePath(address).getPath()); + .containsEntry( + SemanticAttributes.URL_PATH, endpoint.resolvePath(address).getPath()); if (endpoint.getQuery() != null) { - assertThat(attrs).containsEntry(UrlAttributes.URL_QUERY, endpoint.getQuery()); + assertThat(attrs).containsEntry(SemanticAttributes.URL_QUERY, endpoint.getQuery()); } } } @@ -888,8 +886,8 @@ protected SpanDataAssert assertIndexedServerSpan(SpanDataAssert span, int reques } if (SemconvStability.emitStableHttpSemconv()) { span.hasAttributesSatisfying( - equalTo(UrlAttributes.URL_PATH, endpoint.resolvePath(address).getPath())); - span.hasAttributesSatisfying(equalTo(UrlAttributes.URL_QUERY, "id=" + requestId)); + equalTo(SemanticAttributes.URL_PATH, endpoint.resolvePath(address).getPath())); + span.hasAttributesSatisfying(equalTo(SemanticAttributes.URL_QUERY, "id=" + requestId)); } return span; diff --git a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/SemconvStabilityUtil.java b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/SemconvStabilityUtil.java index 7354542bf399..57eb82ad514c 100644 --- a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/SemconvStabilityUtil.java +++ b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/SemconvStabilityUtil.java @@ -6,9 +6,6 @@ package io.opentelemetry.instrumentation.testing.junit.http; import io.opentelemetry.api.common.AttributeKey; -import io.opentelemetry.instrumentation.api.instrumenter.http.internal.HttpAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; -import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; import io.opentelemetry.instrumentation.api.internal.SemconvStability; import io.opentelemetry.semconv.SemanticAttributes; import java.util.HashMap; @@ -20,39 +17,43 @@ public class SemconvStabilityUtil { static { addKey( - oldToNewMap, SemanticAttributes.NET_PROTOCOL_NAME, NetworkAttributes.NETWORK_PROTOCOL_NAME); + oldToNewMap, + SemanticAttributes.NET_PROTOCOL_NAME, + SemanticAttributes.NETWORK_PROTOCOL_NAME); addKey( oldToNewMap, SemanticAttributes.NET_PROTOCOL_VERSION, - NetworkAttributes.NETWORK_PROTOCOL_VERSION); - addKey(oldToNewMap, SemanticAttributes.NET_PEER_NAME, NetworkAttributes.SERVER_ADDRESS); - addKey(oldToNewMap, SemanticAttributes.NET_PEER_PORT, NetworkAttributes.SERVER_PORT); + SemanticAttributes.NETWORK_PROTOCOL_VERSION); + addKey(oldToNewMap, SemanticAttributes.NET_PEER_NAME, SemanticAttributes.SERVER_ADDRESS); + addKey(oldToNewMap, SemanticAttributes.NET_PEER_PORT, SemanticAttributes.SERVER_PORT); addKey( oldToNewMap, SemanticAttributes.NET_SOCK_PEER_ADDR, - NetworkAttributes.CLIENT_SOCKET_ADDRESS); + SemanticAttributes.CLIENT_SOCKET_ADDRESS); addKey( - oldToNewMap, SemanticAttributes.NET_SOCK_PEER_PORT, NetworkAttributes.CLIENT_SOCKET_PORT); - addKey(oldToNewMap, SemanticAttributes.HTTP_URL, UrlAttributes.URL_FULL); - addKey(oldToNewMap, SemanticAttributes.HTTP_METHOD, HttpAttributes.HTTP_REQUEST_METHOD); + oldToNewMap, SemanticAttributes.NET_SOCK_PEER_PORT, SemanticAttributes.CLIENT_SOCKET_PORT); + addKey(oldToNewMap, SemanticAttributes.HTTP_URL, SemanticAttributes.URL_FULL); + addKey(oldToNewMap, SemanticAttributes.HTTP_METHOD, SemanticAttributes.HTTP_REQUEST_METHOD); addKey( oldToNewMap, SemanticAttributes.HTTP_REQUEST_CONTENT_LENGTH, - HttpAttributes.HTTP_REQUEST_BODY_SIZE); + SemanticAttributes.HTTP_REQUEST_BODY_SIZE); addKey( oldToNewMap, SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH, - HttpAttributes.HTTP_RESPONSE_BODY_SIZE); + SemanticAttributes.HTTP_RESPONSE_BODY_SIZE); addKey( - oldToNewMap, SemanticAttributes.HTTP_STATUS_CODE, HttpAttributes.HTTP_RESPONSE_STATUS_CODE); - addKey(oldToNewMap, SemanticAttributes.NET_HOST_NAME, NetworkAttributes.SERVER_ADDRESS); - addKey(oldToNewMap, SemanticAttributes.NET_HOST_PORT, NetworkAttributes.SERVER_PORT); - addKey(oldToNewMap, SemanticAttributes.HTTP_CLIENT_IP, NetworkAttributes.CLIENT_ADDRESS); - addKey(oldToNewMap, SemanticAttributes.HTTP_SCHEME, UrlAttributes.URL_SCHEME); + oldToNewMap, + SemanticAttributes.HTTP_STATUS_CODE, + SemanticAttributes.HTTP_RESPONSE_STATUS_CODE); + addKey(oldToNewMap, SemanticAttributes.NET_HOST_NAME, SemanticAttributes.SERVER_ADDRESS); + addKey(oldToNewMap, SemanticAttributes.NET_HOST_PORT, SemanticAttributes.SERVER_PORT); + addKey(oldToNewMap, SemanticAttributes.HTTP_CLIENT_IP, SemanticAttributes.CLIENT_ADDRESS); + addKey(oldToNewMap, SemanticAttributes.HTTP_SCHEME, SemanticAttributes.URL_SCHEME); addKey( oldToNewMap, SemanticAttributes.NET_SOCK_HOST_ADDR, - NetworkAttributes.SERVER_SOCKET_ADDRESS); + SemanticAttributes.SERVER_SOCKET_ADDRESS); } private SemconvStabilityUtil() {} From aa017ce8402d090198ff7372e95b6b3b89c81f4d Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Wed, 20 Sep 2023 12:36:50 +0000 Subject: [PATCH 11/17] fix(deps): update dependency io.quarkus:quarkus-bom to v3.4.1 (#9513) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> --- smoke-tests/images/quarkus/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/smoke-tests/images/quarkus/build.gradle.kts b/smoke-tests/images/quarkus/build.gradle.kts index 0493d2dbc747..1a402e64d713 100644 --- a/smoke-tests/images/quarkus/build.gradle.kts +++ b/smoke-tests/images/quarkus/build.gradle.kts @@ -16,7 +16,7 @@ plugins { } dependencies { - implementation(enforcedPlatform("io.quarkus:quarkus-bom:3.4.0")) + implementation(enforcedPlatform("io.quarkus:quarkus-bom:3.4.1")) implementation("io.quarkus:quarkus-resteasy") } From 693c2a8d95513a1a0673f26577e02526c29e030d Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Wed, 20 Sep 2023 16:21:57 +0300 Subject: [PATCH 12/17] Fix flaky lettuce 4 test (#9514) --- .../instrumentation/lettuce/v4_0/LettuceSyncClientTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/instrumentation/lettuce/lettuce-4.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSyncClientTest.java b/instrumentation/lettuce/lettuce-4.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSyncClientTest.java index fa82c4686bef..1e0a246e524b 100644 --- a/instrumentation/lettuce/lettuce-4.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSyncClientTest.java +++ b/instrumentation/lettuce/lettuce-4.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/lettuce/v4_0/LettuceSyncClientTest.java @@ -85,6 +85,7 @@ static void setUp() { syncCommands.hmset("TESTHM", testHashMap); // 2 sets + 1 connect trace + testing.waitForTraces(3); testing.clearData(); } From e5c58b130676ab49f0c918d97d166ad617963579 Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Wed, 20 Sep 2023 19:29:29 +0300 Subject: [PATCH 13/17] chore(deps): update plugin io.quarkus to v3.4.1 (#9519) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> --- smoke-tests/images/quarkus/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/smoke-tests/images/quarkus/build.gradle.kts b/smoke-tests/images/quarkus/build.gradle.kts index 1a402e64d713..f7975e587dd0 100644 --- a/smoke-tests/images/quarkus/build.gradle.kts +++ b/smoke-tests/images/quarkus/build.gradle.kts @@ -12,7 +12,7 @@ plugins { id("otel.java-conventions") id("com.google.cloud.tools.jib") - id("io.quarkus") version "3.4.0" + id("io.quarkus") version "3.4.1" } dependencies { From 324de7f9130e58b8c0e131fa9c2d3560c0affb9e Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Wed, 20 Sep 2023 19:56:17 +0300 Subject: [PATCH 14/17] Add build-info.properties to spring boot smoke test image (#9521) --- smoke-tests/images/spring-boot/build.gradle.kts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/smoke-tests/images/spring-boot/build.gradle.kts b/smoke-tests/images/spring-boot/build.gradle.kts index 33b286a55e24..e96bc5943e11 100644 --- a/smoke-tests/images/spring-boot/build.gradle.kts +++ b/smoke-tests/images/spring-boot/build.gradle.kts @@ -37,6 +37,11 @@ java { targetCompatibility = JavaVersion.VERSION_1_8 } +springBoot { + buildInfo { + } +} + jib { from.image = "openjdk:$targetJDK" to.image = "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk$targetJDK-$tag" From 446d9a28ae91aa5c2a374ea7aa9149cfe8aaf456 Mon Sep 17 00:00:00 2001 From: Jonas Kunz Date: Wed, 20 Sep 2023 21:26:56 +0200 Subject: [PATCH 15/17] Implemented factory for generating invokedynamic proxy classes (#9502) --- .../indy/IndyProxyFactory.java | 181 ++++++++++ .../indy/IndyProxyFactoryTest.java | 330 ++++++++++++++++++ .../indy/dummies/DummyAnnotation.java | 14 + 3 files changed, 525 insertions(+) create mode 100644 javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactory.java create mode 100644 javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactoryTest.java create mode 100644 javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/dummies/DummyAnnotation.java diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactory.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactory.java new file mode 100644 index 000000000000..0a1b774ba60f --- /dev/null +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactory.java @@ -0,0 +1,181 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.instrumentation.indy; + +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.List; +import net.bytebuddy.ByteBuddy; +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.description.method.ParameterDescription; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.dynamic.DynamicType; +import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy; +import net.bytebuddy.implementation.FieldAccessor; +import net.bytebuddy.implementation.Implementation; +import net.bytebuddy.implementation.InvokeDynamic; +import net.bytebuddy.implementation.MethodCall; +import net.bytebuddy.implementation.bytecode.StackManipulation; +import net.bytebuddy.implementation.bytecode.member.MethodInvocation; +import net.bytebuddy.implementation.bytecode.member.MethodVariableAccess; +import net.bytebuddy.utility.JavaConstant; + +/** + * Factory for generating proxies which invoke their target via {@code INVOKEDYNAMIC}. Generated + * proxy classes have the following properties: The generated proxies have the following basic + * structure: + * + *
    + *
  • it has same superclass as the proxied class + *
  • it implements all interfaces implemented by the proxied class + *
  • for every public constructor of the proxied class, it defined a matching public constructor + * which: + *
      + *
    • invokes the default constructor of the superclass + *
    • invoked the corresponding constructor of the proxied class to generate the object to + * which the proxy delegates + *
    + *
  • it "copies" every declared static and non-static public method, the implementation will + * delegate to the corresponding method in the proxied class + *
  • all annotations on the proxied class and on its methods are copied to the proxy + *
+ * + *

Note that only the public methods declared by the proxied class are actually proxied. + * Inherited methods are not automatically proxied. If you want those to be proxied, you'll need to + * explicitly override them in the proxied class. + */ +public class IndyProxyFactory { + + @FunctionalInterface + public interface BootstrapArgsProvider { + + /** + * Defines the additional arguments to pass to the invokedynamic bootstrap method for a given + * proxied method. The arguments have to be storable in the constant pool. + * + * @param classBeingProxied the type for which {@link + * IndyProxyFactory#generateProxy(TypeDescription, String)} was invoked + * @param proxiedMethodOrCtor the method or constructor from the proxied class for which the + * arguments are requested + * @return the arguments to pass to the bootstrap method + */ + List getBootstrapArgsForMethod( + TypeDescription classBeingProxied, MethodDescription.InDefinedShape proxiedMethodOrCtor); + } + + private static final String DELEGATE_FIELD_NAME = "delegate"; + + private final MethodDescription.InDefinedShape indyBootstrapMethod; + + private final BootstrapArgsProvider bootstrapArgsProvider; + + public IndyProxyFactory(Method bootstrapMethod, BootstrapArgsProvider bootstrapArgsProvider) { + this.indyBootstrapMethod = new MethodDescription.ForLoadedMethod(bootstrapMethod); + this.bootstrapArgsProvider = bootstrapArgsProvider; + } + + /** + * Generates a proxy. + * + * @param classToProxy the class for which a proxy will be generated + * @param proxyClassName the desired fully qualified name for the proxy class + * @return the generated proxy class + */ + public DynamicType.Unloaded generateProxy( + TypeDescription classToProxy, String proxyClassName) { + TypeDescription.Generic superClass = classToProxy.getSuperClass(); + DynamicType.Builder builder = + new ByteBuddy() + .subclass(superClass, ConstructorStrategy.Default.NO_CONSTRUCTORS) + .implement(classToProxy.getInterfaces()) + .name(proxyClassName) + .annotateType(classToProxy.getDeclaredAnnotations()) + .defineField(DELEGATE_FIELD_NAME, Object.class, Modifier.PRIVATE | Modifier.FINAL); + + for (MethodDescription.InDefinedShape method : classToProxy.getDeclaredMethods()) { + if (method.isPublic()) { + if (method.isConstructor()) { + List bootstrapArgs = + bootstrapArgsProvider.getBootstrapArgsForMethod(classToProxy, method); + builder = createProxyConstructor(superClass, method, bootstrapArgs, builder); + } else if (method.isMethod()) { + List bootstrapArgs = + bootstrapArgsProvider.getBootstrapArgsForMethod(classToProxy, method); + builder = createProxyMethod(method, bootstrapArgs, builder); + } + } + } + return builder.make(); + } + + private DynamicType.Builder createProxyMethod( + MethodDescription.InDefinedShape proxiedMethod, + List bootstrapArgs, + DynamicType.Builder builder) { + InvokeDynamic body = InvokeDynamic.bootstrap(indyBootstrapMethod, bootstrapArgs); + if (!proxiedMethod.isStatic()) { + body = body.withField(DELEGATE_FIELD_NAME); + } + body = body.withMethodArguments(); + int modifiers = Modifier.PUBLIC | (proxiedMethod.isStatic() ? Modifier.STATIC : 0); + return createProxyMethodOrConstructor( + proxiedMethod, + builder.defineMethod(proxiedMethod.getName(), proxiedMethod.getReturnType(), modifiers), + body); + } + + private DynamicType.Builder createProxyConstructor( + TypeDescription.Generic superClass, + MethodDescription.InDefinedShape proxiedConstructor, + List bootstrapArgs, + DynamicType.Builder builder) { + MethodDescription defaultSuperCtor = findDefaultConstructor(superClass); + + Implementation.Composable fieldAssignment = + FieldAccessor.ofField(DELEGATE_FIELD_NAME) + .setsValue( + new StackManipulation.Compound( + MethodVariableAccess.allArgumentsOf(proxiedConstructor), + MethodInvocation.invoke(indyBootstrapMethod) + .dynamic( + "ctor", // the actual method name is not allowed by the verifier + TypeDescription.ForLoadedType.of(Object.class), + proxiedConstructor.getParameters().asTypeList().asErasures(), + bootstrapArgs)), + Object.class); + Implementation.Composable ctorBody = + MethodCall.invoke(defaultSuperCtor).andThen(fieldAssignment); + return createProxyMethodOrConstructor( + proxiedConstructor, builder.defineConstructor(Modifier.PUBLIC), ctorBody); + } + + private static MethodDescription findDefaultConstructor(TypeDescription.Generic superClass) { + return superClass.getDeclaredMethods().stream() + .filter(MethodDescription::isConstructor) + .filter(constructor -> constructor.getParameters().isEmpty()) + .findFirst() + .orElseThrow( + () -> + new IllegalArgumentException( + "Superclass of provided type does not define a default constructor")); + } + + private static DynamicType.Builder createProxyMethodOrConstructor( + MethodDescription.InDefinedShape method, + DynamicType.Builder.MethodDefinition.ParameterDefinition methodDef, + Implementation methodBody) { + for (ParameterDescription param : method.getParameters()) { + methodDef = + methodDef + .withParameter(param.getType(), param.getName(), param.getModifiers()) + .annotateParameter(param.getDeclaredAnnotations()); + } + return methodDef + .throwing(method.getExceptionTypes()) + .intercept(methodBody) + .annotateMethod(method.getDeclaredAnnotations()); + } +} diff --git a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactoryTest.java b/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactoryTest.java new file mode 100644 index 000000000000..c5d1c287013b --- /dev/null +++ b/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/IndyProxyFactoryTest.java @@ -0,0 +1,330 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.instrumentation.indy; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.javaagent.tooling.instrumentation.indy.dummies.DummyAnnotation; +import java.lang.invoke.CallSite; +import java.lang.invoke.ConstantCallSite; +import java.lang.invoke.MethodHandle; +import java.lang.invoke.MethodHandles; +import java.lang.invoke.MethodType; +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.Callable; +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.dynamic.DynamicType; +import net.bytebuddy.utility.JavaConstant; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +public class IndyProxyFactoryTest { + + private static IndyProxyFactory proxyFactory; + + @BeforeAll + public static void init() throws Exception { + Method bootstrap = + IndyProxyFactoryTest.class.getMethod( + "indyBootstrap", + MethodHandles.Lookup.class, + String.class, + MethodType.class, + Object[].class); + proxyFactory = new IndyProxyFactory(bootstrap, IndyProxyFactoryTest::bootstrapArgsGenerator); + } + + public static CallSite indyBootstrap( + MethodHandles.Lookup lookup, String methodName, MethodType methodType, Object... args) { + + try { + String delegateClassName = (String) args[0]; + String kind = (String) args[1]; + + Class proxiedClass = Class.forName(delegateClassName); + + MethodHandle target; + + switch (kind) { + case "static": + target = MethodHandles.publicLookup().findStatic(proxiedClass, methodName, methodType); + break; + case "constructor": + target = + MethodHandles.publicLookup() + .findConstructor(proxiedClass, methodType.changeReturnType(void.class)) + .asType(methodType); + break; + case "virtual": + target = + MethodHandles.publicLookup() + .findVirtual(proxiedClass, methodName, methodType.dropParameterTypes(0, 1)) + .asType(methodType); + break; + default: + throw new IllegalStateException("unknown kind"); + } + return new ConstantCallSite(target); + } catch (Exception e) { + throw new IllegalStateException(e); + } + } + + private static List bootstrapArgsGenerator( + TypeDescription proxiedType, MethodDescription.InDefinedShape proxiedMethod) { + String kind = "virtual"; + if (proxiedMethod.isConstructor()) { + kind = "constructor"; + } else if (proxiedMethod.isStatic()) { + kind = "static"; + } + return Arrays.asList( + JavaConstant.Simple.ofLoaded(proxiedType.getName()), JavaConstant.Simple.ofLoaded(kind)); + } + + public static class StatefulObj { + + static StatefulObj lastCreatedInstance; + + int counter = 0; + + public StatefulObj() { + lastCreatedInstance = this; + } + + public void increaseCounter() { + counter++; + } + } + + @Test + void verifyDelegateInstantiation() throws Exception { + Class proxy = generateProxy(StatefulObj.class); + Constructor ctor = proxy.getConstructor(); + Method increaseCounter = proxy.getMethod("increaseCounter"); + + Object proxyA = ctor.newInstance(); + StatefulObj delegateA = StatefulObj.lastCreatedInstance; + + Object proxyB = ctor.newInstance(); + StatefulObj delegateB = StatefulObj.lastCreatedInstance; + + assertThat(delegateA).isNotNull(); + assertThat(delegateB).isNotNull(); + assertThat(delegateA).isNotSameAs(delegateB); + + increaseCounter.invoke(proxyA); + assertThat(delegateA.counter).isEqualTo(1); + assertThat(delegateB.counter).isEqualTo(0); + + increaseCounter.invoke(proxyB); + increaseCounter.invoke(proxyB); + assertThat(delegateA.counter).isEqualTo(1); + assertThat(delegateB.counter).isEqualTo(2); + } + + public static class UtilityWithPrivateCtor { + + private UtilityWithPrivateCtor() {} + + public static String utilityMethod() { + return "util"; + } + } + + @Test + void proxyClassWithoutConstructor() throws Exception { + Class proxy = generateProxy(UtilityWithPrivateCtor.class); + + // Not legal in Java code but legal in JVM bytecode + assertThat(proxy.getConstructors()).isEmpty(); + + assertThat(proxy.getMethod("utilityMethod").invoke(null)).isEqualTo("util"); + } + + @DummyAnnotation("type") + public static class AnnotationRetention { + + @DummyAnnotation("constructor") + public AnnotationRetention(@DummyAnnotation("constructor_param") String someValue) {} + + @DummyAnnotation("virtual") + public void virtualMethod(@DummyAnnotation("virtual_param") String someValue) {} + + @DummyAnnotation("static") + public static void staticMethod(@DummyAnnotation("static_param") String someValue) {} + } + + @Test + void verifyAnnotationsRetained() throws Exception { + + Class proxy = generateProxy(AnnotationRetention.class); + + assertThat(proxy.getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("type"); + + Constructor ctor = proxy.getConstructor(String.class); + assertThat(ctor.getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("constructor"); + assertThat(ctor.getParameters()[0].getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("constructor_param"); + + Method virtualMethod = proxy.getMethod("virtualMethod", String.class); + assertThat(virtualMethod.getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("virtual"); + assertThat(virtualMethod.getParameters()[0].getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("virtual_param"); + + Method staticMethod = proxy.getMethod("staticMethod", String.class); + assertThat(staticMethod.getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("static"); + assertThat(staticMethod.getParameters()[0].getAnnotation(DummyAnnotation.class)) + .isNotNull() + .extracting(DummyAnnotation::value) + .isEqualTo("static_param"); + + staticMethod.invoke(null, "blub"); + virtualMethod.invoke(ctor.newInstance("bla"), "blub"); + } + + public static class CustomSuperClass { + + int inheritedFromSuperclassCount = 0; + + protected void overrideMe() {} + + public void inheritedFromSuperclass() { + inheritedFromSuperclassCount++; + } + } + + public static interface CustomSuperInterface extends Runnable { + + default void inheritedDefault() { + if (this instanceof WithSuperTypes) { + ((WithSuperTypes) this).inheritedDefaultCount++; + } + } + } + + public static class WithSuperTypes extends CustomSuperClass + implements CustomSuperInterface, Callable { + + static WithSuperTypes lastCreatedInstance; + + public WithSuperTypes() { + lastCreatedInstance = this; + } + + int runInvocCount = 0; + int callInvocCount = 0; + int overrideMeInvocCount = 0; + + int inheritedDefaultCount = 0; + + @Override + public void run() { + runInvocCount++; + } + + @Override + public String call() throws Exception { + callInvocCount++; + return "foo"; + } + + @Override + public void overrideMe() { + overrideMeInvocCount++; + } + } + + @Test + @SuppressWarnings("unchecked") + void verifySuperTypes() throws Exception { + Object proxy = generateProxy(WithSuperTypes.class).getConstructor().newInstance(); + WithSuperTypes proxied = WithSuperTypes.lastCreatedInstance; + + ((Runnable) proxy).run(); + assertThat(proxied.runInvocCount).isEqualTo(1); + + ((Callable) proxy).call(); + assertThat(proxied.callInvocCount).isEqualTo(1); + + ((CustomSuperClass) proxy).overrideMe(); + assertThat(proxied.overrideMeInvocCount).isEqualTo(1); + + // Non-overidden, inherited methods are not proxied + ((CustomSuperClass) proxy).inheritedFromSuperclass(); + assertThat(proxied.inheritedFromSuperclassCount).isEqualTo(0); + ((CustomSuperInterface) proxy).inheritedDefault(); + assertThat(proxied.inheritedDefaultCount).isEqualTo(0); + } + + @SuppressWarnings({"unused", "MethodCanBeStatic"}) + public static class IgnoreNonPublicMethods { + + public IgnoreNonPublicMethods() {} + + protected IgnoreNonPublicMethods(int arg) {} + + IgnoreNonPublicMethods(int arg1, int arg2) {} + + private IgnoreNonPublicMethods(int arg1, int arg2, int arg3) {} + + public void publicMethod() {} + + public static void publicStaticMethod() {} + + protected void protectedMethod() {} + + protected static void protectedStaticMethod() {} + + void packageMethod() {} + + static void packageStaticMethod() {} + + private void privateMethod() {} + + private static void privateStaticMethod() {} + } + + @Test + void verifyNonPublicMembersIgnored() throws Exception { + Class proxy = generateProxy(IgnoreNonPublicMethods.class); + + assertThat(proxy.getConstructors()).hasSize(1); + assertThat(proxy.getDeclaredMethods()) + .hasSize(2) + .anySatisfy(method -> assertThat(method.getName()).isEqualTo("publicMethod")) + .anySatisfy(method -> assertThat(method.getName()).isEqualTo("publicStaticMethod")); + } + + private static Class generateProxy(Class clazz) { + DynamicType.Unloaded unloaded = + proxyFactory.generateProxy( + TypeDescription.ForLoadedType.of(clazz), clazz.getName() + "Proxy"); + // Uncomment the following line to view the generated bytecode if needed + // unloaded.saveIn(new File("generated_proxies")); + return unloaded.load(clazz.getClassLoader()).getLoaded(); + } +} diff --git a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/dummies/DummyAnnotation.java b/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/dummies/DummyAnnotation.java new file mode 100644 index 000000000000..8ce3e917040b --- /dev/null +++ b/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/instrumentation/indy/dummies/DummyAnnotation.java @@ -0,0 +1,14 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.instrumentation.indy.dummies; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface DummyAnnotation { + String value(); +} From 93444e4a3a934e831faa9e354731fd6ed98ce521 Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Thu, 21 Sep 2023 09:26:33 +0300 Subject: [PATCH 16/17] chore(deps): update plugin com.bmuschko.docker-remote-api to v9.3.3 (#9524) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> --- settings.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/settings.gradle.kts b/settings.gradle.kts index 0b6daf35bb2b..5c8b82399015 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -20,7 +20,7 @@ plugins { // in particular, these commands are failing (reproducible locally): // ./gradlew :smoke-tests:images:servlet:buildLinuxTestImages pushMatrix -PsmokeTestServer=jetty // ./gradlew :smoke-tests:images:servlet:buildWindowsTestImages pushMatrix -PsmokeTestServer=jetty - id("com.bmuschko.docker-remote-api") version "9.3.2" apply false + id("com.bmuschko.docker-remote-api") version "9.3.3" apply false } dependencyResolutionManagement { From 27fa00dcfba78dc438b506bc95b04c39f0f3ecff Mon Sep 17 00:00:00 2001 From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com> Date: Thu, 21 Sep 2023 13:41:37 +0200 Subject: [PATCH 17/17] chore(deps): update bellsoft/liberica-openjdk-alpine docker tag to v21 (#9530) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> --- benchmark-overhead/Dockerfile-petclinic-base | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmark-overhead/Dockerfile-petclinic-base b/benchmark-overhead/Dockerfile-petclinic-base index 014d48f4244b..dccbf650910f 100644 --- a/benchmark-overhead/Dockerfile-petclinic-base +++ b/benchmark-overhead/Dockerfile-petclinic-base @@ -13,7 +13,7 @@ RUN git checkout 8aa4d49 RUN ./mvnw package -Dmaven.test.skip=true RUN cp target/spring-petclinic-rest*.jar /app/spring-petclinic-rest.jar -FROM bellsoft/liberica-openjdk-alpine:20 +FROM bellsoft/liberica-openjdk-alpine:21 COPY --from=app-build /app/spring-petclinic-rest.jar /app/spring-petclinic-rest.jar WORKDIR /app EXPOSE 9966