build.gradle

plugins {
    id 'idea'
    id 'java'
    id 'maven-publish'
    id 'org.jetbrains.kotlin.jvm' version '2.0.0'
    id 'com.google.protobuf' version '0.9.4'   // Keep in sync with grpc
    id 'org.jmailen.kotlinter' version "4.3.0"
    id "com.github.ben-manes.versions" version '0.51.0'
    id 'com.github.johnrengelman.shadow' version '8.1.1'
    id 'com.github.gmazzo.buildconfig' version '5.3.5'
    id 'org.jetbrains.kotlinx.kover' version '0.8.1'
    id 'io.gitlab.arturbosch.detekt' version '1.23.6'
    // Turn these off until jacoco fixes their kotlin 1.5.0 SMAP issue
    // id 'jacoco'
    // id 'com.github.kt3k.coveralls' version '2.12.0'
}

group = 'io.prometheus'
version = '1.22.0'

//sourceCompatibility = JavaVersion.VERSION_17
//targetCompatibility = JavaVersion.VERSION_17

buildConfig {
    packageName("io.prometheus")

    buildConfigField('String', 'APP_NAME', "\"${project.name}\"")
    buildConfigField('String', 'APP_VERSION', "\"${project.version}\"")
    buildConfigField('String', 'APP_RELEASE_DATE', "\"06/11/2024\"")
}

repositories {
    google()
    mavenCentral()
    maven { url = 'https://jitpack.io' }
}

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"

    implementation "io.grpc:grpc-netty:$grpc_version"
    implementation "io.grpc:grpc-protobuf:$grpc_version"
    implementation "io.grpc:grpc-stub:$grpc_version"
    implementation "io.grpc:grpc-services:$grpc_version"

    implementation("com.google.protobuf:protobuf-java:$protobuf_version")
    implementation("com.google.protobuf:protobuf-java-util:$protobuf_version")

    implementation "io.grpc:grpc-kotlin-stub:$gengrpc_version"

    implementation "io.github.mscheong01:krotoDC-core:$krotodc_version"

    // Required
    implementation "io.netty:netty-tcnative-boringssl-static:$tcnative_version"

    implementation "com.github.pambrose.common-utils:core-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:corex-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:dropwizard-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:guava-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:grpc-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:jetty-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:ktor-client-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:prometheus-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:service-utils:$utils_version"
    implementation "com.github.pambrose.common-utils:zipkin-utils:$utils_version"

    implementation "org.eclipse.jetty:jetty-servlet:$jetty_version"

    implementation "javax.annotation:javax.annotation-api:$annotation_version"
    implementation "org.jcommander:jcommander:$jcommander_version"
    implementation "com.typesafe:config:$typesafe_version"

    implementation "io.prometheus:simpleclient:$prometheus_version"

    implementation "io.ktor:ktor-client-jvm:$ktor_version"
    implementation "io.ktor:ktor-client-cio-jvm:$ktor_version"
    implementation "io.ktor:ktor-client-auth-jvm:$ktor_version"
    implementation "io.ktor:ktor-network-jvm:$ktor_version"
    implementation "io.ktor:ktor-network-tls-jvm:$ktor_version"

    implementation "io.ktor:ktor-server-jvm:$ktor_version"
    implementation "io.ktor:ktor-server-cio-jvm:$ktor_version"
    implementation "io.ktor:ktor-server-call-logging:$ktor_version"
    implementation "io.ktor:ktor-server-compression:$ktor_version"

    implementation "io.dropwizard.metrics:metrics-healthchecks:$dropwizard_version"

    implementation "io.zipkin.brave:brave-instrumentation-grpc:$zipkin_version"

    implementation "io.github.oshai:kotlin-logging-jvm:$logging_version"
    implementation "ch.qos.logback:logback-classic:$logback_version"
    implementation "org.slf4j:jul-to-slf4j:$slf4j_version"

    testImplementation "org.amshove.kluent:kluent:$kluent_version"
    testImplementation "org.junit.jupiter:junit-jupiter-api:$junit_version"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit_version"
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }
        }
    }
}

compileKotlin.dependsOn ':generateProto'

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:$protoc_version"
    }
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:$grpc_version"
        }

        // Specify protoc to generate using our grpc kotlin plugin
        grpckt {
            artifact = "io.grpc:protoc-gen-grpc-kotlin:$gengrpc_version:jdk8@jar"
        }

        krotoDC {
            artifact = "io.github.mscheong01:protoc-gen-krotoDC:$krotodc_version:jdk8@jar"
        }
    }
    generateProtoTasks {
        all().each { task ->
            task.plugins {
                grpc {}     // Generate Java gRPC classes
                grpckt {}   // Generate Kotlin gRPC using the custom plugin from library
                krotoDC {}  // Generate Kotlin data classes
            }
//            task.builtins {
//                kotlin {}
//            }
        }
    }
}

configurations.all {
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

//startScripts.enabled = false

// This is to fix a bizarre gradle error related to duplicate Agent.toString() methods
project.getTasks().getByName("jar").setProperty("duplicatesStrategy", DuplicatesStrategy.INCLUDE);

tasks.register('sourcesJar', Jar) {
    dependsOn classes
    from sourceSets.main.allSource
    archiveClassifier = 'sources'
}

tasks.register('javadocJar', Jar) {
    dependsOn javadoc
    archiveClassifier = 'javadoc'
    from javadoc.destinationDir
}

artifacts {
    archives sourcesJar
    //archives javadocJar
}

java {
    withSourcesJar()
}

detekt {
    buildUponDefaultConfig = true // preconfigure defaults
    allRules = false // activate all available (even unstable) rules.
    config.setFrom("$projectDir/config/detekt/detekt.yml")
    // point to your custom config defining rules to run, overwriting default behavior
    baseline = file("$projectDir/config/detekt/baseline.xml") // a way of suppressing issues before introducing detekt
}


//tasks.withType(Detekt).configureEach {
//    jvmTarget = "1.8"
//}
//tasks.withType(DetektCreateBaselineTask).configureEach {
//    jvmTarget = "1.8"
//}


//jacocoTestReport {
//    reports {
//        xml.enabled true
//        html.enabled true
//    }
//
//    afterEvaluate {
//        getClassDirectories().setFrom(files(classDirectories.files.collect {
//            fileTree(dir: it,
//                    excludes: [
//                            '**/ConfigVals*',
//                            'io/prometheus/grpc/**'
//                    ])
//        }))
//    }
//}

//check.dependsOn jacocoTestReport

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}

// Required for multiple uberjar targets
shadowJar {
    mergeServiceFiles()
}

task agentJar(type: Jar, dependsOn: shadowJar) {
    archiveFileName = 'prometheus-agent.jar'
    manifest {
        attributes('Main-Class': 'io.prometheus.Agent')
    }
    from zipTree(shadowJar.archiveFile)
}

task proxyJar(type: Jar, dependsOn: shadowJar) {
    archiveFileName = 'prometheus-proxy.jar'
    manifest {
        attributes('Main-Class': 'io.prometheus.Proxy')
    }
    from zipTree(shadowJar.archiveFile)
}

compileKotlin.dependsOn ':generateProto'

kotlin {
    jvmToolchain(17)
}

compileKotlin {
    kotlinOptions.freeCompilerArgs += ['-Xbackend-threads=8',
                                       "-opt-in=kotlin.time.ExperimentalTime",
                                       "-opt-in=kotlin.contracts.ExperimentalContracts",
                                       "-opt-in=kotlin.ExperimentalUnsignedTypes",
                                       "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
                                       "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
                                       "-opt-in=kotlinx.coroutines.DelicateCoroutinesApi"]
}

compileTestKotlin {
    kotlinOptions.freeCompilerArgs += ['-Xbackend-threads=8',
                                       "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
                                       "-opt-in=kotlinx.coroutines.DelicateCoroutinesApi"]
}

test {
    useJUnitPlatform()

    // finalizedBy jacocoTestReport

    testLogging {
        events "passed", "skipped", "failed", "standardOut", "standardError"
        exceptionFormat "full"
        showStandardStreams = true
    }
}

// This will keep generated code out of the kotlinter checks
tasks.named("lintKotlinMain") {
    source = source - fileTree("$buildDir/generated")
}

kotlinter {
    ignoreFailures = false
    reporters = ['checkstyle', 'plain']
}

kover {
    reports {
//        enable()  // create Kover merged reports
//
//        filters { // common filters for all default Kover merged tasks
//            classes { // common class filter for all default Kover merged tasks
//                includes.add("io.prometheus.*") // class inclusion rules
//                //excludes.addAll("io.prometheus.subpackage.*") // class exclusion rules
//            }
//
//            projects { // common projects filter for all default Kover merged tasks
//                //excludes.addAll("project1", ":child:project") // Specifies the projects excluded in the merged tasks
//            }
//        }
//
//
//        xmlReport {
//            onCheck.set(true)
//            // true to run koverMergedXmlReport task during the execution of the check task (if it exists) of the current project
//            reportFile.set(layout.buildDirectory.file("my-merged-report/result.xml")) // change report file name
//            overrideClassFilter { // override common class filter
//                includes.add("io.prometheus.*") // override class inclusion rules
//                //excludes.addAll("io.prometheus.subpackage.*") // override class exclusion rules
//            }
//        }
//
//        htmlReport {
//            onCheck.set(true)
//            // true to run koverMergedHtmlReport task during the execution of the check task (if it exists) of the current project
//            reportDir.set(layout.buildDirectory.dir("my-merged-report/html-result")) // change report directory
//            overrideClassFilter { // override common class filter
//                includes.add("io.prometheus.*") // override class inclusion rules
//                //excludes.addAll("io.prometheus.subpackage.*") // override class exclusion rules
//            }
//        }

//        verify {
//            // onCheck.set(true)
//            // true to run koverMergedVerify task during the execution of the check task (if it exists) of the current project
//            rule { // add verification rule
//                //isEnabled = true // false to disable rule checking
//                name = null // custom name for the rule
//                target = 'ALL' // specify by which entity the code for separate coverage evaluation will be grouped
//
//                overrideClassFilter { // override common class filter
//                    includes.add("io.prometheus.verify.*") // override class inclusion rules
//                    // excludes.addAll("io.prometheus.verify.subpackage.*") // override class exclusion rules
//                }
//
//                bound { // add rule bound
//                    minValue = 10
//                    maxValue = 20
//                    counter = 'LINE' // change coverage metric to evaluate (LINE, INSTRUCTION, BRANCH)
//                    valueType = 'COVERED_PERCENTAGE'
//                    // change counter value (COVERED_COUNT, MISSED_COUNT, COVERED_PERCENTAGE, MISSED_PERCENTAGE)
//                }
//            }
//        }
    }
}