The Gradle Enterprise Maven extension improves your development workflow and your productivity, when developing and maintaining Apache Maven™ builds. The extension enables build scan insights and build cache acceleration.

Getting set up with the Gradle Enterprise Maven Extension

You apply the Gradle Enterprise Maven extension to your build by adding the following configuration block to a new or existing .mvn/extensions.xml file in your Maven project. The extension will be downloaded automatically from Maven Central once you run your build.

<extensions>
  <extension>
    <groupId>com.gradle</groupId>
    <artifactId>gradle-enterprise-maven-extension</artifactId>
    <version>1.1.2</version>
  </extension>
</extensions>

You can also add the extension jar into the lib/ext folder of your Maven installation. This is useful if you are packaging a custom Maven installation for your organization and you want Gradle Enterprise to be available to all your projects out of the box.

The extension is configured through one or more gradle-enterprise.xml files and the pluginManagement sections of your pom.xml files. The configuration options will be introduced over the coming sections. For the full reference of the extension’s configuration, see the Configuration reference.

Using build scans

Build scans are a record of what happened during a build, captured and visualized by Gradle Enterprise.

Build scans are an important tool for developing and maintaining Maven builds. They provide insights into exactly what your builds are doing, helping you identify problems with the build environment, performance, and more. They can also help you understand and improve the build more generally, and make collaborating with others easier.

build scan service overview
Figure 1. build scans can be published to Gradle Enterprise or scans.gradle.com

Gradle Enterprise is a commercial product for companies that can be hosted on their own systems and ships with a build scan server and a build cache backend implementation. scans.gradle.com is a build scan server available for free, hosted by Gradle Inc.

There are two aspects to working with build scans:

  • Data collection

  • Publishing

Enabling publication of build scans

Enabling publication of build scans depends on whether you are publishing to a Gradle Enterprise instance or scans.gradle.com. In the case of Gradle Enterprise, you need to specify the server’s location. In the case of scans.gradle.com, you need to accept the terms of service.

Set the location of your Gradle Enterprise instance

When you publish build scans to a Gradle Enterprise instance, you must configure the location of the Gradle Enterprise server. Add the following configuration to the gradle-enterprise.xml file:

gradle-enterprise.xml
<gradleEnterprise>
  <server>
    <url>https://gradle-enterprise.mycompany.com</url>
  </server>
</gradleEnterprise>

The precise URL you need depends on the hostname that your Gradle Enterprise instance has been configured with. If in doubt, be sure to ask whomever manages that instance.

You may encounter a warning about an untrusted certificate when connecting to Gradle Enterprise over HTTPS. The ideal solution is for someone to add a valid SSL certificate to the Gradle Enterprise instance, but we recognise that you may not be able to do that. In this case, set the allowUntrusted option to true:

gradle-enterprise.xml
<gradleEnterprise>
  <server>
    <url>https://gradle-enterprise.mycompany.com</url>
    <allowUntrusted>true</allowUntrusted>
  </server>
</gradleEnterprise>

This is a convenient workaround, but you shouldn’t use it as a long-term solution.

Accept the scans.gradle.com terms of service

In order to publish to scans.gradle.com, you need to accept the terms of service, by adding the following configuration to the gradle-enterprise.xml:

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <termsOfService>
      <url>https://gradle.com/terms-of-service</url>
      <accept>true</accept>
    </termsOfService>
  </buildScan>
</gradleEnterprise>

Be sure to check the terms of service at the URL shown in the above fragment.

Once you have accepted the terms of service, you can start publishing build scans to scans.gradle.com.

If you don’t accept the terms of service, as explained above, you will be asked to agree to the terms of service on the command line, before any attempt of publishing a build scan. This can be useful if you share your gradle-enterprise.xml file with others, and you want everyone to explicitly accept those terms of service.

Controlling when build scans are published

Once you’ve gone through the initial setup of the previous section, you are ready to start publishing build scans. But when should you publish them? Every time you run a build? Only when the build fails? It’s up to you. The Gradle Enterprise Maven extension has several options that allow you to use whatever approach works best.

Publishing every build run

This is the default. There are many advantages to publishing build scans regularly, such as being able to track the behavior and performance of a build over time. It makes no sense relying on ad-hoc publishing of scans in such a situation as it’s easy to forget on the command line.

When you want to publish every build run, you can use the ALWAYS setting, which is also set by default:

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <publish>ALWAYS</publish>
  </buildScan>
</gradleEnterprise>

This approach means that you get a build scan for every successful and failed build that runs, including from your continuous integration infrastructure and your developers.

Publishing every failed build

If you only want to publish build scans when the build fails, use the following option:

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <publish>ON_FAILURE</publish>
  </buildScan>
</gradleEnterprise>

Publishing on demand

We imagine that when you first start experimenting with build scans, you won’t want to publish them all the time until you become familiar with the implications. Even then, you may have good reason not to go all-in and automate the process. That’s where one-off build scans come in.

If you only want to publish build scans when explicitly requested, use the following option:

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <publish>ON_DEMAND</publish>
  </buildScan>
</gradleEnterprise>

You can then publish a build scan by passing the -Dscan system property to Maven.

$ mvn clean verify -Dscan

Regardless of the configured publication setting, you can always publish a build scan by passing the -Dscan system property to Maven. Passing -Dscan always takes precedence over the publication setting configured in the gradle-enterprise.xml file.

Publishing only for CI builds

If you want to publish build scans only from your CI system, you have to use a specific gradle-enterprise.xml file located at <maven-home>/conf/gradle-enterprise.xml in your CI agents. Alternatively, you can define the -Dgradle.user.config system property on your CI builds to indicate the location of the gradle-enterprise.xml file that needs to be used in this case.

Capturing goal input files

(Maven extension v1.1+)

Build scans capture hashes of goal inputs, to enable identifying changes to inputs when comparing builds, among other features. By default, an overall hash value for each goal input property is captured. This enables identifying which properties changed for a goal execution (e.g. the source or the classpath for Java compilation), but not which individual files changed. In order to identify file changes, the paths and content hashes of each individual input file must be captured, which can be enabled.

When to enable

Capturing goal input files increases the amount of data transmitted to the build scan server at the end of the build. If the network connection to the build scan server is poor, it may increase the time required to transmit. Additionally, it may also increase the data storage requirements for the build scan server.

This data is currently only used for build comparison, which is only available in Gradle Enterprise and is not available with scans.gradle.com. If you are using scans.gradle.com, it is not recommended that you enable capture of goal input files.

If you are using Gradle Enterprise and utilising its build cache to accelerate your builds, it is strongly recommended to enable capture of goal input files as identifying which files have changed between builds with build comparison is extremely effective for diagnosing unexpected build cache misses.

How to enable

Goal input files capture can be enabled via the gradle-enterprise.xml configuration file, or via a system property.

Via gradle-enterprise.xml

To enable, add the following to the gradle-enterprise.xml configuration file.

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <captureGoalInputFiles>true</captureGoalInputFiles>
  </buildScan>
</gradleEnterprise>
Via system property

To enable without modifying gradle-enterprise.xml, supply a gradle.scan.captureGoalInputFiles system property to the build. If the property is set with true, capture will be enabled. If the property is set with false, capture will be disabled, regardless of any programmatic setting. The environmental setting always takes precedence over the programmatic setting.

$ mvn package -Dgradle.scan.captureGoalInputFiles=true

Extending build scans

You can easily include extra custom information in your build scans in the form of tags, links and values. This is a very powerful mechanism for capturing and sharing information that is important to your build and development process.

This information can be anything you like. You can tag all builds run by your continuous integration tool with a CI tag. You can capture the name of the environment that the build published to as a value. You can link to the source revision for the build in an online tool such as GitHub. The possibilities are endless.

You can see how the custom data appears in figure 2:

scan with custom data
Figure 2. A build scan containing the different types of custom data

Gradle Enterprise allows listing and searching across all of the build scans in the system. You can find and filter build scans by tags and custom values, in addition to project name, outcome and other properties. In figure 3, for example, we are filtering for all build scans that have the tag "local" and a git branch name of "master":

build scan filtered list
Figure 3. A filtered list of build scans in Gradle Enterprise

Adding tags

Tags are typically used to indicate the type or class of a build, or a key characteristic. They are prominent in the user interface and quickly inform a user about the nature of a build. A build can have zero or more tags.

They can be added in the gradle-enterprise.xml file and/or your project POM.

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <tags>
      <tag>my tag</tag>
    </tags>
  </buildScan>
</gradleEnterprise>
pom.xml
<project>
  ...
  <plugins>
    <plugin>
      <groupId>org.gradle</groupId>
      <artifactId>gradle-enterprise-maven-extension</artifactId>
      <version>1.1.2</version>
      <configuration>
        <gradleEnterprise>
          <buildScan>
            <tags>
              <tag>my tag</tag>
            </tags>
          </buildScan>
        </gradleEnterprise>
      </configuration>
    <plugin>
  </plugins>
</project>

Note that the order in which you declare the tags doesn’t affect the build scan view. They are displayed in alphabetical order, with any all-caps labels displayed before the rest.

You can see the effect of a custom tag in figure 2.

The Gradle Enterprise Maven extension imposes limits on captured tags:

  • maximum tag count: 50

  • maximum tag length: 200 characters

Builds rarely live in isolation. Where does the project source live? Is there online documentation for the project? Where can you find the project’s issue tracker? If these exist and have a URL, you can add them to the build scan.

They can be added in the gradle-enterprise.xml file and/or your project POM.

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <links>
      <link>
        <name>my link<name>
        <url>http://my-site.com</url>
      </link>
    </links>
  </buildScan>
</gradleEnterprise>
pom.xml
<project>
  ...
  <plugins>
    <plugin>
      <groupId>org.gradle</groupId>
      <artifactId>gradle-enterprise-maven-extension</artifactId>
      <version>1.1.2</version>
      <configuration>
        <gradleEnterprise>
          <buildScan>
            <links>
              <link>
                <name>my link<name>
                <url>http://my-site.com</url>
              </link>
            </links>
          </buildScan>
        </gradleEnterprise>
      </configuration>
    <plugin>
  </plugins>
</project>

The <name> is simply a string identifier that you choose and that means something to you.

You can see the effect of a custom link in figure 2, which shows how a label CVS becomes a hyperlink that anyone viewing the build scan can follow.

The Gradle Enterprise Maven extension imposes limits on captured links:

  • maximum link count: 20

  • maximum link label length: 100 characters

  • maximum link url length: 1,000 characters

Adding custom values

Some information just isn’t useful without context. What does "1G" mean? You might guess that it represents 1 gigabyte, but of what? It’s only when you attach the label "Max heap size for build" that it makes sense. The same applies to git commit IDs, for example, which could be interpreted as some other checksum without a suitable label.

Custom values are designed for these cases that require context. They’re standard key-value pairs, in which the key is a string label of your choosing and the values are also strings, often evaluated from the build environment.

They can be added in the gradle-enterprise.xml file and/or your project POM.

gradle-enterprise.xml
<gradleEnterprise>
  <buildScan>
    <values>
      <value>
        <name>my name<name>
        <value>my value</value>
      </value>
    </values>
  </buildScan>
</gradleEnterprise>
pom.xml
<project>
  ...
  <plugins>
    <plugin>
      <groupId>org.gradle</groupId>
      <artifactId>gradle-enterprise-maven-extension</artifactId>
      <version>1.1.2</version>
      <configuration>
        <gradleEnterprise>
          <buildScan>
            <values>
              <value>
                <name>Build Number<name>
                <value>${project.buildNumber}</value>
              </value>
            </values>
          </buildScan>
        </gradleEnterprise>
      </configuration>
    <plugin>
  </plugins>
</project>

The above example demonstrates how you can read the build number from a project property—assuming you have your build set up for this—and attach it to the build scans as a custom value.

As with tags, you can filter build scans by custom values in Gradle Enterprise.

The Gradle Enterprise Maven extension imposes limits on captured custom values:

  • maximum custom value count: 1,000

  • maximum custom value key length: 1,000 characters

  • maximum custom value value length: 100,000 characters

Providing custom data via system properties

The examples up to this point have shown how to add data in your gradle-enterprise.xml file or project POM. The Gradle Enterprise Maven extension also allows you to inject any form of custom data through the use of specially named system properties. This can help you keep your build files clean of too much environment-specific information that may not be relevant to most of the users of the build.

These system properties take the following forms, depending on whether you want to inject a tag, a link or a custom value:

-Dscan.tag.<tag>
-Dscan.link.<name>=<URL>
-Dscan.value.<name>=<value>

Here are some concrete examples, which assume that the build has been configured to publish build scans automatically:

$ mvn package -Dscan.tag.CI
$ mvn package -Dscan.link.VCS=https://github.com/myorg/my-super-project/tree/my-new-feature
$ mvn package "-Dscan.value.CI Build Type=QA_Build"

This feature is particularly useful for continuous integration builds as you can typically easily configure your CI tool to specify system properties for a build. It’s even common for CI tools to be able to inject system properties into a build that are interpolated with information from the CI system, such as build number.

$ mvn package "-Dscan.value.buildNumber=$CI_BUILD_NUMBER"

You might be interested to add custom tags, links or custom values only if a certain condition is met. You can achieve this, for example, by using the Groovy Maven Plugin, and define your logic in Groovy to conditionally add custom data through the exposed BuildScanApi.

Do not reference the below mentioned Groovy script in your parent POM, otherwise the script will be executed for every module of your project. Rather create a new module called build-scan-custom-data with the following pom.xml contents:

build-scan-custom-data/pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.gradle</groupId>
    <artifactId>build-scan-custom-data</artifactId>
    <packaging>pom</packaging>
    <version>1.0</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.gmavenplus</groupId>
                <artifactId>gmavenplus-plugin</artifactId>
                <version>1.6.2</version>
                <executions>
                    <execution>
                        <id>build-scan-custom-data</id>
                        <phase>validate</phase>
                        <goals>
                            <goal>execute</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <scripts>
                        <script>file:///${project.basedir}/customData.groovy</script>
                    </scripts>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-all</artifactId>
                        <version>2.5.3</version>
                        <type>pom</type>
                        <scope>runtime</scope>
                    </dependency>
                    <dependency>
                        <groupId>org.apache.commons</groupId>
                        <artifactId>commons-lang3</artifactId>
                        <version>3.9</version>
                        <scope>runtime</scope>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

Next we need to register the new module in the parent pom.xml in the <modules> section by adding the following line:

pom.xml
...
    <modules>
        ...
        <module>build-scan-custom-data</module>
        ...
    </modules>
...

When that is setup, create the customData.groovy Groovy script in the new build-scan-custom-data module folder with the following contents:

build-scan-custom-data/customData.groovy
import org.apache.commons.lang3.StringUtils

def buildScan = session.lookup("com.gradle.maven.extension.api.scan.BuildScanApi")                       (1)

def ci = System.getenv('CI')
if (ci) {
  buildScan.tag('CI')                                                                                    (2)
} else {
  buildScan.tag('Local')                                                                                 (2)
}

buildScan.link('VCS Branch', "https://github.com/myorg/sample/tree/${System.getProperty('vcs.branch')}") (3)

def status = StringUtils.chomp('git status --porcelain'.execute().text)
if (status) {
  buildScan.value('Git Status', status)                                                                  (4)
}
1 Look up the BuildScanApi from the Maven Session.
2 Add a CI tag if the CI environment variable is set, or a Local tag if not.
3 Add a link to the VCS branch of the build.
4 Add a custom value with the Git Status.

This Groovy script is just an example of what you are able to do with the BuildScanApi. For more information about the BuildScanApi, see API reference for the complete API documentation.

Using the build cache

The build cache speeds up your builds by reusing outputs from any previous build, on any machine that is connected to the same build cache backend. It does this by reducing the inputs of a goal execution down to a strong hash key and storing the execution’s output under that key. It supports a local cache that allows other subsequent builds on the same machine to reuse the outputs whenever they execute a goal with the same inputs. The full benefit of the build cache is realized when also using the remote backend that Gradle Enterprise provides. This remote cache allows you to share cached outputs across your whole team, including local and CI builds.

Please refer to the build cache guide for step-by-step instructions on how to get started and in-depth explanations of important concepts. Moreover, the guide shows how to measure the effectiveness of the build cache in your project and explains how to roll out the build cache in your organization.

The build caching functionality for Maven requires a Gradle Enterprise license. The free scans.gradle.com server does not allow using the build cache.

Configuring the build cache

In order to use build caching for Apache Maven, you need to configure the location of your Gradle Enterprise server. Add the following configuration to the gradle-enterprise.xml:

gradle-enterprise.xml
<gradleEnterprise>
  <server>
    <url>https://gradle-enterprise.mycompany.com</url>
  </server>
</gradleEnterprise>

The precise URL you need depends on the hostname that your Gradle Enterprise instance has been configured with. If in doubt, be sure to ask whomever manages that instance.

You may encounter a warning about an untrusted certificate when connecting to Gradle Enterprise over HTTPS. The ideal solution is for someone to add a valid SSL certificate to the Gradle Enterprise instance, but we recognise that you may not be able to do that. In this case, set the allowUntrusted option to true:

gradle-enterprise.xml
<gradleEnterprise>
  <server>
    <url>https://gradle-enterprise.mycompany.com</url>
    <allowUntrusted>true</allowUntrusted>
  </server>
</gradleEnterprise>

This is a convenient workaround, but you shouldn’t use it as a long-term solution.

Configuring the local cache

The extension uses a local build cache to store build outputs in the local filesystem. It prevents network roundtrips by storing both outputs that local builds created, as well as outputs that were downloaded from the remote build cache.

Disabling the local cache

The local build cache is enabled by default. This can be changed by setting the enabled option to false.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <local>
      <enabled>false</enabled>
    </local>
  </buildCache>
</gradleEnterprise>

You can also use the -Dgradle.cache.local.enabled=false system property to achieve the same effect.

Changing the local cache directory

The local cache is located at ${user.home}/.m2/.gradle-enterprise/build-cache by default. This can be changed by setting the directory option.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <local>
      <directory>/path/to/local/build-cache</directory>
    </local>
  </buildCache>
</gradleEnterprise>

It is a common practice in large organizations to put the user home on a network share. Since the underlying motivation of a local build cache is to prevent network roundtrips, you should explicitly configure the local cache directory to a path on the local filesystem.

Configuring local cache cleanup

To prevent the local cache from growing in size indefinitely, the local cache directory is cleaned up periodically. By default, the cleanup interval is 24 hours and the retention time is 7 days. The cleanup can be disabled by setting the enabled option to false.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <local>
      <cleanup>
        <enabled>false</enabled>
      </cleanup>
    </local>
  </buildCache>
</gradleEnterprise>

The cleanup interval and retention time are controlled by the interval and retention options. The formats accepted are based on the ISO-8601 duration format PnDTnHnMn.nS.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <local>
      <cleanup>
        <retention>P30D</retention>
        <interval>P10D</interval>
      </cleanup>
    </local>
  </buildCache>
</gradleEnterprise>
Working offline

In order to work offline, the extension needs to have run in online mode at least once in the past 24 hours to check whether the given Gradle Enterprise server allows build caching for Maven. The result of this check is stored in a token in the user home. As long as you are working online, the token is refreshed every hour. The local cache will keep working in offline mode until that token expires after 24 hours.

Configuring the remote cache

Gradle Enterprise provides a cache node that is built into the server. Additionally, remote cache nodes can be spun up and connected to the server. By default, the built-in cache node of the Gradle Enterprise server is used.

Using a different cache node

The address of the remote cache node can be configured in the server option.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <remote>
      <server>
        <url>http://my-node/cache/</url>
      </server>
    </remote>
  </buildCache>
</gradleEnterprise>

Note that you still need to configure the address of your Gradle Enterprise server in the top-level server option.

Similar to the top-level Gradle Enterprise server configuration, the remote cache server configuration also provides an allowUntrusted option to circumvent certificate warnings:

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <remote>
      <server>
        <url>http://my-node/cache/</url>
        <allowUntrusted>true</allowUntrusted>
      </server>
    </remote>
  </buildCache>
</gradleEnterprise>

In order to use an authenticated cache node the credentials for that node have to be configured in the settings.xml file. You can also use Maven’s password encryption feature to safely store these credentials.

<user-home>/.m2/settings.xml
<servers>
  <server>
    <id>my-node</id>
    <username>username</username>
    <password>password</password>
  </server>
</servers>

The cache node with the ID my-node can then be referenced in the remote cache configuration.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <remote>
      <server>
        <id>my-node</id>
        <url>http://my-node/cache/</url>
      </server>
    </remote>
  </buildCache>
</gradleEnterprise>
Disabling the remote cache

The remote build cache is enabled by default. This can be changed by setting the enabled option to false.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <remote>
      <enabled>false</enabled>
    </remote>
  </buildCache>
</gradleEnterprise>

You can also use the -Dgradle.cache.remote.enabled=false system property to achieve the same effect.

Enabling remote store

Since the remote build cache is shared with other developers and CI machines, storing in the remote cache is disabled by default. Storing outputs in the remote cache can be enabled by setting the storeEnabled option to true.

gradle-enterprise.xml
<gradleEnterprise>
  <buildCache>
    <remote>
      <storeEnabled>true</storeEnabled>
    </remote>
  </buildCache>
</gradleEnterprise>

You can also use the -Dgradle.cache.remote.storeEnabled=true system property to achieve the same effect.

In general, the remote cache should only be populated by controlled build environments such as CI servers. Therefore, the recommendation is to only enable it on the CI server.

Normalization

The following snippet shows you how to ignore any file called META-INF/build.properties on any runtime classpath in the given project. You can share this setting across many projects by putting it in the pluginManagement section of your parent POM. You can use ANT-style patterns like META-INF/*/.sql as well.

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <normalization>
        <runtimeClassPath>
          <ignoredFiles>
            <ignoredFile>META-INF/build.properties</ignoredFile>
          </ignoredFiles>
        </runtimeClassPath>
      </normalization>
    </gradleEnterprise>
  </configuration>
</plugin>

Adding inputs and outputs to a plugin or execution

You can fine-tune the inputs and outputs of goal executions in the <pluginManagement> section of your pom.xml file.

The following input normalization strategies are supported:

IGNORED_PATH

Considers the full content of files, but ignores their path.

NAME_ONLY

Considers the full content of files, but only tracks their name and not the rest of their path.

RELATIVE_PATH

The default strategy. Considers the full content of a file, but only tracks their path relative to their root directory. The root directory is the directory that was added as an input. The path of that root directory itself is ignored.

ABSOLUTE_PATH

Considers the full content of files as well as their absolute path. Using this strategy is strongly discouraged, as the project directory (and thus all absolute paths) are usually different on different machines, which prevents cache hits.

CLASSPATH

Considers only the information relevant for running Java code.

COMPILE_CLASSPATH

Considers only the information relevant for compiling Java code. This means for example that only class files are considered and private implementation details like method bodies are ignored.

The following will add the directory src/test/samples as an input to all executions of the failsafe plugin. Any files in that folder which match the given includes and excludes will then be tracked as part of the cache key:

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <plugins>
        <plugin>
          <artifactId>maven-failsafe-plugin</artifactId>
          <inputs>
            <fileSets>
              <fileSet>
                <name>samples</name>
                <paths>
                  <path>src/test/samples</path>
                </paths>
                <includes>
                    <include>**/*.sample</include>
                </includes>
                <excludes>
                    <exclude>archive/**/*.sample</exclude>
                </excludes>
                <normalization>NAME_ONLY</normalization>
              </fileSet>
            </fileSets>
          </inputs>
        </plugin>
      </plugins>
    </gradleEnterprise>
  </configuration>
</plugin>

You can also configure inputs and outputs for a specific execution of a plugin, without affecting other executions. The following will add the additional output directory ${project.build.directory}/schema to the default-compile execution of the compiler plugin. The contents of this directory will become part of the cache archive for this execution.

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <plugins>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <executions>
            <execution>
              <id>default-compile</id>
              <outputs>
                <directories>
                  <directory>
                    <name>generatedSchema</name>
                    <path>${project.build.directory}/schema</path>
                  </directory>
                </directories>
              </outputs>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </gradleEnterprise>
  </configuration>
</plugin>

Disabling build caching for a plugin or execution

You can disable caching on a fine-grained level in the <pluginManagement> section of your pom.xml file. The following will disable caching for all executions of the failsafe plugin in the given project:

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <plugins>
        <plugin>
          <artifactId>maven-failsafe-plugin</artifactId>
          <outputs>
            <notCacheableBecause>these tests verify integration with other systems and should rerun even if our inputs didn't change</notCacheableBecause>
          </outputs>
        </plugin>
      </plugins>
    </gradleEnterprise>
  </configuration>
</plugin>

You can also disable caching for a specific execution. Other executions of that plugin will then still remain cacheable. The following will disable caching only for the systems-integration-test execution of the failsafe plugin. Other tests will remain cacheable.

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <plugins>
        <plugin>
          <artifactId>maven-failsafe-plugin</artifactId>
          <executions>
            <execution>
              <id>systems-integration-test</id>
              <outputs>
                <notCacheableBecause>these tests verify integration with other systems and should rerun even if our inputs didn't change</notCacheableBecause>
              </outputs>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </gradleEnterprise>
  </configuration>
</plugin>

Making other goals cacheable

The extension allows you to make any goal cacheable, beyond the ones that are supported out of the box. Take great care to define all of the goal’s inputs and outputs before doing so, to avoid false cache hits and follow-up errors.

When making goals cacheable, you don’t need to repeat the values of all their inputs and outputs. You can simply provide the name of each property and the extension will look up the value in the goal’s configuration. The extension will make sure that you have handled all configuration parameters of the goal in this way. If some parameter is irrelevant for the purposes of caching, e.g. because it only affects console output, you can tell the extension to ignore it.

For input properties, the extension supports all primitives, Strings, Enums and Collections, Arrays and Maps of those. Any other types need to be broken down using the nestedProperties (for a single complex type) or iteratedProperties (for a Collection of complex types) configuration.

<plugin>
  <groupId>com.gradle</groupId>
  <artifactId>gradle-enterprise-maven-extension</artifactId>
  <version>1.1.2</version>
  <configuration>
    <gradleEnterprise>
      <plugins>
        <plugin>
          <groupId>my.company</groupId>
          <artifactId>awesome-but-slow-plugin</artifactId>
          <inputs>
            <fileSets>
              <fileSet>
                <name>sources</name>
                <includesProperty>includes</includesProperty>
                <excludesProperty>excludes</excludesProperty>
              </fileSet>
            </fileSets>
            <properties>
              <property>
                <name>encoding</name>
              </property>
            </properties>
            <ignoredProperties>
              <ignore>logWarnings</ignore>
            </ignoredProperties>
            <nestedProperties>
              <property>
                <name>forkOptions</name>
                <inputs>
                  <properties>
                    <property>
                      <name>maxHeap</name>
                    </property>
                  </properties>
                </inputs>
              </property>
            </nestedProperties>
            <iteratedProperties>
              <property>
                <name>targetPlatforms</name>
                <inputs>
                  <properties>
                    <property>
                      <name>architecture</name>
                    </property>
                    <property>
                      <name>linkingMode</name>
                    </property>
                  </properties>
                </inputs>
              </property>
            </iteratedProperties>
          </inputs>
          <outputs>
            <directories>
              <directory>
                <name>outputDir</name>
              </directory>
            </directories>
            <cacheableBecause>this plugin has CPU-bound goals with well-defined inputs and outputs</cacheableBecause>
          </outputs>
        </plugin>
      </plugins>
    </gradleEnterprise>
  </configuration>
</plugin>

Solving problems with build caching

While working with the build cache you may encounter situations where build results are not retrieved from cache although you would expect them to. This section provides guidance for analyzing and solving these problems.

Debugging cache operations

The extension provides several loggers to make analyzing problems with build caching easier. To show the effective cache configuration, use the gradle.goal.cache logger:

$ mvn clean verify -Dorg.slf4j.simpleLogger.log.gradle.goal.cache=debug
[DEBUG] Using the build cache with the following configuration:
  Local build cache: enabled
      directory: /Users/johndoe/.m2/.gradle-enterprise/build-cache
      cleanup: enabled
          retention: 168h
          interval: 24h
  Remote build cache: enabled
      url: https://my-server/cache/
      authenticated: false
      storeEnabled: false
      allowUntrustedServer: false

The gradle.goal.cache logger will also print the result of determining the cacheability of the executed goals:

[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ maven-build-scan-extension-sample ---
[INFO] skip non existing resourceDirectory /Users/johndoe/workspace/maven-build-scan-quickstart/src/main/resources
[DEBUG] Build caching was not enabled for this goal execution because the 'resources' goal was not supported.
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ maven-build-scan-extension-sample ---
[DEBUG] Local cache miss
[DEBUG] Remote cache miss
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /Users/johndoe/workspace/maven-build-scan-quickstart/target/classes
[DEBUG] Stored outputs in the local build cache

All information printed by the gradle.goal.cache can also be viewed in the build scan for that build.

Finding the cause of cache misses

Sometimes you might encounter a situation where a goal execution is not avoided by using the cache although you would expect it to be. For example, if you run the same build twice without any changes, the outputs of all supported goals should be retrieved from the local build cache (if it is enabled). If this is not the case, this almost always is caused by unstable inputs, e.g. a timestamp being added to a file by some build logic. In order to identify which inputs change between builds the Maven build comparison feature can be used. Simply run the same Maven build twice and compare those two builds. To make it easier to find unstable input files capturing of goal input files should be explicitly enabled using -Dgradle.scan.captureGoalInputFiles=true

Capturing goal input files has an impact on build performance. For this reason it is disabled by default.

Once the build scans have been published they can be compared in Gradle Enterprise. In this example, the build was configured to write a timestamp to the build.properties file. When comparing the two builds this shows up nicely in the comparison.

comparison unstable input

Once the changing input is identified, the build can be changed to be reproducable or normalization can be used to ignore the changing input.

Solving common causes of cache misses

Some widely used Maven plugins are a common cause of cache misses because they produce changing build results. This chapter shows you how to solve them.

JAXB

Old versions of the XJC binding compiler generate classes with methods in random order on each invocation. This has been fixed in JAXB 2.2.11. Since there are several Maven plugins available for JAXB, you need to find out which release of the plugin you are using includes the fixed JAXB release. For example the jaxb2-maven-plugin includes the fix starting from release 2.1.

Another cause of unstable build results when using JAXB is the fact that the XJC binding compiler generates a header containing a timestamp into all Java classes. This behavior is controlled by the --no-header option which is false by default (= always generate a header). To prevent this add the corresponding configuration to the Maven plugin you use, for example:

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>jaxb2-maven-plugin</artifactId>
  <version>2.4</version>
  <configuration>
    <noGeneratedHeaderComments>true</noGeneratedHeaderComments>
  </configuration>
</plugin>

If you’re using the maven-jaxb2-plugin it’s still a good idea to remove unnecessary instability from its outputs. However, the Gradle Enterprise Maven Extension supports caching its generate goal even if file headers are being generated. Thus, downstream goals will not be affected by its changing outputs when they are loaded from the cache.

Some of the Maven JAXB plugins generate code based on the current system’s locale if not configured otherwise. This leads to unstable outputs depending on the configuration of the machine that executes the build, which in turn can lead to cache misses. For this reason the locale to use during code generation should be explicitly configured. Both the jaxb2-maven-plugin and the maven-jaxb2-plugin provide a <locale> option for this.

maven-bundle-plugin

By default the maven-bundle-plugin generates a timestamp the MANIFEST.MF file. To prevent this, the configuration of the plugin has to be adjusted:

<plugin>
  <groupId>org.apache.felix</groupId>
  <artifactId>maven-bundle-plugin</artifactId>
  <configuration>
    <archive>
      <addMavenDescriptor>false</addMavenDescriptor>
    </archive>
    <instructions>
      <_removeheaders>Bnd-LastModified</_removeheaders>
    </instructions>
  </configuration>
</plugin>

Note that the underscope in <_removeheaders> is not a typo.

maven-resources-plugin

A common pattern is to write a build timestamp to a build.properties file using Maven resource filtering. One way to fix this is using Normalization to ignore the file. Alternatively the build can be adjusted by moving the generation of the timestamp to a separate profile that is only executed when creating a release:

build.properties
build.timestamp=${timestamp}
pom.xml
<properties>
  <timestamp>2019-03-07 12:00:00.000</timestamp>
</properties>

<build>
  <resources>
    <resource>
      <directory>src/main/resources</directory>
      <filtering>true</filtering>
    </resource>
  </resources>
</build>

<profile>
  <id>release</id>
  <properties>
    <maven.build.timestamp.format>yyyy-MM-dd HH:mm:ss.S</maven.build.timestamp.format>
    <timestamp>${maven.build.timestamp}</timestamp>
  </properties>
</profile>
maven-failsafe-plugin

The maven-failsafe-plugin provides two goals: integration-test and verify. The former runs in the integration-test phase of the build and writes its results to a summary file. The latter runs in the verify phase, reads the summary file, and fails the build in case of test failures.

When configuring multiple Failsafe executions, they use the same output location for the summary file by default. This will prevent all but the first execution of the integration-test goal to be cacheable due to overlapping outputs. In order to get cache hits for all executions, you should configure a different summary file for each of them:

pom.xml
<plugin>
  <artifactId>maven-failsafe-plugin</artifactId>
  <executions>
    <execution>
      <id>first-execution</id>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
      <configuration>
        <!-- ... -->
        <summaryFile>${project.build.directory}/failsafe-reports/first-failsafe-summary.xml</summaryFile>
      </configuration>
    </execution>
    <execution>
      <id>second-execution</id>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
      <configuration>
        <!-- ... -->
        <summaryFile>${project.build.directory}/failsafe-reports/second-failsafe-summary.xml</summaryFile>
      </configuration>
    </execution>
  </executions>
</plugin>

If you have configured multiple executions that execute the same or an overlapping set of test classes (e.g. with different parameters), you should in addition change the reports directory, for example:

pom.xml
<plugin>
  <artifactId>maven-failsafe-plugin</artifactId>
  <executions>
    <execution>
      <id>first-execution</id>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
      <configuration>
        <!-- ... -->
        <reportsDirectory>${project.build.directory}/first-failsafe-reports</reportsDirectory>
        <summaryFile>${project.build.directory}/first-failsafe-reports/failsafe-summary.xml</summaryFile>
      </configuration>
    </execution>
    <execution>
      <id>second-execution</id>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
      <configuration>
        <!-- ... -->
        <reportsDirectory>${project.build.directory}/second-failsafe-reports</reportsDirectory>
        <summaryFile>${project.build.directory}/second-failsafe-reports/failsafe-summary.xml</summaryFile>
      </configuration>
    </execution>
  </executions>
</plugin>

Troubleshooting

Slow build startup in MacOS Sierra after applying Gradle Enterprise Maven extension

An issue with resolving localhost affecting MacOS Sierra can cause a 5 second delay after applying the Gradle Enterprise Maven extension to your build. Until the issue is fixed, there is a workaround that you can apply to your /etc/hosts file. Add these lines to your /etc/hosts file, substituting your computer name for 'mbpro' in the below snippet:

/etc/hosts
127.0.0.1   localhost mbpro.local
::1         localhost mbpro.local

Appendix A: Configuration reference

gradle-enterprise.xml

Most aspects of the Gradle Enterprise Maven extension are configured in the gradle-enterprise.xml configuration file. Some of the options can be overwritten by system properties.

The gradle-enterprise.xml file can be put into several locations. These files are merged and their properties overwritten based on the precedence rules below:

  • <maven-home>/conf/gradle-enterprise.xml is used to set global defaults for a given Maven installation. This is useful when you ship a custom Maven distribution to your teams. The location of this configuration file can be overwritten using the -Dgradle.global.config argument. This can be useful for CI environments where changing the Maven installation is not possible.

  • <project-dir>/.mvn/gradle-enterprise.xml is used for project-specific configuration and overrides the global configuration.

  • <user-home>/.m2/gradle-enterprise.xml is used for user-specific configuration and overrides the project configuration. The location of this configuration file can be overwritten using the -Dgradle.user.config argument. This can be useful for CI environments where changing the user home is not possible.

The example below shows a full reference of everything you can configure in this file.

Be sure to include the XML namespace declarations to get auto-completion in your IDE. You can get a specific schema version by appending the version to the schema location, e.g. https://www.gradle.com/schema/gradle-enterprise-maven-1.0.xsd.

gradle-enterprise.xml
<gradleEnterprise
    xmlns="https://www.gradle.com/gradle-enterprise-maven" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://www.gradle.com/gradle-enterprise-maven https://www.gradle.com/schema/gradle-enterprise-maven.xsd">
  <server>
    <!-- ID used to reference an element in the settings.xml -->
    <id>my-server</id>
    <!-- Address of the Gradle Enterprise server. System property is 'gradle.enterprise.url'. -->
    <url>http://my-server/</url>
    <!-- Whether untrusted connections to the Gradle Enterprise server should be accepted. Defaults to false. -->
    <allowUntrusted>false</allowUntrusted>
  </server>
  <buildScan>
    <!-- Behavior of publishing build scans. Possible values are ALWAYS, ON_FAILURE, ON_DEMAND. Defaults to ALWAYS. -->
    <publish>ALWAYS</publish>
    <!-- Terms of service acceptance (mandatory to publish to scans.gradle.com) -->
    <termsOfService>
      <!-- Address of the terms of service. Must be 'https://gradle.com/terms-of-service'. Defaults to an empty string. -->
      <url></url>
      <!-- Signal acceptance of the terms of service. Must be 'true'. Defaults to false. -->
      <accept>false</accept>
    </termsOfService>
    <!-- Whether to capture content hashes of each input file for build scan comparison. Defaults to false. System property is 'gradle.scan.captureGoalInputFiles' -->
    <captureGoalInputFiles>true</captureGoalInputFiles>
    <!-- List of tags to capture -->
    <tags>
      <tag>my tag</tag>
    </tags>
    <!-- List of links to capture -->
    <links>
      <link>
        <name>my link</name>
        <url>http://my-site.com</url>
      </link>
    </links>
    <!-- List of custom values to capture -->
    <values>
      <value>
        <name>my name</name>
        <value>my value</value>
      </value>
    </values>
  </buildScan>
  <buildCache>
    <!-- Local cache configuration -->
    <local>
      <!-- Whether the local cache is enabled. Defaults to true. System property is 'gradle.cache.local.enabled'. -->
      <enabled>true</enabled>
      <!-- Local cache directory. Defaults to ${user.home}/.m2/.gradle-enterprise/build-cache. System property is 'gradle.cache.local.directory'. -->
      <directory>/some/other/location</directory>
      <!-- Local cache cleanup configuration -->
      <cleanup>
        <!-- Whether local cache cleanup is enabled. Defaults to true. System property is 'gradle.cache.local.cleanup.enabled'. -->
        <enabled>true</enabled>
        <!-- Items in the cache that were not used in this period will be deleted. Defaults to P7D. System property is 'gradle.cache.local.cleanup.retention'. -->
        <retention>P30D</retention>
        <!-- Interval at which the cleanup occurs. Defaults to P1D. System property is 'gradle.cache.local.cleanup.interval'. -->
        <interval>P10D</interval>
      </cleanup>
    </local>
    <!-- Remote cache configuration -->
    <remote>
      <!-- Remote cache server configuration -->
      <server>
        <!-- Optionally use the ID of a server specified in your settings.xml to use its credentials. System property is 'gradle.cache.remote.serverId'. -->
        <id>remote-cache</id>
        <!-- URL of the remote cache. Defaults to ${gradle.enterprise.url}/cache/. System property is 'gradle.cache.remote.url'. -->
        <url>http://my-node/cache/</url>
        <!-- Whether the remote cache accepts untrusted connections. Defaults to false. System property is 'gradle.cache.remote.allowUntrustedServer'. -->
        <allowUntrusted>true</allowUntrusted>
      </server>
      <!-- Whether the remote cache is enabled. Defaults to true. System property is 'gradle.cache.remote.enabled'. -->
      <enabled>true</enabled>
      <!-- Whether to store outputs in the remote build cache (as opposed to only loading from it). Defaults to false. System property is 'gradle.cache.remote.storeEnabled'. -->
      <storeEnabled>true</storeEnabled>
    </remote>
  </buildCache>
</gradleEnterprise>

In order to use an authenticated Gradle Enterprise server, the credentials for that server have to be configured in the settings.xml file. You can also use Maven’s password encryption feature to safely store these credentials.

<user-home>/.m2/settings.xml
<servers>
  <server>
    <id>my-server</id>
    <username>username</username>
    <password>password</password>
  </server>
</servers>

pom.xml

The Gradle Enterprise Maven extension also allows you to configure module-specific aspects in the corresponding pom.xml file. This allows you to share common configuration between your project by putting it in a parent POM. See the example below for a full reference.

In order to get auto-completion in your IDE, be sure to include the XML namespace and schema location as shown in the example below. You can get a specific schema version by appending the version to the schema location, e.g. https://www.gradle.com/schema/gradle-enterprise-maven-project-1.0.xsd. Please note that this is currently only supported by Eclipse. For IntelliJ IDEA, there’s an open issue to add such a feature.

pom.xml
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd
        https://www.gradle.com/gradle-enterprise-maven-project https://www.gradle.com/schema/gradle-enterprise-maven-project.xsd">

...

<pluginManagement>
  <plugins>
    <plugin>
      <groupId>com.gradle</groupId>
      <artifactId>gradle-enterprise-maven-extension</artifactId>
      <version>1.1.2</version>
      <configuration>
        <gradleEnterprise xmlns="https://www.gradle.com/gradle-enterprise-maven-project">
          <normalization>
            <runtimeClassPath>
              <ignoredFiles>
                <ignoredFile>META-INF/build.properties</ignoredFile>
              </ignoredFiles>
            </runtimeClassPath>
          </normalization>
          <plugins>
            <!-- an example of adding more details to an already cacheable plugin -->
            <plugin>
              <artifactId>maven-failsafe-plugin</artifactId>
              <inputs>
                <fileSets>
                  <fileSet>
                    <name>samples</name>
                    <paths>
                      <path>src/test/samples</path>
                    </paths>
                    <includes>
                        <include>**/*.sample</include>
                    </includes>
                    <excludes>
                        <exclude>archive/**/*.sample</exclude>
                    </excludes>
                    <normalization>NAME_ONLY</normalization>
                  </fileSet>
                </fileSets>
              </inputs>
              <outputs>
                <files>
                  <file>
                    <name>summary</name>
                    <path>target/test-results/summary.txt</path>
                  </file>
                </files>
                <directories>
                  <directory>
                    <name>screenshots</name>
                    <path>target/test-results/screenshots</path>
                  </directory>
                </directories>
                <notCacheableBecause>these tests verify integration with other systems and should rerun even if our inputs didn't change</notCacheableBecause>
              </outputs>
              <localState>
                <fileSets>
                    <fileSet>
                        <name>someTemporaryStuff</name>
                        <paths>
                            <path>target/myTestFramework/tmp</path>
                        </paths>
                    </fileSet>
                </fileSets>
              </localState>
            </plugin>
            <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <executions>
                <execution>
                  <id>default-compile</id>
                  <inputs>
                    <!-- same as above -->
                  </inputs>
                  <outputs>
                    <!-- same as above -->
                  </outputs>
                  <localState>
                  <!-- same as above -->
                  </localState>
                </execution>
              </executions>
            </plugin>
            <!-- an example of making a custom plugin cacheable -->
            <plugin>
              <groupId>my.company</groupId>
              <artifactId>awesome-but-slow-plugin</artifactId>
              <inputs>
                <fileSets>
                    <fileSet>
                        <name>sources</name>
                        <includesProperty>includes</includesProperty>
                        <excludesProperty>excludes</excludesProperty>
                    </fileSet>
                </fileSets>
                <properties>
                    <property>
                        <name>encoding</name>
                    </property>
                <properties>
                <ignoredProperties>
                    <ignore>logWarnings</ignore>
                </ignoredProperties>
                <nestedProperties>
                    <property>
                        <name>forkOptions</name>
                        <inputs>
                            <properties>
                                <property>
                                    <name>maxHeap</name>
                                </property>
                            <properties>
                         </inputs>
                    </property>
                </nestedProperties>
                <iteratedProperties>
                    <property>
                        <name>targetPlatforms</name>
                        <inputs>
                            <properties>
                                <property>
                                    <name>architecture</name>
                                </property>
                                <property>
                                    <name>linkingMode</name>
                                </property>
                            <properties>
                         </inputs>
                    </property>
                </iteratedProperties>
              </inputs>
              <outputs>
                <directories>
                    <directory>
                        <name>outputDir</name>
                    </director>
                </directories>
                <cacheableBecause>this plugin has CPU-bound goals with well-defined inputs and outputs</cacheableBecause>
              </outputs>
              <localState>
                <fileSets>
                    <fileSet>
                        <name>tempDir</name>
                    </fileSet>
                </fileSets>
              </localState>
            </plugin>
          </plugins>
          <buildScan>
            <tags>
              <tag>my tag</tag>
            </tags>
            <links>
              <link>
                <name>my link</name>
                <url>http://my-site.com</url>
              </link>
            </links>
            <values>
              <value>
                <name>Build Number</name>
                <value>${project.buildNumber}</value>
              </value>
            </values>
          </buildScan>
        </gradleEnterprise>
      </configuration>
    </plugin>
  </plugins>
</pluginManagement>

Appendix B: API reference

Please see the Javadoc.

Appendix C: Build scans captured information

The Gradle Enterprise Maven extension captures information while the build is running and transmits it to a server after the build has completed.

Most of the information captured can be considered to be build data. This includes the name of the projects in your build, the executed goals, plugins and other things of this nature. Some more general environmental information is also captured. This includes your Java version, operating system, hardware, country, timezone and other things of this nature.

Notably, the actual source code being built and the output artifacts are not captured. However, error messages emitted by compilers or errors in tests may reveal aspects of the source code.

Listing

The list below details the notable information captured by the Gradle Enterprise Maven extension and transmitted in a build scan.

  • Environment

    • Username (system property 'user.name')

    • Local hostname (environment variable 'COMPUTERNAME' / 'HOSTNAME')

    • Public hostname

    • IP addresses

    • Build Java Virtual Machine

    • Operating System

    • Hardware

  • Build

    • Maven command-line and invocation options (e.g. requested phases and goals, switches)

    • Build failure exception messages and stacktraces

    • Projects

    • Executed goals

    • Applied plugins

    • Build cache configuration

Access

Build scans published to a Gradle Enterprise installation are viewable by all users that can reach the server and have the required roles, should Identity Access Management (IAM) be turned on. Gradle Enterprise provides a search interface for discovering and finding individual build scans.

Build scans published to scans.gradle.com are viewable by anyone with the link assigned when publishing the build scan. Links to individual build scans are not discoverable and cannot be guessed, but may be shared.

Appendix D: Cacheable plugins and goals

The extension caches the following plugins and goals out of the box. Unless otherwise noted, all their parameters are tracked as part of the cache key.

maven-compiler-plugin

Supported versions: 3.1 and above

Supported goals:

  • compile

  • testCompile

Caching is automatically disabled if:

  • a non-javac toolchain is used

The following use cases currently require disabling the cache for this plugin:

  • using annotation processors that read files outside of Maven’s resource directories

  • using annotation processors that generate sources outside of Maven’s generated sources directory

  • using any non-deterministic annotation processors

Compile avoidance

Unless there are annotation processors on the classpath, the extension uses compile avoidance so your sources are only recompiled if the signatures of the classes on the compile classpath have changed.

maven-surefire-plugin and maven-failsafe-plugin

Supported versions: 2.12.4 and above

Supported goals:

  • surefire:test

  • failsafe:integration-test

Caching is automatically disabled if:

The following use cases currently require disabling the cache for these plugins:

  • non-deterministic tests (e.g. tests with random parameters)

  • tests that read files that are not on the test classpath (e.g. new File("src/test/samples"))

  • tests that write additional results that you absolutely need (e.g. screenshots for failed UI tests)

  • tests that read environment variables that are not explicitly declared using the <environmentVariables> property

  • tests that use Java agents that read additional inputs or create additional outputs, except for JaCoCo, which is explicitly supported

The following properties are deliberately not tracked as inputs, because they should not influence the test result:

jacoco-maven-plugin

Supported versions: 0.5 and above

Supported goals:

  • none of JaCoCo’s own goals are cached

  • surefire and failsafe remain cacheable when JaCoCo is used

Caching is automatically disabled if:

The JaCoCo plugin hooks into surefire and failsafe as a Java agent. The extension automatically tracks all JaCoCo agent options when determining the cache key for surefire and failsafe tests. The JaCoCo execution data file is cached as an additional output of the test execution.

maven-jaxb2-plugin (org.jvnet.jaxb2.maven2)

Supported plugin artifact ids:

  • maven-jaxb2-plugin

  • maven-jaxb20-plugin

  • maven-jaxb21-plugin

  • maven-jaxb22-plugin

  • maven-jaxb23-plugin

Supported versions: 0.12.3 and above

Supported goals:

  • generate

Caching is automatically disabled if:

  • a non-local URL is used to declare a catalog, schema, or binding

The following use cases currently require disabling the cache for these plugins:

  • non-local URL references to schemas or bindings with changing content from within schema or binding files

The following properties are deliberately not tracked as inputs, because they should not influence the result of code generation:

  • logging settings (verbose)

  • proxy settings (proxyHost, proxyPort, proxyUsername, proxyPassword, useActiveProxyAsHttpproxy)

  • settings for the plugin’s up-to-date check and incremental build feature (forceRegenerate, removeOldOutput, produces, cleanPackageDirectories)

maven-javadoc-plugin

Supported versions: 2.7 and above

Supported goals:

  • javadoc:javadoc

  • javadoc:javadoc-no-fork

  • javadoc:test-javadoc

  • javadoc:test-javadoc-no-fork

  • javadoc:jar

  • javadoc:test-jar

Caching is automatically disabled if:

The following properties are deliberately not tracked as inputs, because they should not influence the javadoc output:

maven-checkstyle-plugin

Supported versions: 2.14 and above

Supported goals:

  • check

  • checkstyle

  • checkstyle-aggregate

Caching is automatically disabled if:

The following properties are deliberately not tracked as inputs, because they do not influence the outcome of the goal:

Absolute paths in output files are ignored

Checkstyle’s output files contain absolute paths that are deliberately ignored by the extension. Thus, when loading the goal’s outputs from cache, the referenced paths might not exist on the machine that is executing the build. In case that’s problematic for you, please disable the cache for this goal.

Appendix E: Anatomy of the .gradle-enterprise directory

By default, the Gradle Enterprise Maven extension stores temporary data in the ${user.home}/.m2/.gradle-enterprise directory. The location can be customized by setting the gradle.enterprise.storage.directory system property:

$ mvn clean verify -Dgradle.enterprise.storage.directory=/path/to/.gradle-enterprise

The directory may contain the following subdirectories:

build-cache

Location of the local build cache

build-cache-tmp

Temporary directory for loading and storing entries in the remote build cache in case the local build cache is disabled

build-scan-data

Data collected to create build scans

token-cache

Location of the entitlement tokens

The .gradle-enterprise directory is an internal directory and subject to change without warning.

Appendix F: Gradle Enterprise Maven Extension release history

1.1.2 - 17th May 2019

  • Fixed a bug which resulted in wrong event order caused by system clock adjustments

  • Fix handling of ** in include patterns of supported goals and custom input declarations

1.1.1 - 12th May 2019

  • Read project-specific gradle-enterprise.xml from same .mvn directory that Maven uses to read extensions.xml

1.1 - 3rd May 2019

  • Output of javadoc:aggregate is cached for maven-javadoc-plugin:2.7+

  • Output of javadoc:aggregate-jar is cached for maven-javadoc-plugin:2.7+

  • Output of javadoc:aggregate-no-fork is cached for maven-javadoc-plugin:2.7+

  • Output of javadoc:test-aggregate is cached for maven-javadoc-plugin:2.7+

  • Output of javadoc:test-aggregate-jar is cached for maven-javadoc-plugin:2.7+

  • Output of javadoc:test-aggregate-no-fork is cached for maven-javadoc-plugin:2.7+

  • Maven log no longer disappears when extension is applied twice

  • Skipped cacheable goals are reported as "skipped" instead of "not cacheable"

  • Local cache issues fail the build instead of logging a warning

  • Extension only snapshots input files that match given include/exclude patterns

  • Fix NullPointerException when trying to resolve a non-existing plugin without version

  • Parallel forked goal executions are captured correctly in build scans

  • Capture finer-grained fingerprint events

1.0.8 - 18th April 2019

  • Fix handling of null-valued system properties.

  • Prevent non existing javadoc jars from being attached.

  • java.io.tmpdir is ignored in surefire systemProperties/systemPropertyVariables.

1.0.7 - 17th April 2019

  • Output of javadoc:test-jar is cached for maven-javadoc-plugin:2.7+.

  • Output of javadoc:jar is cached for maven-javadoc-plugin:2.7+.

  • Output of javadoc:test-javadoc-no-fork is cached for maven-javadoc-plugin:2.7+.

  • Output of javadoc:test-javadoc is cached for maven-javadoc-plugin:2.7+.

  • Output of javadoc:javadoc-no-fork is cached for maven-javadoc-plugin:2.7+.

  • Output of javadoc:javadoc is cached for maven-javadoc-plugin:2.7+.

  • Output of generate goal is cached for maven-jaxb2-plugin:0.12.3+.

  • Output of checkstyle:check is cached for maven-checkstyle-plugin:2.14+.

  • Output of checkstyle:checkstyle is cached for maven-checkstyle-plugin:2.14+.

  • Output of checkstyle:checkstyle-aggregate is cached for maven-checkstyle-plugin:2.14+.

  • Protect against double applications.

  • Protect against event notifications received before initialization (workaround for MNG-6619).

  • Handle more absolute paths in JVM arguments out of the box.

  • Broken java executables make goals non-cacheable instead of failing the build.

  • System properties now overwrite values in gradle-enterprise.xml.

  • Allow same file to appear in multiple output locations (e.g. the summaryFile of the maven-failsafe-plugin).

  • User can add additional inputs and outputs to goal executions using the pom.xml DSL.

  • Command line arguments are normalized, removing all known input and output paths from them to allow relocation.

  • Caching is deactivated for goals that contain undeclared file paths in their input properties (e.g. JVM args).

1.0.6 - 26th March 2019

  • Add support for code completion of publishMode in gradle-enterprise.xml.

  • Support broken JARs in annotation processor detection.

1.0.5 - 20th March 2019

  • Only fingerprints for external jars are stored in the build cache.

  • Surefire statistics file and tempDir are tracked as local state.

  • Performance improvements for jar fingerprinting and cache load operations.

  • More helpful error message for invalid build scan publishing mode configuration.

1.0.4 - 15th March 2019

  • Fix ID generation for build cache events.

  • Jar fingerprints are stored in the build cache.

1.0.3 - 12th March 2019

  • Fix hashing of build cache operations, that was leading to event ID collisions.

  • Support a proxy server when publishing build scans.

  • Prevent publishing build scans when there is no entitlement.

1.0.2 - 6th March 2019

  • Runtime classpath normalization recursively inspects WAR, EAR, ZIP and APK files.

  • Track runOrder as input property for the maven-surefire-plugin and maven-failsafe-plugin.

  • Fix project capturing to respect <module> declarations.

1.0.1 - 1st March 2019

  • Restore compatibility with Maven < 3.5.2.

  • Enhance console output of terms of services.

1.0 - 28th February 2019

Initial Release.

Appendix G: Gradle Enterprise Maven Extension compatibility with Apache Maven and Gradle Enterprise

Compatibility between versions of Apache Maven, Gradle Enterprise, and the Gradle Enterprise Maven extension can be found here.