Merge pull request #2221 from digma-ai/close-wizard-when-replacing-deployment

close wizard when changing to centralized Closes #2216

Author: shalom938

build.gradle.kts

@@ -217,6 +217,15 @@ intellijPlatform {
 tasks {
 
     prepareSandbox {
+
+        /*
+        sometimes runIde fails with this error:
+        Execution failed for task ':prepareSandbox'.
+        > Cannot access output property '$1$4' of task ':prepareSandbox'. Accessing unreadable inputs or outputs is not supported. Declare the task as untracked by using Task.doNotTrackState(). For more information, please refer to https://docs.gradle.org/8.8/userguide/incremental_build.html#sec:disable-state-tracking in the Gradle documentation.
+        > java.io.IOException: Cannot snapshot /home/shalom/workspace/digma/digma-intellij-plugin/build/idea-sandbox/IC-2024.1.3/system/jcef_cache/SingletonSocket: not a regular file
+        */
+        doNotTrackState("prepareSandbox needs to re-run every time")
+
         //copy rider dlls to the plugin sandbox, so it is packaged in the zip
         from(configurations.getByName("riderDotNetObjects")) {
             into("${rootProject.name}/dotnet/")
@@ -264,7 +273,12 @@ tasks {
 
     val deleteLog by registering(Delete::class) {
         outputs.upToDateWhen { false }
-        project.layout.buildDirectory.dir("idea-sandbox/system/log").get().asFile.walk().forEach {
+        val ideFolderName = if(platformType == IntelliJPlatformType.Rider){
+            "${platformType.code}-${project.currentProfile().riderVersion}"
+        }else{
+            "${platformType.code}-${project.currentProfile().platformVersion}"
+        }
+        project.layout.buildDirectory.dir("idea-sandbox/$ideFolderName/log").get().asFile.walk().forEach {
             if (it.name.endsWith(".log")) {
                 delete(it)
             }

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

@@ -670,6 +670,16 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
                     throw new AnalyticsServiceException(e);
                 }
 
+
+                //this message should help us understand the logs when debugging issues. it will help
+                // understand that there are more and more exceptions.
+                //code below and in handleInvocationTargetException will log the exceptions but our Log class
+                // will not explode the logs, so we don't see all the exceptions in the log as they happen.
+                //this message will explode the idea.log if user has digma trace logging on and no backend running,
+                // which shouldn't happen, users should not have digma trace logging on all the time.
+                Log.log(LOGGER::trace,"got exception in AnalyticsService {}",ExceptionUtils.findFirstRealExceptionCause(e));
+
+
                 //Note: when logging LOGGER.error idea will pop up a red message which we don't want, so only report warn messages.
 
                 //handle only InvocationTargetException, other exceptions are probably a bug.

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

@@ -6,7 +6,7 @@
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.*;
 import org.digma.intellij.plugin.auth.AuthManager;
-import org.digma.intellij.plugin.common.ProjectUtilsKt;
+import org.digma.intellij.plugin.common.*;
 import org.digma.intellij.plugin.log.Log;
 import org.digma.intellij.plugin.settings.SettingsState;
 
@@ -32,31 +32,33 @@ public AnalyticsServiceSettingsWatcher() {
 
         SettingsState.getInstance().addChangeListener(state -> {
 
-            Log.log(LOGGER::debug, "settings changed event");
+            Backgroundable.executeOnPooledThread(() -> {
+                Log.log(LOGGER::debug, "settings changed event");
 
-            boolean shouldReplaceClient = false;
+                boolean shouldReplaceClient = false;
 
-            if (!Objects.equals(state.apiUrl, myApiUrl)) {
-                myApiUrl = state.apiUrl;
-                shouldReplaceClient = true;
-            }
-
-            //replace the client only when apiUrl is changed.
-            //there is no need to replace the client when api token is changed because there is an
-            // AuthenticationProvider that always takes it from the settings
-            if (shouldReplaceClient) {
-                Log.log(LOGGER::debug, "api url changed to {}, calling replace client", myApiUrl);
-                AuthManager.getInstance().logout();
-                AuthManager.getInstance().pauseBeforeClientChange();
-                AuthManager.getInstance().replaceClient(myApiUrl);
+                if (!Objects.equals(state.apiUrl, myApiUrl)) {
+                    myApiUrl = state.apiUrl;
+                    shouldReplaceClient = true;
+                }
 
-                for (Project openProject : ProjectManager.getInstance().getOpenProjects()) {
-                    if (ProjectUtilsKt.isProjectValid(openProject)) {
-                        var analyticsService = AnalyticsService.getInstance(openProject);
-                        analyticsService.replaceClient(myApiUrl);
+                //replace the client only when apiUrl is changed.
+                //there is no need to replace the client when api token is changed because there is an
+                // AuthenticationProvider that always takes it from the settings
+                if (shouldReplaceClient) {
+                    Log.log(LOGGER::debug, "api url changed to {}, calling replace client", myApiUrl);
+                    AuthManager.getInstance().logout();
+                    AuthManager.getInstance().pauseBeforeClientChange();
+                    AuthManager.getInstance().replaceClient(myApiUrl);
+
+                    for (Project openProject : ProjectManager.getInstance().getOpenProjects()) {
+                        if (ProjectUtilsKt.isProjectValid(openProject)) {
+                            var analyticsService = AnalyticsService.getInstance(openProject);
+                            analyticsService.replaceClient(myApiUrl);
+                        }
                     }
                 }
-            }
+            });
 
         }, this);
 

ide-common/src/main/java/org/digma/intellij/plugin/ui/MainToolWindowCardsController.java

@@ -6,7 +6,7 @@
 import com.intellij.openapi.wm.ToolWindow;
 import com.intellij.ui.content.*;
 import org.digma.intellij.plugin.analytics.*;
-import org.digma.intellij.plugin.common.EDT;
+import org.digma.intellij.plugin.common.*;
 import org.digma.intellij.plugin.log.Log;
 import org.digma.intellij.plugin.ui.panels.DisposablePanel;
 import org.digma.intellij.plugin.updates.*;
@@ -89,9 +89,34 @@ public void connectionGained() {
         project.getMessageBus().connect().subscribe(AggressiveUpdateStateChangedEvent.Companion.getUPDATE_STATE_CHANGED_TOPIC(),
                 (AggressiveUpdateStateChangedEvent) this::updateStateChanged);
 
+
+        project.getMessageBus().connect().subscribe(ApiClientChangedEvent.getAPI_CLIENT_CHANGED_TOPIC(),new ApiClientChangedEvent(){
+
+            @Override
+            public void apiClientChanged(@NotNull String newUrl) {
+                Backgroundable.ensurePooledThread(() -> {
+                    if (wizard.isOn()){
+                        if(isCentralized()){
+                            EDT.ensureEDT(() -> wizardFinished());
+                        }
+                    }
+                });
+            }
+        });
     }
 
 
+    private boolean isCentralized(){
+        try{
+            var about = AnalyticsService.getInstance(project).getAbout();
+            return Boolean.TRUE.equals(about.isCentralize());
+        }catch (Throwable e){
+            return false;
+        }
+    }
+
+
+
     public static MainToolWindowCardsController getInstance(@NotNull Project project) {
         return project.getService(MainToolWindowCardsController.class);
     }

ide-common/src/main/kotlin/org/digma/intellij/plugin/analytics/BackendConnectionMonitor.kt

@@ -2,8 +2,10 @@ package org.digma.intellij.plugin.analytics
 
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.Service
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.util.messages.MessageBusConnection
+import org.digma.intellij.plugin.log.Log
 
 /**
  * This service keeps track of the analytics service connection status. it is used to decide when to show the
@@ -13,6 +15,9 @@ import com.intellij.util.messages.MessageBusConnection
 @Service(Service.Level.PROJECT)
 class BackendConnectionMonitor(val project: Project) : Disposable, AnalyticsServiceConnectionEvent {
 
+
+    private val logger: Logger = Logger.getInstance(this::class.java)
+
     companion object {
         @JvmStatic
         fun getInstance(project: Project): BackendConnectionMonitor {
@@ -53,10 +58,12 @@ class BackendConnectionMonitor(val project: Project) : Disposable, AnalyticsServ
     }
 
     override fun connectionLost() {
+        Log.log(logger::trace,"got connectionLost")
         connectionError()
     }
 
     override fun connectionGained() {
+        Log.log(logger::trace,"got connectionGained")
         connectionOk()
     }
 

src/main/kotlin/org/digma/intellij/plugin/ui/jcef/JCefComponent.kt

@@ -205,6 +205,8 @@ private constructor(
             //this event run on EDT
             Backgroundable.executeOnPooledThread {
                 try {
+                    //can not rely here on backend about info because this event may be processed before the api client was changed.
+                    //the API_CLIENT_CHANGED_TOPIC is more suitable. it is handled here.
                     val apiUrl = settings.apiUrl
                     sendApiUrl(jbCefBrowser.cefBrowser, apiUrl)
                     sendIsMicrometerProject(jbCefBrowser.cefBrowser, SpringBootMicrometerConfigureDepsService.isSpringBootWithMicrometer())
@@ -255,16 +257,14 @@ private constructor(
 
 
         project.messageBus.connect(observabilityChangeParentDisposable).subscribe(
-            ObservabilityChanged.OBSERVABILITY_CHANGED_TOPIC, object : ObservabilityChanged {
-                override fun observabilityChanged(isObservabilityEnabled: Boolean) {
-                    try {
-                        sendObservabilityEnabledMessage(
-                            jbCefBrowser.cefBrowser,
-                            isObservabilityEnabled
-                        )
-                    } catch (e: Throwable) {
-                        ErrorReporter.getInstance().reportError("JCefComponent.observabilityChanged", e)
-                    }
+            ObservabilityChanged.OBSERVABILITY_CHANGED_TOPIC, ObservabilityChanged { isObservabilityEnabled ->
+                try {
+                    sendObservabilityEnabledMessage(
+                        jbCefBrowser.cefBrowser,
+                        isObservabilityEnabled
+                    )
+                } catch (e: Throwable) {
+                    ErrorReporter.getInstance().reportError("JCefComponent.observabilityChanged", e)
                 }
             }
         )
@@ -281,9 +281,9 @@ private constructor(
                             scope,
                             codeLocation,
                             hasErrors,
-                            insightsStats?.analyticsInsightsCount ?: 0,
-                            insightsStats?.issuesInsightsCount ?: 0,
-                            insightsStats?.unreadInsightsCount ?: 0
+                            insightsStats.analyticsInsightsCount,
+                            insightsStats.issuesInsightsCount,
+                            insightsStats.unreadInsightsCount
                         )
                     } catch (e: Throwable) {
                         ErrorReporter.getInstance().reportError("JCefComponent.scopeChanged", e)