Merge pull request #2300 from digma-ai/api-performance-http-neto

api performance neto http

Author: shalom938

analytics-provider/build.gradle.kts

@@ -29,6 +29,7 @@ dependencies {
     implementation(libs.retrofit.scalars)
     implementation(libs.jackson.datetime)
     implementation(libs.guava)
+    implementation(libs.commons.lang3)
     implementation(libs.okhttp.logging) {
         isTransitive = false
     }

analytics-provider/src/main/java/org/digma/intellij/plugin/analytics/RestAnalyticsProvider.java

@@ -5,6 +5,7 @@
 import com.google.common.io.CharStreams;
 import okhttp3.*;
 import okhttp3.logging.HttpLoggingInterceptor;
+import org.apache.commons.lang3.time.StopWatch;
 import org.digma.intellij.plugin.model.rest.AboutResult;
 import org.digma.intellij.plugin.model.rest.assets.AssetDisplayInfo;
 import org.digma.intellij.plugin.model.rest.codelens.*;
@@ -45,6 +46,8 @@
 
 public class RestAnalyticsProvider implements AnalyticsProvider, Closeable {
 
+    public static final ThreadLocal<Long> PERFORMANCE = new ThreadLocal<>();
+
     private final Client client;
     private final String apiUrl;
 
@@ -498,6 +501,8 @@ public Client(String baseUrl, List<AuthenticationProvider> authenticationProvide
             }));
 
 
+            addPerformanceInterceptor(builder);
+
             //always add the logging interceptor last, so it will log info from all other interceptors
             addLoggingInterceptor(builder, logger);
 
@@ -521,6 +526,20 @@ public Client(String baseUrl, List<AuthenticationProvider> authenticationProvide
             analyticsProvider = retrofit.create(AnalyticsProviderRetrofit.class);
         }
 
+        private void addPerformanceInterceptor(OkHttpClient.Builder builder) {
+            builder.addInterceptor(chain -> {
+                PERFORMANCE.remove();
+                var stopWatch = StopWatch.createStarted();
+                try {
+                    return chain.proceed(chain.request());
+                } finally {
+                    stopWatch.stop();
+                    var time = stopWatch.getTime(TimeUnit.MILLISECONDS);
+                    PERFORMANCE.set(time);
+                }
+            });
+        }
+
 
         private void addLoggingInterceptor(OkHttpClient.Builder builder, Consumer<String> logger) {
 
@@ -535,6 +554,7 @@ private void addLoggingInterceptor(OkHttpClient.Builder builder, Consumer<String
             logging.setLevel(HttpLoggingInterceptor.Level.BODY);
             if (!logSensitive) {
                 logging.redactHeader("Authorization");
+                logging.redactHeader("Digma-Access-Token");
             }
             builder.addInterceptor(logging);
         }

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

@@ -692,7 +692,11 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
             } finally {
                 stopWatch.stop();
                 if (BackendConnectionMonitor.getInstance(project).isConnectionOk()) {
-                    project.getService(ApiPerformanceMonitor.class).addPerformance(method.getName(), stopWatch.getTime(TimeUnit.MILLISECONDS));
+                    //httpNetoTime may be null, usually it will not but the ThreadLocal is nullable by default so need to check
+                    var httpNetoTime = RestAnalyticsProvider.PERFORMANCE.get();
+                    if (httpNetoTime != null) {
+                        project.getService(ApiPerformanceMonitor.class).addPerformance(method.getName(), stopWatch.getTime(TimeUnit.MILLISECONDS), httpNetoTime);
+                    }
                 }
                 if (LOGGER.isTraceEnabled()) {
                     Log.log(LOGGER::trace, "Api call {} took {} milliseconds", method.getName(), stopWatch.getTime(TimeUnit.MILLISECONDS));

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

@@ -5,7 +5,6 @@ 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
 
@@ -15,7 +14,7 @@ class ApiPerformanceMonitor(private val project: Project) {
 
     private val frequencyDetector = FrequencyDetector(10.minutes.toJavaDuration())
 
-    private val durations = Collections.synchronizedMap(mutableMapOf<String, Long>())
+    private val durations = Collections.synchronizedMap(mutableMapOf<String, Pair<Long, 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.
@@ -24,28 +23,37 @@ class ApiPerformanceMonitor(private val project: Project) {
     //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) {
+    fun addPerformance(apiName: String, duration: Long, httpNetoTime: Long) {
         if (duration < 2000) {
             return
         }
 
-        val max = max(duration, durations[apiName] ?: 0L)
-        durations[apiName] = max
+        val current = Pair(duration, httpNetoTime)
+        val latest = durations[apiName] ?: Pair(0L, 0L)
+        //put the max in the map
+        val toReport = if (current.first > latest.first) {
+            durations[apiName] = current
+            current
+        } else {
+            durations[apiName] = latest
+            latest
+        }
 
-        report(apiName, max)
+        report(apiName, toReport.first, toReport.second)
     }
 
-    private fun report(apiName: String, duration: Long) {
+    private fun report(apiName: String, duration: Long, httpNetoTime: Long) {
         if (frequencyDetector.isTooFrequentMessage(apiName)) {
             return
         }
 
         //reset the max duration before reporting, new one will be collected
-        durations[apiName] = 0L
+        durations[apiName] = Pair(0L, 0L)
 
         val details = mutableMapOf<String, Any>(
             "api name" to apiName,
-            "duration" to duration
+            "duration" to duration,
+            "http neto" to httpNetoTime
         )
 
         ActivityMonitor.getInstance(project).reportApiPerformanceIssue(details)