Merge pull request #2045 from digma-ai/enhance-instrumentation-flavor

Enhance instrumentation flavor for all configuration types

Author: shalom938

gradle-support/src/main/kotlin/org/digma/intellij/plugin/idea/gradle/execution/GradleModuleResolver.kt

@@ -1,13 +1,13 @@
 package org.digma.intellij.plugin.idea.gradle.execution
 
-import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.SimpleProgramParameters
 import com.intellij.util.keyFMap.KeyFMap
 import org.digma.intellij.plugin.idea.execution.ModuleResolver
 import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
 import org.jetbrains.plugins.gradle.service.task.GradleTaskManager
 
-class GradleModuleResolver(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters) : ModuleResolver(configuration, params) {
+class GradleModuleResolver(configuration: RunConfiguration, params: SimpleProgramParameters) : ModuleResolver(configuration, params) {
 
     override fun findMainClassName(): String? {
 

gradle-support/src/main/kotlin/org/digma/intellij/plugin/idea/gradle/execution/GradleRunConfigurationService.kt

@@ -1,6 +1,6 @@
 package org.digma.intellij.plugin.idea.gradle.execution
 
-import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunnerSettings
 import com.intellij.execution.configurations.SimpleProgramParameters
 import org.digma.intellij.plugin.buildsystem.BuildSystem
@@ -20,94 +20,40 @@ import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
 @Suppress("LightServiceMigrationCode")
 class GradleRunConfigurationService : BaseJvmRunConfigurationInstrumentationService() {
 
-    override fun isApplicableFor(configuration: RunConfigurationBase<*>): Boolean {
-        return isApplicable(configuration, null)
-    }
-
-    override fun isApplicableFor(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): Boolean {
-        return isApplicable(configuration, params)
-    }
-
-    private fun isApplicable(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters?): Boolean {
-        if (configuration is GradleRunConfiguration) {
-
-            val taskNames = configuration.settings.taskNames
-
-            val isMainMethod = taskNames.any {
-                it.contains(".main")
-            }
-            val hasBootRun = taskNames.any {
-                it.contains(":bootRun") || it.equals("bootRun")
-            }
-
-            //support for the run task of the java application plugin. https://docs.gradle.org/current/userguide/application_plugin.html
-            val hasRun = taskNames.any {
-                it.contains(":run") || it.equals("run")
-            }
-
-            if (isMainMethod || hasBootRun || hasRun || isTest(configuration, params)) {
-                return true
-            }
-        }
-
-        return false
-    }
-
-
-    override fun isTest(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters?): Boolean {
-        return if (configuration is GradleRunConfiguration) {
-            val taskNames = configuration.settings.taskNames
-            taskNames.any {
-                it.equals(":test") ||
-                        it.endsWith(":test") ||
-                        it.equals("test") ||
-                        it.equals(":bootTestRun") ||
-                        it.endsWith(":bootTestRun") ||
-                        it.equals("bootTestRun")
-            }
-        } else {
-            false
-        }
+    override fun isApplicableFor(configuration: RunConfiguration): Boolean {
+        return configuration is GradleRunConfiguration
     }
 
 
-    override fun getConfigurationType(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): RunConfigurationType {
+    override fun getConfigurationType(configuration: RunConfiguration): RunConfigurationType {
         return if (configuration is GradleRunConfiguration) {
-            if (isTest(configuration, params)) {
-                RunConfigurationType.GradleTest
-            } else {
-                RunConfigurationType.GradleRun
-            }
+            RunConfigurationType.Gradle
         } else {
             RunConfigurationType.Unknown
         }
     }
 
-    override fun isHandlingType(configuration: RunConfigurationBase<*>): Boolean {
-        return configuration is GradleRunConfiguration
-    }
-
-    override fun getTaskNames(configuration: RunConfigurationBase<*>): Set<String> {
+    override fun getTaskNames(configuration: RunConfiguration): Set<String> {
         if (configuration is GradleRunConfiguration) {
             return configuration.settings.taskNames.toSet()
         }
         return setOf()
     }
 
-    override fun getBuildSystem(configuration: RunConfigurationBase<*>): BuildSystem {
+    override fun getBuildSystem(configuration: RunConfiguration): BuildSystem {
         if (configuration is GradleRunConfiguration) {
             return BuildSystem.GRADLE
         }
         return BuildSystem.INTELLIJ
     }
 
-    override fun shouldCleanConfigurationAfterStart(configuration: RunConfigurationBase<*>): Boolean {
+    override fun shouldCleanConfigurationAfterStart(configuration: RunConfiguration): Boolean {
         return true
     }
 
 
     override fun getModuleResolver(
-        configuration: RunConfigurationBase<*>,
+        configuration: RunConfiguration,
         params: SimpleProgramParameters,
         runnerSettings: RunnerSettings?
     ): ModuleResolver {
@@ -116,14 +62,14 @@ class GradleRunConfigurationService : BaseJvmRunConfigurationInstrumentationServ
 
 
     override fun getJavaToolOptionsMerger(
-        configuration: RunConfigurationBase<*>,
+        configuration: RunConfiguration,
         params: SimpleProgramParameters,
         parametersExtractor: ParametersExtractor
     ): JavaToolOptionsMerger {
         return ExternalSystemJavaToolOptionsMerger(configuration, params, parametersExtractor)
     }
 
-    override fun getConfigurationCleaner(configuration: RunConfigurationBase<*>): ConfigurationCleaner {
+    override fun getConfigurationCleaner(configuration: RunConfiguration): ConfigurationCleaner {
         return ExternalSystemConfigurationCleaner(configuration)
     }
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/execution/RunConfigurationInstrumentationHandler.kt

@@ -1,6 +1,6 @@
 package org.digma.intellij.plugin.execution
 
-import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunnerSettings
 import com.intellij.execution.configurations.SimpleProgramParameters
 import org.digma.intellij.plugin.buildsystem.BuildSystem
@@ -12,43 +12,35 @@ import org.digma.intellij.plugin.buildsystem.BuildSystem
 interface RunConfigurationInstrumentationHandler {
 
     /**
-     * used to sort handlers. we need it to find a handler that can help with extracting details from configuration.
-     * in which case order matters, gradle for example is first, then maven etc.
+     * this is the method used to attach an instrumentation handler to configuration
      */
-    fun getOrder(): Int
+    fun isApplicableFor(configuration: RunConfiguration): Boolean
 
     /**
-     * this method should not be used to find an instrumentation handler, it should only  be used in combination
-     * with more conditions. the reason is that there is no params and finding a module is not guaranteed.
-     * some instrumentation must have knowledge of the module, for example Quarkus+JavaTest
+     * updates the configuration with instrumentation parameters.
+     * returns the java tool options for reporting, or null, or error message.
      */
-    fun isApplicableFor(configuration: RunConfigurationBase<*>): Boolean
+    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String?
 
     /**
-     * this is the method used to attach an instrumentation handler to configuration. it has all the objects necessary to resolve
-     * parameters and the module
+     * returns a description for logging
      */
-    fun isApplicableFor(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): Boolean
-
-    fun updateParameters(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters, runnerSettings: RunnerSettings?)
-    fun getConfigurationDescription(configuration: RunConfigurationBase<*>): String
-    fun getConfigurationType(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): RunConfigurationType
-    fun shouldCleanConfigurationAfterStart(configuration: RunConfigurationBase<*>): Boolean
-    fun cleanConfigurationAfterStart(configuration: RunConfigurationBase<*>)
+    fun getConfigurationDescription(configuration: RunConfiguration, params: SimpleProgramParameters): String
 
     /**
-     * this method should only be used in combination with order, or to find any instrumentation handler that
-     * can handle the type. used to find a configuration handler that can help
-     * extract details from the configuration for reporting.
-     * do not use for attaching instrumentation handler to configuration.
+     * returns a configuration type. this is an internal type that we use for logging only
      */
-    fun isHandlingType(configuration: RunConfigurationBase<*>): Boolean
+    fun getConfigurationType(configuration: RunConfiguration): RunConfigurationType
+
+    fun shouldCleanConfigurationAfterStart(configuration: RunConfiguration): Boolean
+
+    fun cleanConfigurationAfterStart(configuration: RunConfiguration)
 
     /**
      * this method is relevant only for gradle and maven, others will return empty set.
      */
-    fun getTaskNames(configuration: RunConfigurationBase<*>): Set<String>
+    fun getTaskNames(configuration: RunConfiguration): Set<String>
 
-    fun getBuildSystem(configuration: RunConfigurationBase<*>): BuildSystem
+    fun getBuildSystem(configuration: RunConfiguration): BuildSystem
 
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/execution/RunConfigurationInstrumentationService.kt

@@ -1,38 +1,42 @@
 package org.digma.intellij.plugin.execution
 
-import com.intellij.execution.configurations.RunConfigurationBase
+import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunnerSettings
 import com.intellij.execution.configurations.SimpleProgramParameters
 import org.digma.intellij.plugin.buildsystem.BuildSystem
 
+const val DIGMA_INSTRUMENTATION_ERROR = "DIGMA_INSTRUMENTATION_ERROR"
+
 interface RunConfigurationInstrumentationService {
 
     /**
-     * not an accurate method because there is no params to resolve the module or environment variables.
-     * should be used in combination with other conditions or when matching is not supposed to be accurate.
-     * do not use to attach an instrumentation handler to configuration, use fot other needs when
-     * the matching doesn't need to be accurate, like for reporting unhandled configuration.
+     * this method decides if this service handles the configuration
+     */
+    fun isApplicableFor(configuration: RunConfiguration): Boolean
+
+    /**
+     * updates the configuration with instrumentation parameters.
+     * returns the java tool options for reporting, or null if not handled.
+     * the configuration may not be updated because we don't support everything. the service may decide not to instrument.
+     * may return a string starting with DIGMA_INSTRUMENTATION_ERROR for reporting in case of error.
      */
-    fun isApplicableFor(configuration: RunConfigurationBase<*>): Boolean
+    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String?
 
     /**
-     * this is the method to check for attaching a service to a configuration.
+     * returns a description for logging
      */
-    fun isApplicableFor(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): Boolean
+    fun getConfigurationDescription(configuration: RunConfiguration, params: SimpleProgramParameters): String
+
+    fun getConfigurationType(configuration: RunConfiguration): RunConfigurationType
 
-    fun updateParameters(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters, runnerSettings: RunnerSettings?)
-    fun getConfigurationDescription(configuration: RunConfigurationBase<*>): String
-    fun getConfigurationType(configuration: RunConfigurationBase<*>, params: SimpleProgramParameters): RunConfigurationType
-    fun shouldCleanConfigurationAfterStart(configuration: RunConfigurationBase<*>): Boolean
-    fun cleanConfigurationAfterStart(configuration: RunConfigurationBase<*>)
+    fun shouldCleanConfigurationAfterStart(configuration: RunConfiguration): Boolean
+    fun cleanConfigurationAfterStart(configuration: RunConfiguration)
 
     /**
-     * should be used to check if a specific service can handle this configuration type.
-     * should not be used to check is a service can instrument a configuration because there is
-     * no params that are used to resolve the module, some services must resolve a module to match.
+     * this method is relevant only for gradle and maven, others will return empty set.
      */
-    fun isHandlingType(configuration: RunConfigurationBase<*>): Boolean
-    fun getTaskNames(configuration: RunConfigurationBase<*>): Set<String>
-    fun getBuildSystem(configuration: RunConfigurationBase<*>): BuildSystem
+    fun getTaskNames(configuration: RunConfiguration): Set<String>
+
+    fun getBuildSystem(configuration: RunConfiguration): BuildSystem
 
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/execution/RunConfigurationType.kt

@@ -1,18 +1,16 @@
 package org.digma.intellij.plugin.execution
 
+
+/**
+ * this type is only used for logging and reporting. we don't rely on this type for any decision.
+ */
 enum class RunConfigurationType {
-    JavaRun,
+    Java,
     JavaTest,
-    KotlinRun,
-    KotlinTest,
-    GradleRun,
-    GradleTest,
-    MavenRun,
-    MavenTest,
+    Kotlin,
+    Gradle,
+    Maven,
     Jar,
-    TomcatForIdeaUltimate,
-    EeAppSeverAtIdeaUltimate,
-    OpenLiberty,
-    Quarkus,
+    JavaSever,
     Unknown;
 }