Feature/RunConfig - simply modify the (System) properties

Author: arik-dig

java/src/main/kotlin/org/digma/intellij/plugin/idea/runcfg/AutoOtelAgentRunConfigurationExtension.kt

@@ -7,20 +7,15 @@ import com.intellij.execution.configurations.JavaParameters
 import com.intellij.execution.configurations.ModuleRunConfiguration
 import com.intellij.execution.configurations.RunConfigurationBase
 import com.intellij.execution.configurations.RunnerSettings
-import com.intellij.execution.process.ProcessEvent
-import com.intellij.execution.process.ProcessHandler
-import com.intellij.execution.process.ProcessListener
 import com.intellij.execution.ui.ConsoleView
 import com.intellij.execution.ui.ConsoleViewContentType
 import com.intellij.openapi.diagnostic.Logger
-import com.intellij.openapi.project.Project
 import org.digma.intellij.plugin.log.Log
 import org.digma.intellij.plugin.persistence.PersistenceService
 import org.digma.intellij.plugin.settings.SettingsState
 import org.jetbrains.idea.maven.execution.MavenRunConfiguration
 import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
 
-private const val ORG_GRADLE_JAVA_TOOL_OPTIONS = "ORG_GRADLE_JAVA_TOOL_OPTIONS"
 
 class AutoOtelAgentRunConfigurationExtension : RunConfigurationExtension() {
 
@@ -61,25 +56,21 @@ class AutoOtelAgentRunConfigurationExtension : RunConfigurationExtension() {
         Log.log(logger::debug, "updateJavaParameters, project:{}, id:{}, name:{}, type:{}",
                 configuration.project, configuration.id, configuration.name, configuration.type)
 
-        val project = configuration.project
-
         //testing if enabled must be done here just before running.
         if (!enabled()) {
             Log.log(logger::debug, "AutoOtelAgentRunConfigurationExtension is not enabled")
             return
         }
 
-
         if (isJavaConfiguration(configuration)) {
-            //this also works for: CommonJavaRunConfigurationParameters
-            //params.vmParametersList.addParametersString("-verbose:class -javaagent:/home/shalom/tmp/run-configuration/opentelemetry-javaagent.jar")
-            //params.vmParametersList.addProperty("myprop","myvalue")
-            val javaToolOptions = buildJavaToolOptions(configuration, project)
-            javaToolOptions?.let {
-                mergeJavaToolOptions(params, it)
-            }
+            configuration as CommonJavaRunConfigurationParameters
 
+            adjustWithOtelAndDigma(configuration, params)
         } else if (isGradleConfiguration(configuration)) {
+            configuration as GradleRunConfiguration
+
+            adjustWithOtelAndDigma(configuration, params)
+
             //when injecting JAVA_TOOL_OPTIONS to GradleRunConfiguration the GradleRunConfiguration will also run with
             // JAVA_TOOL_OPTIONS which is not ideal. for example, gradle will execute with JAVA_TOOL_OPTIONS and then fork
             // a process for the main method or unit test with JAVA_TOOL_OPTIONS. ideally we want only the forked process
@@ -90,116 +81,46 @@ class AutoOtelAgentRunConfigurationExtension : RunConfigurationExtension() {
             // to learn how gradle does it see GradleTaskManager and GradleExecutionHelper.
             //when gradle runs the :test task it's not possible to pass system properties to the task.
             // JAVA_TOOL_OPTIONS is not the best as said above, but it works.
-            configuration as GradleRunConfiguration
-            val javaToolOptions = buildJavaToolOptions(configuration, project)
-            javaToolOptions?.let {
-                mergeGradleJavaToolOptions(configuration, javaToolOptions)
-            }
+
         } else if (isMavenConfiguration(configuration)) {
             configuration as MavenRunConfiguration
-            val javaToolOptions = buildJavaToolOptions(configuration, project)
-            javaToolOptions?.let {
-                mergeJavaToolOptions(params, it)
-            }
-        }
-    }
 
-
-    //this is only for gradle. we need to keep original JAVA_TOOL_OPTIONS if exists and restore when the process is
-    // finished, anyway we need to clean our JAVA_TOOL_OPTIONS because it will be saved in the run configuration settings.
-    private fun mergeGradleJavaToolOptions(configuration: GradleRunConfiguration, myJavaToolOptions: String) {
-        var javaToolOptions = myJavaToolOptions
-        //need to replace the env because it may be immutable map
-        val newEnv = configuration.settings.env.toMutableMap()
-        if (configuration.settings.env.containsKey(JAVA_TOOL_OPTIONS)) {
-            val currentJavaToolOptions = configuration.settings.env[JAVA_TOOL_OPTIONS]
-            javaToolOptions = "$myJavaToolOptions $currentJavaToolOptions"
-            newEnv[ORG_GRADLE_JAVA_TOOL_OPTIONS] = currentJavaToolOptions!!
+            adjustWithOtelAndDigma(configuration, params)
         }
-        newEnv[JAVA_TOOL_OPTIONS] = javaToolOptions
-        configuration.settings.env = newEnv
     }
 
-
-    //this is for java and maven run configurations. merge in case users have their own JAVA_TOOL_OPTIONS
-    private fun mergeJavaToolOptions(params: JavaParameters, myJavaToolOptions: String) {
-        var javaToolOptions = myJavaToolOptions
-        if (params.env.containsKey(JAVA_TOOL_OPTIONS)) {
-            val currentJavaToolOptions = params.env[JAVA_TOOL_OPTIONS]
-            javaToolOptions = "$myJavaToolOptions $currentJavaToolOptions"
-        }
-        params.env[JAVA_TOOL_OPTIONS] = javaToolOptions
-    }
-
-
-    override fun attachToProcess(
-            configuration: RunConfigurationBase<*>,
-            handler: ProcessHandler,
-            runnerSettings: RunnerSettings?
-    ) {
-        //we need to clean gradle configuration from our JAVA_TOOL_OPTIONS
-        if (isGradleConfiguration(configuration)) {
-            handler.addProcessListener(object : ProcessListener {
-
-                override fun processWillTerminate(event: ProcessEvent, willBeDestroyed: Boolean) {
-                    cleanGradleSettings(configuration)
-                }
-
-                private fun cleanGradleSettings(configuration: RunConfigurationBase<*>) {
-                    configuration as GradleRunConfiguration
-                    Log.log(logger::debug, "Cleaning gradle configuration {}", configuration)
-                    if (configuration.settings.env.containsKey(ORG_GRADLE_JAVA_TOOL_OPTIONS)) {
-                        val orgJavaToolOptions = configuration.settings.env[ORG_GRADLE_JAVA_TOOL_OPTIONS]
-                        configuration.settings.env[JAVA_TOOL_OPTIONS] = orgJavaToolOptions
-                        configuration.settings.env.remove(ORG_GRADLE_JAVA_TOOL_OPTIONS)
-                    } else if (configuration.settings.env.containsKey(JAVA_TOOL_OPTIONS)) {
-                        configuration.settings.env.remove(JAVA_TOOL_OPTIONS)
-                    }
-                }
-            })
-        }
-
-    }
-
-
     override fun decorate(
             console: ConsoleView,
             configuration: RunConfigurationBase<*>,
             executor: Executor
     ): ConsoleView {
-        if (enabled() &&
-                (isMavenConfiguration(configuration) || isJavaConfiguration(configuration))) {
-            //that only works for java and maven run configurations.
-            console.print("This process is enhanced by Digma OTEL agent !\n", ConsoleViewContentType.LOG_WARNING_OUTPUT)
+
+        if (enabled()) {
+            console.print("Observability - this process is enhanced by Digma OTEL agent\n", ConsoleViewContentType.LOG_WARNING_OUTPUT)
         }
 
         return console
     }
 
-    private fun buildJavaToolOptions(configuration: RunConfigurationBase<*>, project: Project): String? {
+    private fun adjustWithOtelAndDigma(configuration: RunConfigurationBase<*>, params: JavaParameters) {
+
+        val otelAgentPath = OTELJarProvider.getInstance().getOtelAgentJarPath(configuration.project)
+        val digmaExtensionPath = OTELJarProvider.getInstance().getDigmaAgentExtensionJarPath(configuration.project)
 
-        val otelAgentPath = OTELJarProvider.getInstance().getOtelAgentJarPath(project)
-        val digmaExtensionPath = OTELJarProvider.getInstance().getDigmaAgentExtensionJarPath(project)
         if (otelAgentPath == null || digmaExtensionPath == null) {
-            Log.log(logger::debug, "could not build $JAVA_TOOL_OPTIONS because otel agent or digma extension jar are not available. please check the logs")
-            return null
+            Log.log(logger::debug, "could not adjust process because OTEL agent and Digma extension are not available. please check the logs")
+            return
         }
 
-        return "".plus("-javaagent:$otelAgentPath")
-                .plus(" ")
-                .plus("-Dotel.javaagent.extensions=$digmaExtensionPath")
-                .plus(" ")
-                .plus("-Dotel.traces.exporter=otlp")
-                .plus(" ")
-                .plus("-Dotel.metrics.exporter=none")
-                .plus(" ")
-                .plus("-Dotel.exporter.otlp.traces.endpoint=${getExporterUrl()}")
-                .plus(" ")
-                .plus("-Dotel.service.name=${getServiceName(configuration)}")
-                .plus(" ")
+        params.vmParametersList.addParametersString("-javaagent:$otelAgentPath")
+        params.vmParametersList.addProperty("otel.javaagent.extensions", digmaExtensionPath)
+        params.vmParametersList.addProperty("otel.traces.exporter", "otlp")
+        params.vmParametersList.addProperty("otel.metrics.exporter", "none")
+        params.vmParametersList.addProperty("otel.exporter.otlp.traces.endpoint", getExporterUrl())
+        params.vmParametersList.addProperty("otel.service.name", evalServiceName(configuration))
     }
 
-    private fun getServiceName(configuration: RunConfigurationBase<*>): String {
+    private fun evalServiceName(configuration: RunConfigurationBase<*>): String {
         return if (configuration is ModuleRunConfiguration && configuration.modules.isNotEmpty()) {
             val moduleName = configuration.modules.first().name
             moduleName.replace(" ", "").trim()