build.gradle

/*
 * Copyright 2023 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import nebula.plugin.release.git.opinion.Strategies

import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

plugins {
	id "com.diffplug.spotless"
	id 'nebula.release'
}

// Required with spotless v6+
// See https://github.com/diffplug/spotless/issues/984 for details
spotless {
	predeclareDepsFromBuildscript()
}

// Need to predeclare every configuration used with spotless
spotlessPredeclare {
	java {
		googleJavaFormat("1.10.0")
	}
	groovyGradle {
		greclipse()
	}
}

// Format the root build too.
spotless {
	groovyGradle {
		target '*.gradle' // default target of groovyGradle
		greclipse()
		licenseHeaderFile rootProject.file('buildscripts/spotless.license.gradle'), '(import|pluginManagement)'
	}
	yaml {
		target "*.yaml"
		licenseHeaderFile rootProject.file('buildscripts/spotless.license.yaml'), '([a-zA-Z]*:)'
	}
	format 'dockerfile', {
		target '*Dockerfile'
		licenseHeaderFile rootProject.file('buildscripts/spotless.license.dockerfile'), '(\\s+|FROM)'
	}
}

// Configure release mechanism.
// Nebula plugin will not configure if .git doesn't exist, let's allow building on it by stubbing it
// out. This supports building from the zip archive downloaded from GitHub.
def releaseTask
if (file('.git').exists()) {
	release {
		defaultVersionStrategy = Strategies.getSNAPSHOT()
	}
	nebulaRelease {
		addReleaseBranchPattern(/v\d+\.\d+\.x/)
	}

	releaseTask = tasks.named("release")
	releaseTask.configure {
		mustRunAfter("snapshotSetup", "finalSetup")
	}
} else {
	releaseTask = tasks.register('release')
}

ext.isReleaseVersion = !version.toString().endsWith("-SNAPSHOT")

subprojects {
	apply plugin: 'jacoco'
	apply plugin: 'java-library'
	apply plugin: 'maven-publish'
	apply plugin: 'signing'
	apply plugin: 'com.diffplug.spotless'
	apply plugin: 'nebula.release'
	group = "com.google.cloud.opentelemetry"
	// Note: Version now comes from nebula plugin

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

	// Set up java codestyle checking and correction.
	plugins.withId("java") {
		plugins.apply('com.diffplug.spotless')

		// Configure our default module name for maven publishing
		archivesBaseName = "${project.name}"
	}

	// Support for some higher language versions can only be achieved using Toolchains.
	// Compatibility matrix at https://docs.gradle.org/current/userguide/compatibility.html#java
	// See https://docs.gradle.org/current/userguide/toolchains.html#toolchains
	java {
		toolchain {
			languageVersion = JavaLanguageVersion.of(11)
		}
	}

	// This ensures bytecode compatibility with Java 8 by ensuring that symbols not
	// available in Java 8 are not used in the source code.
	// This is equivalent of setting --release flag in Java compiler introduced in Java 9.
	// Note that the toolchain used is Java 11 - which means Java 11 is required
	// to build this project.
	compileJava {
		it.options.release = 8
	}

	// Include license check and auto-format support.
	spotless {
		java {
			googleJavaFormat("1.10.0")
			licenseHeaderFile rootProject.file('buildscripts/spotless.license.java'), '(package|import|class|// Includes work from:)'
			// ignore generated code for spotlessCheck & spotlessApply
			targetExclude '**/build/generated/**/*.*'
		}
		groovyGradle {
			target '*.gradle' // default target of groovyGradle
			greclipse()
			licenseHeaderFile rootProject.file('buildscripts/spotless.license.gradle'), '(import|plugins|description)'
		}
		yaml {
			target "*.yaml"
			licenseHeaderFile rootProject.file('buildscripts/spotless.license.yaml'), '([a-zA-Z]*:)'
		}
		format 'shell', {
			target '*.sh'
			licenseHeaderFile (rootProject.file('buildscripts/spotless.license.shell'), "([a-zA-Z])")
					.skipLinesMatching("#!.+?\$")
		}
	}

	// Make sure test failures include exception error messages for correction.
	test {
		testLogging {
			events "passed", "skipped", "failed", "standardOut", "standardError"
			exceptionFormat = 'full'
		}
	}

	ext {
		assertjVersion = '3.22.0'
		autoServiceVersion = '1.1.1'
		autoValueVersion = '1.11.0'
		slf4jVersion = '2.0.16'
		googleAuthVersion = '1.27.0'
		googleCloudVersion = '2.44.1'
		googleTraceVersion = '2.51.0'
		googleCloudBomVersion = '26.48.0'
		cloudMonitoringVersion = '3.52.0'
		openTelemetryBomVersion = '1.49.0'
		openTelemetryVersion = '1.49.0'
		openTelemetryInstrumentationBomVersion = '2.15.0'
		openTelemetryInstrumentationVersion = '2.15.0'
		openTelemetrySemconvVersion = '1.32.0'
		openTelemetryContribVersion = '1.46.0'
		junitVersion = '4.13'
		junit5Version = '5.10.0'
		mockitoVersion = '5.2.0'
		pubSubVersion = '1.133.0'
		testContainersVersion = '1.15.3'
		wiremockVersion = '2.35.0'
		springVersion = '2.7.18'
		springWebVersion = '2.4.5'
		springOpenFeignVersion = '3.0.0'
		springOtelVersion = '1.0.0-M8'
		cloudEventsCoreVersion = '2.5.0'
		cloudFunctionsFrameworkApiVersion = '1.1.0'

		agentLibraries = [
			agent: "io.opentelemetry.javaagent:opentelemetry-javaagent:${openTelemetryInstrumentationVersion}",
		]
		libraries = [
			auto_service_annotations         : "com.google.auto.service:auto-service-annotations:${autoServiceVersion}",
			auto_service                     : "com.google.auto.service:auto-service:${autoServiceVersion}",
			auto_value_annotations           : "com.google.auto.value:auto-value-annotations:${autoValueVersion}",
			auto_value                       : "com.google.auto.value:auto-value:${autoValueVersion}",
			cloudevents_core                 : "io.cloudevents:cloudevents-core:${cloudEventsCoreVersion}",
			google_auth                      : "com.google.auth:google-auth-library-oauth2-http:${googleAuthVersion}",
			google_cloud_core                : "com.google.cloud:google-cloud-core:${googleCloudVersion}",
			google_cloud_trace               : "com.google.cloud:google-cloud-trace:${googleTraceVersion}",
			google_cloud_trace_grpc          : "com.google.api.grpc:grpc-google-cloud-trace-v2:${googleTraceVersion}",
			google_cloud_monitoring          : "com.google.cloud:google-cloud-monitoring:${cloudMonitoringVersion}",
			google_cloud_monitoring_grpc     : "com.google.cloud:grpc-google-cloud-monitoring-v3:${cloudMonitoringVersion}",
			google_cloud_pubsub              : "com.google.cloud:google-cloud-pubsub:${pubSubVersion}",
			google_cloud_functions_framework : "com.google.cloud.functions:functions-framework-api:${cloudFunctionsFrameworkApiVersion}",
			google_cloud_bom                 : "com.google.cloud:libraries-bom:${googleCloudBomVersion}",
			slf4j                            : "org.slf4j:slf4j-api:${slf4jVersion}",
			opentelemetry_api                : "io.opentelemetry:opentelemetry-api:${openTelemetryVersion}",
			opentelemetry_bom                : "io.opentelemetry:opentelemetry-bom:${openTelemetryBomVersion}",
			opentelemetry_instrumetation_bom : "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:${openTelemetryInstrumentationBomVersion}",
			opentelemetry_context            : "io.opentelemetry:opentelemetry-context:${openTelemetryVersion}",
			opentelemetry_sdk                : "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}",
			opentelemetry_sdk_common         : "io.opentelemetry:opentelemetry-sdk-common:${openTelemetryVersion}",
			opentelemetry_semconv            : "io.opentelemetry.semconv:opentelemetry-semconv:${openTelemetrySemconvVersion}",
			opentelemetry_semconv_incubating : "io.opentelemetry.semconv:opentelemetry-semconv-incubating:${openTelemetrySemconvVersion}-alpha",
			opentelemetry_sdk_metrics        : "io.opentelemetry:opentelemetry-sdk-metrics:${openTelemetryVersion}",
			opentelemetry_sdk_autoconf       : "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:${openTelemetryVersion}",
			opentelemetry_autoconfigure_spi  : "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi:${openTelemetryVersion}",
			opentelemetry_agent_extension    : "io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api:${openTelemetryInstrumentationVersion}-alpha",
			opentelemetry_otlp_exporter      : "io.opentelemetry:opentelemetry-exporter-otlp:${openTelemetryVersion}",
			opentelemetry_logging_exporter   : "io.opentelemetry:opentelemetry-exporter-logging:${openTelemetryVersion}",
			opentelemetry_gcp_resources      : "io.opentelemetry.contrib:opentelemetry-gcp-resources:${openTelemetryContribVersion}-alpha",
			opentelemetry_gcp_auth_extension : "io.opentelemetry.contrib:opentelemetry-gcp-auth-extension:${openTelemetryContribVersion}-alpha",
			spring_boot_starter              : "org.springframework.boot:spring-boot-starter:${springVersion}",
			spring_boot_starter_web          : "org.springframework.boot:spring-boot-starter-web:${springWebVersion}",
			spring_boot_starter_actuator     : "org.springframework.boot:spring-boot-starter-actuator:${springVersion}",
			spring_cloud_starter_openfeign   : "org.springframework.cloud:spring-cloud-starter-openfeign:${springOpenFeignVersion}",
			spring_cloud_sleuth_otel_autoconf: "org.springframework.cloud:spring-cloud-sleuth-otel-autoconfigure:${springOtelVersion}",
		]
		testLibraries = [
			assertj : "org.assertj:assertj-core:${assertjVersion}",
			junit       : "junit:junit:${junitVersion}",
			junit5 : "org.junit.jupiter:junit-jupiter-api:${junit5Version}",
			junit5_runtime : "org.junit.jupiter:junit-jupiter-engine:${junit5Version}",
			junit5_params : "org.junit.jupiter:junit-jupiter-params:${junit5Version}",
			mockito     : "org.mockito:mockito-inline:${mockitoVersion}",
			slf4j_simple: "org.slf4j:slf4j-simple:${slf4jVersion}",
			opentelemetry_sdk_testing: "io.opentelemetry:opentelemetry-sdk-testing:${openTelemetryVersion}",
			test_containers: "org.testcontainers:testcontainers:${testContainersVersion}",
			wiremock    : "com.github.tomakehurst:wiremock-jre8:${wiremockVersion}",
		]
	}

	task javadocJar(type: Jar) {
		archiveClassifier.set('javadoc')
		from javadoc
	}

	task sourcesJar(type: Jar) {
		archiveClassifier.set('sources')
		from sourceSets.main.allSource
	}

	test {
		systemProperty 'mock.server.path', System.getProperty('mock.server.path')
		finalizedBy jacocoTestReport
	}

	jacocoTestReport {
		dependsOn test // tests are required to run before generating the report
	}

	artifacts {
		archives javadocJar, sourcesJar
	}

	java {
		withJavadocJar()
		withSourcesJar()
	}

	releaseTask.configure {
		finalizedBy(tasks.named('publish'))
	}

	if (findProperty("release.enabled") == "true") {
		publishing {
			publications {
				maven(MavenPublication) {
					if (findProperty("shadowed") != "true") {
						from components.java
					}
					groupId = 'com.google.cloud.opentelemetry'
					afterEvaluate {
						artifactId = archivesBaseName
						if (findProperty("release.qualifier") != null) {
							String[] versionParts = version.split('-')
							versionParts[0] = "${versionParts[0]}-${findProperty("release.qualifier")}"
							version = versionParts.join("-")
						}
					}
					pom {
						name = 'OpenTelemetry Operations Java'
						url = 'https://github.com/GoogleCloudPlatform/opentelemetry-operations-java'
						licenses {
							license {
								name = 'The Apache License, Version 2.0'
								url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
							}
						}
						developers {
							developer {
								id = 'com.google.cloud.opentelemetry'
								name = 'OpenTelemetry Operations Contributors'
								email = 'opentelemetry-team@google.com'
								organization = 'Google Inc'
								organizationUrl = 'https://cloud.google.com/products/operations'
							}
						}
						scm {
							connection = 'scm:git:https://github.com/GoogleCloudPlatform/opentelemetry-operations-java'
							developerConnection = 'scm:git:https://github.com/GoogleCloudPlatform/opentelemetry-operations-java'
							url = 'https://github.com/GoogleCloudPlatform/opentelemetry-operations-java'
						}
						afterEvaluate {
							// description is not available until evaluated.
							description = project.description
						}
					}
				}
			}
			repositories {
				maven {
					// Publish using Portal OSSRH Staging API.
					// For more information see https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#publishing-by-using-the-portal-ossrh-staging-api
					def ossrhRelease = "https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/"
					def ossrhSnapshot = "https://central.sonatype.com/repository/maven-snapshots/"
					url = isReleaseVersion ? ossrhRelease : ossrhSnapshot
					credentials {
						username = rootProject.hasProperty('centralPortalUsername') ? rootProject.centralPortalUsername : "Unknown user"
						password = rootProject.hasProperty('centralPortalPassword') ? rootProject.centralPortalPassword : "Unknown password"
					}
				}
			}
		}

		signing {
			required false
			// Allow using the GPG agent on linux instead of passwords in a .properties file.
			if (rootProject.hasProperty('signingUseGpgCmd')) {
				useGpgCmd()
			}
			sign publishing.publications.maven
		}
	}
}

tasks.register('sonatypeUploadDefaultRepository') {
	group = 'Deployment'
	description = 'Uploads the artifact repository published by the maven publish plugin to Central Portal so that it is visible in the UI.'

	if (!rootProject.hasProperty('centralPortalUsername') || !rootProject.hasProperty('centralPortalPassword')) {
		throw new GradleException("Unable to find the username and password. Please check ~/.gradle/gradle.properties file.")
	}

	// The logic is placed in a doLast block to ensure it runs during the execution phase.
	doLast {
		// Create authentication string to be used in the bearer token for the API.
		// See https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#manual-api-endpoints
		String authString = "${rootProject.centralPortalUsername}:${rootProject.centralPortalPassword}"

		// Encode the auth string and construct the bearer token to be passed in the auth header.
		String encodedAuthString = Base64.getEncoder().encodeToString(authString.getBytes('UTF-8'))

		String centralPortalUploadEndpoint = 'https://ossrh-staging-api.central.sonatype.com/manual/upload/defaultRepository/com.google.cloud.opentelemetry?publishing_type=user_managed'

		// Make a manual POST request to the Central Portal Endpoint
		def client = HttpClient.newHttpClient()
		def request = HttpRequest.newBuilder()
				.uri(URI.create(centralPortalUploadEndpoint))
				.header('Authorization', "Bearer ${encodedAuthString}")
				.header('accept', '*/*')
				.POST(HttpRequest.BodyPublishers.ofString(''))
				.build()

		println "Sending POST request to: ${centralPortalUploadEndpoint}"

		// The response body will be handled as a String.
		HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString())
		println "Response Status Code: ${response.statusCode()}"
		println "Response Body: ${response.body()}"

		// Optionally, fail the build if the request was not successful
		if (response.statusCode() >= 400) {
			throw new GradleException("Deployment failed! Received HTTP status ${response.statusCode()}")
		} else {
			println "Default repository uploaded successfully! Please visit https://central.sonatype.com/publishing to complete release process."
		}
	}
}