Gradle Build Scans i analizy

Imagine having a super detailed report card for your Gradle build! That's essentially what a Gradle Build Scan is.

It's a comprehensive, shareable, and interactive web report that captures everything about your build execution.

• Performance: How long tasks take.
• Dependencies: What libraries your project uses.
• Tests: Results of your automated tests.
• Environment: Details about the system running the build.

Build Scans are incredibly useful for:

• Debugging: Quickly pinpoint why a build failed or behaved unexpectedly.
• Performance Optimization: Identify slow tasks or configuration issues that are slowing down your build.
• Collaboration: Easily share build details with teammates, support, or maintainers without sending large log files.
• Consistency: Understand differences between local and CI builds.

To start generating Build Scans, you need to apply the Build Scan plugin to your project's root build.gradle or settings.gradle file.

It's typically applied in the plugins block.

Remember to replace '3.16.2' with the latest stable version.

Once the plugin is applied, generating a Build Scan is simple! Just add the --scan flag when you run any Gradle command from your terminal.

For example, to build your project and generate a scan:

The first time you run it, Gradle will ask for your consent to publish the scan. Type "yes" to proceed.

After a successful (or even failed) build with --scan, Gradle will print a unique URL to your console. This is your Build Scan report!

Open this URL in your web browser to explore the interactive report. It's hosted securely on scans.gradle.com.

The "Performance" tab in a Build Scan is a treasure trove for optimization. Here, you can see:

• Task Execution: A detailed timeline of every task, showing its duration.
• Configuration Time: How long Gradle spends configuring your project.
• Build Cache Savings: If and how much time was saved by using the build cache (covered in a later lesson!).

Use this to identify bottlenecks and slow tasks.

Within the "Tasks" section, you can drill down into individual tasks. This shows:

• Task Type: What kind of task it is (e.g., JavaCompile, Test).
• Inputs/Outputs: Files or directories consumed and produced.
• Execution Reason: Why the task ran (e.g., inputs changed, no build cache hit).

This helps understand task behavior and debug non-incremental builds.

Build Scans also provide vital context:

• Dependencies: Lists all resolved dependencies, their versions, and configurations. Crucial for debugging dependency conflicts.
• Environment: Details about the operating system, Java Virtual Machine (JVM) version, Gradle version, and even environment variables.

These sections help ensure builds are reproducible and consistent across different environments.

The generated Build Scan URL can be easily shared with anyone. This is great for collaboration!

By default, Build Scans include a lot of detail. If you need more control over what's published, you can use:

• --scan --publish-quiet: Publishes without asking for consent.
• Configure the plugin to exclude sensitive data.

Always be mindful of what information you're sharing.

You've learned about Gradle Build Scans and their capabilities. Let's check your understanding.

In this lesson, you learned about Gradle Build Scans.

• They provide interactive web reports for your Gradle builds.
• You enable them with the com.gradle.build-scan plugin.
• Generate them using the --scan flag.
• They offer deep insights into performance, tasks, dependencies, tests, and environment.
• Build Scans are powerful tools for debugging, optimizing, and collaborating on Gradle projects.

Keep exploring your builds with Build Scans!