Merge pull request #2396 from digma-ai/fix-some-posthog-events

reorganize first time plugin loaded persistence and event Closes #2391

Author: shalom938

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

@@ -1,43 +1,39 @@
 package org.digma.intellij.plugin.common;
 
+import com.intellij.openapi.components.Service;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.*;
-import com.intellij.util.PlatformUtils;
-import org.digma.intellij.plugin.persistence.PersistenceService;
 import org.digma.intellij.plugin.psi.*;
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.*;
 
-@SuppressWarnings("UnstableApiUsage")
-public class IDEUtilsService {
+/*
+This class is not perfect but it does serve our needs.
+see the comments in com.intellij.util.PlatformUtils, PlatformUtils is marked internal API so its better not to user it.
+for what we need its probably ok:
+isIdeaIDE() is for sure Idea if we have JavaLanguageService installed.
+isRiderIDE() is for sure rider if we have CHarpLanguageService installed.
+isPyCharmIDE() is for sure pycharm if we have PythonLanguageService installed and it's not Idea.
+if we need more capabilities here we need to explore the technics suggested in com.intellij.util.PlatformUtils
+ */
 
-    private final IsRider isRider;
-    private final IsIdea isIdea;
+@Service(Service.Level.PROJECT)
+public final class IDEUtilsService {
+
+    private final Idea idea;
+    private final Rider rider;
+    private final Pycharm pycharm;
 
 
     public IDEUtilsService(Project project) {
-        isRider = new IsRider(project);
-        isIdea = new IsIdea(project);
+        idea = new Idea(project);
+        rider = new Rider(project);
+        pycharm = new Pycharm(project);
     }
 
     public static IDEUtilsService getInstance(@NotNull Project project){
         return project.getService(IDEUtilsService.class);
     }
 
 
-    public static boolean isAlreadyPassedInstallationWizard(){
-        PersistenceService persistenceService = PersistenceService.getInstance();
-        return IDEUtilsService.isIdeaIDE() && persistenceService.isAlreadyPassedTheInstallationWizardForIdeaIDE() ||
-                IDEUtilsService.isRiderIDE() && persistenceService.isAlreadyPassedTheInstallationWizardForRiderIDE() ||
-                IDEUtilsService.isPyCharmIDE() && persistenceService.isAlreadyPassedTheInstallationWizardForPyCharmIDE();
-    }
-
-
-    public static boolean shouldOpenWizard(){
-        return !isAlreadyPassedInstallationWizard();
-    }
-
-
     /*
     There is no easy way to know if a project is a java project. intellij doesn't have a project type. intellij projects
     have modules and each module has some nature. there may be a project that contains a java module and python module,
@@ -49,110 +45,76 @@ public static boolean shouldOpenWizard(){
     mean that its pycharm.
      */
     public boolean isJavaProject() {
-        return (PlatformUtils.isIdeaCommunity() || PlatformUtils.isIdeaUltimate()) && isIdea.isIdea();
+        return idea.is();
     }
 
+    //this is not accurate, it may be rider but not a C# project
     public boolean isCSharpProject() {
-        return (PlatformUtils.isIdeaCommunity() || PlatformUtils.isIdeaUltimate()) && isRider.isRider();
-    }
-
-
-    public static boolean isIdeaIDE() {
-        return PlatformUtils.isIdeaCommunity() || PlatformUtils.isIdeaUltimate();
+        return rider.is();
     }
 
-    public static boolean isRiderIDE() {
-        return PlatformUtils.isRider();
-    }
 
-    public static boolean isPyCharmIDE() {
-        return PlatformUtils.isPyCharm() || PlatformUtils.isPyCharmCommunity() || PlatformUtils.isPyCharmEducational();
+    public boolean isIdeaIDE() {
+        return idea.is();
     }
 
-    public boolean isRiderAndCSharpFile(@NotNull Project project, VirtualFile file) {
-
-        //it may be a C# file that was opened from vcs, it doesn't count as C# that CSharpLanguageService should handle
-        if (!VfsUtilsKt.isValidVirtualFile(file)) {
-            return false;
-        }
-
-        if (isRider.isRider()) {
-            LanguageService csharpLanguageService = isRider.getCSharpLanguageService();
-            PsiFile psiFile = PsiAccessUtilsKt.runInReadAccessWithResult(() -> PsiManager.getInstance(project).findFile(file));
-            if (!PsiUtils.isValidPsiFile(psiFile)) {
-                return false;
-            }
-            return csharpLanguageService.isServiceFor(psiFile.getLanguage());
-        }
-
-        return false;
+    public boolean isRiderIDE() {
+        return rider.is();
     }
 
-    public boolean isRider() {
-        return isRider.isRider();
+    public boolean isPyCharmIDE() {
+        //python plugin may also be installed on Idea
+        return pycharm.is() && !idea.is();
     }
 
 
-
-
-    private static class IsRider {
+    private static abstract class IsIDE {
 
         private LanguageService myLanguageService = null;
 
-        public IsRider(Project project) {
-            init(project);
+        private IsIDE(Project project, SupportedLanguages language) {
+            init(project, language);
         }
 
-        @SuppressWarnings("unchecked")
-        private void init(Project project) {
-            Class<LanguageService> cshrpLanguageServiceClass;
+        private void init(Project project, SupportedLanguages language) {
             try {
-                cshrpLanguageServiceClass = (Class<LanguageService>) Class.forName(SupportedLanguages.CSHARP.getLanguageServiceClassName());
-                myLanguageService = project.getService(cshrpLanguageServiceClass);
+                @SuppressWarnings("unchecked") Class<LanguageService> languageServiceClass = (Class<LanguageService>) Class.forName(language.getLanguageServiceClassName());
+                //noinspection IncorrectServiceRetrieving
+                myLanguageService = project.getService(languageServiceClass);
             } catch (Throwable ignored) {
                 //catch throwable and not exception because it may be Error like NoClassDefFound
             }
         }
 
-        public boolean isRider() {
+        boolean is() {
             return myLanguageService != null;
         }
 
-        public LanguageService getCSharpLanguageService() {
+        @Nullable
+        LanguageService getLanguageService() {
             return myLanguageService;
         }
-    }
-
 
+    }
 
-    private static class IsIdea {
 
-        private LanguageService myLanguageService = null;
-
-        public IsIdea(Project project) {
-            init(project);
-        }
-
-        @SuppressWarnings("unchecked")
-        private void init(Project project) {
-            Class<LanguageService> javaLanguageServiceClass;
-            try {
-                javaLanguageServiceClass = (Class<LanguageService>) Class.forName(SupportedLanguages.JAVA.getLanguageServiceClassName());
-                myLanguageService = project.getService(javaLanguageServiceClass);
-            } catch (Throwable ignored) {
-                //catch throwable and not exception because it may be Error like NoClassDefFound
-            }
+    private static class Rider extends IsIDE {
+        private Rider(Project project) {
+            super(project, SupportedLanguages.CSHARP);
         }
+    }
 
-        public boolean isIdea() {
-            return myLanguageService != null;
+    private static class Idea extends IsIDE {
+        private Idea(Project project) {
+            super(project, SupportedLanguages.JAVA);
         }
+    }
 
-        public LanguageService getJavaLanguageService() {
-            return myLanguageService;
+    private static class Pycharm extends IsIDE {
+        private Pycharm(Project project) {
+            super(project, SupportedLanguages.PYTHON);
         }
     }
 
 
-
 }

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

@@ -1,7 +1,7 @@
 package org.digma.intellij.plugin.common;
 
-import com.intellij.ide.util.RunOnceUtil;
 import com.intellij.openapi.project.*;
+import org.digma.intellij.plugin.persistence.PersistenceService;
 import org.digma.intellij.plugin.posthog.ActivityMonitor;
 import org.digma.intellij.plugin.session.SessionMetadataProperties;
 import org.digma.intellij.plugin.startup.DigmaProjectActivity;
@@ -17,10 +17,14 @@ public class StartupStartupActivity extends DigmaProjectActivity {
 
     @Override
     public void executeProjectStartup(@NotNull Project project) {
-        RunOnceUtil.runOnceForApp(RUN_ONCE_ID, () -> {
+
+        //can't rely on intellij RunOnceUtil.runOnceForApp because it will run it again on ide upgrades
+        if (PersistenceService.getInstance().isFirstTimePluginLoaded()) {
+            PersistenceService.getInstance().setFirstTimePluginLoadedDone();
             ActivityMonitor.getInstance(project).registerFirstTimePluginLoaded();
             project.getService(DumbService.class).runWhenSmart(() -> EDT.ensureEDT(() -> ToolWindowShower.getInstance(project).showToolWindow()));
-        });
+        }
+
         ActivityMonitor.getInstance(project).registerPluginLoaded();
         SessionMetadataProperties.getInstance().put(getPluginLoadedKey(project), true);
     }

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

@@ -21,7 +21,6 @@
 import java.util.function.*;
 
 import static org.digma.intellij.plugin.analytics.EnvUtilsKt.refreshEnvironmentsNowOnBackground;
-import static org.digma.intellij.plugin.persistence.PersistenceUtilsKt.updateInstallationWizardFlag;
 import static org.digma.intellij.plugin.scheduling.SchedulersKt.oneShotTask;
 
 /**
@@ -106,7 +105,6 @@ public void connectionGained() {
                 if (isCentralized()) {
                     //do here everything that happens on INSTALLATION_WIZARD/FINISH message
                     PersistenceService.getInstance().firstWizardLaunchDone();
-                    updateInstallationWizardFlag();
                     EDT.ensureEDT(() -> {
                         ToolWindowShower.getInstance(project).showToolWindow();
                         project.getService(RecentActivityToolWindowShower.class).showToolWindow();
@@ -296,7 +294,7 @@ public void closeCoveringViewsIfNecessary() {
         //in case user finished new install but never clicked finish in the wizard, and clicks a link somewhere,
         // for example in recent activity, then close everything to show the main panel
         if (wizard.isOn()) {
-            updateInstallationWizardFlag();
+            PersistenceService.getInstance().firstWizardLaunchDone();
         }
         wizardFinished();
         troubleshootingFinished();

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

@@ -19,9 +19,6 @@ internal data class PersistenceData(
     // remove isAutoOtel after some versions, can remove in June 2024 when probably all users updated the plugin
     var isAutoOtel: Boolean = true,
     var isObservabilityEnabled: Boolean = true,
-    var alreadyPassedTheInstallationWizardForIdeaIDE: Boolean = false,
-    var alreadyPassedTheInstallationWizardForRiderIDE: Boolean = false,
-    var alreadyPassedTheInstallationWizardForPyCharmIDE: Boolean = false,
     var firstWizardLaunch: Boolean = true,
 
 
@@ -64,8 +61,6 @@ internal data class PersistenceData(
     @OptionTag(converter = InstantConverter::class)
     var firstTimeRecentActivityReceivedTimestamp: Instant? = null,
 
-    //todo: remove isFirstTimePluginLoaded in May 2024
-    var isFirstTimePluginLoaded: Boolean = false,
     @OptionTag(converter = InstantConverter::class)
     var firstTimePluginLoadedTimestamp: Instant? = null,
 

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

@@ -72,15 +72,10 @@ class PersistenceService {
     }
 
     fun isFirstTimePluginLoaded(): Boolean {
-        //todo: backwards compatibility, remove state.isFirstTimePluginLoaded on May 2024
-        if (state.isFirstTimePluginLoaded && state.firstTimePluginLoadedTimestamp == null) {
-            state.firstTimePluginLoadedTimestamp = Instant.now()
-        }
-
-        return state.firstTimePluginLoadedTimestamp != null
+        return state.firstTimePluginLoadedTimestamp == null
     }
 
-    fun setFirstTimePluginLoaded() {
+    fun setFirstTimePluginLoadedDone() {
         state.firstTimePluginLoadedTimestamp = Instant.now()
     }
 
@@ -148,29 +143,6 @@ class PersistenceService {
         state.isAutoOtel = isObservabilityEnabled
     }
 
-    fun isAlreadyPassedTheInstallationWizardForIdeaIDE(): Boolean {
-        return state.alreadyPassedTheInstallationWizardForIdeaIDE
-    }
-
-    fun setAlreadyPassedTheInstallationWizardForIdeaIDE() {
-        state.alreadyPassedTheInstallationWizardForIdeaIDE = true
-    }
-
-    fun isAlreadyPassedTheInstallationWizardForRiderIDE(): Boolean {
-        return state.alreadyPassedTheInstallationWizardForRiderIDE
-    }
-
-    fun setAlreadyPassedTheInstallationWizardForRiderIDE() {
-        state.alreadyPassedTheInstallationWizardForRiderIDE = true
-    }
-
-    fun isAlreadyPassedTheInstallationWizardForPyCharmIDE(): Boolean {
-        return state.alreadyPassedTheInstallationWizardForPyCharmIDE
-    }
-
-    fun setAlreadyPassedTheInstallationWizardForPyCharmIDE() {
-        state.alreadyPassedTheInstallationWizardForPyCharmIDE = true
-    }
 
 
     fun isFirstTimeConnectionEstablished(): Boolean {

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

@@ -646,12 +646,7 @@ class ActivityMonitor(private val project: Project, cs: CoroutineScope) : Dispos
     }
 
 
-    //todo: remove at some point
     fun registerFirstTimePluginLoaded() {
-        postHog?.capture(UniqueGeneratedUserId.userId, "plugin first-loaded")
-    }
-
-    fun registerFirstTimePluginLoadedNew() {
         postHog?.capture(UniqueGeneratedUserId.userId, "plugin first-init")
     }