build.gradle

import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask

plugins {
    id "org.springframework.boot" version "${springBootVersion}"
    id "com.palantir.docker" version "${palantirDockerVersion}"
    id "org.cyclonedx.bom" version "${cyclonedxBomVersion}"
    id "io.spring.dependency-management" version "${springDependencyManangementVersion}"
    id "org.owasp.dependencycheck" version "${owaspDependencyCheckVersion}"
    id "com.github.ben-manes.versions" version "${versionsPlugin}"
}

repositories {
    mavenCentral()
}

apply plugin: "java"
apply plugin: "jacoco"

group = "rocks.inspectit.ocelot"

java {
    sourceCompatibility = "17"
    targetCompatibility = "17"
}

if (!project.hasProperty("buildVersion") || project.getProperty("buildVersion").empty) {
    ext.buildVersion = "SNAPSHOT"
}

version = "$buildVersion"

tasks.register('downloadBoomerangjs') {
    logger.info("Downloading Boomerangjs version {}.", boomerangVersion)
    ext.dest = new File(buildDir, "boomerang-source-${boomerangVersion}.tgz")
    outputs.files(ext.dest)
    doLast {
        def f = ext.dest
        new URL("https://registry.npmjs.org/boomerangjs/-/boomerangjs-${boomerangVersion}.tgz")
                .withInputStream { i -> f.withOutputStream { it << i } }
    }
}

tasks.register('deleteBoomerangjs', Delete) {
    delete new File(project.buildDir, "boomerangjs-${boomerangVersion}")
}

tasks.register ('downloadAndExtractBoomerang', Copy) {
    dependsOn deleteBoomerangjs, downloadBoomerangjs
    from tarTree(downloadBoomerangjs.dest)
    into new File(project.buildDir, "boomerangjs-${boomerangVersion}")
    filter { line -> line.replaceAll("%boomerang_version%", "${boomerangVersion}") }
}

tasks.register('generateVersionFile') {
    ext.versionFile = new File(project.buildDir, "eum-version.info")
    doLast {
        def currentDate = new Date().toString()
        ext.versionFile.withWriter("UTF-8") { writer ->
            writer << "$version\n$currentDate\n$boomerangVersion"
        }
    }
}

tasks.register('downloadOpenTelemetryPlugin') {
    ext.dest = new File(buildDir, "boomerangjs-${boomerangVersion}/package/plugins/boomerang-opentelemetry.js")
    outputs.files(ext.dest)
    doLast {
        def f = ext.dest
        new URL("https://github.com/NovatecConsulting/boomerang-opentelemetry-plugin/releases/download/$boomerangOpenTelemetryPluginVersion/boomerang-opentelemetry.js")
                .withInputStream { i -> f.withOutputStream { it << i } }
    }

}

bootJar {
    dependsOn generateVersionFile
    dependsOn downloadAndExtractBoomerang
    dependsOn downloadOpenTelemetryPlugin

    archiveVersion = "${buildVersion}"

    base {
        archivesName = "inspectit-ocelot-eum-server"
    }

    manifest {
        attributes "Start-Class": "rocks.inspectit.oce.eum.server.EUMServerApplication"
    }

    // include version file
    from generateVersionFile.versionFile

    // include boomerang
    from(layout.buildDirectory.dir("boomerangjs-${boomerangVersion}/package")) {
        include "plugins/*.js"
        include "boomerang.js"
        into "static/boomerang"
    }

    //include boomerang opentelemetry
    from(layout.buildDirectory) {
        include "boomerang-opentelemetry.js"
        into "static/boomerang"
    }
}

cyclonedxBom {
    includeConfigs = ["runtimeClasspath"]
    schemaVersion = "1.4"
    projectType = "application"
    outputName = "bom"
    outputFormat = "all"
}

test {
    useJUnitPlatform()

    testLogging {
        exceptionFormat = "full"
    }
}

dependencies {
    implementation(
            "org.springframework.boot:spring-boot-starter-web",
            "org.springframework.boot:spring-boot-starter-actuator",
            "org.springframework.boot:spring-boot-starter-validation",
            "org.springframework.boot:spring-boot-starter-security",

            "org.yaml:snakeyaml:${snakeYamlVersion}",
            // Has to be included, but is transitive to spring
            "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml",

            // pin Prometheus client to 0.6.0 to prevent auto prefixing counter metrics with "_total"
            // see: https://github.com/prometheus/client_java/issues/640, https://github.com/prometheus/client_java/pull/653
            "io.prometheus:simpleclient:${prometheusClientVersion}",
            "io.prometheus:simpleclient_common:${prometheusClientVersion}",
            "io.prometheus:simpleclient_httpserver:${prometheusClientVersion}",

            "io.opencensus:opencensus-api:${openCensusVersion}",
            "io.opencensus:opencensus-impl:${openCensusVersion}",
            "io.opencensus:opencensus-exporter-stats-prometheus:${openCensusVersion}",
            "rocks.inspectit:opencensus-influxdb-exporter:${openCensusInfluxdbExporterVersion}",

            "io.grpc:grpc-context:${grpcVersion}",

            platform("io.opentelemetry:opentelemetry-bom-alpha:${openTelemetryAlphaVersion}"),
            platform("io.opentelemetry:opentelemetry-bom:${openTelemetryVersion}"),
            "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}",
            "io.opentelemetry:opentelemetry-exporter-otlp:${openTelemetryVersion}",
            "io.opentelemetry:opentelemetry-semconv:${openTelemetrySemConvVersion}",
            "io.opentelemetry.proto:opentelemetry-proto:${openTelemetryProtoVersion}",

            "com.google.protobuf:protobuf-java:${protobufVersion}",
            "com.google.protobuf:protobuf-java-util:${protobufVersion}",

            "com.google.guava:guava:${guavaVersion}",
            "com.maxmind.geoip2:geoip2:${geoip2Version}",

            "commons-net:commons-net:${commonsNetVersion}",
            "org.apache.commons:commons-lang3:${commonsLang3Version}",
            "org.apache.commons:commons-math3:${commonsMath3Version}",
            "commons-io:commons-io:${commonsIoVersion}",

            "org.influxdb:influxdb-java:${influxdbJavaVersion}",
    )

    compileOnly "org.projectlombok:lombok:${lombokVersion}"
    annotationProcessor "org.projectlombok:lombok:${lombokVersion}"

    testImplementation(
            "org.springframework.boot:spring-boot-starter-test",
            "io.opencensus:opencensus-impl:${openCensusVersion}",
            "org.apache.httpcomponents:httpclient:${httpClientVersion}",

            // ServerExtension
            "com.linecorp.armeria:armeria-junit5:${armeriaVersion}",
            "com.linecorp.armeria:armeria-grpc-protocol:${armeriaVersion}",

            // for docker test containers
            "org.testcontainers:testcontainers:${testContainersVersion}",
            "org.testcontainers:junit-jupiter:${testContainersVersion}"
    )

    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
}

tasks.register('copyServerJar', Copy) {
    dependsOn bootJar
    from(layout.buildDirectory.file("libs/inspectit-ocelot-eum-server-${version}.jar"))
    into(layout.buildDirectory.dir("docker-jar"))
    rename("inspectit-ocelot-eum-server-${version}\\.jar",
            "inspectit-ocelot-eum-server.jar")
}

docker {
    dependsOn copyServerJar
    name "inspectit/inspectit-ocelot-eum-server"
    tags "${version}"
    dockerfile file("docker/Dockerfile")
    files "docker/entrypoint.sh", copyServerJar.outputs
}

dependencyCheck {
    failBuildOnCVSS = 6
    suppressionFile = "dependencyCheckSuppression.xml"
    analyzers {
        assemblyEnabled = false
        ossIndex {
            enabled = true
        }
    }
    nvd {
        apiKey = System.getenv("NVD_API_TOKEN")
        delay = 10000
    }
}

def isNonStable = { String candidate ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA', 'JRE'].any { it -> candidate.toUpperCase().contains(it) }
    def versionRegex = /^[0-9,.v-]+(-r)?$/
    return !stableKeyword && !(candidate ==~ versionRegex)
}

def isNotSameMajorMinor = { String current, String candidate, boolean matchMinor ->
    if(current.equals(candidate)) return false

    def firstDot = current.indexOf('.')
    def secondDot = current.indexOf('.', firstDot + 1)
    def major = current.substring(0, firstDot)
    def minor = current.substring(firstDot + 1, secondDot)
    def majorRegex = /^$major\..*/
    def minorRegex = /^$major\.${minor}\..*/
    return !((candidate ==~ majorRegex) && (!matchMinor || (candidate ==~ minorRegex)))
}

tasks.named("dependencyUpdates").configure {
    rejectVersionIf {
        // only patch updates
        isNonStable(it.candidate.version) || isNotSameMajorMinor(it.currentVersion, it.candidate.version, true)
    }
}

tasks.register('dependencyUpdatesMinor', DependencyUpdatesTask) {
    rejectVersionIf {
        // only minor updates
        isNonStable(it.candidate.version) || isNotSameMajorMinor(it.currentVersion, it.candidate.version, false)
    }
}

tasks.register('dependencyUpdatesMajor', DependencyUpdatesTask) {
    rejectVersionIf {
        // all updates including major updates
        isNonStable(it.candidate.version)
    }
}

tasks.withType(DependencyUpdatesTask).configureEach {
    // default settings
    revision = 'milestone'
    gradleReleaseChannel = "current"
    checkConstraints = true
    checkBuildEnvironmentConstraints = true
    outputFormatter = 'json,plain'
    outputDir = 'build/reports'
    reportfileName = 'dependencyUpdates'
}