Implement Duration Breakdown insight

MykolaYaremchuk · MykolaYaremchuk · commit 9448f25a1084 · 2022-11-17T14:36:28.000+02:00
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
@@ -1,18 +1,7 @@
 package org.digma.intellij.plugin.insights.view;
 
 import org.digma.intellij.plugin.model.InsightType;
-import org.digma.intellij.plugin.model.rest.insights.CodeObjectInsight;
-import org.digma.intellij.plugin.model.rest.insights.ErrorInsight;
-import org.digma.intellij.plugin.model.rest.insights.HighUsageInsight;
-import org.digma.intellij.plugin.model.rest.insights.HotspotInsight;
-import org.digma.intellij.plugin.model.rest.insights.LowUsageInsight;
-import org.digma.intellij.plugin.model.rest.insights.NormalUsageInsight;
-import org.digma.intellij.plugin.model.rest.insights.SlowEndpointInsight;
-import org.digma.intellij.plugin.model.rest.insights.SlowestSpansInsight;
-import org.digma.intellij.plugin.model.rest.insights.SpanDurationsInsight;
-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.*;
 import org.digma.intellij.plugin.ui.model.insights.InsightGroupType;
 import org.digma.intellij.plugin.view.EmptyListViewItemBuilder;
 import org.digma.intellij.plugin.view.ListViewItemBuilder;
@@ -50,6 +39,8 @@ private ListViewItemBuilder<? extends CodeObjectInsight> newBuilder(InsightType
                 return new GroupListViewItemBuilder<SpanUsagesInsight>(InsightGroupType.Span, SpanUsagesInsight::getSpan);
             case SpanDurations:
                 return new GroupListViewItemBuilder<SpanDurationsInsight>(InsightGroupType.Span, spanDurationsInsight -> spanDurationsInsight.getSpan().getName());
+            case SpanDurationBreakdown:
+                return new GroupListViewItemBuilder<SpanDurationBreakdownInsight>(InsightGroupType.Span, SpanDurationBreakdownInsight::getSpanName);
             case SpanEndpointBottleneck:
                 return new GroupListViewItemBuilder<SpanSlowEndpointsInsight>(InsightGroupType.Span, insight -> insight.getSpan().getName());
             case SlowestSpans:
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
@@ -1,10 +1,8 @@
 package org.digma.intellij.plugin.insights.view;
 
 import com.intellij.openapi.project.Project;
-import org.digma.intellij.plugin.model.rest.insights.CodeObjectInsight;
-import org.digma.intellij.plugin.model.rest.insights.SlowSpanInfo;
-import org.digma.intellij.plugin.model.rest.insights.SlowestSpansInsight;
-import org.digma.intellij.plugin.model.rest.insights.SpanInfo;
+import org.digma.intellij.plugin.document.CodeObjectsUtil;
+import org.digma.intellij.plugin.model.rest.insights.*;
 import org.digma.intellij.plugin.ui.model.insights.InsightGroupListViewItem;
 import org.digma.intellij.plugin.ui.model.insights.InsightGroupType;
 import org.digma.intellij.plugin.ui.model.insights.InsightListViewItem;
@@ -37,8 +35,11 @@ public List<ListViewItem<?>> build(Project project, T insight, ListGroupManager
 
         switch (insight.getType()){
             case SlowestSpans:{
-                List<SpanInfo> spanInfos = ((SlowestSpansInsight) insight).getSpans().stream().map(SlowSpanInfo::getSpanInfo).collect(Collectors.toList());
-                SlowestSpansHelper.findWorkspaceUrisForSpans(project, theListView, spanInfos, insight.getCodeObjectId());
+                WorkspaceUrisHelper.findWorkspaceUrisForSpans(project, theListView, getSpanIds((SlowestSpansInsight) insight), insight.getCodeObjectId());
+                break;
+            }
+            case SpanDurationBreakdown:{
+                WorkspaceUrisHelper.findWorkspaceUrisForSpans(project,theListView, getSpanIds((SpanDurationBreakdownInsight) insight), insight.getCodeObjectId());
                 break;
             }
         }
@@ -48,7 +49,17 @@ public List<ListViewItem<?>> build(Project project, T insight, ListGroupManager
         return List.of();
     }
 
+    private List<String> getSpanIds(SlowestSpansInsight insight) {
+       return insight.getSpans().stream()
+                .map(it -> CodeObjectsUtil.createSpanId(it.getSpanInfo().getInstrumentationLibrary(), it.getSpanInfo().getName()))
+                .collect(Collectors.toList());
+    }
 
-
+    private List<String> getSpanIds(SpanDurationBreakdownInsight insight) {
+        return insight.getBreakdownEntries()
+                .stream().map(durationBreakdown ->
+                        CodeObjectsUtil.createSpanId(durationBreakdown.getSpanInstrumentationLibrary(), durationBreakdown.getSpanName()))
+                .collect(Collectors.toList());
+    }
 
 }
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
@@ -1,30 +1,19 @@
 package org.digma.intellij.plugin.insights.view;
 
 import com.intellij.openapi.project.Project;
-import org.digma.intellij.plugin.document.CodeObjectsUtil;
-import org.digma.intellij.plugin.model.rest.insights.SpanInfo;
 import org.digma.intellij.plugin.psi.LanguageService;
 import org.digma.intellij.plugin.ui.model.listview.ListViewItem;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
 import java.util.List;
 
-public class SlowestSpansHelper {
+public class WorkspaceUrisHelper {
 
-    private SlowestSpansHelper() {
+    private WorkspaceUrisHelper() {
     }
 
-    public static void findWorkspaceUrisForSpans(Project project, ListViewItem<?> theListView, @NotNull List<SpanInfo> spanInfos, @Nullable String methodCodeObjectId) {
-
-        var spanIds = new ArrayList<String>();
-
-        spanInfos.forEach(spanInfo -> {
-            var spanId = CodeObjectsUtil.createSpanId(spanInfo.getInstrumentationLibrary(), spanInfo.getName());
-            spanIds.add(spanId);
-        });
-
+    public static void findWorkspaceUrisForSpans(Project project, ListViewItem<?> theListView, @NotNull List<String> spanIds, @Nullable String methodCodeObjectId) {
         //when this method is called there is not always a related file.
         //if called while building SlowestSpansInsight then there is a method id and the related file is probably opened
         //and DocumentInfoService should find the method info and by that the language.
diff --git a/ide-common/src/main/java/org/digma/intellij/plugin/summary/SummariesProvider.java b/ide-common/src/main/java/org/digma/intellij/plugin/summary/SummariesProvider.java
@@ -4,10 +4,10 @@
 import com.intellij.openapi.project.Project;
 import org.digma.intellij.plugin.analytics.AnalyticsService;
 import org.digma.intellij.plugin.analytics.AnalyticsServiceException;
+import org.digma.intellij.plugin.document.CodeObjectsUtil;
 import org.digma.intellij.plugin.log.Log;
 import org.digma.intellij.plugin.model.rest.insights.GlobalInsight;
 import org.digma.intellij.plugin.model.rest.insights.SpanDurationChangeInsight;
-import org.digma.intellij.plugin.model.rest.insights.SpanInfo;
 import org.digma.intellij.plugin.model.rest.usage.EnvironmentUsageStatus;
 import org.digma.intellij.plugin.model.rest.usage.UsageStatusResult;
 import org.digma.intellij.plugin.ui.model.listview.ListViewItem;
@@ -17,7 +17,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static org.digma.intellij.plugin.insights.view.SlowestSpansHelper.findWorkspaceUrisForSpans;
+import static org.digma.intellij.plugin.insights.view.WorkspaceUrisHelper.findWorkspaceUrisForSpans;
 
 public class SummariesProvider {
 
@@ -71,8 +71,7 @@ private List<ListViewItem<GlobalInsight>> toListViewItems(List<GlobalInsight> in
                     @SuppressWarnings("OptionalGetWithoutIsPresent")//no need ,it only happens if getSpanDurationChanges is not empty
                     SpanDurationChangeInsight.Change change = ((SpanDurationChangeInsight) insight).getSpanDurationChanges().stream().findAny().get();
                     var methodId = change.getCodeObjectId();
-                    List<SpanInfo> spanInfos = ((SpanDurationChangeInsight) insight).getSpanDurationChanges().stream().map(SpanDurationChangeInsight.Change::getSpan).collect(Collectors.toList());
-                    findWorkspaceUrisForSpans(project, item, spanInfos, methodId);
+                    findWorkspaceUrisForSpans(project, item, getSpanIds((SpanDurationChangeInsight) insight), methodId);
                 }
             }
 
@@ -81,4 +80,11 @@ private List<ListViewItem<GlobalInsight>> toListViewItems(List<GlobalInsight> in
 
         return items;
     }
+
+    private List<String> getSpanIds(SpanDurationChangeInsight insight) {
+        return insight.getSpanDurationChanges().stream()
+                .map(it -> CodeObjectsUtil.createSpanId(it.getSpan().getInstrumentationLibrary(), it.getSpan().getName()))
+                .collect(Collectors.toList());
+    }
+
 }
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
@@ -31,5 +31,6 @@ enum class InsightType {
     TopErrorFlows,
     SpanDurationChange,
     SpanEndpointBottleneck,
+    SpanDurationBreakdown,
     ;
 }
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
@@ -25,6 +25,7 @@ import org.digma.intellij.plugin.model.InsightType
     JsonSubTypes.Type(value = SlowEndpointInsight::class, name = "SlowEndpoint"),
     JsonSubTypes.Type(value = SpanDurationsInsight::class, name = "SpanDurations"),
     JsonSubTypes.Type(value = SpanSlowEndpointsInsight::class, name = "SpanEndpointBottleneck"),
+    JsonSubTypes.Type(value = SpanDurationBreakdownInsight::class, name = "SpanDurationBreakdown"),
 )
 interface CodeObjectInsight {
     val type: InsightType
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdown.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdown.kt
@@ -0,0 +1,17 @@
+package org.digma.intellij.plugin.model.rest.insights
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import java.beans.ConstructorProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class SpanDurationBreakdown
+@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+@ConstructorProperties("spanName", "spanDisplayName", "spanInstrumentationLibrary", "spanCodeObjectId", "percentiles")
+constructor(
+    val spanName: String,
+    val spanDisplayName: String,
+    val spanInstrumentationLibrary: String,
+    val spanCodeObjectId: String,
+    val percentiles: List<SpanDurationBreakdownPercentile>
+)
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdownInsight.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdownInsight.kt
@@ -0,0 +1,17 @@
+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
+
+data class SpanDurationBreakdownInsight
+@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+@ConstructorProperties("codeObjectId", "spanName", "breakdownEntries")
+constructor(
+    override val codeObjectId: String,
+    val spanName: String,
+    val breakdownEntries: List<SpanDurationBreakdown>
+) : CodeObjectInsight {
+
+    override val type: InsightType = InsightType.SpanDurationBreakdown
+}
diff --git a/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdownPercentile.kt b/model/src/main/kotlin/org/digma/intellij/plugin/model/rest/insights/SpanDurationBreakdownPercentile.kt
@@ -0,0 +1,14 @@
+package org.digma.intellij.plugin.model.rest.insights
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import java.beans.ConstructorProperties
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class SpanDurationBreakdownPercentile
+@JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
+@ConstructorProperties("percentile", "duration")
+constructor(
+        val percentile: Float,
+        val duration: Duration,
+)
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
@@ -19,6 +19,7 @@ open class InsightListViewItem<INSIGHT : CodeObjectInsight>(insight: INSIGHT) :
                 InsightType.SpanDurations -> 65
                 InsightType.SpanDurationChange -> 66
                 InsightType.SpanEndpointBottleneck -> 67
+                InsightType.SpanDurationBreakdown -> 68
                 // HTTP Endpoints
                 InsightType.SlowestSpans -> 40
                 InsightType.LowUsage -> 30
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/DurationBreakdownPanel.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/DurationBreakdownPanel.kt
@@ -0,0 +1,166 @@
+package org.digma.intellij.plugin.ui.list.insights
+
+import com.intellij.openapi.project.Project
+import com.intellij.ui.components.ActionLink
+import com.intellij.ui.components.JBPanel
+import com.intellij.util.ui.JBUI.Borders.empty
+import org.digma.intellij.plugin.document.CodeObjectsUtil
+import org.digma.intellij.plugin.model.rest.insights.SpanDurationBreakdown
+import org.digma.intellij.plugin.model.rest.insights.SpanDurationBreakdownInsight
+import org.digma.intellij.plugin.service.InsightsActionsService
+import org.digma.intellij.plugin.ui.common.*
+import org.digma.intellij.plugin.ui.list.PanelsLayoutHelper
+import java.awt.BorderLayout
+import java.awt.Dimension
+import java.awt.GridLayout
+import javax.swing.JComponent
+import javax.swing.JLabel
+import javax.swing.JPanel
+import javax.swing.SwingConstants
+
+const val P_50: Float = 0.5F
+
+fun spanDurationBreakdownPanel(
+        project: Project,
+        insight: SpanDurationBreakdownInsight,
+        moreData: HashMap<String, Any>,
+        panelsLayoutHelper: PanelsLayoutHelper
+): JPanel {
+
+    val resultBreakdownPanel = JBPanel<JBPanel<*>>()
+    resultBreakdownPanel.layout = GridLayout(insight.breakdownEntries.size, 1, 0, 2)
+    resultBreakdownPanel.isOpaque = false
+
+    insight.breakdownEntries
+            .filter { entry -> entry.percentiles.any { breakdown -> breakdown.percentile.equals(P_50) } }
+            .sortedWith(compareByDescending { getValueOfPercentile(it, P_50) })
+            .forEach { durationBreakdown: SpanDurationBreakdown ->
+                val durationBreakdownPanel = durationBreakdownRowPanel(durationBreakdown, project, moreData, panelsLayoutHelper)
+                resultBreakdownPanel.add(durationBreakdownPanel)
+            }
+
+    return createInsightPanel(
+            "Duration Breakdown",
+            "",
+            Laf.Icons.Insight.DURATION,
+            resultBreakdownPanel,
+            null,
+            panelsLayoutHelper)
+}
+
+fun durationBreakdownRowPanel(
+        durationBreakdown: SpanDurationBreakdown,
+        project: Project,
+        moreData: HashMap<String, Any>,
+        layoutHelper: PanelsLayoutHelper
+): JPanel {
+    val durationBreakdownPanel = getDurationBreakdownPanel()
+    val telescopeIconLabel = getTelescopeIconLabel()
+    val spanDisplayNameLabel = getSpanDisplayNameLabel(durationBreakdown, project, moreData)
+    val breakdownDurationLabelPanel = getBreakdownDurationLabelPanel(durationBreakdown, layoutHelper)
+
+    durationBreakdownPanel.add(telescopeIconLabel, BorderLayout.WEST)
+    durationBreakdownPanel.add(spanDisplayNameLabel, BorderLayout.CENTER)
+    durationBreakdownPanel.add(breakdownDurationLabelPanel, BorderLayout.EAST)
+
+    return durationBreakdownPanel
+}
+
+private fun getDurationBreakdownPanel(): JBPanel<JBPanel<*>> {
+    val durationBreakdownPanel = JBPanel<JBPanel<*>>()
+    durationBreakdownPanel.layout = BorderLayout(5, 0)
+    durationBreakdownPanel.border = empty()
+    durationBreakdownPanel.isOpaque = false
+    return durationBreakdownPanel
+}
+
+private fun getTelescopeIconLabel(): JLabel {
+    val iconLabel = JLabel(Laf.Icons.Insight.TELESCOPE, SwingConstants.LEFT)
+    iconLabel.horizontalAlignment = SwingConstants.LEFT
+    iconLabel.verticalAlignment = SwingConstants.TOP
+    iconLabel.isOpaque = false
+    return iconLabel
+}
+
+private fun getSpanDisplayNameLabel(
+        durationBreakdown: SpanDurationBreakdown,
+        project: Project,
+        moreData: HashMap<String, Any>,
+): JComponent {
+    val spanId = CodeObjectsUtil.createSpanId(durationBreakdown.spanInstrumentationLibrary, durationBreakdown.spanName)
+    val displayName = durationBreakdown.spanDisplayName
+
+    val messageLabel = if (moreData.contains(spanId)) {
+        ActionLink(asHtml(displayName)) {
+            val actionListener: InsightsActionsService = project.getService(InsightsActionsService::class.java)
+
+            @Suppress("UNCHECKED_CAST")
+            val workspaceUri: Pair<String, Int> = moreData[spanId] as Pair<String, Int>
+            actionListener.openWorkspaceFileForSpan(workspaceUri.first, workspaceUri.second)
+        }
+    } else {
+        JLabel(asHtml(displayName), SwingConstants.LEFT)
+    }
+    messageLabel.toolTipText = displayName
+    messageLabel.border = empty(0, 0, 5, 0)
+    messageLabel.isOpaque = false
+
+    return messageLabel
+}
+
+private fun getBreakdownDurationLabelPanel(
+        durationBreakdown: SpanDurationBreakdown,
+        layoutHelper: PanelsLayoutHelper
+): JPanel {
+    val pLabelText = getDisplayValueOfPercentile(durationBreakdown, P_50)
+    val pLabel = JLabel(pLabelText)
+    pLabel.toolTipText = getTooltipForDurationLabel(durationBreakdown)
+    boldFonts(pLabel)
+
+    val breakdownDurationLabelPanel = object : JPanel() {
+        override fun getPreferredSize(): Dimension {
+            val ps = super.getPreferredSize()
+            if (ps == null) {
+                return ps
+            }
+            val h = ps.height
+            val w = ps.width
+            addCurrentLargestWidthDurationPLabel(layoutHelper, w)
+            return Dimension(getCurrentLargestWidthDurationPLabel(layoutHelper, w), h)
+        }
+    }
+    breakdownDurationLabelPanel.layout = BorderLayout()
+    breakdownDurationLabelPanel.border = empty()
+    breakdownDurationLabelPanel.isOpaque = false
+    breakdownDurationLabelPanel.add(pLabel, BorderLayout.WEST)
+    addCurrentLargestWidthDurationPLabel(layoutHelper, breakdownDurationLabelPanel.preferredSize.width)
+
+    return breakdownDurationLabelPanel
+}
+
+private fun getDisplayValueOfPercentile(breakdownEntry: SpanDurationBreakdown, requestedPercentile: Float): String {
+    for (pctl in breakdownEntry.percentiles) {
+        if (pctl.percentile.equals(requestedPercentile)) {
+            return "${pctl.duration.value} ${pctl.duration.unit}"
+        }
+    }
+    return ""
+}
+
+private fun getValueOfPercentile(breakdownEntry: SpanDurationBreakdown, requestedPercentile: Float): Long? {
+    for (pctl in breakdownEntry.percentiles) {
+        if (pctl.percentile.equals(requestedPercentile)) {
+            return pctl.duration.raw
+        }
+    }
+    return null
+}
+
+private fun getTooltipForDurationLabel(breakdownEntry: SpanDurationBreakdown): String {
+    val sortedPercentiles = breakdownEntry.percentiles.sortedBy { it.percentile }
+    var tooltip = "Percentage of time spent in span:".plus("<br>")
+    for(p in sortedPercentiles){
+        tooltip += "P${(p.percentile*100).toInt()}: ${p.duration.value} ${p.duration.unit}".plus("<br>")
+    }
+    return asHtml(tooltip)
+}
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
diff --git a/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/SpanPanels.kt b/src/main/kotlin/org/digma/intellij/plugin/ui/list/insights/SpanPanels.kt

Original file line number	Diff line number	Diff line change
`@@ -31,5 +31,6 @@ enum class InsightType {`
`31`	`31`	`TopErrorFlows,`
`32`	`32`	`SpanDurationChange,`
`33`	`33`	`SpanEndpointBottleneck,`
	`34`	`+ SpanDurationBreakdown,`
`34`	`35`	`;`
`35`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ import org.digma.intellij.plugin.model.InsightType`
`25`	`25`	`JsonSubTypes.Type(value = SlowEndpointInsight::class, name = "SlowEndpoint"),`
`26`	`26`	`JsonSubTypes.Type(value = SpanDurationsInsight::class, name = "SpanDurations"),`
`27`	`27`	`JsonSubTypes.Type(value = SpanSlowEndpointsInsight::class, name = "SpanEndpointBottleneck"),`
	`28`	`+ JsonSubTypes.Type(value = SpanDurationBreakdownInsight::class, name = "SpanDurationBreakdown"),`
`28`	`29`	`)`
`29`	`30`	`interface CodeObjectInsight {`
`30`	`31`	`val type: InsightType`