Feature/duration breakdown insight changes (#205)

* duration breakdown support

* aliases refactoring

Author: shaykeren

package-lock.json

@@ -143,6 +143,7 @@
         "@types/jquery": "^3.5.14",
         "@vscode/codicons": "0.0.20",
         "@vscode/webview-ui-toolkit": "^0.8.5",
+        "entities": "^4.4.0",
         "https": "^1.0.0",
         "moment": "^2.29.3",
         "node-fetch": "^2.6.6",

package.json

@@ -185,7 +185,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
         const codelens: vscode.CodeLens[] = [];
         for(let methodInfo of documentInfo.methods)
         {
-            for (let alias of methodInfo.aliases){
+            for (let alias of methodInfo.ids){
                 const insights = documentInfo.insights.all.filter(x=>x.codeObjectId== alias)
                     .filter(x=>x.scope=="Function");
 
@@ -235,7 +235,7 @@ class CodelensProvider implements vscode.CodeLensProvider<vscode.CodeLens>
 
             }
 
-            for (let alias of methodInfo.aliases){
+            for (let alias of methodInfo.ids){
                 const insights = documentInfo.insights.all.filter(x=>x.codeObjectId== alias)
                     .filter(x=>x.scope=="Function");
 

src/analyticsCodeLens.ts

@@ -75,21 +75,11 @@ export class MinimalCodeObjectInfo implements CodeObjectInfo {
 
 export interface ICodeObjectIdParser {
     parse(codeObjectId: string): CodeObjectInfo;
-    generateAliases(codeObjectId: string): string[];
 }
 
 export class CommonCodeObjectIdParser implements ICodeObjectIdParser {
     parse(codeObjectId: string): CodeObjectInfo {
         const [path, method] = codeObjectId.split(CodeObjectId.codeObjectSeparator);
         return new MinimalCodeObjectInfo(codeObjectId, method);
     }
-
-    generateAliases(codeObjectId: string): string[] {
-        const folders = codeObjectId.split('/');
-        const aliases = [codeObjectId];
-        for (let i = 1; i < folders.length; i++) {
-            aliases.push(folders.slice(i, folders.length).join('/'));
-        }
-        return aliases;
-    }
 }

src/services/codeObject.ts

@@ -5,7 +5,7 @@ import { Logger } from "./logger";
 import { SymbolProvider } from './languages/symbolProvider';
 import { Token, TokenType } from './languages/tokens';
 import { Dictionary, Future } from './utils';
-import { EndpointInfo, SpanLocationInfo as SpanLocationInfo, SymbolInfo, IParametersExtractor, CodeObjectLocationInfo } from './languages/extractors';
+import { EndpointInfo, SpanLocationInfo as SpanLocationInfo, SymbolInfo, IParametersExtractor, CodeObjectLocationInfo, ISymbolAliasExtractor } from './languages/extractors';
 import { InstrumentationInfo } from './EditorHelper';
 import { SymbolInformation } from 'vscode';
 import { WorkspaceState } from '../state';
@@ -186,7 +186,9 @@ export class DocumentInfoProvider implements vscode.Disposable
                 const endpoints = await this.symbolProvider.getEndpoints(doc, symbolInfos, tokens, symbolTrees, this);
                 const spans = await this.symbolProvider.getSpans(doc, symbolInfos, tokens);
                 const paramsExtractor = await this.symbolProvider.getParametersExtractor(doc);
-                let methodInfos = await this.createMethodInfos(doc, paramsExtractor, symbolInfos, tokens, spans, endpoints);
+                const symbolAliasExtractor = await this.symbolProvider.getSymbolAliasExtractor(doc);
+
+                let methodInfos = await this.createMethodInfos(doc, paramsExtractor, symbolAliasExtractor, symbolInfos, tokens, spans, endpoints);
 
                 let codeObjectIds = methodInfos.flatMap(s => s.idsWithType)
                         .concat(endpoints.flatMap(e => e.idsWithType))
@@ -230,7 +232,7 @@ export class DocumentInfoProvider implements vscode.Disposable
                 // These are spans that the server is aware of but the client can't discover
                 const spansDiscoveredViaServer = insightsResult
                     .filter(x=>x.scope=="Span")
-                    .filter(x=>!spans.any(e=>e.id===x.codeObjectId));
+                    .filter(x=>!spans.any(e=>e.id===x.codeObjectId)); //why we assume the the codeobjectid is span codeobject id, the output is that these span are spans discovered by server 
 
                 const uniqueSpans = [...new Map(spansDiscoveredViaServer.map(item =>
                     [item.codeObjectId, item])).values()];
@@ -253,7 +255,7 @@ export class DocumentInfoProvider implements vscode.Disposable
                     }
                 }
 
-                const newMethodInfos = await this.createMethodInfos(doc, paramsExtractor, symbolInfos, tokens, spans, endpoints);
+                const newMethodInfos = await this.createMethodInfos(doc, paramsExtractor, symbolAliasExtractor, symbolInfos, tokens, spans, endpoints);
                 methodInfos=newMethodInfos;
                 const insights = new CodeObjectInsightsAccessor(insightsResult);
                 //const lines:LineInfo[] = [];
@@ -306,20 +308,15 @@ export class DocumentInfoProvider implements vscode.Disposable
     private async createMethodInfos(
         document: vscode.TextDocument,
         parametersExtractor: IParametersExtractor,
+        symbolAliasExtractor: ISymbolAliasExtractor,
         symbols: SymbolInfo[],
         tokens: Token[], 
         spans: SpanLocationInfo[],
         endpoints: EndpointInfo[],
     ): Promise<MethodInfo[]> {
-        const codeObjectIdParser = await this.symbolProvider.getCodeObjectIdParser(document);
-        if(!codeObjectIdParser) {
-            return [];
-        }
-
         let methods: MethodInfo[] = [];
-
         for(let symbol of symbols) {
-            const aliases = codeObjectIdParser.generateAliases(symbol.id);
+            const aliases = symbolAliasExtractor.extractAliases(symbol);
             const method = new MethodInfo(
                 symbol.id,
                 symbol.name,
@@ -379,7 +376,7 @@ export class DocumentInfoProvider implements vscode.Disposable
         const lineInfosByEnv: ElementsByEnv<LineInfo> = new ElementsByEnv<LineInfo>(state);
         for(let method of methods)
         {
-            const codeObjectSummary = methodSummaries.find(x=>method.aliases.any(a=>a ==x.codeObjectId));
+            const codeObjectSummary = methodSummaries.find(x=>method.ids.any(a=>a ==x.codeObjectId));
             if(!codeObjectSummary)
                 continue;
 
@@ -579,12 +576,10 @@ export class CodeObjectInsightsAccessor{
 
 
     public  forMethod(methodInfo: MethodInfo, environment: string|undefined){
-        const codeObjectsIds = methodInfo.aliases
-             .concat(methodInfo.relatedCodeObjects.flatMap(r => r.ids));
-        
+        const codeObjectsIds = methodInfo.getIds(true,false);
         let insights = this._codeObjectInsights.filter(x=>codeObjectsIds.any(o=> o==x.codeObjectId));
         if (environment){
-            insights = insights.filter(x=>x.environment==environment);
+            insights = insights.filter(x=>x.environment===environment);
         }
         return insights;
 
@@ -616,7 +611,7 @@ export class MethodInfo implements CodeObjectLocationInfo
         public range: vscode.Range,
         public parameters: ParameterInfo[],
         public symbol: SymbolInfo,
-        public aliases: string[],
+        private aliases: string[],
         public relatedCodeObjects: CodeObjectLocationInfo[],
         public documentUri: vscode.Uri){}
 
@@ -635,7 +630,18 @@ export class MethodInfo implements CodeObjectLocationInfo
         ];
     }
 
-    
+    public getIds(includeRelated: boolean = false, withType: boolean = false): string[] {
+        if(includeRelated) {
+            if(withType){
+                return [...new Set(this.idsWithType .concat(this.relatedCodeObjects.flatMap(r => r.idsWithType)))];
+            }
+            return [...new Set(this.ids .concat(this.relatedCodeObjects.flatMap(r => r.ids)))];
+        }
+        if(withType){
+            return this.idsWithType;
+        }
+        return this.ids;
+    }
 }
 
 export interface ParameterInfo

src/services/documentInfoProvider.ts

@@ -74,6 +74,18 @@ export interface IMethodExtractor {
         tokens: Token [],
     ): Promise<SymbolInfo[]>;
 }
+export interface ISymbolAliasExtractor {
+    extractAliases(
+        symbol: SymbolInfo): string[];
+}
+export class EmptySymbolAliasExtractor implements ISymbolAliasExtractor {
+    extractAliases(symbol: SymbolInfo): string[] {
+        return [];
+    }
+   
+}
+
+
 
 export interface IParametersExtractor {
     extractParameters(methodName: string, methodTokens: Token[]): Promise<ParameterInfo[]>;

src/services/languages/extractors.ts

@@ -34,16 +34,4 @@ export class JSCodeObjectIdParser implements ICodeObjectIdParser {
             symbol,
         );
     }
-
-    generateAliases(codeObjectId: string): string[] {
-        const objectPrefix = 'Object.';
-        const info: JSCodeObjectInfo = this.parse(codeObjectId);
-        const prefixedAliased = info.symbol.startsWith(objectPrefix)
-            ? info.symbol.substring(objectPrefix.length)
-            : `${objectPrefix}${info.symbol}`;
-        return [
-            codeObjectId,
-            `${info.packageName}:${info.modulePath}${CodeObjectId.codeObjectSeparator}${prefixedAliased}`,
-        ];
-    }
 }

src/services/languages/javascript/codeObjectIdParser.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
 import { CodeInspector } from '../codeInspector';
 import { IMethodPositionSelector, DefaultMethodPositionSelector } from './methodPositionSelector';
-import { IMethodExtractor, IParametersExtractor, IEndpointExtractor, ISpanExtractor } from './extractors';
+import { IMethodExtractor, IParametersExtractor, IEndpointExtractor, ISpanExtractor, ISymbolAliasExtractor, EmptySymbolAliasExtractor } from './extractors';
 import { BasicParametersExtractor } from './defaultImpls';
 import { IModulePathToUriConverter } from './modulePathToUriConverters';
 import { ICodeObjectIdParser, CommonCodeObjectIdParser } from '../codeObject';
@@ -16,11 +16,13 @@ export interface ILanguageExtractor {
     getEndpointExtractors(codeInspector: CodeInspector): IEndpointExtractor[];
     getSpanExtractors(codeInspector: CodeInspector): ISpanExtractor[];
     validateConfiguration(): Promise<void>;
+    get symbolAliasExtractor(): ISymbolAliasExtractor;
     getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]>;
     getCodeObjectIdParser(): ICodeObjectIdParser;
 }
 
 export abstract class LanguageExtractor implements ILanguageExtractor {
+    
     public abstract requiredExtensionLoaded: boolean;
 
     public abstract get requiredExtensionId(): string;
@@ -29,6 +31,10 @@ export abstract class LanguageExtractor implements ILanguageExtractor {
 
     public abstract get methodExtractors(): IMethodExtractor[];
 
+    public get symbolAliasExtractor(): ISymbolAliasExtractor {
+        return new EmptySymbolAliasExtractor();
+    }
+    
     public get parametersExtractor(): IParametersExtractor {
         return new BasicParametersExtractor();
     }

src/services/languages/languageExtractor.ts

@@ -1,10 +1,11 @@
 import * as vscode from 'vscode';
 import { CodeInspector } from '../../codeInspector';
-import { IMethodExtractor, ISpanExtractor } from '../extractors';
+import { IMethodExtractor, ISpanExtractor, ISymbolAliasExtractor } from '../extractors';
 import { LanguageExtractor } from '../languageExtractor';
 import { IModulePathToUriConverter, PhysicalModulePathToUriConverter } from '../modulePathToUriConverters';
 import { PythonMethodExtractor } from './methodExtractor';
 import { PythonSpanExtractor } from './spanExtractor';
+import { PythonSymbolAliasExtractor } from './symbolAliasExtractor';
 
 export class PythonLanguageExtractor extends LanguageExtractor {
     public requiredExtensionLoaded: boolean = false;
@@ -29,6 +30,10 @@ export class PythonLanguageExtractor extends LanguageExtractor {
         ];
     }
 
+    public get symbolAliasExtractor(): ISymbolAliasExtractor {
+        return new PythonSymbolAliasExtractor();
+    }
+    
     public async getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]> {
         return [
             new PhysicalModulePathToUriConverter(),

src/services/languages/python/languageExtractor.ts

@@ -0,0 +1,13 @@
+import { ISymbolAliasExtractor, SymbolInfo } from "../extractors";
+
+export class PythonSymbolAliasExtractor implements ISymbolAliasExtractor{
+    public extractAliases(symbol: SymbolInfo): string[] {
+        var folders = symbol.id.split("/");
+        let aliases = [];
+        //aliases.push(symbol.id);
+        for (let i=1;i<folders.length;i++){
+            aliases.push(folders.slice(i, folders.length).join("/"));
+        }
+        return aliases;
+    }
+}