feat(gradle): add timestamp

nrwl · Feb 12, 2025 · 077bd35 · 077bd35
1 parent f6b3ab1
commit 077bd35
Show file tree

Hide file tree

Showing 5 changed files with 63 additions and 23 deletions.
diff --git a/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/CreateNodesTask.kt b/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/CreateNodesTask.kt
@@ -9,6 +9,7 @@ import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import java.io.File
 import javax.inject.Inject
+import java.util.Date
 
 @CacheableTask
 abstract class CreateNodesTask @Inject constructor(private val projectLayout: ProjectLayout) : DefaultTask() {
@@ -30,17 +31,18 @@ abstract class CreateNodesTask @Inject constructor(private val projectLayout: Pr
 
     @TaskAction
     fun action() {
+        logger.info("${Date()} Apply task action CreateNodesTask for ${projectName.get()}")
         val project = projectRef.get() // Get project reference at execution time
         val report = createNodeForProject(project) // Compute report at execution time
         val reportJson = gson.toJson(report)
 
 
         if (outputFile.exists() && outputFile.readText() == reportJson) {
-            logger.info("No change in the node report for ${projectName.get()}")
+            logger.info("${Date()} No change in the node report for ${projectName.get()}")
             return
         }
 
-        logger.info("Writing node report for ${projectName.get()}")
+        logger.info("${Date()} Writing node report for ${projectName.get()}")
         outputFile.writeText(reportJson)
     }
 }
diff --git a/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/NodesPlugin.kt b/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/NodesPlugin.kt
@@ -3,12 +3,19 @@ package dev.nx.gradle.native
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskProvider
+import java.util.Date
 
 class NodesPlugin : Plugin<Project> {
     override fun apply(project: Project) {
-        project.logger.info("Applying NodesPlugin to ${project.name}")
+        project.logger.info("${Date()} Applying NodesPlugin to ${project.name}")
 
-        // Register the task lazily, only configuring execution inputs
+        // Skip applying the plugin inside buildSrc to avoid unnecessary overhead
+        if (project.rootProject.name == "buildSrc") {
+            project.logger.info("${Date()} Skipping NodesPlugin configuration inside buildSrc")
+            return
+        }
+
+        // Lazily register the task without forcing realization
         val createNodesTask: TaskProvider<CreateNodesTask> =
                 project.tasks.register("createNodesLocal", CreateNodesTask::class.java) { task ->
                     task.projectName.set(project.name)
@@ -17,29 +24,41 @@ class NodesPlugin : Plugin<Project> {
                     task.description = "Create nodes and dependencies for Nx"
                     task.group = "Nx Custom"
 
-                    task.logger.info("Registered createNodes for ${project.name}")
-
-                    // Ensure all included builds are processed only once
-                    project.gradle.includedBuilds.distinct().forEach { includedBuild ->
-                        task.dependsOn(includedBuild.task(":createNodesLocal"))
+                    // Avoid logging during configuration phase
+                    task.doFirst {
+                        it.logger.info("${Date()} Running createNodesLocal for ${project.name}")
                     }
                 }
 
-        // Add a finalizer task to ALWAYS print the file path
-        project.tasks.register("createNodes") { task ->
-            task.dependsOn(createNodesTask) // Ensure it runs AFTER createNodesTask
+        // Ensure all included builds are processed only once using lazy evaluation
+        project.gradle.includedBuilds.distinct().forEach { includedBuild ->
+            createNodesTask.configure {
+                it.dependsOn(includedBuild.task(":createNodesLocal"))
+            }
+        }
 
+        // Register a finalizer task lazily
+        project.tasks.register("createNodes").configure { task ->
+            task.dependsOn(createNodesTask) // Ensure it runs AFTER createNodesTask
             task.description = "Print nodes report for Nx"
             task.group = "Nx Custom"
 
+            // Use lazy evaluation to avoid realizing the task early
+            val outputFileProvider = createNodesTask.map { it.outputFile }
+
+            task.doFirst {
+                it.logger.info("${Date()} Running createNodes for ${project.name}")
+            }
+
             task.doLast {
-                val outputFile = createNodesTask.get().outputFile
-                println(outputFile.path) // This will run even if createNodesTask is skipped
+                println(outputFileProvider.get().path) // This ensures lazy evaluation
             }
+        }
 
-            // Ensure all included builds are processed only once
-            project.gradle.includedBuilds.distinct().forEach { includedBuild ->
-                task.dependsOn(includedBuild.task(":createNodes"))
+        // Ensure all included builds are processed only once using lazy evaluation
+        project.gradle.includedBuilds.distinct().forEach { includedBuild ->
+            project.tasks.named("createNodes").configure {
+                it.mustRunAfter(includedBuild.task(":createNodes"))
             }
         }
     }

diff --git a/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/utils/ProjectUtils.kt b/packages/gradle/native/src/main/kotlin/dev/nx/gradle/native/utils/ProjectUtils.kt
@@ -2,13 +2,14 @@ package dev.nx.gradle.native.utils
 
 import dev.nx.gradle.native.data.*
 import org.gradle.api.Project
+import java.util.Date
 
 /**
  * Loops through a project and populate dependencies and nodes for each target
  */
 fun createNodeForProject(project: Project): GradleNodeReport {
     val logger = project.logger
-    logger.info("createNodeForProject: get nodes and dependencies for ${project.name}")
+    logger.info("${Date()} createNodeForProject: get nodes and dependencies for ${project.name}")
 
     // Initialize dependencies with an empty Set to prevent null issues
     val dependencies: Set<Dependency> = try {
@@ -32,7 +33,7 @@ fun createNodeForProject(project: Project): GradleNodeReport {
         )
         nodes = mapOf(projectRoot to projectNode)
         externalNodes = gradleTargets.externalNodes
-        logger.info("CreateNodes: get nodes and external nodes for $projectRoot")
+        logger.info("${Date()}  CreateNodes: get nodes and external nodes for $projectRoot")
     } catch (e: Exception) {
         logger.info("${project.name}: get nodes error: ${e.message}")
         nodes = emptyMap()
@@ -62,7 +63,7 @@ fun processTargetsForProject(
 
     val logger = project.logger
 
-    logger.info("${project}: process targets")
+    logger.info("${Date()} ${project}: process targets")
 
     var gradleProject = project.buildTreePath
     if (!gradleProject.endsWith(":")) {
@@ -71,7 +72,7 @@ fun processTargetsForProject(
 
     project.tasks.forEach { task ->
         try {
-            logger.info("Processing $task")
+            logger.info("${Date()} Processing $task")
             // add task to target groups
             val group: String? = task.group
             if (!group.isNullOrBlank()) {

diff --git a/packages/gradle/src/plugin/utils/get-create-nodes-lines.ts b/packages/gradle/src/plugin/utils/get-create-nodes-lines.ts
@@ -1,4 +1,4 @@
-import { AggregateCreateNodesError, logger } from '@nx/devkit';
+import { AggregateCreateNodesError, logger, output } from '@nx/devkit';
 import { execGradleAsync, newLineSeparator } from '../../utils/exec-gradle';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
@@ -28,7 +28,7 @@ export async function getCreateNodesLines(
       '--build-cache',
       '--warning-mode',
       'none',
-      process.env.VERBOSE ? '--info' : '',
+      process.env.NX_VERBOSE_LOGGING ? '--info' : '',
     ]);
   } catch (e) {
     throw new AggregateCreateNodesError(
@@ -46,6 +46,13 @@ export async function getCreateNodesLines(
       []
     );
   }
+
+  if (process.env.NX_VERBOSE_LOGGING === 'true') {
+    output.log({
+      title: `Successfully ran 'createNodes' task using ${gradlewFile} with hash ${gradleConfigHash}`,
+      bodyLines: createNodesBuffer.toString().split(newLineSeparator),
+    });
+  }
   return createNodesBuffer
     .toString()
     .split(newLineSeparator)

diff --git a/packages/gradle/src/plugin/utils/get-nodes-from-gradle-plugin.ts b/packages/gradle/src/plugin/utils/get-nodes-from-gradle-plugin.ts
@@ -112,11 +112,22 @@ export async function populateNodes(
       createNodesLines: Promise<string[]>,
       gradlewFile: string
     ): Promise<string[]> => {
+      const getCreateNodesLinesStart = performance.mark(
+        `${gradlewFile}GetCreateNodesLine:start`
+      );
       const allLines = await createNodesLines;
       const currentLines = await getCreateNodesLines(
         gradlewFile,
         gradleConfigHash
       );
+      const getCreateNodesLinesEnd = performance.mark(
+        `${gradlewFile}GetCreateNodesLine:end`
+      );
+      performance.measure(
+        `${gradlewFile}GetCreateNodesLine`,
+        getCreateNodesLinesStart.name,
+        getCreateNodesLinesEnd.name
+      );
       return [...allLines, ...currentLines];
     },
     Promise.resolve([])