clear current env when deleting last env

Author: shalom938

ide-common/src/main/java/org/digma/intellij/plugin/analytics/Environment.java

@@ -67,7 +67,7 @@ void setCurrentById(@NotNull String envId, @Nullable Runnable taskToRunAfterChan
         try {
             Log.log(LOGGER::debug, "Setting current environment by id , old={},new={}", current, envId);
 
-            if (StringUtils.isEmpty(envId)) {
+            if (StringUtils.isEmpty(envId) || StringUtils.isBlank(envId)) {
                 Log.log(LOGGER::debug, "setCurrent was called with an empty environment {}", envId);
                 return;
             }
@@ -174,12 +174,18 @@ private void updateCurrentEnv(@Nullable String preferred) {
         var oldEnv = current;
 
         var optionalEnv = find(preferred);
-        if (optionalEnv.isPresent()) {
-            current = optionalEnv.get();
-        } else if (current == null) {
-            current = environments.isEmpty() ? null : environments.get(0);
-        }
-
+        current = optionalEnv.orElseGet(() -> environments.isEmpty() ? null : environments.get(0));
+
+        //latestKnownEnvId is updated only if current is not null.
+        //current will be null on connection lost, or when the last env was deleted. actually when the
+        // environments list is empty, this code can't distinguish between these two cases.
+        // so if current is null we keep latestKnownEnvId with its current value. if connection was
+        // lost and gained it will help restore the current env. if the environments list was empty
+        // because the last env was deleted then it will keep a value of the latest that actually
+        // does not exist, but it will change on the first new environment.
+        //the persistence is changed to null if current is null. on connection lost it will be set
+        // back with value after connection gained. and if the last env was deleted it will be set
+        // back with value when a new environment is added.
         if (current != null) {
             latestKnownEnvId = current.getId();
             PersistenceService.getInstance().setLatestSelectedEnvId(latestKnownEnvId);

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

@@ -18,9 +18,9 @@ interface RunConfigurationInstrumentationHandler {
 
     /**
      * updates the configuration with instrumentation parameters.
-     * returns the java tool options for reporting, or null, or error message.
+     * returns the java tool options  and otel resource attributes for reporting, or null.
      */
-    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String?
+    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): Pair<String, String>?
 
     /**
      * returns a description for logging

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

@@ -16,11 +16,11 @@ interface RunConfigurationInstrumentationService {
 
     /**
      * updates the configuration with instrumentation parameters.
-     * returns the java tool options for reporting, or null if not handled.
+     * returns the java tool options and otel resource attributes 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.
+     * may return in place of java tool options a string starting with DIGMA_INSTRUMENTATION_ERROR for reporting in case of error.
      */
-    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String?
+    fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): Pair<String, String>?
 
     /**
      * returns a description for logging

ide-common/src/main/kotlin/org/digma/intellij/plugin/persistence/PersistenceService.kt

@@ -23,6 +23,7 @@ class PersistenceService {
 
     /**
      * Do not use this method to get the current environment.
+     * It is used only for restoring the current env after restart or after connection lost/gained
      */
     fun getLatestSelectedEnvId(): String? {
         return state.latestSelectedEnvId

ide-common/src/main/kotlin/org/digma/intellij/plugin/posthog/ActivityMonitor.kt

@@ -515,6 +515,7 @@ class ActivityMonitor(private val project: Project) : Disposable {
         runConfigTypeName: String,
         description: String,
         javaToolOptions: String,
+        resourceAttributes: String,
         observabilityEnabled: Boolean,
         connectedToBackend: Boolean
     ) {
@@ -535,6 +536,8 @@ class ActivityMonitor(private val project: Project) : Disposable {
             details["java tool options"] = javaToolOptions
         }
 
+        details["otel resource attributes"] = resourceAttributes
+
         capture(
             "instrumented run configuration",
             details

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

@@ -63,9 +63,11 @@ class InstrumentationRunConfigurationExtension : RunConfigurationExtension() {
                 if (runConfigurationHandler == null) {
                     reportUnknownConfigurationType(configuration)
                 } else {
-                    val javaToolOptions = runConfigurationHandler.updateParameters(configuration, params, runnerSettings)
-                    if (javaToolOptions != null) {
-                        reportRunConfig(runConfigurationHandler, javaToolOptions, configuration, params)
+
+                    //instrumentationParams contains the java tool options and otel resource attributes and is used for reporting only
+                    val instrumentationParams = runConfigurationHandler.updateParameters(configuration, params, runnerSettings)
+                    if (instrumentationParams != null) {
+                        reportRunConfig(runConfigurationHandler, instrumentationParams.first, instrumentationParams.second, configuration, params)
                     } else {
                         reportUnhandledConfiguration(runConfigurationHandler, configuration, params)
                     }
@@ -80,6 +82,7 @@ class InstrumentationRunConfigurationExtension : RunConfigurationExtension() {
     private fun reportRunConfig(
         runConfigurationHandler: RunConfigurationInstrumentationHandler,
         javaToolOptions: String,
+        resourceAttributes: String,
         configuration: RunConfiguration,
         params: SimpleProgramParameters
     ) {
@@ -91,6 +94,7 @@ class InstrumentationRunConfigurationExtension : RunConfigurationExtension() {
                     runConfigurationType.name,
                     runConfigDescription,
                     javaToolOptions,
+                    resourceAttributes,
                     isObservabilityEnabled(),
                     isConnectedToBackend(configuration.project)
                 )

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

@@ -28,7 +28,7 @@ open class OtelResourceAttributesBuilder(
             }
         }
 
-        if (!parametersExtractor.hasDigmaEnvironmentIdAttribute(configuration, params) &&
+        if (!parametersExtractor.hasDigmaEnvironmentIdAttribute() &&
             isCentralized(configuration.project)
         ) {
             withUserId()
@@ -59,8 +59,8 @@ open class OtelResourceAttributesBuilder(
 
 
     private fun needToAddDigmaEnvironmentAttribute(parametersExtractor: ParametersExtractor): Boolean {
-        return !parametersExtractor.hasDigmaEnvironmentIdAttribute(configuration, params) &&
-                !parametersExtractor.hasDigmaEnvironmentAttribute(configuration, params)
+        return !parametersExtractor.hasDigmaEnvironmentIdAttribute() &&
+                !parametersExtractor.hasDigmaEnvironmentAttribute()
     }
 
 

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

@@ -20,7 +20,7 @@ open class ParametersExtractor(protected val configuration: RunConfiguration, pr
         )
     }
 
-    open fun extractOtelServiceNameFromExternalSystem(configuration: RunConfiguration): String? {
+    private fun extractOtelServiceNameFromExternalSystem(configuration: RunConfiguration): String? {
 
         return if (configuration is ExternalSystemRunConfiguration) {
             configuration.settings.env[OTEL_SERVICE_NAME_ENV_VAR_NAME]
@@ -34,19 +34,19 @@ open class ParametersExtractor(protected val configuration: RunConfiguration, pr
         }
     }
 
-    open fun extractOtelServiceNameFromVmOptions(params: SimpleProgramParameters): String? {
+    private fun extractOtelServiceNameFromVmOptions(params: SimpleProgramParameters): String? {
         if (params is SimpleJavaParameters) {
             return params.vmParametersList?.getPropertyValue(OTEL_SERVICE_NAME_PROP_NAME)
         }
         return null
     }
 
-    open fun extractOtelServiceNameFromParamsEnv(params: SimpleProgramParameters): String? {
+    private fun extractOtelServiceNameFromParamsEnv(params: SimpleProgramParameters): String? {
         return params.env[OTEL_SERVICE_NAME_ENV_VAR_NAME]
     }
 
 
-    open fun hasDigmaEnvironmentIdAttribute(configuration: RunConfiguration, params: SimpleProgramParameters): Boolean {
+    open fun hasDigmaEnvironmentIdAttribute(): Boolean {
         if (configuration is ExternalSystemRunConfiguration &&
             configuration.settings.env[OTEL_RESOURCE_ATTRIBUTES]?.contains("$DIGMA_ENVIRONMENT_ID_RESOURCE_ATTRIBUTE=") == true
         ) {
@@ -56,7 +56,7 @@ open class ParametersExtractor(protected val configuration: RunConfiguration, pr
         return params.env[OTEL_RESOURCE_ATTRIBUTES]?.contains("$DIGMA_ENVIRONMENT_ID_RESOURCE_ATTRIBUTE=") ?: false
     }
 
-    open fun hasDigmaEnvironmentAttribute(configuration: RunConfiguration, params: SimpleProgramParameters): Boolean {
+    open fun hasDigmaEnvironmentAttribute(): Boolean {
         if (configuration is ExternalSystemRunConfiguration &&
             configuration.settings.env[OTEL_RESOURCE_ATTRIBUTES]?.contains("$DIGMA_ENVIRONMENT_RESOURCE_ATTRIBUTE=") == true
         ) {

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

@@ -17,7 +17,11 @@ abstract class BaseRunConfigurationInstrumentationHandler : RunConfigurationInst
         return getService()?.isApplicableFor(configuration) ?: false
     }
 
-    override fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String? {
+    override fun updateParameters(
+        configuration: RunConfiguration,
+        params: SimpleProgramParameters,
+        runnerSettings: RunnerSettings?
+    ): Pair<String, String>? {
         return getService()?.updateParameters(configuration, params, runnerSettings)
     }
 

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

@@ -13,6 +13,7 @@ import org.digma.intellij.plugin.idea.execution.ConfigurationCleaner
 import org.digma.intellij.plugin.idea.execution.JavaParametersMerger
 import org.digma.intellij.plugin.idea.execution.JavaToolOptionsBuilder
 import org.digma.intellij.plugin.idea.execution.ModuleResolver
+import org.digma.intellij.plugin.idea.execution.OTEL_RESOURCE_ATTRIBUTES
 import org.digma.intellij.plugin.idea.execution.OtelResourceAttributesBuilder
 import org.digma.intellij.plugin.idea.execution.ParametersExtractor
 import org.digma.intellij.plugin.idea.execution.ProjectHeuristics
@@ -24,7 +25,11 @@ import org.digma.intellij.plugin.idea.execution.flavor.InstrumentationFlavor
  */
 abstract class BaseJvmRunConfigurationInstrumentationService : RunConfigurationInstrumentationService {
 
-    override fun updateParameters(configuration: RunConfiguration, params: SimpleProgramParameters, runnerSettings: RunnerSettings?): String? {
+    override fun updateParameters(
+        configuration: RunConfiguration,
+        params: SimpleProgramParameters,
+        runnerSettings: RunnerSettings?
+    ): Pair<String, String>? {
 
         val projectHeuristics = getProjectHeuristics(configuration.project)
         val moduleResolver = getModuleResolver(configuration, params)
@@ -82,11 +87,14 @@ abstract class BaseJvmRunConfigurationInstrumentationService : RunConfigurationI
             getJavaParametersMerger(configuration, params, parametersExtractor)
                 .mergeJavaToolOptionsAndOtelResourceAttributes(instrumentationFlavor.getFlavor(), javaToolOptions, otelResourceAttributes)
 
-            return javaToolOptions
+
+            //we need this return value only for reporting what was added to the configuration
+            val otelResourceAttributesEnv = parametersExtractor.extractEnvValue(OTEL_RESOURCE_ATTRIBUTES)
+            return Pair(javaToolOptions.toString(), otelResourceAttributesEnv.toString())
 
         } catch (e: Throwable) {
             ErrorReporter.getInstance().reportError("${this::class.java}.updateParameters", e)
-            "$DIGMA_INSTRUMENTATION_ERROR $e"
+            Pair("$DIGMA_INSTRUMENTATION_ERROR $e", "")
         }
 
     }