@Data
public class TimeBucket {
    private final AtomicLong totalCount = new AtomicLong(0);
    private final AtomicLong successCount = new AtomicLong(0);
    private final AtomicLong failCount = new AtomicLong(0);
    private final LongAdder totalTime = new LongAdder();
    private volatile long maxTime = 0;
    private volatile long minTime = Long.MAX_VALUE;
    private final long bucketStartTime;
    private volatile long lastUpdateTime;

    public TimeBucket(long bucketStartTime) {
        this.bucketStartTime = bucketStartTime;
        this.lastUpdateTime = System.currentTimeMillis();
    }

    public synchronized void record(long duration, boolean success) {
        totalCount.incrementAndGet();
        if (success) {
            successCount.incrementAndGet();
        } else {
            failCount.incrementAndGet();
        }
        
        totalTime.add(duration);
        maxTime = Math.max(maxTime, duration);
        minTime = Math.min(minTime, duration);
        lastUpdateTime = System.currentTimeMillis();
    }

    public double getAvgTime() {
        long total = totalCount.get();
        return total == 0 ? 0.0 : (double) totalTime.sum() / total;
    }

    public double getSuccessRate() {
        long total = totalCount.get();
        return total == 0 ? 0.0 : (double) successCount.get() / total * 100;
    }
}

@Data
public class HierarchicalMethodMetrics {
    
    // 基礎(chǔ)統(tǒng)計(jì)信息
    private final AtomicLong totalCount = new AtomicLong(0);
    private final AtomicLong successCount = new AtomicLong(0);
    private final AtomicLong failCount = new AtomicLong(0);
    private final LongAdder totalTime = new LongAdder();
    private volatile long maxTime = 0;
    private volatile long minTime = Long.MAX_VALUE;
    private final String methodName;

    // 分級(jí)時(shí)間桶
    private final ConcurrentHashMap<Long, TimeBucket> secondBuckets = new ConcurrentHashMap<>();  // 最近5分鐘，秒級(jí)
    private final ConcurrentHashMap<Long, TimeBucket> minuteBuckets = new ConcurrentHashMap<>();  // 最近1小時(shí)，分鐘級(jí)
    private final ConcurrentHashMap<Long, TimeBucket> hourBuckets = new ConcurrentHashMap<>();    // 最近24小時(shí)，小時(shí)級(jí)
    private final ConcurrentHashMap<Long, TimeBucket> dayBuckets = new ConcurrentHashMap<>();     // 最近7天，天級(jí)

    public synchronized void record(long duration, boolean success) {
        long currentTime = System.currentTimeMillis();
        
        // 更新基礎(chǔ)統(tǒng)計(jì)
        totalCount.incrementAndGet();
        if (success) {
            successCount.incrementAndGet();
        } else {
            failCount.incrementAndGet();
        }
        totalTime.add(duration);
        maxTime = Math.max(maxTime, duration);
        minTime = Math.min(minTime, duration);

        // 分級(jí)記錄到不同時(shí)間桶
        recordToTimeBuckets(currentTime, duration, success);
        
        // 清理過(guò)期桶
        cleanupExpiredBuckets(currentTime);
    }

    public TimeRangeMetrics queryTimeRange(long startTime, long endTime) {
        List<TimeBucket.TimeBucketSnapshot> buckets = selectBucketsForTimeRange(startTime, endTime);
        return aggregateSnapshots(buckets, startTime, endTime);
    }
}

@Slf4j
@Aspect
@Component
public class MethodMetricsAspect {
    
    private final ConcurrentHashMap<String, HierarchicalMethodMetrics> metricsMap = new ConcurrentHashMap<>();

    @Around("@within(org.springframework.web.bind.annotation.RestController) || " +
            "@within(org.springframework.stereotype.Controller)")
    public Object recordMetrics(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = buildMethodName(joinPoint);
        long startTime = System.nanoTime();
        boolean success = true;
        
        try {
            Object result = joinPoint.proceed();
            return result;
        } catch (Throwable throwable) {
            success = false;
            throw throwable;
        } finally {
            long duration = (System.nanoTime() - startTime) / 1_000_000; // Convert to milliseconds
            
            metricsMap.computeIfAbsent(methodName, HierarchicalMethodMetrics::new)
                     .record(duration, success);
        }
    }

    private String buildMethodName(ProceedingJoinPoint joinPoint) {
        String className = joinPoint.getTarget().getClass().getSimpleName();
        String methodName = joinPoint.getSignature().getName();
        return className + "." + methodName + "()";
    }

    public Map<String, HierarchicalMethodMetrics> getMetricsSnapshot() {
        return new ConcurrentHashMap<>(metricsMap);
    }
}

@RestController
@RequestMapping("/api/metrics")
@RequiredArgsConstructor
public class MetricsController {
    
    private final MethodMetricsAspect metricsAspect;

    @GetMapping
    public Map<String, Object> getMetrics(
            @RequestParam(required = false) Long startTime,
            @RequestParam(required = false) Long endTime,
            @RequestParam(required = false) String methodFilter) {
        
        Map<String, Object> result = new HashMap<>();
        Map<String, HierarchicalMethodMetrics> snapshot = metricsAspect.getMetricsSnapshot();
        
        // 應(yīng)用接口名過(guò)濾
        if (StringUtils.hasText(methodFilter)) {
            snapshot = snapshot.entrySet().stream()
                    .filter(entry -> entry.getKey().toLowerCase().contains(methodFilter.toLowerCase()))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        }
        
        // 時(shí)間范圍查詢
        if (startTime != null && endTime != null) {
            snapshot.forEach((methodName, metrics) -> {
                HierarchicalMethodMetrics.TimeRangeMetrics timeRangeMetrics = 
                        metrics.queryTimeRange(startTime, endTime);
                Map<String, Object> metricData = buildTimeRangeMetricData(timeRangeMetrics);
                result.put(methodName, metricData);
            });
        } else {
            // 全量數(shù)據(jù)
            snapshot.forEach((methodName, metrics) -> {
                Map<String, Object> metricData = buildMetricData(metrics);
                result.put(methodName, metricData);
            });
        }
        
        return result;
    }

    @GetMapping("/recent/{minutes}")
    public Map<String, Object> getRecentMetrics(
            @PathVariable int minutes,
            @RequestParam(required = false) String methodFilter) {
        
        long endTime = System.currentTimeMillis();
        long startTime = endTime - (minutes * 60L * 1000L);
        
        return getMetrics(startTime, endTime, methodFilter);
    }

    @GetMapping("/summary")
    public Map<String, Object> getSummary(
            @RequestParam(required = false) Long startTime,
            @RequestParam(required = false) Long endTime,
            @RequestParam(required = false) String methodFilter) {
        
        // 匯總統(tǒng)計(jì)邏輯
        Map<String, HierarchicalMethodMetrics> snapshot = metricsAspect.getMetricsSnapshot();
        // ... 匯總計(jì)算
        return summary;
    }
}

@Service
@RequiredArgsConstructor
public class MetricsCleanupService {

    private final MethodMetricsAspect metricsAspect;

    @Value("${dashboard.metrics.max-age:3600000}")
    private long maxAge;

    @Scheduled(fixedRateString = "${dashboard.metrics.cleanup-interval:300000}")
    public void cleanupStaleMetrics() {
        try {
            metricsAspect.removeStaleMetrics(maxAge);
            int currentMethodCount = metricsAspect.getMetricsSnapshot().size();
            log.info("Metrics cleanup completed. Current methods being monitored: {}", currentMethodCount);
        } catch (Exception e) {
            log.error("Error during metrics cleanup", e);
        }
    }
}

function metricsApp() {
    return {
        metrics: {},
        summary: {},
        timeRange: 'all',
        methodFilter: '',
        
        // 時(shí)間范圍設(shè)置
        setTimeRange(range) {
            this.timeRange = range;
            this.updateTimeRangeText();
            if (range !== 'custom') {
                this.fetchMetrics();
                this.fetchSummary();
            }
        },

        // 構(gòu)建API查詢URL
        buildApiUrl(endpoint) {
            let url = `/api/metrics${endpoint}`;
            const params = new URLSearchParams();
            
            // 添加時(shí)間參數(shù)
            if (this.timeRange !== 'all') {
                if (this.timeRange === 'custom') {
                    if (this.customStartTime && this.customEndTime) {
                        params.append('startTime', new Date(this.customStartTime).getTime());
                        params.append('endTime', new Date(this.customEndTime).getTime());
                    }
                } else {
                    const endTime = Date.now();
                    const startTime = endTime - (this.timeRange * 60 * 1000);
                    params.append('startTime', startTime);
                    params.append('endTime', endTime);
                }
            }
            
            // 添加搜索參數(shù)
            if (this.methodFilter.trim()) {
                params.append('methodFilter', this.methodFilter.trim());
            }
            
            return params.toString() ? url + '?' + params.toString() : url;
        },

        // 獲取監(jiān)控?cái)?shù)據(jù)
        async fetchMetrics() {
            this.loading = true;
            try {
                const response = await fetch(this.buildApiUrl(''));
                this.metrics = await response.json();
                this.lastUpdate = new Date().toLocaleTimeString();
            } catch (error) {
                console.error('Failed to fetch metrics:', error);
            } finally {
                this.loading = false;
            }
        }
    };
}

server:
  port: 8080

spring:
  application:
    name: springboot-api-dashboard
  aop:
    auto: true
    proxy-target-class: true

# 監(jiān)控配置
dashboard:
  metrics:
    cleanup-interval: 300000  # 清理間隔：5分鐘
    max-age: 3600000         # 最大存活時(shí)間：1小時(shí)
    debug-enabled: false     # 調(diào)試模式

logging:
  level:
    com.example.dashboard: INFO

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

mvn clean install
mvn spring-boot:run

# 獲取所有監(jiān)控?cái)?shù)據(jù)
curl http://localhost:8080/api/metrics

# 獲取最近5分鐘的數(shù)據(jù)
curl http://localhost:8080/api/metrics/recent/5

# 按時(shí)間范圍和接口名篩選
curl "http://localhost:8080/api/metrics?startTime=1640995200000&endTime=1641000000000&methodFilter=user"

# 獲取匯總統(tǒng)計(jì)
curl http://localhost:8080/api/metrics/summary

# 清空監(jiān)控?cái)?shù)據(jù)
curl -X DELETE http://localhost:8080/api/metrics