Reorganize classes

Author: sarahchen6

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

@@ -50,6 +50,8 @@
 import datadog.trace.api.naming.SpanNaming;
 import datadog.trace.api.remoteconfig.ServiceNameCollector;
 import datadog.trace.api.rum.RumInjector;
+import datadog.trace.api.rum.RumInjectorMetrics;
+import datadog.trace.api.rum.RumTelemetryCollector;
 import datadog.trace.api.sampling.PrioritySampling;
 import datadog.trace.api.scopemanager.ScopeListener;
 import datadog.trace.api.time.SystemTimeSource;
@@ -84,10 +86,8 @@
 import datadog.trace.core.datastreams.DefaultDataStreamsMonitoring;
 import datadog.trace.core.flare.TracerFlarePoller;
 import datadog.trace.core.histogram.Histograms;
-import datadog.trace.core.monitor.DefaultRumInjectorHealthMetrics;
 import datadog.trace.core.monitor.HealthMetrics;
 import datadog.trace.core.monitor.MonitoringImpl;
-import datadog.trace.core.monitor.RumInjectorHealthMetrics;
 import datadog.trace.core.monitor.TracerHealthMetrics;
 import datadog.trace.core.propagation.ExtractedContext;
 import datadog.trace.core.propagation.HttpCodec;
@@ -207,7 +207,7 @@ public static CoreTracerBuilder builder() {
   private final Monitoring performanceMonitoring;
 
   private final HealthMetrics healthMetrics;
-  private final RumInjectorHealthMetrics rumInjectorHealthMetrics;
+  private final RumTelemetryCollector rumInjectorHealthMetrics;
   private final Recording traceWriteTimer;
   private final IdGenerationStrategy idGenerationStrategy;
   private final TraceCollector.Factory traceCollectorFactory;
@@ -707,14 +707,14 @@ private CoreTracer(
             : HealthMetrics.NO_OP;
     healthMetrics.start();
 
-    // Start RUM injector health metrics
+    // Start RUM injector metrics
     rumInjectorHealthMetrics =
         config.isHealthMetricsEnabled() && config.isRumEnabled()
-            ? new DefaultRumInjectorHealthMetrics(this.statsDClient)
-            : RumInjectorHealthMetrics.NO_OP;
+            ? new RumInjectorMetrics(this.statsDClient)
+            : RumTelemetryCollector.NO_OP;
     rumInjectorHealthMetrics.start();
     // Register rumInjectorHealthMetrics as the RumInjector's telemetry collector
-    RumInjector.setTelemetryCollector((DefaultRumInjectorHealthMetrics) rumInjectorHealthMetrics);
+    RumInjector.setTelemetryCollector(rumInjectorHealthMetrics);
 
     performanceMonitoring =
         config.isPerfMetricsEnabled()

dd-trace-core/src/main/java/datadog/trace/core/monitor/RumInjectorHealthMetrics.java

@@ -1,41 +1,34 @@
-package datadog.trace.core.monitor;
+package datadog.trace.api.rum;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
 
 import datadog.trace.api.StatsDClient;
-import datadog.trace.api.rum.RumTelemetryCollector;
 import datadog.trace.util.AgentTaskScheduler;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
-import org.jctools.counters.CountersFactory;
-import org.jctools.counters.FixedSizeStripedLongCounter;
+import java.util.concurrent.atomic.AtomicLong;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 // Default implementation of RumInjectorHealthMetrics that reports metrics via StatsDClient
 // This class implements the RumTelemetryCollector interface, which is used to collect telemetry
 // from the RumInjector in the internal-api module
-public class DefaultRumInjectorHealthMetrics extends RumInjectorHealthMetrics
-    implements RumTelemetryCollector {
-  private static final Logger log = LoggerFactory.getLogger(DefaultRumInjectorHealthMetrics.class);
+public class RumInjectorMetrics implements RumTelemetryCollector {
+  private static final Logger log = LoggerFactory.getLogger(RumInjectorMetrics.class);
 
   private static final String[] NO_TAGS = new String[0];
 
   private final AtomicBoolean started = new AtomicBoolean(false);
-  private volatile AgentTaskScheduler.Scheduled<DefaultRumInjectorHealthMetrics> cancellation;
+  private volatile AgentTaskScheduler.Scheduled<RumInjectorMetrics> cancellation;
 
-  private final FixedSizeStripedLongCounter injectionSucceed =
-      CountersFactory.createFixedSizeStripedCounter(8);
-  private final FixedSizeStripedLongCounter injectionFailed =
-      CountersFactory.createFixedSizeStripedCounter(8);
-  private final FixedSizeStripedLongCounter injectionSkipped =
-      CountersFactory.createFixedSizeStripedCounter(8);
+  private final AtomicLong injectionSucceed = new AtomicLong();
+  private final AtomicLong injectionFailed = new AtomicLong();
+  private final AtomicLong injectionSkipped = new AtomicLong();
 
   private final StatsDClient statsd;
   private final long interval;
   private final TimeUnit units;
 
-  @Override
   public void start() {
     if (started.compareAndSet(false, true)) {
       cancellation =
@@ -44,39 +37,37 @@ public void start() {
     }
   }
 
-  public DefaultRumInjectorHealthMetrics(final StatsDClient statsd) {
+  public RumInjectorMetrics(final StatsDClient statsd) {
     this(statsd, 30, SECONDS);
   }
 
-  public DefaultRumInjectorHealthMetrics(final StatsDClient statsd, long interval, TimeUnit units) {
+  public RumInjectorMetrics(final StatsDClient statsd, long interval, TimeUnit units) {
     this.statsd = statsd;
     this.interval = interval;
     this.units = units;
   }
 
   @Override
   public void onInjectionSucceed() {
-    injectionSucceed.inc();
+    injectionSucceed.incrementAndGet();
   }
 
   @Override
   public void onInjectionFailed() {
-    injectionFailed.inc();
+    injectionFailed.incrementAndGet();
   }
 
   @Override
   public void onInjectionSkipped() {
-    injectionSkipped.inc();
+    injectionSkipped.incrementAndGet();
   }
 
-  @Override
   public void close() {
     if (null != cancellation) {
       cancellation.cancel();
     }
   }
 
-  @Override
   public String summary() {
     return "injectionSucceed="
         + injectionSucceed.get()
@@ -86,13 +77,13 @@ public String summary() {
         + injectionSkipped.get();
   }
 
-  private static class Flush implements AgentTaskScheduler.Task<DefaultRumInjectorHealthMetrics> {
+  private static class Flush implements AgentTaskScheduler.Task<RumInjectorMetrics> {
 
     private final long[] previousCounts = new long[3]; // one per counter
     private int countIndex;
 
     @Override
-    public void run(DefaultRumInjectorHealthMetrics target) {
+    public void run(RumInjectorMetrics target) {
       countIndex = -1;
       try {
         reportIfChanged(target.statsd, "rum.injection.succeed", target.injectionSucceed, NO_TAGS);
@@ -107,10 +98,7 @@ public void run(DefaultRumInjectorHealthMetrics target) {
     }
 
     private void reportIfChanged(
-        StatsDClient statsDClient,
-        String aspect,
-        FixedSizeStripedLongCounter counter,
-        String[] tags) {
+        StatsDClient statsDClient, String aspect, AtomicLong counter, String[] tags) {
       long count = counter.get();
       long delta = count - previousCounts[++countIndex];
       if (delta > 0) {

dd-trace-core/src/main/java/datadog/trace/core/monitor/DefaultRumInjectorHealthMetrics.java renamed to internal-api/src/main/java/datadog/trace/api/rum/RumInjectorMetrics.java

@@ -1,4 +1,4 @@
-package datadog.trace.core.monitor
+package datadog.trace.api.rum
 
 import datadog.trace.api.StatsDClient
 import spock.lang.Specification
@@ -7,16 +7,16 @@ import spock.lang.Subject
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
-class RumInjectorHealthMetricsTest extends Specification {
+class RumInjectorMetricsTest extends Specification {
   def statsD = Mock(StatsDClient)
 
   @Subject
-  def healthMetrics = new DefaultRumInjectorHealthMetrics(statsD)
+  def healthMetrics = new RumInjectorMetrics(statsD)
 
   def "test onInjectionSucceed"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new DefaultRumInjectorHealthMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
     healthMetrics.start()
 
     when:
@@ -34,7 +34,7 @@ class RumInjectorHealthMetricsTest extends Specification {
   def "test onInjectionFailed"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new DefaultRumInjectorHealthMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
     healthMetrics.start()
 
     when:
@@ -52,7 +52,7 @@ class RumInjectorHealthMetricsTest extends Specification {
   def "test onInjectionSkipped"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new DefaultRumInjectorHealthMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
     healthMetrics.start()
 
     when:
@@ -70,7 +70,7 @@ class RumInjectorHealthMetricsTest extends Specification {
   def "test multiple events"() {
     setup:
     def latch = new CountDownLatch(3) // expecting 3 metric types
-    def healthMetrics = new DefaultRumInjectorHealthMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
     healthMetrics.start()
 
     when: