1. import java.util.*;
  2. import java.util.concurrent.*;
  3. import java.time.Instant;
  4. import java.time.Duration;
  6. public class TimestampAnomalyDetector {
  8. private final int windowSize; // Time window for anomaly detection (in seconds)
  9. private final int maxRequestsPerWindow; // Maximum requests allowed within the window
  10. private final Queue<Long> timestamps; // Queue to store timestamps
  11. private final Semaphore semaphore; // Semaphore for rate limiting
  12. private final List<TimestampAnomaly> anomalies; // List to store detected anomalies
  15. public TimestampAnomalyDetector(int windowSize, int maxRequestsPerWindow) {
  16. this.windowSize = windowSize;
  17. this.maxRequestsPerWindow = maxRequestsPerWindow;
  18. this.timestamps = new LinkedList<>();
  19. this.semaphore = new Semaphore(maxRequestsPerWindow);
  20. this.anomalies = new ArrayList<>();
  21. }
  23. public synchronized boolean allowRequest() throws InterruptedException {
  24. semaphore.acquire(); // Acquire a permit from the semaphore (rate limiting)
  25. return true;
  26. }
  28. public synchronized void releaseRequest() {
  29. semaphore.release(); // Release the permit
  30. }
  33. public TimestampAnomaly detectAnomalies() {
  34. // Process timestamps and detect anomalies
  35. long currentTime = Instant.now().getEpochSecond();
  37. // Remove timestamps outside the current window
  38. while (!timestamps.isEmpty() && (currentTime - timestamps.peek() > windowSize)) {
  39. timestamps.poll();
  40. }
  42. // Check if the number of timestamps exceeds the rate limit
  43. if (timestamps.size() > maxRequestsPerWindow) {
  44. List<TimestampAnomaly> anomaly = new ArrayList<>();
  45. anomaly.add(new TimestampAnomaly("Timestamp Exceeded Rate Limit", timestamps.size(), currentTime));
  46. anomalies.addAll(anomaly);
  47. timestamps.clear(); // Reset the timestamps
  48. return anomaly.get(0);
  49. }
  51. return null; // No anomaly detected
  52. }
  55. public void addTimestamp(long timestamp) throws InterruptedException {
  56. // Add a new timestamp to the queue
  57. timestamps.offer(timestamp);
  59. // Simulate processing time
  60. try {
  61. Thread.sleep(100); // Simulate some processing time
  62. } catch (InterruptedException e) {
  63. Thread.currentThread().interrupt();
  64. }
  65. }
  68. public List<TimestampAnomaly> getAnomalies() {
  69. return anomalies;
  70. }
  72. // Inner class to represent a timestamp anomaly
  73. public static class TimestampAnomaly {
  74. private final String message;
  75. private final int count;
  76. private final long timestamp;
  78. public TimestampAnomaly(String message, int count, long timestamp) {
  79. this.message = message;
  80. this.count = count;
  81. this.timestamp = timestamp;
  82. }
  84. public String getMessage() {
  85. return message;
  86. }
  88. public int getCount() {
  89. return count;
  90. }
  92. public long getTimestamp() {
  93. return timestamp;
  94. }
  95. }
  99. public static void main(String[] args) throws InterruptedException {
  100. // Example usage
  101. TimestampAnomalyDetector detector = new TimestampAnomalyDetector(60, 10); // 60 seconds window, 10 requests/window
  103. for (int i = 0; i < 15; i++) {
  104. long timestamp = Instant.now().getEpochSecond() - (15 - i) * 30; // Generate timestamps
  105. detector.addTimestamp(timestamp);
  107. TimestampAnomaly anomaly = detector.detectAnomalies();
  108. if (anomaly != null) {
  109. System.out.println("Anomaly detected: " + anomaly.getMessage() + " at timestamp: " + anomaly.getTimestamp());
  110. }
  111. Thread.sleep(500);
  112. }
  114. List<TimestampAnomaly> allAnomalies = detector.getAnomalies();
  115. System.out.println("Total Anomalies: " + allAnomalies.size());
  116. }
  117. }

Add your comment