फोर्क पर आधारित मल्टीप्रोसेसिंग के दौरान मैं अजगर लॉगर्स और हैंडलर की विरासत को कैसे रोक सकता हूं?

Question

मान लीजिए कि मैंने मुख्य प्रक्रिया में लॉगिंग हैंडलर को कॉन्फ़िगर किया है। मुख्य प्रक्रिया कुछ बच्चों को जन्म देती है और os.fork() (लिनक्स में) के कारण सभी लॉगर्स और हैंडलर मुख्य प्रक्रिया से विरासत में प्राप्त होते हैं।

import multiprocessing as mp 
import logging 


def do_log(no): 
    # root logger logs Hello World to stderr (StreamHandler) 
    # BUT I DON'T WANT THAT! 
    logging.getLogger().info('Hello world {}'.format(no)) 


def main(): 
    format = '%(processName)-10s %(name)s %(levelname)-8s %(message)s' 

    # This creates a StreamHandler 
    logging.basicConfig(format=format, level=logging.INFO) 

    n_cores = 4 
    pool = mp.Pool(n_cores) 
    # Log to stdout 100 times concurrently 
    pool.map(do_log, range(100)) 
    pool.close() 
    pool.join() 


if __name__ == '__main__': 
    main() 

इस तरह कुछ प्रिंट होगा: 'Hello World' नीचे दिए गए उदाहरण में कंसोल के लिए 100 बार मुद्रित किया जाएगा

ForkPoolWorker-1 root INFO  Hello world 0 
ForkPoolWorker-3 root INFO  Hello world 14 
ForkPoolWorker-3 root INFO  Hello world 15 
ForkPoolWorker-3 root INFO  Hello world 16 
... 

हालांकि, मैं बच्चे प्रक्रिया सभी लॉगिंग विन्यास के वारिस नहीं करना चाहते माता-पिता से तो do_log से ऊपर के उदाहरण में stderr पर कुछ भी प्रिंट नहीं करना चाहिए क्योंकि StreamHandler नहीं होना चाहिए।

मैं मूल अभिभावक प्रक्रिया में उन्हें हटाने या हटाने के बिना लॉगर्स और हैंडलर को विरासत में कैसे रोकूं?

---

संपादित करें: यह एक अच्छा विचार बस पूल के प्रारंभ में सभी संचालकों को दूर करने के होगा?

def init_logging(): 
    for logger in logging.Logger.manager.loggerDict.values(): 
     if hasattr(logger, 'handlers'): 
      logger.handlers = [] 

और

pool = mp.Pool(n_cores, initializer=init_logging, initargs=()) 

इसके अलावा

, मैं भी सुरक्षित रूप से close() सब (फाइल) प्रारंभ समारोह के दौरान संचालकों कर सकते हैं?

Answer 1

आप इसे रोकने के लिए की जरूरत नहीं है की जाँच करने के लिए कर सकते हैं, तो आप सिर्फ प्रवेश पदानुक्रम पुन: कॉन्फ़िगर करने की जरूरत है।

मुझे लगता है कि आप पूल प्रारंभकर्ता के साथ सही रास्ते पर हैं। लेकिन चीजों को हैक करने की कोशिश करने के बजाय, लॉगिंग पैकेज को जो करने के लिए डिज़ाइन किया गया है उसे करने दें। लॉगिंग पैकेज कार्यकर्ता प्रक्रियाओं में लॉगिंग पदानुक्रम का पुनर्गठन करने दें।

def main(): 

    def configure_logging(): 
     logging_config = { 
      'formatters': { 
       'f': { 
        'format': '%(processName)-10s %(name)s' 
           ' %(levelname)-8s %(message)s', 
       }, 
      }, 
      'handlers': { 
       'h': { 
        'level':'INFO', 
        'class':'logging.StreamHandler', 
        'formatter':'f', 
       }, 
      }, 
      'loggers': { 
       '': { 
        'handlers': ['h'], 
        'level':'INFO', 
        'propagate': True, 
       }, 
      }, 
      'version': 1, 
     } 

     pname = mp.current_process().name 
     if pname != 'MainProcess': 
      logging_config['handlers'] = { 
       'h': { 
        'level':'INFO', 
        'formatter':'f', 
        'class':'logging.FileHandler', 
        'filename': pname + '.log', 
       }, 
      } 

     logging.config.dictConfig(logging_config) 

    configure_logging() # MainProcess 
    def pool_initializer(): 
     configure_logging() 

    n_cores = 4 
    pool = mp.Pool(n_cores, initializer=pool_initializer) 
    pool.map(do_log, range(100)) 
    pool.close() 
    pool.join() 

अब, कार्यकर्ता प्रक्रियाओं को एक अपने व्यक्तिगत लॉग फाइल करने के लिए लॉग इन करेंगे, और अब मुख्य प्रक्रिया के stderr StreamHandler का उपयोग करेगा:

यहाँ एक उदाहरण है।

Answer 2

सबसे सरल जवाब यह है कि आपको शायद multiprocessing के साथ ग्लोबल्स को संशोधित करने से बचना चाहिए। ध्यान दें कि रूट लॉगजर, जिसे आप logging.getLogger() का उपयोग करते हैं, वैश्विक है।

इसके आसपास सबसे आसान तरीका बस प्रत्येक प्रक्रिया के लिए एक नया logging.Logger उदाहरण बना रहा है। आप प्रक्रियाओं के बाद उन्हें नाम कर सकते हैं, या बस बेतरतीब ढंग से:

log= logging.getLogger(str(uuid.uuid4()))

तुम भी how should I log while using multiprocessing in python

Answer 3

आप जरूरत तो कार्यकर्ता प्रक्रियाओं में विरासत में मिला होने से प्रवेश पदानुक्रम को रोकने के लिए, बस लॉगिंग विन्यास कार्यकर्ता पूल बनाने के बाद है।आपके उदाहरण से:

pool = mp.Pool(n_cores) 
logging.basicConfig(format=format, level=logging.INFO) 

फिर, कुछ भी विरासत में नहीं मिलेगा।

अन्यथा, जैसा कि आपने कहा, os.fork() की वजह से, चीजें विरासत/डुप्लीकेट हो जाएंगी। इस मामले में, पूल बनाने के बाद आपके विकल्प लॉगिंग को पुन: कॉन्फ़िगर कर रहे हैं (मेरा अन्य उत्तर देखें), या अन्य (सुझाव) सुझाव/उत्तर।