Merge pull request #2287 from digma-ai/backend-version-tracking

track server version, don't rely on connection gained Closes #2277

Author: shalom938

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

@@ -19,7 +19,7 @@ public void executeProjectStartup(@NotNull Project project) {
 
             AnalyticsService.getInstance(project);
             //make sure BackendInfoHolder is initialized after AnalyticsService
-            BackendInfoHolder.getInstance(project).loadOnStartup();
+            BackendInfoHolder.getInstance(project);
         });
     }
 }

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

@@ -1,28 +1,32 @@
 package org.digma.intellij.plugin.analytics
 
 import com.intellij.collaboration.async.disposingScope
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeout
+import org.digma.intellij.plugin.common.DisposableAdaptor
 import org.digma.intellij.plugin.common.ExceptionUtils
 import org.digma.intellij.plugin.errorreporting.ErrorReporter
 import org.digma.intellij.plugin.log.Log
 import org.digma.intellij.plugin.model.rest.AboutResult
+import org.digma.intellij.plugin.posthog.ActivityMonitor
 import java.util.concurrent.atomic.AtomicReference
+import kotlin.time.Duration.Companion.minutes
 
 /**
  * keep the backend info and tracks it on connection events.
  * Its necessary because there is code that runs on EDT that may need the backend info. it's possible
  * in that case to do it on background but then the EDT will wait for the api call, and we don't want that.
  */
 @Service(Service.Level.PROJECT)
-class BackendInfoHolder(val project: Project) : Disposable {
+class BackendInfoHolder(val project: Project) : DisposableAdaptor {
 
     private val logger: Logger = Logger.getInstance(BackendInfoHolder::class.java)
 
@@ -35,14 +39,6 @@ class BackendInfoHolder(val project: Project) : Disposable {
         }
     }
 
-    fun loadOnStartup() {
-        updateInBackground()
-    }
-
-
-    override fun dispose() {
-        //nothing to do, used as parent disposable
-    }
 
     init {
         project.messageBus.connect(this)
@@ -64,29 +60,42 @@ class BackendInfoHolder(val project: Project) : Disposable {
                 Log.log(logger::debug, "got apiClientChanged")
                 updateInBackground()
             })
+
+
+        @Suppress("UnstableApiUsage")
+        disposingScope().launch {
+            while (isActive) {
+                update()
+                delay(1.minutes.inWholeMilliseconds)
+            }
+        }
     }
 
 
-    //updateInBackground is also called every time the analytics client is replaced
     private fun updateInBackground() {
         @Suppress("UnstableApiUsage")
         disposingScope().launch {
-            try {
-
-                aboutRef.set(AnalyticsService.getInstance(project).about)
+            update()
+        }
+    }
 
-            } catch (e: Throwable) {
-                val isConnectionException = ExceptionUtils.isAnyConnectionException(e)
 
-                if (!isConnectionException) {
-                    ErrorReporter.getInstance().reportError("BackendUtilsKt.updateInBackground", e)
-                }
+    //must be called in background coroutine
+    private fun update() {
+        try {
+            aboutRef.set(AnalyticsService.getInstance(project).about)
+            aboutRef.get()?.let {
+                ActivityMonitor.getInstance(project).registerServerInfo(it)
+            }
+        } catch (e: Throwable) {
+            val isConnectionException = ExceptionUtils.isAnyConnectionException(e)
+            if (!isConnectionException) {
+                ErrorReporter.getInstance().reportError("BackendInfoHolder.update", e)
             }
         }
     }
 
 
-
     fun getAbout(): AboutResult? {
         if (aboutRef.get() == null) {
             return getAboutInBackgroundNow()
@@ -104,7 +113,6 @@ class BackendInfoHolder(val project: Project) : Disposable {
     }
 
 
-
     fun isCentralized(): Boolean {
         return aboutRef.get()?.let {
             it.isCentralize ?: false
@@ -121,17 +129,9 @@ class BackendInfoHolder(val project: Project) : Disposable {
 
         @Suppress("UnstableApiUsage")
         val deferred = disposingScope().async {
-            try {
-                aboutRef.set(AnalyticsService.getInstance(project).about)
-            } catch (e: Throwable) {
-                val isConnectionException = ExceptionUtils.isAnyConnectionException(e)
-                if (!isConnectionException) {
-                    ErrorReporter.getInstance().reportError("BackendUtilsKt.getAboutInBackgroundNowWithTimeout", e)
-                }
-            }
+            update()
         }
 
-
         return runBlocking {
             try {
                 withTimeout(5000) {

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

@@ -13,6 +13,7 @@ import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.datetime.toJavaInstant
 import org.digma.intellij.plugin.analytics.BackendConnectionMonitor
+import org.digma.intellij.plugin.analytics.BackendInfoHolder
 import org.digma.intellij.plugin.common.ExceptionUtils
 import org.digma.intellij.plugin.common.UniqueGeneratedUserId
 import org.digma.intellij.plugin.common.objectToJson
@@ -85,7 +86,6 @@ class ActivityMonitor(private val project: Project) : Disposable {
 
         registerSessionDetails()
 
-        ServerVersionMonitor.getInstance(project)
         PluginActivityMonitor.getInstance(project)
 
         settingsChangeTracker.start(this)
@@ -334,7 +334,7 @@ class ActivityMonitor(private val project: Project) : Disposable {
                 "ide.version" to ideVersion,
                 "ide.build" to ideBuildNumber,
                 "plugin.version" to pluginVersion,
-                "server.version" to ServerVersionMonitor.getInstance(project).getServerVersion(),
+                "server.version" to BackendInfoHolder.getInstance(project).getAbout()?.applicationVersion.toString(),
                 "user.type" to if (isDevUser) "internal" else "external"
             )
 
@@ -423,7 +423,7 @@ class ActivityMonitor(private val project: Project) : Disposable {
         details["user.type"] = if (UniqueGeneratedUserId.isDevUser) "internal" else "external"
         details["error source"] = source
         details["plugin.version"] = pluginVersion
-        details["server.version"] = ServerVersionMonitor.getInstance(project).getServerVersion()
+        details["server.version"] = BackendInfoHolder.getInstance(project).getAbout()?.applicationVersion.toString()
 
 
         capture(
@@ -466,7 +466,7 @@ class ActivityMonitor(private val project: Project) : Disposable {
                     "ide.version" to ideVersion,
                     "ide.build" to ideBuildNumber,
                     "plugin.version" to pluginVersion,
-                    "server.version" to ServerVersionMonitor.getInstance(project).getServerVersion(),
+                    "server.version" to BackendInfoHolder.getInstance(project).getAbout()?.applicationVersion.toString(),
                     "user.type" to if (isDevUser) "internal" else "external"
                 )
             )