Merge

Author: opoliarush

CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 
-## [2.0.328] - 2024-05-01
+## [2.0.331] - 2024-05-09
+
+- clear current env when deleting last env Closes #2139 by @shalom938
+  in https://github.com/digma-ai/digma-intellij-plugin/pull/2140
+- put jars urls in properties file by @shalom938 in https://github.com/digma-ai/digma-intellij-plugin/pull/2147
+
+## 2.0.330 - 2024-05-06
+
+- Update Digmathon by @kshmidt-digma in https://github.com/digma-ai/digma-intellij-plugin/pull/2134
+
+## 2.0.329 - 2024-05-05
+
+- prevent posthog errors when can't connect Closes #2041 by @shalom938
+  in https://github.com/digma-ai/digma-intellij-plugin/pull/2137
+- don't log NoSelectedEnvironmentException in warn level Closes #2136 by @shalom938
+  in https://github.com/digma-ai/digma-intellij-plugin/pull/2138
+
+## 2.0.328 - 2024-05-01
 
 - remove some info from settings events Closes #2013 by @shalom938 in https://github.com/digma-ai/digma-intellij-plugin/pull/2127
 - update build profiles by @shalom938 in https://github.com/digma-ai/digma-intellij-plugin/pull/2131

ide-common/build.gradle.kts

@@ -31,6 +31,7 @@ dependencies {
     api(libs.maven.artifact)
     api(libs.glovoapp.versioning)
     api(libs.byte.buddy)
+    api(libs.jackson.datetime)
 
 
     implementation(project(":model"))

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/java/org/digma/intellij/plugin/common/EDT.java

@@ -36,7 +36,7 @@ public static void assertEDT(String message) {
         }
         //log an error here, intellij will pop up an error message. usually we don't want an error message
         // but this should be caught in development time.
-        Log.log(LOGGER::error,message);
+        LOGGER.error(message);
     }
 
 

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

@@ -2,6 +2,7 @@
 
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
+import org.digma.intellij.plugin.analytics.NoSelectedEnvironmentException;
 import org.digma.intellij.plugin.errorreporting.*;
 
 import java.time.Duration;
@@ -18,7 +19,7 @@ public class Log {
     public static final String API_LOGGER_NAME = "api.digma.org";
 
 
-    private static final FrequentErrorDetector FREQUENT_ERROR_DETECTOR = new FrequentErrorDetector(Duration.ofMinutes(10));
+    private static final FrequentErrorDetector FREQUENT_ERROR_DETECTOR = new FrequentErrorDetector(Duration.ofMinutes(30));
 
 
 
@@ -31,6 +32,11 @@ public static void log(Consumer<String> consumer, String format, Object... args)
     }
 
     public static void debugWithException(Logger logger,Throwable e, String format, Object... args) {
+
+        if (!logger.isDebugEnabled()) {
+            return;
+        }
+
         if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
             return;
         }
@@ -39,24 +45,43 @@ public static void debugWithException(Logger logger,Throwable e, String format,
     }
 
     public static void debugWithException(Logger logger, Project project,Throwable e, String format, Object... args) {
+
+        if (!logger.isDebugEnabled()) {
+            return;
+        }
+
         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;
+
+        //don't log NoSelectedEnvironmentException in warn level
+        if (e instanceof NoSelectedEnvironmentException) {
+            debugWithException(logger, e, format, args);
+        } else {
+            if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+                return;
+            }
+            logger.warn(DIGMA + String.format(format.replace("{}", "%s"), args), e);
         }
-        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;
+
+        //don't log NoSelectedEnvironmentException in warn level
+        if (e instanceof NoSelectedEnvironmentException) {
+            debugWithException(logger, project, e, format, args);
+        } else {
+            if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(format, e)) {
+                return;
+            }
+            logger.warn(DIGMA_PROJECT + project.getName() + ": " + String.format(format.replace("{}", "%s"), args), e);
         }
-        logger.warn(DIGMA_PROJECT + project.getName() + ": " + String.format(format.replace("{}", "%s"), args),e);
     }
 
 
@@ -68,30 +93,40 @@ public static void log(Consumer<String> consumer, String msg) {
         consumer.accept(DIGMA + 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);
+    //Note: We should never log error in intellij because logging error will popup a red error to the user.
+
+    private static void error(Logger logger, Project project, Exception exception, String format, Object... args) {
+
+        if (exception instanceof NoSelectedEnvironmentException) {
+            debugWithException(logger, exception, format, args);
+        } else {
+
+            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) {
+
+    private 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) {
+    private static void error(Logger logger, Exception exception, String msg) {
         if (FREQUENT_ERROR_DETECTOR.isTooFrequentException(msg, exception)) {
             return;
         }
         logger.error(DIGMA + msg, exception);
     }
 
-    public static void error(Logger logger, String msg) {
+    private static void error(Logger logger, String msg) {
         logger.error(DIGMA + msg);
     }
 

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

@@ -3,19 +3,37 @@ package org.digma.intellij.plugin.common
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.databind.util.StdDateFormat
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 
 
 /**
  * a factory for ObjectMapper to be used by components and services that need an ObjectMapper,
  * makes sure all will use the same configuration.
  */
 fun createObjectMapper(): ObjectMapper {
+    //Note that it is risky to change configuration or install modules.
+    // because there are components that already use this object mapper as is
+    // and changes to configuration may cause issues. its probably mainly dates that were
+    // serialized to persistence.
+    //but, probably installing the JavaTimeModule should be OK because it's backwards compatible.
+    //users of this factory may change configuration on the instance they create.
     val objectMapper = ObjectMapper()
     objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
     objectMapper.setDateFormat(StdDateFormat())
     return objectMapper
 }
 
+
+fun createObjectMapperWithJavaTimeModule(): ObjectMapper {
+    //install the JavaTimeModule for better serialization of dates
+    val objectMapper = ObjectMapper()
+    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+    objectMapper.registerModules(JavaTimeModule())
+    objectMapper.setDateFormat(StdDateFormat())
+    return objectMapper
+}
+
+
 /**
  * ObjectMapper is fully thread safe and does not need to be created many times.
  * usually its more convenient to create a class member in classes that need to use an ObjectMapper

ide-common/src/main/kotlin/org/digma/intellij/plugin/digmathon/DigmathonProductKey.kt

@@ -9,11 +9,13 @@ import java.nio.charset.StandardCharsets
 
 
 private const val MY_SERVICE = "org.digma.digmathon.productKey"
-private const val MY_KEY = "product-key-2024.4"
+
+//change MY_KEY for every new dismathon
+private const val MY_KEY = "product-key-2024.5"
 
 class DigmathonProductKey {
 
-    private val myHash = "b9fe040958b98f68533511125bc104435bfefd4293b328060992767d51333321"
+    private val myHash = "89e0f23f9a0a670b2bb7393a1280aa59eaf7c59c22b77d869b5c9c7af021785f"
 
     @Throws(InvalidProductKeyException::class)
     fun validateAndSave(productKey: String) {