open-telemetry
/
opentelemetry-java-instrumentation
mirror of https://github.com/open-telemetry/opentelemetry-java-instrumentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Deleted redundant checks (#10434)

This commit is contained in:
Steve Rao 2024-02-07 23:30:52 +08:00 committed by GitHub
parent 0ec3d0a029
commit 0a5c31193c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 910 additions and 1040 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
examples/distro/instrumentation/servlet-3/src/test/java/com/example/javaagent/instrumentation/DemoServlet3InstrumentationTest.java
View File

@ -80,13 +80,10 @@ class DemoServlet3InstrumentationTest {
assertEquals("result", response.body().string());
assertThat(instrumentation.waitForTraces(1))
.hasSize(1)
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> span.hasName("GET /servlet").hasKind(SpanKind.SERVER)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("GET /servlet").hasKind(SpanKind.SERVER)));
var traceId = instrumentation.spans().get(0).getTraceId();
assertEquals(traceId, response.header("X-server-id"));

18
instrumentation/couchbase/couchbase-3.2/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/couchbase/v3_2/CouchbaseClient32Test.java
View File

@ -71,15 +71,13 @@ class CouchbaseClient32Test {
testing.waitAndAssertTracesWithoutScopeVersionVerification(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("get");
if (Boolean.getBoolean("testLatestDeps")) {
span.hasStatus(StatusData.error());
}
},
span -> span.hasName("dispatch_to_server")));
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("get");
if (Boolean.getBoolean("testLatestDeps")) {
span.hasStatus(StatusData.error());
}
},
span -> span.hasName("dispatch_to_server")));
}
}

8
instrumentation/dropwizard/dropwizard-views-0.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/dropwizardviews/ViewRenderTest.java
View File

@ -51,11 +51,9 @@ class ViewRenderTest {
assertThat(outputStream.toString("UTF-8")).contains("This is an example of a view");
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> span.hasName("Render " + template).hasParent(trace.getSpan(0))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> span.hasName("Render " + template).hasParent(trace.getSpan(0))));
}
@Test

50
instrumentation/geode-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/geode/PutGetTest.java
View File

@ -126,32 +126,30 @@ class PutGetTest {
void assertGeodeTrace(String verb, String query) {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("someTrace").hasKind(SpanKind.INTERNAL),
span ->
span.hasName("clear test-region")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, "clear")),
span ->
span.hasName("put test-region")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, "put")),
span ->
span.hasName(verb.concat(" test-region"))
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, verb),
equalTo(SemanticAttributes.DB_STATEMENT, query))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("someTrace").hasKind(SpanKind.INTERNAL),
span ->
span.hasName("clear test-region")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, "clear")),
span ->
span.hasName("put test-region")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, "put")),
span ->
span.hasName(verb.concat(" test-region"))
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "geode"),
equalTo(SemanticAttributes.DB_NAME, "test-region"),
equalTo(SemanticAttributes.DB_OPERATION, verb),
equalTo(SemanticAttributes.DB_STATEMENT, query))));
}
static class Card implements DataSerializable {

64
instrumentation/gwt-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/gwt/GwtTest.java
View File

@ -147,23 +147,20 @@ class GwtTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("POST " + getContextPath() + "/greeting/greet")
.hasKind(SpanKind.SERVER)
.hasNoParent(),
span ->
span.hasName("test.gwt.shared.MessageService/sendMessage")
.hasKind(SpanKind.SERVER)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.RPC_SYSTEM, "gwt"),
equalTo(
SemanticAttributes.RPC_SERVICE,
"test.gwt.shared.MessageService"),
equalTo(SemanticAttributes.RPC_METHOD, "sendMessage"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("POST " + getContextPath() + "/greeting/greet")
.hasKind(SpanKind.SERVER)
.hasNoParent(),
span ->
span.hasName("test.gwt.shared.MessageService/sendMessage")
.hasKind(SpanKind.SERVER)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.RPC_SYSTEM, "gwt"),
equalTo(
SemanticAttributes.RPC_SERVICE, "test.gwt.shared.MessageService"),
equalTo(SemanticAttributes.RPC_METHOD, "sendMessage"))));
testing.clearData();
@ -173,24 +170,21 @@ class GwtTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("POST " + getContextPath() + "/greeting/greet")
.hasKind(SpanKind.SERVER)
.hasNoParent(),
span ->
span.hasName("test.gwt.shared.MessageService/sendMessage")
.hasKind(SpanKind.SERVER)
.hasParent(trace.getSpan(0))
.hasException(new IOException())
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.RPC_SYSTEM, "gwt"),
equalTo(
SemanticAttributes.RPC_SERVICE,
"test.gwt.shared.MessageService"),
equalTo(SemanticAttributes.RPC_METHOD, "sendMessage"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("POST " + getContextPath() + "/greeting/greet")
.hasKind(SpanKind.SERVER)
.hasNoParent(),
span ->
span.hasName("test.gwt.shared.MessageService/sendMessage")
.hasKind(SpanKind.SERVER)
.hasParent(trace.getSpan(0))
.hasException(new IOException())
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.RPC_SYSTEM, "gwt"),
equalTo(
SemanticAttributes.RPC_SERVICE, "test.gwt.shared.MessageService"),
equalTo(SemanticAttributes.RPC_METHOD, "sendMessage"))));
driver.close();
}

74
instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/CriteriaTest.java
View File

@ -59,43 +59,41 @@ public class CriteriaTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName(
"SELECT io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("SELECT db1.Value")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
stringAssert -> stringAssert.startsWith("select")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName(
"SELECT io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("SELECT db1.Value")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
stringAssert -> stringAssert.startsWith("select")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
}
}

52
instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/EntityManagerTest.java
View File

@ -129,33 +129,31 @@ public class EntityManagerTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> assertSessionSpan(span, trace.getSpan(0), parameter.resource),
span ->
span.hasName("SELECT db1.Value")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
assertTransactionCommitSpan(
span,
trace.getSpan(0),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> assertSessionSpan(span, trace.getSpan(0), parameter.resource),
span ->
span.hasName("SELECT db1.Value")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
assertTransactionCommitSpan(
span,
trace.getSpan(0),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
}
private static Stream<Arguments> provideHibernateActionParameters() {

141
instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/ProcedureCallTest.java
View File

@ -86,40 +86,38 @@ public class ProcedureCallTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("ProcedureCall.getOutputs TEST_PROC")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("CALL test.TEST_PROC")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
equalTo(SemanticAttributes.DB_STATEMENT, "{call TEST_PROC()}"),
equalTo(SemanticAttributes.DB_OPERATION, "CALL")),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("ProcedureCall.getOutputs TEST_PROC")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("CALL test.TEST_PROC")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
equalTo(SemanticAttributes.DB_STATEMENT, "{call TEST_PROC()}"),
equalTo(SemanticAttributes.DB_OPERATION, "CALL")),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
}
@Test
@ -145,44 +143,41 @@ public class ProcedureCallTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("ProcedureCall.getOutputs TEST_PROC")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasStatus(StatusData.error())
.hasEventsSatisfyingExactly(
event ->
event
.hasName("exception")
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("exception.type"),
"org.hibernate.exception.SQLGrammarException"),
satisfies(
AttributeKey.stringKey("exception.message"),
val ->
val.startsWith("could not prepare statement")),
satisfies(
AttributeKey.stringKey("exception.stacktrace"),
val -> val.isNotNull())))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("ProcedureCall.getOutputs TEST_PROC")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasStatus(StatusData.error())
.hasEventsSatisfyingExactly(
event ->
event
.hasName("exception")
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("exception.type"),
"org.hibernate.exception.SQLGrammarException"),
satisfies(
AttributeKey.stringKey("exception.message"),
val -> val.startsWith("could not prepare statement")),
satisfies(
AttributeKey.stringKey("exception.stacktrace"),
val -> val.isNotNull())))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
span.hasName("Transaction.commit")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(
AttributeKey.stringKey("hibernate.session_id"),
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))))));
}
}

306
instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/SessionTest.java
View File

@ -79,25 +79,23 @@ public class SessionTest extends AbstractHibernateTest {
private static void assertTraces(Parameter parameter) {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span -> assertClientSpan(span, trace.getSpan(1)),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span -> assertClientSpan(span, trace.getSpan(1)),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
}
@ParameterizedTest(name = "{index}: {0}")
@ -119,26 +117,24 @@ public class SessionTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(5)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span -> assertClientSpan(span, trace.getSpan(1), "SELECT"),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))),
span -> assertClientSpan(span, trace.getSpan(3))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span -> assertClientSpan(span, trace.getSpan(1), "SELECT"),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))),
span -> assertClientSpan(span, trace.getSpan(3))));
}
@Test
@ -160,31 +156,29 @@ public class SessionTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("Session.replicate java.lang.Long")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasStatus(StatusData.error())
.hasException(
new UnknownEntityTypeException(
"Unable to locate persister: java.lang.Long"))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("Session.replicate java.lang.Long")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))
.hasStatus(StatusData.error())
.hasException(
new UnknownEntityTypeException(
"Unable to locate persister: java.lang.Long"))
.hasAttributesSatisfyingExactly(
satisfies(
AttributeKey.stringKey("hibernate.session_id"),
val -> val.isInstanceOf(String.class))),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
}
@ParameterizedTest(name = "{index}: {0}")
@ -206,25 +200,23 @@ public class SessionTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))),
span -> assertClientSpan(span, trace.getSpan(2))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
assertSessionSpan(
span,
trace.getSpan(0),
"Session." + parameter.methodName + " " + parameter.resource),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id"))),
span -> assertClientSpan(span, trace.getSpan(2))));
}
@ParameterizedTest(name = "{index}: {0}")
@ -243,33 +235,31 @@ public class SessionTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(4)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> assertSessionSpan(span, trace.getSpan(0), parameter.resource),
span ->
span.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span -> assertSessionSpan(span, trace.getSpan(0), parameter.resource),
span ->
span.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "h2"),
equalTo(SemanticAttributes.DB_NAME, "db1"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "h2:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "Value")),
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Transaction.commit",
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")))));
}
@Test
@ -300,55 +290,53 @@ public class SessionTest extends AbstractHibernateTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(9)
.hasSpansSatisfyingExactly(
span -> span.hasName("overlapping Sessions"),
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.save io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId1.set(
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.insert io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId2.set(
trace
.getSpan(2)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span -> assertClientSpan(span, trace.getSpan(2), "INSERT"),
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.save io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId3.set(
trace
.getSpan(4)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Session.delete io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value",
sessionId1.get()),
span ->
assertSpanWithSessionId(
span, trace.getSpan(0), "Transaction.commit", sessionId1.get()),
span -> assertClientSpan(span, trace.getSpan(6), "INSERT"),
span -> assertClientSpan(span, trace.getSpan(6), "DELETE")));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("overlapping Sessions"),
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.save io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId1.set(
trace
.getSpan(1)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.insert io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId2.set(
trace
.getSpan(2)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span -> assertClientSpan(span, trace.getSpan(2), "INSERT"),
span -> {
assertSessionSpan(
span,
trace.getSpan(0),
"Session.save io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value");
sessionId3.set(
trace
.getSpan(4)
.getAttributes()
.get(AttributeKey.stringKey("hibernate.session_id")));
},
span ->
assertSpanWithSessionId(
span,
trace.getSpan(0),
"Session.delete io.opentelemetry.javaagent.instrumentation.hibernate.v6_0.Value",
sessionId1.get()),
span ->
assertSpanWithSessionId(
span, trace.getSpan(0), "Transaction.commit", sessionId1.get()),
span -> assertClientSpan(span, trace.getSpan(6), "INSERT"),
span -> assertClientSpan(span, trace.getSpan(6), "DELETE")));
assertNotEquals(sessionId1.get(), sessionId2.get());
assertNotEquals(sessionId2.get(), sessionId3.get());

543
instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/RabbitMqTest.java
View File

@ -116,55 +116,51 @@ class RabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(5)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "exchange.declare", trace.getSpan(0));
},
span -> {
verifySpan(trace, span, 2, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(trace, span, 3, "queue.bind", trace.getSpan(0));
},
span -> {
verifySpan(
trace,
span,
4,
exchangeName,
routingKey,
"publish",
exchangeName,
trace.getSpan(0));
producerSpan.set(trace.getSpan(4));
}),
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "exchange.declare", trace.getSpan(0));
},
span -> {
verifySpan(trace, span, 2, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(trace, span, 3, "queue.bind", trace.getSpan(0));
},
span -> {
verifySpan(
trace,
span,
4,
exchangeName,
routingKey,
"publish",
exchangeName,
trace.getSpan(0));
producerSpan.set(trace.getSpan(4));
}),
trace -> {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
routingKey,
"receive",
"<generated>",
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
routingKey,
"receive",
"<generated>",
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
});
}
@ -192,49 +188,38 @@ class RabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(
trace,
span,
2,
"<default>",
null,
"publish",
"<default>",
trace.getSpan(0));
producerSpan.set(trace.getSpan(2));
}),
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(
trace, span, 2, "<default>", null, "publish", "<default>", trace.getSpan(0));
producerSpan.set(trace.getSpan(2));
}),
trace -> {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
null,
"receive",
"<generated>",
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
null,
"receive",
"<generated>",
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
});
}
@ -282,65 +267,55 @@ class RabbitMqTest extends AbstractRabbitMqTest {
List<java.util.function.Consumer<TraceAssert>> traceAssertions = new ArrayList<>();
traceAssertions.add(
trace -> {
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "exchange.declare");
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "exchange.declare");
});
});
traceAssertions.add(
trace -> {
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
});
});
traceAssertions.add(
trace -> {
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.bind");
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.bind");
});
});
traceAssertions.add(
trace -> {
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
});
});
for (int i = 1; i <= messageCount; i++) {
traceAssertions.add(
trace -> {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, exchangeName, null, "publish", exchangeName);
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
null,
"process",
resource,
trace.getSpan(0),
null,
null,
null,
setTimestamp);
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, exchangeName, null, "publish", exchangeName);
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
null,
"process",
resource,
trace.getSpan(0),
null,
null,
null,
setTimestamp);
});
});
}
@ -378,55 +353,45 @@ class RabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "exchange.declare");
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "exchange.declare");
}),
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
}),
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.bind");
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.bind");
}),
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
}),
trace -> {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, exchangeName, null, "publish", exchangeName);
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
null,
"process",
"<generated>",
trace.getSpan(0),
null,
error,
error.getMessage(),
false);
});
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, exchangeName, null, "publish", exchangeName);
},
span -> {
verifySpan(
trace,
span,
1,
exchangeName,
null,
"process",
"<generated>",
trace.getSpan(0),
null,
error,
error.getMessage(),
false);
});
});
}
@ -447,24 +412,22 @@ class RabbitMqTest extends AbstractRabbitMqTest {
Throwable finalThrown = thrown;
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(
trace,
span,
0,
null,
null,
accessor.getString(3),
accessor.getString(0),
null,
null,
finalThrown,
accessor.getString(2),
false);
}));
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(
trace,
span,
0,
null,
null,
accessor.getString(3),
accessor.getString(0),
null,
null,
finalThrown,
accessor.getString(2),
false);
}));
}
@Test
@ -492,49 +455,45 @@ class RabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(
trace,
span,
2,
"<default>",
"some-routing-queue",
"publish",
"<default>",
trace.getSpan(0));
producerSpan.set(trace.getSpan(2));
}),
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("producer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(trace, span, 1, "queue.declare", trace.getSpan(0));
},
span -> {
verifySpan(
trace,
span,
2,
"<default>",
"some-routing-queue",
"publish",
"<default>",
trace.getSpan(0));
producerSpan.set(trace.getSpan(2));
}),
trace -> {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
"some-routing-queue",
"receive",
queue.getName(),
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent();
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
"some-routing-queue",
"receive",
queue.getName(),
trace.getSpan(0),
producerSpan.get(),
null,
null,
false);
});
});
cachingConnectionFactory.destroy();
@ -570,63 +529,57 @@ class RabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "queue.declare");
}),
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "<default>", null, "publish", "<default>");
span.hasAttributesSatisfying(
attributes -> {
assertThat(attributes)
.satisfies(
attrs -> {
List<String> verifyHeaders =
attrs.get(
AttributeKey.stringArrayKey(
"messaging.header.test_message_header"));
assertNotNull(verifyHeaders);
assertTrue(verifyHeaders.contains("test"));
});
});
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
null,
"process",
"<generated>",
trace.getSpan(0));
span.hasAttributesSatisfying(
attributes -> {
assertThat(attributes)
.satisfies(
attrs -> {
List<String> verifyHeaders =
attrs.get(
AttributeKey.stringArrayKey(
"messaging.header.test_message_header"));
assertNotNull(verifyHeaders);
assertTrue(verifyHeaders.contains("test"));
});
});
}),
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "<default>", null, "publish", "<default>");
span.hasAttributesSatisfying(
attributes -> {
assertThat(attributes)
.satisfies(
attrs -> {
List<String> verifyHeaders =
attrs.get(
AttributeKey.stringArrayKey(
"messaging.header.test_message_header"));
assertNotNull(verifyHeaders);
assertTrue(verifyHeaders.contains("test"));
});
});
},
span -> {
verifySpan(
trace,
span,
1,
"<default>",
null,
"process",
"<generated>",
trace.getSpan(0));
span.hasAttributesSatisfying(
attributes -> {
assertThat(attributes)
.satisfies(
attrs -> {
List<String> verifyHeaders =
attrs.get(
AttributeKey.stringArrayKey(
"messaging.header.test_message_header"));
assertNotNull(verifyHeaders);
assertTrue(verifyHeaders.contains("test"));
});
});
}),
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
}));
trace.hasSpansSatisfyingExactly(
span -> {
verifySpan(trace, span, 0, "basic.consume");
}));
}
private static Stream<Arguments> provideParametersForMessageCountAndTimestamp() {

47
instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/ReactorRabbitMqTest.java
View File

@ -39,32 +39,29 @@ class ReactorRabbitMqTest extends AbstractRabbitMqTest {
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> {
span.hasName("exchange.declare")
.hasKind(SpanKind.CLIENT)
.hasAttribute(SemanticAttributes.MESSAGING_SYSTEM, "rabbitmq")
.hasAttribute(
AttributeKey.stringKey("rabbitmq.command"), "exchange.declare")
.hasAttributesSatisfying(
attributes ->
assertThat(attributes)
.satisfies(
attrs -> {
String peerAddr =
attrs.get(NetworkAttributes.NETWORK_PEER_ADDRESS);
assertThat(peerAddr)
.isIn("127.0.0.1", "0:0:0:0:0:0:0:1", null);
trace.hasSpansSatisfyingExactly(
span -> {
span.hasName("exchange.declare")
.hasKind(SpanKind.CLIENT)
.hasAttribute(SemanticAttributes.MESSAGING_SYSTEM, "rabbitmq")
.hasAttribute(AttributeKey.stringKey("rabbitmq.command"), "exchange.declare")
.hasAttributesSatisfying(
attributes ->
assertThat(attributes)
.satisfies(
attrs -> {
String peerAddr =
attrs.get(NetworkAttributes.NETWORK_PEER_ADDRESS);
assertThat(peerAddr)
.isIn("127.0.0.1", "0:0:0:0:0:0:0:1", null);
String networkType =
attrs.get(SemanticAttributes.NETWORK_TYPE);
assertThat(networkType).isIn("ipv4", "ipv6", null);
String networkType =
attrs.get(SemanticAttributes.NETWORK_TYPE);
assertThat(networkType).isIn("ipv4", "ipv6", null);
assertNotNull(
attrs.get(NetworkAttributes.NETWORK_PEER_PORT));
}));
}));
assertNotNull(
attrs.get(NetworkAttributes.NETWORK_PEER_PORT));
}));
}));
}
}

46
instrumentation/spark-2.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/sparkjava/SparkJavaBasedTest.java
View File

@ -52,29 +52,27 @@ public class SparkJavaBasedTest {
assertEquals(content, "Hello asdf1234");
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span ->
span.hasName("GET /param/:param")
.hasKind(SpanKind.SERVER)
.hasNoParent()
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.URL_SCHEME, "http"),
equalTo(SemanticAttributes.URL_PATH, "/param/asdf1234"),
equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"),
equalTo(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200),
satisfies(
SemanticAttributes.USER_AGENT_ORIGINAL,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.HTTP_ROUTE, "/param/:param"),
equalTo(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"),
equalTo(SemanticAttributes.SERVER_ADDRESS, "localhost"),
equalTo(SemanticAttributes.SERVER_PORT, port),
equalTo(SemanticAttributes.CLIENT_ADDRESS, "127.0.0.1"),
equalTo(NetworkAttributes.NETWORK_PEER_ADDRESS, "127.0.0.1"),
satisfies(
NetworkAttributes.NETWORK_PEER_PORT,
val -> val.isInstanceOf(Long.class)))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("GET /param/:param")
.hasKind(SpanKind.SERVER)
.hasNoParent()
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.URL_SCHEME, "http"),
equalTo(SemanticAttributes.URL_PATH, "/param/asdf1234"),
equalTo(SemanticAttributes.HTTP_REQUEST_METHOD, "GET"),
equalTo(SemanticAttributes.HTTP_RESPONSE_STATUS_CODE, 200),
satisfies(
SemanticAttributes.USER_AGENT_ORIGINAL,
val -> val.isInstanceOf(String.class)),
equalTo(SemanticAttributes.HTTP_ROUTE, "/param/:param"),
equalTo(SemanticAttributes.NETWORK_PROTOCOL_VERSION, "1.1"),
equalTo(SemanticAttributes.SERVER_ADDRESS, "localhost"),
equalTo(SemanticAttributes.SERVER_PORT, port),
equalTo(SemanticAttributes.CLIENT_ADDRESS, "127.0.0.1"),
equalTo(NetworkAttributes.NETWORK_PEER_ADDRESS, "127.0.0.1"),
satisfies(
NetworkAttributes.NETWORK_PEER_PORT,
val -> val.isInstanceOf(Long.class)))));
}
}

20
instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/instrumentation/annotations/AbstractWithSpanAspectTest.java
View File

@ -223,9 +223,8 @@ abstract class AbstractWithSpanAspectTest {
assertThat(testing.waitForTraces(1))
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(span -> span.hasName("parent").hasKind(INTERNAL)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(INTERNAL)));
// when
future.complete("DONE");
@ -258,9 +257,8 @@ abstract class AbstractWithSpanAspectTest {
assertThat(testing.waitForTraces(1))
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(span -> span.hasName("parent").hasKind(INTERNAL)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(INTERNAL)));
// when
future.completeExceptionally(new Exception("Test @WithSpan With completeExceptionally"));
@ -321,9 +319,8 @@ abstract class AbstractWithSpanAspectTest {
assertThat(testing.waitForTraces(1))
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(span -> span.hasName("parent").hasKind(INTERNAL)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(INTERNAL)));
// when
future.complete("DONE");
@ -357,9 +354,8 @@ abstract class AbstractWithSpanAspectTest {
assertThat(testing.waitForTraces(1))
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(span -> span.hasName("parent").hasKind(INTERNAL)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(INTERNAL)));
// when
future.completeExceptionally(new Exception("Test @WithSpan With completeExceptionally"));

14
instrumentation/spring/spring-core-2.0/javaagent/src/test/java/SimpleAsyncTaskExecutorInstrumentationTest.java
View File

@ -64,14 +64,12 @@ public class SimpleAsyncTaskExecutorInstrumentationTest {
});
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("asyncChild")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("parent").hasKind(SpanKind.INTERNAL).hasNoParent(),
span ->
span.hasName("asyncChild")
.hasKind(SpanKind.INTERNAL)
.hasParent(trace.getSpan(0))));
}
static class AsyncTask implements Runnable, Callable<Object> {

428
instrumentation/spring/spring-data/spring-data-common/testing/src/main/java/AbstractSpringJpaTest.java
View File

@ -61,72 +61,64 @@ public abstract class AbstractSpringJpaTest<
// Asserting that a span is NOT created for toString
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span -> span.hasName("toString test").hasTotalAttributeCount(0)));
trace.hasSpansSatisfyingExactly(
span -> span.hasName("toString test").hasTotalAttributeCount(0)));
}
static void assertHibernate4Trace(TraceAssert trace, String repoClassName) {
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("INSERT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("insert ")),
equalTo(SemanticAttributes.DB_OPERATION, "INSERT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("INSERT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(SemanticAttributes.DB_STATEMENT, val -> val.startsWith("insert ")),
equalTo(SemanticAttributes.DB_OPERATION, "INSERT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")));
}
static void assertHibernateTrace(TraceAssert trace, String repoClassName) {
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("CALL test")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("call next value for ")),
equalTo(SemanticAttributes.DB_OPERATION, "CALL")),
span ->
span.hasName("INSERT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("insert ")),
equalTo(SemanticAttributes.DB_OPERATION, "INSERT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("CALL test")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("call next value for ")),
equalTo(SemanticAttributes.DB_OPERATION, "CALL")),
span ->
span.hasName("INSERT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(SemanticAttributes.DB_STATEMENT, val -> val.startsWith("insert ")),
equalTo(SemanticAttributes.DB_OPERATION, "INSERT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")));
}
@Test
@ -142,29 +134,26 @@ public abstract class AbstractSpringJpaTest<
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findAll")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findAll")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findAll")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findAll")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
clearData();
repo.save(customer);
@ -182,113 +171,102 @@ public abstract class AbstractSpringJpaTest<
assertEquals(id(customer), savedId);
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")),
span ->
span.hasName("UPDATE test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("update ")),
equalTo(SemanticAttributes.DB_OPERATION, "UPDATE"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.save")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "save")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")),
span ->
span.hasName("UPDATE test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("update ")),
equalTo(SemanticAttributes.DB_OPERATION, "UPDATE"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
clearData();
customer = findByLastName(repo, "Anonymous").get(0);
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findByLastName")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findByLastName")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findByLastName")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findByLastName")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
clearData();
repo.delete(customer);
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(3)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.delete")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "delete")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")),
span ->
span.hasName("DELETE test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("delete ")),
equalTo(SemanticAttributes.DB_OPERATION, "DELETE"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.delete")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "delete")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer")),
span ->
span.hasName("DELETE test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("delete ")),
equalTo(SemanticAttributes.DB_OPERATION, "DELETE"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
}
@Test
@ -301,29 +279,26 @@ public abstract class AbstractSpringJpaTest<
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findSpecialCustomers")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findSpecialCustomers")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findSpecialCustomers")
.hasKind(SpanKind.INTERNAL)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findSpecialCustomers")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
}
@Test
@ -347,30 +322,27 @@ public abstract class AbstractSpringJpaTest<
assertNotNull(expectedException);
testing.waitAndAssertTraces(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findOneByLastName")
.hasKind(SpanKind.INTERNAL)
.hasStatus(StatusData.error())
.hasException(expectedException)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findOneByLastName")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT,
val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("JpaCustomerRepository.findOneByLastName")
.hasKind(SpanKind.INTERNAL)
.hasStatus(StatusData.error())
.hasException(expectedException)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.CODE_NAMESPACE, repoClassName),
equalTo(SemanticAttributes.CODE_FUNCTION, "findOneByLastName")),
span ->
span.hasName("SELECT test.JpaCustomer")
.hasKind(SpanKind.CLIENT)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.DB_SYSTEM, "hsqldb"),
equalTo(SemanticAttributes.DB_NAME, "test"),
equalTo(SemanticAttributes.DB_USER, "sa"),
equalTo(SemanticAttributes.DB_CONNECTION_STRING, "hsqldb:mem:"),
satisfies(
SemanticAttributes.DB_STATEMENT, val -> val.startsWith("select ")),
equalTo(SemanticAttributes.DB_OPERATION, "SELECT"),
equalTo(SemanticAttributes.DB_SQL_TABLE, "JpaCustomer"))));
}
}

122
instrumentation/spring/spring-rabbit-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/rabbit/v1_0/ContextPropagationTest.java
View File

@ -152,71 +152,67 @@ public class ContextPropagationTest {
});
testing.waitAndAssertTraces(
trace -> {
trace
.hasSize(5)
.hasSpansSatisfyingExactlyInAnyOrder(
span -> span.hasName("parent"),
span ->
span.hasName("<default> publish")
.hasKind(SpanKind.PRODUCER)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
getAssertions(
"<default>", "publish", "127.0.0.1", true, testHeaders)),
// spring-cloud-stream-binder-rabbit listener puts all messages into a
// BlockingQueue immediately after receiving
// that's why the rabbitmq CONSUMER span will never have any child span (and
// propagate context, actually)
span ->
span.hasName("testQueue process")
.hasKind(SpanKind.CONSUMER)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
getAssertions(
"<default>", "process", "127.0.0.1", true, testHeaders)),
// created by spring-rabbit instrumentation
span ->
span.hasName("testQueue process")
.hasKind(SpanKind.CONSUMER)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
getAssertions("testQueue", "process", null, false, testHeaders)),
span -> {
// occasionally "testQueue process" spans have their order swapped, usually
// it would be
// 0 - parent
// 1 - <default> publish
// 2 - testQueue process (<default>)
// 3 - testQueue process (testQueue)
// 4 - consumer
// but it could also be
// 0 - parent
// 1 - <default> publish
// 2 - testQueue process (testQueue)
// 3 - consumer
// 4 - testQueue process (<default>)
// determine the correct parent span based on the span name
SpanData parentSpan = trace.getSpan(3);
if (!"testQueue process".equals(parentSpan.getName())) {
parentSpan = trace.getSpan(2);
}
span.hasName("consumer").hasParent(parentSpan);
});
trace.hasSpansSatisfyingExactlyInAnyOrder(
span -> span.hasName("parent"),
span ->
span.hasName("<default> publish")
.hasKind(SpanKind.PRODUCER)
.hasParent(trace.getSpan(0))
.hasAttributesSatisfyingExactly(
getAssertions(
"<default>", "publish", "127.0.0.1", true, testHeaders)),
// spring-cloud-stream-binder-rabbit listener puts all messages into a
// BlockingQueue immediately after receiving
// that's why the rabbitmq CONSUMER span will never have any child span (and
// propagate context, actually)
span ->
span.hasName("testQueue process")
.hasKind(SpanKind.CONSUMER)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
getAssertions(
"<default>", "process", "127.0.0.1", true, testHeaders)),
// created by spring-rabbit instrumentation
span ->
span.hasName("testQueue process")
.hasKind(SpanKind.CONSUMER)
.hasParent(trace.getSpan(1))
.hasAttributesSatisfyingExactly(
getAssertions("testQueue", "process", null, false, testHeaders)),
span -> {
// occasionally "testQueue process" spans have their order swapped, usually
// it would be
// 0 - parent
// 1 - <default> publish
// 2 - testQueue process (<default>)
// 3 - testQueue process (testQueue)
// 4 - consumer
// but it could also be
// 0 - parent
// 1 - <default> publish
// 2 - testQueue process (testQueue)
// 3 - consumer
// 4 - testQueue process (<default>)
// determine the correct parent span based on the span name
SpanData parentSpan = trace.getSpan(3);
if (!"testQueue process".equals(parentSpan.getName())) {
parentSpan = trace.getSpan(2);
}
span.hasName("consumer").hasParent(parentSpan);
});
},
trace -> {
trace
.hasSize(1)
.hasSpansSatisfyingExactly(
span ->
span.hasName("basic.ack")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.NETWORK_TYPE, "ipv4"),
equalTo(NetworkAttributes.NETWORK_PEER_ADDRESS, "127.0.0.1"),
satisfies(
NetworkAttributes.NETWORK_PEER_PORT,
AbstractLongAssert::isNotNegative),
equalTo(SemanticAttributes.MESSAGING_SYSTEM, "rabbitmq")));
trace.hasSpansSatisfyingExactly(
span ->
span.hasName("basic.ack")
.hasKind(SpanKind.CLIENT)
.hasAttributesSatisfyingExactly(
equalTo(SemanticAttributes.NETWORK_TYPE, "ipv4"),
equalTo(NetworkAttributes.NETWORK_PEER_ADDRESS, "127.0.0.1"),
satisfies(
NetworkAttributes.NETWORK_PEER_PORT,
AbstractLongAssert::isNotNegative),
equalTo(SemanticAttributes.MESSAGING_SYSTEM, "rabbitmq")));
});
}
}

1
smoke-tests-otel-starter/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java
View File

@ -85,7 +85,6 @@ class OtelSpringStarterSmokeTest {
// Span
TracesAssert.assertThat(exportedSpans)
.hasSize(2)
.hasTracesSatisfyingExactly(
traceAssert ->
traceAssert.hasSpansSatisfyingExactly(

9
testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/LibraryInstrumentationExtensionTest.java
View File

@ -36,13 +36,10 @@ class LibraryInstrumentationExtensionTest {
// then
List<List<SpanData>> traces = testing.waitForTraces(1);
assertThat(traces)
.hasSize(1)
.hasTracesSatisfyingExactly(
trace ->
trace
.hasSize(2)
.hasSpansSatisfyingExactly(
parentSpan -> parentSpan.hasName("parent"),
childSpan -> childSpan.hasName("child")));
trace.hasSpansSatisfyingExactly(
parentSpan -> parentSpan.hasName("parent"),
childSpan -> childSpan.hasName("child")));
}
}