Getting Started with Develocity for Apache Maven™ users

Execute the init goal to quickly set up the Develocity Maven extension on a Maven project:

See here for more information.

Apply the Develocity Maven extension to your build by adding the following configuration block to a new or existing .mvn/extensions.xml file in your Maven project. Maven automatically downloads the extension from Maven Central when you run your build.

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 Develocity to be available to all your projects out of the box.

The extension is configured through one or more develocity.xml files and the pluginManagement sections of your pom.xml files. Similarly to the extensions.xml file, the develocity.xml file can be placed in your Maven project’s .mvn directory. Unless you intend to publish build scans to scans.gradle.com, the minimum configuration required is the Develocity server URL.

More detailed information about the Develocity Maven extension can be found in the Develocity Maven extension user manual.

Search through all the captured build scans by going to https://develocity.mycompany.com/scans.

This view allows searching by various criteria, including top-level project name, user name, build outcome, build start time and more. By default, the list is sorted to show the most recent scans first.

Beyond looking for a particular build scan, the listing can provide new insights into the actual builds being run at your organization and by your colleagues. You may find occurrences of previously unknown errors with your build, or that the build is taking longer in certain cases than you expected, or that certain build users are executing more goals than they need to and are therefore subjecting themselves to more build time than they need to, and other previously unknown behaviors.

A key benefit of build scans are the various insights they provide into build performance. Many builds provide different functions for different people and will perform differently on different machines. Having deep performance insights available for every build enables optimizing all corners of the build, for all users.

Use the left navigation menu to visit the Performance section.

The different tabs focus on different aspects of performance, with the first Build tab providing a high level build time breakdown and memory information.

The Execution plan tab provides an interactive breakdown of the time spent preparing the execution plan of the projects participating in the build. The time shown for each project is the time taken before starting to execute the goals of the project. The most common contributor for a project is downloading plugins and dependencies.

The Dependency resolution tab provides shows insights about e.g. the dependency resolution for a given project or a given plugin. It also shows the size of the dependencies and if its resolution failed.

The Goal execution tab provides a concise breakdown of the goals that participated in the build, grouped by outcome. This provides a high level view of goal execution and can be used to understand build caching coverage for a particular build.

The Build Cache tab displays the Build Cache configuration for the build (e.g. whether a remote Build Cache was used), and lists the individual Build Cache operations and how long they took. This is particularly useful for analyzing the performance of the remote Build Cache connection and identifying whether a slow connection is having adverse effects on the build time.

The dedicated Timeline section (available via the left navigation menu) provides an alternative view onto the goal executions.

This view provides more detail on individual goals (click the icon when hovering over a goal execution).

Build scans make it easy to see which goals are cacheable, and why those that aren’t, aren’t. For instance, the surefire:test goal is cacheable for version 2.12.4 and above of the maven-surefire-plugin.

The Timeline section allows filtering of goal executions via certain criteria, one of which is cacheability.

This is useful when starting with build caching, and as your projects change and evolve, to ensure that you are getting the most out of the Build Cache.

Develocity provides the ability to compare aspects of two build scans.

To compare two scans, use the scan list to find the scans to compare, selecting them by clicking the respective or icon. Or, from a scan that you wish to compare with another, click the Compare Build Scan on the left navigation menu.

The goal inputs comparison is particularly effective in helping diagnose issues with build caching, particularly cases where reuse was expected but didn’t occur. In such cases, it is common that a non obvious input has actually changed which is preventing reuse. By comparing the inputs of the goal execution from the builds where reuse was expected, the exact input property with a different value between the builds is immediately apparent.

When goal execution outputs are reused in a build, due to build caching, the build scan for that build provides links to the build scan of the origin build.

This feature can be used to provide an audit trail of build outputs, and for validating reuse. It is particularly useful for identifying and diagnosing incorrect reuse, which is typically caused by under declaration of goal inputs. In such cases, the build scan for the origin build can be used to determine the actual input state for cross referencing with the build scan that incorrectly reused the outputs.

To see this feature in action, create two build scans where one reuses output from another. The simplest way to do this is by running exactly the same build twice. View the build scan for the subsequent build and open the timeline visualization. Click on the icon of any goal that was FROM-CACHE, and click the View origin Build Scan link to view the build scan for the build that produced the reused outputs.

The build scan plugin can be configured to publish a build scan for every build invocation, or, always publishing if certain programmatically defined criteria are met, or, always publishing if the build fails. The dedicated Develocity Maven extension user manual provides a section outlining how to do this.

It is strongly recommended to configure your builds to always publish build scans, for every build. Collecting build scans for every build yields deeper visibility and insights into how your build is performing and is being used, as well as making features such as tracing reused task outputs more effective.

Build scans can be enriched with metadata particular to your environment by several means.

Extending your build scans with tags, values and links is strongly recommended. In particular:

This adds useful context to your build scans.

The Gradle Jenkins plugin prominently displays links to the Build Scan for any Gradle or Maven build that produce build scans, which makes it convenient to access the build scans. See the following screenshot for an example:

Besides that, the plugin allows you to instrument all CI jobs and to publish a Build Scan without modifying the underlying projects. This eases the adoption of build scans within the company and allows configuring the Develocity Gradle plugin or Develocity Maven extension in a central place. For more information please read the documentation here.

The TeamCity Build Scan plugin prominently displays links to the Build Scan for any Gradle or Maven build that produce build scans, which makes it convenient to access the build scans. See the following screenshot for an example:

Besides that, the plugin allows you to instrument all CI jobs and to publish a Build Scan without modifying the underlying projects. This eases the adoption of build scans within the company and allows configuring the Develocity Gradle plugin or Develocity Maven extension in a central place. For more information please read the documentation here.

The Develocity Bamboo plugin prominently displays links to the Build Scan for any Gradle or Maven build that produce build scans, which makes it convenient to access the build scans. See the following screenshot for an example:

Besides that, the plugin allows you to instrument all CI jobs and to publish a Build Scan without modifying the underlying projects. This eases the adoption of build scans within the company and allows configuring the Develocity Gradle plugin or Develocity Maven extension in a central place. For more information please read the documentation here.

The Develocity GitLab templates allow you to instrument CI jobs and to publish a Build Scan without modifying the project’s build scripts. This eases the adoption of build scans within the company and allows configuring the Develocity Gradle plugin or Develocity Maven extension at the CI level. For more information please read the documentation here.

Reading the dedicated Maven build caching guide is strongly recommended. This guide provides detailed information about build caching in general, including considerations for using it in practice. It also covers how to debug and optimize Build Cache usage using build scans.

The best roll out strategy depends on your circumstances. A common strategy however is to first enable Build Cache usage only for CI builds, then later enabling for local development builds. The Build Cache configuration within a build can be specified dynamically, supporting this kind of usage.

For instance, you can define the -Dgradle.user.config system property on your CI builds to indicate the location of the develocity.xml file that needs to be used in this case or you can utilize the extension support to conditionally apply configuration only on CI. If you need to roll out the extension to lots of projects, consider creating your own extension to bundle the necessary configuration in a central place.

Enabling build scans for any build using the remote Build Cache should be considered a prerequisite. Build scan insights make it considerably easier to debug and optimize Build Cache usage.