build.gradle

buildscript {
  dependencies {
    classpath "pl.allegro.tech.build:axion-release-plugin:1.14.4"
  }

  configurations.all {
    resolutionStrategy.dependencySubstitution {
      substitute module("com.jcraft:jsch") using module("com.github.mwiede:jsch:0.2.17") because "jcraft is unmaintained"
      substitute module("com.jcraft:jsch.agentproxy") using module("com.github.mwiede:jsch:0.2.17") because "jcraft is unmaintained"
      substitute module("com.jcraft:jzlib") using module("com.github.mwiede:jsch:0.2.17") because "jcraft is unmaintained"
    }
  }
}

plugins {
  id "com.diffplug.spotless" version "6.13.0"
  id 'com.github.spotbugs' version '5.0.14'
  id "de.thetaphi.forbiddenapis" version "3.5.1"

  id 'pl.allegro.tech.build.axion-release' version '1.14.4'
  id 'io.github.gradle-nexus.publish-plugin' version '1.3.0'

  id "com.github.johnrengelman.shadow" version "7.1.2" apply false
  id "me.champeau.jmh" version "0.7.0" apply false
  id 'org.gradle.playframework' version '0.13' apply false
  id 'info.solidsoft.pitest' version '1.9.11'  apply false
}

description = 'dd-trace-java'

def isCI = System.getenv("CI") != null

apply from: "$rootDir/gradle/scm.gradle"
spotless {
  // only resolve the spotless dependencies once in the build
  predeclareDeps()
}
spotlessPredeclare {
  // these need to align with the types and versions in gradle/spotless.gradle
  java {
    // This is the last Google Java Format version that supports Java 8
    googleJavaFormat('1.7')
  }
  groovyGradle {
    greclipse()
  }
  groovy {
    greclipse()
  }
  kotlinGradle {
    ktlint('0.41.0')
  }
  kotlin {
    ktlint('0.41.0')
  }
  scala {
    scalafmt('2.7.5')
  }
}
apply from: "$rootDir/gradle/spotless.gradle"

def compileTask = tasks.register("compile")

allprojects {
  group = 'com.datadoghq'
  version = scmVersion.version

  if (isCI) {
    buildDir = "$rootDir/workspace/${projectDir.path.replace(rootDir.path, '')}/build/"
  }

  apply from: "$rootDir/gradle/dependencies.gradle"
  apply from: "$rootDir/gradle/util.gradle"

  compileTask.configure {
    dependsOn tasks.withType(AbstractCompile)
  }
}

repositories {
  mavenLocal()
  mavenCentral()
  gradlePluginPortal()
}

tasks.register("latestDepTest")

nexusPublishing {
  repositories {
    def forceLocal = project.hasProperty('forceLocal') && forceLocal
    if (forceLocal && !isCI) {
      local {
        // For testing use with https://hub.docker.com/r/sonatype/nexus
        // docker run --rm -d -p 8081:8081 --name nexus sonatype/nexus:oss
        // ./gradlew publishToLocal
        // Doesn't work for testing releases though... (due to staging)
        nexusUrl = uri("http://localhost:8081/nexus/content/repositories/releases/")
        snapshotRepositoryUrl = uri("http://localhost:8081/nexus/content/repositories/snapshots/")
        username = "admin"
        password = "admin123"
        allowInsecureProtocol = true
      }
    } else {
      sonatype {
        username = System.getenv("SONATYPE_USERNAME")
        password = System.getenv("SONATYPE_PASSWORD")
      }
    }
  }
}

wrapper {
  distributionType = Wrapper.DistributionType.ALL
}

tasks.register('writeMuzzleTasksToFile') {
  doLast {
    def muzzleFile = file("${buildDir}/muzzleTasks")
    assert muzzleFile.parentFile.mkdirs() || muzzleFile.parentFile.directory

    muzzleFile.text = subprojects.findAll { subproject -> subproject.plugins.hasPlugin('muzzle') }
    .collect { it.path + ":muzzle" }
    .join('\n')
  }
}

def writeMainVersionFileTask = tasks.register('writeMainVersionFile') {
  def versionFile = file("${rootProject.buildDir}/main.version")
  inputs.property "version", scmVersion.version
  outputs.file versionFile

  doFirst {
    assert versionFile.parentFile.mkdirs() || versionFile.parentFile.directory
    versionFile.text = "${inputs.properties.version}"
  }
}

allprojects {
  tasks.withType(JavaForkOptions).configureEach {
    maxHeapSize = System.properties["datadog.forkedMaxHeapSize"]
    minHeapSize = System.properties["datadog.forkedMinHeapSize"]
    jvmArgs "-XX:ErrorFile=/tmp/hs_err_pid%p.log"
    jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
    jvmArgs "-XX:HeapDumpPath=/tmp"
  }

  tasks.withType(PublishToMavenLocal).configureEach {
    it.finalizedBy(writeMainVersionFileTask)
  }
}

allprojects { project ->
  project.ext {
    activePartition = true
  }
  final boolean shouldUseTaskPartitions = project.rootProject.hasProperty("taskPartitionCount") && project.rootProject.hasProperty("taskPartition")
  if (shouldUseTaskPartitions) {
    final int taskPartitionCount = project.rootProject.property("taskPartitionCount") as int
    final int taskPartition = project.rootProject.property("taskPartition") as int
    final currentTaskPartition = Math.abs(project.path.hashCode() % taskPartitionCount)
    project.setProperty("activePartition", currentTaskPartition == taskPartition)
  }
}


def testAggregate(String baseTaskName, includePrefixes, excludePrefixes) {
  def createRootTask = { rootTaskName, subProjTaskName ->
    tasks.register(rootTaskName) { aggTest ->
      subprojects { subproject ->
        if (subproject.property("activePartition") && includePrefixes.any { subproject.path.startsWith(it) } && !excludePrefixes.any { subproject.path.startsWith(it) }) {
          def testTask = subproject.tasks.findByName(subProjTaskName)
          if (testTask != null) {
            aggTest.dependsOn(testTask)
          }
        }
      }
    }
  }

  createRootTask "${baseTaskName}Test", 'allTests'
  createRootTask "${baseTaskName}LatestDepTest", 'allLatestDepTests'
  createRootTask "${baseTaskName}Check", 'check'
}

// To lock dependency versions, run `./gradlew resolveAndLockAll --write-locks`
tasks.register('resolveAndLockAll') {
  notCompatibleWithConfigurationCache("Filters configurations at execution time")
  doFirst {
    assert gradle.startParameter.writeDependencyLocks
  }
  doLast {
    allprojects { project ->
      project.configurations.findAll {
        it.canBeResolved && !it.name.startsWith('incrementalScalaAnalysis')
      }.each { it.resolve() }
    }
  }
}

allprojects { project ->
  project.dependencyLocking {
    lockAllConfigurations()
    //lockmode set to LENIENT because there are resolution
    //errors in the build with an apiguardian dependency.
    //See: https://docs.gradle.org/current/userguide/dependency_locking.html for more info
    lockMode = LockMode.LENIENT

  }
}

testAggregate("smoke", [":dd-smoke-tests"], [])
testAggregate("instrumentation", [":dd-java-agent:instrumentation"], [])
testAggregate("profiling", [":dd-java-agent:agent-profiling"], [])
testAggregate("debugger", [":dd-java-agent:agent-debugger"], [])
testAggregate("base", [":"], [
  ":dd-java-agent:instrumentation",
  ":dd-smoke-tests",
  ":dd-java-agent:agent-profiling",
  ":dd-java-agent:agent-debugger"
])