如何读取CMD全部输出并生成带日期时间的日志文件

Got it, let's walk through building this multi-operation program that checks all your boxes. I'll use Python for the example since it's cross-platform, easy to read, and handles all these requirements smoothly.

Just to confirm we're on the same page, your program needs to:

• Output real-time debug messages and completion status for every operation
• Terminate immediately if any error is detected
• Capture all CMD/console output (including debug logs, status updates, and error messages)
• Save everything to a timestamped log file for troubleshooting

1. Set Up Logging & Output Capture #

First, we'll create a way to capture both standard output (stdout) and standard error (stderr) so nothing gets missed. We'll also generate a log filename with the current date and time to avoid overwriting old logs.

2. Implement Operation Logic with Status Tracking #

Each operation will have clear debug messages, and we'll explicitly print whether it succeeded or failed. If any operation throws an error, we'll catch it, log it, and exit immediately.

3. Full Working Example #

import sys
import datetime
from contextlib import contextmanager

# Context manager to capture all console output (logs to file + prints to screen)
@contextmanager
def capture_output():
    old_stdout = sys.stdout
    old_stderr = sys.stderr
    log_file = open(get_log_filename(), 'w')
    try:
        # Create a writer that sends output to both console and log file
        class DualWriter:
            def __init__(self, real_out, log_out):
                self.real_out = real_out
                self.log_out = log_out
            def write(self, data):
                self.real_out.write(data)
                self.log_out.write(data)
            def flush(self):
                self.real_out.flush()
                self.log_out.flush()
        
        sys.stdout = DualWriter(old_stdout, log_file)
        sys.stderr = DualWriter(old_stderr, log_file)
        yield
    finally:
        # Restore original output streams and close the log file
        sys.stdout = old_stdout
        sys.stderr = old_stderr
        log_file.close()

# Generate a unique timestamped log filename
def get_log_filename():
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    return f"program_operation_log_{timestamp}.txt"

# Example operation 1: Simulate successful task
def fetch_source_data():
    print("[DEBUG] Starting operation: Fetching source data from database...")
    # Add your actual operation logic here
    print("[STATUS] Operation completed: Source data fetched successfully")

# Example operation 2: Simulate a failing task
def process_data():
    print("[DEBUG] Starting operation: Processing raw data...")
    # Simulate an unrecoverable error
    raise ValueError("Critical error: Invalid data schema detected - cannot proceed")

# Example operation 3: Won't run due to error in operation 2
def save_processed_results():
    print("[DEBUG] Starting operation: Saving processed results to filesystem...")
    print("[STATUS] Operation completed: Results saved successfully")

if __name__ == "__main__":
    print("=== Program Initialization Complete ===")
    try:
        with capture_output():
            fetch_source_data()
            process_data()  # Triggers error and terminates program
            save_processed_results()  # Never executes
    except Exception as e:
        print(f"[ERROR] Program terminated abruptly: {str(e)}")
        sys.exit(1)

Key Features Explained #

• Dual Output: The DualWriter class ensures you get real-time console feedback and a permanent log file for later debugging
• Unique Logs: get_log_filename() creates a log like program_operation_log_2024-05-20_14-30-45.txt so you never lose old troubleshooting data
• Immediate Termination: Any unhandled exception in an operation is caught, logged, and the program exits with a non-zero status code (signaling failure to the OS)
• Full Capture: All print() statements, debug messages, and error tracebacks are saved to the log file—nothing slips through the cracks

• If you're using another language (like C# or PowerShell), the core logic stays identical: capture output streams, track operation status, handle errors aggressively, and write to a timestamped log.
• For external CMD commands, use your language's subprocess tools (like subprocess.run() in Python) and redirect their output to the same log file to include their output too.

内容的提问来源于stack exchange，提问作者Max S