1. import java.util.ArrayList;
  2. import java.util.HashMap;
  3. import java.util.List;
  4. import java.util.Map;
  6. public class LogFlattener {
  8. /**
  9. * Flattens a nested log entry structure into a single-level map.
  10. * Handles potential null values gracefully.
  11. * @param nestedLog The nested log entry data.
  12. * @return A flattened map representing the log entry.
  13. */
  14. public static Map<String, String> flattenLogEntry(Object nestedLog) {
  15. Map<String, String> flattened = new HashMap<>();
  16. flattenHelper(nestedLog, "", flattened);
  17. return flattened;
  18. }
  20. private static void flattenHelper(Object obj, String prefix, Map<String, String> flattened) {
  21. if (obj == null) {
  22. return; // Handle null values
  23. }
  25. if (obj instanceof Map) {
  26. Map<?, ?> map = (Map<?, ?>) obj;
  27. for (Map.Entry<?, ?> entry : map.entrySet()) {
  28. String key = prefix + entry.getKey().toString();
  29. flattenHelper(entry.getValue(), key + ".", flattened);
  30. }
  31. } else if (obj instanceof List) {
  32. List<?> list = (List<?>) obj;
  33. for (int i = 0; i < list.size(); i++) {
  34. String key = prefix + i;
  35. flattenHelper(list.get(i), key + ".", flattened);
  36. }
  37. } else {
  38. String key = prefix;
  39. flattened.put(key, obj.toString());
  40. }
  41. }
  43. /**
  44. * Simulates a validation check with a fixed retry interval.
  45. * @param logEntry The flattened log entry.
  46. * @param retryCount The number of retry attempts.
  47. * @param retryIntervalMillis The interval between retry attempts in milliseconds.
  48. * @return True if the validation check passes, false otherwise.
  49. */
  50. public static boolean validateLogEntry(Map<String, String> logEntry, int retryCount, long retryIntervalMillis) throws InterruptedException {
  51. // Simulate a validation check. In a real scenario, this would involve
  52. // querying a database, checking a configuration, etc.
  53. if (logEntry.containsKey("status") && logEntry.get("status").equals("error")) {
  54. System.out.println("Validation failed: Status is error.");
  55. if (retryCount > 0) {
  56. System.out.println("Retrying in " + retryIntervalMillis + "ms...");
  57. Thread.sleep(retryIntervalMillis);
  58. return validateLogEntry(logEntry, retryCount - 1, retryIntervalMillis);
  59. } else {
  60. System.out.println("Validation failed after multiple retries.");
  61. return false;
  62. }
  63. } else {
  64. System.out.println("Validation passed.");
  65. return true;
  66. }
  67. }
  69. public static void main(String[] args) {
  70. // Example usage
  71. Object nestedLog = new HashMap<>();
  72. Map<String, String> innerMap = new HashMap<>();
  73. innerMap.put("code", "404");
  74. innerMap.put("message", "Resource not found");
  75. nestedLog.put("status", "error");
  76. nestedLog.put("details", innerMap);
  77. nestedLog.put("tags", new List<>(){
  78. List<String> list = new ArrayList<>();
  79. {
  80. list.add("error");
  81. list.add("resource");
  82. }
  83. });
  85. Map<String, String> flattenedLog = flattenLogEntry(nestedLog);
  87. System.out.println("Flattened Log Entry: " + flattenedLog);
  89. try {
  90. boolean isValid = validateLogEntry(flattenedLog, 3, 1000); // Retry 3 times with 1 second interval
  91. System.out.println("Log entry is valid: " + isValid);
  92. } catch (InterruptedException e) {
  93. e.printStackTrace();
  94. }
  95. }
  96. }

Add your comment