Support component name for general release metrics

Signed-off-by: Prudhvi Godithi <[email protected]>

src/main/java/org/opensearchmetrics/metrics/MetricsCalculation.java

@@ -126,19 +126,19 @@ public void generateLabelMetrics(List<String> repositories) {
                                 throw new RuntimeException(e);
                             }
                             return labelInfo.entrySet().stream().flatMap(entry -> {
-                                String labelname = entry.getKey();
+                                String labelName = entry.getKey();
                                 List<Long> values = entry.getValue();
                                 LabelData labelData = new LabelData();
                                 try {
                                     labelData.setId(String.valueOf(UUID.nameUUIDFromBytes(MessageDigest.getInstance("SHA-1")
-                                            .digest(("label-metrics-" + labelname + "-" + currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + "-" + repo)
+                                            .digest(("label-metrics-" + labelName + "-" + currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + "-" + repo)
                                                     .getBytes()))));
                                 } catch (NoSuchAlgorithmException e) {
                                     throw new RuntimeException(e);
                                 }
                                 labelData.setRepository(repo);
                                 labelData.setCurrentDate(currentDate.toString());
-                                labelData.setLabelName(labelname);
+                                labelData.setLabelName(labelName);
                                 labelData.setLabelPullCount(values.get(1));
                                 labelData.setLabelIssueCount(values.get(0));
                                 return Stream.of(labelData);
@@ -155,35 +155,38 @@ public void generateReleaseMetrics() {
         Map<String, String> metricFinalData =
                 Arrays.stream(releaseInputs)
                         .filter(ReleaseInputs::getTrack)
-                        .flatMap(releaseInput -> releaseMetrics.getReleaseRepos(releaseInput.getVersion()).stream()
-                        .flatMap(repo -> {
+                        .flatMap(releaseInput -> releaseMetrics.getReleaseRepos(releaseInput.getVersion()).entrySet().stream()
+                        .flatMap(entry -> {
+                            String repoName = entry.getKey();
+                            String componentName = entry.getValue();
                             ReleaseMetricsData releaseMetricsData = new ReleaseMetricsData();
-                            releaseMetricsData.setRepository(repo);
+                            releaseMetricsData.setRepository(repoName);
+                            releaseMetricsData.setComponent(componentName);
                             releaseMetricsData.setCurrentDate(currentDate.toString());
                             try {
                                 releaseMetricsData.setId(String.valueOf(UUID.nameUUIDFromBytes(MessageDigest.getInstance("SHA-1")
-                                        .digest(("release-metrics-" + releaseInput.getVersion() + "-" + currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + "-" + repo)
+                                        .digest(("release-metrics-" + releaseInput.getVersion() + "-" + currentDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + "-" + repoName)
                                                 .getBytes()))));
                             } catch (NoSuchAlgorithmException e) {
                                 throw new RuntimeException(e);
                             }
                             releaseMetricsData.setReleaseVersion(releaseInput.getVersion());
                             releaseMetricsData.setVersion(releaseInput.getVersion());
                             releaseMetricsData.setReleaseState(releaseInput.getState());
-                            releaseMetricsData.setIssuesOpen(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repo, "open", false));
-                            releaseMetricsData.setAutocutIssuesOpen(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repo, "open", true));
-                            releaseMetricsData.setIssuesClosed(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repo, "closed", false));
-                            releaseMetricsData.setPullsOpen(releaseMetrics.getReleaseLabelPulls(releaseInput.getVersion(), repo, "open"));
-                            releaseMetricsData.setPullsClosed(releaseMetrics.getReleaseLabelPulls(releaseInput.getVersion(), repo, "closed"));
-                            releaseMetricsData.setVersionIncrement(releaseMetrics.getReleaseVersionIncrement(releaseInput.getVersion(), repo, releaseInput.getBranch()));
-                            releaseMetricsData.setReleaseNotes(releaseMetrics.getReleaseNotes(releaseInput.getVersion(), repo, releaseInput.getBranch()));
-                            releaseMetricsData.setReleaseBranch(releaseMetrics.getReleaseBranch(releaseInput.getVersion(), repo));
-                            String[] releaseOwners = releaseMetrics.getReleaseOwners(releaseInput.getVersion(), repo);
+                            releaseMetricsData.setIssuesOpen(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repoName, "open", false));
+                            releaseMetricsData.setAutocutIssuesOpen(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repoName, "open", true));
+                            releaseMetricsData.setIssuesClosed(releaseMetrics.getReleaseLabelIssues(releaseInput.getVersion(), repoName, "closed", false));
+                            releaseMetricsData.setPullsOpen(releaseMetrics.getReleaseLabelPulls(releaseInput.getVersion(), repoName, "open"));
+                            releaseMetricsData.setPullsClosed(releaseMetrics.getReleaseLabelPulls(releaseInput.getVersion(), repoName, "closed"));
+                            releaseMetricsData.setVersionIncrement(releaseMetrics.getReleaseVersionIncrement(releaseInput.getVersion(), repoName, releaseInput.getBranch()));
+                            releaseMetricsData.setReleaseNotes(releaseMetrics.getReleaseNotes(releaseInput.getVersion(), repoName, releaseInput.getBranch()));
+                            releaseMetricsData.setReleaseBranch(releaseMetrics.getReleaseBranch(releaseInput.getVersion(), repoName));
+                            String[] releaseOwners = releaseMetrics.getReleaseOwners(releaseInput.getVersion(), repoName);
                             releaseMetricsData.setReleaseOwners(releaseOwners);
                             releaseMetricsData.setReleaseOwnerExists(Optional.ofNullable(releaseOwners)
                                     .map(owners -> owners.length > 0)
                                     .orElse(false));
-                            String releaseIssue = releaseMetrics.getReleaseIssue(releaseInput.getVersion(), repo);
+                            String releaseIssue = releaseMetrics.getReleaseIssue(releaseInput.getVersion(), repoName);
                             releaseMetricsData.setReleaseIssue(releaseIssue);
                             releaseMetricsData.setReleaseIssueExists(Optional.ofNullable(releaseIssue)
                                     .map(str -> !str.isEmpty())

src/main/java/org/opensearchmetrics/metrics/release/ReleaseMetrics.java

@@ -5,6 +5,7 @@
 
 import javax.inject.Inject;
 import java.util.List;
+import java.util.Map;
 
 public class ReleaseMetrics {
 
@@ -39,10 +40,11 @@ public ReleaseMetrics(OpenSearchUtil openSearchUtil, ObjectMapper objectMapper,
         this.releaseIssueChecker = releaseIssueChecker;
     }
 
-    public List<String> getReleaseRepos(String releaseVersion) {
+    public Map<String, String> getReleaseRepos(String releaseVersion) {
         return releaseRepoFetcher.getReleaseRepos(releaseVersion);
     }
 
+
     public Long getReleaseLabelIssues(String releaseVersion, String repo, String issueState, boolean autoCut) {
         return releaseLabelIssuesFetcher.releaseLabelIssues(releaseVersion, repo, issueState, autoCut, openSearchUtil);
     }

src/main/java/org/opensearchmetrics/metrics/release/ReleaseRepoFetcher.java

@@ -8,10 +8,9 @@
 import java.io.InputStreamReader;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 public class ReleaseRepoFetcher {
 
@@ -20,32 +19,28 @@ public class ReleaseRepoFetcher {
     public ReleaseRepoFetcher() {
     }
 
-    public List<String> getReleaseRepos(String releaseVersion) {
-        List<String> repoNames = new ArrayList<>();
-        repoNames.add("opensearch-build");
-        repoNames.add("performance-analyzer-rca");
-        repoNames.add("project-website");
+    public Map<String, String> getReleaseRepos(String releaseVersion) {
+        Map<String, String> repoMap = new HashMap<>();
         String[] urls = {
                 String.format("https://raw.githubusercontent.com/opensearch-project/opensearch-build/main/manifests/%s/opensearch-%s.yml", releaseVersion, releaseVersion),
                 String.format("https://raw.githubusercontent.com/opensearch-project/opensearch-build/main/manifests/%s/opensearch-dashboards-%s.yml", releaseVersion, releaseVersion)
         };
         for (String url : urls) {
             String responseBody = readUrl(url);
-            parseYaml(responseBody, repoNames);
+            parseYaml(responseBody, repoMap);
         }
-        repoNames.addAll(releaseRepoExceptionList());
-        return repoNames.stream()
-                .distinct()
-                .collect(Collectors.toList());
+        repoMap.putAll(releaseRepoExceptionMap());
+        return repoMap;
     }
 
-    public List<String> releaseRepoExceptionList() {
-        List<String> repoExceptionList = new ArrayList<>();
-        repoExceptionList.add("opensearch-build");
-        repoExceptionList.add("performance-analyzer-rca");
-        repoExceptionList.add("project-website");
-        repoExceptionList.add("documentation-website");
-        return repoExceptionList;
+
+    public Map<String, String> releaseRepoExceptionMap() {
+        Map<String, String> repoExceptionMap = new HashMap<>();
+        repoExceptionMap.put("opensearch-build", "opensearch-build");
+        repoExceptionMap.put("performance-analyzer-rca", "performance-analyzer-rca");
+        repoExceptionMap.put("project-website", "project-website");
+        repoExceptionMap.put("documentation-website", "documentation-website");
+        return repoExceptionMap;
     };
 
     public String readUrl(String url) {
@@ -70,7 +65,7 @@ public URL createURL(String url){
     }
 
 
-    public void parseYaml(String responseBody, List<String> repoNames) {
+    public void parseYaml(String responseBody, Map<String, String> repoMap) {
         new Yaml().loadAll(responseBody).forEach(document -> {
             if (document instanceof Map) {
                 Map<?, ?> map = (Map<?, ?>) document;
@@ -79,21 +74,16 @@ public void parseYaml(String responseBody, List<String> repoNames) {
                         .flatMap(value -> ((List<?>) value).stream())
                         .filter(component -> component instanceof Map)
                         .map(component -> (Map<?, ?>) component)
-                        .filter(componentMap -> {
-                            Object repository = componentMap.get("repository");
-                            return repository != null && repository.toString().contains("github.com");
-                        })
-                        .map(componentMap -> {
+                        .forEach(componentMap -> {
                             String repoUrl = componentMap.get("repository").toString();
+                            String componentName = componentMap.get("name").toString();
+
                             int startIndex = repoUrl.lastIndexOf('/') + 1;
                             int endIndex = repoUrl.lastIndexOf(".git");
-                            if (repoUrl != null && endIndex != -1) {
-                                return repoUrl.substring(startIndex, endIndex);
-                            } else {
-                                return repoUrl.substring(startIndex);
-                            }
-                        })
-                        .forEach(repoNames::add);
+                            String repoName = (endIndex != -1) ? repoUrl.substring(startIndex, endIndex) : repoUrl.substring(startIndex);
+
+                            repoMap.put(repoName, componentName);
+                        });
             }
         });
     }

src/main/java/org/opensearchmetrics/model/release/ReleaseMetricsData.java

@@ -21,6 +21,9 @@ public class ReleaseMetricsData {
     @JsonProperty("repository")
     private String repository;
 
+    @JsonProperty("component")
+    private String component;
+
     @JsonProperty("release_version")
     private String releaseVersion;
 
@@ -70,6 +73,7 @@ public String toJson(ObjectMapper mapper) throws JsonProcessingException {
         data.put("id", id);
         data.put("current_date", currentDate);
         data.put("repository", repository);
+        data.put("component", component);
         data.put("release_version", releaseVersion);
         data.put("version", version);
         data.put("release_state", releaseState);

src/test/java/org/opensearchmetrics/metrics/release/ReleaseMetricsTest.java

@@ -8,6 +8,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
@@ -47,10 +48,10 @@ public class ReleaseMetricsTest {
     @Test
     public void testGetReleaseRepos() {
         MockitoAnnotations.openMocks(this);
-        List<String> repos = Collections.singletonList("testRepo");
+        Map<String, String> repos = Collections.singletonMap("testRepo", "testComponent");
         when(releaseRepoFetcher.getReleaseRepos(anyString())).thenReturn(repos);
-        List<String> result = releaseRepoFetcher.getReleaseRepos("1.0.0");
-        assertSame(repos, result);
+        Map<String, String> result = releaseRepoFetcher.getReleaseRepos("1.0.0");
+        assertEquals(repos, result);
     }
 
     @Test

src/test/java/org/opensearchmetrics/metrics/release/ReleaseRepoFetcherTest.java

@@ -9,7 +9,9 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -36,15 +38,15 @@ public void testReleaseRepoExceptionList() {
         ReleaseRepoFetcher fetcher = new ReleaseRepoFetcher();
 
         // Call the method under test
-        List<String> result = fetcher.releaseRepoExceptionList();
-        List<String> expectedList = new ArrayList<>();
-        expectedList.add("opensearch-build");
-        expectedList.add("performance-analyzer-rca");
-        expectedList.add("project-website");
-        expectedList.add("documentation-website");
+        Map<String, String> result = fetcher.releaseRepoExceptionMap();
+        Map<String, String> expectedMap = new HashMap<>();
+        expectedMap.put("opensearch-build", "opensearch-build");
+        expectedMap.put("performance-analyzer-rca", "performance-analyzer-rca");
+        expectedMap.put("project-website", "project-website");
+        expectedMap.put("documentation-website", "documentation-website");
 
         // Assert that the result matches the expected list
-        assertEquals(expectedList, result);
+        assertEquals(expectedMap, result);
     }
     @Test
     public void testCreateURL() {
@@ -72,7 +74,7 @@ public void testParseYaml() {
                 "    checks:\n" +
                 "      - gradle:publish\n" +
                 "      - gradle:properties:version\n" +
-                "  - name: common-utils\n" +
+                "  - name: commonUtils\n" +
                 "    repository: https://github.com/opensearch-project/common-utils.git\n" +
                 "    ref: tags/1.3.15.0\n" +
                 "    checks:\n" +
@@ -81,18 +83,22 @@ public void testParseYaml() {
                 "    platforms:\n" +
                 "      - linux\n" +
                 "      - windows\n";
-        List<String> repoNames = new ArrayList<>();
+        Map<String, String> repoNames = new HashMap<>();
         ReleaseRepoFetcher fetcher = new ReleaseRepoFetcher();
         fetcher.parseYaml(responseBody, repoNames);
         assertEquals(2, repoNames.size());
-        assertEquals(new ArrayList<>(Arrays.asList("OpenSearch", "common-utils")), repoNames);
+        Map<String, String> expectedRepoNames = new HashMap<>();
+        expectedRepoNames.put("OpenSearch", "OpenSearch");
+        expectedRepoNames.put("common-utils", "commonUtils");
+        assertEquals(expectedRepoNames, repoNames);
+        // assertEquals(new ArrayList<>(Arrays.asList("OpenSearch", "common-utils")), repoNames);
     }
 
     @Test
     public void testGetReleaseRepos() {
         ReleaseRepoFetcher fetcher = Mockito.spy(new ReleaseRepoFetcher());
         Mockito.doReturn("Test content").when(fetcher).readUrl(Mockito.anyString());
-        List<String> repos = fetcher.getReleaseRepos("1.0.0");
+        Map<String, String> repos = fetcher.getReleaseRepos("1.0.0");
         // Default will always have 4 repos part of exception list
         assertEquals(4, repos.size());
     }
@@ -101,18 +107,20 @@ public void testGetReleaseRepos() {
     public void testGetReleaseRepos_withData() {
         ReleaseRepoFetcher fetcher = Mockito.spy(new ReleaseRepoFetcher());
         Mockito.doReturn("Test content").when(fetcher).readUrl(Mockito.anyString());
-        List<String> repoNames = new ArrayList<>();
-        repoNames.add("repo1");
+        Map<String, String> repoNames = new HashMap<>();
+        repoNames.put("repoName", "componentName");
         Mockito.doAnswer(invocation -> {
             Object[] args = invocation.getArguments();
-            List<String> list = (List<String>) args[1];
-            list.addAll(repoNames);
+            String responseBody = (String) args[0];
+            Map<String, String> map = (Map<String, String>) args[1];
+            // Add all entries from repoNames to the provided map
+            map.putAll(repoNames);
             return null;
-        }).when(fetcher).parseYaml(Mockito.anyString(), Mockito.anyList());
-        List<String> repos = fetcher.getReleaseRepos("1.0.0");
+        }).when(fetcher).parseYaml(Mockito.anyString(), Mockito.anyMap());
+        Map<String, String> repos = fetcher.getReleaseRepos("1.0.0");
         // Default will always have 4 repos part of exception list
         assertEquals(5, repos.size());
-        assertTrue(repos.contains("repo1"));
+        assertTrue(repos.containsKey("repoName"));
     }
 
 }