Merge pull request #2246 from digma-ai/api-performance-monitor

api performance issue event Closes #2245

Author: shalom938

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

@@ -707,7 +707,10 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
                 throw e;
             } finally {
                 stopWatch.stop();
-                Log.log(LOGGER::trace, "Api call {} took {} milliseconds", method.getName(), stopWatch.getTime(TimeUnit.MILLISECONDS));
+                project.getService(ApiPerformanceMonitor.class).addPerformance(method.getName(),stopWatch.getTime(TimeUnit.MILLISECONDS));
+                if (LOGGER.isTraceEnabled()) {
+                    Log.log(LOGGER::trace, "Api call {} took {} milliseconds", method.getName(), stopWatch.getTime(TimeUnit.MILLISECONDS));
+                }
             }
         }
 

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

@@ -3,6 +3,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.common.FrequencyDetector;
 import org.digma.intellij.plugin.errorreporting.*;
 
 import java.time.Duration;
@@ -19,7 +20,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(30));
+    private static final FrequencyDetector FREQUENT_ERROR_DETECTOR = new FrequencyDetector(Duration.ofMinutes(30));
 
 
 

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

@@ -0,0 +1,56 @@
+package org.digma.intellij.plugin.analytics
+
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.project.Project
+import org.digma.intellij.plugin.common.FrequencyDetector
+import org.digma.intellij.plugin.posthog.ActivityMonitor
+import java.util.Collections
+import kotlin.math.max
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.toJavaDuration
+
+
+@Service(Service.Level.PROJECT)
+class ApiPerformanceMonitor(private val project: Project) {
+
+    private val frequencyDetector = FrequencyDetector(10.minutes.toJavaDuration())
+
+    private val durations = Collections.synchronizedMap(mutableMapOf<String, Long>())
+
+    //this method is not thread safe. max duration for apiName may not be the real max if two threads for
+    // the same apiName run concurrently, and they have different durations.
+    //it's not a bug just not completely accurate reporting.
+    //the only way to make it accurate is to lock the code that computes max and puts it in the durations map.
+    //but locking means that threads will wait for each other.
+    //it's possible to execute this code in a coroutine, and then It's ok to lock, but the error is minor and doesn't
+    // worth the complexity of a coroutine.
+    fun addPerformance(apiName: String, duration: Long) {
+        if (duration < 2000) {
+            return
+        }
+
+        val max = max(duration, durations[apiName] ?: 0L)
+        durations[apiName] = max
+
+        report(apiName, max)
+    }
+
+    private fun report(apiName: String, duration: Long) {
+        if (frequencyDetector.isTooFrequentMessage(apiName)) {
+            return
+        }
+
+        //reset the max duration before reporting, new one will be collected
+        durations[apiName] = 0L
+
+        val details = mutableMapOf<String, Any>(
+            "api name" to apiName,
+            "duration" to duration
+        )
+
+        ActivityMonitor.getInstance(project).reportApiPerformanceIssue(details)
+
+    }
+
+
+}

…/errorreporting/FrequentErrorDetector.kt …ellij/plugin/common/FrequencyDetector.ktide-common/src/main/kotlin/org/digma/intellij/plugin/errorreporting/FrequentErrorDetector.kt renamed to ide-common/src/main/kotlin/org/digma/intellij/plugin/common/FrequencyDetector.kt ide-common/src/main/kotlin/org/digma/intellij/plugin/errorreporting/FrequentErrorDetector.kt renamed to ide-common/src/main/kotlin/org/digma/intellij/plugin/common/FrequencyDetector.kt

@@ -1,4 +1,4 @@
-package org.digma.intellij.plugin.errorreporting
+package org.digma.intellij.plugin.common
 
 import com.github.benmanes.caffeine.cache.Caffeine
 import com.intellij.openapi.diagnostic.UntraceableException
@@ -8,11 +8,20 @@ import java.util.concurrent.atomic.AtomicInteger
 import kotlin.time.Duration
 import kotlin.time.toKotlinDuration
 
-class FrequentErrorDetector(cacheExpirationTime: java.time.Duration) {
+class FrequencyDetector(cacheExpirationTime: java.time.Duration) {
 
     private val myCache = MyCache(cacheExpirationTime.toKotlinDuration())
 
 
+    fun isTooFrequentMessage(message: String): Boolean {
+        val counter = myCache.getOrCreate(message)
+        val occurrences = counter.incrementAndGet()
+        return occurrences > 1
+    }
+
+
+
+
     fun isTooFrequentError(message: String, action: String): Boolean {
         val counter = myCache.getOrCreate(message, action)
         val occurrences = counter.incrementAndGet()
@@ -84,4 +93,8 @@ private class MyCache(cacheExpirationTime: Duration) {
     fun getOrCreate(message: String, action: String): AtomicInteger {
         return cache.get("$message:$action") { AtomicInteger() }
     }
+
+    fun getOrCreate(message: String): AtomicInteger {
+        return cache.get(message) { AtomicInteger() }
+    }
 }

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

@@ -11,6 +11,7 @@ import net.bytebuddy.implementation.bind.annotation.RuntimeType
 import net.bytebuddy.matcher.ElementMatchers
 import org.digma.intellij.plugin.analytics.NoSelectedEnvironmentException
 import org.digma.intellij.plugin.common.ExceptionUtils
+import org.digma.intellij.plugin.common.FrequencyDetector
 import org.digma.intellij.plugin.common.findActiveProject
 import org.digma.intellij.plugin.common.isProjectValid
 import org.digma.intellij.plugin.log.Log
@@ -29,7 +30,7 @@ open class ErrorReporter {
 
     private val logger: Logger = Logger.getInstance(this::class.java)
 
-    private val frequentErrorDetector = FrequentErrorDetector(60.minutes.toJavaDuration())
+    private val frequencyDetector = FrequencyDetector(60.minutes.toJavaDuration())
 
     //must be public class
     class MyPauseInterceptor {
@@ -119,7 +120,7 @@ open class ErrorReporter {
     open fun reportError(project: Project?, message: String, action: String, details: Map<String, String>) {
 
 
-        if (frequentErrorDetector.isTooFrequentError(message, action)) {
+        if (frequencyDetector.isTooFrequentError(message, action)) {
             return
         }
 
@@ -150,7 +151,7 @@ open class ErrorReporter {
                 return
             }
 
-            if (frequentErrorDetector.isTooFrequentException(message, throwable)) {
+            if (frequencyDetector.isTooFrequentException(message, throwable)) {
                 return
             }
 
@@ -187,7 +188,7 @@ open class ErrorReporter {
     ) {
 
         try {
-            if (frequentErrorDetector.isTooFrequentException(message, exception)) {
+            if (frequencyDetector.isTooFrequentException(message, exception)) {
                 return
             }
 
@@ -208,7 +209,7 @@ open class ErrorReporter {
     }
 
     open fun reportBackendError(project: Project?, message: String, action: String) {
-        if (frequentErrorDetector.isTooFrequentError(message, action)) {
+        if (frequencyDetector.isTooFrequentError(message, action)) {
             return
         }
 
@@ -234,7 +235,7 @@ open class ErrorReporter {
     // if the error is not a result of an exception create a new RuntimeException and send it, so we have the stack trace.
     open fun reportInternalFatalError(project: Project, source: String, exception: Throwable, details: Map<String, String> = mapOf()) {
 
-        if (frequentErrorDetector.isTooFrequentException(source, exception)) {
+        if (frequencyDetector.isTooFrequentException(source, exception)) {
             return
         }
 

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

@@ -989,5 +989,11 @@ class ActivityMonitor(private val project: Project) : Disposable {
         return PersistenceService.getInstance().getUserRegistrationEmail() ?: PersistenceService.getInstance().getUserEmail() ?: ""
     }
 
+    fun reportApiPerformanceIssue(details: MutableMap<String, Any>) {
+        capture(
+            "api-performance-issue",details
+        )
+    }
+
 
 }