Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cloudwatch): return logStreamName on FilterLogEvents results (#2259)
TiMa0adea90733c
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.javaindex 83837ffa2c..0a278e0f80 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java@@ -211,7 +211,7 @@ public class CloudWatchLogsHandler {logsService.filterLogEvents(groupName, streamNames, startTime, endTime, filterPattern, limit, region);ObjectNode response = objectMapper.createObjectNode();- response.set("events", buildEventsArray(result.events()));+ response.set("events", buildFilteredEventsArray(result.events()));if (result.nextToken() != null) {response.put("nextToken", result.nextToken());}@@ -467,16 +467,36 @@ public class CloudWatchLogsHandler {private ArrayNode buildEventsArray(List<LogEvent> events) {ArrayNode array = objectMapper.createArrayNode();for (LogEvent e : events) {- ObjectNode node = objectMapper.createObjectNode();- node.put("eventId", e.getEventId());- node.put("timestamp", e.getTimestamp());- node.put("message", e.getMessage());- node.put("ingestionTime", e.getIngestionTime());+ array.add(buildEventNode(e));+ }+ return array;+ }++ /**+ * Serializes FilteredLogEvent, which carries {@code logStreamName} on top of the GetLogEvents+ * shape. The field is what attributes a match back to the stream that emitted it, and real AWS+ * returns it on every FilterLogEvents result; GetLogEvents omits it, so it stays out of+ * {@link #buildEventsArray}.+ */+ private ArrayNode buildFilteredEventsArray(List<CloudWatchLogsService.FilteredEvent> events) {+ ArrayNode array = objectMapper.createArrayNode();+ for (CloudWatchLogsService.FilteredEvent filtered : events) {+ ObjectNode node = buildEventNode(filtered.event());+ node.put("logStreamName", filtered.logStreamName());array.add(node);}return array;}+ private ObjectNode buildEventNode(LogEvent e) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("eventId", e.getEventId());+ node.put("timestamp", e.getTimestamp());+ node.put("message", e.getMessage());+ node.put("ingestionTime", e.getIngestionTime());+ return node;+ }+private Map<String, String> extractTags(JsonNode tagsNode) {Map<String, String> tags = new HashMap<>();if (tagsNode != null && tagsNode.isObject()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.javaindex e703a342f6..0726e8c212 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java@@ -407,7 +407,14 @@ public class CloudWatchLogsService {}}- public record FilteredLogEventsResult(List<LogEvent> events, String nextToken) {}+ /**+ * A FilterLogEvents match paired with the stream that emitted it. FilterLogEvents is the+ * cross-stream API, so the stream is what lets a caller attribute a hit; GetLogEvents needs+ * no such pairing because the caller named the stream in the request.+ */+ public record FilteredEvent(String logStreamName, LogEvent event) {}++ public record FilteredLogEventsResult(List<FilteredEvent> events, String nextToken) {}public FilteredLogEventsResult filterLogEvents(String groupName, List<String> streamNames,Long startTime, Long endTime,@@ -417,25 +424,31 @@ public class CloudWatchLogsService {maxEventsPerQuery);String groupPrefix = groupKeyPrefix(region) + groupName + "::";- List<LogEvent> all = new ArrayList<>();-- if (streamNames != null && !streamNames.isEmpty()) {- for (String sn : streamNames) {- String eventPrefix = eventKeyPrefix(region, groupName, sn);- all.addAll(eventStore.scan(k -> k.startsWith(eventPrefix)));+ List<String> requested = streamNames == null ? List.of() : streamNames;++ // Walk keys rather than values: the key is the only place the emitting stream is+ // recorded, so reading it back is what lets each match carry its stream name. It also+ // keeps a stream-restricted filter to one pass over the keyset instead of one scan per+ // requested stream, since every scan walks the whole keyset regardless of its prefix.+ List<FilteredEvent> all = new ArrayList<>();+ for (String key : eventStore.keys()) {+ if (!key.startsWith(groupPrefix)) {+ continue;}- } else {- // All streams in group- all.addAll(eventStore.scan(k -> k.startsWith(groupPrefix)));+ String streamName = streamNameFromEventKey(key, groupPrefix);+ if (!requested.isEmpty() && !requested.contains(streamName)) {+ continue;+ }+ eventStore.get(key).ifPresent(e -> all.add(new FilteredEvent(streamName, e)));}- all.sort(EVENT_ORDER);+ all.sort(Comparator.comparing(FilteredEvent::event, EVENT_ORDER));- List<LogEvent> result = all.stream()- .filter(e -> (startTime == null || e.getTimestamp() >= startTime)- && (endTime == null || e.getTimestamp() <= endTime))- .filter(e -> filterPattern == null || filterPattern.isBlank()- || e.getMessage().contains(filterPattern))+ List<FilteredEvent> result = all.stream()+ .filter(f -> (startTime == null || f.event().getTimestamp() >= startTime)+ && (endTime == null || f.event().getTimestamp() <= endTime))+ .filter(f -> filterPattern == null || filterPattern.isBlank()+ || f.event().getMessage().contains(filterPattern)).limit(maxEvents).toList();@@ -713,6 +726,21 @@ public class CloudWatchLogsService {+ String.format("%015d", timestamp) + "::" + uuid;}+ /**+ * Recover the emitting stream from an event key, which {@link #eventKey} lays out as+ * {@code <region>::<group>::<stream>::<timestamp>::<uuid>}. The stream is bounded by the+ * caller's group prefix on the left and by the trailing timestamp and uuid on the right, both+ * of which are generated here and contain no "::", so the name comes back whole even though+ * nothing stops a caller from creating a stream whose name holds a ':'.+ */+ private static String streamNameFromEventKey(String eventKey, String groupPrefix) {+ int uuidSeparator = eventKey.lastIndexOf("::");+ int timestampSeparator = uuidSeparator < 0 ? -1 : eventKey.lastIndexOf("::", uuidSeparator - 1);+ return timestampSeparator < groupPrefix.length()+ ? eventKey.substring(groupPrefix.length())+ : eventKey.substring(groupPrefix.length(), timestampSeparator);+ }+private static String subscriptionFilterKeyPrefix(String region, String logGroupName) {return region + "::" + logGroupName + "::filter::";}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandlerTest.javaindex db516b42b0..d5a2b2bb39 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandlerTest.java@@ -305,6 +305,56 @@ class CloudWatchLogsHandlerTest {JsonNode events = ((ObjectNode) response.getEntity()).path("events");assertEquals(1, events.size());assertThat(events.get(0).path("message").asText(), containsString("ERROR"));+ assertEquals(STREAM, events.get(0).path("logStreamName").asText());+ }++ @Test+ void filterLogEventsAttributesEachMatchToItsStream() {+ // FilterLogEvents spans streams, so a caller can only attribute a hit if the response+ // says which stream emitted it.+ String otherStream = "postgresql.log.2026-06-05";+ service.createLogStream(GROUP, otherStream, REGION);++ long now = System.currentTimeMillis();+ service.putLogEvents(GROUP, STREAM, java.util.List.of(+ java.util.Map.of("timestamp", now, "message", "ERROR: from first")+ ), REGION);+ service.putLogEvents(GROUP, otherStream, java.util.List.of(+ java.util.Map.of("timestamp", now + 1, "message", "ERROR: from second")+ ), REGION);++ ObjectNode request = MAPPER.createObjectNode();+ request.put("logGroupName", GROUP);+ request.put("filterPattern", "ERROR");++ Response response = handler.handle("FilterLogEvents", request, REGION);++ assertEquals(200, response.getStatus());+ JsonNode events = ((ObjectNode) response.getEntity()).path("events");+ assertEquals(2, events.size());+ assertEquals(STREAM, events.get(0).path("logStreamName").asText());+ assertEquals(otherStream, events.get(1).path("logStreamName").asText());+ }++ @Test+ void getLogEventsOmitsLogStreamName() {+ // OutputLogEvent has no logStreamName in real AWS: the caller named the stream in the+ // request, so echoing it back would be a shape floci invents.+ long now = System.currentTimeMillis();+ service.putLogEvents(GROUP, STREAM, java.util.List.of(+ java.util.Map.of("timestamp", now, "message", "only one stream here")+ ), REGION);++ ObjectNode request = MAPPER.createObjectNode();+ request.put("logGroupName", GROUP);+ request.put("logStreamName", STREAM);++ Response response = handler.handle("GetLogEvents", request, REGION);++ assertEquals(200, response.getStatus());+ JsonNode events = ((ObjectNode) response.getEntity()).path("events");+ assertEquals(1, events.size());+ assertTrue(events.get(0).path("logStreamName").isMissingNode());}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsServiceTest.javaindex 33e223033f..2be2421000 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsServiceTest.java@@ -249,7 +249,7 @@ class CloudWatchLogsServiceTest {assertEquals(10, result.events().size());for (int i = 0; i < 10; i++) {- assertEquals("SEQLINE-" + i, result.events().get(i).getMessage(),+ assertEquals("SEQLINE-" + i, result.events().get(i).event().getMessage(),"event at index " + i + " out of ingestion order");}}@@ -286,7 +286,87 @@ class CloudWatchLogsServiceTest {CloudWatchLogsService.FilteredLogEventsResult result = service.filterLogEvents("/app/logs", null, null, null, "ERROR", 100, REGION);assertEquals(2, result.events().size());- assertTrue(result.events().stream().allMatch(e -> e.getMessage().contains("ERROR")));+ assertTrue(result.events().stream().allMatch(f -> f.event().getMessage().contains("ERROR")));+ }++ @Test+ void filterLogEventsCarriesEmittingStreamPerEvent() {+ service.createLogGroup("/app/logs", null, null, REGION);+ service.createLogStream("/app/logs", "stream-1", REGION);+ service.createLogStream("/app/logs", "stream-2", REGION);++ long now = System.currentTimeMillis();+ service.putLogEvents("/app/logs", "stream-1",+ List.of(Map.of("timestamp", now, "message", "ERROR: from one")), REGION);+ service.putLogEvents("/app/logs", "stream-2",+ List.of(Map.of("timestamp", now + 1, "message", "ERROR: from two")), REGION);++ CloudWatchLogsService.FilteredLogEventsResult result = service.filterLogEvents(+ "/app/logs", null, null, null, "ERROR", 100, REGION);++ assertEquals(2, result.events().size());+ assertEquals("stream-1", result.events().get(0).logStreamName());+ assertEquals("stream-2", result.events().get(1).logStreamName());+ }++ @Test+ void filterLogEventsRestrictedToNamedStreamsSkipsTheRest() {+ service.createLogGroup("/app/logs", null, null, REGION);+ service.createLogStream("/app/logs", "stream-1", REGION);+ service.createLogStream("/app/logs", "stream-2", REGION);++ long now = System.currentTimeMillis();+ service.putLogEvents("/app/logs", "stream-1",+ List.of(Map.of("timestamp", now, "message", "keep me")), REGION);+ service.putLogEvents("/app/logs", "stream-2",+ List.of(Map.of("timestamp", now + 1, "message", "drop me")), REGION);++ CloudWatchLogsService.FilteredLogEventsResult result = service.filterLogEvents(+ "/app/logs", List.of("stream-2"), null, null, null, 100, REGION);++ assertEquals(1, result.events().size());+ assertEquals("stream-2", result.events().getFirst().logStreamName());+ assertEquals("drop me", result.events().getFirst().event().getMessage());+ }++ @Test+ void filterLogEventsDoesNotLeakEventsFromAPrefixSiblingGroup() {+ // "/app/logs" must not sweep up "/app/logs-archive": the key layout separates the group+ // from the stream with "::", so the group prefix has to be matched with it.+ service.createLogGroup("/app/logs", null, null, REGION);+ service.createLogStream("/app/logs", "stream-1", REGION);+ service.createLogGroup("/app/logs-archive", null, null, REGION);+ service.createLogStream("/app/logs-archive", "stream-1", REGION);++ long now = System.currentTimeMillis();+ service.putLogEvents("/app/logs", "stream-1",+ List.of(Map.of("timestamp", now, "message", "live")), REGION);+ service.putLogEvents("/app/logs-archive", "stream-1",+ List.of(Map.of("timestamp", now, "message", "archived")), REGION);++ CloudWatchLogsService.FilteredLogEventsResult result = service.filterLogEvents(+ "/app/logs", null, null, null, null, 100, REGION);++ assertEquals(1, result.events().size());+ assertEquals("live", result.events().getFirst().event().getMessage());+ }++ @Test+ void filterLogEventsRecoversStreamNamesHoldingAColon() {+ // AWS forbids ':' in a stream name but floci does not enforce that, so the stream a match+ // is attributed to must not depend on the name being AWS-legal.+ String awkward = "app:worker:1";+ service.createLogGroup("/app/logs", null, null, REGION);+ service.createLogStream("/app/logs", awkward, REGION);++ service.putLogEvents("/app/logs", awkward,+ List.of(Map.of("timestamp", System.currentTimeMillis(), "message", "hello")), REGION);++ CloudWatchLogsService.FilteredLogEventsResult result = service.filterLogEvents(+ "/app/logs", null, null, null, null, 100, REGION);++ assertEquals(1, result.events().size());+ assertEquals(awkward, result.events().getFirst().logStreamName());}@Test