Development: Add more data for Telemetry

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

@@ -0,0 +1,89 @@
+package de.tum.cit.aet.artemis.core.service.telemetry;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_SCHEDULING;
+
+import java.net.URI;
+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.context.annotation.Profile;
+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.RestTemplate;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@Profile(PROFILE_SCHEDULING)
+@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);
+
+            for (JsonNode application : new ObjectMapper().readTree(response.getBody()).get("applications")) {
+                if (application.get("name").asText().equals("ARTEMIS")) {
+                    return application.get("instances").size();
+                }
+            }
+        }
+        catch (Exception 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/telemetry/TelemetrySendingService.java

@@ -0,0 +1,144 @@
+package de.tum.cit.aet.artemis.core.service.telemetry;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_SCHEDULING;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.env.Environment;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+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, List<String> profiles, boolean isProductionInstance, boolean isTestServer, String dataSource,
+            boolean isMultiNode, long numberOfNodes, long buildAgentCount, String contact, String adminName) {
+    }
+
+    private final Environment env;
+
+    private final RestTemplate restTemplate;
+
+    private final ProfileService profileService;
+
+    private final EurekaClientService eurekaClientService;
+
+    public TelemetrySendingService(Environment env, RestTemplate restTemplate, ProfileService profileService, EurekaClientService eurekaClientService) {
+        this.env = env;
+        this.restTemplate = restTemplate;
+        this.profileService = profileService;
+        this.eurekaClientService = eurekaClientService;
+    }
+
+    @Value("${artemis.version}")
+    private String version;
+
+    @Value("${server.url}")
+    private String serverUrl;
+
+    @Value("${info.operatorName}")
+    private String operator;
+
+    @Value("${info.operatorAdminName}")
+    private String operatorAdminName;
+
+    @Value("${info.contact}")
+    private String operatorContact;
+
+    @Value("${artemis.telemetry.destination}")
+    private String destination;
+
+    @Value("${spring.datasource.url}")
+    private String datasourceUrl;
+
+    @Value("${artemis.continuous-integration.concurrent-build-size:0}")
+    private long buildAgentCount;
+
+    @Value("${info.test-server:false}")
+    private boolean isTestServer;
+
+    /**
+     * Sends telemetry data to a specified destination via an HTTP POST request asynchronously.
+     * The telemetry includes information about the application version, environment, data source,
+     * and optionally, administrator details. If Eureka is enabled, the number of registered
+     * instances is also included.
+     *
+     * <p>
+     * The method constructs the telemetry data object, converts it to JSON, and sends it to a
+     * telemetry collection server. The request is sent asynchronously due to the {@code @Async} annotation.
+     *
+     * @param eurekaEnabled    a flag indicating whether Eureka is enabled. If {@code true},
+     *                             the method retrieves the number of instances registered with Eureka.
+     * @param sendAdminDetails a flag indicating whether to include administrator details in the
+     *                             telemetry data (such as contact information and admin name).
+     */
+    public void sendTelemetryByPostRequest(boolean eurekaEnabled, boolean sendAdminDetails) {
+
+        long numberOfNodes = 1;
+
+        if (eurekaEnabled) {
+            log.info("Querying other instances from Eureka...");
+            numberOfNodes = eurekaClientService.getNumberOfReplicas();
+        }
+
+        try {
+            String telemetryJson = new ObjectMapper().writer().withDefaultPrettyPrinter().writeValueAsString(buildTelemetryData(sendAdminDetails, eurekaEnabled, numberOfNodes));
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<String> requestEntity = new HttpEntity<>(telemetryJson, headers);
+
+            log.info("Sending telemetry to {}", destination);
+            var response = restTemplate.postForEntity(destination + "/api/telemetry", requestEntity, String.class);
+            log.info("Successfully sent telemetry data. {}", response.getBody());
+        }
+        catch (JsonProcessingException e) {
+            log.warn("JsonProcessingException in sendTelemetry.", e);
+        }
+        catch (Exception e) {
+            log.warn("Exception in sendTelemetry, with dst URI: {}", destination, e);
+        }
+    }
+
+    /**
+     * Retrieves telemetry data for the current system configuration, including details
+     * about the active profiles, data source type, and optionally admin contact details.
+     *
+     * @param sendAdminDetails whether to include admin contact information in the telemetry data
+     * @param isMultiNode      whether the application runs in multi node or single node mode
+     * @param numberOfNodes    the number of nodes which are part of the cluster
+     * @return an instance of {@link TelemetryData} containing the gathered telemetry information
+     */
+    private TelemetryData buildTelemetryData(boolean sendAdminDetails, boolean isMultiNode, long numberOfNodes) {
+        TelemetryData telemetryData;
+        var dataSource = datasourceUrl.startsWith("jdbc:mysql") ? "mysql" : "postgresql";
+        List<String> activeProfiles = Arrays.asList(env.getActiveProfiles());
+
+        String contact = null;
+        String adminName = null;
+        if (sendAdminDetails) {
+            contact = operatorContact;
+            adminName = operatorAdminName;
+        }
+        telemetryData = new TelemetryData(version, serverUrl, operator, activeProfiles, profileService.isProductionActive(), isTestServer, dataSource, isMultiNode, numberOfNodes,
+                buildAgentCount, contact, adminName);
+        return telemetryData;
+    }
+}