Merge pull request #402 from digma-ai/feat/add_links_on_insights

borisermakof · web-flow · commit a40253c87ac1 · 2023-03-22T16:26:03.000+01:00
Add links to TopUsage/Bottleneck/ScalingRootCause insights
diff --git a/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/BuildersHolder.java b/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/BuildersHolder.java
@@ -17,6 +17,7 @@
 import org.digma.intellij.plugin.model.rest.insights.SpanSlowEndpointsInsight;
 import org.digma.intellij.plugin.model.rest.insights.SpanUsagesInsight;
 import org.digma.intellij.plugin.model.rest.insights.UnmappedInsight;
+import org.digma.intellij.plugin.model.rest.insights.SpanScalingRootCauseInsight;
 import org.digma.intellij.plugin.ui.model.insights.InsightGroupType;
 import org.digma.intellij.plugin.view.EmptyListViewItemBuilder;
 import org.digma.intellij.plugin.view.ListViewItemBuilder;
@@ -56,6 +57,8 @@ private ListViewItemBuilder<? extends CodeObjectInsight> newBuilder(InsightType
                 return new GroupListViewItemBuilder<SpanDurationsInsight>(InsightGroupType.Span, null, spanDurationsInsight -> spanDurationsInsight.spanName());
             case SpanScaling:
                 return new GroupListViewItemBuilder<SpanScalingInsight>(InsightGroupType.Span, null, SpanScalingInsight::spanName);
+            case SpanScalingRootCause:
+                return new GroupListViewItemBuilder<SpanScalingRootCauseInsight>(InsightGroupType.Span, null, SpanScalingRootCauseInsight::spanName);
             case SpanDurationBreakdown:
                 return new GroupListViewItemBuilder<SpanDurationBreakdownInsight>(InsightGroupType.Span, null, SpanDurationBreakdownInsight::spanName);
             case SpanEndpointBottleneck:
diff --git a/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/GroupListViewItemBuilder.java b/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/GroupListViewItemBuilder.java
@@ -12,6 +12,7 @@
 import org.digma.intellij.plugin.view.ListViewItemBuilder;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -54,23 +55,60 @@ public List<ListViewItem<?>> build(Project project, @NotNull MethodInfo methodIn
                 WorkspaceUrisHelper.findWorkspaceUrisForSpans(project,theListView, getSpanIds((SpanScalingInsight) insight), methodInfo);
                 break;
             }
+            case SpanEndpointBottleneck: {
+                WorkspaceUrisHelper.findWorkspaceUrisForMethodCodeObjectIds(project, theListView, getCodeObjectIds((SpanSlowEndpointsInsight) insight), methodInfo);
+                break;
+            }
+            case SpanUsages: {
+                WorkspaceUrisHelper.findWorkspaceUrisForMethodCodeObjectIds(project, theListView, getCodeObjectIds((SpanUsagesInsight) insight), methodInfo);
+                break;
+            }
+            case SpanScalingRootCause: {
+                WorkspaceUrisHelper.findWorkspaceUrisForMethodCodeObjectIds(project, theListView, getCodeObjectIds((SpanScalingRootCauseInsight) insight), methodInfo);
+                break;
+            }
         }
 
         theGroup.addItem(theListView);
 
         return List.of();
     }
 
+    private List<String> getCodeObjectIds(SpanUsagesInsight insight) {
+        var codeObjectIds = new ArrayList<String>();
+        for (SpanFlow ins: insight.getFlows()) {
+            var firstServiceId = ins.getFirstService();
+            if (firstServiceId != null)
+                codeObjectIds.add(firstServiceId.getCodeObjectId());
+            var lastServiceId = ins.getLastService();
+            if (lastServiceId != null)
+                codeObjectIds.add(lastServiceId.getCodeObjectId());
+        }
+        return codeObjectIds;
+    }
+
+    private List<String> getCodeObjectIds(SpanScalingRootCauseInsight insight) {
+        return insight.getAffectedEndpoints().stream().filter(it -> it.getCodeObjectId() != null)
+                .map(it -> it.getCodeObjectId())
+                .toList();
+    }
+
+    private List<String> getCodeObjectIds(SpanSlowEndpointsInsight insight) {
+        return insight.getSlowEndpoints().stream().filter(it -> it.getEndpointInfo().getCodeObjectId() != null)
+                .map(it -> it.getEndpointInfo().getCodeObjectId())
+                .toList();
+    }
+
     private List<String> getSpanIds(SpanScalingInsight insight) {
         return insight.getRootCauseSpans().stream()
                 .map(it -> CodeObjectsUtil.createSpanId(it.getInstrumentationLibrary(), it.getName()))
-                .collect(Collectors.toList());
+                .toList();
     }
 
     private List<String> getSpanIds(SlowestSpansInsight insight) {
        return insight.getSpans().stream()
                 .map(it -> CodeObjectsUtil.createSpanId(it.getSpanInfo().getInstrumentationLibrary(), it.getSpanInfo().getName()))
-                .collect(Collectors.toList());
+               .toList();
     }
 
     private List<String> getSpanIds(SpanDurationBreakdownInsight insight) {
diff --git a/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/WorkspaceUrisHelper.java b/ide-common/src/main/java/org/digma/intellij/plugin/insights/view/WorkspaceUrisHelper.java
@@ -23,9 +23,18 @@ public static void findWorkspaceUrisForSpans(@NotNull Project project, ListViewI
         findWorkspaceUrisForSpans(theListView, spanIds, languageService);
     }
 
+    public static void findWorkspaceUrisForMethodCodeObjectIds(@NotNull Project project, ListViewItem<?> theListView, @NotNull List<String> codeObjectIds, @NotNull MethodInfo methodInfo) {
+        var languageService = LanguageService.findLanguageServiceByMethodInfo(project, methodInfo);
+        findWorkspaceUrisMethodCodeObjectIds(theListView, codeObjectIds, languageService);
+    }
 
     private static void findWorkspaceUrisForSpans(ListViewItem<?> theListView, @NotNull List<String> spanIds, @NotNull LanguageService languageService) {
         var workspaceUris = languageService.findWorkspaceUrisForSpanIds(spanIds);
         workspaceUris.forEach((k, v) -> theListView.getMoreData().put(k, v));
     }
+
+    private static void findWorkspaceUrisMethodCodeObjectIds(ListViewItem<?> theListView, @NotNull List<String> codeObjectIds, @NotNull LanguageService languageService) {
+        var workspaceUris = languageService.findWorkspaceUrisForMethodCodeObjectIds(codeObjectIds);
+        workspaceUris.forEach((k, v) -> theListView.getMoreData().put(k, v));
+    }
 }
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/model.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/model.kt
@@ -35,6 +35,7 @@ enum class InsightType {
     SpanEndpointBottleneck,
     SpanDurationBreakdown,
     SpanScaling,
+    SpanScalingRootCause,
     ;
 }
 
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/CodeObjectInsight.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/CodeObjectInsight.kt
@@ -27,6 +27,7 @@ import java.util.*
     JsonSubTypes.Type(value = SpanNPlusOneInsight::class, name = "SpaNPlusOne"),
     JsonSubTypes.Type(value = SlowEndpointInsight::class, name = "SlowEndpoint"),
     JsonSubTypes.Type(value = SpanScalingInsight::class, name = "SpanScaling"),
+    JsonSubTypes.Type(value = SpanScalingRootCauseInsight::class, name = "SpanScalingRootCause"),
     JsonSubTypes.Type(value = SpanDurationsInsight::class, name = "SpanDurations"),
     JsonSubTypes.Type(value = SpanSlowEndpointsInsight::class, name = "SpanEndpointBottleneck"),
     JsonSubTypes.Type(value = SpanDurationBreakdownInsight::class, name = "SpanDurationBreakdown"),
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/EndpointInfo.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/EndpointInfo.kt
@@ -7,9 +7,10 @@ import java.beans.ConstructorProperties
 @JsonIgnoreProperties(ignoreUnknown = true)
 data class EndpointInfo
 @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
-@ConstructorProperties("route", "serviceName", "instrumentationLibrary")
+@ConstructorProperties("route", "serviceName", "instrumentationLibrary", "codeObjectId")
 constructor(
     val route: String,
     val serviceName: String,
     val instrumentationLibrary: String,
+    val codeObjectId: String?,
 )
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanFlow.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanFlow.kt
@@ -19,10 +19,11 @@ constructor(
 
     data class Service
     @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
-    @ConstructorProperties("service", "span")
+    @ConstructorProperties("service", "span", "codeObjectId")
     constructor(
         val service: String,
         val span: String,
+        val codeObjectId: String,
     )
 
 }
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanInfo.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanInfo.kt
@@ -22,5 +22,5 @@ constructor(
         val spanCodeObjectId: String?, //TODO: should be not null, somehow the backend returns nulls on endpoints
         val displayName: String,
         val methodCodeObjectId: String?,
-        val kind: String,
+        val kind: String?,
 )
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanScalingRootCauseInsight.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanScalingRootCauseInsight.kt
@@ -0,0 +1,40 @@
+package org.digma.intellij.plugin.model.rest.insights
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import org.digma.intellij.plugin.model.InsightType
+import java.beans.ConstructorProperties
+import java.util.Date
+import kotlin.collections.ArrayList
+
+
+data class SpanScalingRootCauseInsight
+@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+@ConstructorProperties(
+        "codeObjectId",
+        "environment",
+        "scope",
+        "importance",
+        "decorators",
+        "actualStartTime",
+        "customStartTime",
+        "prefixedCodeObjectId",
+        "shortDisplayInfo",
+        "spanInfo",
+        "affectedEndpoints",
+)
+constructor(
+        override val codeObjectId: String,
+        override val environment: String,
+        override val scope: String,
+        override val importance: Int,
+        override val decorators: List<CodeObjectDecorator>?,
+        override val actualStartTime: Date?,
+        override val customStartTime: Date?,
+        override val prefixedCodeObjectId: String?,
+        override val shortDisplayInfo: ShortDisplayInfo?,
+        override val spanInfo: SpanInfo,
+        val affectedEndpoints: List<EndpointInfo> = ArrayList()
+) : SpanInsight {
+
+    override val type: InsightType = InsightType.SpanScalingRootCause
+}
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/ui/model/insights/InsightListViewItem.kt b/model/src/main/kotlin/org/digma/intellij/plugin/ui/model/insights/InsightListViewItem.kt
@@ -17,6 +17,7 @@ open class InsightListViewItem<INSIGHT : CodeObjectInsight>(insight: INSIGHT) :
                 // Span
                 InsightType.SpanDurations -> 60
                 InsightType.SpanUsages -> 61
+                InsightType.SpanScalingRootCause -> 62
                 InsightType.SpanScaling -> 63
                 InsightType.SpaNPlusOne -> 65
                 InsightType.SpanDurationChange -> 66
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/EPNPlusSpansPanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/EPNPlusSpansPanel.kt
@@ -19,7 +19,7 @@ import java.awt.BorderLayout
 import java.math.RoundingMode
 import javax.swing.*
 
-private const val RECORDS_PER_PAGE_EPNPLUS = 1
+private const val RECORDS_PER_PAGE_EPNPLUS = 3
 
 fun ePNPlusSpansPanel(
         project: Project,
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/InsightsListCellRenderer.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/InsightsListCellRenderer.kt
@@ -46,12 +46,13 @@ class InsightsListCellRenderer : AbstractPanelListCellRenderer() {
             is SlowEndpointInsight -> slowEndpointPanel(project, value.modelObject as SlowEndpointInsight)
             is SlowestSpansInsight -> slowestSpansPanel(project,
                 value.modelObject as SlowestSpansInsight, value.moreData)
-            is SpanUsagesInsight -> spanUsagesPanel(project, value.modelObject as SpanUsagesInsight)
+            is SpanUsagesInsight -> spanUsagesPanel(project, value.modelObject as SpanUsagesInsight, value.moreData)
             is SpanDurationsInsight -> spanDurationPanel(project, value.modelObject as SpanDurationsInsight, panelsLayoutHelper)
             is SpanDurationBreakdownInsight -> spanDurationBreakdownPanel(project,
                 value.modelObject as SpanDurationBreakdownInsight, value.moreData)
-            is SpanSlowEndpointsInsight -> spanSlowEndpointsPanel(project, value.modelObject as SpanSlowEndpointsInsight)
+            is SpanSlowEndpointsInsight -> spanSlowEndpointsPanel(project, value.modelObject as SpanSlowEndpointsInsight, value.moreData)
             is SpanScalingInsight -> spanScalingListViewItemsPanel(project, value.modelObject as SpanScalingInsight, value.moreData)
+            is SpanScalingRootCauseInsight -> spanScalingRootCauseItemsPanel(project, value.modelObject as SpanScalingRootCauseInsight, value.moreData)
             is UnmappedInsight -> unmappedInsightPanel(project, value.modelObject as UnmappedInsight)
             else -> genericPanelForSingleInsight(project, value.modelObject)
         }
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/ScalingListViewItemsPanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/ScalingListViewItemsPanel.kt
@@ -18,6 +18,7 @@ import org.digma.intellij.plugin.ui.model.TraceSample
 import java.awt.BorderLayout
 import javax.swing.*
 
+
 fun spanScalingListViewItemsPanel(project: Project, insight: SpanScalingInsight, moreData: HashMap<String, Any>): JPanel {
     val scalingPanel = createDefaultBoxLayoutYAxisPanel()
     scalingPanel.add(getScalingCalculationsPanel(insight))
@@ -44,6 +45,8 @@ fun spanScalingListViewItemsPanel(project: Project, insight: SpanScalingInsight,
     )
 }
 
+
+
 fun getRootCauseSpansPanel(project: Project, moreData: HashMap<String, Any>, insight: SpanScalingInsight): JPanel {
 
     val rootCauseSpansPanel = createDefaultBoxLayoutYAxisPanel()
@@ -65,6 +68,8 @@ fun getRootCauseSpansPanel(project: Project, moreData: HashMap<String, Any>, ins
     return rootCauseSpansPanel
 }
 
+
+
 fun getRootCauseSpanPanel(project: Project, moreData: HashMap<String, Any>, rootCauseSpan: RootCauseSpan): JPanel {
 
     val rootCausePanel = JPanel(BorderLayout())
@@ -111,7 +116,6 @@ private fun getScalingCalculationsPanel(insight: SpanScalingInsight): JPanel {
     return scalingBodyPanel
 }
 
-
 private fun buildButtonToPercentilesGraph(project: Project, spanName: String,instLibrary: String): JButton {
     val analyticsService = AnalyticsService.getInstance(project)
     val button = ListItemActionButton("Histogram")
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/ScalingRootCausePanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/ScalingRootCausePanel.kt
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/SlowestSpansPanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/SlowestSpansPanel.kt
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/UsagesPanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/UsagesPanel.kt

Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,18 @@ public static void findWorkspaceUrisForSpans(@NotNull Project project, ListViewI`
`23`	`23`	`findWorkspaceUrisForSpans(theListView, spanIds, languageService);`
`24`	`24`	`}`
`25`	`25`
	`26`	`+ public static void findWorkspaceUrisForMethodCodeObjectIds(@NotNull Project project, ListViewItem<?> theListView, @NotNull List<String> codeObjectIds, @NotNull MethodInfo methodInfo) {`
	`27`	`+ var languageService = LanguageService.findLanguageServiceByMethodInfo(project, methodInfo);`
	`28`	`+ findWorkspaceUrisMethodCodeObjectIds(theListView, codeObjectIds, languageService);`
	`29`	`+ }`
`26`	`30`
`27`	`31`	`private static void findWorkspaceUrisForSpans(ListViewItem<?> theListView, @NotNull List<String> spanIds, @NotNull LanguageService languageService) {`
`28`	`32`	`var workspaceUris = languageService.findWorkspaceUrisForSpanIds(spanIds);`
`29`	`33`	`workspaceUris.forEach((k, v) -> theListView.getMoreData().put(k, v));`
`30`	`34`	`}`
	`35`	`+`
	`36`	`+ private static void findWorkspaceUrisMethodCodeObjectIds(ListViewItem<?> theListView, @NotNull List<String> codeObjectIds, @NotNull LanguageService languageService) {`
	`37`	`+ var workspaceUris = languageService.findWorkspaceUrisForMethodCodeObjectIds(codeObjectIds);`
	`38`	`+ workspaceUris.forEach((k, v) -> theListView.getMoreData().put(k, v));`
	`39`	`+ }`
`31`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ enum class InsightType {`
`35`	`35`	`SpanEndpointBottleneck,`
`36`	`36`	`SpanDurationBreakdown,`
`37`	`37`	`SpanScaling,`
	`38`	`+ SpanScalingRootCause,`
`38`	`39`	`;`
`39`	`40`	`}`
`40`	`41`
Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,11 @@ constructor(`
`19`	`19`
`20`	`20`	`data class Service`
`21`	`21`	`@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)`
`22`		`- @ConstructorProperties("service", "span")`
	`22`	`+ @ConstructorProperties("service", "span", "codeObjectId")`
`23`	`23`	`constructor(`
`24`	`24`	`val service: String,`
`25`	`25`	`val span: String,`
	`26`	`+ val codeObjectId: String,`
`26`	`27`	`)`
`27`	`28`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,5 +22,5 @@ constructor(`
`22`	`22`	`val spanCodeObjectId: String?, //TODO: should be not null, somehow the backend returns nulls on endpoints`
`23`	`23`	`val displayName: String,`
`24`	`24`	`val methodCodeObjectId: String?,`
`25`		`- val kind: String,`
	`25`	`+ val kind: String?,`
`26`	`26`	`)`