1. import re
  2. from datetime import datetime
  4. def sort_log_records(log_records, hypothesis_fields):
  5. """
  6. Sorts log records based on specified hypothesis fields,
  7. using fallback logic for missing or invalid fields.
  9. Args:
  10. log_records: A list of strings, where each string is a log record.
  11. hypothesis_fields: A list of strings representing the fields to sort by,
  12. in order of priority.
  14. Returns:
  15. A sorted list of log records. Returns the original list if an error occurs.
  16. """
  18. def parse_log_record(record):
  19. """Parses a log record and extracts field values."""
  20. try:
  21. # Regular expression to extract fields (adapt to your log format)
  22. match = re.match(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}) - (.*) - (.*) - (.*)", record)
  23. if not match:
  24. return None #Or raise an exception, depending on desired behavior
  25. timestamp_str, field1, field2, field3 = match.groups()
  26. return {
  27. "timestamp": datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S,%f"),
  28. "field1": field1.strip(),
  29. "field2": field2.strip(),
  30. "field3": field3.strip()
  31. }
  32. except (ValueError, TypeError) as e:
  33. print(f"Error parsing record: {record}. Error: {e}")
  34. return None # Or raise
  36. def sort_key(record):
  37. """Generates a sort key based on hypothesis fields, with fallback."""
  38. if record is None: # Handle records that couldn't be parsed
  39. return (datetime.min, "", "") #Place invalid records at the beginning
  41. sort_values = []
  42. for field in hypothesis_fields:
  43. try:
  44. sort_values.append(getattr(record, field)) #Access record attributes
  45. except AttributeError:
  46. sort_values.append("") #Fallback to empty string if field is missing
  47. except Exception as e:
  48. print(f"Error accessing field {field}: {e}")
  49. sort_values.append("") #Fallback to empty string
  51. return tuple(sort_values) #Convert to tuple for consistent comparison
  53. parsed_records = [parse_log_record(record) for record in log_records]
  55. #Filter out any records that failed parsing
  56. valid_records = [r for r in parsed_records if r is not None]
  58. if not valid_records:
  59. print("No valid records found after parsing. Returning original list.")
  60. return log_records
  62. sorted_records = sorted(valid_records, key=sort_key)
  64. return sorted_records

Add your comment