We Saved 50% on CI Build Time Using Bazel 7.0 and Gradle 8.10 for Monorepo Builds

// build.gradle.kts for our user-service subproject, Gradle 8.10
// Enables configuration cache, remote build cache, and incremental compilation
plugins {
    id(\"org.springframework.boot\") version \"3.2.0\"
    id(\"io.spring.dependency-management\") version \"1.1.4\"
    kotlin(\"jvm\") version \"1.9.20\"
    kotlin(\"plugin.spring\") version \"1.9.20\"
}

group = \"com.example.monorepo\"
version = \"1.0.0-SNAPSHOT\"

// Enable Gradle 8.10 configuration cache (stable as of 8.10)
configurationCache {
    enabled = true
    // Fail build if configuration cache can't be reused
    failOnCacheError = true
}

// Enable remote build cache backed by Bazel 7.0's HTTP cache
buildCache {
    remote(HttpBuildCache::class.java) {
        url = uri(\"https://bazel-cache.example.com/gradle\")
        // Authenticate with service account for cache write access
        credentials {
            username = providers.environmentVariable(\"BAZEL_CACHE_USER\").getOrElse(\"anonymous\")
            password = providers.environmentVariable(\"BAZEL_CACHE_TOKEN\").getOrNull()
        }
        // Only push to cache on main branch builds
        push = providers.environmentVariable(\"GITHUB_REF\").map { it == \"refs/heads/main\" }.getOrElse(false)
        // Cache timeout: 7 days for compiled classes, 1 day for test results
        timeout = Duration.ofMinutes(5)
    }
    local {
        // Disable local cache to force remote cache usage (we have fast network)
        enabled = false
    }
}

repositories {
    mavenCentral()
    // Fallback to internal Nexus for proprietary dependencies
    maven {
        url = uri(\"https://nexus.example.com/repository/maven-public\")
        credentials {
            username = providers.environmentVariable(\"NEXUS_USER\").getOrElse(\"ci-user\")
            password = providers.environmentVariable(\"NEXUS_PASS\").getOrNull()
        }
        // Handle 404s gracefully for missing dependencies
        authentication {
            create<BasicAuthentication>(\"basic\")
        }
    }
}

dependencies {
    implementation(\"org.springframework.boot:spring-boot-starter-web\")
    implementation(\"com.fasterxml.jackson.module:jackson-module-kotlin:2.16.0\")
    implementation(\"org.jetbrains.kotlin:kotlin-reflect\")
    testImplementation(\"org.springframework.boot:spring-boot-starter-test\")
    testImplementation(\"org.junit.jupiter:junit-jupiter-api:5.10.1\")
    testRuntimeOnly(\"org.junit.jupiter:junit-jupiter-engine:5.10.1\")
}

tasks.withType<Test> {
    useJUnitPlatform()
    // Enable Gradle 8.10's parallel test execution
    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
    // Retry flaky tests once before failing
    retry {
        maxRetries = 1
        maxFailures = 5
        // Only retry integration tests, not unit tests
        filter {
            includeTestsMatching(\"com.example.monorepo.user.integration.*\")
        }
    }
    // Generate test reports even on failure
    reports {
        junitXml.required.set(true)
        html.required.set(true)
    }
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions {
        jvmTarget = \"17\"
        // Enable incremental Kotlin compilation (new in Gradle 8.10)
        incremental = true
        // Report compiler warnings as errors in CI
        allWarningsAsErrors = providers.environmentVariable(\"CI\").isPresent
    }
}

// Custom task to validate Bazel compatibility
tasks.register(\"validateBazelCompatibility\") {
    doLast {
        val bazelVersion = providers.exec {
            commandLine(\"bazel\", \"--version\")
        }.standardOutput.asText.getOrElse(\"unknown\").trim()
        if (!bazelVersion.startsWith(\"bazel 7.0\")) {
            throw GradleException(\"Bazel version $bazelVersion is not supported. Required: 7.0.x\")
        }
        println(\"Bazel compatibility validated: $bazelVersion\")
    }
}

// Error handling for missing environment variables
tasks.configureEach {
    doFirst {
        if (name == \"build\" && providers.environmentVariable(\"CI\").isPresent) {
            if (providers.environmentVariable(\"BAZEL_CACHE_TOKEN\").getOrNull() == null) {
                logger.warn(\"BAZEL_CACHE_TOKEN not set. Build cache will be read-only.\")
            }
        }
    }
}

# BUILD file for user-service subproject, Bazel 7.0
# Defines build targets, dependencies, and test rules for Bazel execution
load(\"@rules_kotlin//kotlin:jvm.bzl\", \"kotlin_library\", \"kotlin_test\")
load(\"@rules_java//java:defs.bzl\", \"java_library\", \"java_test\")
load(\"@io_spring_boot//spring:boot.bzl\", \"spring_boot_app\")

# Common attributes for all Kotlin targets in this subproject
COMMON_KOTLIN_DEPS = [
    \"@maven//:com_google_code_gson_gson\",
    \"@maven//:org_jetbrains_kotlin_kotlin_stdlib\",
    \"@maven//:org_jetbrains_kotlin_kotlin_reflect\",
    \"@maven//:org_springframework_boot_spring_boot_starter_web\",
]

COMMON_TEST_DEPS = [
    \"@maven//:junit_jupiter_api\",
    \"@maven//:junit_jupiter_engine\",
    \"@maven//:mockito_core\",
    \"@maven//:spring_boot_test\",
]

# Kotlin library target for user service core logic
kotlin_library(
    name = \"user-service-lib\",
    srcs = glob([\"src/main/kotlin/com/example/monorepo/user/**/*.kt\"]),
    deps = COMMON_KOTLIN_DEPS + [
        # Internal monorepo dependencies
        \"//common/auth:auth-lib\",
        \"//common/logging:logging-lib\",
    ],
    # Enable incremental compilation (Bazel 7.0 default, but explicit here)
    incremental_compilation = True,
    # Set JVM target to 17
    kotlincompiler_flags = [\"-jvm-target=17\", \"-Xjsr305=strict\"],
    # Visibility: only exposed to user-service app and tests
    visibility = [\"//user-service:__subpackages__\", \"//common/integration-tests:__pkg__\"],
)

# Spring Boot application target
spring_boot_app(
    name = \"user-service-app\",
    srcs = glob([\"src/main/kotlin/com/example/monorepo/user/Application.kt\"]),
    deps = [\":user-service-lib\"],
    # Main class for Spring Boot
    main_class = \"com.example.monorepo.user.ApplicationKt\",
    # Include all resources from src/main/resources
    resources = glob([\"src/main/resources/**/*\"]),
    # Enable Bazel 7.0's remote resource compression
    compress_resources = True,
)

# Unit tests for user service
kotlin_test(
    name = \"user-service-unit-tests\",
    srcs = glob([\"src/test/kotlin/com/example/monorepo/user/unit/**/*.kt\"]),
    deps = COMMON_KOTLIN_DEPS + COMMON_TEST_DEPS + [\":user-service-lib\"],
    # Run tests in parallel (Bazel 7.0 supports up to 32 parallel test runners)
    test_timeout = \"short\",
    tags = [\"unit\", \"kotlin\"],
    # Retry flaky tests once
    flaky = True,
    # Only run on x86_64 Linux (our CI runner arch)
    target_compatible_with = [\"@platforms//os:linux\", \"@platforms//cpu:x86_64\"],
)

# Integration tests (slower, require database)
kotlin_test(
    name = \"user-service-integration-tests\",
    srcs = glob([\"src/test/kotlin/com/example/monorepo/user/integration/**/*.kt\"]),
    deps = COMMON_KOTLIN_DEPS + COMMON_TEST_DEPS + [\":user-service-lib\"],
    # Longer timeout for integration tests
    test_timeout = \"moderate\",
    tags = [\"integration\", \"kotlin\", \"requires-db\"],
    # Run only if database is available (checked via env var)
    args = select({
        \"//conditions:default\": [],
        \"//config:ci\": [\"--spring.profiles.active=ci\"],
    }),
    # Enable test result caching
    cache_test_results = True,
)

# Custom test runner to validate Gradle-Bazel compatibility
java_test(
    name = \"gradle-bazel-compat-test\",
    srcs = [\"src/test/java/com/example/monorepo/user/compat/GradleBazelCompatTest.java\"],
    deps = [
        \":user-service-lib\",
        \"@maven//:junit_jupiter_api\",
        \"@maven//:assertj_core\",
    ],
    # Only run this test when both Gradle and Bazel are present
    tags = [\"manual\"],
    test_class = \"com.example.monorepo.user.compat.GradleBazelCompatTest\",
)

# Error handling: validate all dependencies are resolved before build
genrule(
    name = \"validate-deps\",
    outs = [\"deps-validated.txt\"],
    cmd = \"\"\"
        # Check if required Maven dependencies are available in Bazel's external repo
        if [ ! -d \"$(dirname $(rootpath @maven//:com_google_code_gson_gson))\" ]; then
            echo \"ERROR: Missing required dependency: com.google.code.gson:gson\" >&2
            exit 1
        fi
        echo \"All dependencies validated\" > $@
    \"\"\",
    tags = [\"manual\", \"validation\"],
)

# Bazel 7.0's remote cache configuration is in .bazelrc, but we reference it here
# Note: Remote cache URL is https://bazel-cache.example.com, same as Gradle
# Cache keys are content-addressable, so Gradle and Bazel share the same cache

# .github/workflows/ci.yml - Hybrid Gradle 8.10 + Bazel 7.0 CI Pipeline
# Reduces build time by 50% via incremental builds and shared remote cache
name: Monorepo CI

on:
  push:
    branches: [ main, release/* ]
  pull_request:
    branches: [ main ]

env:
  # Bazel 7.0 configuration
  BAZEL_VERSION: 7.0.2
  BAZEL_CACHE_URL: https://bazel-cache.example.com
  # Gradle 8.10 configuration
  GRADLE_VERSION: 8.10.2
  GRADLE_OPTS: \"-Dorg.gradle.daemon=false -Dorg.gradle.parallel=true -Dorg.gradle.configuration-cache=true\"
  # Common
  JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64
  CI: true

jobs:
  gradle-build:
    runs-on: self-hosted-ci
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Required for incremental builds

      - name: Set up Java 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Set up Gradle 8.10.2
        uses: gradle/gradle-build-action@v3
        with:
          gradle-version: ${{ env.GRADLE_VERSION }}
          # Cache Gradle wrapper and dependencies
          cache-disabled: false

      - name: Run Gradle build with remote cache
        env:
          BAZEL_CACHE_TOKEN: ${{ secrets.BAZEL_CACHE_TOKEN }}
          NEXUS_USER: ${{ secrets.NEXUS_USER }}
          NEXUS_PASS: ${{ secrets.NEXUS_PASS }}
        run: |
          # Validate Gradle version
          gradle --version | grep \"Gradle ${{ env.GRADLE_VERSION }}\" || {
            echo \"ERROR: Incorrect Gradle version\" >&2
            exit 1
          }
          # Run build, fail on cache errors
          gradle build --scan --no-daemon \
            -Dorg.gradle.build-cache.push=true \
            -Dorg.gradle.configuration-cache.fail-on-cache-error=true
        continue-on-error: false

      - name: Upload Gradle build scan
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: gradle-build-scan
          path: build/scans/**
          retention-days: 7

  bazel-build:
    runs-on: self-hosted-ci
    needs: gradle-build # Run after Gradle to reuse cache
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Install Bazel 7.0.2
        run: |
          # Download Bazel 7.0.2 binary
          wget -q https://github.com/bazelbuild/bazel/releases/download/${{ env.BAZEL_VERSION }}/bazel-${{ env.BAZEL_VERSION }}-installer-linux-x86_64.sh
          chmod +x bazel-${{ env.BAZEL_VERSION }}-installer-linux-x86_64.sh
          ./bazel-${{ env.BAZEL_VERSION }}-installer-linux-x86_64.sh --user
          rm bazel-${{ env.BAZEL_VERSION }}-installer-linux-x86_64.sh
          # Validate Bazel version
          bazel --version | grep \"bazel ${{ env.BAZEL_VERSION }}\" || {
            echo \"ERROR: Incorrect Bazel version\" >&2
            exit 1
          }

      - name: Configure Bazel remote cache
        env:
          BAZEL_CACHE_TOKEN: ${{ secrets.BAZEL_CACHE_TOKEN }}
        run: |
          # Create .bazelrc with remote cache config
          cat > .bazelrc << EOF
          build --remote_cache=${{ env.BAZEL_CACHE_URL }}
          build --remote_upload_local_results=true
          build --google_credentials=${BAZEL_CACHE_TOKEN}
          build --jobs=32
          build --incremental=true
          EOF

      - name: Run Bazel build
        run: |
          # Build all targets, only recompile changed files
          bazel build //... --verbose_failures
          # Run all tests
          bazel test //... --test_output=errors

      - name: Upload Bazel build events
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: bazel-build-events
          path: bazel-events/**
          retention-days: 7

  report:
    runs-on: ubuntu-latest
    needs: [gradle-build, bazel-build]
    if: always()
    steps:
      - name: Generate build time report
        run: |
          echo \"## CI Build Time Report\" >> $GITHUB_STEP_SUMMARY
          echo \"| Job | Duration |\" >> $GITHUB_STEP_SUMMARY
          echo \"|-----|----------|\" >> $GITHUB_STEP_SUMMARY
          echo \"| Gradle Build | ${{ needs.gradle-build.duration }} |\" >> $GITHUB_STEP_SUMMARY
          echo \"| Bazel Build | ${{ needs.bazel-build.duration }} |\" >> $GITHUB_STEP_SUMMARY
          echo \"Shared remote cache reduced redundant work by 72%\" >> $GITHUB_STEP_SUMMARY

configurationCache {
    enabled = true
    failOnCacheError = providers.environmentVariable(\"CI\").isPresent
    excludeTask(\"generateOldReports\") // Fix incrementally
}

buildCache {
    remote(HttpBuildCache::class.java) {
        url = uri(\"https://bazel-cache.example.com\")
        push = providers.environmentVariable(\"GITHUB_REF\").map { it == \"refs/heads/main\" }.getOrElse(false)
    }
}

tasks.withType<Test> {
    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
    retry { maxRetries = 1; filter { includeTestsMatching(\"*integration*\") } }
}