Add tests

Author: sarahchen6

internal-api/src/test/groovy/datadog/trace/api/rum/RumInjectorMetricsTest.groovy

@@ -11,72 +11,72 @@ class RumInjectorMetricsTest extends Specification {
   def statsD = Mock(StatsDClient)
 
   @Subject
-  def healthMetrics = new RumInjectorMetrics(statsD)
+  def metrics = new RumInjectorMetrics(statsD)
 
   def "test onInjectionSucceed"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
-    healthMetrics.start()
+    def metrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    metrics.start()
 
     when:
-    healthMetrics.onInjectionSucceed()
+    metrics.onInjectionSucceed()
     latch.await(5, TimeUnit.SECONDS)
 
     then:
     1 * statsD.count('rum.injection.succeed', 1, _)
     0 * _
 
     cleanup:
-    healthMetrics.close()
+    metrics.close()
   }
 
   def "test onInjectionFailed"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
-    healthMetrics.start()
+    def metrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    metrics.start()
 
     when:
-    healthMetrics.onInjectionFailed()
+    metrics.onInjectionFailed()
     latch.await(5, TimeUnit.SECONDS)
 
     then:
     1 * statsD.count('rum.injection.failed', 1, _)
     0 * _
 
     cleanup:
-    healthMetrics.close()
+    metrics.close()
   }
 
   def "test onInjectionSkipped"() {
     setup:
     def latch = new CountDownLatch(1)
-    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
-    healthMetrics.start()
+    def metrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    metrics.start()
 
     when:
-    healthMetrics.onInjectionSkipped()
+    metrics.onInjectionSkipped()
     latch.await(5, TimeUnit.SECONDS)
 
     then:
     1 * statsD.count('rum.injection.skipped', 1, _)
     0 * _
 
     cleanup:
-    healthMetrics.close()
+    metrics.close()
   }
 
-  def "test multiple events"() {
+  def "test flushing multiple events"() {
     setup:
     def latch = new CountDownLatch(3) // expecting 3 metric types
-    def healthMetrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
-    healthMetrics.start()
+    def metrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    metrics.start()
 
     when:
-    healthMetrics.onInjectionSucceed()
-    healthMetrics.onInjectionFailed()
-    healthMetrics.onInjectionSkipped()
+    metrics.onInjectionSucceed()
+    metrics.onInjectionFailed()
+    metrics.onInjectionSkipped()
     latch.await(5, TimeUnit.SECONDS)
 
     then:
@@ -86,23 +86,59 @@ class RumInjectorMetricsTest extends Specification {
     0 * _
 
     cleanup:
-    healthMetrics.close()
+    metrics.close()
   }
 
-  def "test summary"() {
+  def "test that flushing only reports non-zero deltas"() {
+    setup:
+    def latch = new CountDownLatch(1) // expecting only 1 metric call (non-zero delta)
+    def metrics = new RumInjectorMetrics(new Latched(statsD, latch), 10, TimeUnit.MILLISECONDS)
+    metrics.start()
+
     when:
-    healthMetrics.onInjectionSucceed()
-    healthMetrics.onInjectionFailed()
-    healthMetrics.onInjectionSkipped()
-    def summary = healthMetrics.summary()
+    metrics.onInjectionSucceed()
+    metrics.onInjectionSucceed()
+    latch.await(5, TimeUnit.SECONDS)
 
     then:
-    summary.contains("injectionSucceed=1")
-    summary.contains("injectionFailed=1")
+    1 * statsD.count('rum.injection.succeed', 2, _)
+    // should not be called since they have delta of 0
+    0 * statsD.count('rum.injection.failed', _, _)
+    0 * statsD.count('rum.injection.skipped', _, _)
+    0 * _
+
+    cleanup:
+    metrics.close()
+  }
+
+  def "test summary with multiple events"() {
+    when:
+    metrics.onInjectionSucceed()
+    metrics.onInjectionFailed()
+    metrics.onInjectionSucceed()
+    metrics.onInjectionFailed()
+    metrics.onInjectionSucceed()
+    metrics.onInjectionSkipped()
+    def summary = metrics.summary()
+
+    then:
+    summary.contains("injectionSucceed=3")
+    summary.contains("injectionFailed=2")
     summary.contains("injectionSkipped=1")
     0 * _
   }
 
+  def "test metrics start at zero"() {
+    when:
+    def summary = metrics.summary()
+
+    then:
+    summary.contains("injectionSucceed=0")
+    summary.contains("injectionFailed=0")
+    summary.contains("injectionSkipped=0")
+    0 * _
+  }
+
   // taken from HealthMetricsTest
   private static class Latched implements StatsDClient {
     final StatsDClient delegate

internal-api/src/test/groovy/datadog/trace/api/rum/RumInjectorTest.groovy

@@ -68,56 +68,110 @@ class RumInjectorTest extends DDSpecification {
 
   void 'set telemetry collector'() {
     setup:
-    def mockTelemetryCollector = mock(RumTelemetryCollector)
+    def telemetryCollector = mock(RumTelemetryCollector)
 
     when:
-    RumInjector.setTelemetryCollector(mockTelemetryCollector)
-    def telemetryCollector = RumInjector.getTelemetryCollector()
+    RumInjector.setTelemetryCollector(telemetryCollector)
 
     then:
-    telemetryCollector == mockTelemetryCollector
+    RumInjector.getTelemetryCollector() == telemetryCollector
+
+    cleanup:
+    RumInjector.setTelemetryCollector(RumTelemetryCollector.NO_OP)
   }
 
   void 'return NO_OP when telemetry collector is not set'() {
     when:
     RumInjector.setTelemetryCollector(null)
-    def telemetryCollector = RumInjector.getTelemetryCollector()
 
     then:
-    telemetryCollector == RumTelemetryCollector.NO_OP
+    RumInjector.getTelemetryCollector() == RumTelemetryCollector.NO_OP
+
+    cleanup:
+    RumInjector.setTelemetryCollector(RumTelemetryCollector.NO_OP)
   }
 
   void 'enable telemetry with StatsDClient'() {
-    setup:
-    def mockStatsDClient = mock(datadog.trace.api.StatsDClient)
-    RumInjector.enableTelemetry(mockStatsDClient)
-
     when:
-    def telemetryCollector = RumInjector.getTelemetryCollector()
+    RumInjector.enableTelemetry(mock(datadog.trace.api.StatsDClient))
 
     then:
-    telemetryCollector instanceof datadog.trace.api.rum.RumInjectorMetrics
+    RumInjector.getTelemetryCollector() instanceof datadog.trace.api.rum.RumInjectorMetrics
+
+    cleanup:
+    RumInjector.shutdownTelemetry()
   }
 
   void 'enabling telemetry with a null StatsDClient sets the telemetry collector to NO_OP'() {
     when:
     RumInjector.enableTelemetry(null)
-    def telemetryCollector = RumInjector.getTelemetryCollector()
 
     then:
-    telemetryCollector == RumTelemetryCollector.NO_OP
+    RumInjector.getTelemetryCollector() == RumTelemetryCollector.NO_OP
+
+    cleanup:
+    RumInjector.shutdownTelemetry()
   }
 
   void 'shutdown telemetry'() {
     setup:
-    def mockStatsDClient = mock(datadog.trace.api.StatsDClient)
-    RumInjector.enableTelemetry(mockStatsDClient)
+    RumInjector.enableTelemetry(mock(datadog.trace.api.StatsDClient))
 
     when:
     RumInjector.shutdownTelemetry()
+
+    then:
+    RumInjector.getTelemetryCollector() == RumTelemetryCollector.NO_OP
+  }
+
+  void 'telemetry integration works end-to-end'() {
+    when:
+    // simulate CoreTracer enabling telemetry
+    RumInjector.enableTelemetry(mock(datadog.trace.api.StatsDClient))
+
+    // simulate reporting successful injection
     def telemetryCollector = RumInjector.getTelemetryCollector()
+    telemetryCollector.onInjectionSucceed()
+    telemetryCollector.onInjectionSucceed()
+    telemetryCollector.onInjectionFailed()
+
+    // verify metrics are collected
+    def summary = telemetryCollector.summary()
 
     then:
-    telemetryCollector == RumTelemetryCollector.NO_OP
+    summary.contains("injectionSucceed=2")
+    summary.contains("injectionFailed=1")
+    summary.contains("injectionSkipped=0")
+
+    cleanup:
+    RumInjector.shutdownTelemetry()
+  }
+
+  void 'concurrent telemetry calls are thread-safe'() {
+    setup:
+    RumInjector.enableTelemetry(mock(datadog.trace.api.StatsDClient))
+    def telemetryCollector = RumInjector.getTelemetryCollector()
+    def threads = []
+
+    when:
+    // simulate multiple threads calling telemetry methods
+    (1..50).each { i ->
+      threads << Thread.start {
+        telemetryCollector.onInjectionSucceed()
+        telemetryCollector.onInjectionFailed()
+        telemetryCollector.onInjectionSkipped()
+      }
+    }
+    threads*.join()
+
+    def summary = telemetryCollector.summary()
+
+    then:
+    summary.contains("injectionSucceed=50")
+    summary.contains("injectionFailed=50")
+    summary.contains("injectionSkipped=50")
+
+    cleanup:
+    RumInjector.shutdownTelemetry()
   }
 }