build.gradle

plugins {
  id 'java'
  id 'maven-publish'
  id 'signing'
  id 'com.vanniktech.maven.publish' version '0.28.0'
}

version = rootProject.version
group = rootProject.group

java {
  toolchain {
    languageVersion = JavaLanguageVersion.of(17)
    vendor = JvmVendorSpec.ADOPTIUM
  }
}

tasks.withType(JavaCompile).configureEach {
  options.release = 17
}

repositories {
  mavenCentral()
}

// Shared config for all agent subprojects (bootstrap, internal)
subprojects {
  apply plugin: 'java'
  apply plugin: 'dev.braintrust.muzzle'

  java {
    toolchain {
      languageVersion = JavaLanguageVersion.of(17)
      vendor = JvmVendorSpec.ADOPTIUM
    }
  }

  tasks.withType(JavaCompile).configureEach {
    options.release = 17
  }

  repositories {
    mavenCentral()
  }
}

// Add muzzle generation task and muzzle check plugin to smoke-test test-instrumentation.
// (Instrumentation subprojects under :braintrust-sdk are configured in braintrust-sdk/build.gradle.)
subprojects { subproject ->
  subproject.afterEvaluate {
    if (subproject.path == ':braintrust-java-agent:smoke-test:test-instrumentation') {
      def instrumentationApi = project(':braintrust-java-agent:instrumenter')

      // Bootstrap classes (e.g. BraintrustBridge) are on the bootstrap classpath at runtime.
      // Make them available at compile time so instrumentation modules can reference them.
      dependencies.add('compileOnly', project(':braintrust-java-agent:bootstrap'))

      // --- $Muzzle side-class generation (compile-time) ---

      // Configuration for the muzzle generator classpath
      configurations.maybeCreate('muzzleGenerator')
      dependencies.add('muzzleGenerator', instrumentationApi)
      dependencies.add('muzzleGenerator', 'net.bytebuddy:byte-buddy:1.17.5')

      task generateMuzzle(type: JavaExec) {
        dependsOn compileJava, instrumentationApi.tasks.named('compileJava')
        description = 'Generates $Muzzle side-classes for InstrumentationModule subclasses'
        group = 'build'

        // Classpath: compiled instrumentation classes + instrumenter + bytebuddy + deps
        classpath = files(
          sourceSets.main.output.classesDirs,
          configurations.muzzleGenerator,
          configurations.compileClasspath
        )
        mainClass = 'dev.braintrust.instrumentation.muzzle.MuzzleGenerator'
        args = [sourceSets.main.java.classesDirectory.get().asFile.absolutePath]
      }

      // Run muzzle generation after compileJava, before jar
      tasks.named('classes').configure { dependsOn generateMuzzle }

      // Run muzzle checks as part of the check lifecycle
      tasks.named('check').configure { dependsOn 'muzzle' }
    }
  }
}

// No main source code — this project only assembles the agent JAR and runs tests.
sourceSets.main.java.srcDirs = []

configurations {
  // Bootstrap classes (BraintrustAgent, BraintrustClassLoader, BraintrustAutoConfigCustomizer)
  // — our code + META-INF/services, bundled as normal .class files
  bootstrap

  // Bootstrap libraries — unshaded, added to bootstrap classpath at runtime via
  // Instrumentation.appendToBootstrapClassLoaderSearch(). Includes:
  //   - OTel API (Tracer, Span, Context, etc.)
  //   - OTel SDK (SdkTracerProvider, SpanProcessor, etc.)
  //   - OTel SDK autoconfigure (AutoConfiguredOpenTelemetrySdk)
  //   - OTel SDK autoconfigure SPI (AutoConfigurationCustomizerProvider)
  bootstrapLibs

  // Agent internals (ByteBuddy, OTLP exporter, OkHttp, instrumentation code)
  // — hidden as .classdata under internal/, only loadable by BraintrustClassLoader
  internal
}

dependencies {
  bootstrap project(':braintrust-java-agent:bootstrap')

  // OTel API + SDK + autoconfigure on bootstrap classpath
  bootstrapLibs "io.opentelemetry:opentelemetry-api:${otelVersion}"

  internal project(path: ':braintrust-java-agent:internal', configuration: 'shadow')

  // Test dependencies
  testImplementation "org.junit.jupiter:junit-jupiter:${junitVersion}"
  testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
  testImplementation "io.opentelemetry:opentelemetry-api:${otelVersion}"
  testImplementation "org.slf4j:slf4j-simple:${slf4jVersion}"
  testCompileOnly project(':braintrust-java-agent:bootstrap')
}

/**
 * Configure the standard jar task to assemble the agent JAR with classloader isolation.
 */
jar {
  dependsOn configurations.bootstrap, configurations.bootstrapLibs, configurations.internal

  archiveBaseName.set('braintrust-java-agent')
  archiveClassifier.set('')

  manifest {
    attributes(
      'Premain-Class': 'dev.braintrust.system.AgentBootstrap',
      'Agent-Class': 'dev.braintrust.system.AgentBootstrap',
      'Can-Redefine-Classes': 'true',
      'Can-Retransform-Classes': 'true',
      'Implementation-Title': 'Braintrust Java Agent',
      'Implementation-Version': project.version,
      'Implementation-Vendor': 'Braintrust',
    )
  }

  // 1) Include bootstrap classes as normal .class files (our code + META-INF/services)
  from(provider { configurations.bootstrap.collect { zipTree(it) } }) {
    // Keep META-INF/services (needed for ServiceLoader) but exclude other META-INF
    exclude 'META-INF/MANIFEST.MF'
    exclude 'META-INF/maven/**'
  }

  // 2) Include bootstrap libraries as normal .class files (OTel API + SDK + autoconfigure)
  from(provider { configurations.bootstrapLibs.collect { zipTree(it) } }) {
    exclude 'META-INF/**'
  }

  // 3) Include internal classes as .classdata files under internal/
  from(provider { configurations.internal.collect { zipTree(it) } }) {
    into 'internal'
    rename '(.*)\\.class$', '$1.classdata'
    // Keep META-INF/services (needed by ServiceLoader in BraintrustClassLoader)
    // but exclude everything else in META-INF
    exclude 'META-INF/MANIFEST.MF'
    exclude 'META-INF/maven/**'
    exclude 'META-INF/*.SF'
    exclude 'META-INF/*.DSA'
    exclude 'META-INF/*.RSA'
    exclude 'META-INF/LICENSE*'
    exclude 'META-INF/NOTICE*'
    exclude 'META-INF/DEPENDENCIES'
    exclude 'META-INF/proguard/**'
    exclude 'META-INF/versions/**'
  }
}

test {
  useJUnitPlatform()

  // Launch JUnit with the Braintrust Java Agent attached
  jvmArgs "-javaagent:${jar.archiveFile.get().asFile.absolutePath}"
  // TODO: add config to turn off exporter so this isn't necessary
  environment 'BRAINTRUST_API_KEY', 'bogus'

  testLogging {
    events "passed", "skipped", "failed"
    showStandardStreams = true
    exceptionFormat "full"
  }
}

/**
 * Runs GlobalLoggerTest as a standalone main() with the agent attached.
 */
task testGlobalLogger(type: JavaExec) {
  dependsOn jar, testClasses

  mainClass = 'dev.braintrust.system.GlobalLoggerTest'
  classpath = sourceSets.test.runtimeClasspath
  // jvmArgs "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005"
  jvmArgs "-javaagent:${jar.archiveFile.get().asFile.absolutePath}"
  // TODO: add config to turn off exporter so this isn't necessary
  environment 'BRAINTRUST_API_KEY', 'bogus'

  inputs.files(jar)
  inputs.files(sourceSets.test.output)
  def markerFile = layout.buildDirectory.file('test-results/global-logger-test.passed')
  outputs.file(markerFile)

  doLast {
    markerFile.get().asFile.tap {
      parentFile.mkdirs()
      text = "passed at ${java.time.Instant.now()}"
    }
  }
}

test.dependsOn testGlobalLogger

import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.JavaLibrary
import com.vanniktech.maven.publish.SonatypeHost

def signingKey = System.getenv("GPG_SIGNING_KEY")
def signingKeyId = System.getenv("GPG_SIGNING_KEY_ID")
def signingPassword = System.getenv("GPG_SIGNING_PASSWORD")

if (signingKey != null && signingKeyId != null && signingPassword != null) {
  ext["signingInMemoryKey"] = signingKey
  ext["signingInMemoryKeyId"] = signingKeyId
  ext["signingInMemoryKeyPassword"] = signingPassword
}

mavenPublishing {
  if (signingKey != null && signingKeyId != null && signingPassword != null) {
    signAllPublications()
  }
  publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)

  coordinates(group.toString(), 'braintrust-java-agent', version.toString())
  configure(
    new JavaLibrary(
      new JavadocJar.Empty(),
      false // no sources jar — this is a fat agent jar
    )
  )

  pom {
    name = 'Braintrust Java Agent'
    description = 'Braintrust auto-instrumentation Java agent for OpenTelemetry-based tracing'
    url = 'https://github.com/braintrustdata/braintrust-sdk-java'

    licenses {
      license {
        name = 'MIT License'
        url = 'https://opensource.org/licenses/MIT'
      }
    }

    developers {
      developer {
        id = 'braintrust'
        name = 'Braintrust Team'
        email = 'sdk@braintrustdata.com'
      }
    }

    scm {
      connection = 'scm:git:git://github.com/braintrustdata/braintrust-sdk-java.git'
      developerConnection = 'scm:git:git://github.com/braintrustdata/braintrust-sdk-java.git'
      url = 'https://github.com/braintrustdata/braintrust-sdk-java'
    }
  }
}