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

Revert JvmTestSuite changes (#14550)

This commit is contained in:
Jay DeLuca 2025-08-31 06:25:26 -04:00 committed by GitHub
parent 774ee40f4e
commit 0cf2488555
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
102 changed files with 1153 additions and 1957 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
instrumentation-api-incubator/build.gradle.kts
View File

@ -28,30 +28,6 @@ dependencies {
testImplementation("io.opentelemetry:opentelemetry-sdk-extension-incubator")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database/dup,code/dup")
}
}
}
}
}
}
tasks {
// exclude auto-generated code
named<Checkstyle>("checkstyleMain") {
@ -69,7 +45,19 @@ tasks {
dependsOn("generateJflex")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database/dup,code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv, testBothSemconv)
}
}

26
instrumentation/alibaba-druid-1.0/javaagent/build.gradle.kts
View File

@ -21,28 +21,20 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/alibaba-druid-1.0/library/build.gradle.kts
View File

@ -9,22 +9,14 @@ dependencies {
testImplementation(project(":instrumentation:alibaba-druid-1.0:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

27
instrumentation/apache-dbcp-2.0/javaagent/build.gradle.kts
View File

@ -21,28 +21,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/apache-dbcp-2.0/library/build.gradle.kts
View File

@ -9,22 +9,15 @@ dependencies {
testImplementation(project(":instrumentation:apache-dbcp-2.0:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/aws-sdk/aws-sdk-1.11/javaagent/build.gradle.kts
View File

@ -128,18 +128,6 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -166,6 +154,19 @@ tasks {
jvmArgs("-Dotel.instrumentation.aws-sdk.experimental-span-attributes=true")
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testStableSemconv)
}
}
if (!(findProperty("testLatestDeps") as Boolean)) {

29
instrumentation/aws-sdk/aws-sdk-1.11/library-autoconfigure/build.gradle.kts
View File

@ -23,29 +23,22 @@ dependencies {
latestDepTestLibrary("com.amazonaws:aws-java-sdk-sqs:1.12.583") // documented limitation
}
testing {
suites {
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SqsSuppressReceiveSpansTest")
}
include("**/SqsSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("otel.instrumentation.aws-sdk.experimental-span-attributes", "true")
systemProperty("otel.instrumentation.messaging.experimental.capture-headers", "Test-Message-Header")
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SqsSuppressReceiveSpansTest")
}
include("**/SqsSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("SqsSuppressReceiveSpansTest")
@ -54,7 +47,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpansDisabled)
}
}

18
instrumentation/aws-sdk/aws-sdk-1.11/library/build.gradle.kts
View File

@ -48,21 +48,17 @@ testing {
implementation("com.amazonaws:aws-java-sdk-secretsmanager:$version")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

81
instrumentation/aws-sdk/aws-sdk-2.2/javaagent/build.gradle.kts
View File

@ -171,53 +171,40 @@ testing {
}
}
testing {
suites {
val testExperimentalSqs by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
excludeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
systemProperty("otel.instrumentation.aws-sdk.experimental-use-propagator-for-messaging", "true")
systemProperty("otel.instrumentation.messaging.experimental.receive-telemetry.enabled", "true")
}
}
}
}
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
include("**/Aws2SqsSuppressReceiveSpansTest.*")
}
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
excludeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
systemProperty("otel.instrumentation.messaging.experimental.receive-telemetry.enabled", "true")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testExperimentalSqs by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
excludeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
systemProperty("otel.instrumentation.aws-sdk.experimental-use-propagator-for-messaging", "true")
systemProperty("otel.instrumentation.messaging.experimental.receive-telemetry.enabled", "true")
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
include("**/Aws2SqsSuppressReceiveSpansTest.*")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
excludeTestsMatching("Aws2SqsSuppressReceiveSpansTest")
}
systemProperty("otel.instrumentation.messaging.experimental.receive-telemetry.enabled", "true")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
filter {
@ -228,7 +215,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testExperimentalSqs, testStableSemconv, testReceiveSpansDisabled)
}
withType<Test>().configureEach {

23
instrumentation/aws-sdk/aws-sdk-2.2/library-autoconfigure/build.gradle.kts
View File

@ -24,20 +24,6 @@ dependencies {
testLibrary("software.amazon.awssdk:sqs:2.2.0")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("otel.instrumentation.aws-sdk.experimental-span-attributes", true)
@ -46,7 +32,14 @@ tasks {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

19
instrumentation/aws-sdk/aws-sdk-2.2/library/build.gradle.kts
View File

@ -66,16 +66,6 @@ testing {
implementation("software.amazon.awssdk:bedrockruntime:$version")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -87,7 +77,14 @@ tasks {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

27
instrumentation/c3p0-0.9/javaagent/build.gradle.kts
View File

@ -23,28 +23,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/c3p0-0.9/library/build.gradle.kts
View File

@ -9,22 +9,15 @@ dependencies {
testImplementation(project(":instrumentation:c3p0-0.9:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

44
instrumentation/camel-2.20/javaagent/build.gradle.kts
View File

@ -67,32 +67,6 @@ dependencies {
latestDepTestLibrary("org.apache.camel:camel-cassandraql:2.+") // documented limitation
}
testing {
suites {
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.camel.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.camel.experimental-span-attributes=true")
}
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
jvmArgs("-Dotel.instrumentation.aws-sdk.experimental-span-attributes=true")
@ -109,8 +83,24 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.camel.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.camel.experimental-span-attributes=true")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv, testExperimental)
}
}

25
instrumentation/cassandra/cassandra-3.0/javaagent/build.gradle.kts
View File

@ -40,28 +40,21 @@ dependencies {
// Requires old Guava. Can't use enforcedPlatform since predates BOM
configurations.testRuntimeClasspath.get().resolutionStrategy.force("com.google.guava:guava:19.0")
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/cassandra/cassandra-4.0/javaagent/build.gradle.kts
View File

@ -23,28 +23,21 @@ dependencies {
testInstrumentation(project(":instrumentation:cassandra:cassandra-4.4:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/cassandra/cassandra-4.4/javaagent/build.gradle.kts
View File

@ -26,28 +26,21 @@ dependencies {
testInstrumentation(project(":instrumentation:cassandra:cassandra-4.0:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/cassandra/cassandra-4.4/library/build.gradle.kts
View File

@ -11,26 +11,18 @@ dependencies {
testImplementation(project(":instrumentation:cassandra:cassandra-4.4:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

32
instrumentation/clickhouse-client-0.5/javaagent/build.gradle.kts
View File

@ -22,31 +22,21 @@ dependencies {
testLibrary("org.apache.httpcomponents.client5:httpclient5:5.2.3")
}
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
}
}
}
}
}
}
tasks {
test {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", collectMetadata)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/couchbase/couchbase-2.0/javaagent/build.gradle.kts
View File

@ -30,21 +30,6 @@ dependencies {
latestDepTestLibrary("com.couchbase.client:java-client:2.5.+") // see couchbase-2.6 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// required on jdk17
@ -55,7 +40,15 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

44
instrumentation/couchbase/couchbase-2.6/javaagent/build.gradle.kts
View File

@ -33,32 +33,6 @@ dependencies {
latestDepTestLibrary("com.couchbase.client:java-client:2.+") // see couchbase-3.1 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.couchbase.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.couchbase.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// required on jdk17
@ -68,7 +42,23 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.couchbase.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.couchbase.experimental-span-attributes=true")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv, testExperimental)
}
}

23
instrumentation/couchbase/couchbase-3.1.6/javaagent/build.gradle.kts
View File

@ -38,26 +38,19 @@ dependencies {
latestDepTestLibrary("com.couchbase.client:java-client:3.1.+") // see couchbase-3.2 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/couchbase/couchbase-3.1/javaagent/build.gradle.kts
View File

@ -39,26 +39,18 @@ dependencies {
latestDepTestLibrary("com.couchbase.client:java-client:3.1.5") // see couchbase-3.1.6 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/couchbase/couchbase-3.2/javaagent/build.gradle.kts
View File

@ -36,27 +36,20 @@ dependencies {
testImplementation("org.testcontainers:couchbase")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

21
instrumentation/elasticsearch/elasticsearch-api-client-7.16/javaagent/build.gradle.kts
View File

@ -70,17 +70,6 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -92,7 +81,15 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

25
instrumentation/elasticsearch/elasticsearch-rest-5.0/javaagent/build.gradle.kts
View File

@ -35,21 +35,6 @@ dependencies {
latestDepTestLibrary("org.elasticsearch.client:elasticsearch-rest-client:6.3.+") // see elasticsearch-rest-6.4 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
@ -58,7 +43,15 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/elasticsearch/elasticsearch-rest-6.4/javaagent/build.gradle.kts
View File

@ -35,28 +35,21 @@ dependencies {
latestDepTestLibrary("org.elasticsearch.client:elasticsearch-rest-client:6.+") // see elasticsearch-rest-7.0 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/elasticsearch/elasticsearch-rest-7.0/javaagent/build.gradle.kts
View File

@ -38,21 +38,6 @@ dependencies {
testImplementation("org.testcontainers:elasticsearch")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
@ -61,7 +46,15 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

44
instrumentation/elasticsearch/elasticsearch-transport-5.0/javaagent/build.gradle.kts
View File

@ -49,32 +49,6 @@ dependencies {
latestDepTestLibrary("org.elasticsearch.client:transport:5.2.+") // see elasticsearch-transport-5.3 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.elasticsearch.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.elasticsearch.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// required on jdk17
@ -83,7 +57,23 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.elasticsearch.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.elasticsearch.experimental-span-attributes=true")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv, testExperimental)
}
}

44
instrumentation/elasticsearch/elasticsearch-transport-5.3/javaagent/build.gradle.kts
View File

@ -65,32 +65,6 @@ dependencies {
latestDepTestLibrary("org.springframework.data:spring-data-elasticsearch:3.0.+") // see elasticsearch-transport-6.0 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.elasticsearch.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.elasticsearch.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
@ -102,7 +76,23 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.elasticsearch.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.elasticsearch.experimental-span-attributes=true")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv, testExperimental)
}
}

60
instrumentation/external-annotations/javaagent/build.gradle.kts
View File

@ -34,41 +34,31 @@ dependencies {
testCompileOnly("org.springframework:spring-core:4.3.30.RELEASE")
}
testing {
suites {
val testIncludeProperty by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("ConfiguredTraceAnnotationsTest")
}
include("**/ConfiguredTraceAnnotationsTest.*")
jvmArgs("-Dotel.instrumentation.external-annotations.include=io.opentelemetry.javaagent.instrumentation.extannotations.OuterClass\$InterestingMethod")
}
}
}
}
val testExcludeMethodsProperty by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("TracedMethodsExclusionTest")
}
include("**/TracedMethodsExclusionTest.*")
jvmArgs(
"-Dotel.instrumentation.external-annotations.exclude-methods=io.opentelemetry.javaagent.instrumentation.extannotations.TracedMethodsExclusionTest\$TestClass[excluded,annotatedButExcluded]"
)
}
}
}
}
}
}
tasks {
val testIncludeProperty by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("ConfiguredTraceAnnotationsTest")
}
include("**/ConfiguredTraceAnnotationsTest.*")
jvmArgs("-Dotel.instrumentation.external-annotations.include=io.opentelemetry.javaagent.instrumentation.extannotations.OuterClass\$InterestingMethod")
}
val testExcludeMethodsProperty by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("TracedMethodsExclusionTest")
}
include("**/TracedMethodsExclusionTest.*")
jvmArgs(
"-Dotel.instrumentation.external-annotations.exclude-methods=io.opentelemetry.javaagent.instrumentation.extannotations.TracedMethodsExclusionTest\$TestClass[excluded,annotatedButExcluded]"
)
}
test {
filter {
excludeTestsMatching("ConfiguredTraceAnnotationsTest")
@ -77,6 +67,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testIncludeProperty, testExcludeMethodsProperty)
}
}

27
instrumentation/geode-1.4/javaagent/build.gradle.kts
View File

@ -19,28 +19,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/graphql-java/graphql-java-20.0/javaagent/build.gradle.kts
View File

@ -23,29 +23,22 @@ dependencies {
testImplementation(project(":instrumentation:graphql-java:graphql-java-common:testing"))
}
testing {
suites {
val testDataFetcher by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.graphql.data-fetcher.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.graphql.data-fetcher.enabled=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
jvmArgs("-Dotel.instrumentation.graphql.add-operation-name-to-span-name.enabled=true")
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testDataFetcher by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.graphql.data-fetcher.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.graphql.data-fetcher.enabled=true")
}
check {
dependsOn(testing.suites)
dependsOn(testDataFetcher)
}
}

40
instrumentation/guava-10.0/javaagent/build.gradle.kts
View File

@ -32,32 +32,22 @@ dependencies {
testImplementation("io.opentelemetry:opentelemetry-extension-annotations")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv, testBothSemconv)
}
}

23
instrumentation/hibernate/hibernate-3.3/javaagent/build.gradle.kts
View File

@ -48,20 +48,6 @@ if (findProperty("testLatestDeps") as Boolean) {
}
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// TODO run tests both with and without experimental span attributes
@ -71,7 +57,14 @@ tasks {
jvmArgs("-XX:+IgnoreUnrecognizedVMOptions")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

19
instrumentation/hibernate/hibernate-4.0/javaagent/build.gradle.kts
View File

@ -68,16 +68,6 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -94,7 +84,14 @@ tasks {
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

19
instrumentation/hibernate/hibernate-6.0/javaagent/build.gradle.kts
View File

@ -62,16 +62,6 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -93,7 +83,14 @@ tasks {
}
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

23
instrumentation/hibernate/hibernate-6.0/spring-testing/build.gradle.kts
View File

@ -24,20 +24,6 @@ otelJava {
minJavaVersionSupported.set(JavaVersion.VERSION_17)
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
jvmArgs("-javaagent:" + springAgent.singleFile.absolutePath)
@ -48,7 +34,14 @@ tasks {
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/hibernate/hibernate-procedure-call-4.3/javaagent/build.gradle.kts
View File

@ -31,27 +31,20 @@ dependencies {
latestDepTestLibrary("org.hibernate:hibernate-entitymanager:5.+") // documented limitation
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// TODO run tests both with and without experimental span attributes
jvmArgs("-Dotel.instrumentation.hibernate.experimental-span-attributes=true")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

19
instrumentation/hibernate/hibernate-reactive-1.0/javaagent/build.gradle.kts
View File

@ -72,16 +72,6 @@ testing {
compileOnly("io.vertx:vertx-codegen:4.4.2")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -114,8 +104,15 @@ tasks {
}
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

27
instrumentation/hikaricp-3.0/javaagent/build.gradle.kts
View File

@ -24,28 +24,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/hikaricp-3.0/library/build.gradle.kts
View File

@ -9,22 +9,15 @@ dependencies {
testImplementation(project(":instrumentation:hikaricp-3.0:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

19
instrumentation/influxdb-2.4/javaagent/build.gradle.kts
View File

@ -32,16 +32,6 @@ testing {
implementation("org.testcontainers:testcontainers")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -59,7 +49,14 @@ tasks {
}
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

104
instrumentation/jdbc/javaagent/build.gradle.kts
View File

@ -54,66 +54,50 @@ sourceSets {
}
}
testing {
suites {
val testSlick by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SlickTest")
}
include("**/SlickTest.*")
}
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
excludeTestsMatching("SlickTest")
excludeTestsMatching("PreparedStatementParametersTest")
}
jvmArgs("-Dotel.instrumentation.jdbc-datasource.enabled=true")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
val testSlickStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SlickTest")
}
include("**/SlickTest.*")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
val testCaptureParameters by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("PreparedStatementParametersTest")
}
jvmArgs("-Dotel.instrumentation.jdbc.experimental.capture-query-parameters=true")
}
}
}
}
}
}
tasks {
val testSlick by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SlickTest")
}
include("**/SlickTest.*")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
excludeTestsMatching("SlickTest")
excludeTestsMatching("PreparedStatementParametersTest")
}
jvmArgs("-Dotel.instrumentation.jdbc-datasource.enabled=true")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
val testSlickStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SlickTest")
}
include("**/SlickTest.*")
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
val testCaptureParameters by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("PreparedStatementParametersTest")
}
jvmArgs("-Dotel.instrumentation.jdbc.experimental.capture-query-parameters=true")
}
test {
filter {
excludeTestsMatching("SlickTest")
@ -123,7 +107,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testSlick, testStableSemconv, testSlickStableSemconv, testCaptureParameters)
}
}

23
instrumentation/jdbc/library/build.gradle.kts
View File

@ -15,20 +15,6 @@ dependencies {
testImplementation(project(":instrumentation:jdbc:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
// We cannot use "--release" javac option here because that will forbid using apis that were added
// in later versions. In JDBC wrappers we wish to implement delegation for methods that are not
@ -65,8 +51,15 @@ tasks {
include("io/opentelemetry/javaagent/bootstrap/**")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

19
instrumentation/jedis/jedis-1.4/javaagent/build.gradle.kts
View File

@ -35,16 +35,6 @@ testing {
implementation(project(":instrumentation:jedis:jedis-1.4:testing"))
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -53,7 +43,14 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

23
instrumentation/jedis/jedis-3.0/javaagent/build.gradle.kts
View File

@ -28,26 +28,19 @@ dependencies {
latestDepTestLibrary("redis.clients:jedis:3.+") // see jedis-4.0 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

23
instrumentation/jedis/jedis-4.0/javaagent/build.gradle.kts
View File

@ -24,20 +24,6 @@ dependencies {
testInstrumentation(project(":instrumentation:jedis:jedis-3.0:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// latest dep test fails because peer ip is 0:0:0:0:0:0:0:1 instead of 127.0.0.1
@ -45,7 +31,14 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

25
instrumentation/jms/jms-1.1/javaagent/build.gradle.kts
View File

@ -45,19 +45,6 @@ testing {
}
}
}
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Jms1SuppressReceiveSpansTest")
}
include("**/Jms1SuppressReceiveSpansTest.*")
}
}
}
}
}
}
@ -66,6 +53,16 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Jms1SuppressReceiveSpansTest")
}
include("**/Jms1SuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("Jms1SuppressReceiveSpansTest")
@ -74,7 +71,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testReceiveSpansDisabled)
}
}

29
instrumentation/jms/jms-3.0/javaagent/build.gradle.kts
View File

@ -29,23 +29,6 @@ dependencies {
testImplementation("org.apache.activemq:artemis-jakarta-client:2.27.1")
}
testing {
suites {
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Jms3SuppressReceiveSpansTest")
}
include("**/Jms3SuppressReceiveSpansTest.*")
}
}
}
}
}
}
otelJava {
minJavaVersionSupported.set(JavaVersion.VERSION_11)
}
@ -55,6 +38,16 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Jms3SuppressReceiveSpansTest")
}
include("**/Jms3SuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("Jms3SuppressReceiveSpansTest")
@ -63,6 +56,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testReceiveSpansDisabled)
}
}

52
instrumentation/kafka/kafka-clients/kafka-clients-0.11/javaagent/build.gradle.kts
View File

@ -25,37 +25,6 @@ dependencies {
testImplementation(project(":instrumentation:kafka:kafka-clients:kafka-clients-0.11:testing"))
}
testing {
suites {
val testPropagationDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("KafkaClientPropagationDisabledTest")
}
include("**/KafkaClientPropagationDisabledTest.*")
jvmArgs("-Dotel.instrumentation.kafka.producer-propagation.enabled=false")
}
}
}
}
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("KafkaClientSuppressReceiveSpansTest")
}
include("**/KafkaClientSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
@ -66,6 +35,25 @@ tasks {
jvmArgs("-Dotel.instrumentation.kafka.experimental-span-attributes=true")
}
val testPropagationDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("KafkaClientPropagationDisabledTest")
}
include("**/KafkaClientPropagationDisabledTest.*")
jvmArgs("-Dotel.instrumentation.kafka.producer-propagation.enabled=false")
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("KafkaClientSuppressReceiveSpansTest")
}
include("**/KafkaClientSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("KafkaClientPropagationDisabledTest")
@ -75,6 +63,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testPropagationDisabled, testReceiveSpansDisabled)
}
}

30
instrumentation/kafka/kafka-clients/kafka-clients-2.6/library/build.gradle.kts
View File

@ -16,30 +16,22 @@ dependencies {
testAnnotationProcessor("com.google.auto.value:auto-value")
}
testing {
suites {
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("InterceptorsSuppressReceiveSpansTest")
includeTestsMatching("WrapperSuppressReceiveSpansTest")
}
include("**/InterceptorsSuppressReceiveSpansTest.*", "**/WrapperSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("InterceptorsSuppressReceiveSpansTest")
includeTestsMatching("WrapperSuppressReceiveSpansTest")
}
include("**/InterceptorsSuppressReceiveSpansTest.*", "**/WrapperSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("InterceptorsSuppressReceiveSpansTest")
@ -50,6 +42,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpansDisabled)
}
}

28
instrumentation/kafka/kafka-streams-0.11/javaagent/build.gradle.kts
View File

@ -23,23 +23,6 @@ dependencies {
testImplementation("org.testcontainers:kafka")
}
testing {
suites {
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("KafkaStreamsSuppressReceiveSpansTest")
}
include("**/KafkaStreamsSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
@ -50,6 +33,15 @@ tasks {
jvmArgs("-Dotel.instrumentation.kafka.experimental-span-attributes=true")
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("KafkaStreamsSuppressReceiveSpansTest")
}
include("**/KafkaStreamsSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("KafkaStreamsSuppressReceiveSpansTest")
@ -58,6 +50,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpansDisabled)
}
}

22
instrumentation/lettuce/lettuce-4.0/javaagent/build.gradle.kts
View File

@ -17,20 +17,6 @@ dependencies {
latestDepTestLibrary("biz.paluch.redis:lettuce:4.+") // see lettuce-5.0 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// TODO run tests both with and without experimental span attributes
@ -39,7 +25,13 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/lettuce/lettuce-5.0/javaagent/build.gradle.kts
View File

@ -24,20 +24,6 @@ dependencies {
latestDepTestLibrary("io.lettuce:lettuce-core:5.0.+") // see lettuce-5.1 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// TODO run tests both with and without experimental span attributes
@ -46,7 +32,13 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/lettuce/lettuce-5.1/javaagent/build.gradle.kts
View File

@ -23,27 +23,19 @@ dependencies {
testInstrumentation(project(":instrumentation:reactor:reactor-3.1:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/lettuce/lettuce-5.1/library/build.gradle.kts
View File

@ -12,27 +12,19 @@ dependencies {
testImplementation(project(":instrumentation:reactor:reactor-3.1:library"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/log4j/log4j-appender-2.17/javaagent/build.gradle.kts
View File

@ -45,23 +45,15 @@ tasks.withType<Test>().configureEach {
systemProperty("testLatestDeps", testLatestDeps)
}
testing {
suites {
val testAsync by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-DLog4j2.contextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector")
}
}
}
}
}
}
tasks {
val testAsync by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-DLog4j2.contextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector")
}
check {
dependsOn(testing.suites)
dependsOn(testAsync)
}
}

54
instrumentation/log4j/log4j-appender-2.17/library/build.gradle.kts
View File

@ -17,47 +17,31 @@ dependencies {
}
}
testing {
suites {
val testAsyncLogger by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-DLog4j2.contextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector")
}
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
val testAsyncLogger by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-DLog4j2.contextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testAsyncLogger, testStableSemconv, testBothSemconv)
}
}

54
instrumentation/log4j/log4j-context-data/log4j-context-data-2.17/library-autoconfigure/build.gradle.kts
View File

@ -11,38 +11,6 @@ dependencies {
testImplementation(project(":instrumentation:log4j:log4j-context-data:log4j-context-data-common:testing"))
}
testing {
suites {
val testAddBaggage by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("LibraryLog4j2BaggageTest")
}
jvmArgs("-Dotel.instrumentation.log4j-context-data.add-baggage=true")
}
}
}
}
val testLoggingKeys by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("LibraryLog4j2LoggingKeysTest")
}
jvmArgs("-Dotel.instrumentation.common.logging.trace-id=trace_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.span-id=span_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.trace-flags=trace_flags_test")
}
}
}
}
}
}
tasks {
test {
filter {
@ -51,7 +19,27 @@ tasks {
}
}
val testAddBaggage by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("LibraryLog4j2BaggageTest")
}
jvmArgs("-Dotel.instrumentation.log4j-context-data.add-baggage=true")
}
val testLoggingKeys by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("LibraryLog4j2LoggingKeysTest")
}
jvmArgs("-Dotel.instrumentation.common.logging.trace-id=trace_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.span-id=span_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.trace-flags=trace_flags_test")
}
named("check") {
dependsOn(testing.suites)
dependsOn(testAddBaggage, testLoggingKeys)
}
}

54
instrumentation/log4j/log4j-context-data/log4j-context-data-2.7/javaagent/build.gradle.kts
View File

@ -21,38 +21,6 @@ dependencies {
latestDepTestLibrary("org.apache.logging.log4j:log4j-core:2.16.+") // see log4j-context-data-2.17 module
}
testing {
suites {
val testAddBaggage by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Log4j27BaggageTest")
}
jvmArgs("-Dotel.instrumentation.log4j-context-data.add-baggage=true")
}
}
}
}
val testLoggingKeys by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Log4j27LoggingKeysTest")
}
jvmArgs("-Dotel.instrumentation.common.logging.trace-id=trace_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.span-id=span_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.trace-flags=trace_flags_test")
}
}
}
}
}
}
tasks {
test {
filter {
@ -62,7 +30,27 @@ tasks {
jvmArgs("-Dotel.instrumentation.common.mdc.resource-attributes=service.name,telemetry.sdk.language")
}
val testAddBaggage by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Log4j27BaggageTest")
}
jvmArgs("-Dotel.instrumentation.log4j-context-data.add-baggage=true")
}
val testLoggingKeys by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Log4j27LoggingKeysTest")
}
jvmArgs("-Dotel.instrumentation.common.logging.trace-id=trace_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.span-id=span_id_test")
jvmArgs("-Dotel.instrumentation.common.logging.trace-flags=trace_flags_test")
}
named("check") {
dependsOn(testing.suites)
dependsOn(testAddBaggage, testLoggingKeys)
}
}

34
instrumentation/logback/logback-appender-1.0/library/build.gradle.kts
View File

@ -121,33 +121,25 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv, testBothSemconv)
}
}

78
instrumentation/micrometer/micrometer-1.5/javaagent/build.gradle.kts
View File

@ -19,53 +19,37 @@ dependencies {
testImplementation(project(":instrumentation:micrometer:micrometer-1.5:testing"))
}
testing {
suites {
val testPrometheusMode by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*PrometheusModeTest")
}
include("**/*PrometheusModeTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.prometheus-mode.enabled=true")
}
}
}
}
val testBaseTimeUnit by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*TimerMillisecondsTest")
}
include("**/*TimerMillisecondsTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.base-time-unit=milliseconds")
}
}
}
}
val testHistogramGauges by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*HistogramGaugesTest")
}
include("**/*HistogramGaugesTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.histogram-gauges.enabled=true")
}
}
}
}
}
}
tasks {
val testPrometheusMode by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*PrometheusModeTest")
}
include("**/*PrometheusModeTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.prometheus-mode.enabled=true")
}
val testBaseTimeUnit by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*TimerMillisecondsTest")
}
include("**/*TimerMillisecondsTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.base-time-unit=milliseconds")
}
val testHistogramGauges by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*HistogramGaugesTest")
}
include("**/*HistogramGaugesTest.*")
jvmArgs("-Dotel.instrumentation.micrometer.histogram-gauges.enabled=true")
}
test {
filter {
excludeTestsMatching("*TimerMillisecondsTest")
@ -75,7 +59,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testBaseTimeUnit, testPrometheusMode, testHistogramGauges)
}
withType<Test>().configureEach {

22
instrumentation/mongo/mongo-3.1/javaagent/build.gradle.kts
View File

@ -23,26 +23,18 @@ dependencies {
testInstrumentation(project(":instrumentation:mongo:mongo-4.0:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/mongo/mongo-3.1/library/build.gradle.kts
View File

@ -12,26 +12,18 @@ dependencies {
testImplementation(project(":instrumentation:mongo:mongo-3.1:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/mongo/mongo-3.7/javaagent/build.gradle.kts
View File

@ -33,26 +33,18 @@ dependencies {
testInstrumentation(project(":instrumentation:mongo:mongo-4.0:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/mongo/mongo-4.0/javaagent/build.gradle.kts
View File

@ -29,26 +29,18 @@ dependencies {
testInstrumentation(project(":instrumentation:mongo:mongo-3.7:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/mongo/mongo-async-3.3/javaagent/build.gradle.kts
View File

@ -24,26 +24,18 @@ dependencies {
testInstrumentation(project(":instrumentation:mongo:mongo-4.0:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

34
instrumentation/netty/netty-4.0/javaagent/build.gradle.kts
View File

@ -35,27 +35,19 @@ dependencies {
latestDepTestLibrary("io.netty:netty-codec-http:4.0.+") // see netty-4.1 module
}
testing {
suites {
val testConnectionSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Netty40ConnectionSpanTest")
includeTestsMatching("Netty40ClientSslTest")
}
include("**/Netty40ConnectionSpanTest.*", "**/Netty40ClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
}
}
}
}
}
}
tasks {
val testConnectionSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Netty40ConnectionSpanTest")
includeTestsMatching("Netty40ClientSslTest")
}
include("**/Netty40ConnectionSpanTest.*", "**/Netty40ClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
}
test {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
@ -66,7 +58,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testConnectionSpan)
}
}

34
instrumentation/netty/netty-4.1/javaagent/build.gradle.kts
View File

@ -42,27 +42,19 @@ dependencies {
testCompileOnly("io.netty:netty-transport-native-kqueue:4.1.11.Final:osx-x86_64")
}
testing {
suites {
val testConnectionSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("Netty41ConnectionSpanTest")
includeTestsMatching("Netty41ClientSslTest")
}
include("**/Netty41ConnectionSpanTest.*", "**/Netty41ClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
}
}
}
}
}
}
tasks {
val testConnectionSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("Netty41ConnectionSpanTest")
includeTestsMatching("Netty41ClientSslTest")
}
include("**/Netty41ConnectionSpanTest.*", "**/Netty41ClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
}
test {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
@ -74,7 +66,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testConnectionSpan)
}
}

22
instrumentation/opensearch/opensearch-rest-1.0/javaagent/build.gradle.kts
View File

@ -39,26 +39,18 @@ dependencies {
latestDepTestLibrary("org.opensearch.client:opensearch-rest-client:2.+") // see opensearch-rest-3.0 module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
test {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/opensearch/opensearch-rest-3.0/javaagent/build.gradle.kts
View File

@ -32,26 +32,18 @@ dependencies {
testImplementation(project(":instrumentation:opensearch:opensearch-rest-common:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
test {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

34
instrumentation/opentelemetry-instrumentation-api/javaagent/build.gradle.kts
View File

@ -41,26 +41,6 @@ testing {
implementation(project(":instrumentation:opentelemetry-instrumentation-api:testing"))
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
}
}
}
}
}
@ -87,7 +67,19 @@ configurations.configureEach {
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv, testBothSemconv)
}
}

26
instrumentation/oracle-ucp-11.2/javaagent/build.gradle.kts
View File

@ -22,29 +22,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
test {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", collectMetadata)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/oracle-ucp-11.2/library/build.gradle.kts
View File

@ -10,26 +10,18 @@ dependencies {
testImplementation(project(":instrumentation:oracle-ucp-11.2:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
test {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

26
instrumentation/oshi/javaagent/build.gradle.kts
View File

@ -22,28 +22,20 @@ dependencies {
testImplementation(project(":instrumentation:oshi:testing"))
}
testing {
suites {
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.oshi.experimental-metrics.enabled=true")
systemProperty("testExperimental", "true")
systemProperty("metadataConfig", "otel.instrumentation.oshi.experimental-metrics.enabled=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.oshi.experimental-metrics.enabled=true")
systemProperty("testExperimental", "true")
systemProperty("metadataConfig", "otel.instrumentation.oshi.experimental-metrics.enabled=true")
}
check {
dependsOn(testing.suites)
dependsOn(testExperimental)
}
}

28
instrumentation/pulsar/pulsar-2.8/javaagent/build.gradle.kts
View File

@ -19,24 +19,16 @@ dependencies {
testImplementation("org.apache.pulsar:pulsar-client-admin:2.8.0")
}
testing {
suites {
val testReceiveSpanDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("PulsarClientSuppressReceiveSpansTest")
}
include("**/PulsarClientSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
val testReceiveSpanDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("PulsarClientSuppressReceiveSpansTest")
}
include("**/PulsarClientSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("PulsarClientSuppressReceiveSpansTest")
@ -45,7 +37,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpanDisabled)
}
}

22
instrumentation/r2dbc-1.0/javaagent/build.gradle.kts
View File

@ -30,26 +30,18 @@ dependencies {
testInstrumentation(project(":instrumentation:reactor:reactor-3.1:javaagent"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

22
instrumentation/r2dbc-1.0/library/build.gradle.kts
View File

@ -10,26 +10,18 @@ dependencies {
testImplementation(project(":instrumentation:reactor:reactor-3.1:library"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

34
instrumentation/reactor/reactor-3.1/javaagent/build.gradle.kts
View File

@ -53,32 +53,24 @@ testing {
implementation("io.projectreactor:reactor-test:$version")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
}
}
}
val testBothSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code")
}
val testBothSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=code/dup")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv, testBothSemconv)
}
}

32
instrumentation/reactor/reactor-netty/reactor-netty-0.9/javaagent/build.gradle.kts
View File

@ -31,26 +31,18 @@ dependencies {
latestDepTestLibrary("io.projectreactor.netty:reactor-netty:0.+") // see reactor-netty-1.0 modules
}
testing {
suites {
val testConnectionSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("ReactorNettyConnectionSpanTest")
}
include("**/ReactorNettyConnectionSpanTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
}
}
}
}
}
tasks {
val testConnectionSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("ReactorNettyConnectionSpanTest")
}
include("**/ReactorNettyConnectionSpanTest.*")
jvmArgs("-Dotel.instrumentation.netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
test {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
@ -60,6 +52,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testConnectionSpan)
}
}

36
instrumentation/reactor/reactor-netty/reactor-netty-1.0/javaagent/build.gradle.kts
View File

@ -43,28 +43,20 @@ dependencies {
testImplementation(project(":instrumentation-annotations"))
}
testing {
suites {
val testConnectionSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("ReactorNettyConnectionSpanTest")
includeTestsMatching("ReactorNettyClientSslTest")
}
include("**/ReactorNettyConnectionSpanTest.*", "**/ReactorNettyClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.reactor-netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
}
}
}
}
}
tasks {
val testConnectionSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("ReactorNettyConnectionSpanTest")
includeTestsMatching("ReactorNettyClientSslTest")
}
include("**/ReactorNettyConnectionSpanTest.*", "**/ReactorNettyClientSslTest.*")
jvmArgs("-Dotel.instrumentation.netty.ssl-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.reactor-netty.connection-telemetry.enabled=true")
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
test {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
@ -75,6 +67,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testConnectionSpan)
}
}

22
instrumentation/redisson/redisson-3.17/javaagent/build.gradle.kts
View File

@ -24,27 +24,19 @@ dependencies {
testImplementation(project(":instrumentation:redisson:redisson-common:testing"))
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

28
instrumentation/rocketmq/rocketmq-client/rocketmq-client-5.0/javaagent/build.gradle.kts
View File

@ -17,24 +17,16 @@ dependencies {
testImplementation(project(":instrumentation:rocketmq:rocketmq-client:rocketmq-client-5.0:testing"))
}
testing {
suites {
val testReceiveSpanDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("RocketMqClientSuppressReceiveSpanTest")
}
include("**/RocketMqClientSuppressReceiveSpanTest.*")
}
}
}
}
}
}
tasks {
val testReceiveSpanDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("RocketMqClientSuppressReceiveSpanTest")
}
include("**/RocketMqClientSuppressReceiveSpanTest.*")
}
test {
filter {
excludeTestsMatching("RocketMqClientSuppressReceiveSpanTest")
@ -44,6 +36,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpanDisabled)
}
}

78
instrumentation/runtime-telemetry/runtime-telemetry-java17/library/build.gradle.kts
View File

@ -11,52 +11,6 @@ dependencies {
testImplementation("io.github.netmikey.logunit:logunit-jul:1.1.3")
}
testing {
suites {
val testG1 by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*G1GcMemoryMetricTest*")
}
include("**/*G1GcMemoryMetricTest.*")
jvmArgs("-XX:+UseG1GC")
}
}
}
}
val testPS by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*PsGcMemoryMetricTest*")
}
include("**/*PsGcMemoryMetricTest.*")
jvmArgs("-XX:+UseParallelGC")
}
}
}
}
val testSerial by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*SerialGcMemoryMetricTest*")
}
include("**/*SerialGcMemoryMetricTest.*")
jvmArgs("-XX:+UseSerialGC")
}
}
}
}
}
}
tasks.register("generateDocs", JavaExec::class) {
group = "build"
description = "Generate table for README.md"
@ -66,6 +20,36 @@ tasks.register("generateDocs", JavaExec::class) {
}
tasks {
val testG1 by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*G1GcMemoryMetricTest*")
}
include("**/*G1GcMemoryMetricTest.*")
jvmArgs("-XX:+UseG1GC")
}
val testPS by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*PsGcMemoryMetricTest*")
}
include("**/*PsGcMemoryMetricTest.*")
jvmArgs("-XX:+UseParallelGC")
}
val testSerial by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*SerialGcMemoryMetricTest*")
}
include("**/*SerialGcMemoryMetricTest.*")
jvmArgs("-XX:+UseSerialGC")
}
test {
filter {
excludeTestsMatching("*G1GcMemoryMetricTest")
@ -75,7 +59,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testG1, testPS, testSerial)
}
compileJava {

56
instrumentation/spring/spring-batch-3.0/javaagent/build.gradle.kts
View File

@ -24,40 +24,28 @@ dependencies {
latestDepTestLibrary("org.springframework.batch:spring-batch-core:4.+") // documented limitation
}
testing {
suites {
val testChunkRootSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*ChunkRootSpanTest")
}
include("**/*ChunkRootSpanTest.*")
jvmArgs("-Dotel.instrumentation.spring-batch.experimental.chunk.new-trace=true")
}
}
}
}
val testItemLevelSpan by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("*ItemLevelSpanTest")
includeTestsMatching("*CustomSpanEventTest")
}
include("**/*ItemLevelSpanTest.*", "**/*CustomSpanEventTest.*")
jvmArgs("-Dotel.instrumentation.spring-batch.item.enabled=true")
}
}
}
}
}
}
tasks {
val testChunkRootSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*ChunkRootSpanTest")
}
include("**/*ChunkRootSpanTest.*")
jvmArgs("-Dotel.instrumentation.spring-batch.experimental.chunk.new-trace=true")
}
val testItemLevelSpan by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("*ItemLevelSpanTest")
includeTestsMatching("*CustomSpanEventTest")
}
include("**/*ItemLevelSpanTest.*", "**/*CustomSpanEventTest.*")
jvmArgs("-Dotel.instrumentation.spring-batch.item.enabled=true")
}
test {
filter {
excludeTestsMatching("*ChunkRootSpanTest")
@ -70,7 +58,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testChunkRootSpan, testItemLevelSpan)
}
withType<Test>().configureEach {

18
instrumentation/spring/spring-boot-autoconfigure/build.gradle.kts
View File

@ -174,16 +174,6 @@ testing {
}
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -230,7 +220,13 @@ tasks {
from(sourceSets["javaSpring3"].java)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

24
instrumentation/spring/spring-data/spring-data-1.8/javaagent/build.gradle.kts
View File

@ -45,21 +45,6 @@ dependencies {
latestDepTestLibrary("org.springframework:spring-test:5.+") // see spring-data-3.0:testing module
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
jvmArgs("--add-opens=java.base/java.lang.invoke=ALL-UNNAMED")
@ -70,7 +55,14 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

18
instrumentation/spring/spring-data/spring-data-3.0/testing/build.gradle.kts
View File

@ -36,16 +36,6 @@ testing {
implementation("com.h2database:h2:1.4.197")
}
}
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
@ -57,7 +47,13 @@ tasks {
jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true")
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testing.suites, testStableSemconv)
}
}

64
instrumentation/spring/spring-integration-4.1/javaagent/build.gradle.kts
View File

@ -40,44 +40,32 @@ dependencies {
latestDepTestLibrary("org.springframework.cloud:spring-cloud-stream-binder-rabbit:3.+") // documented limitation
}
testing {
suites {
val testWithRabbitInstrumentation by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SpringIntegrationAndRabbitTest")
}
include("**/SpringIntegrationAndRabbitTest.*")
jvmArgs("-Dotel.instrumentation.rabbitmq.enabled=true")
jvmArgs("-Dotel.instrumentation.spring-rabbit.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-rabbit.enabled=true")
}
}
}
}
val testWithProducerInstrumentation by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SpringCloudStreamProducerTest")
}
include("**/SpringCloudStreamProducerTest.*")
jvmArgs("-Dotel.instrumentation.rabbitmq.enabled=false")
jvmArgs("-Dotel.instrumentation.spring-rabbit.enabled=false")
jvmArgs("-Dotel.instrumentation.spring-integration.producer.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-integration.producer.enabled=true")
}
}
}
}
}
}
tasks {
val testWithRabbitInstrumentation by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SpringIntegrationAndRabbitTest")
}
include("**/SpringIntegrationAndRabbitTest.*")
jvmArgs("-Dotel.instrumentation.rabbitmq.enabled=true")
jvmArgs("-Dotel.instrumentation.spring-rabbit.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-rabbit.enabled=true")
}
val testWithProducerInstrumentation by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SpringCloudStreamProducerTest")
}
include("**/SpringCloudStreamProducerTest.*")
jvmArgs("-Dotel.instrumentation.rabbitmq.enabled=false")
jvmArgs("-Dotel.instrumentation.spring-rabbit.enabled=false")
jvmArgs("-Dotel.instrumentation.spring-integration.producer.enabled=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-integration.producer.enabled=true")
}
test {
filter {
excludeTestsMatching("SpringIntegrationAndRabbitTest")
@ -88,7 +76,7 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testWithRabbitInstrumentation, testWithProducerInstrumentation)
}
withType<Test>().configureEach {

28
instrumentation/spring/spring-jms/spring-jms-6.0/javaagent/build.gradle.kts
View File

@ -34,29 +34,21 @@ otelJava {
minJavaVersionSupported.set(JavaVersion.VERSION_17)
}
testing {
suites {
val testReceiveSpansDisabled by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
filter {
includeTestsMatching("SpringListenerSuppressReceiveSpansTest")
}
include("**/SpringListenerSuppressReceiveSpansTest.*")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testReceiveSpansDisabled by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
filter {
includeTestsMatching("SpringListenerSuppressReceiveSpansTest")
}
include("**/SpringListenerSuppressReceiveSpansTest.*")
}
test {
filter {
excludeTestsMatching("SpringListenerSuppressReceiveSpansTest")
@ -65,6 +57,6 @@ tasks {
}
check {
dependsOn(testing.suites)
dependsOn(testReceiveSpansDisabled)
}
}

26
instrumentation/spring/spring-scheduling-3.1/javaagent/build.gradle.kts
View File

@ -20,21 +20,6 @@ dependencies {
testLibrary("org.springframework:spring-context:3.2.3.RELEASE")
}
testing {
suites {
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.instrumentation.spring-scheduling.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-scheduling.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// required on jdk17
@ -43,6 +28,17 @@ tasks {
systemProperty("collectMetadata", findProperty("collectMetadata")?.toString() ?: "false")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.instrumentation.spring-scheduling.experimental-span-attributes=true")
systemProperty("metadataConfig", "otel.instrumentation.spring-scheduling.experimental-span-attributes=true")
}
check {
dependsOn(testExperimental)
}
}
val latestDepTest = findProperty("testLatestDeps") as Boolean

24
instrumentation/spring/spring-webmvc/spring-webmvc-3.1/javaagent/build.gradle.kts
View File

@ -43,21 +43,6 @@ dependencies {
latestDepTestLibrary("org.springframework.boot:spring-boot-starter-security:2.+") // see spring-webmvc-6.0 module
}
testing {
suites {
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
systemProperty("metadataConfig", "otel.instrumentation.spring-webmvc.experimental-span-attributes=true")
jvmArgs("-Dotel.instrumentation.spring-webmvc.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
@ -71,8 +56,15 @@ tasks {
jvmArgs("-Dotel.instrumentation.common.experimental.view-telemetry.enabled=true")
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
systemProperty("metadataConfig", "otel.instrumentation.spring-webmvc.experimental-span-attributes=true")
jvmArgs("-Dotel.instrumentation.spring-webmvc.experimental-span-attributes=true")
}
check {
dependsOn(testing.suites)
dependsOn(testExperimental)
}
}

24
instrumentation/spring/spring-webmvc/spring-webmvc-6.0/javaagent/build.gradle.kts
View File

@ -44,21 +44,6 @@ otelJava {
minJavaVersionSupported.set(JavaVersion.VERSION_17)
}
testing {
suites {
val testExperimental by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
systemProperty("metadataConfig", "otel.instrumentation.spring-webmvc.experimental-span-attributes=true")
jvmArgs("-Dotel.instrumentation.spring-webmvc.experimental-span-attributes=true")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// required on jdk17
@ -71,7 +56,14 @@ tasks {
systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
}
val testExperimental by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
systemProperty("metadataConfig", "otel.instrumentation.spring-webmvc.experimental-span-attributes=true")
jvmArgs("-Dotel.instrumentation.spring-webmvc.experimental-span-attributes=true")
}
check {
dependsOn(testing.suites)
dependsOn(testExperimental)
}
}

22
instrumentation/spymemcached-2.12/javaagent/build.gradle.kts
View File

@ -20,20 +20,6 @@ dependencies {
testImplementation("com.google.guava:guava")
}
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
// TODO run tests both with and without experimental span attributes
@ -41,7 +27,13 @@ tasks {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

26
instrumentation/tomcat/tomcat-jdbc/javaagent/build.gradle.kts
View File

@ -18,28 +18,20 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

26
instrumentation/vertx/vertx-redis-client-4.0/javaagent/build.gradle.kts
View File

@ -22,29 +22,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", collectMetadata)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

24
instrumentation/vertx/vertx-sql-client/vertx-sql-client-4.0/javaagent/build.gradle.kts
View File

@ -30,29 +30,21 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", collectMetadata)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

24
instrumentation/vertx/vertx-sql-client/vertx-sql-client-5.0/javaagent/build.gradle.kts
View File

@ -30,28 +30,20 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
withType<Test>().configureEach {
usesService(gradle.sharedServices.registrations["testcontainersBuildService"].service)
systemProperty("collectMetadata", collectMetadata)
}
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

26
instrumentation/vibur-dbcp-11.0/javaagent/build.gradle.kts
View File

@ -21,28 +21,20 @@ dependencies {
val collectMetadata = findProperty("collectMetadata")?.toString() ?: "false"
testing {
suites {
val testStableSemconv by registering(JvmTestSuite::class) {
targets {
all {
testTask.configure {
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
}
}
}
}
}
tasks {
val testStableSemconv by registering(Test::class) {
testClassesDirs = sourceSets.test.get().output.classesDirs
classpath = sourceSets.test.get().runtimeClasspath
jvmArgs("-Dotel.semconv-stability.opt-in=database")
systemProperty("collectMetadata", collectMetadata)
systemProperty("metadataConfig", "otel.semconv-stability.opt-in=database")
}
test {
systemProperty("collectMetadata", collectMetadata)
}
check {
dependsOn(testing.suites)
dependsOn(testStableSemconv)
}
}

Some files were not shown because too many files have changed in this diff Show More