Fix Java 8 compatibility: Replace Map.of() with HashMap

Replaced all java.util.Map.of() calls with HashMap initialization
to support Java 8 compilation. Map.of() was introduced in Java 9.

Fixed in:
- CoreTracer.java
- RemoteWriter.java
- PayloadDispatcherImpl.java

Author: robertomonteromiguel

dd-trace-core/src/main/java/datadog/trace/common/writer/PayloadDispatcherImpl.java

@@ -110,49 +110,37 @@ public void accept(int messageCount, ByteBuffer buffer) {
       healthMetrics.onSerialize(sizeInBytes);
 
       // Antithesis: Track all send attempts
-      Assert.sometimes(
-        true,
-        "trace_payloads_being_sent",
-        java.util.Map.of(
-          "trace_count", messageCount,
-          "payload_size_bytes", sizeInBytes,
-          "dropped_traces_in_payload", payload.droppedTraces(),
-          "dropped_spans_in_payload", payload.droppedSpans()
-        )
-      );
+      java.util.Map<String, Object> sendAttemptDetails = new java.util.HashMap<>();
+      sendAttemptDetails.put("trace_count", messageCount);
+      sendAttemptDetails.put("payload_size_bytes", sizeInBytes);
+      sendAttemptDetails.put("dropped_traces_in_payload", payload.droppedTraces());
+      sendAttemptDetails.put("dropped_spans_in_payload", payload.droppedSpans());
+      Assert.sometimes(true, "trace_payloads_being_sent", sendAttemptDetails);
 
       RemoteApi.Response response = api.sendSerializedTraces(payload);
       mapper.reset();
 
       if (response.success()) {
         // Antithesis: Track successful sends
-        Assert.sometimes(
-          true,
-          "traces_sent_successfully",
-          java.util.Map.of(
-            "decision", "sent_success",
-            "trace_count", messageCount,
-            "payload_size_bytes", sizeInBytes,
-            "http_status", response.status()
-          )
-        );
+        java.util.Map<String, Object> successDetails = new java.util.HashMap<>();
+        successDetails.put("decision", "sent_success");
+        successDetails.put("trace_count", messageCount);
+        successDetails.put("payload_size_bytes", sizeInBytes);
+        successDetails.put("http_status", response.status());
+        Assert.sometimes(true, "traces_sent_successfully", successDetails);
         if (log.isDebugEnabled()) {
           log.debug("Successfully sent {} traces to the API", messageCount);
         }
         healthMetrics.onSend(messageCount, sizeInBytes, response);
       } else {
         // Antithesis: Track failed sends
-        Assert.sometimes(
-          true,
-          "traces_failed_to_send",
-          java.util.Map.of(
-            "decision", "dropped_send_failed",
-            "trace_count", messageCount,
-            "payload_size_bytes", sizeInBytes,
-            "http_status", response.status(),
-            "has_exception", response.exception() != null
-          )
-        );
+        java.util.Map<String, Object> failedDetails = new java.util.HashMap<>();
+        failedDetails.put("decision", "dropped_send_failed");
+        failedDetails.put("trace_count", messageCount);
+        failedDetails.put("payload_size_bytes", sizeInBytes);
+        failedDetails.put("http_status", response.status());
+        failedDetails.put("has_exception", response.exception() != null);
+        Assert.sometimes(true, "traces_failed_to_send", failedDetails);
         if (log.isDebugEnabled()) {
           log.debug(
               "Failed to send {} traces of size {} bytes to the API", messageCount, sizeInBytes);

dd-trace-core/src/main/java/datadog/trace/common/writer/RemoteWriter.java

@@ -70,14 +70,10 @@ protected RemoteWriter(
   public void write(final List<DDSpan> trace) {
     if (closed) {
       // Antithesis: Track traces dropped during shutdown
-      Assert.sometimes(
-        true,
-        "trace_dropped_writer_closed",
-        java.util.Map.of(
-          "decision", "dropped_shutdown",
-          "span_count", trace.size()
-        )
-      );
+      java.util.Map<String, Object> shutdownDetails = new java.util.HashMap<>();
+      shutdownDetails.put("decision", "dropped_shutdown");
+      shutdownDetails.put("span_count", trace.size());
+      Assert.sometimes(true, "trace_dropped_writer_closed", shutdownDetails);
       // We can't add events after shutdown otherwise it will never complete shutting down.
       log.debug("Dropped due to shutdown: {}", trace);
       handleDroppedTrace(trace);
@@ -91,16 +87,12 @@ public void write(final List<DDSpan> trace) {
         switch (traceProcessingWorker.publish(root, samplingPriority, trace)) {
           case ENQUEUED_FOR_SERIALIZATION:
             // Antithesis: Track traces enqueued for sending
-            Assert.sometimes(
-              true,
-              "trace_enqueued_for_send",
-              java.util.Map.of(
-                "decision", "enqueued",
-                "trace_id", root.getTraceId().toString(),
-                "span_count", trace.size(),
-                "sampling_priority", samplingPriority
-              )
-            );
+            java.util.Map<String, Object> enqueuedDetails = new java.util.HashMap<>();
+            enqueuedDetails.put("decision", "enqueued");
+            enqueuedDetails.put("trace_id", root.getTraceId().toString());
+            enqueuedDetails.put("span_count", trace.size());
+            enqueuedDetails.put("sampling_priority", samplingPriority);
+            Assert.sometimes(true, "trace_enqueued_for_send", enqueuedDetails);
             log.debug("Enqueued for serialization: {}", trace);
             healthMetrics.onPublish(trace, samplingPriority);
             break;
@@ -109,31 +101,23 @@ public void write(final List<DDSpan> trace) {
             break;
           case DROPPED_BY_POLICY:
             // Antithesis: Track traces dropped by policy
-            Assert.sometimes(
-              true,
-              "trace_dropped_by_policy",
-              java.util.Map.of(
-                "decision", "dropped_policy",
-                "trace_id", root.getTraceId().toString(),
-                "span_count", trace.size(),
-                "sampling_priority", samplingPriority
-              )
-            );
+            java.util.Map<String, Object> policyDetails = new java.util.HashMap<>();
+            policyDetails.put("decision", "dropped_policy");
+            policyDetails.put("trace_id", root.getTraceId().toString());
+            policyDetails.put("span_count", trace.size());
+            policyDetails.put("sampling_priority", samplingPriority);
+            Assert.sometimes(true, "trace_dropped_by_policy", policyDetails);
             log.debug("Dropped by the policy: {}", trace);
             handleDroppedTrace(trace);
             break;
           case DROPPED_BUFFER_OVERFLOW:
             // Antithesis: Track traces dropped due to buffer overflow
-            Assert.sometimes(
-              true,
-              "trace_dropped_buffer_overflow",
-              java.util.Map.of(
-                "decision", "dropped_buffer_overflow",
-                "trace_id", root.getTraceId().toString(),
-                "span_count", trace.size(),
-                "sampling_priority", samplingPriority
-              )
-            );
+            java.util.Map<String, Object> overflowDetails = new java.util.HashMap<>();
+            overflowDetails.put("decision", "dropped_buffer_overflow");
+            overflowDetails.put("trace_id", root.getTraceId().toString());
+            overflowDetails.put("span_count", trace.size());
+            overflowDetails.put("sampling_priority", samplingPriority);
+            Assert.sometimes(true, "trace_dropped_buffer_overflow", overflowDetails);
             if (log.isDebugEnabled()) {
               log.debug("Dropped due to a buffer overflow: {}", trace);
             } else {

dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java

@@ -1249,29 +1249,21 @@ void write(final List<DDSpan> trace) {
     boolean published = forceKeep || traceCollector.sample(spanToSample);
     if (published) {
       // Antithesis: Track traces accepted by sampling
-      Assert.sometimes(
-        true,
-        "trace_accepted_by_sampling",
-        java.util.Map.of(
-          "decision", "accepted",
-          "trace_id", writtenTrace.get(0).getTraceId().toString(),
-          "span_count", writtenTrace.size(),
-          "sampling_priority", spanToSample.samplingPriority()
-        )
-      );
+      java.util.Map<String, Object> acceptedDetails = new java.util.HashMap<>();
+      acceptedDetails.put("decision", "accepted");
+      acceptedDetails.put("trace_id", writtenTrace.get(0).getTraceId().toString());
+      acceptedDetails.put("span_count", writtenTrace.size());
+      acceptedDetails.put("sampling_priority", spanToSample.samplingPriority());
+      Assert.sometimes(true, "trace_accepted_by_sampling", acceptedDetails);
       writer.write(writtenTrace);
     } else {
       // Antithesis: Track traces dropped by sampling
-      Assert.sometimes(
-        true,
-        "trace_dropped_by_sampling",
-        java.util.Map.of(
-          "decision", "dropped_sampling",
-          "trace_id", writtenTrace.get(0).getTraceId().toString(),
-          "span_count", writtenTrace.size(),
-          "sampling_priority", spanToSample.samplingPriority()
-        )
-      );
+      java.util.Map<String, Object> droppedDetails = new java.util.HashMap<>();
+      droppedDetails.put("decision", "dropped_sampling");
+      droppedDetails.put("trace_id", writtenTrace.get(0).getTraceId().toString());
+      droppedDetails.put("span_count", writtenTrace.size());
+      droppedDetails.put("sampling_priority", spanToSample.samplingPriority());
+      Assert.sometimes(true, "trace_dropped_by_sampling", droppedDetails);
       // with span streaming this won't work - it needs to be changed
       // to track an effective sampling rate instead, however, tests
       // checking that a hard reference on a continuation prevents