Merge pull request #226 from digma-ai/feat4demo/span-dur-chg-notif

Feat4demo/span dur chg notif

Author: noamkfir

.vscode/settings.json

@@ -11,5 +11,6 @@
     "python.linting.enabled": true,
     "digma.environment": "DEV",
     "torque.activeProfile": "",
-    "editor.detectIndentation": false
+    "editor.detectIndentation": false,
+    "editor.tabSize": 4,
 }

README.md

@@ -9,14 +9,20 @@ This is a  [Visual Studio Code](https://code.visualstudio.com)  extension for Di
 ### 🤨 What does this extension do? 
 It provides code objects insights and runtime analytics inside the IDE. The IDE is inteded to be extensible (currentluy refactoring toward that), so that anyone would be able to define new types of insights based on the collected data. 
 
-- [Code Objects Discovery](#code-object-discovery)
-- [Pull Request Insights](#pr-insights) (WIP)
-- [Code Insights](#code-insights)
-- [Runtime Errors](#runtime-errors)
-- [Runtime Errors Drilldown](#runtime-errors-drilldown)
-- [Code Objects Annotation](#code-obj-annotation)
-- [Usage Analytics](#usage-analytics)
-- [Selecting Environments](#environment)
+- [Digma Visual Studio Code Plugin](#digma-visual-studio-code-plugin)
+    - [🤨 What does this extension do?](#-what-does-this-extension-do)
+      - [🔬 Code Object Discovery](#-code-object-discovery)
+      - [🧑‍💻 Pull Request Insights (WIP)](#-pull-request-insights-wip)
+      - [🧑‍🔬 Code Insights](#-code-insights)
+      - [🪳 Runtime Errors](#-runtime-errors)
+        - [? What is a code object flow ?](#-what-is-a-code-object-flow-)
+      - [👓 Runtime Errors Drilldown](#-runtime-errors-drilldown)
+      - [🔦 Code Objects Annotation](#-code-objects-annotation)
+      - [🎯 Usage Analytics](#-usage-analytics)
+      - [፨ Selecting Environments](#-selecting-environments)
+      - [⚙️ Extension Settings](#️-extension-settings)
+  - [How to Build](#how-to-build)
+    - [License](#license)
 
 
 #### 🔬 [Code Object Discovery](#code-object-discovery)	
@@ -115,11 +121,12 @@ Environments can be easily assigned to observability data collected via an env v
 This extension contributes the following settings:
 | Key | Description |
 | :-- | :---------- |
-| `digma.enableCodeLens` | Enable/Disable methods codelens regarding errors.|
+| `digma.enableCodeLens` | Enable/disable methods codelens regarding errors.|
 | `digma.url` | Digma api endpoint url.|
 | `digma.environment` | Filter the telemtry data by environment. <br/> Can be set from the [Context](#context-panel) panel, by selecting from the **Environment** dropdown. |
 | `digma.hideFramesOutsideWorkspace` | Show/Hide frame of files that do not belog to the opened workspace(s)<br/>Can be in [Error Flow Details](#error-flow-details-panel) panel, by checking/unchecking the **Workspace only** checkbox). |
 | `digma.sourceControl` | Workspace's source control - used to open files in specific revision.<br/>Only `git` is supported for now. |
+| `digma.enableNotifications` | Enable/disable insight event notifications.|
 
 ## How to Build
 

package.json

@@ -135,6 +135,10 @@
                 "digma.customHeader": {
                     "type": "string",
                     "description": "Specify a custom header to requests sent to Digma server. Useful in case Digma is deployed behind an ingress component, and need be routed (Example: \"Host:digma.loremipsum.com\")."
+                },
+                "digma.enableNotifications": {
+                    "type": "boolean",
+                    "default": false
                 }
             }
         }

src/extension.ts

@@ -18,9 +18,15 @@ import { ErrorsLineDecorator } from './views/codeAnalytics/decorators/errorsLine
 import { HotspotMarkerDecorator } from './views/codeAnalytics/decorators/hotspotMarkerDecorator';
 import { EnvSelectStatusBar } from './views/codeAnalytics/StatusBar/envSelectStatusBar';
 import { InsightsStatusBar } from './views/codeAnalytics/StatusBar/insightsStatusBar';
+import { EnvironmentManager } from './services/EnvironmentManager';
+import { EventManager } from './services/EventManager';
+import { Scheduler } from './services/Scheduler';
 
 export async function activate(context: vscode.ExtensionContext) 
 {
+    const scheduler = new Scheduler();
+    context.subscriptions.push(scheduler);
+
     const supportedLanguages = [
         new PythonLanguageExtractor(),
         new CSharpLanguageExtractor(),
@@ -40,12 +46,8 @@ export async function activate(context: vscode.ExtensionContext)
     const editorHelper = new EditorHelper(sourceControl, documentInfoProvider);
     const codeLensProvider = new AnalyticsCodeLens(documentInfoProvider, workspaceState);
 
-    if(!workspaceState.environment){
-        const firstEnv = (await analyticsProvider.getEnvironments()).firstOrDefault();
-        if(firstEnv) {
-            workspaceState.setEnvironment(firstEnv);
-        }
-    }
+    const environmentManager = new EnvironmentManager(analyticsProvider, workspaceState);
+    await environmentManager.initializeCurrentEnvironment();
 
     const envStatusbar = new EnvSelectStatusBar(workspaceState);
     const insightBar = new InsightsStatusBar(workspaceState,documentInfoProvider, editorHelper, context);
@@ -60,15 +62,21 @@ export async function activate(context: vscode.ExtensionContext)
     context.subscriptions.push(sourceControl);
     context.subscriptions.push(documentInfoProvider);
     context.subscriptions.push(new CodeAnalyticsView(analyticsProvider, documentInfoProvider,
-        context.extensionUri, editorHelper,workspaceState,codeLensProvider,envStatusbar));
+        context.extensionUri, editorHelper, workspaceState, codeLensProvider, envStatusbar, environmentManager));
     context.subscriptions.push(new ErrorsLineDecorator(documentInfoProvider));
     context.subscriptions.push(new HotspotMarkerDecorator(documentInfoProvider));
     context.subscriptions.push(new VsCodeDebugInstrumentation(analyticsProvider));
 
-    
+    context.subscriptions.push(new EventManager(
+        scheduler,
+        analyticsProvider,
+        environmentManager,
+        documentInfoProvider,
+        editorHelper,
+    ));
 }
 
 // this method is called when your extension is deactivated
 export function deactivate() {
 
-}
+}

src/services/EnvironmentManager.ts

@@ -0,0 +1,32 @@
+import { WorkspaceState } from './../state';
+import { AnalyticsProvider } from './analyticsProvider';
+
+export type Environment = string;
+
+export class EnvironmentManager {
+    private _environments: Environment[] = [];
+
+    constructor(
+        private analyticsProvider: AnalyticsProvider,
+        private workspaceState: WorkspaceState,
+    ) {
+    }
+
+    public async getEnvironments(): Promise<Environment[]> {
+        if (this._environments.length === 0) {
+            this._environments = await this.analyticsProvider.getEnvironments();
+        }
+
+        return this._environments;
+    }
+
+    public async initializeCurrentEnvironment() {
+        if(!this.workspaceState.environment){
+            const environments = await this.getEnvironments();
+            const firstEnvironment = (environments).firstOrDefault();
+            if(firstEnvironment) {
+                this.workspaceState.setEnvironment(firstEnvironment);
+            }
+        }
+    }
+}

src/services/EventManager.ts

@@ -0,0 +1,59 @@
+import * as vscode from 'vscode';
+import { EditorHelper } from './EditorHelper';
+import { DocumentInfoProvider } from './documentInfoProvider';
+import { SpanSearchInfo } from './../views/codeAnalytics/InsightListView/Common/SpanSearch';
+import { AnalyticsProvider, CodeObjectDurationChangeEvent } from './analyticsProvider';
+import { Scheduler } from './Scheduler';
+import { EnvironmentManager } from './EnvironmentManager';
+import { SpanSearch } from '../views/codeAnalytics/InsightListView/Common/SpanSearch';
+import { Settings } from '../settings';
+
+export class EventManager implements vscode.Disposable {
+    private lastFetch = new Date();
+
+    constructor(
+        scheduler: Scheduler,
+        private analyticsProvider: AnalyticsProvider,
+        private environmentManager: EnvironmentManager,
+        private documentInfoProvider: DocumentInfoProvider,
+        private editorHelper: EditorHelper,
+    ) {
+        if(Settings.enableNotifications.value) {
+            scheduler.schedule(15, this.fetchEvents.bind(this));
+        }
+    }
+
+    private async fetchEvents() {
+        const environments = await this.environmentManager.getEnvironments();
+
+        const now = new Date();
+        const { events } = await this.analyticsProvider.getEvents(environments, this.lastFetch);
+        this.lastFetch = now;
+
+        events.forEach(async (event) => {
+            const eventData = <CodeObjectDurationChangeEvent>event;
+            const message = `A possible change was detected in "${eventData?.span?.displayName}". Would you like to check it out?`;
+            const item = 'Go';
+            const response = await vscode.window.showInformationMessage(message, item);
+            if(response === item) {
+                const span: SpanSearchInfo = {
+                    instrumentationLibrary: eventData.span.instrumentationLibrary,
+                    name: eventData.span.name,
+                };
+                const spanSearch = new SpanSearch(this.documentInfoProvider);
+                const spanLocations = await spanSearch.searchForSpans([span]);
+                const spanLocation = spanLocations[0];
+                if(spanLocation !== undefined) {
+                    const uri = spanLocation.documentUri;
+                    const line = spanLocation.range.end.line + 1;
+
+                    const document = await this.editorHelper.openTextDocumentFromUri(uri);
+                    await this.editorHelper.openFileAndLine(document, line);
+                }
+            }
+        });
+    }
+
+    dispose() {
+    }
+}

src/services/Scheduler.ts

@@ -0,0 +1,66 @@
+type Interval = number;
+type Time = number;
+
+export class Scheduler {
+    private _timer?: NodeJS.Timeout;
+    private readonly _jobs: Job[] = [];
+
+    constructor() {
+        this.nextTick();
+    }
+
+    private async tick() {
+        this._jobs
+            .filter((job) => !job.running && job.schedule.isReady(Date.now(), job.previous))
+            .forEach(async (job) => {
+                try {
+                    job.running = true;
+                    await job.action();
+                }
+                finally {
+                    // record the time the job ended rather than started to avoid starvation
+                    job.previous = Date.now();
+                    job.running = false;
+                }
+            });
+
+        this.nextTick();
+    }
+
+    private nextTick() {
+        this._timer = setTimeout(this.tick.bind(this), 1000);
+    }
+
+    public schedule(interval: Interval, action: Function) {
+        this._jobs.push({
+            schedule: new IntervalBasedSchedule(interval),
+            action: action,
+        });
+    }
+
+    public dispose() {
+        if (this._timer) {
+            clearTimeout(this._timer);
+        }
+    }
+}
+
+interface Schedule {
+    isReady(now: Time, previous?: Time): boolean;
+}
+
+class IntervalBasedSchedule implements Schedule {
+    constructor(private interval: Interval) {
+    }
+
+    public isReady(now: Time, previous?: Time) {
+        return !previous || (now - previous) > this.interval * 1000;
+    }
+}
+
+interface Job {
+    previous?: Time
+    running?: boolean
+    schedule: Schedule
+    action: Function
+}