Add Visual Studio Webview support

packages/jaeger-ui/src/api/digma/index.ts

@@ -1,8 +1,12 @@
 import logger from '../../logging';
+import { platform } from '../../platform';
 import isObject from '../../utils/ts/typeGuards/isObject';
 import ActionDispatcher from './ActionDispatcher';
+import convertToDigmaJsonRpcRequest from './json-rpc/convertToDigmaJsonRpcRequest';
+import convertToDigmaMessageData from './json-rpc/convertToDigmaMessageData';
+import isDigmaJsonRpcRequest from './json-rpc/isDigmaJsonRpcRequest';
 import { updateState } from './state';
-import { DigmaMessageEvent, IDigmaOutgoingMessageData } from './types';
+import { DigmaMessageEvent, IDigmaIncomingMessageData, IDigmaOutgoingMessageData } from './types';
 
 const isDigmaMessageEvent = (e: MessageEvent): e is DigmaMessageEvent =>
   isObject(e.data) && e.data.type === 'digma';
@@ -13,25 +17,61 @@ const INCOMING_MESSAGE_ACTION_ID_CONSOLE_STYLE = 'color: green; font-weight: bol
 
 export const initializeDigmaMessageListener = (dispatcher: ActionDispatcher) => {
   const handleDigmaMessage = (e: MessageEvent) => {
+    let data: IDigmaIncomingMessageData | undefined;
+
+    if (isDigmaJsonRpcRequest(e)) {
+      data = convertToDigmaMessageData(e.data);
+    }
+
     if (isDigmaMessageEvent(e)) {
-      logger.debug(
-        `Message received: %c${e.data.action}
+      data = e.data;
+    }
+
+    if (!data) {
+      return;
+    }
+
+    logger.debug(
+      `Message received: %c${e.data.action}
 %cRaw message: %O`,
-        INCOMING_MESSAGE_ACTION_ID_CONSOLE_STYLE,
-        null,
-        e.data
-      );
+      INCOMING_MESSAGE_ACTION_ID_CONSOLE_STYLE,
+      null,
+      e.data
+    );
 
-      updateState(e.data.action, e.data.payload);
+    updateState(e.data.action, e.data.payload);
 
-      dispatcher.dispatch(e.timeStamp, e.data.action, e.data.payload, e.data.error);
-    }
+    dispatcher.dispatch(e.timeStamp, e.data.action, e.data.payload, e.data.error);
   };
 
+  switch (platform) {
+    case 'Visual Studio':
+      if (window.chrome?.webview) {
+        window.chrome.webview.addEventListener('message', handleDigmaMessage);
+      }
+      break;
+    case 'JetBrains':
+      window.addEventListener('message', handleDigmaMessage);
+      break;
+    default:
+      break;
+  }
+
   window.addEventListener('message', handleDigmaMessage);
 
   return () => {
-    window.removeEventListener('message', handleDigmaMessage);
+    switch (platform) {
+      case 'Visual Studio':
+        if (window.chrome?.webview) {
+          window.chrome.webview.removeEventListener('message', handleDigmaMessage);
+        }
+        break;
+      case 'JetBrains':
+        window.removeEventListener('message', handleDigmaMessage);
+        break;
+      default:
+        break;
+    }
   };
 };
 
@@ -45,6 +85,21 @@ Raw message: %O`,
   updateState(message.action, message.payload);
 
   switch (window.platform) {
+    case 'Visual Studio': {
+      const jsonRpcMessage = convertToDigmaJsonRpcRequest(message);
+
+      if (window.chrome?.webview) {
+        window.chrome.webview?.postMessage(jsonRpcMessage);
+        logger.debug(
+          `Message has been successfully sent to Visual Studio: %c${jsonRpcMessage.method}
+%cRaw message: %O`,
+          OUTGOING_MESSAGE_ACTION_ID_CONSOLE_STYLE,
+          null,
+          jsonRpcMessage
+        );
+      }
+      break;
+    }
     case 'VS Code':
       if (window.sendMessageToVSCode) {
         window.sendMessageToVSCode(message);

packages/jaeger-ui/src/api/digma/json-rpc/convertToDigmaJsonRpcRequest.ts

@@ -0,0 +1,14 @@
+import isObject from '../../../utils/ts/typeGuards/isObject';
+import type { IDigmaOutgoingMessageData } from '../types';
+import { DigmaJSONRPCRequest } from './types';
+
+const convertToDigmaJsonRpcRequest = (data: IDigmaOutgoingMessageData<unknown>): DigmaJSONRPCRequest => ({
+  meta: {
+    channel: 'digma',
+  },
+  jsonrpc: '2.0',
+  method: data.action,
+  ...(isObject(data.payload) ? { params: data.payload } : {}),
+});
+
+export default convertToDigmaJsonRpcRequest;

packages/jaeger-ui/src/api/digma/json-rpc/convertToDigmaMessageData.ts

@@ -0,0 +1,10 @@
+import type { IDigmaIncomingMessageData } from '../types';
+import type { DigmaJSONRPCRequest } from './types';
+
+const convertToDigmaMessageData = (data: DigmaJSONRPCRequest): IDigmaIncomingMessageData => ({
+  type: 'digma',
+  action: data.method,
+  ...(data.params ? { payload: data.params } : {}),
+});
+
+export default convertToDigmaMessageData;

packages/jaeger-ui/src/api/digma/json-rpc/isDigmaJsonRpcRequest.ts

@@ -0,0 +1,7 @@
+import isObject from '../../../utils/ts/typeGuards/isObject';
+import type { DigmaJSONRPCRequest } from './types';
+
+const isDigmaJsonRpcRequest = (e: MessageEvent): e is MessageEvent<DigmaJSONRPCRequest> =>
+  isObject(e.data) && e.data.jsonrpc === '2.0' && isObject(e.data.meta) && e.data.meta.channel === 'digma';
+
+export default isDigmaJsonRpcRequest;

packages/jaeger-ui/src/api/digma/json-rpc/types.ts

@@ -0,0 +1,38 @@
+export type JSONRPCID = string | number | null;
+
+export interface IJSONRPCRequest {
+  jsonrpc: '2.0';
+  method: string;
+  params?: unknown[] | Record<string, unknown>;
+  id?: JSONRPCID;
+}
+
+export interface IJSONRPCSuccessResponse {
+  jsonrpc: '2.0';
+  result: unknown;
+  id: JSONRPCID;
+}
+
+export interface IJSONRPCError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+export interface IJSONRPCErrorResponse {
+  jsonrpc: '2.0';
+  error: IJSONRPCError;
+  id: JSONRPCID;
+}
+
+export interface IDigmaJSONRPCExtension {
+  meta: {
+    channel: 'digma';
+  };
+}
+
+export type DigmaJSONRPCRequest = IJSONRPCRequest & IDigmaJSONRPCExtension;
+
+export type DigmaJSONRPCErrorResponse = IJSONRPCErrorResponse & IDigmaJSONRPCExtension;
+
+export type DigmaJSONRPCSuccessResponse = IJSONRPCSuccessResponse & IDigmaJSONRPCExtension;

packages/jaeger-ui/src/components/common/InsightIcon/types.ts

@@ -33,4 +33,5 @@ export enum InsightType {
   EndpointQueryOptimizationV2 = 'EndpointQueryOptimizationV2',
   EndpointSlowdownSource = 'EndpointSlowdownSource',
   SpanPerformanceAnomaly = 'SpanPerformanceAnomaly',
+  EndpointScaling = 'EndpointScaling',
 }

packages/jaeger-ui/src/components/common/InsightIcon/utils.ts

@@ -76,6 +76,10 @@ export const getInsightTypeInfo = (
       icon: ScalesIcon,
       label: 'Scaling Issue Found',
     },
+    [InsightType.EndpointScaling]: {
+      icon: ScalesIcon,
+      label: 'Scaling Issue Found',
+    },
     [InsightType.SpanUsages]: {
       icon: SineIcon,
       label: 'Top Usage',

packages/jaeger-ui/src/logging/Logger.ts

@@ -1,12 +1,12 @@
 import moment from 'moment';
-import LOG_LEVEL from './types';
+import LogLevel from './types';
 
 class Logger {
   private minLogLevel: number;
   private showTimeStamp: boolean;
   private showLogLevel: boolean;
 
-  constructor(minLogLevel: LOG_LEVEL, showTimeStamp = true, showLogLevel = true) {
+  constructor(minLogLevel: LogLevel, showTimeStamp = true, showLogLevel = true) {
     this.minLogLevel = minLogLevel;
     this.showTimeStamp = showTimeStamp;
     this.showLogLevel = showLogLevel;
@@ -17,7 +17,7 @@ class Logger {
   }
 
   private getLogLevelTag(): string {
-    return LOG_LEVEL[this.minLogLevel];
+    return LogLevel[this.minLogLevel];
   }
 
   private getFormattedMessage(tags: string[], message: unknown): string {
@@ -34,31 +34,31 @@ class Logger {
     return `${tagsString}: ${message as string}`;
   }
 
-  public setLogLevel(logLevel: LOG_LEVEL): void {
+  public setLogLevel(logLevel: LogLevel): void {
     this.minLogLevel = logLevel;
   }
 
-  public log(level: LOG_LEVEL, tags: string[], message?: unknown, ...optionalParams: unknown[]): void {
+  public log(level: LogLevel, tags: string[], message?: unknown, ...optionalParams: unknown[]): void {
     const formattedMessage = this.getFormattedMessage(tags, message);
 
     if (this.minLogLevel > level) {
       return;
     }
 
     switch (level) {
-      case LOG_LEVEL.DEBUG:
+      case LogLevel.Debug:
         // eslint-disable-next-line no-console
         console.debug(formattedMessage, ...optionalParams);
         break;
-      case LOG_LEVEL.INFO:
+      case LogLevel.Info:
         // eslint-disable-next-line no-console
         console.info(formattedMessage, ...optionalParams);
         break;
-      case LOG_LEVEL.WARN:
+      case LogLevel.Warn:
         // eslint-disable-next-line no-console
         console.warn(formattedMessage, ...optionalParams);
         break;
-      case LOG_LEVEL.ERROR:
+      case LogLevel.Error:
         // eslint-disable-next-line no-console
         console.error(formattedMessage, ...optionalParams);
         break;
@@ -68,19 +68,19 @@ class Logger {
   }
 
   public debug(message?: unknown, ...optionalParams: unknown[]): void {
-    this.log(LOG_LEVEL.DEBUG, [], message, ...optionalParams);
+    this.log(LogLevel.Debug, [], message, ...optionalParams);
   }
 
   public info(message?: unknown, ...optionalParams: unknown[]): void {
-    this.log(LOG_LEVEL.INFO, [], message, ...optionalParams);
+    this.log(LogLevel.Info, [], message, ...optionalParams);
   }
 
   public warn(message?: unknown, ...optionalParams: unknown[]): void {
-    this.log(LOG_LEVEL.WARN, [], message, ...optionalParams);
+    this.log(LogLevel.Warn, [], message, ...optionalParams);
   }
 
   public error(message?: unknown, ...optionalParams: unknown[]): void {
-    this.log(LOG_LEVEL.ERROR, [], message, ...optionalParams);
+    this.log(LogLevel.Error, [], message, ...optionalParams);
   }
 }
 

packages/jaeger-ui/src/logging/index.ts

@@ -1,6 +1,6 @@
 import Logger from './Logger';
-import LOG_LEVEL from './types';
+import LogLevel from './types';
 
-const logger = new Logger(window.isLoggingEnabled === true ? LOG_LEVEL.DEBUG : LOG_LEVEL.NONE);
+const logger = new Logger(window.isLoggingEnabled === true ? LogLevel.Debug : LogLevel.None);
 
 export default logger;

packages/jaeger-ui/src/logging/types.ts

@@ -1,9 +1,9 @@
-enum LOG_LEVEL {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-  NONE = 4,
+enum LogLevel {
+  Debug = 0,
+  Info = 1,
+  Warn = 2,
+  Error = 3,
+  None = 4,
 }
 
-export default LOG_LEVEL;
+export default LogLevel;

packages/jaeger-ui/src/platform.ts

@@ -1,8 +1,8 @@
 import isString from './utils/ts/typeGuards/isString';
 
-type Platform = 'JetBrains' | 'VS Code' | 'Web';
+type Platform = 'JetBrains' | 'VS Code' | 'Web' | 'Visual Studio';
 
-const PLATFORMS = ['JetBrains', 'VS Code', 'Web'];
+const PLATFORMS = ['JetBrains', 'VS Code', 'Visual Studio', 'Web'];
 
 const isPlatform = (platform: unknown): platform is Platform =>
   isString(platform) && PLATFORMS.includes(platform);

packages/jaeger-ui/typings/custom.d.ts

@@ -31,12 +31,19 @@ declare interface Window {
     onFailure: (error_code, error_message) => void;
   }) => string;
   cefQueryCancel?: (request_id: string) => void;
+  chrome?: {
+    webview?: {
+      addEventListener: typeof window.addEventListener;
+      removeEventListener: typeof window.removeEventListener;
+      postMessage: typeof window.postMessage;
+    };
+  };
   sendMessageToDigma: <T>(
     message: { action: string; payload?: T } /* IDigmaOutgoingMessageData */
   ) => string | undefined;
   cancelMessageToDigma: (request_id: string) => void;
   platform?: unknown;
-  baseUrl?: unknown
+  baseUrl?: unknown;
   apiBaseUrl?: unknown;
   initialRoutePath?: unknown;
   embeddedMode?: unknown;