SECURITY_GROUPS = List.of(
+ "sg-0e357c99b6b13bf62"
+ );
+
+ /**
+ * Runs a Fargate task using the specified task definition in Amazon ECS.
+ *
+ * @param taskDefinition The ARN or family name of the task definition to use.
+ * @return The ARN of the task that was started, or null if the task failed to start.
+ */
+ public String runFargateTask(String taskDefinition, String clusterName ) {
+ EcsClient ecsClient = EcsClient.builder().region(REGION).build();
+
+ AwsVpcConfiguration vpcConfig = AwsVpcConfiguration.builder()
+ .subnets(SUBNETS)
+ .securityGroups(SECURITY_GROUPS)
+ .assignPublicIp(AssignPublicIp.ENABLED)
+ .build();
+
+ NetworkConfiguration netConfig = NetworkConfiguration.builder()
+ .awsvpcConfiguration(vpcConfig)
+ .build();
+
+ RunTaskRequest request = RunTaskRequest.builder()
+ .cluster(clusterName)
+ .launchType(LaunchType.FARGATE)
+ .taskDefinition(taskDefinition)
+ .networkConfiguration(netConfig)
+ .count(1)
+ .build();
+
+ RunTaskResponse response = ecsClient.runTask(request);
+
+ if (!response.tasks().isEmpty()) {
+ String taskArn = response.tasks().get(0).taskArn();
+ System.out.println("🚀 Started task: " + taskArn);
+ return taskArn;
+ } else {
+ System.err.println("❌ Run task failed: " + response.failures());
+ return null;
+ }
+ }
+}
diff --git a/.tools/weathertop/backend/src/main/java/com/weathertop/service/GetLogMessages.java b/.tools/weathertop/backend/src/main/java/com/weathertop/service/GetLogMessages.java
new file mode 100644
index 00000000000..0f71c21c4c6
--- /dev/null
+++ b/.tools/weathertop/backend/src/main/java/com/weathertop/service/GetLogMessages.java
@@ -0,0 +1,119 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.weathertop.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import software.amazon.awssdk.core.ResponseBytes;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
+import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
+import software.amazon.awssdk.services.s3.model.S3Object;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Comparator;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class GetLogMessages {
+
+ private static final Region REGION = Region.US_EAST_1;
+ private static final String BUCKET_NAME = "weathertop2";
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+ private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH-mm");
+
+
+ /**
+ * Retrieves the historical test summary for a specific SDK language from S3.
+ *
+ * This method performs the following steps:
+ *
+ * - Builds an {@link S3Client} for the configured {@code REGION}.
+ * - Finds the latest JSON test result file in the bucket {@code BUCKET_NAME} for the given language using {@link #getLatestFileKey}.
+ * - Downloads the JSON file as bytes and converts it to a UTF-8 string.
+ * - Parses the JSON and extracts the {@code tests} array under {@code results}.
+ * - Returns the extracted tests array as a pretty-printed JSON string. If the {@code tests} node is not an array, returns {@code "[]"}
+ *
+ *
+ * Example output:
+ *
+ * @param language The SDK language prefix (e.g., "java", "python") used to locate the latest test results.
+ * @return A pretty-printed JSON string representing the {@code tests} array for the specified language.
+ * @throws RuntimeException if there is a failure reading the JSON, extracting the tests node, or any S3-related error occurs.
+ */
+ public String getHistoricalSummary(String language) {
+ S3Client s3 = S3Client.builder()
+ .region(REGION)
+ .build();
+
+ String latestFileKey = getLatestFileKey(s3, BUCKET_NAME, language);
+ System.out.println("Latest file: " + latestFileKey);
+
+ GetObjectRequest getRequest = GetObjectRequest.builder()
+ .bucket(BUCKET_NAME)
+ .key(latestFileKey)
+ .build();
+
+ ResponseBytes objectBytes = s3.getObjectAsBytes(getRequest);
+ String jsonString = objectBytes.asString(StandardCharsets.UTF_8);
+
+ try {
+ JsonNode root = MAPPER.readTree(jsonString);
+ JsonNode testsNode = root.path("results").path("tests");
+
+ if (!testsNode.isArray()) {
+ return "[]";
+ }
+
+ return MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(testsNode);
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to parse JSON or extract tests node", e);
+ }
+ }
+
+
+ /**
+ * Retrieves the key of the latest timestamped JSON file for a given SDK language in an S3 bucket.
+ * Example filename: {@code java-2025-07-10T12-15.json}
+ * If multiple matching files exist, the one with the most recent timestamp is returned.
+ *
+ * @param s3Client The {@link S3Client} used to interact with Amazon S3.
+ * @param bucketName The name of the S3 bucket to search for JSON files.
+ * @param languagePrefix The prefix for the SDK language (e.g., "java", "python") used to filter files.
+ * @return The key of the latest JSON file matching the specified language prefix.
+ * @throws RuntimeException if no matching files are found in the bucket.
+ */
+ public static String getLatestFileKey(S3Client s3Client, String bucketName, String languagePrefix) {
+ Pattern filePattern = Pattern.compile(languagePrefix + "-(\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2})\\.json");
+
+ ListObjectsV2Request request = ListObjectsV2Request.builder()
+ .bucket(bucketName)
+ .prefix(languagePrefix + "-")
+ .build();
+
+ ListObjectsV2Response response = s3Client.listObjectsV2(request);
+ List objects = response.contents();
+
+ return objects.stream()
+ .map(S3Object::key)
+ .filter(key -> filePattern.matcher(key).matches())
+ .sorted(Comparator.comparing((String key) -> extractTimestamp(key, filePattern)).reversed())
+ .findFirst()
+ .orElseThrow(() -> new RuntimeException("No matching files found for prefix: " + languagePrefix));
+ }
+
+ private static LocalDateTime extractTimestamp(String key, Pattern pattern) {
+ Matcher matcher = pattern.matcher(key);
+ if (matcher.find()) {
+ return LocalDateTime.parse(matcher.group(1), FORMATTER);
+ } else {
+ throw new RuntimeException("Invalid file format: " + key);
+ }
+ }
+}
diff --git a/.tools/weathertop/backend/src/main/java/com/weathertop/service/HistoricalSDK.java b/.tools/weathertop/backend/src/main/java/com/weathertop/service/HistoricalSDK.java
new file mode 100644
index 00000000000..39a4f3f9941
--- /dev/null
+++ b/.tools/weathertop/backend/src/main/java/com/weathertop/service/HistoricalSDK.java
@@ -0,0 +1,117 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.weathertop.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import software.amazon.awssdk.core.ResponseBytes;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.*;
+
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class HistoricalSDK {
+
+ private static final Region REGION = Region.US_EAST_1;
+ private static final String BUCKET_NAME = "weathertop2";
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+ private static final DateTimeFormatter FILENAME_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+ /**
+ * Returns historical test summary for the latest 3 runs of the given language.
+ *
+ * @param language SDK language prefix (e.g., "java")
+ * @return A JSON string with the historical summary in the required format
+ */
+ public String getHistoricalSummary(String language) {
+ S3Client s3 = S3Client.builder().region(REGION).build();
+ String prefix = language + "-";
+ Pattern pattern = Pattern.compile(language + "-(\\d{4}-\\d{2}-\\d{2})T\\d{2}-\\d{2}\\.json");
+
+ // List all matching files
+ List matchedObjects = listMatchingObjects(s3, BUCKET_NAME, prefix, pattern);
+
+ // Sort descending by date in filename
+ matchedObjects.sort(Comparator.comparing(
+ o -> extractDateFromKey(o.key(), pattern), Comparator.reverseOrder()));
+
+ List> historyList = new ArrayList<>();
+
+ for (int i = 0; i < Math.min(3, matchedObjects.size()); i++) {
+ String key = matchedObjects.get(i).key();
+ String json = readS3Object(s3, BUCKET_NAME, key);
+
+ try {
+ JsonNode root = MAPPER.readTree(json);
+ JsonNode summary = root.path("results").path("summary");
+
+ int tests = summary.path("tests").asInt();
+ int passed = summary.path("passed").asInt();
+ double passRate = (tests == 0) ? 0.0 : (double) passed / tests * 100;
+
+ Map entry = new LinkedHashMap<>();
+ entry.put("date", extractDateFromKey(key, pattern).format(FILENAME_DATE_FORMATTER));
+ entry.put("tests", tests);
+ entry.put("passed", passed);
+ entry.put("passRate", Math.round(passRate * 100.0) / 100.0); // round to 2 decimals
+
+ historyList.add(entry);
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to parse JSON from: " + key, e);
+ }
+ }
+
+ Map result = new LinkedHashMap<>();
+ result.put("language", language);
+ result.put("history", historyList);
+
+ try {
+ return MAPPER.writeValueAsString(result);
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to serialize final result", e);
+ }
+ }
+
+ private List listMatchingObjects(S3Client s3, String bucket, String prefix, Pattern pattern) {
+ ListObjectsV2Request request = ListObjectsV2Request.builder()
+ .bucket(bucket)
+ .prefix(prefix)
+ .build();
+
+ ListObjectsV2Response response = s3.listObjectsV2(request);
+ List matched = new ArrayList<>();
+
+ for (S3Object obj : response.contents()) {
+ if (pattern.matcher(obj.key()).matches()) {
+ matched.add(obj);
+ }
+ }
+ return matched;
+ }
+
+ private String readS3Object(S3Client s3, String bucket, String key) {
+ GetObjectRequest getObjectRequest = GetObjectRequest.builder()
+ .bucket(bucket)
+ .key(key)
+ .build();
+
+ ResponseBytes bytes = s3.getObjectAsBytes(getObjectRequest);
+ return bytes.asString(StandardCharsets.UTF_8);
+ }
+
+ private LocalDate extractDateFromKey(String key, Pattern pattern) {
+ Matcher matcher = pattern.matcher(key);
+ if (matcher.find()) {
+ return LocalDate.parse(matcher.group(1));
+ } else {
+ throw new RuntimeException("Invalid key format: " + key);
+ }
+ }
+}
diff --git a/.tools/weathertop/backend/src/main/java/com/weathertop/service/QueryLatestFromS3.java b/.tools/weathertop/backend/src/main/java/com/weathertop/service/QueryLatestFromS3.java
new file mode 100644
index 00000000000..207f33f4028
--- /dev/null
+++ b/.tools/weathertop/backend/src/main/java/com/weathertop/service/QueryLatestFromS3.java
@@ -0,0 +1,120 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.weathertop.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import software.amazon.awssdk.core.ResponseBytes;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.*;
+
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Comparator;
+import java.util.List;
+import java.util.regex.*;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+/*
+ This code example is test code to query latest JSON files
+ used for weathertop 2
+ */
+public class QueryLatestFromS3 {
+
+ private static final Pattern FILE_PATTERN = Pattern.compile("java-(\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2})\\.json");
+ private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH-mm");
+
+ /**
+ * Reads a JSON file from an S3 bucket, injects a "runid" field at the top level of the JSON,
+ * and returns the modified JSON as a pretty-printed string.
+ *
+ * This method performs the following steps:
+ *
If any exception occurs during the process (e.g., while parsing the JSON or injecting the "runid"),
+ * a RuntimeException is thrown with an appropriate message.
+ *
+ * @param language the language code used to determine the latest file key in the S3 bucket
+ * @return a pretty-printed JSON string with the "runid" field injected at the top level
+ * @throws RuntimeException if an error occurs while reading from S3, parsing the JSON, or injecting the "runid"
+ */
+ public String readJsonFromS3(String language) {
+ String bucketName = "weathertop2";
+ Region region = Region.US_EAST_1;
+ S3Client s3 = S3Client.builder()
+ .region(region)
+ .build();
+
+ String latestFileKey = getLatestFileKey(s3, bucketName, language);
+ System.out.println("📄 Latest file: " + latestFileKey);
+
+ // Extract just the filename without .json
+ String runId = latestFileKey.replace(".json", "");
+ GetObjectRequest getRequest = GetObjectRequest.builder()
+ .bucket(bucketName)
+ .key(latestFileKey)
+ .build();
+
+ ResponseBytes objectBytes = s3.getObjectAsBytes(getRequest);
+ String originalJson = objectBytes.asString(StandardCharsets.UTF_8);
+
+ // Inject runid at top-level (not inside results)
+ try {
+ ObjectMapper mapper = new ObjectMapper();
+ JsonNode rootNode = mapper.readTree(originalJson);
+
+ if (rootNode.isObject()) {
+ ((ObjectNode) rootNode).put("runid", runId);
+ }
+
+ return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to parse or inject runid into JSON", e);
+ }
+ }
+
+ /**
+ * Retrieves the key of the latest file in the specified S3 bucket that matches the given language prefix.
+ *
+ * This method constructs a regex pattern to match filenames that follow the format:
+ * "-YYYY-MM-DDTHH-MM.json". It then lists all objects in the specified S3 bucket
+ * with the given prefix, filters them to match the regex pattern, sorts them by the timestamp
+ * extracted from the filenames in descending order, and returns the key of the first (latest) file.
+ *
+ * @param s3Client the S3Client used to interact with Amazon S3
+ * @param bucketName the name of the S3 bucket to search in
+ * @param languagePrefix the prefix of the filenames to match (e.g., "kotlin")
+ * @return the key of the latest file that matches the pattern
+ * @throws RuntimeException if no matching files are found for the given prefix
+ */
+ public static String getLatestFileKey(S3Client s3Client, String bucketName, String languagePrefix) {
+ Pattern filePattern = Pattern.compile(languagePrefix + "-(\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2})\\.json");
+ ListObjectsV2Request request = ListObjectsV2Request.builder()
+ .bucket(bucketName)
+ .prefix(languagePrefix + "-")
+ .build();
+
+ ListObjectsV2Response response = s3Client.listObjectsV2(request);
+ List objects = response.contents();
+
+ return objects.stream()
+ .map(S3Object::key)
+ .filter(key -> filePattern.matcher(key).matches())
+ .sorted(Comparator.comparing((String key) -> extractTimestamp(key, filePattern)).reversed())
+ .findFirst()
+ .orElseThrow(() -> new RuntimeException("No matching files found for prefix: " + languagePrefix));
+ }
+
+ private static LocalDateTime extractTimestamp(String key, Pattern pattern) {
+ Matcher matcher = pattern.matcher(key);
+ if (matcher.find()) {
+ return LocalDateTime.parse(matcher.group(1), FORMATTER);
+ } else {
+ throw new RuntimeException("Invalid file format: " + key);
+ }
+ }
+}
diff --git a/.tools/weathertop/backend/src/main/java/com/weathertop/service/SDKStats.java b/.tools/weathertop/backend/src/main/java/com/weathertop/service/SDKStats.java
new file mode 100644
index 00000000000..28a59283463
--- /dev/null
+++ b/.tools/weathertop/backend/src/main/java/com/weathertop/service/SDKStats.java
@@ -0,0 +1,226 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.weathertop.service;
+
+import software.amazon.awssdk.core.ResponseBytes;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.*;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.regex.*;
+
+public class SDKStats {
+
+ private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH-mm");
+
+ /**
+ * Retrieves the latest test result summaries for a set of SDK languages from an S3 bucket.
+ *
+ * For each language in the provided array:
+ *
+ * - Finds the most recent JSON test result file in the S3 bucket based on a timestamped filename pattern (e.g., {@code java-2025-07-10T12-15.json}).
+ * - Parses the file to extract total tests and passed tests.
+ * - Calculates the pass rate as {@code (passed / tests) * 100} and rounds to two decimal places.
+ * - Builds a JSON response summarizing the test statistics for each language.
+ *
+ *
+ * The final returned JSON has the structure:
+ *
+ * {
+ * "summary": [
+ * {
+ * "language": "java",
+ * "tests": 429,
+ * "passRate": 98.37
+ * },
+ * {
+ * "language": "kotlin",
+ * "tests": 287,
+ * "passRate": 97.56
+ * }
+ * ...
+ * ]
+ * }
+ *
+ *
+ * @param languages An array of SDK language prefixes (e.g., {@code ["java", "kotlin", "php"]}) used to locate result files in S3.
+ * @return A JSON string containing test result summaries for each language, including total tests and calculated pass rate.
+ * @throws JsonProcessingException If parsing or generating JSON fails.
+ */
+ public String getCoverageSummary(String[] languages) throws JsonProcessingException {
+ Region region = Region.US_EAST_1;
+ S3Client s3Client = S3Client.builder().region(region).build();
+ String bucketName = "weathertop2";
+ ObjectMapper mapper = new ObjectMapper();
+
+ List> summaryList = new ArrayList<>();
+
+ for (String lang : languages) {
+ String prefix = lang + "-";
+ Pattern timestampPattern = Pattern.compile(lang + "-(\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2})\\.json");
+
+ String latestKey = getLatestJsonKey(s3Client, bucketName, prefix, timestampPattern);
+ if (latestKey == null) {
+ System.out.println(" No file found for language: " + lang);
+ continue;
+ }
+
+ // Download and parse.
+ GetObjectRequest getObjectRequest = GetObjectRequest.builder()
+ .bucket(bucketName)
+ .key(latestKey)
+ .build();
+
+ ResponseBytes objectBytes = s3Client.getObjectAsBytes(getObjectRequest);
+ String jsonContent = objectBytes.asString(StandardCharsets.UTF_8);
+
+ JsonNode root = mapper.readTree(jsonContent);
+ JsonNode summary = root.path("results").path("summary");
+
+ int tests = summary.path("tests").asInt();
+ int passed = summary.path("passed").asInt();
+ int failed = summary.path("failed").asInt();
+
+ if (tests == 0) continue; // Avoid divide by zero
+
+ double passRate = ((double) passed / tests) * 100;
+
+ Map langStats = new HashMap<>();
+ langStats.put("language", lang);
+ langStats.put("tests", tests);
+ langStats.put("passed", passed); // ✅ use actual passed count
+ langStats.put("failed", failed); // ✅ add failed count
+ langStats.put("passRate", Math.round(passRate * 100.0) / 100.0); // round to 2 decimals
+ summaryList.add(langStats);
+ }
+
+ Map finalResult = new HashMap<>();
+ finalResult.put("summary", summaryList);
+ return mapper.writeValueAsString(finalResult);
+ }
+
+ /**
+ * Retrieves the key of the most recent timestamped JSON file in the specified S3 bucket.
+ *
+ * This method lists objects in the given S3 bucket that match the specified prefix and timestamp pattern
+ * (e.g., {@code java-2025-07-10T12-15.json}). It filters the list using the provided regex {@link Pattern},
+ * extracts the timestamp from each matching key, and returns the one with the latest (most recent) timestamp.
+ *
+ * @param s3Client The {@link S3Client} used to interact with Amazon S3.
+ * @param bucket The name of the S3 bucket containing the result files.
+ * @param prefix The prefix used to filter the keys (e.g., {@code "java-"}).
+ * @param pattern The regular expression {@link Pattern} to match and extract the timestamp from object keys.
+ * @return The key of the most recent matching JSON file, or {@code null} if no valid file is found.
+ */
+ private String getLatestJsonKey(S3Client s3Client, String bucket, String prefix, Pattern pattern) {
+ ListObjectsV2Request request = ListObjectsV2Request.builder()
+ .bucket(bucket)
+ .prefix(prefix)
+ .build();
+
+ ListObjectsV2Response response = s3Client.listObjectsV2(request);
+ return response.contents().stream()
+ .map(S3Object::key)
+ .filter(key -> pattern.matcher(key).matches())
+ .max(Comparator.comparing(key -> extractTimestamp(key, pattern)))
+ .orElse(null);
+ }
+
+ /**
+ * Extracts a {@link LocalDateTime} timestamp from an S3 object key using the provided regex pattern.
+ *
+ * The key must match the format defined by the pattern, typically something like:
+ * {@code language-yyyy-MM-ddTHH-mm.json} (e.g., {@code java-2025-07-10T12-15.json}).
+ * The method captures the timestamp portion, parses it using the predefined formatter, and returns it
+ * as a {@code LocalDateTime} object.
+ *
+ * @param key The S3 object key string (e.g., {@code java-2025-07-10T12-15.json}).
+ * @param pattern A {@link Pattern} containing a capturing group that extracts the timestamp portion of the key.
+ * @return The extracted {@link LocalDateTime} from the key.
+ * @throws RuntimeException if the key does not match the expected pattern.
+ */
+ private LocalDateTime extractTimestamp(String key, Pattern pattern) {
+ Matcher matcher = pattern.matcher(key);
+ if (matcher.matches()) {
+ return LocalDateTime.parse(matcher.group(1), FORMATTER);
+ }
+ throw new RuntimeException("Invalid timestamp format in key: " + key);
+ }
+
+ /**
+ * Retrieves a list of services that have no tests for each specified SDK language.
+ *
+ * This method scans the S3 bucket for the latest JSON test result file for each language
+ * (based on timestamped filenames like {@code java-2025-07-10T12-15.json}). It reads
+ * the {@code no_tests} section of each JSON and returns a JSON string that maps each
+ * SDK language to the list of services with no tests.
+ *
+ *
+ * Example output:
+ *
+ * {
+ * "dotnet": ["bedrock-runtime", "cognito"],
+ * "java": ["s3", "lambda"],
+ * "javascript": []
+ * }
+ *
+ *
+ * If no JSON file is found for a given language, the method will return an empty array
+ * for that language.
+ *
+ * @param languages An array of SDK language prefixes (e.g., {@code ["java", "dotnet", "javascript"]})
+ * used to locate the result files in S3.
+ * @return A JSON string mapping each SDK language to an array of service names that have no tests.
+ * @throws JsonProcessingException If there is an error parsing or generating JSON.
+ */
+ public String getNoTestsBySDK(String[] languages) throws JsonProcessingException {
+ Region region = Region.US_EAST_1;
+ S3Client s3Client = S3Client.builder().region(region).build();
+ String bucketName = "weathertop2";
+ ObjectMapper mapper = new ObjectMapper();
+
+ Map> sdkNoTestsMap = new HashMap<>();
+
+ for (String lang : languages) {
+ String prefix = lang + "-";
+ Pattern timestampPattern = Pattern.compile(lang + "-(\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2})\\.json");
+
+ String latestKey = getLatestJsonKey(s3Client, bucketName, prefix, timestampPattern);
+ if (latestKey == null) {
+ System.out.println("No file found for language: " + lang);
+ sdkNoTestsMap.put(lang, Collections.emptyList());
+ continue;
+ }
+
+ // Download and parse
+ GetObjectRequest getObjectRequest = GetObjectRequest.builder()
+ .bucket(bucketName)
+ .key(latestKey)
+ .build();
+
+ ResponseBytes objectBytes = s3Client.getObjectAsBytes(getObjectRequest);
+ String jsonContent = objectBytes.asString(StandardCharsets.UTF_8);
+
+ JsonNode root = mapper.readTree(jsonContent);
+ JsonNode noTestsNode = root.path("results").path("no_tests");
+
+ List noTestsList = new ArrayList<>();
+ if (noTestsNode.isArray()) {
+ for (JsonNode node : noTestsNode) {
+ noTestsList.add(node.asText());
+ }
+ }
+
+ sdkNoTestsMap.put(lang, noTestsList);
+ }
+
+ return mapper.writeValueAsString(sdkNoTestsMap);
+ }
+}
diff --git a/.tools/weathertop/backend/src/test/java/WeatheetopTest.java b/.tools/weathertop/backend/src/test/java/WeatheetopTest.java
new file mode 100644
index 00000000000..4d442ce76a7
--- /dev/null
+++ b/.tools/weathertop/backend/src/test/java/WeatheetopTest.java
@@ -0,0 +1,58 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import com.weathertop.service.GetLogMessages;
+import com.weathertop.service.HistoricalSDK;
+import com.weathertop.service.QueryLatestFromS3;
+import com.weathertop.service.SDKStats;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+@TestInstance(TestInstance.Lifecycle.PER_METHOD)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class WeatheetopTest {
+
+ @Test
+ @Order(1)
+ public void testStats() throws com.fasterxml.jackson.core.JsonProcessingException {
+ SDKStats langStats = new SDKStats();
+ String[] langs = {"java", "kotlin", "dotnetv4", "php", "javascriptv3", "python", "gov2", "rustv1"};
+ String JSON = assertDoesNotThrow(() -> langStats.getCoverageSummary(langs));
+ System.out.println(JSON);
+ }
+
+ @Test
+ @Order(2)
+ public void testGetLogs() throws com.fasterxml.jackson.core.JsonProcessingException {
+ GetLogMessages logs = new GetLogMessages();
+ String lang = "python";
+
+ // Ensure the method does not throw an exception
+ String json = assertDoesNotThrow(() -> logs.getHistoricalSummary(lang));
+
+ // Print the result
+ System.out.println(json);
+ }
+
+
+ @Test
+ @Order(3)
+ public void testS3Query() throws com.fasterxml.jackson.core.JsonProcessingException {
+ QueryLatestFromS3 wt = new QueryLatestFromS3();
+ String json = assertDoesNotThrow(() -> wt.readJsonFromS3("python"));
+ System.out.println(json);
+ }
+
+ @Test
+ @Order(4)
+ public void testGetHistoryData() throws com.fasterxml.jackson.core.JsonProcessingException {
+ HistoricalSDK history = new HistoricalSDK();
+ String json = assertDoesNotThrow(() -> history.getHistoricalSummary("java"));
+ System.out.println(json);
+ }
+}