Merge

Author: opoliarush

CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
-## [2.0.321] - 2024-04-22
+## [2.0.324] - 2024-04-26
+
+- improve AuthManager by @shalom938 in https://github.com/digma-ai/digma-intellij-plugin/pull/2115
+
+## 2.0.323 - 2024-04-25
+
+- Update UI by @kshmidt-digma in https://github.com/digma-ai/digma-intellij-plugin/pull/2113
+
+## 2.0.322 - 2024-04-24
+
+- Feature/asset naviagation by @opoliarush in https://github.com/digma-ai/digma-intellij-plugin/pull/2105
+- Fixed error message for login by @opoliarush in https://github.com/digma-ai/digma-intellij-plugin/pull/2109
+- Update UI by @kshmidt-digma in https://github.com/digma-ai/digma-intellij-plugin/pull/2112
+
+## 2.0.321 - 2024-04-22
 
 - unify action names by @opoliarush in https://github.com/digma-ai/digma-intellij-plugin/pull/2094
 - catch exceptions in settings changed Closes #2100 by @shalom938 in https://github.com/digma-ai/digma-intellij-plugin/pull/2102

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

@@ -495,7 +495,6 @@ public InsightsStatsResult getInsightsStats(String spanCodeObjectId) throws Anal
             var env = getCurrentEnvironmentId();
             var envId = getCurrentEnvironmentId();
             var params = new HashMap<String, Object>();
-            params.put("Environment", env);
             params.put("Environment", envId);
 
             if (spanCodeObjectId != null) {

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

@@ -2,8 +2,9 @@
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
-import org.digma.intellij.plugin.errorreporting.ErrorReporter;
+import org.digma.intellij.plugin.errorreporting.*;
 
+import java.time.Duration;
 import java.util.function.Consumer;
 
 /**
@@ -15,6 +16,11 @@ public class Log {
     public static final String DIGMA = "Digma: ";
     public static final String DIGMA_PROJECT = "Digma: Project:";
 
+
+    private static final FrequentErrorDetector FREQUENT_ERROR_DETECTOR = new FrequentErrorDetector(Duration.ofMinutes(10));
+
+
+
     public static void log(Consumer<String> consumer, Project project, String format, Object... args) {
         consumer.accept(DIGMA_PROJECT + project.getName() + ": " + String.format(format.replace("{}", "%s"), args));
     }
@@ -24,18 +30,31 @@ public static void log(Consumer<String> consumer, String format, Object... args)
     }
 
     public static void debugWithException(Logger logger,Throwable e, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+            return;
+        }
+
         logger.debug(DIGMA + String.format(format.replace("{}", "%s"), args),e);
     }
 
     public static void debugWithException(Logger logger, Project project,Throwable e, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+            return;
+        }
         logger.debug(DIGMA_PROJECT + project.getName() + ": " + String.format(format.replace("{}", "%s"), args),e);
     }
 
     public static void warnWithException(Logger logger,Throwable e, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+            return;
+        }
         logger.warn(DIGMA + String.format(format.replace("{}", "%s"), args),e);
     }
 
     public static void warnWithException(Logger logger, Project project,Throwable e, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+            return;
+        }
         logger.warn(DIGMA_PROJECT + project.getName() + ": " + String.format(format.replace("{}", "%s"), args),e);
     }
 
@@ -49,15 +68,25 @@ public static void log(Consumer<String> consumer, String msg) {
     }
 
     public static void error(Logger logger,Project project, Exception exception, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, exception)) {
+            return;
+        }
+
         var msg = String.format(format.replace("{}", "%s"), args);
         error(logger, exception, DIGMA_PROJECT + project.getName() + ": " + msg);
         ErrorReporter.getInstance().reportError(project, "Log.error", exception);
     }
     public static void error(Logger logger, Exception exception, String format, Object... args) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, exception)) {
+            return;
+        }
         error(logger, exception, DIGMA + String.format(format.replace("{}", "%s"), args));
     }
 
     public static void error(Logger logger, Exception exception, String msg) {
+        if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(msg, exception)) {
+            return;
+        }
         logger.error(DIGMA + msg, exception);
     }
 

ide-common/src/main/kotlin/org/digma/intellij/plugin/auth/AbstractLoginHandler.kt

@@ -0,0 +1,70 @@
+package org.digma.intellij.plugin.auth
+
+import com.intellij.openapi.diagnostic.Logger
+import org.digma.intellij.plugin.analytics.AuthenticationException
+import org.digma.intellij.plugin.analytics.RestAnalyticsProvider
+import org.digma.intellij.plugin.auth.account.DigmaAccount
+import org.digma.intellij.plugin.auth.account.DigmaDefaultAccountHolder
+import org.digma.intellij.plugin.common.ExceptionUtils
+import org.digma.intellij.plugin.errorreporting.ErrorReporter
+import org.digma.intellij.plugin.log.Log
+
+abstract class AbstractLoginHandler(protected val analyticsProvider: RestAnalyticsProvider) : LoginHandler {
+
+    override val logger: Logger = Logger.getInstance(this::class.java)
+
+    protected val authApiClient = AuthApiClient(analyticsProvider)
+
+    protected fun defaultAccountExists(): Boolean {
+        return DigmaDefaultAccountHolder.getInstance().account != null
+    }
+
+    protected fun getDefaultAccount(): DigmaAccount? {
+        return DigmaDefaultAccountHolder.getInstance().account
+    }
+
+
+    override fun login(user: String, password: String): LoginResult {
+
+        return try {
+
+            reportPosthogEvent("login", mapOf("user" to user))
+
+            Log.log(logger::trace, "login called for url {}, user {}", analyticsProvider.apiUrl, user)
+
+            if (defaultAccountExists()) {
+                Log.log(logger::trace, "default account exists, deleting before login, {}", getDefaultAccount())
+                logout()
+            }
+
+            Log.log(logger::trace, "doing login for url {}, user {}", analyticsProvider.apiUrl, user)
+
+            val loginResult = authApiClient.login(user, password)
+
+            Log.log(logger::trace, "login success for url {}, user {}, created account {}", analyticsProvider.apiUrl, user, getDefaultAccount())
+
+            reportPosthogEvent("login success", mapOf("user" to user))
+
+            loginResult
+
+        } catch (e: Throwable) {
+
+            Log.warnWithException(logger, e, "Exception in login {}, url {}", e, analyticsProvider.apiUrl)
+            ErrorReporter.getInstance().reportError("AuthManager.login", e)
+
+            if (e is AuthenticationException) {
+                Log.warnWithException(logger, e, "Exception in login, url {}", analyticsProvider.apiUrl)
+                ErrorReporter.getInstance().reportError("AuthManager.login", e)
+                val errorMessage = ExceptionUtils.getNonEmptyMessage(e)
+                reportPosthogEvent("login failed", mapOf("user" to user, "error" to errorMessage.toString()))
+                //return no success LoginResult
+                LoginResult(false, null, e.detailedMessage)
+            }
+
+
+            LoginResult(false, null, ExceptionUtils.getNonEmptyMessage(e))
+
+        }
+    }
+
+}

ide-common/src/main/kotlin/org/digma/intellij/plugin/auth/AuthApiClient.kt

@@ -0,0 +1,59 @@
+package org.digma.intellij.plugin.auth
+
+import kotlinx.datetime.Clock
+import org.digma.intellij.plugin.analytics.RestAnalyticsProvider
+import org.digma.intellij.plugin.auth.account.DigmaAccount
+import org.digma.intellij.plugin.auth.account.DigmaAccountManager
+import org.digma.intellij.plugin.auth.credentials.DigmaCredentials
+import org.digma.intellij.plugin.model.rest.login.LoginRequest
+import org.digma.intellij.plugin.model.rest.login.RefreshRequest
+
+
+class AuthApiClient(private val analyticsProvider: RestAnalyticsProvider) {
+
+    @Synchronized
+    fun login(user: String, password: String): LoginResult {
+
+        val loginResponse = analyticsProvider.login(LoginRequest(user, password))
+
+        val digmaAccount = DigmaAccountManager.createAccount(analyticsProvider.apiUrl, loginResponse.userId)
+
+        val digmaCredentials = DigmaCredentials(
+            loginResponse.accessToken,
+            loginResponse.refreshToken,
+            analyticsProvider.apiUrl,
+            TokenType.Bearer.name,
+            loginResponse.expiration.time,
+            Clock.System.now().toEpochMilliseconds()
+        )
+
+        updateAccount(digmaAccount, digmaCredentials)
+
+        return LoginResult(true, loginResponse.userId, null)
+    }
+
+
+    @Synchronized
+    fun refreshToken(
+        digmaAccount: DigmaAccount,
+        credentials: DigmaCredentials
+    ): Boolean {
+
+        val loginResponse = analyticsProvider.refreshToken(RefreshRequest(credentials.accessToken, credentials.refreshToken))
+
+        val digmaCredentials = DigmaCredentials(
+            loginResponse.accessToken,
+            loginResponse.refreshToken,
+            digmaAccount.server.url,
+            TokenType.Bearer.name,
+            loginResponse.expiration.time,
+            Clock.System.now().toEpochMilliseconds()
+        )
+
+        updateAccount(digmaAccount, digmaCredentials)
+
+        return true
+
+    }
+
+}