Merge pull request #257 from digma-ai/feature/add_method_info_features

doppleware · web-flow · commit b7350ea84f55 · 2023-02-07T13:22:33.000-05:00
Feature/add method info features
diff --git a/src/analyticsCodeLens.ts b/src/analyticsCodeLens.ts
@@ -1,25 +1,44 @@
 import * as vscode from 'vscode';
 import { Settings } from './settings';
-import { DocumentInfoProvider, MethodInfo } from './services/documentInfoProvider';
+import { DocumentInfo, DocumentInfoProvider, MethodInfo } from './services/documentInfoProvider';
 import { CodeAnalyticsView } from './views/codeAnalytics/codeAnalyticsView';
 import { WorkspaceState } from './state';
 import { CodeObjectInsight, InsightImportance } from './views/codeAnalytics/InsightListView/IInsightListViewItemsCreator';
 import { CodeObjectLocationInfo } from './services/languages/extractors';
 import { UsageStatusResults } from './services/analyticsProvider';
+import { CodeInspector } from './services/codeInspector';
+import { Token } from './services/languages/tokens';
 
+export interface CodeLensData{
+    
+    methodInfo : MethodInfo;
+    insights: CodeObjectInsight[];
+    
+}
 export class AnalyticsCodeLens implements vscode.Disposable
 {
 
     private _provider: CodelensProvider;
     private _disposables: vscode.Disposable[] = [];
 
     constructor(documentInfoProvider: DocumentInfoProvider,
-                state: WorkspaceState)
+                state: WorkspaceState, condeInspector: CodeInspector)
     {
-        this._provider = new CodelensProvider(documentInfoProvider,state);
+        this._provider = new CodelensProvider(documentInfoProvider,state,condeInspector);
 
         this._disposables.push(vscode.commands.registerCommand(CodelensProvider.clickCommand, async (methodInfo: MethodInfo, environment:string) => {
+            
             if(vscode.window.activeTextEditor) {
+                if (methodInfo.documentUri!== vscode.window.activeTextEditor.document.uri){
+                   
+                    const doc = await vscode.workspace.openTextDocument(methodInfo.documentUri);
+                    if (doc){
+                        await vscode.window.showTextDocument(doc, { preview: true });
+
+                    }
+
+                }
+
                 vscode.window.activeTextEditor.selection = new vscode.Selection(methodInfo.range.start, methodInfo.range.start);
             }
 
@@ -55,7 +74,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
     public readonly onDidChangeCodeLenses: vscode.Event<void> = this._onDidChangeCodeLenses.event;
 
     constructor(private _documentInfoProvider: DocumentInfoProvider,
-        private _state: WorkspaceState)
+        private _state: WorkspaceState, private _codeInspector: CodeInspector)
     {
     }
 
@@ -92,7 +111,6 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
     private async getCodeLens(methodInfo: MethodInfo,
                               codeObjectInfo:CodeObjectLocationInfo, 
                               insights: CodeObjectInsight[],
-                              state: UsageStatusResults,
                               environmentPrefix: boolean): Promise<vscode.CodeLens[]> {
         
         const lens: vscode.CodeLens[] = [];
@@ -165,7 +183,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
                     = insights
                         .filter(x=>x.environment==this._state.environment);
                 
-                const lenses = await this.getCodeLens(methodInfo,codeObject,currentEnvInsights,usageStatus,false);
+                const lenses = await this.getCodeLens(methodInfo,codeObject,currentEnvInsights,false);
                 for (const lens of lenses){
                     codelens.push(lens);
                 }
@@ -176,7 +194,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
                         .filter(x=>x.decorators && x.importance<InsightImportance.important)
                         .filter(x=>!currentEnvInsights.some(i=>i.type==x.type && i.importance==x.importance));
 
-                const otherEnvLenses = await this.getCodeLens(methodInfo,codeObject,otherEnvsInsightsToShow, usageStatus,true);
+                const otherEnvLenses = await this.getCodeLens(methodInfo,codeObject,otherEnvsInsightsToShow,true);
                 for (const lens of otherEnvLenses){
                     codelens.push(lens);
                 }         
@@ -185,7 +203,67 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
             return codelens;
         
     }
+ 
+    public async getCodeLensesForFunctions (document: vscode.TextDocument, documentInfo: DocumentInfo, token: vscode.CancellationToken): Promise<vscode.CodeLens[]> {
+
+        
+        const memoised: {[token:string]: CodeLensData} = {};
+        const functions = documentInfo.tokens.filter(x=>x.type==='function');
+        const lens : vscode.CodeLens[]= [];
+        for (const methodInfo of documentInfo.methods){
+
+             for (const func of functions.filter(x=>x.range.intersection(methodInfo.range))){
+
+                const funcKey = tokenKey(func.text, document.uri);
+                if (funcKey in memoised){
+                    const data = memoised[funcKey];
+                    const newLens =  await this.getCodeLens(data.methodInfo,getFakeCodeLocation(func),
+                                                            data.insights,false);
+                    lens.push(...newLens);
+                }
 
+                else {
+
+                    if (func.text === methodInfo.name && func.range === methodInfo.nameRange){
+                        continue;
+                    }
+                    const remoteMethodInfo = 
+                        await this._codeInspector.getExecuteDefinitionMethodInfo(document, func.range.start, this._documentInfoProvider);
+                    
+                    if(!remoteMethodInfo) {
+                        continue;
+                    }
+    
+                    const remoteDoc = await this._codeInspector.getDocumentInfo(document, func.range.start, this._documentInfoProvider);
+                    if(!remoteDoc) {
+                        continue;
+                    }
+    
+                    const insights = remoteDoc.insights.forMethod(remoteMethodInfo,this._state.environment);
+                    const funcLens = await this.getCodeLens(remoteMethodInfo,
+                         getFakeCodeLocation(func),insights,false);
+                    
+                    lens.push(...funcLens);
+                    memoised[funcKey]={ insights: insights, methodInfo: remoteMethodInfo};
+                }
+
+             }
+        }
+
+        return lens;
+
+
+        function getFakeCodeLocation(func: Token): CodeObjectLocationInfo {
+            return {
+                range: func.range, documentUri: documentInfo.uri, ids: [], displayName: func.text,
+                id: func.text, idsWithType: [func.text]
+            };
+        }
+
+        function tokenKey(token:string, uri: vscode.Uri) {
+            return `${uri}$$${token}`
+        }
+    }
     public async provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken): Promise<vscode.CodeLens[]> 
     {
         if (!Settings.enableCodeLens.value) 
@@ -209,7 +287,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
 
                 const lenses = await this.getCodeLens(methodInfo,methodInfo,
                     thisEnvInsights.filter(x=>x.scope=="Function"),
-                    documentInfo.usageData.getAll(),false);
+                    false);
                     
                 for (const lens of lenses){
                     methodCodeLens.push(lens);
@@ -272,7 +350,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
                         .filter(x=>x.decorators && x.importance<InsightImportance.important);
 
                 const otherEnvLenses = await this.getCodeLens(methodInfo,methodInfo,otherEnvsInsights,
-                     documentInfo.usageData.getAll(),true);
+                     true);
                 for (const lens of otherEnvLenses){
                     methodCodeLens.push(lens);
                 }
@@ -287,7 +365,8 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
             
         }
 
-  
+        const funcLenses = await this.getCodeLensesForFunctions(document,documentInfo,token);
+        codelens.push(...funcLenses);
 
         return codelens;
     }
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) 
 {
@@ -47,7 +48,7 @@ export async function activate(context: vscode.ExtensionContext)
     const documentInfoCache = new DocumentInfoCache(symbolProvider, analyticsProvider);
     const documentInfoProvider = new DocumentInfoProvider(analyticsProvider, symbolProvider, workspaceState, documentInfoCache);
     const editorHelper = new EditorHelper(sourceControl, documentInfoProvider);
-    const codeLensProvider = new AnalyticsCodeLens(documentInfoProvider, workspaceState);
+    const codeLensProvider = new AnalyticsCodeLens(documentInfoProvider, workspaceState, codeInspector);
     const spanLinkResolver = new SpanLinkResolver(symbolProvider,documentInfoProvider);
     const environmentManager = new EnvironmentManager(analyticsProvider, workspaceState);
     await environmentManager.initializeCurrentEnvironment();
@@ -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,workspaceState, codeInspector ));
     context.subscriptions.push(new HotspotMarkerDecorator(documentInfoProvider));
     context.subscriptions.push(new VsCodeDebugInstrumentation(analyticsProvider));
 
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 } from './languages/tokens';
 
@@ -15,7 +15,7 @@ export type DefinitionWithTokens = Definition & {
 
 export class CodeInspector {
 
-    public async getExecuteDefinitionMethodInfo(
+public async getExecuteDefinitionMethodInfo(
         usageDocument: vscode.TextDocument,
         usagePosition: vscode.Position,
         documentInfoProvider: DocumentInfoProvider,
@@ -34,6 +34,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);
@@ -37,17 +40,19 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
     constructor(
         private _documentInfoProvider: DocumentInfoProvider,
         private _codeInspector: CodeInspector,
+        private _workspaceState: WorkspaceState
     ) {
     }
 
-    public async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> 
+public async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> 
     {
         const sourceDocInfo = await this._documentInfoProvider.getDocumentInfo(document);
         if(!sourceDocInfo) {
             return;
         }
         
         let methodInfo: MethodInfo | undefined = sourceDocInfo?.methods.firstOrDefault((m) => m.nameRange?.contains(position) ?? false);
+        let remoteDoc: DocumentInfo | undefined = undefined;
         if(!methodInfo){
             if(!sourceDocInfo.tokens.some(t => (t.type == TokenType.function || t.type == TokenType.method) && t.range.contains(position))) {
                 return;
@@ -56,8 +61,16 @@ class MethodCallErrorHoverProvider implements vscode.HoverProvider
             if(!methodInfo) {
                 return;
             }
+            remoteDoc = await this._codeInspector.getDocumentInfo(document, position, this._documentInfoProvider);
+            if(!methodInfo) {
+                return;
+            }
+
         }
-        const markdown = await this.getMethodMarkdown(methodInfo);
+        if (!remoteDoc){
+            return;
+        }
+        const markdown = await this.getMethodMarkdown(methodInfo,remoteDoc);
         if(markdown)
         {
             return new vscode.Hover(markdown);
@@ -82,14 +95,49 @@ 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;
         }
         
-        const markdown = new vscode.MarkdownString('', true);
         markdown.appendText('Throws:\n');
         for(const error of errors)
         {
@@ -100,6 +148,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;
+        //await vscode.commands.executeCommand(PerformanceDecorator.Commands.Show);
+
 
     }
 
diff --git a/src/views/codeAnalytics/decorators/performanceDecorator.ts b/src/views/codeAnalytics/decorators/performanceDecorator.ts

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`	`+ //await vscode.commands.executeCommand(PerformanceDecorator.Commands.Show);`
	`449`	`+`
`447`	`450`
`448`	`451`	`}`
`449`	`452`