import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

import java.util.concurrent.atomic.AtomicBoolean

plugins {

id "com.github.johnrengelman.shadow"

}

description = 'dd-java-agent'

apply from: "$rootDir/gradle/java.gradle"

apply from: "$rootDir/gradle/publish.gradle"

configurations {

shadowInclude

sharedShadowInclude

}

/*

* 7 shadow jars are created

* - The main "dd-java-agent" jar that also has the bootstrap project

* - 5 jars based on projects (instrumentation, jmxfetch, profiling, appsec, iast)

* - 1 based on the shared dependencies

* This general config is shared by all of them

*/

ext.generalShadowJarConfig = {

mergeServiceFiles()

exclude '**/module-info.class'

// Prevents conflict with other SLF4J instances. Important for premain.

relocate 'org.slf4j', 'datadog.slf4j'

// rewrite dependencies calling Logger.getLogger

relocate 'java.util.logging.Logger', 'datadog.trace.bootstrap.PatchLogger'

if (!project.hasProperty("disableShadowRelocate") || !disableShadowRelocate) {

// shadow OT impl to prevent casts to implementation

relocate 'datadog.trace.common', 'datadog.trace.agent.common'

relocate 'datadog.trace.core', 'datadog.trace.agent.core'

relocate 'datadog.opentracing', 'datadog.trace.agent.ot'

// shadow things in internal API that has slf4j in the API and is accessed from core

relocate 'datadog.trace.relocate', 'datadog.trace.agent.relocate'

}

}

def includeShadowJar(TaskProvider<ShadowJar> shadowJarTask, String jarname) {

def opentracingFound = new AtomicBoolean()

project.processResources {

doFirst {

eachFile {

// We seem unlikely to use this name somewhere else.

if (it.path.contains("opentracing") && it.name.contains("Format\$Builtin")) {

opentracingFound.set(true)

}

}

}

doLast {

if (opentracingFound.get()) {

throw new GradleException("OpenTracing direct dependency found!")

}

}

from(zipTree(shadowJarTask.get().archiveFile)) {

into jarname

rename '(^.*)\\.class$', '$1.classdata'

// Rename LICENSE file since it clashes with license dir on non-case sensitive FSs (i.e. Mac)

rename '^LICENSE$', 'LICENSE.renamed'

}

}

project.tasks.named("processResources").configure {

dependsOn shadowJarTask

}

shadowJarTask.configure generalShadowJarConfig

}

def includeSubprojShadowJar(String projName, String jarname) {

evaluationDependsOn projName

def proj = project(projName)

includeShadowJar proj.tasks.named("shadowJar"), jarname

}

includeSubprojShadowJar ':dd-java-agent:instrumentation', 'inst'

includeSubprojShadowJar ':dd-java-agent:agent-jmxfetch', 'metrics'

includeSubprojShadowJar ':dd-java-agent:agent-profiling', 'profiling'

includeSubprojShadowJar ':dd-java-agent:appsec', 'appsec'

includeSubprojShadowJar ':dd-java-agent:iast', 'iast'

includeSubprojShadowJar ':dd-java-agent:agent-debugger', 'debugger'

def sharedShadowJar = tasks.register('sharedShadowJar', ShadowJar) {

configurations = [project.configurations.sharedShadowInclude]

// Put the jar in a different directory so we don't overwrite the normal shadow jar and

// break caching, and also to not interfere with CI scripts that copy everything in the

// libs directory

it.destinationDirectory.set(file("${project.buildDir}/shared-lib"))

// Add a classifier so we don't confuse the jar file with the normal shadow jar

archiveClassifier = 'shared'

it.dependencies {

exclude(project(':dd-java-agent:agent-bootstrap'))

exclude(project(':dd-java-agent:agent-logging'))

exclude(project(':dd-trace-api'))

exclude(project(':internal-api'))

exclude(project(':internal-api:internal-api-8'))

exclude(project(':utils:time-utils'))

exclude(dependency('org.slf4j::'))

}

}

includeShadowJar(sharedShadowJar, 'shared')

shadowJar generalShadowJarConfig >> {

configurations = [project.configurations.shadowInclude]

archiveClassifier = ''

manifest {

attributes(

"Main-Class": "datadog.trace.bootstrap.AgentBootstrap",

"Agent-Class": "datadog.trace.bootstrap.AgentBootstrap",

"Premain-Class": "datadog.trace.bootstrap.AgentBootstrap",

"Can-Redefine-Classes": true,

"Can-Retransform-Classes": true,

)

}

}

tasks.register('generateAgentJarIndex', JavaExec) {

def contentDir = "${sourceSets.main.output.resourcesDir}"

def indexFile = "${contentDir}/dd-java-agent.index"

it.group = 'Build'

it.description = "Generate dd-java-agent.index"

it.inputs.files(contentDir)

it.outputs.files(indexFile)

it.mainClass = 'datadog.trace.bootstrap.AgentJarIndex$IndexGenerator'

it.classpath = project.configurations.shadowInclude

it.args = [contentDir]

dependsOn 'processResources'

dependsOn 'writeVersionNumberFile'

}

compileJava.dependsOn 'generateAgentJarIndex'

subprojects { Project subProj ->

// Don't need javadoc task run for internal projects.

subProj.tasks.withType(Javadoc).configureEach { enabled = false }

}

// We don't want bundled dependencies to show up in the pom.

tasks.withType(GenerateMavenPom).configureEach { task ->

doFirst {

task.pom.withXml { XmlProvider provider ->

Node dependencies = provider.asNode().dependencies[0]

dependencies.children().clear()

}

}

}

dependencies {

testImplementation(project(':dd-java-agent:agent-bootstrap')) {

exclude group: 'com.datadoghq', module: 'agent-logging'

}

testImplementation project(':dd-trace-api')

testImplementation project(':dd-trace-core')

testImplementation project(':utils:test-utils')

testImplementation deps.testLogging

testImplementation deps.guava

testImplementation deps.okhttp

testImplementation group: 'io.opentracing', name: 'opentracing-util', version: '0.31.0'

// Includes for the top level shadow jar

shadowInclude project(path: ':dd-java-agent:agent-bootstrap')

shadowInclude project(path: ':dd-java-agent:agent-debugger:debugger-bootstrap')

// Includes for the shared internal shadow jar

sharedShadowInclude deps.shared

// force a controlled version of ASM that is used by Debugger while pulled transitively by jnr

sharedShadowInclude deps.asm

sharedShadowInclude deps.asmcommons

sharedShadowInclude project(':communication'), {

transitive = false

// do not bring along slf4j and dependent subprojects

// (which are loaded on the bootstrap cl)

}

sharedShadowInclude project(':telemetry'), {

transitive = false

// do not bring along slf4j and dependent subprojects

// (which are loaded on the bootstrap cl)

}

sharedShadowInclude project(':remote-config'), {

transitive = false

}

sharedShadowInclude project(':utils:container-utils'), {

transitive = false

}

sharedShadowInclude project(':utils:socket-utils'), {

transitive = false

}

sharedShadowInclude project(':utils:version-utils'), {

transitive = false

}

sharedShadowInclude project(':utils:process-utils'), {

transitive = false

}

}

tasks.withType(Test).configureEach {

jvmArgs "-Ddd.service.name=java-agent-tests"

jvmArgs "-Ddd.writer.type=LoggingWriter"

// Multi-threaded logging seems to be causing deadlocks with Gradle's log capture.

// jvmArgs "-Ddatadog.slf4j.simpleLogger.defaultLogLevel=debug"

// jvmArgs "-Dorg.slf4j.simpleLogger.defaultLogLevel=debug"

doFirst {

// Defining here to allow jacoco to be first on the command line.

jvmArgs "-javaagent:${shadowJar.archivePath}"

}

testLogging {

events "started"

}

if (project.hasProperty("disableShadowRelocate") && disableShadowRelocate) {

exclude 'datadog/trace/agent/integration/classloading/ShadowPackageRenamingTest.class'

}

dependsOn "shadowJar"

}

tasks.register('checkAgentJarSize').configure {

doLast {

// Arbitrary limit to prevent unintentional increases to the agent jar size

// Raise or lower as required

assert shadowJar.archiveFile.get().getAsFile().length() < 21 * 1024 * 1024

}

dependsOn "shadowJar"

}

tasks.named('check').configure {

dependsOn 'checkAgentJarSize'

}