Merge pull request #2272 from digma-ai/fix-error-in-242

fix-error-in-242 Closes #2271

Author: shalom938

common-build-logic/src/main/kotlin/common/BuildProfile.kt

@@ -190,8 +190,8 @@ object BuildProfiles {
 
             isEAP = true,
             profile = Profile.p242,
-            platformVersion = "242.19533-EAP-CANDIDATE-SNAPSHOT",
-            riderVersion = "2024.2-EAP5-SNAPSHOT",
+            platformVersion = "242.19890-EAP-CANDIDATE-SNAPSHOT",
+            riderVersion = "2024.2-EAP6-SNAPSHOT",
             pycharmVersion = "242-EAP-SNAPSHOT",
             riderTargetFramework = "net8.0",
             riderResharperVersionConstant = "PROFILE_2023_2",

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/execution/InstrumentationRunConfigurationExtension.kt

@@ -40,7 +40,7 @@ class InstrumentationRunConfigurationExtension : RunConfigurationExtension() {
     }
 
     private fun getHandlerForConfiguration(configuration: RunConfiguration): RunConfigurationInstrumentationHandler? {
-        return RunConfigurationHandlersHolder.runConfigurationHandlers.find { it.isApplicableFor(configuration) }
+        return RunConfigurationHandlersHolder.getInstance().getRunConfigurationHandlers().find { it.isApplicableFor(configuration) }
     }
 
     override fun <T : RunConfigurationBase<*>?> updateJavaParameters(
@@ -164,7 +164,7 @@ class InstrumentationRunConfigurationExtension : RunConfigurationExtension() {
 
             //find a handler that wants to handle this configuration and also that should clean after start
             val configurationInstrumentationHandler =
-                RunConfigurationHandlersHolder.runConfigurationHandlers.find {
+                RunConfigurationHandlersHolder.getInstance().getRunConfigurationHandlers().find {
                     it.isApplicableFor(configuration) && it.shouldCleanConfigurationAfterStart(configuration)
                 }
 

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/execution/JavaToolOptionsDemoBuilder.kt

@@ -9,7 +9,7 @@ import org.digma.intellij.plugin.errorreporting.ErrorReporter
 class JavaToolOptionsDemoBuilder {
 
     fun isSupported(configuration: RunConfiguration): Boolean {
-        return RunConfigurationHandlersHolder.runConfigurationHandlers.find { it.isApplicableFor(configuration) } != null
+        return RunConfigurationHandlersHolder.getInstance().getRunConfigurationHandlers().find { it.isApplicableFor(configuration) } != null
     }
 
 
@@ -25,7 +25,7 @@ class JavaToolOptionsDemoBuilder {
             val template = factory.createTemplateConfiguration(configuration.project)
             val dummyConfig = factory.createConfiguration("dummy", template)
 
-            val handler = RunConfigurationHandlersHolder.runConfigurationHandlers.find { it.isApplicableFor(dummyConfig) }
+            val handler = RunConfigurationHandlersHolder.getInstance().getRunConfigurationHandlers().find { it.isApplicableFor(dummyConfig) }
 
             if (handler == null) {
                 return null

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/execution/RunConfigurationHandlersHolder.kt

@@ -1,26 +1,44 @@
 package org.digma.intellij.plugin.idea.execution
 
+import com.intellij.openapi.components.service
 import org.digma.intellij.plugin.errorreporting.ErrorReporter
 import org.digma.intellij.plugin.execution.RunConfigurationInstrumentationHandler
 import java.util.ServiceLoader
 
-object RunConfigurationHandlersHolder {
+@Suppress("LightServiceMigrationCode")
+class RunConfigurationHandlersHolder {
+
+    private var runConfigurationHandlers: List<RunConfigurationInstrumentationHandler>? = null
+
+    companion object {
+        fun getInstance(): RunConfigurationHandlersHolder {
+            return service<RunConfigurationHandlersHolder>()
+        }
+    }
+
 
     //RunConfigurationInstrumentationHandler is a delegating facades to services that provide the real work.
     //the main reason is to hide gradle and maven classes from the plugin in case gradle or maven are disabled.
     //RunConfigurationInstrumentationHandler that don't need a service can do the work themselves.
-    val runConfigurationHandlers: List<RunConfigurationInstrumentationHandler> = try {
-        //ServiceLoader doesn't work in intellij as it is in any other java application.
-        //see https://youtrack.jetbrains.com/issue/IDEA-241229
-        //so changing the context class loader for loading is the workaround
-        val currentClassLoader = Thread.currentThread().contextClassLoader
-        Thread.currentThread().setContextClassLoader(this::class.java.classLoader)
-        val handlers =
-            ServiceLoader.load(RunConfigurationInstrumentationHandler::class.java).stream().map { it.get() }.toList()
-        Thread.currentThread().setContextClassLoader(currentClassLoader)
-        handlers
-    } catch (e: Throwable) {
-        ErrorReporter.getInstance().reportInternalFatalError("RunConfigurationHandlersHolder.init", e)
-        listOf()
+    fun getRunConfigurationHandlers(): List<RunConfigurationInstrumentationHandler> {
+        if (runConfigurationHandlers == null) {
+
+            //ServiceLoader doesn't work in intellij as it is in any other java application.
+            //see https://youtrack.jetbrains.com/issue/IDEA-241229
+            //so changing the context class loader for loading is the workaround
+            val currentClassLoader = Thread.currentThread().contextClassLoader
+
+            runConfigurationHandlers = try {
+                Thread.currentThread().setContextClassLoader(this::class.java.classLoader)
+                ServiceLoader.load(RunConfigurationInstrumentationHandler::class.java).stream().map { it.get() }.toList()
+            } catch (e: Throwable) {
+                ErrorReporter.getInstance().reportInternalFatalError("RunConfigurationHandlersHolder.init", e)
+                emptyList()
+            } finally {
+                Thread.currentThread().setContextClassLoader(currentClassLoader)
+            }
+        }
+        return runConfigurationHandlers ?: emptyList()
     }
+
 }

jvm-common/src/main/kotlin/org/digma/intellij/plugin/idea/execution/RunConfigurationStartupActivity.kt

@@ -52,7 +52,7 @@ class RunConfigurationStartupActivity : DigmaProjectActivity() {
 
                 val isTemp = isTempRunConfig(config, tempConfigurations)
 
-                val handler = RunConfigurationHandlersHolder.runConfigurationHandlers.find {
+                val handler = RunConfigurationHandlersHolder.getInstance().getRunConfigurationHandlers().find {
                     it.isApplicableFor(config)
                 }
 

src/main/resources/META-INF/org.digma.intellij-with-jvm.xml

@@ -49,6 +49,9 @@
         <projectService
                 serviceImplementation="org.digma.intellij.plugin.idea.psi.discovery.endpoint.EndpointDiscoveryService"/>
 
+        <applicationService
+                serviceImplementation="org.digma.intellij.plugin.idea.execution.RunConfigurationHandlersHolder"/>
+
     </extensions>