1) update GitHub API to support new /metrics route, replace the old /usage route 2) add MetricsToUsageConverter class, to map the new returned metrics schedma to old metrics schema, so the caller don't need to update more. 3) add CopilotUsageChecker to check the data quality of the new fetched schema, and display it in api-response page.

Author: DevOps-zhuang

src/api/GitHubApi.ts

@@ -1,14 +1,11 @@
-//Make a call to the GitHub API to get Copilot Metrics, the API is /api/github/orgs/toussaintt/copilot/usage
-//Add the header Accept: application/vnd.github+json to the request
-//Add also the Authorization: Bearer <token> header where <token> is hardcoded for now
-//Also add X-GitHub-Api-Version: 2022-11-28 header
-//Return the response from the API
-
 import axios from "axios";
-
 import { Metrics } from "../model/Metrics";
-import organizationMockedResponse from '../assets/organization_response_sample.json';
-import enterpriseMockedResponse from '../assets/enterprise_response_sample.json';
+import { CopilotMetrics } from '../model/Copilot_Metrics';
+import { convertToMetrics } from './MetricsToUsageConverter';
+import organizationMockedResponse from '../assets/organization_usage_response_sample.json';
+import enterpriseMockedResponse from '../assets/enterprise_usage_response_sample.json';
+import organizationMockedMetricsResponse from '../assets/organization_metrics_response_sample.json';
+import enterpriseMockedMetricsResponse from '../assets/enterprise_metrics_response_sample.json';
 import config from '../config';
 
 const headers = {
@@ -17,27 +14,43 @@ const headers = {
   ...(config.github.token ? { Authorization: `token ${config.github.token}` } : {})
 };
 
-export const getMetricsApi = async (): Promise<Metrics[]> => {
+const ensureCopilotMetrics = (data: any[]): CopilotMetrics[] => {
+  return data.map(item => {
+    if (!item.copilot_ide_code_completions) {
+      item.copilot_ide_code_completions = { editors: [] };
+    }
+    item.copilot_ide_code_completions.editors?.forEach((editor: any) => {
+      editor.models?.forEach((model: any) => {
+        if (!model.languages) {
+          model.languages = [];
+        }
+      });
+    });
+    return item as CopilotMetrics;
+  });
+};
 
+export const getMetricsApi = async (): Promise<{ metrics: Metrics[], original: CopilotMetrics[] }> => {
   let response;
-  let metricsData;
+  let metricsData: Metrics[];
+  let originalData: CopilotMetrics[];
 
   if (config.mockedData) {
     console.log("Using mock data. Check VUE_APP_MOCKED_DATA variable.");
-    response = config.scope.type === "organization" ? organizationMockedResponse : enterpriseMockedResponse;
-    metricsData = response.map((item: any) => new Metrics(item));
+    response = config.scope.type === "organization" ? organizationMockedMetricsResponse : enterpriseMockedMetricsResponse;
+    originalData = ensureCopilotMetrics(response);
+    metricsData = convertToMetrics(originalData);
   } else {
     response = await axios.get(
-      `${config.github.apiUrl}/copilot/usage`,
+      `${config.github.apiUrl}/copilot/metrics`,
       {
-       headers
+        headers
       }
     );
-
-
-    metricsData = response.data.map((item: any) => new Metrics(item));
+    originalData = ensureCopilotMetrics(response.data);
+    metricsData = convertToMetrics(originalData);
   }
-  return metricsData;
+  return { metrics: metricsData, original: originalData };
 };
 
 export const getTeams = async (): Promise<string[]> => {
@@ -48,12 +61,12 @@ export const getTeams = async (): Promise<string[]> => {
   return response.data;
 }
 
-export const getTeamMetricsApi = async (): Promise<Metrics[]> => {
+export const getTeamMetricsApi = async (): Promise<{ metrics: Metrics[], original: CopilotMetrics[] }> => {
   console.log("config.github.team: " + config.github.team);
 
   if (config.github.team && config.github.team.trim() !== '') {
     const response = await axios.get(
-      `${config.github.apiUrl}/team/${config.github.team}/copilot/usage`,
+      `${config.github.apiUrl}/team/${config.github.team}/copilot/metrics`,
       {
         headers: {
           Accept: "application/vnd.github+json",
@@ -63,9 +76,10 @@ export const getTeamMetricsApi = async (): Promise<Metrics[]> => {
       }
     );
 
-    return response.data.map((item: any) => new Metrics(item));
+    const originalData = ensureCopilotMetrics(response.data);
+    const metricsData = convertToMetrics(originalData);
+    return { metrics: metricsData, original: originalData };
   }
 
-  return [];
-
+  return { metrics: [], original: [] };
 }

src/api/MetricsToUsageConverter.ts

@@ -0,0 +1,55 @@
+import { Metrics, BreakdownData } from "../model/Metrics";
+import { CopilotMetrics } from '../model/Copilot_Metrics';
+
+export const convertToMetrics = (copilotMetrics: CopilotMetrics[]): Metrics[] => {
+  try {
+    const usageData: Metrics[] = copilotMetrics.map(metric => {
+      const breakdown: BreakdownData[] = [];
+
+      metric.copilot_ide_code_completions?.editors?.forEach(editor => {
+        editor.models?.forEach(model => {
+          model.languages?.forEach(language => {
+            breakdown.push(new BreakdownData({
+              language: language.name,
+              editor: editor.name,
+              suggestions_count: language.total_code_suggestions,
+              acceptances_count: language.total_code_acceptances,
+              lines_suggested: language.total_code_lines_suggested,
+              lines_accepted: language.total_code_lines_accepted,
+              active_users: language.total_engaged_users
+            }));
+          });
+        });
+      });
+
+      const totalChatInsertions = metric.copilot_ide_chat?.editors?.reduce((sum, editor) => 
+        sum + editor.models?.reduce((sum, model) => sum + model.total_chat_insertion_events, 0), 0) || 0;
+
+      const totalChatCopies = metric.copilot_ide_chat?.editors?.reduce((sum, editor) => 
+        sum + editor.models?.reduce((sum, model) => sum + model.total_chat_copy_events, 0), 0) || 0;
+
+      console.log(`Date: ${metric.date}`);
+      console.log(`Total Chat Insertions: ${totalChatInsertions}`);
+      console.log(`Total Chat Copies: ${totalChatCopies}`);
+
+      return new Metrics({
+        day: metric.date,
+        total_suggestions_count: breakdown.reduce((sum, item) => sum + item.suggestions_count, 0),
+        total_acceptances_count: breakdown.reduce((sum, item) => sum + item.acceptances_count, 0),
+        total_lines_suggested: breakdown.reduce((sum, item) => sum + item.lines_suggested, 0),
+        total_lines_accepted: breakdown.reduce((sum, item) => sum + item.lines_accepted, 0),
+        total_active_users: metric.total_active_users || 0,
+        total_chat_acceptances: totalChatInsertions + totalChatCopies,
+        total_chat_turns: metric.copilot_ide_chat?.editors?.reduce((sum, editor) => 
+          sum + editor.models?.reduce((sum, model) => sum + model.total_chats, 0), 0) || 0,
+        total_active_chat_users: metric.copilot_ide_chat?.total_engaged_users || 0,
+        breakdown: breakdown
+      });
+    });
+
+    return usageData;
+  } catch (error) {
+    console.error('Error converting metrics to usage format:', error);
+    return [];
+  }
+};

src/api/MetricsValidator.ts

@@ -0,0 +1,94 @@
+import { CopilotMetrics } from '../model/Copilot_Metrics';
+
+export class MetricsValidator {
+  metrics: CopilotMetrics[];
+
+  constructor(metrics: CopilotMetrics[]) {
+    this.metrics = metrics;
+  }
+
+  checkContinuousDates(): string[] {
+    const dates = this.metrics.map(metric => new Date(metric.date));
+    dates.sort((a, b) => a.getTime() - b.getTime());
+  
+    const missingDates: string[] = [];
+    for (let i = 1; i < dates.length; i++) {
+      const prevDate = dates[i - 1];
+      const currDate = dates[i];
+      const diffDays = (currDate.getTime() - prevDate.getTime()) / (1000 * 60 * 60 * 24);
+  
+      if (diffDays > 1) {
+        for (let d = 1; d < diffDays; d++) {
+          const missingDate = new Date(prevDate.getTime() + d * (1000 * 60 * 60 * 24));
+          missingDates.push(missingDate.toISOString().split('T')[0]);
+        }
+      }
+    }
+    return missingDates;
+  }
+
+  validateCodeCompletions(): { date: string, editor: string, language: string }[] {
+    const invalidEntries: { date: string, editor: string, language: string }[] = [];
+
+    this.metrics.forEach(metric => {
+      if (metric.copilot_ide_code_completions?.editors) {
+        metric.copilot_ide_code_completions.editors.forEach(editor => {
+          if (editor.models) {
+            editor.models.forEach(model => {
+              if (model.languages) {
+                model.languages.forEach(language => {
+                  if (language.total_code_acceptances > language.total_code_suggestions ||
+                      language.total_code_lines_accepted > language.total_code_lines_suggested) {
+                    invalidEntries.push({
+                      date: metric.date,
+                      editor: editor.name,
+                      language: language.name
+                    });
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+
+    return invalidEntries;
+  }
+
+  validateChatEngagedUsers(): { date: string, editor: string, total_engaged_users: number }[] {
+    const invalidEntries: { date: string, editor: string, total_engaged_users: number }[] = [];
+
+    this.metrics.forEach(metric => {
+      if (metric.copilot_ide_chat?.editors) {
+        metric.copilot_ide_chat.editors.forEach(editor => {
+          if (editor.models) {
+            const totalModelEngagedUsers = editor.models.reduce((sum, model) => 
+              sum + (model.total_engaged_users || 0), 0);
+            if (totalModelEngagedUsers < (editor.total_engaged_users || 0)) {
+              invalidEntries.push({
+                date: metric.date,
+                editor: editor.name,
+                total_engaged_users: editor.total_engaged_users
+              });
+            }
+          }
+        });
+      }
+    });
+
+    return invalidEntries;
+  }
+
+  checkAllMetrics() {
+    const nonContinuousDates = this.checkContinuousDates();
+    const invalidCodeCompletions = this.validateCodeCompletions();
+    const invalidChatEngagedUsers = this.validateChatEngagedUsers();
+
+    return {
+      nonContinuousDates,
+      invalidCodeCompletions,
+      invalidChatEngagedUsers
+    };
+  }
+}