build.gradle

buildscript {
    ext.javaLanguageVersion = JavaLanguageVersion.of(JavaVersion.current().isJava11Compatible() ? JavaVersion.current().getMajorVersion() : 17)
    ext.javaTargetVersion = JavaVersion.VERSION_1_8
    dependencyLocking {
        lockAllConfigurations()
    }

    repositories {
        mavenCentral()
        gradlePluginPortal()
    }

    dependencies {
        classpath 'gradle.plugin.com.hierynomus.gradle.plugins:license-gradle-plugin:0.16.1'
        classpath 'com.netflix.nebula:nebula-release-plugin:17.1.0'
        classpath 'com.netflix.nebula:nebula-publishing-plugin:20.1.0'
        classpath 'com.netflix.nebula:nebula-project-plugin:10.1.2'
        classpath 'io.spring.nohttp:nohttp-gradle:0.0.11'
        classpath 'io.github.gradle-nexus:publish-plugin:1.3.0'
        classpath 'me.champeau.gradle:japicmp-gradle-plugin:0.4.1'
        classpath 'de.undercouch:gradle-download-task:5.2.1'
        classpath 'io.spring.javaformat:spring-javaformat-gradle-plugin:0.0.38'
        classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.15.0'
        classpath 'biz.aQute.bnd:biz.aQute.bnd.gradle:6.4.0'

        constraints {
            classpath('org.ow2.asm:asm:7.3.1') {
                because 'Supports modern JDKs'
            }
        }
    }

    configurations.classpath.resolutionStrategy.cacheDynamicVersionsFor 0, 'minutes'
}

// TODO: remove this hack, see: https://github.com/nebula-plugins/nebula-release-plugin/issues/213
def releaseStage = findProperty('release.stage')
apply plugin: 'com.netflix.nebula.release'
release.defaultVersionStrategy = nebula.plugin.release.git.opinion.Strategies.SNAPSHOT

apply plugin: 'io.github.gradle-nexus.publish-plugin'
apply from: 'dependencies.gradle'

allprojects {
    group = 'io.micrometer'
    ext.'release.stage' = releaseStage ?: 'SNAPSHOT'

    afterEvaluate { project -> println "I'm configuring $project.name with version $project.version" }
}

subprojects {
    apply plugin: 'signing'
    apply plugin: 'io.spring.javaformat'
    apply plugin: 'com.diffplug.spotless'

    if (project.name != 'micrometer-bom') {
        if (project.name.contains('samples') || project.name.contains('benchmarks')) {
            apply plugin: 'java'
        } else {
            apply plugin: 'java-library'
        }
        apply plugin: 'com.github.hierynomus.license'
        apply plugin: 'checkstyle'
        apply plugin: 'io.spring.nohttp'

        java {
            // It is more idiomatic to define different features for different sets of optional
            // dependencies, e.g., 'dropwizard' and 'reactor'. If this library published Gradle
            // metadata, Gradle users would be able to use these feature names in their dependency
            // declarations instead of understanding the actual required optional dependencies.
            // But we don't publish Gradle metadata yet and this may be overkill so just have a
            // single feature for now to correspond to any optional dependency.
            registerFeature('optional') {
                usingSourceSet(sourceSets.main)
            }

            toolchain {
                languageVersion = javaLanguageVersion
            }
        }

        // All projects use optional annotations, but since we don't expose them downstream we would
        // have to add the dependency in every project, which is tedious so just do it here.
        dependencies {
            // JSR-305 only used for non-required meta-annotations
            optionalApi "com.google.code.findbugs:jsr305:latest.release"
            checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:latest.release")
        }

        tasks {
            compileJava {
                options.encoding = 'UTF-8'
                options.compilerArgs << '-Xlint:unchecked' << '-Xlint:deprecation'

                sourceCompatibility = javaTargetVersion
                targetCompatibility = javaTargetVersion

                // ensure Java 8 baseline is enforced for main source
                options.release = 8

                doLast {
                    task -> logger.info("Compiling with " + task.javaCompiler.get().executablePath)
                }
            }
            compileTestJava {
                options.encoding = 'UTF-8'
                options.compilerArgs << '-Xlint:unchecked' << '-Xlint:deprecation'
            }


            javadoc {
                if (project.name.contains('samples')) {
                    enabled = false
                } else {
                    configure(options) {
                        tags(
                                'apiNote:a:API Note:',
                                'implSpec:a:Implementation Requirements:',
                                'implNote:a:Implementation Note:'
                        )
                        options.addBooleanOption('Xdoclint:all,-missing', true)
                    }
                }
            }
        }

        normalization {
            runtimeClasspath {
                metaInf {
                    [
                            'Bnd-LastModified',
                            'Build-Date',
                            'Build-Date-UTC',
                            'Built-By',
                            'Built-OS',
                            'Build-Host',
                            'Build-Job',
                            'Build-Number',
                            'Build-Id',
                            'Change',
                            'Full-Change',
                            'Branch',
                            'Module-Origin',
                            'Created-By',
                            'Build-Java-Version'
                    ].each {
                        ignoreAttribute it
                        ignoreProperty it
                    }
                }
            }
        }

        //noinspection GroovyAssignabilityCheck
        test {
            // set heap size for the test JVM(s)
            maxHeapSize = "1500m"

            useJUnitPlatform {
                excludeTags 'docker'
            }

            retry {
                maxFailures = 5
                maxRetries = 3
            }
        }

        task dockerTest(type: Test) {
            // set heap size for the test JVM(s)
            maxHeapSize = "1500m"

            useJUnitPlatform {
                includeTags 'docker'
            }
        }

        project.tasks.withType(Test) { Test testTask ->
            testTask.testLogging.exceptionFormat = 'full'
        }

        license {
            header rootProject.file('gradle/licenseHeader.txt')
            strictCheck true
            mapping {
                java = 'SLASHSTAR_STYLE'
            }
            sourceSets = project.sourceSets

            ext.year = Calendar.getInstance().get(Calendar.YEAR)
            skipExistingHeaders = true
            exclude '**/*.json' // comments not supported
        }

        spotless {
            kotlin {
                ktlint().editorConfigOverride(['ktlint_standard_no-wildcard-imports': 'disabled'])
            }
        }

        // Publish resolved versions.
        plugins.withId('maven-publish') {
            publishing {
                publications {
                    nebula(MavenPublication) {
                        versionMapping {
                            allVariants {
                                fromResolutionResult()
                            }
                        }

                        // We publish resolved versions so don't need to publish our dependencyManagement
                        // too. This is different from many Maven projects, where published artifacts often
                        // don't include resolved versions and have a parent POM including dependencyManagement.
                        pom.withXml {
                            def dependencyManagement = asNode().get('dependencyManagement')
                            if (dependencyManagement != null) {
                                asNode().remove(dependencyManagement)
                            }
                        }
                    }
                }
            }
        }
    }

    plugins.withId('maven-publish') {
        publishing {
            publications {
                nebula(MavenPublication) {
                    // Nebula converts dynamic versions to static ones so it's ok.
                    suppressAllPomMetadataWarnings()
                }
            }
            repositories {
                maven {
                    name = 'Snapshot'
                    url = 'https://repo.spring.io/snapshot'
                    credentials {
                        username findProperty('SNAPSHOT_REPO_USER')
                        password findProperty('SNAPSHOT_REPO_PASSWORD')
                    }
                }
                maven {
                    name = 'Milestone'
                    url = 'https://repo.spring.io/milestone'
                    credentials {
                        username findProperty('MILESTONE_REPO_USER')
                        password findProperty('MILESTONE_REPO_PASSWORD')
                    }
                }
            }
        }

        signing {
            required = System.env.CIRCLE_STAGE == 'deploy'
            useInMemoryPgpKeys(findProperty('SIGNING_KEY'), findProperty('SIGNING_PASSWORD'))
            sign publishing.publications.nebula
        }

        // Nebula doesn't interface with Gradle's module format so just disable it for now.
        tasks.withType(GenerateModuleMetadata) {
            enabled = false
        }
    }

    dependencyLocking {
        lockAllConfigurations()
    }

    tasks.register('resolveAndLockAll') {
        description = 'Resolves dependencies of all configurations and writes them into the lock file.'
        outputs.upToDateWhen { false }
        doFirst {
            assert gradle.startParameter.writeDependencyLocks || gradle.startParameter.lockedDependenciesToUpdate: 'Execute resolveAndLockAll --write-locks or --update-locks <dependencies>'
        }
        doLast {
            project.configurations.findAll { it.canBeResolved }*.resolve()
        }
    }

    tasks.register('downloadDependencies') {
        outputs.upToDateWhen { false }
        doLast {
            project.configurations.findAll { it.canBeResolved }*.files
        }
    }

    if (!['samples', 'benchmarks'].find { project.name.contains(it) }) {
        apply plugin: 'com.netflix.nebula.maven-publish'
        apply plugin: 'com.netflix.nebula.maven-manifest'
        apply plugin: 'com.netflix.nebula.maven-developer'
        apply plugin: 'com.netflix.nebula.javadoc-jar'
        apply plugin: 'com.netflix.nebula.source-jar'
        apply plugin: 'com.netflix.nebula.maven-apache-license'
        apply plugin: 'com.netflix.nebula.publish-verification'
        apply plugin: 'com.netflix.nebula.contacts'
        apply plugin: 'com.netflix.nebula.info'
        apply plugin: 'com.netflix.nebula.project'

        if (project.name != 'micrometer-bom') {
            apply plugin: 'biz.aQute.bnd.builder'

            jar {
                manifest.attributes.put('Automatic-Module-Name', project.name.replace('-', '.'))
                metaInf {
                    from "$rootDir/LICENSE"
                    from "$rootDir/NOTICE"
                }

                bundle {
                    // workaround for multi-version JARs
                    //  see https://github.com/bndtools/bnd/issues/2227
                    bnd '''\
                        -fixupmessages: '^Classes found in the wrong directory: .*'
                        -exportcontents: io.micrometer.*
                        '''.stripIndent()
                }
            }

            task testModules(type: Exec) {
                dependsOn jar
                String executablePath = javaToolchains.launcherFor { languageVersion = javaLanguageVersion }.get().executablePath
                commandLine "$executablePath", '-p', "$jar.archivePath", '--list-modules'
                standardOutput = new ByteArrayOutputStream()
                ignoreExitValue = true

                doLast {
                    if (executionResult.get().getExitValue() != 0) {
                        throw new GradleException("Command finished with non-zero exit value ${executionResult.get().getExitValue()}:\n$standardOutput")
                    }
                }
            }

            check.dependsOn("testModules")

            if (!(project.name in ['micrometer-osgi-test'])) {
                apply plugin: 'me.champeau.gradle.japicmp'
                apply plugin: 'de.undercouch.download'

                task downloadBaseline(type: Download) {
                    onlyIf {
                        if (project.gradle.startParameter.isOffline()) {
                            println 'Offline: skipping downloading of baseline and JAPICMP'
                            return false
                        } else if (compatibleVersion == 'SKIP') {
                            println 'SKIP: Instructed to skip the baseline comparison'
                            return false
                        } else {
                            println "Will download and perform baseline comparison with ${compatibleVersion}"
                            return true
                        }
                    }

                    onlyIfNewer true
                    compress true
                    String rootUrl
                    if (compatibleVersion.contains('-M') || compatibleVersion.contains('-RC')) {
                        rootUrl = 'https://repo.spring.io/milestone/'
                    } else if (compatibleVersion.contains('-SNAPSHOT') ) {
                        rootUrl = 'https://repo.spring.io/snapshot/'
                    } else {
                        rootUrl = repositories.mavenCentral().url
                    }

                    src "${rootUrl}io/micrometer/${project.name}/${compatibleVersion}/${project.name}-${compatibleVersion}.jar"
                    dest "${buildDir}/baselineLibs/${project.name}-${compatibleVersion}.jar"
                }

                task japicmp(type: me.champeau.gradle.japicmp.JapicmpTask) {
                    oldClasspath.from(files("${buildDir}/baselineLibs/${project.name}-${compatibleVersion}.jar"))
                    newClasspath.from(files(jar.archiveFile, project(":${project.name}").jar))
                    onlyBinaryIncompatibleModified = true
                    failOnModification = true
                    failOnSourceIncompatibility = true
                    txtOutputFile = file("${project.buildDir}/reports/japi.txt")
                    ignoreMissingClasses = true
                    includeSynthetic = true

                    compatibilityChangeExcludes = [ "METHOD_NEW_DEFAULT" ]

                    packageExcludes = ['io.micrometer.shaded.*', 'io.micrometer.statsd.internal']

                    onlyIf { compatibleVersion != 'SKIP' }
                }

                tasks.japicmp.dependsOn(downloadBaseline)
                tasks.japicmp.dependsOn(jar)
                tasks.check.dependsOn(japicmp)
            }
        }

        contacts {
            'tludwig@vmware.com' {
                moniker 'Tommy Ludwig'
                github 'shakuzen'
            }
        }
    }

    description = 'Application monitoring instrumentation facade'

    repositories {
        mavenCentral()
    }

    def check = tasks.findByName('check')
    if (check) project.rootProject.tasks.releaseCheck.dependsOn check
}

nexusPublishing {
    repositories {
        mavenCentral {
            nexusUrl.set(uri('https://s01.oss.sonatype.org/service/local/'))
            snapshotRepositoryUrl.set(uri('https://repo.spring.io/snapshot/')) // not used but necessary for the plugin
            username = findProperty('MAVEN_CENTRAL_USER')
            password = findProperty('MAVEN_CENTRAL_PASSWORD')
        }
    }
}

task deleteLockFiles(type: Delete) {
    delete fileTree(dir: '.', include: '**/gradle.lockfile')
}

wrapper {
    gradleVersion = '8.0.2'
}

defaultTasks 'build'