Development: Add more data for telemetry

src/main/java/de/tum/cit/aet/artemis/core/service/telemetry/EurekaClientService.java

@@ -0,0 +1,92 @@
+package de.tum.cit.aet.artemis.core.service.telemetry;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Collections;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@Service
+public class EurekaClientService {
+
+    private static final Logger log = LoggerFactory.getLogger(EurekaClientService.class);
+
+    @Value("${eureka.client.service-url.defaultZone}")
+    private String eurekaServiceUrl;
+
+    private final RestTemplate restTemplate;
+
+    public EurekaClientService(RestTemplate restTemplate) {
+        this.restTemplate = restTemplate;
+    }
+
+    /**
+     * Retrieves the number of Artemis application instances registered with the Eureka server.
+     * <p>
+     * This method makes an HTTP GET request to the Eureka server's `/api/eureka/applications` endpoint to
+     * retrieve a list of all registered applications. It then filters out the Artemis application
+     * and returns the number of instances associated with it. If any error occurs during the request
+     * (e.g., network issues, parsing issues, invalid URI), the method returns 1 as the default value.
+     *
+     * @return the number of Artemis application instances, or 1 if an error occurs.
+     */
+    public long getNumberOfReplicas() {
+        try {
+            var eurekaURI = new URI(eurekaServiceUrl);
+            HttpHeaders headers = createHeaders(eurekaURI.getUserInfo());
+            HttpEntity<String> request = new HttpEntity<>(headers);
+            var requestUrl = eurekaURI.getScheme() + "://" + eurekaURI.getAuthority() + "/api/eureka/applications";
+
+            ResponseEntity<String> response = restTemplate.exchange(requestUrl, HttpMethod.GET, request, String.class);
+
+            ObjectMapper objectMapper = new ObjectMapper();
+            JsonNode rootNode = objectMapper.readTree(response.getBody());
+            JsonNode applicationsNode = rootNode.get("applications");
+            for (JsonNode application : applicationsNode) {
+                if (application.get("name").asText().equals("ARTEMIS")) {
+                    JsonNode instancesNode = application.get("instances");
+                    return instancesNode.size();
+                }
+            }
+        }
+        catch (RestClientException | JacksonException | URISyntaxException e) {
+            log.warn("Error while trying to retrieve number of replicas.");
+        }
+
+        return 1;
+    }
+
+    /**
+     * Creates HTTP headers with Basic Authentication and JSON content type.
+     *
+     * @param auth the user credentials in the format "username:password" to be encoded and included in the Authorization header.
+     * @return HttpHeaders with Basic Authentication and JSON content types.
+     */
+    private HttpHeaders createHeaders(String auth) {
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
+
+        byte[] encodedAuth = Base64.getEncoder().encode(auth.getBytes(StandardCharsets.US_ASCII));
+        String authHeader = "Basic " + new String(encodedAuth);
+
+        headers.set("Authorization", authHeader);
+        return headers;
+    }
+}

src/main/java/de/tum/cit/aet/artemis/core/service/TelemetrySendingService.java → src/main/java/de/tum/cit/aet/artemis/core/service/telemetry/TelemetrySendingService.java

@@ -1,4 +1,4 @@
-package de.tum.cit.aet.artemis.core.service;
+package de.tum.cit.aet.artemis.core.service.telemetry;
 
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_SCHEDULING;
 
@@ -21,23 +21,32 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
 
+import de.tum.cit.aet.artemis.core.service.ProfileService;
+
 @Service
 @Profile(PROFILE_SCHEDULING)
 public class TelemetrySendingService {
 
     private static final Logger log = LoggerFactory.getLogger(TelemetrySendingService.class);
 
     @JsonInclude(JsonInclude.Include.NON_EMPTY)
-    public record TelemetryData(String version, String serverUrl, String operator, String contact, List<String> profiles, String adminName) {
+    public record TelemetryData(String version, String serverUrl, String operator, List<String> profiles, boolean isProductionInstance, String dataSource, long numberOfNodes,
+            long buildAgentCount, String contact, String adminName) {
     }
 
     private final Environment env;
 
     private final RestTemplate restTemplate;
 
-    public TelemetrySendingService(Environment env, RestTemplate restTemplate) {
+    private final EurekaClientService eurekaClientService;
+
+    private final ProfileService profileService;
+
+    public TelemetrySendingService(Environment env, RestTemplate restTemplate, EurekaClientService eurekaClientService, ProfileService profileService) {
         this.env = env;
         this.restTemplate = restTemplate;
+        this.eurekaClientService = eurekaClientService;
+        this.profileService = profileService;
     }
 
     @Value("${artemis.version}")
@@ -61,6 +70,15 @@ public TelemetrySendingService(Environment env, RestTemplate restTemplate) {
     @Value("${artemis.telemetry.destination}")
     private String destination;
 
+    @Value("${spring.datasource.url}")
+    private String datasourceUrl;
+
+    @Value("${eureka.client.enabled}")
+    private boolean eurekaEnabled;
+
+    @Value("${artemis.continuous-integration.concurrent-build-size}")
+    private long buildAgentCount;
+
     /**
      * Assembles the telemetry data, and sends it to the external telemetry server.
      *
@@ -70,11 +88,19 @@ public TelemetrySendingService(Environment env, RestTemplate restTemplate) {
     public void sendTelemetryByPostRequest() throws Exception {
         List<String> activeProfiles = Arrays.asList(env.getActiveProfiles());
         TelemetryData telemetryData;
+        var dataSource = datasourceUrl.startsWith("jdbc:mysql") ? "mysql" : "postgresql";
+        long numberOfInstances = 1;
+        if (eurekaEnabled) {
+            numberOfInstances = eurekaClientService.getNumberOfReplicas();
+        }
+
         if (sendAdminDetails) {
-            telemetryData = new TelemetryData(version, serverUrl, operator, contact, activeProfiles, operatorAdminName);
+            telemetryData = new TelemetryData(version, serverUrl, operator, activeProfiles, profileService.isProductionActive(), dataSource, numberOfInstances, buildAgentCount,
+                    contact, operatorAdminName);
         }
         else {
-            telemetryData = new TelemetryData(version, serverUrl, operator, null, activeProfiles, null);
+            telemetryData = new TelemetryData(version, serverUrl, operator, activeProfiles, profileService.isProductionActive(), dataSource, numberOfInstances, buildAgentCount,
+                    null, null);
         }
 
         HttpHeaders headers = new HttpHeaders();

src/main/java/de/tum/cit/aet/artemis/core/service/TelemetryService.java → src/main/java/de/tum/cit/aet/artemis/core/service/telemetry/TelemetryService.java

@@ -1,4 +1,4 @@
-package de.tum.cit.aet.artemis.core.service;
+package de.tum.cit.aet.artemis.core.service.telemetry;
 
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_SCHEDULING;
 
@@ -12,6 +12,8 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 
+import de.tum.cit.aet.artemis.core.service.ProfileService;
+
 @Service
 @Profile(PROFILE_SCHEDULING)
 public class TelemetryService {

src/test/java/de/tum/cit/aet/artemis/telemetry/TelemetryServiceTest.java

@@ -2,31 +2,36 @@
 
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.mockito.Mockito.spy;
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.header;
 import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
 import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
 import static org.springframework.test.web.client.response.MockRestResponseCreators.withServerError;
 import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
 import static org.testcontainers.shaded.org.awaitility.Awaitility.await;
 
 import java.net.URI;
+import java.util.List;
+import java.util.Map;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.client.ExpectedCount;
 import org.springframework.test.web.client.MockRestServiceServer;
 import org.springframework.web.client.RestTemplate;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import de.tum.cit.aet.artemis.AbstractSpringIntegrationIndependentTest;
-import de.tum.cit.aet.artemis.core.service.TelemetryService;
+import de.tum.cit.aet.artemis.core.service.telemetry.TelemetryService;
 
 @ExtendWith(MockitoExtension.class)
 class TelemetryServiceTest extends AbstractSpringIntegrationIndependentTest {
@@ -46,19 +51,45 @@ class TelemetryServiceTest extends AbstractSpringIntegrationIndependentTest {
     @Value("${artemis.telemetry.destination}")
     private String destination;
 
+    @Value("${eureka.client.service-url.defaultZone}")
+    private String defaultZoneUrl;
+
+    private String eurekaRequestUrl;
+
+    private byte[] appliciationsBody;
+
     @BeforeEach
-    void init() {
+    void init() throws JsonProcessingException {
+        try {
+            var eurekaURI = new URI(defaultZoneUrl);
+            eurekaRequestUrl = eurekaURI.getScheme() + "://" + eurekaURI.getAuthority() + "/api/eureka/applications";
+
+        }
+        catch (Exception ignored) {
+        }
+
         telemetryServiceSpy = spy(telemetryService);
-        mockServer = MockRestServiceServer.createServer(restTemplate);
+
+        appliciationsBody = mapper.writeValueAsBytes(Map.of("applications", List.of(Map.of("name", "ARTEMIS", "instances", List.of(Map.of()) // Mocking an instance object
+        ))));
+        MockRestServiceServer.MockRestServiceServerBuilder builder = MockRestServiceServer.bindTo(restTemplate);
+        builder.ignoreExpectOrder(true);
+        mockServer = builder.build();
+
         telemetryServiceSpy.useTelemetry = true;
     }
 
     @Test
     void testSendTelemetry_TelemetryEnabled() throws Exception {
+        mockServer.expect(ExpectedCount.once(), requestTo(new URI(eurekaRequestUrl))).andExpect(method(HttpMethod.GET))
+                .andExpect(header(HttpHeaders.AUTHORIZATION, "Basic YWRtaW46YWRtaW4="))
+                .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON).body(appliciationsBody));
+
         mockServer.expect(ExpectedCount.once(), requestTo(new URI(destination + "/api/telemetry"))).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON).body(mapper.writeValueAsString("Success!")));
         telemetryServiceSpy.sendTelemetry();
-        await().atMost(1, SECONDS).untilAsserted(() -> mockServer.verify());
+
+        await().atMost(2, SECONDS).untilAsserted(() -> mockServer.verify());
     }
 
     @Test
@@ -72,9 +103,12 @@ void testSendTelemetry_TelemetryDisabled() throws Exception {
 
     @Test
     void testSendTelemetry_ExceptionHandling() throws Exception {
+        mockServer.expect(ExpectedCount.once(), requestTo(new URI(eurekaRequestUrl))).andExpect(method(HttpMethod.GET))
+                .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON).body(appliciationsBody));
         mockServer.expect(ExpectedCount.once(), requestTo(new URI(destination + "/api/telemetry"))).andExpect(method(HttpMethod.POST))
                 .andRespond(withServerError().body(mapper.writeValueAsString("Failure!")));
+
         telemetryServiceSpy.sendTelemetry();
-        await().atMost(1, SECONDS).untilAsserted(() -> mockServer.verify());
+        await().atMost(2, SECONDS).untilAsserted(() -> mockServer.verify());
     }
 }

src/test/resources/config/application-artemis.yml

@@ -48,6 +48,7 @@ artemis:
         password: fake-password
         token: fake-token
         url: https://continuous-integration.fake.fake
+        concurrent-build-size: 1
         secret-push-token: fake-token-hash
         vcs-credentials: fake-key
         artemis-authentication-token-key: fake-key

src/test/resources/config/application.yml

@@ -75,6 +75,7 @@ spring:
     application:
         name: Artemis
     datasource:
+        url: jdbc:mysql://artemis-mysql:3306/
         type: com.zaxxer.hikari.HikariDataSource
         name:
         username:
@@ -288,3 +289,10 @@ jhipster:
 
 aeolus:
     url: http://mock-aeolus-url:8090
+
+# Eureka configuration
+eureka:
+    client:
+        enabled: true
+        service-url:
+            defaultZone: http://admin:admin@localhost:8761/eureka/