Fix tests

dd-java-agent/instrumentation/couchbase-2.0/src/main/java/datadog/trace/instrumentation/couchbase/client/CouchbaseClusterInstrumentation.java

@@ -53,7 +53,7 @@ public class CouchbaseClusterInstrumentation extends Instrumenter.Default {
   @Override
   public Map<? extends ElementMatcher<? super MethodDescription>, String> transformers() {
     return singletonMap(
-        isMethod().and(isPublic()).and(returns(named("rx.Observable"))),
+        isMethod().and(isPublic()).and(returns(named("rx.Observable"))).and(not(named("core"))),
         CouchbaseClientAdvice.class.getName());
   }
 

dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/CouchbaseAsyncClientTest.groovy

@@ -1,9 +1,13 @@
+import com.couchbase.client.java.AsyncCluster
+import com.couchbase.client.java.CouchbaseAsyncCluster
 import com.couchbase.client.java.document.JsonDocument
 import com.couchbase.client.java.document.json.JsonObject
 import com.couchbase.client.java.query.N1qlQuery
 import spock.util.concurrent.BlockingVariable
 import util.AbstractCouchbaseTest
 
+import java.util.concurrent.TimeUnit
+
 import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
 import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
 
@@ -13,21 +17,29 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
     def hasBucket = new BlockingVariable<Boolean>()
 
     when:
-    manager.hasBucket(bucketSettings.name()).subscribe({ result -> hasBucket.set(result) })
+    cluster.openBucket(bucketSettings.name(), bucketSettings.password()).subscribe({ bkt ->
+      manager.hasBucket(bucketSettings.name()).subscribe({ result -> hasBucket.set(result) })
+    })
 
     then:
     assert hasBucket.get()
-    assertTraces(1) {
+    sortAndAssertTraces(1) {
-      trace(0, 1) {
+      trace(0, 2) {
-        assertCouchbaseCall(it, 0, "ClusterManager.hasBucket")
+        assertCouchbaseCall(it, 0, "Cluster.openBucket", null)
+        assertCouchbaseCall(it, 1, "ClusterManager.hasBucket", null, span(0))
       }
     }
 
-    where:
+    cleanup:
-    manager               | cluster               | bucketSettings
+    cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
-    couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
-    memcacheAsyncManager  | memcacheAsyncCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
+    manager = cluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
     type = bucketSettings.type().name()
   }
 
@@ -49,7 +61,7 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
     then:
     inserted.get().content().getString("hello") == "world"
 
-    assertTraces(1) {
+    sortAndAssertTraces(1) {
       trace(0, 3) {
         basicSpan(it, 0, "someTrace")
 
@@ -58,11 +70,15 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
       }
     }
 
-    where:
+    cleanup:
-    manager               | cluster               | bucketSettings
+    cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
-    couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
-    memcacheAsyncManager  | memcacheAsyncCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
     type = bucketSettings.type().name()
   }
 
@@ -92,7 +108,7 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
     found.get() == inserted.get()
     found.get().content().getString("hello") == "world"
 
-    assertTraces(1) {
+    sortAndAssertTraces(1) {
       trace(0, 4) {
         basicSpan(it, 0, "someTrace")
 
@@ -102,23 +118,29 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
       }
     }
 
-    where:
+    cleanup:
-    manager               | cluster               | bucketSettings
+    cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
-    couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
-    memcacheAsyncManager  | memcacheAsyncCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
     type = bucketSettings.type().name()
   }
 
   def "test query"() {
     setup:
+    // Only couchbase buckets support queries.
+    AsyncCluster cluster = CouchbaseAsyncCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
     def queryResult = new BlockingVariable<JsonObject>()
 
     when:
     // Mock expects this specific query.
     // See com.couchbase.mock.http.query.QueryServer.handleString.
     runUnderTrace("someTrace") {
-      cluster.openBucket(bucketSettings.name(), bucketSettings.password()).subscribe({
+      cluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password()).subscribe({
         bkt ->
           bkt.query(N1qlQuery.simple("SELECT mockrow"))
             .flatMap({ query -> query.rows() })
@@ -132,20 +154,16 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
     then:
     queryResult.get().get("row") == "value"
 
-    assertTraces(1) {
+    sortAndAssertTraces(1) {
       trace(0, 3) {
         basicSpan(it, 0, "someTrace")
 
         assertCouchbaseCall(it, 2, "Cluster.openBucket", null, span(0))
-        assertCouchbaseCall(it, 1, "Bucket.query", bucketSettings.name(), span(2))
+        assertCouchbaseCall(it, 1, "Bucket.query", bucketCouchbase.name(), span(2))
       }
     }
 
-    where:
+    cleanup:
-    manager               | cluster               | bucketSettings
+    cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
-    couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
-    // Only couchbase buckets support queries.
-
-    type = bucketSettings.type().name()
   }
 }

dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/CouchbaseClientTest.groovy

@@ -1,4 +1,6 @@
 import com.couchbase.client.java.Bucket
+import com.couchbase.client.java.Cluster
+import com.couchbase.client.java.CouchbaseCluster
 import com.couchbase.client.java.document.JsonDocument
 import com.couchbase.client.java.document.json.JsonObject
 import com.couchbase.client.java.query.N1qlQuery
@@ -8,24 +10,28 @@ import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
 import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
 
 class CouchbaseClientTest extends AbstractCouchbaseTest {
-
   def "test hasBucket #type"() {
     when:
     def hasBucket = manager.hasBucket(bucketSettings.name())
 
     then:
     assert hasBucket
-    assertTraces(1) {
+    sortAndAssertTraces(1) {
       trace(0, 1) {
         assertCouchbaseCall(it, 0, "ClusterManager.hasBucket")
       }
     }
 
-    where:
+    cleanup:
-    manager          | cluster          | bucketSettings
+    cluster?.disconnect()
-    couchbaseManager | couchbaseCluster | bucketCouchbase
-    memcacheManager  | memcacheCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
+    manager = cluster.clusterManager(USERNAME, PASSWORD)
     type = bucketSettings.type().name()
   }
 
@@ -43,20 +49,27 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
     found == inserted
     found.content().getString("hello") == "world"
 
-    assertTraces(2) {
+    sortAndAssertTraces(3) {
       trace(0, 1) {
-        assertCouchbaseCall(it, 0, "Bucket.upsert", bucketSettings.name())
+        assertCouchbaseCall(it, 0, "Cluster.openBucket")
       }
       trace(1, 1) {
+        assertCouchbaseCall(it, 0, "Bucket.upsert", bucketSettings.name())
+      }
+      trace(2, 1) {
         assertCouchbaseCall(it, 0, "Bucket.get", bucketSettings.name())
       }
     }
 
-    where:
+    cleanup:
-    manager          | cluster          | bucketSettings
+    cluster?.disconnect()
-    couchbaseManager | couchbaseCluster | bucketCouchbase
-    memcacheManager  | memcacheCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
     type = bucketSettings.type().name()
   }
 
@@ -74,31 +87,42 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
     runUnderTrace("someTrace") {
       inserted = bkt.upsert(JsonDocument.create("helloworld", content))
       found = bkt.get("helloworld")
+
+      blockUntilChildSpansFinished(2)
     }
 
     then:
     found == inserted
     found.content().getString("hello") == "world"
 
-    assertTraces(1) {
+    sortAndAssertTraces(2) {
-      trace(0, 3) {
+      trace(0, 1) {
+        assertCouchbaseCall(it, 0, "Cluster.openBucket")
+      }
+      trace(1, 3) {
         basicSpan(it, 0, "someTrace")
         assertCouchbaseCall(it, 2, "Bucket.upsert", bucketSettings.name(), span(0))
         assertCouchbaseCall(it, 1, "Bucket.get", bucketSettings.name(), span(0))
       }
     }
 
-    where:
+    cleanup:
-    manager          | cluster          | bucketSettings
+    cluster?.disconnect()
-    couchbaseManager | couchbaseCluster | bucketCouchbase
-    memcacheManager  | memcacheCluster  | bucketMemcache
 
+    where:
+    environment          | bucketSettings
+    couchbaseEnvironment | bucketCouchbase
+    memcacheEnvironment  | bucketMemcache
+
+    cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
     type = bucketSettings.type().name()
   }
-
+  
   def "test query"() {
     setup:
-    Bucket bkt = cluster.openBucket(bucketSettings.name(), bucketSettings.password())
+    // Only couchbase buckets support queries.
+    Cluster cluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
+    Bucket bkt = cluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
 
     when:
     // Mock expects this specific query.
@@ -111,17 +135,16 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
     result.first().value().get("row") == "value"
 
     and:
-    assertTraces(1) {
+    sortAndAssertTraces(2) {
       trace(0, 1) {
-        assertCouchbaseCall(it, 0, "Bucket.query", bucketSettings.name())
+        assertCouchbaseCall(it, 0, "Cluster.openBucket")
+      }
+      trace(1, 1) {
+        assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
       }
     }
 
-    where:
+    cleanup:
-    manager          | cluster          | bucketSettings
+    cluster?.disconnect()
-    couchbaseManager | couchbaseCluster | bucketCouchbase
-    // Only couchbase buckets support queries.
-
-    type = bucketSettings.type().name()
   }
 }

dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/springdata/CouchbaseSpringRepositoryTest.groovy

@@ -1,9 +1,9 @@
 package springdata
 
+import com.couchbase.client.java.Cluster
+import com.couchbase.client.java.CouchbaseCluster
 import com.couchbase.client.java.view.DefaultView
 import com.couchbase.client.java.view.DesignDocument
-import datadog.trace.api.DDSpanTypes
-import io.opentracing.tag.Tags
 import org.springframework.context.ConfigurableApplicationContext
 import org.springframework.context.annotation.AnnotationConfigApplicationContext
 import org.springframework.data.repository.CrudRepository
@@ -31,20 +31,21 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
   DocRepository repo
 
   def setupSpec() {
+    Cluster couchbaseCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
 
     // Create view for SpringRepository's findAll()
     couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password()).bucketManager()
       .insertDesignDocument(
-      DesignDocument.create("doc", Collections.singletonList(DefaultView.create("all",
+        DesignDocument.create("doc", Collections.singletonList(DefaultView.create("all",
-        '''
+          '''
           function (doc, meta) {
              if (doc._class == "springdata.Doc") {
                emit(meta.id, null);
              }
           }
         '''.stripIndent()
-      )))
+        )))
-    )
+      )
     CouchbaseConfig.setEnvironment(couchbaseEnvironment)
     CouchbaseConfig.setBucketSettings(bucketCouchbase)
 
@@ -75,21 +76,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
     and:
     assertTraces(1) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.query"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
     }
 
@@ -107,21 +94,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
     and:
     assertTraces(1) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.upsert", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.upsert"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
     }
     TEST_WRITER.clear()
@@ -132,21 +105,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
     and:
     assertTraces(1) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.get", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.get"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
     }
     TEST_WRITER.clear()
@@ -160,55 +119,13 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
 
     assertTraces(3) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.upsert", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.upsert"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
       trace(1, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.query"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
       trace(2, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.get", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.get"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
     }
     TEST_WRITER.clear()
@@ -222,38 +139,10 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
     and:
     assertTraces(2) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.remove", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.remove"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
       trace(1, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
-          serviceName "couchbase"
-          resourceName "Bucket.query"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" bucketCouchbase.name()
-            defaultTags()
-          }
-        }
       }
     }
   }

dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/springdata/CouchbaseSpringTemplateTest.groovy

@@ -1,18 +1,32 @@
 package springdata
 
 import com.couchbase.client.java.Bucket
-import datadog.trace.api.DDSpanTypes
+import com.couchbase.client.java.Cluster
-import io.opentracing.tag.Tags
+import com.couchbase.client.java.CouchbaseCluster
+import com.couchbase.client.java.cluster.ClusterManager
 import org.springframework.data.couchbase.core.CouchbaseTemplate
 import spock.lang.Shared
 import util.AbstractCouchbaseTest
 
+import java.util.concurrent.TimeUnit
+
 class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
 
   @Shared
   List<CouchbaseTemplate> templates
 
+  @Shared
+  Cluster couchbaseCluster
+
+  @Shared
+  Cluster memcacheCluster
+
   def setupSpec() {
+    couchbaseCluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
+    memcacheCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
+    ClusterManager couchbaseManager = couchbaseCluster.clusterManager(USERNAME, PASSWORD)
+    ClusterManager memcacheManager = memcacheCluster.clusterManager(USERNAME, PASSWORD)
+
     Bucket bucketCouchbase = couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
     Bucket bucketMemcache = memcacheCluster.openBucket(bucketMemcache.name(), bucketMemcache.password())
 
@@ -20,8 +34,12 @@ class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
                  new CouchbaseTemplate(memcacheManager.info(), bucketMemcache)]
   }
 
+  def cleanupSpec() {
+    couchbaseCluster?.disconnect(5, TimeUnit.SECONDS)
+    memcacheCluster?.disconnect(5, TimeUnit.SECONDS)
+  }
 
-  def "test write/read #name"() {
+  def "test write #name"() {
     setup:
     def doc = new Doc()
 
@@ -31,81 +49,42 @@ class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
     then:
     template.findById("1", Doc) != null
 
+    and:
+    assertTraces(2) {
+      trace(0, 1) {
+        assertCouchbaseCall(it, 0, "Bucket.upsert", name)
+      }
+      trace(1, 1) {
+        assertCouchbaseCall(it, 0, "Bucket.get", name)
+      }
+    }
+
+    where:
+    template << templates
+    name = template.couchbaseBucket.name()
+  }
+
+  def "test remove #name"() {
+    setup:
+    def doc = new Doc()
+
     when:
+    template.save(doc)
     template.remove(doc)
 
     then:
     template.findById("1", Doc) == null
 
     and:
-    assertTraces(4) {
+    assertTraces(3) {
       trace(0, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.upsert", name)
-          serviceName "couchbase"
-          resourceName "Bucket.upsert"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" name
-            defaultTags()
-          }
-        }
       }
       trace(1, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.remove", name)
-          serviceName "couchbase"
-          resourceName "Bucket.get"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" name
-            defaultTags()
-          }
-        }
       }
       trace(2, 1) {
-        span(0) {
+        assertCouchbaseCall(it, 0, "Bucket.get", name)
-          serviceName "couchbase"
-          resourceName "Bucket.remove"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" name
-            defaultTags()
-          }
-        }
-      }
-      trace(3, 1) {
-        span(0) {
-          serviceName "couchbase"
-          resourceName "Bucket.get"
-          operationName "couchbase.call"
-          spanType DDSpanTypes.COUCHBASE
-          errored false
-          parent()
-          tags {
-            "$Tags.COMPONENT.key" "couchbase-client"
-            "$Tags.DB_TYPE.key" "couchbase"
-            "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
-            "bucket" name
-            defaultTags()
-          }
-        }
       }
     }
 

dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/util/AbstractCouchbaseTest.groovy

@@ -2,12 +2,8 @@ package util
 
 import com.couchbase.client.core.metrics.DefaultLatencyMetricsCollectorConfig
 import com.couchbase.client.core.metrics.DefaultMetricsCollectorConfig
-import com.couchbase.client.java.CouchbaseAsyncCluster
-import com.couchbase.client.java.CouchbaseCluster
 import com.couchbase.client.java.bucket.BucketType
-import com.couchbase.client.java.cluster.AsyncClusterManager
 import com.couchbase.client.java.cluster.BucketSettings
-import com.couchbase.client.java.cluster.ClusterManager
 import com.couchbase.client.java.cluster.DefaultBucketSettings
 import com.couchbase.client.java.env.CouchbaseEnvironment
 import com.couchbase.client.java.env.DefaultCouchbaseEnvironment
@@ -17,20 +13,22 @@ import com.couchbase.mock.CouchbaseMock
 import com.couchbase.mock.http.query.QueryServer
 import datadog.opentracing.DDSpan
 import datadog.trace.agent.test.AgentTestRunner
+import datadog.trace.agent.test.asserts.ListWriterAssert
 import datadog.trace.agent.test.asserts.TraceAssert
 import datadog.trace.agent.test.utils.PortUtils
 import datadog.trace.api.Config
 import datadog.trace.api.DDSpanTypes
+import groovy.transform.stc.ClosureParams
+import groovy.transform.stc.SimpleType
 import io.opentracing.tag.Tags
 import spock.lang.Shared
 
-import java.util.concurrent.RejectedExecutionException
 import java.util.concurrent.TimeUnit
 
 abstract class AbstractCouchbaseTest extends AgentTestRunner {
 
-  private static final USERNAME = "Administrator"
+  static final USERNAME = "Administrator"
-  private static final PASSWORD = "password"
+  static final PASSWORD = "password"
 
   @Shared
   private int port = PortUtils.randomOpenPort()
@@ -58,53 +56,23 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
 
   @Shared
   CouchbaseMock mock
-  @Shared
+
-  protected CouchbaseCluster couchbaseCluster
-  @Shared
-  protected CouchbaseAsyncCluster couchbaseAsyncCluster
-  @Shared
-  protected CouchbaseCluster memcacheCluster
-  @Shared
-  protected CouchbaseAsyncCluster memcacheAsyncCluster
   @Shared
   protected CouchbaseEnvironment couchbaseEnvironment
   @Shared
   protected CouchbaseEnvironment memcacheEnvironment
-  @Shared
-  protected ClusterManager couchbaseManager
-  @Shared
-  protected AsyncClusterManager couchbaseAsyncManager
-  @Shared
-  protected ClusterManager memcacheManager
-  @Shared
-  protected AsyncClusterManager memcacheAsyncManager
 
   def setupSpec() {
-
     mock = new CouchbaseMock("127.0.0.1", port, 1, 1)
     mock.httpServer.register("/query", new QueryServer())
     mock.start()
     println "CouchbaseMock listening on localhost:$port"
 
     mock.createBucket(convert(bucketCouchbase))
-
-    couchbaseEnvironment = envBuilder(bucketCouchbase).build()
-    couchbaseCluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
-    couchbaseAsyncCluster = CouchbaseAsyncCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
-    couchbaseManager = couchbaseCluster.clusterManager(USERNAME, PASSWORD)
-    couchbaseAsyncManager = couchbaseAsyncCluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
-
     mock.createBucket(convert(bucketMemcache))
 
+    couchbaseEnvironment = envBuilder(bucketCouchbase).build()
     memcacheEnvironment = envBuilder(bucketMemcache).build()
-    memcacheCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
-    memcacheAsyncCluster = CouchbaseAsyncCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
-    memcacheManager = memcacheCluster.clusterManager(USERNAME, PASSWORD)
-    memcacheAsyncManager = memcacheAsyncCluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
-
-    // Cache buckets:
-    couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
-    memcacheCluster.openBucket(bucketMemcache.name(), bucketMemcache.password())
 
     // This setting should have no effect since decorator returns null for the instance.
     System.setProperty(Config.PREFIX + Config.DB_CLIENT_HOST_SPLIT_BY_INSTANCE, "true")
@@ -121,17 +89,6 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
   }
 
   def cleanupSpec() {
-    try {
-      couchbaseCluster?.disconnect()
-    } catch (RejectedExecutionException e) {
-      // already closed by a test?
-    }
-    try {
-      memcacheCluster?.disconnect()
-    } catch (RejectedExecutionException e) {
-      // already closed by a test?
-    }
-
     mock?.stop()
 
     System.clearProperty(Config.PREFIX + Config.DB_CLIENT_HOST_SPLIT_BY_INSTANCE)
@@ -159,6 +116,33 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
       .socketConnectTimeout(timeout.intValue())
   }
 
+  void sortAndAssertTraces(
+    final int size,
+    @ClosureParams(value = SimpleType, options = "datadog.trace.agent.test.asserts.ListWriterAssert")
+    @DelegatesTo(value = ListWriterAssert, strategy = Closure.DELEGATE_FIRST)
+    final Closure spec) {
+
+    TEST_WRITER.waitForTraces(size)
+
+    TEST_WRITER.each {
+      it.sort({
+        a, b ->
+          boolean aIsCouchbaseOperation = a.operationName == "couchbase.call"
+          boolean bIsCouchbaseOperation = b.operationName == "couchbase.call"
+
+          if (aIsCouchbaseOperation && !bIsCouchbaseOperation) {
+            return 1
+          } else if (!aIsCouchbaseOperation && bIsCouchbaseOperation) {
+            return -1
+          }
+
+          return a.resourceName.compareTo(b.resourceName)
+      })
+    }
+
+    assertTraces(size, spec)
+  }
+
   void assertCouchbaseCall(TraceAssert trace, int index, String name, String bucketName = null, Object parentSpan = null) {
     trace.span(index) {
       serviceName "couchbase"