Feature/add prometheus and grafana

core/pom.xml

@@ -263,6 +263,18 @@
             <artifactId>jsoup</artifactId>
             <version>1.18.1</version>
         </dependency>
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-registry-prometheus</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

core/src/main/java/greencity/config/SecurityConfig.java

@@ -1,15 +1,17 @@
 package greencity.config;
 
+import greencity.metrics.ActiveUsersInMemoryMetrics;
+import greencity.metrics.RequestCountMetrics;
 import greencity.security.filters.AccessTokenAuthenticationFilter;
 import greencity.security.filters.XSSFilter;
 import greencity.security.jwt.JwtTool;
 import greencity.security.providers.JwtAuthenticationProvider;
 import greencity.service.UserService;
-import java.util.Arrays;
-import java.util.List;
+import io.micrometer.core.instrument.MeterRegistry;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.actuate.autoconfigure.security.servlet.EndpointRequest;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpMethod;
@@ -26,10 +28,9 @@
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 import org.springframework.web.cors.CorsConfiguration;
-import static greencity.constant.AppConstant.ADMIN;
-import static greencity.constant.AppConstant.USER;
-import static greencity.constant.AppConstant.MODERATOR;
-import static greencity.constant.AppConstant.UBS_EMPLOYEE;
+import java.util.Arrays;
+import java.util.List;
+import static greencity.constant.AppConstant.*;
 import static jakarta.servlet.http.HttpServletResponse.SC_FORBIDDEN;
 import static jakarta.servlet.http.HttpServletResponse.SC_UNAUTHORIZED;
 import static org.springframework.security.config.http.SessionCreationPolicy.STATELESS;
@@ -88,6 +89,8 @@ public class SecurityConfig {
     private final JwtTool jwtTool;
     private final UserService userService;
     private final AuthenticationConfiguration authenticationConfiguration;
+    private final MeterRegistry meterRegistry;
+    private final RequestCountMetrics requestCountMetrics;
 
     @Value("${spring.messaging.stomp.websocket.allowed-origins}")
     private String[] allowedOrigins;
@@ -125,6 +128,8 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                 UsernamePasswordAuthenticationFilter.class)
             .addFilterBefore(new XSSFilter(),
                 UsernamePasswordAuthenticationFilter.class)
+            .addFilterAfter(new ActiveUsersInMemoryMetrics(meterRegistry), AccessTokenAuthenticationFilter.class)
+            .addFilterBefore(requestCountMetrics, AccessTokenAuthenticationFilter.class)
             .exceptionHandling(exception -> exception.authenticationEntryPoint((req, resp, exc) -> resp
                 .sendError(SC_UNAUTHORIZED, "Authorize first."))
                 .accessDeniedHandler((req, resp, exc) -> resp.sendError(SC_FORBIDDEN, "You don't have authorities.")))
@@ -139,8 +144,10 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
                     "/swagger-ui.html",
                     "/swagger-ui/**",
                     "/swagger-resources/**",
-                    "/webjars/**")
+                    "/webjars/**",
+                    "/metrics/recordLogin")
                 .permitAll()
+                .requestMatchers(EndpointRequest.toAnyEndpoint()).permitAll()
                 .requestMatchers("/css/**", "/img/**").permitAll()
                 .requestMatchers(HttpMethod.GET,
                     FACT_OF_THE_DAY + RANDOM,

core/src/main/java/greencity/controller/MetricsController.java

@@ -0,0 +1,23 @@
+package greencity.controller;
+
+import greencity.dto.metric.LoginEventDto;
+import greencity.metrics.ActiveUsersInMemoryMetrics;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/metrics")
+@RequiredArgsConstructor
+public class MetricsController {
+    private final ActiveUsersInMemoryMetrics activeUsersInMemoryMetrics;
+
+    @PostMapping("/recordLogin")
+    public ResponseEntity<Void> recordLogin(@RequestBody LoginEventDto loginEventDto) {
+        activeUsersInMemoryMetrics.recordLogin(loginEventDto.getEmail(), loginEventDto.getLoginTime());
+        return ResponseEntity.ok().build();
+    }
+}

core/src/main/java/greencity/dto/metric/LoginEventDto.java

@@ -0,0 +1,13 @@
+package greencity.dto.metric;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class LoginEventDto {
+    private String email;
+    private Long loginTime;
+}

core/src/main/java/greencity/metrics/ActiveUsersInMemoryMetrics.java

@@ -0,0 +1,86 @@
+package greencity.metrics;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Component
+public class ActiveUsersInMemoryMetrics extends OncePerRequestFilter {
+    private static final Logger logger = LoggerFactory.getLogger(ActiveUsersInMemoryMetrics.class);
+    private final MeterRegistry meterRegistry;
+    private final Map<String, Instant> activeUsers = new ConcurrentHashMap<>();
+    private final Map<String, List<Instant>> userLogins = new ConcurrentHashMap<>();
+    private static final long INACTIVITY_TIMEOUT_MINUTES = 60;
+    private static final long INACTIVITY_TIMEOUT_SECONDS = INACTIVITY_TIMEOUT_MINUTES * 60;
+    private static final long LOGIN_WINDOW_HOURS = 3;
+    private static final long LOGIN_WINDOW_SECONDS = LOGIN_WINDOW_HOURS * 3600;
+
+    public ActiveUsersInMemoryMetrics(MeterRegistry meterRegistry) {
+        this.meterRegistry = meterRegistry;
+
+        Gauge.builder("app_active_users", this::getActiveUsersCount)
+            .description("Number of active users on the site")
+            .baseUnit("users")
+            .register(meterRegistry);
+
+        Gauge.builder("app_user_logins_per_3h", this::getUserLoginsCount)
+            .description("Number of unique user logins in the last 3 hours")
+            .baseUnit("users")
+            .register(meterRegistry);
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+        throws ServletException, IOException {
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        if (auth != null && auth.isAuthenticated() && !"anonymousUser".equals(auth.getName())) {
+            String username = auth.getName();
+            Instant now = Instant.now();
+            activeUsers.put(username, now);
+        }
+
+        removeInactiveUsers();
+        filterChain.doFilter(request, response);
+    }
+
+    public void recordLogin(String email, Long loginTime) {
+        Instant signInInstant = Instant.ofEpochMilli(loginTime);
+        userLogins.computeIfAbsent(email, k -> new ArrayList<>()).add(signInInstant);
+        logger.debug("New login recorded for user: {} at time: {}", email, signInInstant);
+
+        removeInactiveUsers();
+    }
+
+    private void removeInactiveUsers() {
+        Instant now = Instant.now();
+        activeUsers.entrySet()
+            .removeIf(entry -> now.getEpochSecond() - entry.getValue().getEpochSecond() > INACTIVITY_TIMEOUT_SECONDS);
+
+        userLogins.forEach((key, logins) -> logins
+            .removeIf(login -> now.getEpochSecond() - login.getEpochSecond() > LOGIN_WINDOW_SECONDS));
+        userLogins.entrySet().removeIf(entry -> entry.getValue().isEmpty());
+    }
+
+    private int getActiveUsersCount() {
+        return activeUsers.size();
+    }
+
+    private int getUserLoginsCount() {
+        return userLogins.values().stream().mapToInt(List::size).sum();
+    }
+}

core/src/main/java/greencity/metrics/CPUMetrics.java

@@ -0,0 +1,34 @@
+package greencity.metrics;
+
+import com.sun.management.OperatingSystemMXBean;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import java.lang.management.ManagementFactory;
+
+@Component
+public class CPUMetrics {
+    private final MeterRegistry meterRegistry;
+    private final OperatingSystemMXBean osBean;
+
+    public CPUMetrics(MeterRegistry meterRegistry) {
+        this.meterRegistry = meterRegistry;
+        this.osBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+
+        Gauge.builder("app_cpu_usage_percent", this, CPUMetrics::getCpuUsage)
+            .description("CPU usage of the application in percent")
+            .baseUnit("percent")
+            .register(meterRegistry);
+    }
+
+    @Scheduled(fixedRate = 60000)
+    public void updateCPUMetrics() {
+        meterRegistry.gauge("app_cpu_usage_percent", this, CPUMetrics::getCpuUsage);
+    }
+
+    private double getCpuUsage() {
+        double cpuLoad = osBean.getProcessCpuLoad() * 100;
+        return cpuLoad >= 0 ? cpuLoad : 0;
+    }
+}

core/src/main/java/greencity/metrics/GarbageCollectionMetrics.java

@@ -0,0 +1,125 @@
+package greencity.metrics;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import org.springframework.stereotype.Component;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+@Component
+public class GarbageCollectionMetrics {
+    private static final long TIME_WINDOW_SECONDS = 3600;
+    private final MeterRegistry meterRegistry;
+    private final List<GarbageCollectorMXBean> gcBeans;
+    private final Map<GarbageCollectorMXBean, ConcurrentLinkedQueue<GCTimeRecord>> gcTimeHistory =
+        new ConcurrentHashMap<>();
+    private final Map<GarbageCollectorMXBean, ConcurrentLinkedQueue<GCCountRecord>> gcCountHistory =
+        new ConcurrentHashMap<>();
+
+    public GarbageCollectionMetrics(MeterRegistry meterRegistry) {
+        this.meterRegistry = meterRegistry;
+        this.gcBeans = ManagementFactory.getGarbageCollectorMXBeans();
+        for (GarbageCollectorMXBean gcBean : gcBeans) {
+            gcTimeHistory.put(gcBean, new ConcurrentLinkedQueue<>());
+            gcCountHistory.put(gcBean, new ConcurrentLinkedQueue<>());
+        }
+        registerGauges();
+    }
+
+    private void registerGauges() {
+        for (GarbageCollectorMXBean gcBean : gcBeans) {
+            Gauge.builder("app_gc_time_ms_per_hour", this, metrics -> getGCTimePerHour(gcBean))
+                .description("Time spent in garbage collection per hour in milliseconds")
+                .baseUnit("milliseconds")
+                .tag("collector", gcBean.getName())
+                .register(meterRegistry);
+
+            Gauge.builder("app_gc_count_per_hour", this, metrics -> getGCCountPerHour(gcBean))
+                .description("Number of garbage collection cycles per hour")
+                .baseUnit("cycles")
+                .tag("collector", gcBean.getName())
+                .register(meterRegistry);
+        }
+    }
+
+    private double getGCTimePerHour(GarbageCollectorMXBean gcBean) {
+        return getGCTimePerHour(gcBean, Instant.now());
+    }
+
+    double getGCTimePerHour(GarbageCollectorMXBean gcBean, Instant now) {
+        ConcurrentLinkedQueue<GCTimeRecord> history = gcTimeHistory.get(gcBean);
+        long currentGCTime = gcBean.getCollectionTime();
+
+        history.add(new GCTimeRecord(now, currentGCTime));
+        cleanupOldGCTimeRecords(gcBean, now);
+
+        if (history.size() < 2) {
+            return 0.0;
+        }
+
+        GCTimeRecord oldest = history.peek();
+        long timeDiff = currentGCTime - oldest.gcTime;
+        return timeDiff >= 0 ? timeDiff : 0.0;
+    }
+
+    private double getGCCountPerHour(GarbageCollectorMXBean gcBean) {
+        return getGCCountPerHour(gcBean, Instant.now());
+    }
+
+    double getGCCountPerHour(GarbageCollectorMXBean gcBean, Instant now) {
+        ConcurrentLinkedQueue<GCCountRecord> history = gcCountHistory.get(gcBean);
+        long currentGCCount = gcBean.getCollectionCount();
+
+        history.add(new GCCountRecord(now, currentGCCount));
+        cleanupOldGCCountRecords(gcBean, now);
+
+        if (history.size() < 2) {
+            return 0.0;
+        }
+
+        GCCountRecord oldest = history.peek();
+        long countDiff = currentGCCount - oldest.gcCount;
+        return countDiff >= 0 ? countDiff : 0.0;
+    }
+
+    void cleanupOldGCTimeRecords(GarbageCollectorMXBean gcBean, Instant now) {
+        ConcurrentLinkedQueue<GCTimeRecord> history = gcTimeHistory.get(gcBean);
+        Instant threshold = now.minusSeconds(TIME_WINDOW_SECONDS);
+        while (!history.isEmpty() && history.peek().timestamp.isBefore(threshold)) {
+            history.poll();
+        }
+    }
+
+    void cleanupOldGCCountRecords(GarbageCollectorMXBean gcBean, Instant now) {
+        ConcurrentLinkedQueue<GCCountRecord> history = gcCountHistory.get(gcBean);
+        Instant threshold = now.minusSeconds(TIME_WINDOW_SECONDS);
+        while (!history.isEmpty() && history.peek().timestamp.isBefore(threshold)) {
+            history.poll();
+        }
+    }
+
+    private static class GCTimeRecord {
+        final Instant timestamp;
+        final long gcTime;
+
+        GCTimeRecord(Instant timestamp, long gcTime) {
+            this.timestamp = timestamp;
+            this.gcTime = gcTime;
+        }
+    }
+
+    private static class GCCountRecord {
+        final Instant timestamp;
+        final long gcCount;
+
+        GCCountRecord(Instant timestamp, long gcCount) {
+            this.timestamp = timestamp;
+            this.gcCount = gcCount;
+        }
+    }
+}