Light, fluffy, and always free - The AWS Local Emulator alternative
feat(kinesis): implement EnableEnhancedMonitoring and DisableEnhancedMonitoring (#417)
TiMcf9eb3251627
diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.javaindex f2ded40616..9a303d59b5 100644--- a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandler.java@@ -14,10 +14,12 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;+import java.util.ArrayList;import java.util.Base64;import java.util.HashMap;import java.util.List;import java.util.Map;+import java.util.Set;@ApplicationScopedpublic class KinesisJsonHandler {@@ -57,6 +59,8 @@ public class KinesisJsonHandler {case "ListShards" -> handleListShards(request, region);case "IncreaseStreamRetentionPeriod" -> handleIncreaseStreamRetentionPeriod(request, region);case "DecreaseStreamRetentionPeriod" -> handleDecreaseStreamRetentionPeriod(request, region);+ case "EnableEnhancedMonitoring" -> handleEnableEnhancedMonitoring(request, region);+ case "DisableEnhancedMonitoring" -> handleDisableEnhancedMonitoring(request, region);default -> Response.status(400).entity(new AwsErrorResponse("UnsupportedOperation", "Operation " + action + " is not supported.")).build();@@ -125,6 +129,8 @@ public class KinesisJsonHandler {desc.put("KeyId", stream.getKeyId());}+ addEnhancedMonitoringNode(desc, stream);+ArrayNode shards = desc.putArray("Shards");for (KinesisShard shard : stream.getShards()) {ObjectNode sNode = shards.addObject();@@ -163,9 +169,17 @@ public class KinesisJsonHandler {if (stream.getKeyId() != null) {summary.put("KeyId", stream.getKeyId());}++ addEnhancedMonitoringNode(summary, stream);+return Response.ok(response).build();}+ private void addEnhancedMonitoringNode(ObjectNode parent, KinesisStream stream) {+ ArrayNode shardLevelMetrics = parent.putArray("EnhancedMonitoring").addObject().putArray("ShardLevelMetrics");+ stream.getEnhancedMonitoringMetrics().stream().sorted().forEach(shardLevelMetrics::add);+ }+private Response handleRegisterStreamConsumer(JsonNode request, String region) {String streamArn = request.path("StreamARN").asText();String consumerName = request.path("ConsumerName").asText();@@ -409,4 +423,42 @@ public class KinesisJsonHandler {return Response.ok(response).build();}+ private Response handleEnableEnhancedMonitoring(JsonNode request, String region) {+ String streamName = resolveStreamName(request);++ List<String> metrics = new ArrayList<>();+ request.path("ShardLevelMetrics").forEach(m -> metrics.add(m.asText()));++ Set<String> currentMetrics = service.enableEnhancedMonitoring(streamName, metrics, region);+ KinesisStream updated = service.describeStream(streamName, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("StreamName", streamName);+ response.put("StreamARN", updated.getStreamArn());+ ArrayNode current = response.putArray("CurrentShardLevelMetrics");+ currentMetrics.stream().sorted().forEach(current::add);+ ArrayNode desired = response.putArray("DesiredShardLevelMetrics");+ updated.getEnhancedMonitoringMetrics().stream().sorted().forEach(desired::add);+ return Response.ok(response).build();+ }++ private Response handleDisableEnhancedMonitoring(JsonNode request, String region) {+ String streamName = resolveStreamName(request);++ List<String> metrics = new ArrayList<>();+ request.path("ShardLevelMetrics").forEach(m -> metrics.add(m.asText()));++ Set<String> currentMetrics = service.disableEnhancedMonitoring(streamName, metrics, region);+ KinesisStream updated = service.describeStream(streamName, region);++ ObjectNode response = objectMapper.createObjectNode();+ response.put("StreamName", streamName);+ response.put("StreamARN", updated.getStreamArn());+ ArrayNode current = response.putArray("CurrentShardLevelMetrics");+ currentMetrics.stream().sorted().forEach(current::add);+ ArrayNode desired = response.putArray("DesiredShardLevelMetrics");+ updated.getEnhancedMonitoringMetrics().stream().sorted().forEach(desired::add);+ return Response.ok(response).build();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisService.java b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisService.javaindex 0833efe224..11b1f23064 100644--- a/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisService.java+++ b/src/main/java/io/github/hectorvent/floci/services/kinesis/KinesisService.java@@ -21,6 +21,11 @@ import java.util.concurrent.atomic.AtomicLong;@ApplicationScopedpublic class KinesisService {private static final Logger LOG = Logger.getLogger(KinesisService.class);+ private static final Set<String> VALID_SHARD_LEVEL_METRICS = Set.of(+ "IncomingBytes", "IncomingRecords", "OutgoingBytes", "OutgoingRecords",+ "WriteProvisionedThroughputExceeded", "ReadProvisionedThroughputExceeded",+ "IteratorAgeMilliseconds", "ALL");+private final StorageBackend<String, KinesisStream> store;private final StorageBackend<String, KinesisConsumer> consumerStore;private final RegionResolver regionResolver;@@ -186,6 +191,46 @@ public class KinesisService {LOG.infov("Decreased retention period for stream {0} to {1} hours", streamName, retentionPeriodHours);}+ public Set<String> enableEnhancedMonitoring(String streamName, List<String> metrics, String region) {+ KinesisStream stream = resolveStream(streamName, region);+ Set<String> current = new HashSet<>(stream.getEnhancedMonitoringMetrics());+ Set<String> desired = resolveMetrics(metrics);+ stream.getEnhancedMonitoringMetrics().addAll(desired);+ store.put(regionKey(region, streamName), stream);+ LOG.infov("Enabled enhanced monitoring for stream {0}: {1}", streamName, desired);+ return current;+ }++ public Set<String> disableEnhancedMonitoring(String streamName, List<String> metrics, String region) {+ KinesisStream stream = resolveStream(streamName, region);+ Set<String> current = new HashSet<>(stream.getEnhancedMonitoringMetrics());+ Set<String> toRemove = resolveMetrics(metrics);+ stream.getEnhancedMonitoringMetrics().removeAll(toRemove);+ store.put(regionKey(region, streamName), stream);+ LOG.infov("Disabled enhanced monitoring for stream {0}: {1}", streamName, toRemove);+ return current;+ }++ private Set<String> resolveMetrics(List<String> metrics) {+ if (metrics.isEmpty()) {+ throw new AwsException("InvalidArgumentException",+ "ShardLevelMetrics must contain at least one metric", 400);+ }+ // Validate all entries before expanding ALL+ for (String m : metrics) {+ if (!VALID_SHARD_LEVEL_METRICS.contains(m)) {+ throw new AwsException("InvalidArgumentException",+ "Invalid ShardLevelMetric: " + m, 400);+ }+ }+ if (metrics.contains("ALL")) {+ Set<String> all = new HashSet<>(VALID_SHARD_LEVEL_METRICS);+ all.remove("ALL");+ return all;+ }+ return new HashSet<>(metrics);+ }+public void stopStreamEncryption(String streamName, String region) {KinesisStream stream = resolveStream(streamName, region);stream.setEncryptionType("NONE");diff --git a/src/main/java/io/github/hectorvent/floci/services/kinesis/model/KinesisStream.java b/src/main/java/io/github/hectorvent/floci/services/kinesis/model/KinesisStream.javaindex 4efaf9180e..f57a132ea4 100644--- a/src/main/java/io/github/hectorvent/floci/services/kinesis/model/KinesisStream.java+++ b/src/main/java/io/github/hectorvent/floci/services/kinesis/model/KinesisStream.java@@ -6,8 +6,10 @@ import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;import java.util.ArrayList;import java.util.HashMap;+import java.util.HashSet;import java.util.List;import java.util.Map;+import java.util.Set;@RegisterForReflection@JsonIgnoreProperties(ignoreUnknown = true)@@ -22,6 +24,7 @@ public class KinesisStream {private String encryptionType = "NONE";private String keyId;private String streamMode = "PROVISIONED";+ private Set<String> enhancedMonitoringMetrics = new HashSet<>();public KinesisStream() {}@@ -61,4 +64,7 @@ public class KinesisStream {public String getStreamMode() { return streamMode; }public void setStreamMode(String streamMode) { this.streamMode = streamMode; }++ public Set<String> getEnhancedMonitoringMetrics() { return enhancedMonitoringMetrics; }+ public void setEnhancedMonitoringMetrics(Set<String> enhancedMonitoringMetrics) { this.enhancedMonitoringMetrics = enhancedMonitoringMetrics; }}diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.javaindex a49ca435f7..ec69884df2 100644--- a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisJsonHandlerTest.java@@ -155,6 +155,72 @@ class KinesisJsonHandlerTest {assertThat(responseEntity(resp).has("SequenceNumber"), is(true));}+ @Test+ void enableEnhancedMonitoringReturnsMetrics() {+ createStream("test-stream");++ ObjectNode req = MAPPER.createObjectNode();+ req.put("StreamName", "test-stream");+ req.putArray("ShardLevelMetrics").add("IncomingBytes").add("OutgoingBytes");+ Response resp = handler.handle("EnableEnhancedMonitoring", req, REGION);+ assertThat(resp.getStatus(), is(200));++ ObjectNode body = responseEntity(resp);+ assertEquals("test-stream", body.get("StreamName").asText());+ assertEquals(0, body.get("CurrentShardLevelMetrics").size());+ assertEquals(2, body.get("DesiredShardLevelMetrics").size());+ }++ @Test+ void disableEnhancedMonitoringReturnsMetrics() {+ createStream("test-stream");++ ObjectNode enableReq = MAPPER.createObjectNode();+ enableReq.put("StreamName", "test-stream");+ enableReq.putArray("ShardLevelMetrics").add("IncomingBytes").add("OutgoingBytes");+ handler.handle("EnableEnhancedMonitoring", enableReq, REGION);++ ObjectNode disableReq = MAPPER.createObjectNode();+ disableReq.put("StreamName", "test-stream");+ disableReq.putArray("ShardLevelMetrics").add("IncomingBytes");+ Response resp = handler.handle("DisableEnhancedMonitoring", disableReq, REGION);+ assertThat(resp.getStatus(), is(200));++ ObjectNode body = responseEntity(resp);+ assertEquals(2, body.get("CurrentShardLevelMetrics").size());+ assertEquals(1, body.get("DesiredShardLevelMetrics").size());+ }++ @Test+ void describeStreamIncludesEnhancedMonitoring() {+ createStream("test-stream");++ ObjectNode enableReq = MAPPER.createObjectNode();+ enableReq.put("StreamName", "test-stream");+ enableReq.putArray("ShardLevelMetrics").add("IncomingBytes");+ handler.handle("EnableEnhancedMonitoring", enableReq, REGION);++ ObjectNode descReq = MAPPER.createObjectNode();+ descReq.put("StreamName", "test-stream");+ Response resp = handler.handle("DescribeStream", descReq, REGION);+ ObjectNode desc = (ObjectNode) responseEntity(resp).get("StreamDescription");+ assertEquals(1, desc.get("EnhancedMonitoring").size());+ assertEquals(1, desc.get("EnhancedMonitoring").get(0).get("ShardLevelMetrics").size());+ assertEquals("IncomingBytes", desc.get("EnhancedMonitoring").get(0).get("ShardLevelMetrics").get(0).asText());+ }++ @Test+ void describeStreamSummaryIncludesEnhancedMonitoring() {+ createStream("test-stream");++ ObjectNode descReq = MAPPER.createObjectNode();+ descReq.put("StreamName", "test-stream");+ Response resp = handler.handle("DescribeStreamSummary", descReq, REGION);+ ObjectNode summary = (ObjectNode) responseEntity(resp).get("StreamDescriptionSummary");+ assertEquals(1, summary.get("EnhancedMonitoring").size());+ assertEquals(0, summary.get("EnhancedMonitoring").get(0).get("ShardLevelMetrics").size());+ }+@Testvoid streamNameTakesPrecedenceOverArn() {createStream("by-name");diff --git a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisServiceTest.javaindex 792adef585..b571cf2590 100644--- a/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/kinesis/KinesisServiceTest.java@@ -11,6 +11,7 @@ import org.junit.jupiter.api.Test;import java.nio.charset.StandardCharsets;import java.util.List;import java.util.Map;+import java.util.Set;import static org.junit.jupiter.api.Assertions.*;@@ -191,6 +192,76 @@ class KinesisServiceTest {assertFalse(updated.getShards().get(2).isClosed());}+ @Test+ void enableEnhancedMonitoring() {+ kinesisService.createStream("my-stream", 1, REGION);+ Set<String> before = kinesisService.enableEnhancedMonitoring(+ "my-stream", List.of("IncomingBytes", "OutgoingBytes"), REGION);++ assertTrue(before.isEmpty());+ KinesisStream stream = kinesisService.describeStream("my-stream", REGION);+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("IncomingBytes"));+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("OutgoingBytes"));+ }++ @Test+ void enableEnhancedMonitoringAll() {+ kinesisService.createStream("my-stream", 1, REGION);+ kinesisService.enableEnhancedMonitoring("my-stream", List.of("ALL"), REGION);++ KinesisStream stream = kinesisService.describeStream("my-stream", REGION);+ assertEquals(7, stream.getEnhancedMonitoringMetrics().size());+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("IncomingBytes"));+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("IteratorAgeMilliseconds"));+ }++ @Test+ void disableEnhancedMonitoring() {+ kinesisService.createStream("my-stream", 1, REGION);+ kinesisService.enableEnhancedMonitoring(+ "my-stream", List.of("IncomingBytes", "OutgoingBytes", "IncomingRecords"), REGION);+ Set<String> before = kinesisService.disableEnhancedMonitoring(+ "my-stream", List.of("OutgoingBytes"), REGION);++ assertEquals(3, before.size());+ KinesisStream stream = kinesisService.describeStream("my-stream", REGION);+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("IncomingBytes"));+ assertTrue(stream.getEnhancedMonitoringMetrics().contains("IncomingRecords"));+ assertFalse(stream.getEnhancedMonitoringMetrics().contains("OutgoingBytes"));+ }++ @Test+ void disableEnhancedMonitoringAll() {+ kinesisService.createStream("my-stream", 1, REGION);+ kinesisService.enableEnhancedMonitoring(+ "my-stream", List.of("IncomingBytes", "OutgoingBytes"), REGION);+ kinesisService.disableEnhancedMonitoring("my-stream", List.of("ALL"), REGION);++ KinesisStream stream = kinesisService.describeStream("my-stream", REGION);+ assertTrue(stream.getEnhancedMonitoringMetrics().isEmpty());+ }++ @Test+ void enableEnhancedMonitoringInvalidMetric() {+ kinesisService.createStream("my-stream", 1, REGION);+ assertThrows(AwsException.class, () ->+ kinesisService.enableEnhancedMonitoring("my-stream", List.of("BogusMetric"), REGION));+ }++ @Test+ void enableEnhancedMonitoringEmptyListThrows() {+ kinesisService.createStream("my-stream", 1, REGION);+ assertThrows(AwsException.class, () ->+ kinesisService.enableEnhancedMonitoring("my-stream", List.of(), REGION));+ }++ @Test+ void enableEnhancedMonitoringAllWithInvalidThrows() {+ kinesisService.createStream("my-stream", 1, REGION);+ assertThrows(AwsException.class, () ->+ kinesisService.enableEnhancedMonitoring("my-stream", List.of("ALL", "BogusMetric"), REGION));+ }+@Testvoid startAndStopEncryption() {kinesisService.createStream("my-stream", 1, REGION);