Implement attempt to fix tests

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/config/CiVisibilitySettings.java

@@ -142,9 +142,9 @@ public CiVisibilitySettings fromJson(Map<String, Object> json) {
           getBoolean(json, "flaky_test_retries_enabled", false),
           getBoolean(json, "impacted_tests_enabled", false),
           getBoolean(json, "known_tests_enabled", false),
-          EarlyFlakeDetectionSettingsJsonAdapter.INSTANCE.fromJson(
+          EarlyFlakeDetectionSettings.JsonAdapter.INSTANCE.fromJson(
               (Map<String, Object>) json.get("early_flake_detection")),
-          TestManagementSettingsJsonAdapter.INSTANCE.fromJson(
+          TestManagementSettings.JsonAdapter.INSTANCE.fromJson(
               (Map<String, Object>) json.get("test_management")));
     }
 

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/config/ConfigurationApiImpl.java

@@ -84,7 +84,7 @@ public ConfigurationApiImpl(BackendApi backendApi, CiVisibilityMetricCollector m
         new Moshi.Builder()
             .add(ConfigurationsJsonAdapter.INSTANCE)
             .add(CiVisibilitySettings.JsonAdapter.INSTANCE)
-            .add(EarlyFlakeDetectionSettingsJsonAdapter.INSTANCE)
+            .add(EarlyFlakeDetectionSettings.JsonAdapter.INSTANCE)
             .add(MetaDtoJsonAdapter.INSTANCE)
             .build();
 

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/config/EarlyFlakeDetectionSettings.java

@@ -1,8 +1,14 @@
 package datadog.trace.civisibility.config;
 
+import com.squareup.moshi.FromJson;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.TimeUnit;
 
 public class EarlyFlakeDetectionSettings {
 
@@ -34,15 +40,6 @@ public List<ExecutionsByDuration> getExecutionsByDuration() {
     return executionsByDuration;
   }
 
-  public int getExecutions(long durationMillis) {
-    for (ExecutionsByDuration e : executionsByDuration) {
-      if (durationMillis <= e.durationMillis) {
-        return e.executions;
-      }
-    }
-    return 0;
-  }
-
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -62,38 +59,84 @@ public int hashCode() {
     return Objects.hash(enabled, executionsByDuration, faultySessionThreshold);
   }
 
-  public static final class ExecutionsByDuration {
-    public final long durationMillis;
-    public final int executions;
-
-    public ExecutionsByDuration(long durationMillis, int executions) {
-      this.durationMillis = durationMillis;
-      this.executions = executions;
+  public static final class Serializer {
+    public static void serialize(
+        datadog.trace.civisibility.ipc.serialization.Serializer serializer,
+        EarlyFlakeDetectionSettings settings) {
+      if (!settings.enabled) {
+        serializer.write((byte) 0);
+        return;
+      }
+      serializer.write((byte) 1);
+      serializer.write(settings.faultySessionThreshold);
+      serializer.write(settings.executionsByDuration, ExecutionsByDuration.Serializer::serialize);
     }
 
-    public long getDurationMillis() {
-      return durationMillis;
-    }
+    public static EarlyFlakeDetectionSettings deserialize(ByteBuffer buf) {
+      boolean enabled = datadog.trace.civisibility.ipc.serialization.Serializer.readByte(buf) != 0;
+      if (!enabled) {
+        return EarlyFlakeDetectionSettings.DEFAULT;
+      }
 
-    public int getExecutions() {
-      return executions;
+      int faultySessionThreshold =
+          datadog.trace.civisibility.ipc.serialization.Serializer.readInt(buf);
+      List<ExecutionsByDuration> executionsByDuration =
+          datadog.trace.civisibility.ipc.serialization.Serializer.readList(
+              buf, ExecutionsByDuration.Serializer::deserialize);
+      return new EarlyFlakeDetectionSettings(enabled, executionsByDuration, faultySessionThreshold);
     }
+  }
+
+  public static final class JsonAdapter {
+    public static final JsonAdapter INSTANCE = new JsonAdapter();
 
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
+    @FromJson
+    public EarlyFlakeDetectionSettings fromJson(Map<String, Object> json) {
+      if (json == null) {
+        return EarlyFlakeDetectionSettings.DEFAULT;
       }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
+
+      Boolean enabled = (Boolean) json.get("enabled");
+      Double faultySessionThreshold = (Double) json.get("faulty_session_threshold");
+
+      List<ExecutionsByDuration> executionsByDuration;
+      Map<String, Double> slowTestRetries = (Map<String, Double>) json.get("slow_test_retries");
+      if (slowTestRetries != null) {
+        executionsByDuration = new ArrayList<>(slowTestRetries.size());
+        for (Map.Entry<String, Double> e : slowTestRetries.entrySet()) {
+          long durationMillis = parseDuration(e.getKey());
+          int retries = e.getValue().intValue();
+          executionsByDuration.add(new ExecutionsByDuration(durationMillis, retries));
+        }
+        executionsByDuration.sort(Comparator.comparingLong(r -> r.durationMillis));
+      } else {
+        executionsByDuration = Collections.emptyList();
       }
-      ExecutionsByDuration that = (ExecutionsByDuration) o;
-      return durationMillis == that.durationMillis && executions == that.executions;
+
+      return new EarlyFlakeDetectionSettings(
+          enabled != null ? enabled : false,
+          executionsByDuration,
+          faultySessionThreshold != null ? faultySessionThreshold.intValue() : -1);
     }
 
-    @Override
-    public int hashCode() {
-      return Objects.hash(durationMillis, executions);
+    private static long parseDuration(String duration) {
+      char lastCharacter = duration.charAt(duration.length() - 1);
+      int numericValue = Integer.parseInt(duration.substring(0, duration.length() - 1));
+      TimeUnit timeUnit;
+      switch (lastCharacter) {
+        case 's':
+          timeUnit = TimeUnit.SECONDS;
+          break;
+        case 'm':
+          timeUnit = TimeUnit.MINUTES;
+          break;
+        case 'h':
+          timeUnit = TimeUnit.HOURS;
+          break;
+        default:
+          throw new IllegalArgumentException("Unexpected duration unit: " + lastCharacter);
+      }
+      return timeUnit.toMillis(numericValue);
     }
   }
 }

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/config/ExecutionSettings.java

@@ -5,7 +5,6 @@
 import datadog.trace.api.civisibility.config.TestMetadata;
 import datadog.trace.civisibility.diff.Diff;
 import datadog.trace.civisibility.diff.LineDiff;
-import datadog.trace.civisibility.ipc.serialization.Serializer;
 import java.nio.ByteBuffer;
 import java.util.BitSet;
 import java.util.Collection;
@@ -272,7 +271,7 @@ public int hashCode() {
         pullRequestDiff);
   }
 
-  public static class ExecutionSettingsSerializer {
+  public static class Serializer {
 
     private static final int ITR_ENABLED_FLAG = 1;
     private static final int CODE_COVERAGE_ENABLED_FLAG = 2;
@@ -281,7 +280,8 @@ public static class ExecutionSettingsSerializer {
     private static final int IMPACTED_TESTS_DETECTION_ENABLED_FLAG = 16;
 
     public static ByteBuffer serialize(ExecutionSettings settings) {
-      Serializer s = new Serializer();
+      datadog.trace.civisibility.ipc.serialization.Serializer s =
+          new datadog.trace.civisibility.ipc.serialization.Serializer();
 
       byte flags =
           (byte)
@@ -294,59 +294,75 @@ public static ByteBuffer serialize(ExecutionSettings settings) {
                       : 0));
       s.write(flags);
 
-      EarlyFlakeDetectionSettingsSerializer.serialize(s, settings.earlyFlakeDetectionSettings);
+      EarlyFlakeDetectionSettings.Serializer.serialize(s, settings.earlyFlakeDetectionSettings);
 
-      TestManagementSettingsSerializer.serialize(s, settings.testManagementSettings);
+      TestManagementSettings.Serializer.serialize(s, settings.testManagementSettings);
 
       s.write(settings.itrCorrelationId);
       s.write(
           settings.skippableTests,
           TestIdentifierSerializer::serialize,
           TestMetadataSerializer::serialize);
 
-      s.write(settings.skippableTestsCoverage, Serializer::write, Serializer::write);
+      s.write(
+          settings.skippableTestsCoverage,
+          datadog.trace.civisibility.ipc.serialization.Serializer::write,
+          datadog.trace.civisibility.ipc.serialization.Serializer::write);
 
-      s.write(settings.testSettings, TestFQNSerializer::serialize, Serializer::write);
       s.write(
-          settings.settingsCount, TestSetting.TestSettingsSerializer::serialize, Serializer::write);
+          settings.testSettings,
+          TestFQNSerializer::serialize,
+          datadog.trace.civisibility.ipc.serialization.Serializer::write);
+      s.write(
+          settings.settingsCount,
+          TestSetting.Serializer::serialize,
+          datadog.trace.civisibility.ipc.serialization.Serializer::write);
 
       Diff.SERIALIZER.serialize(settings.pullRequestDiff, s);
 
       return s.flush();
     }
 
     public static ExecutionSettings deserialize(ByteBuffer buffer) {
-      byte flags = Serializer.readByte(buffer);
+      byte flags = datadog.trace.civisibility.ipc.serialization.Serializer.readByte(buffer);
       boolean itrEnabled = (flags & ITR_ENABLED_FLAG) != 0;
       boolean codeCoverageEnabled = (flags & CODE_COVERAGE_ENABLED_FLAG) != 0;
       boolean testSkippingEnabled = (flags & TEST_SKIPPING_ENABLED_FLAG) != 0;
       boolean flakyTestRetriesEnabled = (flags & FLAKY_TEST_RETRIES_ENABLED_FLAG) != 0;
       boolean impactedTestsDetectionEnabled = (flags & IMPACTED_TESTS_DETECTION_ENABLED_FLAG) != 0;
 
       EarlyFlakeDetectionSettings earlyFlakeDetectionSettings =
-          EarlyFlakeDetectionSettingsSerializer.deserialize(buffer);
+          EarlyFlakeDetectionSettings.Serializer.deserialize(buffer);
 
       TestManagementSettings testManagementSettings =
-          TestManagementSettingsSerializer.deserialize(buffer);
+          TestManagementSettings.Serializer.deserialize(buffer);
 
-      String itrCorrelationId = Serializer.readString(buffer);
+      String itrCorrelationId =
+          datadog.trace.civisibility.ipc.serialization.Serializer.readString(buffer);
 
       Map<TestIdentifier, TestMetadata> skippableTests =
-          Serializer.readMap(
+          datadog.trace.civisibility.ipc.serialization.Serializer.readMap(
               buffer, TestIdentifierSerializer::deserialize, TestMetadataSerializer::deserialize);
 
       Map<String, BitSet> skippableTestsCoverage =
-          Serializer.readMap(buffer, Serializer::readString, Serializer::readBitSet);
+          datadog.trace.civisibility.ipc.serialization.Serializer.readMap(
+              buffer,
+              datadog.trace.civisibility.ipc.serialization.Serializer::readString,
+              datadog.trace.civisibility.ipc.serialization.Serializer::readBitSet);
 
       Map<TestFQN, Integer> testSettings =
-          Serializer.readMap(buffer, TestFQNSerializer::deserialize, Serializer::readInt);
+          datadog.trace.civisibility.ipc.serialization.Serializer.readMap(
+              buffer,
+              TestFQNSerializer::deserialize,
+              datadog.trace.civisibility.ipc.serialization.Serializer::readInt);
+
       EnumMap<TestSetting, Integer> settingsCount =
           (EnumMap<TestSetting, Integer>)
-              Serializer.readMap(
+              datadog.trace.civisibility.ipc.serialization.Serializer.readMap(
                   buffer,
                   () -> new EnumMap<>(TestSetting.class),
-                  TestSetting.TestSettingsSerializer::deserialize,
-                  Serializer::readInt);
+                  TestSetting.Serializer::deserialize,
+                  datadog.trace.civisibility.ipc.serialization.Serializer::readInt);
 
       Diff diff = Diff.SERIALIZER.deserialize(buffer);