build.gradle

buildscript {
	ext.javaLanguageVersion = JavaLanguageVersion.of(JavaVersion.current().isJava11Compatible() ? JavaVersion.current().getMajorVersion() : 17)
	ext.javaTargetVersion = JavaVersion.VERSION_17
	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:16.0.0'
		classpath 'com.netflix.nebula:nebula-publishing-plugin:18.4.0'
		classpath 'com.netflix.nebula:nebula-project-plugin:9.4.0'
		classpath 'io.spring.nohttp:nohttp-gradle:0.0.10'
		classpath 'org.gradle:test-retry-gradle-plugin:1.4.1'
		classpath 'io.github.gradle-nexus:publish-plugin:1.1.0'
		classpath 'me.champeau.gradle:japicmp-gradle-plugin:0.4.0'
		classpath 'de.undercouch:gradle-download-task:5.0.2'
		classpath 'io.spring.javaformat:spring-javaformat-gradle-plugin:0.0.34'

		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: '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'

	if (project.name != 'micrometer-observation-spring-boot-dependencies') {
		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'
		apply plugin: 'org.gradle.test-retry'

		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

				options.release = Integer.valueOf(javaTargetVersion.toString())

				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 {
					[
							'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
		}

		// 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: 'nebula.maven-publish'
		apply plugin: 'nebula.maven-manifest'
		apply plugin: 'nebula.maven-developer'
		apply plugin: 'nebula.javadoc-jar'
		apply plugin: 'nebula.source-jar'
		apply plugin: 'nebula.maven-apache-license'
		apply plugin: 'nebula.publish-verification'
		apply plugin: 'nebula.contacts'
		apply plugin: 'nebula.info'
		apply plugin: 'nebula.project'

		if (project.name != 'micrometer-observation-spring-boot-dependencies') {
			jar {
				manifest.attributes.put('Automatic-Module-Name', project.name.replace('-', '.'))
				metaInf {
					from "$rootDir/LICENSE"
					from "$rootDir/NOTICE"
				}
			}

			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")
			
		}

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

	description = 'Micrometer Observation Spring Boot Autoconfiurations'

	repositories {
		mavenCentral()
		maven {
			url 'https://repo.spring.io/milestone/'
		}
		maven {
			url 'https://repo.spring.io/snapshot/'
		}
	}

	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: '**/*.lockfile')
}

wrapper {
	gradleVersion = '7.5.1'
}

defaultTasks 'build'