Merge pull request #96 from digma-ai/feature/detect_span_debug

Feature/detect span debug

Author: doppleware

src/extension.ts

@@ -13,7 +13,8 @@ import { CodeAnalyticsView } from './views/codeAnalytics/codeAnalyticsView';
 import { ErrorsLineDecorator } from './decorators/errorsLineDecorator';
 import { HotspotMarkerDecorator } from './decorators/hotspotMarkerDecorator';
 import { EditorHelper } from './services/EditorHelper';
-import { CodeInvestigator } from './services/codeInvestigator';
+import { CodeInspector } from './services/codeInspector';
+import { VsCodeDebugInstrumentation } from './instrumentation/vscodeInstrumentation';
 
 export async function activate(context: vscode.ExtensionContext) 
 {
@@ -25,8 +26,8 @@ export async function activate(context: vscode.ExtensionContext)
         new Git()
     ];
     const sourceControl = new SourceControl(supportedSourceControls);
-    const codeInvestigator = new CodeInvestigator();
-    const symbolProvider = new SymbolProvider(supportedLanguages, codeInvestigator);
+    const codeInspector = new CodeInspector();
+    const symbolProvider = new SymbolProvider(supportedLanguages, codeInspector);
     const analyticsProvider = new AnalyticsProvider();
     const documentInfoProvider = new DocumentInfoProvider(analyticsProvider, symbolProvider);
     const editorHelper = new EditorHelper(sourceControl, documentInfoProvider);
@@ -39,13 +40,14 @@ export async function activate(context: vscode.ExtensionContext)
     }
     context.subscriptions.push(new AnaliticsCodeLens(documentInfoProvider));
     context.subscriptions.push(new ContextView(analyticsProvider, context.extensionUri));
-    context.subscriptions.push(new MethodCallErrorTooltip(documentInfoProvider, codeInvestigator));
+    context.subscriptions.push(new MethodCallErrorTooltip(documentInfoProvider, codeInspector));
     context.subscriptions.push(sourceControl);
     context.subscriptions.push(documentInfoProvider);
     context.subscriptions.push(new CodeAnalyticsView(analyticsProvider, documentInfoProvider,
         context.extensionUri, editorHelper));
     context.subscriptions.push(new ErrorsLineDecorator(documentInfoProvider));
     context.subscriptions.push(new HotspotMarkerDecorator(documentInfoProvider));
+    context.subscriptions.push(new VsCodeDebugInstrumentation(analyticsProvider));
 
 }
 

src/instrumentation/vscodeInstrumentation.ts

@@ -0,0 +1,41 @@
+import { NONAME } from 'dns';
+import * as vscode from 'vscode';
+import { Disposable } from 'vscode-languageclient';
+import { AnalyticsProvider } from '../services/analyticsProvider';
+
+export class VsCodeDebugInstrumentation implements vscode.Disposable{
+
+    private eventRegistration : Disposable;
+
+    constructor(private _analyticsProvider: AnalyticsProvider){
+
+        this.eventRegistration = vscode.debug.registerDebugAdapterTrackerFactory('*', {
+            createDebugAdapterTracker(session: vscode.DebugSession) {
+              return {
+                onWillReceiveMessage: m => {
+                },
+                onDidSendMessage: 
+                    m => {
+                        if (m.event ==='continued'){
+                            console.log('continued');
+                            _analyticsProvider.sendInsturmentationEvent(1);
+                        }
+                        if (m.event==='stopped'){
+                            _analyticsProvider.sendInsturmentationEvent(0);
+                        }
+                }
+              };
+            }
+          }); 
+
+    }
+    dispose() {
+        if (this.eventRegistration){
+            this.eventRegistration.dispose();
+        }
+    }
+
+
+}
+
+  

src/services/EditorHelper.ts

@@ -41,7 +41,7 @@ export class EditorHelper {
         {
             let doc: vscode.TextDocument | undefined = undefined;
 
-            if(!await utils.fileExits(workspaceUri))
+            if(!await utils.fileExists(workspaceUri))
             {
                 doc = await this.askAndOpenFromSourceControl(editorInfo);
             }

src/services/analyticsProvider.ts

@@ -6,6 +6,8 @@ import { Logger } from "./logger";
 import { Dictionary, momentJsDateParser } from "./utils";
 import moment = require("moment");
 import { integer } from "vscode-languageclient";
+import * as os from 'os';
+
 
 export enum Impact 
 {
@@ -349,6 +351,25 @@ export class AnalyticsProvider
         }
         return;
     }
+    
+    public async sendInsturmentationEvent(event:integer): Promise<undefined> 
+    {
+        try
+        {
+            const timestamp = Date.now().toString();
+            const response = await this.send<undefined>(
+                'POST',
+                `/CodeAnalytics/instrumentation/event`, 
+                undefined,
+                {event: event.toString(), machineName: os.hostname(),timestamp:timestamp });
+
+            return response;
+        }
+        catch(error){
+            Logger.error('Failed to get error flow', error);
+        }
+        return;
+    }
 
 
     private async send<TResponse>(method: string, relativePath: string, queryParams?: Dictionary<string, any>, body?: any): Promise<TResponse>

src/services/codeInvestigator.ts src/services/codeInspector.tssrc/services/codeInvestigator.ts renamed to src/services/codeInspector.ts

@@ -1,7 +1,8 @@
 import * as vscode from 'vscode';
 
-import { DocumentInfoProvider, MethodInfo } from "./documentInfoProvider";
-import { Token, SymbolProvider } from './languages/symbolProvider';
+import { DocumentInfoProvider, MethodInfo } from './documentInfoProvider';
+import { SymbolProvider, SymbolTree } from './languages/symbolProvider';
+import { Token, TokenType } from './languages/tokens';
 
 export interface Definition {
     document: vscode.TextDocument
@@ -12,7 +13,7 @@ export type DefinitionWithTokens = Definition & {
     tokens: Token[]
 };
 
-export class CodeInvestigator {
+export class CodeInspector {
 
     public async getExecuteDefinitionMethodInfo(
         usageDocument: vscode.TextDocument,
@@ -63,4 +64,51 @@ export class CodeInvestigator {
             location,
         };
     }
+
+    public * getAllSymbolsOfKind(symbolTrees: SymbolTree[] | undefined, kind: vscode.SymbolKind): Generator<SymbolTree> {
+        if(!symbolTrees) {
+            return;
+        }
+
+        for (const symbolTree of symbolTrees) {
+            if(symbolTree.kind === kind) {
+                yield symbolTree;
+            }
+            yield * this.getAllSymbolsOfKind(symbolTree.children as SymbolTree[] | undefined, kind);
+        }
+    }
+
+    public async derivesFrom(
+        definition: DefinitionWithTokens,
+        ancestorName: string,
+        symbolProvider: SymbolProvider,
+        findParentToken: (tokens: Token[], position: vscode.Position) => Token | undefined,
+    ): Promise<boolean> {
+        const parentToken = findParentToken(definition.tokens, definition.location.range.start);
+        if(!parentToken) {
+            return false;
+        }
+
+        if(parentToken.text === ancestorName) {
+            return true;
+        }
+
+        const parentInfo = await this.getTokensFromSymbolProvider(definition.document, parentToken.range.start, symbolProvider);
+        if(!parentInfo) {
+            return false;
+        }
+
+        const parentSymbolTree = await symbolProvider.getSymbolTree(parentInfo.document);
+        if(!parentSymbolTree) {
+            return false;
+        }
+
+        const parentDerivesFromAncestor = this.derivesFrom(
+            parentInfo,
+            ancestorName,
+            symbolProvider,
+            findParentToken,
+        );
+        return parentDerivesFromAncestor;
+    }
 }

src/services/documentInfoProvider.ts

@@ -2,7 +2,8 @@ import { setInterval, clearInterval } from 'timers';
 import * as vscode from 'vscode';
 import { AnalyticsProvider, CodeObjectSummary, MethodCodeObjectSummary } from './analyticsProvider';
 import { Logger } from "./logger";
-import { SymbolProvider, Token, TokenType } from './languages/symbolProvider';
+import { SymbolProvider } from './languages/symbolProvider';
+import { Token, TokenType } from './languages/tokens';
 import { Dictionary, Future } from './utils';
 import { EndpointInfo, SpanInfo, SymbolInfo, CodeObjectInfo } from './languages/extractors';
 import { InstrumentationInfo } from './EditorHelper';
@@ -84,33 +85,38 @@ export class DocumentInfoProvider implements vscode.Disposable
     private async addOrUpdateDocumentInfo(doc: vscode.TextDocument): Promise<DocumentInfo | undefined>
     {
         const docRelativePath = doc.uri.toModulePath();
-        if(!docRelativePath || !this.symbolProvider.supportsDocument(doc))
+        if(!docRelativePath || !this.symbolProvider.supportsDocument(doc)) {
             return undefined;
+        }
 
         let document = this._documents[docRelativePath];
-        if(!document)
-        {
+        if(!document) {
             document = this._documents[docRelativePath] = new DocumentInfoContainer();
         }
 
         let latestVersionInfo = document.versions[doc.version];
-        if(!latestVersionInfo)
-        {
+        if(!latestVersionInfo) {
             latestVersionInfo = document.versions[doc.version] = new Future<DocumentInfo>();
 
-            try
-            {
+            try {
                 Logger.trace(`Starting building DocumentInfo for "${docRelativePath}" v${doc.version}`);
-                const symbolInfos = await this.symbolProvider.getMethods(doc);
+                const symbolTrees = await this.symbolProvider.getSymbolTree(doc);
+                const symbolInfos = await this.symbolProvider.getMethods(doc, symbolTrees);
                 const tokens = await this.symbolProvider.getTokens(doc);
-                const endpoints = await this.symbolProvider.getEndpoints(doc, symbolInfos, tokens);
+                const endpoints = await this.symbolProvider.getEndpoints(doc, symbolInfos, tokens, symbolTrees, this);
                 const spans = await this.symbolProvider.getSpans(doc, symbolInfos, tokens);
-                const methods = this.createMethodInfos(doc, symbolInfos, tokens, spans, endpoints);
-                const summaries = new CodeObjectSummeryAccessor(await this.analyticsProvider.getSummaries(methods.map(s => s.idWithType).concat(endpoints.map(e => e.idWithType)).concat(spans.map(s => s.idWithType))));
-                const lines = this.createLineInfos(doc, summaries, methods);
+                const methodInfos = this.createMethodInfos(doc, symbolInfos, tokens, spans, endpoints);
+                const summaries = new CodeObjectSummaryAccessor(
+                    await this.analyticsProvider.getSummaries(
+                        methodInfos.map(s => s.idWithType)
+                            .concat(endpoints.map(e => e.idWithType))
+                            .concat(spans.map(s => s.idWithType))
+                    )
+                );
+                const lines = this.createLineInfos(doc, summaries, methodInfos);
                 latestVersionInfo.value = {
                     summaries,
-                    methods,
+                    methods: methodInfos,
                     lines,
                     tokens,
                     endpoints,
@@ -119,10 +125,9 @@ export class DocumentInfoProvider implements vscode.Disposable
                 };
                 Logger.trace(`Finished building DocumentInfo for "${docRelativePath}" v${doc.version}`);
             }
-            catch(e)
-            {
+            catch(e) {
                 latestVersionInfo.value = {
-                    summaries: new CodeObjectSummeryAccessor([]),
+                    summaries: new CodeObjectSummaryAccessor([]),
                     methods: [],
                     lines: [],
                     tokens: [],
@@ -136,19 +141,21 @@ export class DocumentInfoProvider implements vscode.Disposable
 
             return latestVersionInfo.value;
         }
-        else
-        {
+        else {
             return await latestVersionInfo.wait();
         }
     }
 
-    private createMethodInfos(document: vscode.TextDocument, symbols: SymbolInfo[], tokens: Token[], 
-        spans: SpanInfo[], endpoints: EndpointInfo[]): MethodInfo[] 
-    {
+    private createMethodInfos(
+        document: vscode.TextDocument,
+        symbols: SymbolInfo[],
+        tokens: Token[], 
+        spans: SpanInfo[],
+        endpoints: EndpointInfo[],
+    ): MethodInfo[] {
         let methods: MethodInfo[] = [];
 
-        for(let symbol of symbols)
-        {
+        for(let symbol of symbols) {
             const method = new MethodInfo(
                 symbol.id,
                 symbol.name,
@@ -164,22 +171,22 @@ export class DocumentInfoProvider implements vscode.Disposable
             methods.push(method);
 
             const methodTokens = tokens.filter(t => symbol.range.contains(t.range.start));
-            for(let token of methodTokens)
-            {
+            for(let token of methodTokens) {
                 const name = token.text;// document.getText(token.range);
 
-                if((token.type === TokenType.method || token.type==TokenType.function)
-                 && !method.nameRange
-                    && name ===symbol.name)
-                {
+                if(
+                    (token.type === TokenType.method || token.type === TokenType.function || token.type === TokenType.member)
+                    && !method.nameRange
+                    && name === symbol.name
+                ) {
                     method.nameRange = token.range;
                 }
 
-                if(token.type == TokenType.parameter)
-                {
-                    if(method.parameters.any(p => p.name == name))
+                if(token.type === TokenType.parameter) {
+                    if(method.parameters.any(p => p.name === name)) {
                         continue;
-                    
+                    }
+
                     method.parameters.push({ name, range: token.range, token });
                 }
             }
@@ -188,7 +195,7 @@ export class DocumentInfoProvider implements vscode.Disposable
         return methods;
     }
 
-    public createLineInfos(document: vscode.TextDocument, codeObjectSummaries: CodeObjectSummeryAccessor, methods: MethodInfo[]): LineInfo[]
+    public createLineInfos(document: vscode.TextDocument, codeObjectSummaries: CodeObjectSummaryAccessor, methods: MethodInfo[]): LineInfo[]
     {
         const lineInfos: LineInfo[] = [];
         for(let method of methods)
@@ -258,15 +265,15 @@ class DocumentInfoContainer
 
 export interface DocumentInfo
 {
-    summaries: CodeObjectSummeryAccessor;
+    summaries: CodeObjectSummaryAccessor;
     methods: MethodInfo[];
     lines: LineInfo[];
     tokens: Token[];
     endpoints: EndpointInfo[];
     spans: SpanInfo[];
     uri: vscode.Uri;
 }
-export class CodeObjectSummeryAccessor{
+export class CodeObjectSummaryAccessor{
     constructor(private _codeObejctSummeries: CodeObjectSummary[]){}
 
     public get<T extends CodeObjectSummary>(type: { new(): T ;}, codeObjectId: string): T | undefined