diff --git a/examples/distro/instrumentation/servlet-3/src/test/java/com/example/javaagent/instrumentation/DemoServlet3InstrumentationTest.java b/examples/distro/instrumentation/servlet-3/src/test/java/com/example/javaagent/instrumentation/DemoServlet3InstrumentationTest.java index 96039f43ee..773d01cbad 100644 --- a/examples/distro/instrumentation/servlet-3/src/test/java/com/example/javaagent/instrumentation/DemoServlet3InstrumentationTest.java +++ b/examples/distro/instrumentation/servlet-3/src/test/java/com/example/javaagent/instrumentation/DemoServlet3InstrumentationTest.java @@ -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")); diff --git a/instrumentation/couchbase/couchbase-3.2/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/couchbase/v3_2/CouchbaseClient32Test.java b/instrumentation/couchbase/couchbase-3.2/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/couchbase/v3_2/CouchbaseClient32Test.java index dc859eb4f0..ef7a320cca 100644 --- a/instrumentation/couchbase/couchbase-3.2/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/couchbase/v3_2/CouchbaseClient32Test.java +++ b/instrumentation/couchbase/couchbase-3.2/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/couchbase/v3_2/CouchbaseClient32Test.java @@ -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"))); } } diff --git a/instrumentation/dropwizard/dropwizard-views-0.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/dropwizardviews/ViewRenderTest.java b/instrumentation/dropwizard/dropwizard-views-0.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/dropwizardviews/ViewRenderTest.java index 1020b616cb..dbba452d34 100644 --- a/instrumentation/dropwizard/dropwizard-views-0.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/dropwizardviews/ViewRenderTest.java +++ b/instrumentation/dropwizard/dropwizard-views-0.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/dropwizardviews/ViewRenderTest.java @@ -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 diff --git a/instrumentation/geode-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/geode/PutGetTest.java b/instrumentation/geode-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/geode/PutGetTest.java index 1bf8dc6de1..128e86f730 100644 --- a/instrumentation/geode-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/geode/PutGetTest.java +++ b/instrumentation/geode-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/geode/PutGetTest.java @@ -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 { diff --git a/instrumentation/gwt-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/gwt/GwtTest.java b/instrumentation/gwt-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/gwt/GwtTest.java index 747a88bb34..fe69fea4bc 100644 --- a/instrumentation/gwt-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/gwt/GwtTest.java +++ b/instrumentation/gwt-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/gwt/GwtTest.java @@ -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(); } diff --git a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/CriteriaTest.java b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/CriteriaTest.java index 7ed2a4f13a..a181b14e39 100644 --- a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/CriteriaTest.java +++ b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/CriteriaTest.java @@ -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")))))); } } diff --git a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/EntityManagerTest.java b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/EntityManagerTest.java index 19ea741f25..11ec476320 100644 --- a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/EntityManagerTest.java +++ b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/EntityManagerTest.java @@ -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 provideHibernateActionParameters() { diff --git a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/ProcedureCallTest.java b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/ProcedureCallTest.java index a60ea4d197..d1e79fa63a 100644 --- a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/ProcedureCallTest.java +++ b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/ProcedureCallTest.java @@ -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")))))); } } diff --git a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/SessionTest.java b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/SessionTest.java index 722b7d84d4..6d77f982db 100644 --- a/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/SessionTest.java +++ b/instrumentation/hibernate/hibernate-6.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/hibernate/v6_0/SessionTest.java @@ -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()); diff --git a/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/RabbitMqTest.java b/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/RabbitMqTest.java index 464d5f0aee..ae0d6cb8c9 100644 --- a/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/RabbitMqTest.java +++ b/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/RabbitMqTest.java @@ -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", - "", - 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", + "", + 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, - "", - null, - "publish", - "", - 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, "", null, "publish", "", 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, - "", - null, - "receive", - "", - trace.getSpan(0), - producerSpan.get(), - null, - null, - false); - }); + trace.hasSpansSatisfyingExactly( + span -> { + span.hasName("consumer parent").hasKind(SpanKind.INTERNAL).hasNoParent(); + }, + span -> { + verifySpan( + trace, + span, + 1, + "", + null, + "receive", + "", + trace.getSpan(0), + producerSpan.get(), + null, + null, + false); + }); }); } @@ -282,65 +267,55 @@ class RabbitMqTest extends AbstractRabbitMqTest { List> 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", - "", - 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", + "", + 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, - "", - "some-routing-queue", - "publish", - "", - 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, + "", + "some-routing-queue", + "publish", + "", + 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, - "", - "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, + "", + "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, "", null, "publish", ""); - span.hasAttributesSatisfying( - attributes -> { - assertThat(attributes) - .satisfies( - attrs -> { - List verifyHeaders = - attrs.get( - AttributeKey.stringArrayKey( - "messaging.header.test_message_header")); - assertNotNull(verifyHeaders); - assertTrue(verifyHeaders.contains("test")); - }); - }); - }, - span -> { - verifySpan( - trace, - span, - 1, - "", - null, - "process", - "", - trace.getSpan(0)); - span.hasAttributesSatisfying( - attributes -> { - assertThat(attributes) - .satisfies( - attrs -> { - List verifyHeaders = - attrs.get( - AttributeKey.stringArrayKey( - "messaging.header.test_message_header")); - assertNotNull(verifyHeaders); - assertTrue(verifyHeaders.contains("test")); - }); - }); - }), + trace.hasSpansSatisfyingExactly( + span -> { + verifySpan(trace, span, 0, "", null, "publish", ""); + span.hasAttributesSatisfying( + attributes -> { + assertThat(attributes) + .satisfies( + attrs -> { + List verifyHeaders = + attrs.get( + AttributeKey.stringArrayKey( + "messaging.header.test_message_header")); + assertNotNull(verifyHeaders); + assertTrue(verifyHeaders.contains("test")); + }); + }); + }, + span -> { + verifySpan( + trace, + span, + 1, + "", + null, + "process", + "", + trace.getSpan(0)); + span.hasAttributesSatisfying( + attributes -> { + assertThat(attributes) + .satisfies( + attrs -> { + List 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 provideParametersForMessageCountAndTimestamp() { diff --git a/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/ReactorRabbitMqTest.java b/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/ReactorRabbitMqTest.java index b384555b7b..203479c1fa 100644 --- a/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/ReactorRabbitMqTest.java +++ b/instrumentation/rabbitmq-2.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/rabbitmq/ReactorRabbitMqTest.java @@ -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)); + })); + })); } } diff --git a/instrumentation/spark-2.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/sparkjava/SparkJavaBasedTest.java b/instrumentation/spark-2.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/sparkjava/SparkJavaBasedTest.java index c637c5a3e2..418f2d6c06 100644 --- a/instrumentation/spark-2.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/sparkjava/SparkJavaBasedTest.java +++ b/instrumentation/spark-2.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/sparkjava/SparkJavaBasedTest.java @@ -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))))); } } diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/instrumentation/annotations/AbstractWithSpanAspectTest.java b/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/instrumentation/annotations/AbstractWithSpanAspectTest.java index ddfb9a9c26..798f1f8d02 100644 --- a/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/instrumentation/annotations/AbstractWithSpanAspectTest.java +++ b/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/instrumentation/annotations/AbstractWithSpanAspectTest.java @@ -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")); diff --git a/instrumentation/spring/spring-core-2.0/javaagent/src/test/java/SimpleAsyncTaskExecutorInstrumentationTest.java b/instrumentation/spring/spring-core-2.0/javaagent/src/test/java/SimpleAsyncTaskExecutorInstrumentationTest.java index 5e2baddaff..cf94a5a692 100644 --- a/instrumentation/spring/spring-core-2.0/javaagent/src/test/java/SimpleAsyncTaskExecutorInstrumentationTest.java +++ b/instrumentation/spring/spring-core-2.0/javaagent/src/test/java/SimpleAsyncTaskExecutorInstrumentationTest.java @@ -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 { diff --git a/instrumentation/spring/spring-data/spring-data-common/testing/src/main/java/AbstractSpringJpaTest.java b/instrumentation/spring/spring-data/spring-data-common/testing/src/main/java/AbstractSpringJpaTest.java index d192b1d9ac..3df645775c 100644 --- a/instrumentation/spring/spring-data/spring-data-common/testing/src/main/java/AbstractSpringJpaTest.java +++ b/instrumentation/spring/spring-data/spring-data-common/testing/src/main/java/AbstractSpringJpaTest.java @@ -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")))); } } diff --git a/instrumentation/spring/spring-rabbit-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/rabbit/v1_0/ContextPropagationTest.java b/instrumentation/spring/spring-rabbit-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/rabbit/v1_0/ContextPropagationTest.java index acb904cddf..5d6bf1ca22 100644 --- a/instrumentation/spring/spring-rabbit-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/rabbit/v1_0/ContextPropagationTest.java +++ b/instrumentation/spring/spring-rabbit-1.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/rabbit/v1_0/ContextPropagationTest.java @@ -152,71 +152,67 @@ public class ContextPropagationTest { }); testing.waitAndAssertTraces( trace -> { - trace - .hasSize(5) - .hasSpansSatisfyingExactlyInAnyOrder( - span -> span.hasName("parent"), - span -> - span.hasName(" publish") - .hasKind(SpanKind.PRODUCER) - .hasParent(trace.getSpan(0)) - .hasAttributesSatisfyingExactly( - getAssertions( - "", "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( - "", "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 - publish - // 2 - testQueue process () - // 3 - testQueue process (testQueue) - // 4 - consumer - // but it could also be - // 0 - parent - // 1 - publish - // 2 - testQueue process (testQueue) - // 3 - consumer - // 4 - testQueue process () - // 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(" publish") + .hasKind(SpanKind.PRODUCER) + .hasParent(trace.getSpan(0)) + .hasAttributesSatisfyingExactly( + getAssertions( + "", "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( + "", "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 - publish + // 2 - testQueue process () + // 3 - testQueue process (testQueue) + // 4 - consumer + // but it could also be + // 0 - parent + // 1 - publish + // 2 - testQueue process (testQueue) + // 3 - consumer + // 4 - testQueue process () + // 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"))); }); } } diff --git a/smoke-tests-otel-starter/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java b/smoke-tests-otel-starter/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java index 4fd5581784..d7da4bd906 100644 --- a/smoke-tests-otel-starter/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java +++ b/smoke-tests-otel-starter/src/test/java/io/opentelemetry/smoketest/OtelSpringStarterSmokeTest.java @@ -85,7 +85,6 @@ class OtelSpringStarterSmokeTest { // Span TracesAssert.assertThat(exportedSpans) - .hasSize(2) .hasTracesSatisfyingExactly( traceAssert -> traceAssert.hasSpansSatisfyingExactly( diff --git a/testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/LibraryInstrumentationExtensionTest.java b/testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/LibraryInstrumentationExtensionTest.java index ffbdf71b4a..7c6c9bfa60 100644 --- a/testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/LibraryInstrumentationExtensionTest.java +++ b/testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/LibraryInstrumentationExtensionTest.java @@ -36,13 +36,10 @@ class LibraryInstrumentationExtensionTest { // then List> 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"))); } }