Merge branch 'master' into ts/43260_profiler_crash_after_missconfig

Author: DreierF

.github/workflows/actions.yml

@@ -2,7 +2,7 @@ name: Build
 
 on:
   push:
-    branches: '**'
+    branches: master
     tags: 'v*'
   pull_request:
     branches: '**'
@@ -47,6 +47,14 @@ jobs:
             -Psigning.keyId=4FB80B8E \
             -PsonatypeUsername=${{ secrets.SONATYPE_USER }} \
             -PsonatypePassword=${{ secrets.SONATYPE_PASSWORD }}
+      - name: Push Docker Image to DockerHub
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          ./gradlew :agent:pushOciImage :agent:pushLegacyOciImage --registry=dockerHub
+          ./gradlew :agent:pushOciImage :agent:pushLegacyOciImage --registry=dockerHub -PociImageTag=latest
+        env:
+          ORG_GRADLE_PROJECT_dockerHubUsername: ${{ secrets.DOCKERHUB_USER }}
+          ORG_GRADLE_PROJECT_dockerHubPassword: ${{ secrets.DOCKERHUB_TOKEN }}
       - name: Upload coverage to Teamscale
         if: always() && github.event_name == 'push'
         uses: cqse/teamscale-upload-action@v9.2.1
@@ -83,32 +91,3 @@ jobs:
           format: 'JACOCO'
           message: 'Coverage Windows'
           files: '**/jacocoTestReport.xml'
-
-  docker:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v6
-        with:
-          images: cqse/teamscale-jacoco-agent
-      - name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v4
-        with:
-          username: ${{ secrets.DOCKERHUB_USER }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v7
-        with:
-          file: 'agent/src/docker/Dockerfile'
-          push: ${{ startsWith(github.ref, 'refs/tags/v') }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: |
-            GITHUB_REF=${{ github.ref }}
-

CHANGELOG.md

@@ -6,7 +6,14 @@ We use [semantic versioning](http://semver.org/):
 
 # Next version
 - [fix] _agent_: The profiled application no longer crashes when the profiler configuration is invalid (e.g., missing `teamscale-user`). Instead, the application starts normally without coverage collection.
-- [feature] _teamscale-gradle-plugin_: Annotated tasks with `@DisableCachingByDefault` where caching can't be applied
+
+# 36.5.0
+- [feature] _agent_: Renamed the docker image to `cqse/teamscale-java-profiler` and added support for the `linux/arm64` platform
+- [fix] _teamscale-gradle-plugin_: Coverage aggregation report and upload were skipped when tests failed with `--continue`
+
+# 36.4.1
+- [fix] _agent_: Fixed `IllegalStateException: Can't add different class with same name` when application servers like JBoss perform a reload without full restart or when duplicate class files exist across multiple archives
+- [fix] _teamscale-gradle-plugin_: Annotated tasks with `@DisableCachingByDefault` where caching can't be applied
 
 # 36.4.0
 - [feature] _maven-plugin_: Auto-detect commit from CI/CD environment variables (Jenkins, GitHub Actions, GitLab CI, Azure DevOps, etc.)

CLAUDE.md

@@ -51,7 +51,7 @@ Entry point: `PreMain.premain()` in `agent/src/main/java/com/teamscale/jacoco/ag
 4. Classes are instrumented at load time with coverage probes
 
 **Coverage modes:**
-- **Interval-based** (`Agent` class) - Periodically dumps coverage (default every 10 min)
+- **Interval-based** (`Agent` class) - Periodically dumps coverage (default every 480 min)
 - **Test-wise** (`TestwiseCoverageAgent` class) - Per-test coverage via HTTP endpoints (`/test/start`, `/test/end`)
 
 **Key classes:**

README.md

@@ -11,6 +11,86 @@
 * [Teamscale Gradle Plugin](https://docs.teamscale.com/reference/integrations/gradle-plugin/)
 * [Teamscale Maven Plugin](https://docs.teamscale.com/reference/integrations/maven-plugin/)
 
+## Architecture
+
+The profiler is a JVM agent that uses [JaCoCo](https://www.jacoco.org/) under the hood for bytecode instrumentation and coverage recording. 
+The diagram below shows the data flow from JVM startup to coverage upload.
+
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│  JVM                                                                     │
+│                                                                          │
+│  -javaagent:teamscale-jacoco-agent.jar=...                               │
+│       │                                                                  │
+│       ▼                                                                  │
+│  ┌──────────┐     ┌─────────────────────┐     ┌──────────────────────┐   │
+│  │ PreMain  │────▶│ JaCoCoPreMain       │────▶│ LenientCoverage-     │   │
+│  │          │     │                     │     │ Transformer          │   │
+│  │ Parses   │     │ Creates JaCoCo      │     │                      │   │
+│  │ options, │     │ runtime, registers  │     │ Registered with JVM  │   │
+│  │ logging  │     │ class transformer   │     │ via addTransformer() │   │
+│  └──────────┘     └─────────────────────┘     └──────────┬───────────┘   │
+│       │                                                  │               │
+│       │           ┌──────────────────────────────────────────────────┐   │
+│       │           │  Class Loading                                   │   │
+│       │           │                                                  │   │
+│       │           │  For every class loaded by the JVM:              │   │
+│       │           │  1. Transformer receives original bytecode       │   │
+│       │           │  2. JaCoCo injects boolean[] probes at branches  │   │
+│       │           │     and lines                                    │   │
+│       │           │  3. Modified bytecode returned to JVM            │   │
+│       │           │                                                  │   │
+│       │           │  Instrumentation happens ONLY at class load      │   │
+│       │           │  time. Already-loaded classes are never          │   │
+│       │           │  retransformed.                                  │   │
+│       │           └──────────────────────────────────────────────────┘   │
+│       │                                                  │               │
+│       │           ┌──────────────────────────────────────────────────┐   │
+│       │           │  Runtime                                         │   │
+│       │           │                                                  │   │
+│       │           │  Probes fire during normal code execution.       │   │
+│       │           │  Each probe sets a flag in a per-class           │   │
+│       │           │  boolean[], tracking which lines/branches ran.   │   │
+│       │           │  Data accumulates in JaCoCo runtime memory.      │   │
+│       │           └──────────────────────────────────────────────────┘   │
+│       │                                                                  │
+│       ▼                                                                  │
+│  ┌─────────────────────────────────────────────────────────────────┐     │
+│  │  Agent (Normal mode)         OR   TestwiseCoverageAgent         │     │
+│  │                                                                 │     │
+│  │  HTTP server (Jetty + Jersey) for control:                      │     │
+│  │    POST /dump ─── trigger coverage dump                         │     │
+│  │    POST /test/start, /test/end ─── per-test coverage            │     │
+│  └─────────────────────────────────────────────────────────────────┘     │
+│                                                                          │
+└──────────────────────────────────────────────────────────────────────────┘
+         │
+         │  Periodically (default: every 480 min) or on HTTP request
+         ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│  Coverage Dump Pipeline                                                 │
+│                                                                         │
+│  1. JacocoRuntimeController.dumpAndReset()                              │
+│     Retrieves execution data from JaCoCo runtime and resets probes.     │
+│                                                                         │
+│  2. JaCoCoXmlReportGenerator.convertSingleDumpToReport()                │
+│     Reads class files (from auto-created dump dir or user-specified     │
+│     class-dir), matches them with execution data by CRC64 class ID,     │
+│     and produces a JaCoCo XML coverage report.                          │
+│                                                                         │
+│  3. IUploader.upload()                                                  │
+│     Sends the XML report to the configured destination.                 │
+│                                                                         │
+└────────────────────────────┬────────────────────────────────────────────┘
+                             │
+              ┌──────────────┼──────────────┐
+              ▼              ▼              ▼
+        ┌──────────┐  ┌───────────┐  ┌────────────┐
+        │Teamscale │  │Artifactory│  │Local disk  │
+        │  Server  │  │ / Azure   │  │            │
+        └──────────┘  └───────────┘  └────────────┘
+```
+
 ## Development
 
 Before starting development, please enable the pre-commit hook by running:

agent/build.gradle.kts

@@ -1,3 +1,5 @@
+import io.github.sgtsilvio.gradle.oci.dsl.OciImageDefinition
+
 plugins {
 	com.teamscale.`java-convention`
 	application
@@ -9,6 +11,7 @@ plugins {
 	com.teamscale.coverage
 	com.teamscale.publish
 	com.teamscale.`logger-patch`
+	alias(libs.plugins.oci)
 }
 
 evaluationDependsOn(":installer")
@@ -101,3 +104,57 @@ distributions {
 tasks.shadowDistZip {
 	archiveFileName = "teamscale-jacoco-agent.zip"
 }
+
+// The OCI plugin adds a project-level repository ('dockerHubOciRegistry') for resolving
+// OCI image dependencies, which overrides the settings-level dependencyResolutionManagement
+// repositories. We need to re-declare mavenCentral() here so regular dependencies can still
+// be resolved. See: https://github.com/SgtSilvio/gradle-oci/issues/125
+repositories {
+	mavenCentral()
+}
+
+oci {
+	registries {
+		dockerHub {
+			optionalCredentials()
+		}
+	}
+
+	val ociImageTag = providers.gradleProperty("ociImageTag").orElse(appVersion)
+	val configureImage: Action<OciImageDefinition> = Action {
+		imageTag = ociImageTag
+		allPlatforms {
+			dependencies {
+				runtime("library:alpine:latest")
+			}
+			config {
+				entryPoint = listOf("/entrypoint.sh")
+			}
+			layer("agent") {
+				contents {
+					into("agent") {
+						from(tasks.shadowJar)
+					}
+				}
+			}
+			layer("entrypoint") {
+				contents {
+					from("src/docker/entrypoint.sh") {
+						filePermissions = "755".toInt(8)
+					}
+				}
+			}
+		}
+		specificPlatform(platform("linux", "amd64"))
+		specificPlatform(platform("linux", "arm64"))
+	}
+
+	imageDefinitions.register("main") {
+		imageName = "cqse/teamscale-java-profiler"
+		configureImage.execute(this)
+	}
+	imageDefinitions.register("legacy") {
+		imageName = "cqse/teamscale-jacoco-agent"
+		configureImage.execute(this)
+	}
+}

agent/src/docker/Dockerfile

@@ -0,0 +1,11 @@
+#!/bin/sh
+# When /transfer exists (shared volume), copy the agent JAR there and exit.
+# This supports the Kubernetes init container pattern where this image provides
+# the agent JAR to the application container via a shared volume.
+if [ -e /transfer ]; then
+  cp -r /agent/teamscale-jacoco-agent.jar /transfer
+  exit 0
+fi
+# Otherwise, keep the container alive indefinitely as a sidecar.
+trap : TERM INT
+sleep infinity & wait

agent/src/docker/entrypoint.sh

@@ -40,9 +40,6 @@
  */
 public class Agent extends AgentBase {
 
-	/** Converts binary data to XML. */
-	private final JaCoCoXmlReportGenerator generator;
-
 	/** Regular dump task. */
 	private Timer timer;
 
@@ -57,9 +54,6 @@ public Agent(AgentOptions options, Instrumentation instrumentation)
 		uploader = options.createUploader(instrumentation);
 		logger.info("Upload method: {}", uploader.describe());
 		retryUnsuccessfulUploads(options, uploader);
-		generator = new JaCoCoXmlReportGenerator(options.getClassDirectoriesOrZips(),
-				options.getLocationIncludeFilter(), options.getDuplicateClassFileBehavior(),
-				options.shouldIgnoreUncoveredClasses(), wrap(logger));
 
 		if (options.shouldDumpInIntervals()) {
 			timer = new Timer(this::dumpReport, Duration.ofMinutes(options.getDumpIntervalInMinutes()));
@@ -165,9 +159,11 @@ private static void deleteDirectoryIfEmpty(Path directory) throws IOException {
 	/**
 	 * Dumps the current execution data, converts it, writes it to the output directory defined in {@link #options} and
 	 * uploads it if an uploader is configured. Logs any errors, never throws an exception.
+	 * <p>
+	 * Synchronized because this can be triggered concurrently by the timer and by the HTTP /dump endpoint.
 	 */
 	@Override
-	public void dumpReport() {
+	public synchronized void dumpReport() {
 		logger.debug("Starting dump");
 
 		try {
@@ -188,6 +184,10 @@ private void dumpReportUnsafe() {
 			return;
 		}
 
+		JaCoCoXmlReportGenerator generator = new JaCoCoXmlReportGenerator(
+				options.getClassDirectoriesOrZips(), options.getLocationIncludeFilter(),
+				options.getDuplicateClassFileBehavior(), options.shouldIgnoreUncoveredClasses(), wrap(logger));
+
 		try (Benchmark ignored = new Benchmark("Generating the XML report")) {
 			File outputFile = options.createNewFileInOutputDirectory("jacoco", "xml");
 			CoverageFile coverageFile = generator.convertSingleDumpToReport(dump, outputFile);

agent/src/main/java/com/teamscale/jacoco/agent/Agent.java

@@ -35,11 +35,11 @@ public String createJacocoAgentOptions() throws AgentOptionParseException, IOExc
 		// Don't dump class files in testwise mode when coverage is written to an exec file
 		boolean needsClassFiles = agentOptions.mode == EMode.NORMAL || agentOptions.testwiseCoverageMode != ETestwiseCoverageMode.EXEC_FILE;
 		if (agentOptions.classDirectoriesOrZips.isEmpty() && needsClassFiles) {
-			Path tempDir = createTemporaryDumpDirectory();
-			tempDir.toFile().deleteOnExit();
-			builder.append(",classdumpdir=").append(tempDir.toAbsolutePath());
+			Path classDumpDirectory = createTemporaryDumpDirectory();
+			classDumpDirectory.toFile().deleteOnExit();
+			builder.append(",classdumpdir=").append(classDumpDirectory.toAbsolutePath());
 
-			agentOptions.classDirectoriesOrZips = Collections.singletonList(tempDir.toFile());
+			agentOptions.classDirectoriesOrZips = Collections.singletonList(classDumpDirectory.toFile());
 		}
 
 		agentOptions.additionalJacocoOptions

agent/src/main/java/com/teamscale/jacoco/agent/options/JacocoAgentOptionsBuilder.java

@@ -4,7 +4,7 @@ plugins {
 
 group = "com.teamscale"
 
-val appVersion by extra("36.4.0")
+val appVersion by extra("36.5.0")
 
 val snapshotVersion = appVersion + if (VersionUtils.isTaggedRelease()) "" else "-SNAPSHOT"