import re
import os
import argparse
from datetime import datetime

def backup_log(file_path):
    """Create a backup of the original log file"""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_path = f"{file_path}.backup_{timestamp}"
    try:
        with open(file_path, 'r') as source, open(backup_path, 'w') as backup:
            backup.write(source.read())
        print(f"Backup created: {backup_path}")
        return True
    except Exception as e:
        print(f"Error creating backup: {e}")
        return False

def clean_log(file_path, process_name=None, pid=None):
    """Remove log entries related to specific process name or PID"""
    if not process_name and not pid:
        print("Error: Please provide either process name or PID")
        return False

    # Create backup before modifying
    if not backup_log(file_path):
        return False

    try:
        # Read the log file
        with open(file_path, 'r') as file:
            log_lines = file.readlines()

        # Counter for removed lines
        removed_count = 0
        cleaned_lines = []

        # Process each line
        for line in log_lines:
            should_remove = False

            if process_name:
                # Check for process name (case insensitive)
                if re.search(process_name, line, re.IGNORECASE):
                    should_remove = True

            if pid:
                # Check for PID
                if str(pid) in line:
                    should_remove = True

            if not should_remove:
                cleaned_lines.append(line)
            else:
                removed_count += 1

        # Write cleaned content back to file
        with open(file_path, 'w') as file:
            file.writelines(cleaned_lines)

        print(f"Cleaning complete. Removed {removed_count} lines.")
        return True

    except Exception as e:
        print(f"Error processing log file: {e}")
        return False

def main():
    # Set up argument parser
    parser = argparse.ArgumentParser(description='Clean log files by removing entries related to specific process or PID')
    parser.add_argument('file_path', help='Path to the log file')
    parser.add_argument('-n', '--name', help='Process name to search for')
    parser.add_argument('-p', '--pid', type=int, help='Process ID to search for')

    args = parser.parse_args()

    # Verify file exists
    if not os.path.exists(args.file_path):
        print(f"Error: File {args.file_path} does not exist")
        return

    # Clean the log file
    clean_log(args.file_path, args.name, args.pid)

if __name__ == "__main__":
    main()

# Clean by process name
python clean_logs.py /var/log/syslog -n apache2

# Clean by PID
python clean_logs.py /var/log/syslog -p 1234

# Clean by both process name and PID
python clean_logs.py /var/log/syslog -n apache2 -p 1234

def is_system_log(file_path):
    """Check if the file is a sensitive system log"""
    sensitive_paths = ['/var/log/syslog', '/var/log/auth.log', '/var/log/kern.log']
    return any(file_path.startswith(path) for path in sensitive_paths)

# Add to the clean_log function:
if is_system_log(file_path):
    confirm = input("Warning: You are about to modify a system log file. Continue? (y/N): ")
    if confirm.lower() != 'y':
        print("Operation cancelled")
        return False

import re
import os
import argparse
from datetime import datetime
import shutil

def backup_file(file_path):
    """Create a backup of the original log file"""
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    backup_path = f"{file_path}.backup_{timestamp}"
    shutil.copy2(file_path, backup_path)
    print(f"Backup created: {backup_path}")
    return backup_path

def clean_log_file(file_path, process_name=None, pid=None, dry_run=False):
    """
    Clean log entries related to specific process name or PID
    
    Args:
        file_path (str): Path to the log file
        process_name (str): Process name to search for
        pid (str): Process ID to search for
        dry_run (bool): If True, only show what would be removed without making changes
    """
    
    if not os.path.exists(file_path):
        print(f"Error: File {file_path} does not exist.")
        return

    if not (process_name or pid):
        print("Error: Either process name or PID must be specified.")
        return

    # Create backup before modifying
    if not dry_run:
        backup_file(file_path)

    # Create patterns for matching
    patterns = []
    if process_name:
        patterns.append(process_name)
    if pid:
        patterns.append(rf'\[?{pid}\]?')

    pattern = '|'.join(patterns)

    # Read the file and filter lines
    try:
        with open(file_path, 'r') as file:
            lines = file.readlines()

        # Keep track of matches
        matched_lines = []
        clean_lines = []

        for line in lines:
            if re.search(pattern, line, re.IGNORECASE):
                matched_lines.append(line)
            else:
                clean_lines.append(line)

        # Print summary
        print(f"\nFound {len(matched_lines)} matching entries")
        
        if dry_run:
            print("\nDry run - showing first 5 matches that would be removed:")
            for line in matched_lines[:5]:
                print(line.strip())
        else:
            # Write cleaned content back to file
            with open(file_path, 'w') as file:
                file.writelines(clean_lines)
            print(f"\nRemoved {len(matched_lines)} entries from {file_path}")

    except Exception as e:
        print(f"Error processing file: {str(e)}")

def main():
    parser = argparse.ArgumentParser(description='Clean log files by removing entries related to specific process or PID')
    parser.add_argument('file', help='Path to the log file')
    parser.add_argument('-n', '--name', help='Process name to search for')
    parser.add_argument('-p', '--pid', help='Process ID to search for')
    parser.add_argument('--dry-run', action='store_true', help='Show what would be removed without making changes')

    args = parser.parse_args()

    clean_log_file(args.file, args.name, args.pid, args.dry_run)

if __name__ == "__main__":
    main()

# Search and remove entries for a specific process name
python log_cleaner.py /var/log/syslog -n httpd

# Search and remove entries for a specific PID
python log_cleaner.py /var/log/syslog -p 1234

# Do a dry run first to see what would be removed
python log_cleaner.py /var/log/syslog -n apache --dry-run

# Search and remove entries matching either process name or PID
python log_cleaner.py /var/log/syslog -n nginx -p 5678

# Add these lines at the start of the script
if os.geteuid() != 0:
    print("This script requires root privileges to modify system logs")
    exit(1)

import os
import re
import shutil
from datetime import datetime

def clean_log_entries(log_path, process_name=None, pid=None, backup=True):
    """
    Remove log entries matching either process name or PID.
    
    Args:
        log_path (str): Path to the log file
        process_name (str): Process name to search for
        pid (str): Process ID to search for
        backup (bool): Create backup before modifying
    """
    if not os.path.exists(log_path):
        print(f"Error: Log file '{log_path}' not found.")
        return False

    # Create backup if requested
    if backup:
        backup_path = f"{log_path}.bak.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        try:
            shutil.copy2(log_path, backup_path)
            print(f"Backup created: {backup_path}")
        except Exception as e:
            print(f"Error creating backup: {str(e)}")
            return False

    # Validate input parameters
    if not process_name and not pid:
        print("Error: Either process_name or pid must be specified")
        return False

    # Create patterns for matching
    patterns = []
    if process_name:
        patterns.append(re.compile(rf'\b{re.escape(process_name)}\b', re.IGNORECASE))
    if pid:
        patterns.append(re.compile(rf'\b{pid}\b'))

    # Process the log file
    temp_path = f"{log_path}.temp"
    entries_removed = 0

    try:
        with open(log_path, 'r') as input_file, open(temp_path, 'w') as output_file:
            for line in input_file:
                # Check if line matches any pattern
                match_found = any(pattern.search(line) for pattern in patterns)
                
                if not match_found:
                    output_file.write(line)
                else:
                    entries_removed += 1

        # Replace original file with cleaned version
        os.replace(temp_path, log_path)
        print(f"Successfully removed {entries_removed} matching entries")
        return True

    except Exception as e:
        print(f"Error processing log file: {str(e)}")
        if os.path.exists(temp_path):
            os.remove(temp_path)
        return False

def main():
    import argparse
    
    parser = argparse.ArgumentParser(description='Clean log entries by process name or PID')
    parser.add_argument('log_path', help='Path to the log file')
    parser.add_argument('--process', help='Process name to search for')
    parser.add_argument('--pid', help='Process ID to search for')
    parser.add_argument('--no-backup', action='store_true', help='Skip creating backup')
    
    args = parser.parse_args()

    if not args.process and not args.pid:
        parser.error("At least one of --process or --pid must be specified")

    clean_log_entries(
        args.log_path,
        process_name=args.process,
        pid=args.pid,
        backup=not args.no_backup
    )

if __name__ == "__main__":
    main()

# Search and remove entries by process name
python clean_logs.py /var/log/syslog --process nginx

# Search and remove entries by PID
python clean_logs.py /var/log/syslog --pid 1234

# Search by both process name and PID
python clean_logs.py /var/log/syslog --process nginx --pid 1234

# Skip creating backup
python clean_logs.py /var/log/syslog --process nginx --no-backup

# Add this to handle multiple log files
def clean_multiple_logs(log_paths, **kwargs):
    results = {}
    for log_path in log_paths:
        results[log_path] = clean_log_entries(log_path, **kwargs)
    return results

# Add date range filtering
def clean_log_entries(log_path, process_name=None, pid=None, 
                     start_date=None, end_date=None, backup=True):
    # Add date parsing logic here
    # Only process lines within the date range

import re
import os
import argparse
from datetime import datetime
import shutil

def backup_file(file_path):
    """Create a backup of the original log file"""
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    backup_path = f"{file_path}.backup_{timestamp}"
    shutil.copy2(file_path, backup_path)
    print(f"Backup created: {backup_path}")
    return backup_path

def remove_entries(file_path, process_name=None, pid=None, dry_run=False):
    """Remove log entries matching the process name or PID"""
    if not os.path.exists(file_path):
        print(f"Error: File {file_path} does not exist")
        return

    # Create backup before modifying
    if not dry_run:
        backup_file(file_path)

    # Compile regex patterns
    patterns = []
    if process_name:
        patterns.append(re.compile(rf'\b{re.escape(process_name)}\b'))
    if pid:
        patterns.append(re.compile(rf'\b{pid}\b'))

    if not patterns:
        print("Error: Please provide either process name or PID")
        return

    # Read and process the file
    matched_lines = 0
    total_lines = 0
    clean_lines = []

    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                total_lines += 1
                match_found = False
                
                for pattern in patterns:
                    if pattern.search(line):
                        matched_lines += 1
                        match_found = True
                        break
                
                if not match_found:
                    clean_lines.append(line)

        # Write cleaned content back to file
        if not dry_run and matched_lines > 0:
            with open(file_path, 'w', encoding='utf-8') as file:
                file.writelines(clean_lines)

        # Print summary
        print(f"\nSummary for {file_path}:")
        print(f"Total lines processed: {total_lines}")
        print(f"Matching lines found: {matched_lines}")
        print(f"Remaining lines: {len(clean_lines)}")
        
        if dry_run:
            print("\nThis was a dry run. No changes were made.")
        else:
            if matched_lines > 0:
                print("\nMatching entries have been removed.")
            else:
                print("\nNo matching entries found. File unchanged.")

    except Exception as e:
        print(f"Error processing file: {str(e)}")

def main():
    parser = argparse.ArgumentParser(description='Clean log files by removing entries matching process name or PID')
    parser.add_argument('file_path', help='Path to the log file')
    parser.add_argument('--process', '-p', help='Process name to search for')
    parser.add_argument('--pid', help='Process ID to search for')
    parser.add_argument('--dry-run', '-d', action='store_true', 
                        help='Perform a dry run without making changes')

    args = parser.parse_args()

    remove_entries(args.file_path, args.process, args.pid, args.dry_run)

if __name__ == "__main__":
    main()

# Remove entries for a specific process name
python log_cleaner.py /var/log/syslog --process apache2

# Remove entries for a specific PID
python log_cleaner.py /var/log/syslog --pid 1234

# Perform a dry run first
python log_cleaner.py /var/log/syslog --process apache2 --dry-run

# Additional error handling for file permissions
try:
    if not os.access(file_path, os.R_OK):
        print(f"Error: No read permission for {file_path}")
        return
    if not os.access(file_path, os.W_OK):
        print(f"Error: No write permission for {file_path}")
        return
except Exception as e:
    print(f"Error checking file permissions: {str(e)}")
    return

def process_large_file(file_path, chunk_size=1024*1024):
    """Process large files in chunks"""
    temp_output = file_path + '.temp'
    with open(file_path, 'r') as input_file, open(temp_output, 'w') as output_file:
        while True:
            chunk = input_file.read(chunk_size)
            if not chunk:
                break
            # Process chunk here
            output_file.write(processed_chunk)
    os.replace(temp_output, file_path)

import os
import re
import argparse
from datetime import datetime
import shutil

def backup_file(file_path):
    """Create a backup of the original log file."""
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    backup_path = f"{file_path}.backup_{timestamp}"
    shutil.copy2(file_path, backup_path)
    print(f"Backup created: {backup_path}")

def clean_log_file(file_path, process_name=None, pid=None):
    """
    Remove log entries related to a specific process name or PID.
    Returns the number of lines removed.
    """
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"Log file not found: {file_path}")

    # Create a backup before modifying
    backup_file(file_path)

    # Create patterns for matching
    patterns = []
    if process_name:
        patterns.append(re.compile(rf'\b{re.escape(process_name)}\b', re.IGNORECASE))
    if pid:
        patterns.append(re.compile(rf'\b{pid}\b'))

    if not patterns:
        raise ValueError("Either process_name or pid must be provided")

    # Read the file and filter out matching lines
    temp_file_path = f"{file_path}.temp"
    lines_removed = 0
    
    try:
        with open(file_path, 'r', encoding='utf-8') as input_file, \
             open(temp_file_path, 'w', encoding='utf-8') as output_file:
            
            for line in input_file:
                match_found = False
                for pattern in patterns:
                    if pattern.search(line):
                        match_found = True
                        lines_removed += 1
                        break
                
                if not match_found:
                    output_file.write(line)

        # Replace original file with cleaned version
        os.replace(temp_file_path, file_path)
        
    except Exception as e:
        # Clean up temp file if it exists
        if os.path.exists(temp_file_path):
            os.remove(temp_file_path)
        raise e

    return lines_removed

def main():
    parser = argparse.ArgumentParser(description='Clean log files by removing entries related to specific process or PID')
    parser.add_argument('log_file', help='Path to the log file')
    parser.add_argument('--process-name', '-p', help='Process name to search for')
    parser.add_argument('--pid', help='Process ID to search for')
    
    args = parser.parse_args()

    try:
        if not args.process_name and not args.pid:
            print("Error: Either --process-name or --pid must be specified")
            return 1

        lines_removed = clean_log_file(
            args.log_file,
            process_name=args.process_name,
            pid=args.pid
        )
        
        print(f"Successfully cleaned log file: {args.log_file}")
        print(f"Lines removed: {lines_removed}")
        return 0

    except Exception as e:
        print(f"Error: {str(e)}")
        return 1

if __name__ == '__main__':
    exit(main())

# Clean by process name
python clean_logs.py /var/log/syslog --process-name nginx

# Clean by PID
python clean_logs.py /var/log/syslog --pid 1234

# Clean by both process name and PID
python clean_logs.py /var/log/syslog --process-name nginx --pid 1234

Backup created: /var/log/syslog.backup_20230615_143022
Successfully cleaned log file: /var/log/syslog
Lines removed: 42