refactor tests

Author: liustve

awsagentprovider/src/test/java/software/amazon/opentelemetry/javaagent/providers/exporter/aws/metrics/AwsCloudWatchEmfExporterTest.java

@@ -45,8 +45,6 @@ public class AwsCloudWatchEmfExporterTest extends BaseEmfExporterTest<CloudWatch
   private static final String LOG_STREAM_NAME = "test-stream";
   private static final String REGION = "us-east-1";
 
-  private AwsCloudWatchEmfExporter mockExporter;
-  private CloudWatchLogsClientEmitter testMockEmitter;
   private CloudWatchLogsClient mockClient;
   private CloudWatchLogsClientEmitter wrapper;
   private long currentTime;
@@ -55,12 +53,6 @@ public class AwsCloudWatchEmfExporterTest extends BaseEmfExporterTest<CloudWatch
   void setUp() {
     super.setup();
     this.currentTime = System.currentTimeMillis();
-    this.testMockEmitter = mock(CloudWatchLogsClientEmitter.class);
-    this.mockExporter =
-        AwsCloudWatchEmfExporter.builder()
-            .setNamespace(NAMESPACE)
-            .setEmitter(this.testMockEmitter)
-            .build();
     this.mockClient = mock(CloudWatchLogsClient.class);
     this.wrapper = spy(new CloudWatchLogsClientEmitter(LOG_GROUP_NAME, LOG_STREAM_NAME, REGION));
     doReturn(this.mockClient).when(this.wrapper).getEmitter();
@@ -72,17 +64,18 @@ protected LogEventEmitter<CloudWatchLogsClient> createEmitter() {
   }
 
   @Override
-  protected MetricExporter createExporter() {
+  protected MetricExporter buildExporter(boolean shouldAddAppSignals) {
     return AwsCloudWatchEmfExporter.builder()
         .setNamespace(NAMESPACE)
         .setEmitter(this.mockEmitter)
+        .setShouldAddApplicationSignalsDimensions(shouldAddAppSignals)
         .build();
   }
 
   @Test
   void testShutdown() {
-    AwsCloudWatchEmfExporter spyExporter = spy(this.mockExporter);
-    doNothing().when(this.testMockEmitter).flushEvents();
+    MetricExporter spyExporter = spy(buildExporter(false));
+    doNothing().when(this.mockEmitter).flushEvents();
 
     CompletableResultCode result = spyExporter.shutdown();
 
@@ -241,26 +234,26 @@ void testBatchInactiveAfter24Hours() {
     Map<String, Object> firstEvent = createLogEvent("test1", this.currentTime);
     Map<String, Object> secondEvent = createLogEvent("test2", futureTime);
 
-    this.testMockEmitter.emit(firstEvent);
-    this.testMockEmitter.emit(secondEvent);
+    this.mockEmitter.emit(firstEvent);
+    this.mockEmitter.emit(secondEvent);
 
     // Should trigger 2 separate batch sends due to 24-hour span limit
-    verify(this.testMockEmitter, times(1)).emit(firstEvent);
-    verify(this.testMockEmitter, times(1)).emit(secondEvent);
+    verify(this.mockEmitter, times(1)).emit(firstEvent);
+    verify(this.mockEmitter, times(1)).emit(secondEvent);
   }
 
   @ParameterizedTest
   @MethodSource("batchLimitScenarios")
   void testEventBatchLimits(
       Map<String, Object> logEvent, int eventCount, boolean shouldExceedLimit) {
     for (int i = 0; i < eventCount; i++) {
-      this.testMockEmitter.emit(logEvent);
+      this.mockEmitter.emit(logEvent);
     }
 
     if (shouldExceedLimit) {
-      verify(this.testMockEmitter, atLeast(2)).emit(logEvent);
+      verify(this.mockEmitter, atLeast(2)).emit(logEvent);
     } else {
-      verify(this.testMockEmitter, times(eventCount)).emit(logEvent);
+      verify(this.mockEmitter, times(eventCount)).emit(logEvent);
     }
   }
 

awsagentprovider/src/test/java/software/amazon/opentelemetry/javaagent/providers/exporter/aws/metrics/BaseEmfExporterTest.java

@@ -63,13 +63,13 @@ public abstract class BaseEmfExporterTest<T> {
 
   abstract LogEventEmitter<T> createEmitter();
 
-  abstract MetricExporter createExporter();
+  abstract MetricExporter buildExporter(boolean shouldAddAppSignals);
 
   @BeforeEach
   void setup() {
     capturedLogEvents = new ArrayList<>();
     mockEmitter = createEmitter();
-    exporter = createExporter();
+    exporter = buildExporter(false);
     metricData = mock(MetricData.class);
 
     doAnswer(
@@ -264,6 +264,52 @@ void testExponentialHistogramMetricProcessing() {
     }
   }
 
+  @ParameterizedTest
+  @MethodSource("applicationSignalsDimensionsProvider")
+  void testApplicationSignalsDimensions(
+      Map<String, String> resourceAttrs, String expectedService, String expectedEnvironment) {
+    MetricExporter exporterWithAppSignals = buildExporter(true);
+
+    Resource resource = Resource.empty();
+    for (Map.Entry<String, String> entry : resourceAttrs.entrySet()) {
+      resource = resource.toBuilder().put(entry.getKey(), entry.getValue()).build();
+    }
+
+    GaugeData gaugeData = mock(GaugeData.class);
+    DoublePointData pointData = mock(DoublePointData.class);
+    when(pointData.getValue()).thenReturn(10.0);
+    when(pointData.getAttributes()).thenReturn(Attributes.empty());
+    when(pointData.getEpochNanos()).thenReturn(timestampCounter += 1_000_000);
+
+    when(metricData.getName()).thenReturn("test.metric");
+    when(metricData.getUnit()).thenReturn("1");
+    when(metricData.getData()).thenReturn(gaugeData);
+    when(metricData.getResource()).thenReturn(resource);
+    when(gaugeData.getPoints()).thenReturn(Collections.singletonList(pointData));
+
+    CompletableResultCode result =
+        exporterWithAppSignals.export(Collections.singletonList(metricData));
+
+    assertTrue(result.isSuccess());
+    assertEquals(1, capturedLogEvents.size());
+
+    Map<String, Object> emfLog =
+        validateEmfStructure(capturedLogEvents.get(0), "test.metric").orElseThrow();
+
+    assertEquals(expectedService, emfLog.get("Service"));
+    assertEquals(expectedEnvironment, emfLog.get("Environment"));
+
+    Map<String, Object> awsMetadata = (Map<String, Object>) emfLog.get("_aws");
+    List<Map<String, Object>> cloudWatchMetrics =
+        (List<Map<String, Object>>) awsMetadata.get("CloudWatchMetrics");
+    Map<String, Object> metricGroup = cloudWatchMetrics.get(0);
+    List<List<String>> dimensions = (List<List<String>>) metricGroup.get("Dimensions");
+
+    List<String> dimensionNames = dimensions.get(0);
+    assertTrue(dimensionNames.contains("Service"));
+    assertTrue(dimensionNames.contains("Environment"));
+  }
+
   @ParameterizedTest
   @MethodSource("metricsGroupingProvider")
   void testGroupByAttributesAndTimestamp(List<MetricData> metrics, int expectedLogCount) {
@@ -338,6 +384,57 @@ private List<Number> generateRandomNumbers(int count) {
     return values;
   }
 
+  static List<Arguments> applicationSignalsDimensionsProvider() {
+    return Arrays.asList(
+        // Both service.name and deployment.environment.name provided
+        Arguments.of(
+            Map.of("service.name", "test-service", "deployment.environment.name", "prod"),
+            "test-service",
+            "prod"),
+        // Only service.name provided, environment defaults to generic:default
+        Arguments.of(Map.of("service.name", "test-service"), "test-service", "generic:default"),
+        // No service.name, defaults to UnknownService
+        Arguments.of(Map.of("deployment.environment.name", "staging"), "UnknownService", "staging"),
+        // Empty service.name, defaults to UnknownService
+        Arguments.of(
+            Map.of("service.name", "", "deployment.environment.name", "dev"),
+            "UnknownService",
+            "dev"),
+        // No attributes, both default
+        Arguments.of(Map.of(), "UnknownService", "generic:default"),
+        // cloud.platform=aws_ec2, environment defaults to ec2:default
+        Arguments.of(
+            Map.of("service.name", "ec2-service", "cloud.platform", "aws_ec2"),
+            "ec2-service",
+            "ec2:default"),
+        // cloud.platform=aws_ecs, environment defaults to ecs:default
+        Arguments.of(
+            Map.of("service.name", "ecs-service", "cloud.platform", "aws_ecs"),
+            "ecs-service",
+            "ecs:default"),
+        // cloud.platform=aws_eks, environment defaults to eks:default
+        Arguments.of(
+            Map.of("service.name", "eks-service", "cloud.platform", "aws_eks"),
+            "eks-service",
+            "eks:default"),
+        // cloud.platform=aws_lambda, environment defaults to lambda:default
+        Arguments.of(
+            Map.of("service.name", "lambda-service", "cloud.platform", "aws_lambda"),
+            "lambda-service",
+            "lambda:default"),
+        // deployment.environment.name takes precedence over cloud.platform
+        Arguments.of(
+            Map.of(
+                "service.name",
+                "override-service",
+                "deployment.environment.name",
+                "custom-env",
+                "cloud.platform",
+                "aws_ec2"),
+            "override-service",
+            "custom-env"));
+  }
+
   static List<Arguments> metricsGroupingProvider() {
     Attributes attrs1 = Attributes.builder().put("env", "prod").build();
     Attributes attrs2 = Attributes.builder().put("env", "dev").build();

awsagentprovider/src/test/java/software/amazon/opentelemetry/javaagent/providers/exporter/aws/metrics/ConsoleEmfExporterTest.java

@@ -55,8 +55,12 @@ protected LogEventEmitter<PrintStream> createEmitter() {
   }
 
   @Override
-  protected MetricExporter createExporter() {
-    return ConsoleEmfExporter.builder().setNamespace(NAMESPACE).setEmitter(mockEmitter).build();
+  protected MetricExporter buildExporter(boolean shouldAddAppSignals) {
+    return ConsoleEmfExporter.builder()
+        .setNamespace(NAMESPACE)
+        .setEmitter(mockEmitter)
+        .setShouldAddApplicationSignalsDimensions(shouldAddAppSignals)
+        .build();
   }
 
   @Test