पायथन में मल्टीप्रोसेसिंग-अवेयर लॉगिंग कैसे लागू करें

पायथन में मल्टीप्रोसेसिंग कई प्रक्रियाओं के निर्माण की अनुमति देती है जो स्वतंत्र रूप से चलती हैं। हालाँकि, लॉग फ़ाइलों जैसे साझा संसाधनों तक पहुँचना जटिल हो सकता है क्योंकि कई प्रक्रियाएँ उन्हें एक साथ लिखने का प्रयास कर सकती हैं।

इस समस्या से बचने के लिए, पायथन मल्टीप्रोसेसिंग मॉड्यूल मॉड्यूल-स्तरीय मल्टीप्रोसेसिंग-जागरूक लॉगिंग क्षमताएं प्रदान करता है। यह लॉगर को यह सुनिश्चित करके लॉग संदेशों की गड़बड़ी को रोकने में सक्षम बनाता है कि एक समय में केवल एक प्रक्रिया एक विशिष्ट फ़ाइल डिस्क्रिप्टर को लिखती है।

हालांकि, फ्रेमवर्क के भीतर मौजूदा मॉड्यूल मल्टीप्रोसेसिंग-जागरूक नहीं हो सकते हैं, जिससे आवश्यकता होती है वैकल्पिक समाधान के लिए. एक दृष्टिकोण में एक कस्टम लॉग हैंडलर बनाना शामिल है जो एक पाइप के माध्यम से मूल प्रक्रिया में लॉगिंग संदेश भेजता है।

इस दृष्टिकोण का कार्यान्वयन नीचे दिया गया है:

from logging.handlers import RotatingFileHandler
import multiprocessing, threading, logging, sys, traceback

class MultiProcessingLog(logging.Handler):
    def __init__(self, name, mode, maxsize, rotate):
        logging.Handler.__init__(self)

        # Set up the file handler for the parent process
        self._handler = RotatingFileHandler(name, mode, maxsize, rotate)
        
        # Create a queue to receive log messages from child processes
        self.queue = multiprocessing.Queue(-1)
        
        # Start a thread in the parent process to receive and log messages
        t = threading.Thread(target=self.receive)
        t.daemon = True
        t.start()

    def receive(self):
        while True:
            try:
                # Get a log record from the queue
                record = self.queue.get()
                
                # Log the record using the parent process's file handler
                self._handler.emit(record)
            # Exit the thread if an exception is raised
            except (KeyboardInterrupt, SystemExit):
                raise
            except EOFError:
                break
            except:
                traceback.print_exc(file=sys.stderr)

    def send(self, s):
        # Put the log record into the queue for the receiving thread
        self.queue.put_nowait(s)

    def _format_record(self, record):
        # Stringify any objects in the record to ensure that they can be sent over the pipe
        if record.args:
            record.msg = record.msg % record.args
            record.args = None
        if record.exc_info:
            dummy = self.format(record)
            record.exc_info = None
            
        return record

    def emit(self, record):
        try:
            # Format and send the log record through the pipe
            s = self._format_record(record)
            self.send(s)
        except (KeyboardInterrupt, SystemExit):
            raise
        except:
            self.handleError(record)

    def close(self):
        # Close the file handler and the handler itself
        self._handler.close()
        logging.Handler.close(self)

यह कस्टम लॉग हैंडलर फ्रेमवर्क के भीतर मॉड्यूल को मल्टीप्रोसेसिंग-जागरूक हुए बिना मानक लॉगिंग प्रथाओं का उपयोग करने की अनुमति देता है। लॉग संदेश चाइल्ड प्रक्रियाओं से मूल प्रक्रिया में एक पाइप के माध्यम से भेजे जाते हैं, यह सुनिश्चित करते हुए कि वे विकृत नहीं हैं और लॉग फ़ाइल में सही ढंग से लिखे गए हैं।