Feature/lambda bash setup

apps/unicorn-store-spring/pom.xml

@@ -58,6 +58,12 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/io.micrometer/micrometer-registry-prometheus -->
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-registry-prometheus</artifactId>
+            <version>1.14.7</version>
+        </dependency>
         <!-- AWS SDK dependencies -->
         <dependency>
             <groupId>software.amazon.awssdk</groupId>

apps/unicorn-store-spring/src/main/java/com/unicorn/store/config/MonitoringConfig.java

@@ -0,0 +1,168 @@
+package com.unicorn.store.config;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.config.MeterFilter;
+import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.URI;
+import java.net.UnknownHostException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Files;
+import java.util.Optional;
+
+@Configuration
+public class MonitoringConfig {
+
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+    private static final File NAMESPACE_FILE = new File("/var/run/secrets/kubernetes.io/serviceaccount/namespace");
+
+    @Bean
+    public MeterRegistryCustomizer<MeterRegistry> meterRegistryCustomizer() {
+        return registry -> {
+            String clusterType = System.getenv("ECS_CONTAINER_METADATA_URI_V4") != null ? "ecs" : "eks";
+            String cluster = clusterType.equals("ecs") ? extractClusterNameFromMetadata().orElse("unknown") : Optional.ofNullable(System.getenv("CLUSTER")).orElse("unknown");
+            String containerName = "unicorn-store-spring";
+            String taskOrPodId = extractTaskOrPodId().orElse("unknown");
+            String namespace = clusterType.equals("eks") ? readNamespaceFile().orElse("default") : "";
+
+            // Get the container/pod IP address
+            String ipAddress = getContainerOrPodIp().orElse("unknown");
+
+            registry.config().commonTags(
+                    "cluster", cluster,
+                    "cluster_type", clusterType,
+                    "container_name", containerName,
+                    "task_pod_id", taskOrPodId,
+                    "instance", ipAddress,       // Keep this for backward compatibility
+                    "container_ip", ipAddress    // Add this new tag that won't be overwritten
+            );
+
+            if (!namespace.isEmpty()) {
+                registry.config().commonTags("namespace", namespace);
+            } else {
+                registry.config().commonTags("namespace", "<no namespace>");
+            }
+
+            registry.config().meterFilter(
+                    MeterFilter.deny(id ->
+                            id.getName().equals("jvm.gc.pause") &&
+                                    !id.getTags().stream().allMatch(tag ->
+                                            tag.getKey().equals("action") ||
+                                                    tag.getKey().equals("cause") ||
+                                                    tag.getKey().equals("gc")
+                                    )
+                    )
+            );
+        };
+    }
+
+    private Optional<String> extractTaskOrPodId() {
+        String metadataUri = System.getenv("ECS_CONTAINER_METADATA_URI_V4");
+        if (metadataUri != null) {
+            try {
+                HttpRequest request = HttpRequest.newBuilder()
+                        .uri(URI.create(metadataUri + "/task"))
+                        .build();
+
+                HttpResponse<String> response = HttpClient.newHttpClient()
+                        .send(request, HttpResponse.BodyHandlers.ofString());
+
+                JsonNode root = OBJECT_MAPPER.readTree(response.body());
+                String taskArn = root.path("TaskARN").asText();
+                String[] parts = taskArn.split("/");
+                return parts.length > 1 ? Optional.of(parts[parts.length - 1]) : Optional.empty();
+
+            } catch (IOException | InterruptedException e) {
+                return Optional.empty();
+            }
+        }
+
+        // EKS fallback: read pod name from Downward API
+        return readFile("/etc/podinfo/name");
+    }
+
+    private Optional<String> extractClusterNameFromMetadata() {
+        String metadataUri = System.getenv("ECS_CONTAINER_METADATA_URI_V4");
+        if (metadataUri != null) {
+            try {
+                HttpRequest request = HttpRequest.newBuilder()
+                        .uri(URI.create(metadataUri + "/task"))
+                        .build();
+
+                HttpResponse<String> response = HttpClient.newHttpClient()
+                        .send(request, HttpResponse.BodyHandlers.ofString());
+
+                JsonNode root = OBJECT_MAPPER.readTree(response.body());
+                String clusterArn = root.path("Cluster").asText();
+                String[] parts = clusterArn.split("/");
+                return parts.length > 1 ? Optional.of(parts[parts.length - 1]) : Optional.empty();
+
+            } catch (IOException | InterruptedException e) {
+                return Optional.empty();
+            }
+        }
+        return Optional.empty();
+    }
+
+    private Optional<String> readNamespaceFile() {
+        return readFile(NAMESPACE_FILE.getAbsolutePath());
+    }
+
+    private Optional<String> readFile(String path) {
+        try {
+            return Optional.of(Files.readString(new File(path).toPath()).trim());
+        } catch (IOException e) {
+            return Optional.empty();
+        }
+    }
+
+    // New method to get the container or pod IP address
+    private Optional<String> getContainerOrPodIp() {
+        // For ECS
+        String metadataUri = System.getenv("ECS_CONTAINER_METADATA_URI_V4");
+        if (metadataUri != null) {
+            try {
+                HttpRequest request = HttpRequest.newBuilder()
+                        .uri(URI.create(metadataUri))
+                        .build();
+
+                HttpResponse<String> response = HttpClient.newHttpClient()
+                        .send(request, HttpResponse.BodyHandlers.ofString());
+
+                JsonNode root = OBJECT_MAPPER.readTree(response.body());
+
+                if (root.has("Networks") && root.path("Networks").isArray() && !root.path("Networks").isEmpty()) {
+                    JsonNode network = root.path("Networks").get(0);
+                    if (network.has("IPv4Addresses") && network.path("IPv4Addresses").isArray() &&
+                            !network.path("IPv4Addresses").isEmpty()) {
+                        return Optional.of(network.path("IPv4Addresses").get(0).asText());
+                    }
+                }
+            } catch (IOException | InterruptedException e) {
+                // Fall through to next method
+            }
+        }
+
+        // For Kubernetes/EKS
+        String podIp = System.getenv("KUBERNETES_POD_IP");
+        if (podIp != null && !podIp.isEmpty()) {
+            return Optional.of(podIp);
+        }
+
+        // Try to get local IP as fallback
+        try {
+            return Optional.of(InetAddress.getLocalHost().getHostAddress());
+        } catch (UnknownHostException e) {
+            return Optional.empty();
+        }
+    }
+}

apps/unicorn-store-spring/src/main/java/com/unicorn/store/controller/ThreadManagementController.java

@@ -0,0 +1,42 @@
+// src/main/java/com/unicorn/store/controller/ThreadManagementController.java
+package com.unicorn.store.controller;
+
+import com.unicorn.store.service.ThreadGeneratorService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/threads")
+public class ThreadManagementController {
+
+    private final ThreadGeneratorService threadGeneratorService;
+
+    public ThreadManagementController(ThreadGeneratorService threadGeneratorService) {
+        this.threadGeneratorService = threadGeneratorService;
+    }
+
+    @PostMapping("/start")
+    public ResponseEntity<String> startThreads(@RequestParam(defaultValue = "500") int count) {
+        try {
+            threadGeneratorService.startThreads(count);
+            return ResponseEntity.ok("Successfully started " + count + " threads");
+        } catch (IllegalStateException e) {
+            return ResponseEntity.badRequest().body(e.getMessage());
+        }
+    }
+
+    @PostMapping("/stop")
+    public ResponseEntity<String> stopThreads() {
+        try {
+            threadGeneratorService.stopThreads();
+            return ResponseEntity.ok("Successfully stopped all threads");
+        } catch (IllegalStateException e) {
+            return ResponseEntity.badRequest().body(e.getMessage());
+        }
+    }
+
+    @GetMapping("/count")
+    public ResponseEntity<Integer> getThreadCount() {
+        return ResponseEntity.ok(threadGeneratorService.getActiveThreadCount());
+    }
+}

apps/unicorn-store-spring/src/main/java/com/unicorn/store/monitoring/ThreadMonitoringMBean.java

@@ -0,0 +1,23 @@
+// src/main/java/com/unicorn/store/monitoring/ThreadMonitoringMBean.java
+package com.unicorn.store.monitoring;
+
+import com.unicorn.store.service.ThreadGeneratorService;
+import org.springframework.jmx.export.annotation.ManagedAttribute;
+import org.springframework.jmx.export.annotation.ManagedResource;
+import org.springframework.stereotype.Component;
+
+@Component
+@ManagedResource(objectName = "com.unicorn.store:type=ThreadMonitoring,name=ThreadStats")
+public class ThreadMonitoringMBean {
+
+    private final ThreadGeneratorService threadGeneratorService;
+
+    public ThreadMonitoringMBean(ThreadGeneratorService threadGeneratorService) {
+        this.threadGeneratorService = threadGeneratorService;
+    }
+
+    @ManagedAttribute(description = "Number of active custom threads")
+    public int getActiveThreadCount() {
+        return threadGeneratorService.getActiveThreadCount();
+    }
+}

apps/unicorn-store-spring/src/main/java/com/unicorn/store/service/ThreadGeneratorService.java

@@ -0,0 +1,86 @@
+// src/main/java/com/unicorn/store/service/ThreadGeneratorService.java
+package com.unicorn.store.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@Service
+public class ThreadGeneratorService {
+    private static final Logger logger = LoggerFactory.getLogger(ThreadGeneratorService.class);
+    private final List<Thread> activeThreads = new ArrayList<>();
+    private final AtomicBoolean running = new AtomicBoolean(false);
+
+    public synchronized void startThreads(int threadCount) {
+        if (running.get()) {
+            throw new IllegalStateException("Threads are already running");
+        }
+
+        running.set(true);
+        logger.info("Starting {} threads", threadCount);
+
+        for (int i = 0; i < threadCount; i++) {
+            Thread thread = new Thread(new DummyWorkload(running));
+            thread.setName("DummyThread-" + i);
+            activeThreads.add(thread);
+            thread.start();
+        }
+
+        logger.info("Started {} threads", threadCount);
+    }
+
+    public synchronized void stopThreads() {
+        if (!running.get()) {
+            throw new IllegalStateException("No threads are running");
+        }
+
+        logger.info("Stopping {} threads", activeThreads.size());
+        running.set(false);
+
+        // Wait for all threads to complete
+        activeThreads.forEach(thread -> {
+            try {
+                thread.join(5000); // Wait up to 5 seconds for each thread
+            } catch (InterruptedException e) {
+                logger.warn("Interrupted while waiting for thread {} to stop", thread.getName());
+            }
+        });
+
+        activeThreads.clear();
+        logger.info("All threads stopped");
+    }
+
+    public int getActiveThreadCount() {
+        return activeThreads.size();
+    }
+
+    private static class DummyWorkload implements Runnable {
+        private final AtomicBoolean running;
+
+        public DummyWorkload(AtomicBoolean running) {
+            this.running = running;
+        }
+
+        @Override
+        public void run() {
+            while (running.get()) {
+                // Simulate some work
+                try {
+                    // Calculate some dummy values to keep CPU busy
+                    double result = 0;
+                    for (int i = 0; i < 1000; i++) {
+                        result += Math.sqrt(i) * Math.random();
+                    }
+                    Thread.sleep(100); // Sleep to prevent excessive CPU usage
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+        }
+    }
+}

apps/unicorn-store-spring/src/main/resources/application.properties

@@ -1,20 +1,30 @@
 spring.sql.init.mode=always
-# spring.datasource.url=jdbc:postgresql://localhost:5432/unicorns
 spring.datasource.username=postgres
-# spring.datasource.password=postgres
 spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
 server.error.include-message=always
 spring.jpa.open-in-view=false
-spring.datasource.hikari.maximumPoolSize=1
-spring.datasource.hikari.data-source-properties.preparedStatementCacheQueries=0
-management.endpoint.health.probes.enabled=true
 
-# Disable Hibernate usage of JDBC metadata
 spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
-
-# Database initialization will typically be performed outside of Spring lifecycle
 spring.jpa.hibernate.ddl-auto=none
+
+spring.datasource.hikari.initialization-fail-timeout=0
+spring.datasource.hikari.maximumPoolSize=1
 spring.datasource.hikari.allow-pool-suspension=true
+spring.datasource.hikari.data-source-properties.preparedStatementCacheQueries=0
+
+# Virtual Threads
+spring.threads.virtual.enabled=true
+
+# Actuator config
+spring.jmx-enabled=true
+management.endpoints.web.exposure.include=threaddump,prometheus,health,info
+management.endpoint.health.probes.enabled=true
+management.endpoint.prometheus.enabled=true
+management.endpoint.health.group.liveness.include=livenessState
+management.endpoint.health.group.readiness.include=readinessState
+
+management.metrics.enable.all=true
+management.metrics.tags.application=otel-jmx-unicorn-store
 
-# Enable virtual threads
-spring.threads.virtual.enabled=true
+server.port=8080
+server.address=0.0.0.0

infrastructure/cdk/pom.xml

@@ -75,5 +75,10 @@
           <version>${junit.version}</version>
           <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>software.constructs</groupId>
+            <artifactId>constructs</artifactId>
+            <version>10.3.0</version>
+        </dependency>
     </dependencies>
 </project>