import os
import re

def delete_log_entries(log_file_path, search_term):
    try:
        # Read the log file
        with open(log_file_path, 'r') as file:
            lines = file.readlines()
        
        # Filter lines that do not contain the search term
        filtered_lines = []
        for line in lines:
            if not re.search(r'\b' + re.escape(search_term) + r'\b', line):
                filtered_lines.append(line)
        
        # Write the filtered lines back to the log file
        with open(log_file_path, 'w') as file:
            file.writelines(filtered_lines)
        
        print(f"Processed {log_file_path}. Removed entries related to '{search_term}'.")
    
    except FileNotFoundError:
        print(f"Error: The log file {log_file_path} does not exist.")
    except Exception as e:
        print(f"An error occurred while processing {log_file_path}: {e}")

def search_and_delete_logs(log_directory, process_name_or_pid):
    # Walk through all files in the specified directory
    for root, _, files in os.walk(log_directory):
        for file_name in files:
            # Assuming log files usually have .log extension, change this if needed
            if file_name.endswith('.log'):
                file_path = os.path.join(root, file_name)
                delete_log_entries(file_path, process_name_or_pid)

# Example usage
if __name__ == "__main__":
    dir_to_search = "/var/log"  # Change this path to the directory containing your log files
    process_identifier = "process_name_or_pid"  # Replace with the actual process name or PID you're targeting
    search_and_delete_logs(dir_to_search, process_identifier)

import os
import re

def search_and_delete_logs(log_file_path, search_term):
    # Temporary file to store log entries that do not match the search term
    temp_file_path = log_file_path + ".tmp"

    try:
        with open(log_file_path, 'r') as log_file, open(temp_file_path, 'w') as temp_file:
            for line in log_file:
                if search_term not in line:
                    temp_file.write(line)

        # Replace the original log file with the temporary file
        os.replace(temp_file_path, log_file_path)
        print(f"Finished cleaning {log_file_path}. Removed entries containing '{search_term}'.")
    except Exception as e:
        print(f"An error occurred while processing {log_file_path}: {e}")
        # Clean up the temporary file in case of an error
        if os.path.exists(temp_file_path):
            os.remove(temp_file_path)

def process_logs(log_dir, search_term):
    # Iterate over each file in the directory
    for log_filename in os.listdir(log_dir):
        log_file_path = os.path.join(log_dir, log_filename)

        # Skip if it's not a file (e.g., it's a directory)
        if not os.path.isfile(log_file_path):
            continue

        # Process only `.log` files - adjust as needed
        if log_filename.endswith('.log'): 
            search_and_delete_logs(log_file_path, search_term)

if __name__ == "__main__":
    # Specify the directory containing your log files
    log_directory = "/var/log"

    # Enter the process name or PID you want to search for
    search_term = input("Enter the process name or PID to search for: ")

    # Call the function to process logs
    process_logs(log_directory, search_term)

import re
import shutil
import os

def clean_log_file(log_file_path, process_name=None, pid=None):
    if not os.path.isfile(log_file_path):
        print("Specified log file does not exist.")
        return
    
    # Take a backup of the original log file
    backup_log_file_path = log_file_path + ".bak"
    shutil.copy(log_file_path, backup_log_file_path)
    print(f"Backup of the log file created at: {backup_log_file_path}")
    
    try:
        with open(log_file_path, 'r') as file:
            lines = file.readlines()
        
        with open(log_file_path, 'w') as file:
            for line in lines:
                # Skip lines that match process name or PID
                if process_name and process_name in line:
                    continue
                if pid and re.search(r'\b' + re.escape(str(pid)) + r'\b', line):
                    continue
                file.write(line)

        print("Log file cleaned successfully.")

    except Exception as e:
        print(f"An error occurred: {e}")
        # Restore the backup in case of error
        shutil.copy(backup_log_file_path, log_file_path)
        print("Restored from backup due to error.")

if __name__ == "__main__":
    # Example usage
    log_file_path = "/var/log/example.log"  # Path to your log file
    process_name = "my_process"             # Name of the process to remove
    pid = 1234                              # PID to remove

    clean_log_file(log_file_path, process_name=process_name, pid=pid)

import os
import re

def search_and_delete_logs(log_file_path, identifier):
    """
    Search and delete log entries that match a specific process name or PID.

    :param log_file_path: Path to the log file
    :param identifier: Process name or PID to search for
    :return: None
    """
    try:
        with open(log_file_path, 'r') as file:
            lines = file.readlines()

        # Regular expression to find lines containing the process name or PID
        regex_pattern = re.compile(rf'\b{re.escape(identifier)}\b')

        # Filter out lines matching the identifier
        new_lines = [line for line in lines if not regex_pattern.search(line)]

        # Write the filtered lines back to the file
        with open(log_file_path, 'w') as file:
            file.writelines(new_lines)

        print(f"Entries related to '{identifier}' have been deleted from {log_file_path}.")

    except FileNotFoundError:
        print(f"Log file {log_file_path} not found.")
    except PermissionError:
        print(f"Permission denied when accessing {log_file_path}.")
    except Exception as e:
        print(f"An error occurred: {e}")

def main():
    # Specify the path of the log file
    log_file_path = '/var/log/syslog'  # Change this to the path of your log file

    # Specify the process name or PID to search for
    identifier = input("Enter the process name or PID to delete from logs: ")

    if os.path.exists(log_file_path):
        search_and_delete_logs(log_file_path, identifier)
    else:
        print(f"The log file {log_file_path} does not exist.")

if __name__ == "__main__":
    main()

import os
import re

def backup_file(filename):
    backup_filename = filename + ".bak"
    with open(filename, 'r') as original, open(backup_filename, 'w') as backup:
        backup.write(original.read())
    print(f"Backup of {filename} created at {backup_filename}")

def filter_log_entries(filename, process_name=None, pid=None):
    # Regular expressions to match the process name or pid
    if process_name:
        process_pattern = re.compile(r'\b%s\b' % re.escape(process_name))
    else:
        process_pattern = None

    if pid:
        pid_pattern = re.compile(r'\b%s\b' % re.escape(str(pid)))
    else:
        pid_pattern = None

    with open(filename, 'r') as file:
        lines = file.readlines()

    with open(filename, 'w') as file:
        for line in lines:
            # Check if the line contains the process_name or pid
            if process_pattern and process_pattern.search(line):
                continue
            if pid_pattern and pid_pattern.search(line):
                continue
            file.write(line)

def clean_log_files(log_directory, process_name=None, pid=None):
    # Filter and delete log entries for each file in the directory
    for root, dirs, files in os.walk(log_directory):
        for file in files:
            if file.endswith('.log'):
                full_path = os.path.join(root, file)
                print(f"Processing {full_path}")
                backup_file(full_path)
                filter_log_entries(full_path, process_name, pid)

if __name__ == "__main__":
    log_directory = "/var/log"  # Replace with the path of your log files
    process_name_to_filter = "your_process_name"  # Replace with the process name you want to search
    pid_to_filter = 1234  # Replace with the PID you want to search

    clean_log_files(log_directory, process_name=process_name_to_filter, pid=pid_to_filter)