Deleted redundant checks (#10434)

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"));

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")));
   }
 }

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

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 {

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();
   }

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"))))));
   }
 }

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<Arguments> provideHibernateActionParameters() {

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"))))));
   }
 }

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());

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",
-                        "<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() {

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));
+                                      }));
+                }));
   }
 }

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)))));
   }
 }

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"));

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<Object> {

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"))));
   }
 }

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("<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")));
             });
       }
     }

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(

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

@@ -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")));
   }
 }