adding performance info for methods

doppleware · doppleware · commit 54dd73fc1ed4 · 2023-02-05T21:04:07.000-08:00
diff --git a/src/extension.ts b/src/extension.ts
@@ -23,6 +23,7 @@ import { EventManager } from './services/EventManager';
 import { Scheduler } from './services/Scheduler';
 import { DocumentInfoCache } from './services/DocumentInfoCache';
 import { SpanLinkResolver } from './services/spanLinkResolver';
+import { PerformanceDecorator } from './views/codeAnalytics/decorators/performanceDecorator';
 
 export async function activate(context: vscode.ExtensionContext) 
 {
@@ -61,12 +62,13 @@ export async function activate(context: vscode.ExtensionContext)
 
     context.subscriptions.push(codeLensProvider);
     //context.subscriptions.push(new ContextView(analyticsProvider, context.extensionUri));
-    context.subscriptions.push(new MethodCallErrorTooltip(documentInfoProvider, codeInspector));
+    context.subscriptions.push(new MethodCallErrorTooltip(documentInfoProvider, codeInspector,workspaceState));
     context.subscriptions.push(sourceControl);
     context.subscriptions.push(documentInfoProvider);
     context.subscriptions.push(new CodeAnalyticsView(analyticsProvider, documentInfoProvider,
         context.extensionUri, editorHelper, workspaceState, codeLensProvider, envStatusbar, environmentManager,spanLinkResolver, documentInfoCache));
     context.subscriptions.push(new ErrorsLineDecorator(documentInfoProvider));
+    context.subscriptions.push(new PerformanceDecorator(documentInfoProvider));
     context.subscriptions.push(new HotspotMarkerDecorator(documentInfoProvider));
     context.subscriptions.push(new VsCodeDebugInstrumentation(analyticsProvider));
 
diff --git a/src/services/analyticsProvider.ts b/src/services/analyticsProvider.ts
@@ -361,7 +361,7 @@ export class AnalyticsProvider {
     }
 
     public async getCodeObjectsErrors(codeObjectIds: string[]): Promise<CodeObjectErrorResponse[]> {
-        let params: [string, any][] = [["environment", this.state.environment]];
+        let params: [string, any][  ] = [["environment", this.state.environment]];
         codeObjectIds.forEach(o => params.push(["codeObjectId", o]));
 
         const response = await this.send<CodeObjectErrorResponse[]>(
diff --git a/src/services/codeInspector.ts b/src/services/codeInspector.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { DocumentInfoProvider, MethodInfo } from './documentInfoProvider';
+import { DocumentInfo, DocumentInfoProvider, MethodInfo } from './documentInfoProvider';
 import { SymbolProvider, SymbolTree } from './languages/symbolProvider';
 import { Token, TokenType } from './languages/tokens';
 
@@ -32,6 +32,19 @@ export class CodeInspector {
         return methodInfo;
     }
 
+    public async getDocumentInfo(
+        usageDocument: vscode.TextDocument,
+        usagePosition: vscode.Position,
+        documentInfoProvider: DocumentInfoProvider,
+    ): Promise<DocumentInfo | undefined> {
+        const definition = await this.getDefinition(usageDocument, usagePosition);
+        if (!definition)
+            return;
+
+        const docInfo = await documentInfoProvider.getDocumentInfo(definition.document);
+        return docInfo;
+    }
+
     public async getDefinitionWithTokens(
         usageDocument: vscode.TextDocument,
         usagePosition: vscode.Position,
diff --git a/src/services/methodCallErrorTooltip.ts b/src/services/methodCallErrorTooltip.ts
@@ -1,8 +1,10 @@
 import * as vscode from 'vscode';
 import { ErrorsViewTab } from '../views/codeAnalytics/errorsViewTab';
-import { DocumentInfoProvider, MethodInfo } from './documentInfoProvider';
+import { DocumentInfo, DocumentInfoProvider, MethodInfo } from './documentInfoProvider';
 import { TokenType } from './languages/tokens';
 import { CodeInspector } from './codeInspector';
+import { WorkspaceState } from '../state';
+import { SpanDurationsInsight } from '../views/codeAnalytics/InsightListView/SpanInsight';
 
 export class MethodCallErrorTooltip implements vscode.Disposable
 {
@@ -14,10 +16,11 @@ export class MethodCallErrorTooltip implements vscode.Disposable
     constructor(
         documentInfoProvider: DocumentInfoProvider,
         codeInspector: CodeInspector,
+        workspaceState: WorkspaceState
     ) {
         this._disposables.push(vscode.languages.registerHoverProvider(
             documentInfoProvider.symbolProvider.languageExtractors.map(x => x.documentFilter),
-            new MethodCallErrorHoverProvider(documentInfoProvider, codeInspector))
+            new MethodCallErrorHoverProvider(documentInfoProvider, codeInspector,workspaceState))
         );
         this._disposables.push(vscode.commands.registerCommand(MethodCallErrorTooltip.Commands.ShowErrorView, async (args) => {
              await vscode.commands.executeCommand(ErrorsViewTab.Commands.ShowErrorView, args.codeObjectId, args.codeObjectDisplayName, args.errorFlowId);
@@ -36,6 +39,7 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
     constructor(
         private _documentInfoProvider: DocumentInfoProvider,
         private _codeInspector: CodeInspector,
+        private _workspaceState: WorkspaceState
     ) {
     }
 
@@ -46,15 +50,24 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
             return;
         
         let methodInfo: MethodInfo | undefined = sourceDocInfo?.methods.firstOrDefault((m) => m.nameRange?.contains(position) ?? false);
+        let remoteDoc: DocumentInfo | undefined = undefined;
         if(!methodInfo){
             if(!sourceDocInfo.tokens.any(t => (t.type == TokenType.function || t.type == TokenType.method) && t.range.contains(position)))
                 return;
             methodInfo = await this._codeInspector.getExecuteDefinitionMethodInfo(document, position, this._documentInfoProvider);
             if(!methodInfo) {
                 return;
             }
+            remoteDoc = await this._codeInspector.getDocumentInfo(document, position, this._documentInfoProvider);
+            if(!methodInfo) {
+                return;
+            }
+
+        }
+        if (!remoteDoc){
+            return;
         }
-        const markdown = await this.getMethodMarkdown(methodInfo);
+        const markdown = await this.getMethodMarkdown(methodInfo,remoteDoc);
         if(markdown)
         {
             return new vscode.Hover(markdown);
@@ -79,13 +92,48 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
         //return new vscode.Hover(markdown);
     }
 
-    private async getMethodMarkdown(methodInfo: MethodInfo): Promise<vscode.MarkdownString | undefined>
+    private async getMethodMarkdown(methodInfo: MethodInfo, remoteDoc: DocumentInfo): Promise<vscode.MarkdownString | undefined>
     {
+        let markdown = new vscode.MarkdownString('', true);
+
+        
+        const insights = remoteDoc.insights.forMethod(methodInfo, this._workspaceState.environment);
+        const importantInsights = insights.filter(x=>x.importance<4);
+        if (importantInsights.length>0){
+            markdown.appendMarkdown(` <span style="color:#FF0000;"><i>${importantInsights.map(x=>x.name).join(' ')}</i></span>`);
+            markdown.appendText('\n');
+
+        }
+
+        const perfStats = insights.filter(x=>x.name=="Performance Stats");
+        for (var stat of perfStats){
+
+            const durationInsight : SpanDurationsInsight = stat as SpanDurationsInsight;
+            
+            const p50 =durationInsight.percentiles.filter(x=>x.percentile==0.5)
+                .firstOrDefault();
+            const p95 =durationInsight.percentiles.filter(x=>x.percentile==0.95).firstOrDefault();
+            const spanName = durationInsight.span.displayName;
+           
+            if (p50 || p95){
+                markdown.appendText(`${spanName} Duration: `)
+                if (p50!=null){
+                    markdown.appendText(`${p50.currentDuration.value} ${p50.currentDuration.unit} (Median) `);
+                }
+    
+                if (p95!=null){
+                    markdown.appendText(`${p95.currentDuration.value} ${p95.currentDuration.unit} (P95) `);
+                }
+                markdown.appendText('\n');
+            }
+                
+
+            
+        }
         const errors = await this._documentInfoProvider.analyticsProvider.getCodeObjectsErrors(methodInfo.idsWithType);
         if(!errors?.length)
             return;
         
-        let markdown = new vscode.MarkdownString('', true);
         markdown.appendText('Throws:\n');
         for(let error of errors)
         {
@@ -96,6 +144,8 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
             markdown.appendMarkdown(` \u00B7 [$(link-external)](command:${command}?${args} "Show in side panel") `);
             markdown.appendText('\n');
         }
+
+
         markdown.supportHtml = true;
         markdown.isTrusted = true;
         return markdown;
diff --git a/src/views/codeAnalytics/codeAnalyticsView.ts b/src/views/codeAnalytics/codeAnalyticsView.ts
@@ -36,6 +36,7 @@ import { EnvironmentManager } from '../../services/EnvironmentManager';
 import { Action } from "./InsightListView/Actions/Action";
 import { SpanLinkResolver } from "../../services/spanLinkResolver";
 import { DocumentInfoCache, ScanningStatus } from "../../services/DocumentInfoCache";
+import { PerformanceDecorator } from "./decorators/performanceDecorator";
 //import { DigmaFileDecorator } from "../../decorators/fileDecorator";
 
 
@@ -444,6 +445,8 @@ class CodeAnalyticsViewProvider implements vscode.WebviewViewProvider,vscode.Dis
             this._overlay.hide();
         }
         this._currentCodeObject = codeObject;
+        vscode.commands.executeCommand(PerformanceDecorator.Commands.Show);
+
 
     }
 
diff --git a/src/views/codeAnalytics/decorators/performanceDecorator.ts b/src/views/codeAnalytics/decorators/performanceDecorator.ts
@@ -0,0 +1,123 @@
+import * as vscode from 'vscode';
+import { DocumentInfoProvider, LineInfo } from '../../../services/documentInfoProvider';
+import { WorkspaceState } from '../../../state';
+
+export class PerformanceDecorator implements vscode.Disposable
+{
+    public static Commands = class {
+        public static readonly Show = `digma.performanceDecorator.show`;
+        public static readonly Hide = `digma.performanceDecorator.hide`;
+    };
+
+    private _iconDecorationType: vscode.TextEditorDecorationType;
+    private _textDecorationType: vscode.TextEditorDecorationType;
+    private _disposables: vscode.Disposable[] = [];
+
+    constructor(private _documentInfoProvider: DocumentInfoProvider)
+    {
+        this._iconDecorationType = vscode.window.createTextEditorDecorationType({
+            after:{
+                contentText: "\uea86",
+                color: 'var(--vscode-editorCodeLens-foreground)',
+                margin: '0 0 0 2em',
+                textDecoration: "none; font-family: codicon; position: absolute; "
+            }
+        });
+        this._textDecorationType = vscode.window.createTextEditorDecorationType({
+            after:{
+                margin: '0 0 0 3em',
+                color: 'var(--vscode-editorCodeLens-foreground)',
+            }
+        });   
+        this._disposables.push(this._textDecorationType);   
+        this._disposables.push(vscode.commands.registerCommand(PerformanceDecorator.Commands.Show, this.onShow.bind(this)));
+        this._disposables.push(vscode.commands.registerCommand(PerformanceDecorator.Commands.Hide, this.onHide.bind(this)));
+    }
+
+    private async onShow(codeObjectId?: string) 
+    {
+        if(!codeObjectId)
+            return;
+
+        const editor = vscode.window.activeTextEditor;
+        if(!editor)
+            return;
+        
+        const docInfo = await this._documentInfoProvider.getDocumentInfo(editor.document);
+        if(!docInfo)
+            return;
+        
+        const method = docInfo.methods.firstOrDefault(m => m.symbol.id == codeObjectId);
+        if(!method)
+            return;
+        
+        const lines = docInfo.lines.getAllByCurrentEnv().filter(l => method.range.contains(l.range.start));
+        if(!lines)
+            return;
+
+        const textDecorationOptions: vscode.DecorationOptions[] = lines
+            .map(lineInfo => {
+                return <vscode.DecorationOptions>{
+                    hoverMessage: this.getTooltip(lineInfo),
+                    range: new vscode.Range(lineInfo.range.end, lineInfo.range.end),
+                    renderOptions: {
+                        after:{
+                            contentText: [...new Set( lineInfo.exceptions.map(e => e.type))].join('\xB7')
+                        }
+                    }
+                }
+            });
+        const iconDecorationOptions = lines
+            .map(lineInfo => {
+                return <vscode.DecorationOptions>{
+                    range: new vscode.Range(lineInfo.range.end, lineInfo.range.end),
+                }
+            });
+
+        editor.setDecorations(this._iconDecorationType, iconDecorationOptions);
+        editor.setDecorations(this._textDecorationType, textDecorationOptions);
+    }
+
+    private async onHide()
+    {
+        const editor = vscode.window.activeTextEditor;
+        if(!editor)
+            return;
+
+        editor.setDecorations(this._iconDecorationType, []);
+        editor.setDecorations(this._textDecorationType, []);
+    }
+
+    private getTooltip(lineInfo: LineInfo): vscode.MarkdownString
+    {
+        let markdown = new vscode.MarkdownString('', true);
+        markdown.appendText('Throws:\n');
+        let typesShown : string[] = []; 
+        for(let exception of lineInfo.exceptions)
+        {
+            if (typesShown.includes(exception.type)){
+                continue;
+            }
+            typesShown.push(exception.type);
+
+            markdown.appendMarkdown(`- \`${exception.type}\``);
+            
+            if (!exception.handled){
+                markdown.appendMarkdown(` \u00B7 <span style="color:#f14c4c;"><i>Unhandled</i></span>`);
+            }
+            if (exception.unexpected){
+                markdown.appendMarkdown(` \u00B7 <span style="color:#cca700"><i>Unexpected</i></span>`);
+            }
+
+            markdown.appendMarkdown(`\\`);
+            markdown.appendMarkdown(`\n${exception.message}\n`);
+        }
+        markdown.isTrusted = true;
+        return markdown;
+    }
+
+    public dispose() {
+        for(let dis of this._disposables)
+            dis.dispose();
+    }
+} 

Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ export class AnalyticsProvider {`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`public async getCodeObjectsErrors(codeObjectIds: string[]): Promise<CodeObjectErrorResponse[]> {`
`364`		`- let params: [string, any][] = [["environment", this.state.environment]];`
	`364`	`+ let params: [string, any][ ] = [["environment", this.state.environment]];`
`365`	`365`	`codeObjectIds.forEach(o => params.push(["codeObjectId", o]));`
`366`	`366`
`367`	`367`	`const response = await this.send<CodeObjectErrorResponse[]>(`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ import { EnvironmentManager } from '../../services/EnvironmentManager';`
`36`	`36`	`import { Action } from "./InsightListView/Actions/Action";`
`37`	`37`	`import { SpanLinkResolver } from "../../services/spanLinkResolver";`
`38`	`38`	`import { DocumentInfoCache, ScanningStatus } from "../../services/DocumentInfoCache";`
	`39`	`+import { PerformanceDecorator } from "./decorators/performanceDecorator";`
`39`	`40`	`//import { DigmaFileDecorator } from "../../decorators/fileDecorator";`
`40`	`41`
`41`	`42`
`@@ -444,6 +445,8 @@ class CodeAnalyticsViewProvider implements vscode.WebviewViewProvider,vscode.Dis`
`444`	`445`	`this._overlay.hide();`
`445`	`446`	`}`
`446`	`447`	`this._currentCodeObject = codeObject;`
	`448`	`+ vscode.commands.executeCommand(PerformanceDecorator.Commands.Show);`
	`449`	`+`
`447`	`450`
`448`	`451`	`}`
`449`	`452`