<div>
Following is some code from __init__.py 
 

<pre><code class="code-10 nolinks" id="code-20-42993499-1">Logger = logging.getLoggerClass()
class BBLogger(Logger):
 def __init__(self, name):
 if name.split(&quot;.&quot;)[0] == &quot;BitBake&quot;:
 self.debug = self.bbdebug
 Logger.__init__(self, name)

 def bbdebug(self, level, msg, *args, **kwargs):
 return self.log(logging.DEBUG - level + 1, msg, *args, **kwargs)

 def plain(self, msg, *args, **kwargs):
 return self.log(logging.INFO + 1, msg, *args, **kwargs)

 def verbose(self, msg, *args, **kwargs):
 return self.log(logging.INFO - 1, msg, *args, **kwargs)

 def verbnote(self, msg, *args, **kwargs):
 return self.log(logging.INFO + 2, msg, *args, **kwargs)


logging.raiseExceptions = False
logging.setLoggerClass(BBLogger)

logger = logging.getLogger(&quot;BitBake&quot;)
logger.addHandler(NullHandler())
logger.setLevel(logging.DEBUG - 2)

mainlogger = logging.getLogger(&quot;BitBake.Main&quot;)

# This has to be imported after the setLoggerClass, as the import of bb.msg
# can result in construction of the various loggers.
import bb.msg

from bb import fetch2 as fetch
sys.modules['bb.fetch'] = sys.modules['bb.fetch2']
</code></pre>
</div>

<div>
logging.getLoggerClass() returns an instantiated logger yes. Here is a few examples and explanations on how to use it. 
 
<a href="https://www.programcreek.com/python/example/10123/logging.getLoggerClass" rel="ugc">https://www.programcreek.com/python/example/10123/logging.getLoggerClass</a>
</div>

naseeam

<div>
&gt;&gt; &nbsp;<a href="https://www.programcreek.com/python/example/10123/logging.getLoggerClass" rel="ugc">https://www.programcreek.com/python/example/10123/logging.getLoggerClass</a> 
I went through these explanations previously but couldn't understand. &nbsp; 
Please provide few complete working examples that use getLoggerClass( ), setLoggerClass( ), and class BBLogger(Logger) in __init__.py file. 
There seems to be some connections between getLoggerClass( ), setLoggerClass( ), and class BBLogger(Logger) ? 
Following is entire __init__.py file. 
 
__init__.py 

<pre><code class="code-100 nolinks" id="code-20-42993565-1"># ex:ts=4:sw=4:sts=4:et
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
#
# BitBake Build System Python Library
#
# Copyright (C) 2003 Holger Schurig
# Copyright (C) 2003, 2004 Chris Larson
#
# Based on Gentoo's portage.py.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

__version__ = &quot;1.40.0&quot;

import sys
if sys.version_info &lt; (3, 4, 0):
 raise RuntimeError(&quot;Sorry, python 3.4.0 or later is required for this version of bitbake&quot;)


class BBHandledException(Exception):
 &quot;&quot;&quot;
 The big dilemma for generic bitbake code is what information to give the user
 when an exception occurs. Any exception inheriting this base exception class
 has already provided information to the user via some 'fired' message type such as
 an explicitly fired event using bb.fire, or a bb.error message. If bitbake 
 encounters an exception derived from this class, no backtrace or other information 
 will be given to the user, its assumed the earlier event provided the relevant information.
 &quot;&quot;&quot;
 pass

import os
import logging


class NullHandler(logging.Handler):
 def emit(self, record):
 pass

Logger = logging.getLoggerClass()
class BBLogger(Logger):
 def __init__(self, name):
 if name.split(&quot;.&quot;)[0] == &quot;BitBake&quot;:
 self.debug = self.bbdebug
 Logger.__init__(self, name)

 def bbdebug(self, level, msg, *args, **kwargs):
 return self.log(logging.DEBUG - level + 1, msg, *args, **kwargs)

 def plain(self, msg, *args, **kwargs):
 return self.log(logging.INFO + 1, msg, *args, **kwargs)

 def verbose(self, msg, *args, **kwargs):
 return self.log(logging.INFO - 1, msg, *args, **kwargs)

 def verbnote(self, msg, *args, **kwargs):
 return self.log(logging.INFO + 2, msg, *args, **kwargs)


logging.raiseExceptions = False
logging.setLoggerClass(BBLogger)

logger = logging.getLogger(&quot;BitBake&quot;)
logger.addHandler(NullHandler())
logger.setLevel(logging.DEBUG - 2)

mainlogger = logging.getLogger(&quot;BitBake.Main&quot;)

# This has to be imported after the setLoggerClass, as the import of bb.msg
# can result in construction of the various loggers.
import bb.msg

from bb import fetch2 as fetch
sys.modules['bb.fetch'] = sys.modules['bb.fetch2']

# Messaging convenience functions
def plain(*args):
 mainlogger.plain(''.join(args))

def debug(lvl, *args):
 if isinstance(lvl, str):
 mainlogger.warning(&quot;Passed invalid debug level '%s' to bb.debug&quot;, lvl)
 args = (lvl,) + args
 lvl = 1
 mainlogger.debug(lvl, ''.join(args))

def note(*args):
 mainlogger.info(''.join(args))

#
# A higher prioity note which will show on the console but isn't a warning
#
# Something is happening the user should be aware of but they probably did
# something to make it happen
#
def verbnote(*args):
 mainlogger.verbnote(''.join(args))

#
# Warnings - things the user likely needs to pay attention to and fix
#
def warn(*args):
 mainlogger.warning(''.join(args))

def error(*args, **kwargs):
 mainlogger.error(''.join(args), extra=kwargs)

def fatal(*args, **kwargs):
 mainlogger.critical(''.join(args), extra=kwargs)
 raise BBHandledException()

def deprecated(func, name=None, advice=&quot;&quot;):
 &quot;&quot;&quot;This is a decorator which can be used to mark functions
 as deprecated. It will result in a warning being emitted
 when the function is used.&quot;&quot;&quot;
 import warnings

 if advice:
 advice = &quot;: %s&quot; % advice
 if name is None:
 name = func.__name__

 def newFunc(*args, **kwargs):
 warnings.warn(&quot;Call to deprecated function %s%s.&quot; % (name,
 advice),
 category=DeprecationWarning,
 stacklevel=2)
 return func(*args, **kwargs)
 newFunc.__name__ = func.__name__
 newFunc.__doc__ = func.__doc__
 newFunc.__dict__.update(func.__dict__)
 return newFunc

# For compatibility
def deprecate_import(current, modulename, fromlist, renames = None):
 &quot;&quot;&quot;Import objects from one module into another, wrapping them with a DeprecationWarning&quot;&quot;&quot;
 import sys

 module = __import__(modulename, fromlist = fromlist)
 for position, objname in enumerate(fromlist):
 obj = getattr(module, objname)
 newobj = deprecated(obj, &quot;{0}.{1}&quot;.format(current, objname),
 &quot;Please use {0}.{1} instead&quot;.format(modulename, objname))
 if renames:
 newname = renames[position]
 else:
 newname = objname

 setattr(sys.modules[current], newname, newobj)
</code></pre>
</div>

<div>
&gt;&gt; <a href="https://www.programcreek.com/python/example/10123/logging.getLoggerClass" rel="ugc">https://www.programcreek.com/python/example/10123/logging.getLoggerClass</a> 
Each example is a python function. &nbsp;Please use an example to code python program that logs some events to console. &nbsp; And please provide explanation of code.
</div>

<div>
I'm afraid you will have to research that. I simply don't have time to do it right now. Are you locked into using that logger or could you use the standard python logger?
</div>

<div>
&gt;&gt; Are you locked into using that logger 
I just want to understand that logger
</div>

<div>
Following is part of /usr/lib/python3.6/logging/__init__.py 
 
When above bitbake code calls def getLoggerClass( ) below, _loggerClass is returned. &nbsp;_loggerClass = Logger &nbsp; &nbsp; What is Logger? 
 
In above code, logging.setLoggerClass(BBLogger) is called. &nbsp;In below code in def setLoggerClass(klass), how is BBLogger subclass of Logger? 
 
 
 
 

<pre><code class="code-10 nolinks" id="code-20-42993668-1">#---------------------------------------------------------------------------
# Level related stuff
#---------------------------------------------------------------------------
#
# Default levels and level names, these can be replaced with any positive set
# of values having corresponding names. There is a pseudo-level, NOTSET, which
# is only really there as a lower limit for user-defined levels. Handlers and
# loggers are initialized with NOTSET so that they will log all messages, even
# at user-defined levels.
#

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0


#
# Determine which class to use when instantiating loggers.
#

def setLoggerClass(klass):
 &quot;&quot;&quot;
 Set the class to be used when instantiating a logger. The class should
 define __init__() such that only a name argument is required, and the
 __init__() should call Logger.__init__()
 &quot;&quot;&quot;
 if klass != Logger:
 if not issubclass(klass, Logger):
 raise TypeError(&quot;logger not derived from logging.Logger: &quot;
 + klass.__name__)
 global _loggerClass
 _loggerClass = klass

def getLoggerClass():
 &quot;&quot;&quot;
 Return the class to be used when instantiating a logger.
 &quot;&quot;&quot;
 return _loggerClass



class RootLogger(Logger):
 &quot;&quot;&quot;
 A root logger is not that different to any other logger, except that
 it must have a logging level and there is only one instance of it in
 the hierarchy.
 &quot;&quot;&quot;
 def __init__(self, level):
 &quot;&quot;&quot;
 Initialize the logger with the name &quot;root&quot;.
 &quot;&quot;&quot;
 Logger.__init__(self, &quot;root&quot;, level)

_loggerClass = Logger


root = RootLogger(WARNING)
Logger.root = root
Logger.manager = Manager(Logger.root)
</code></pre>
</div>

<div>
Please confirm my understanding: 
 
The purpose of getLoggerClass( ) and setLoggerClass( ) is to use application class for logging. &nbsp;Besides using Logger class from python standard library, application also uses it's own class for logging. 
There are Three ways I know to setup logging system: 

<ol type="1">
<li> &nbsp;call logging.getLogger( ) to use default logger from python standard library</li>
<li> &nbsp;call logging.getLogger(&lt;name&gt;) to use custom logger from python standard library</li>
<li> &nbsp;call logging.getLoggerClass( ) so Logger Class from python standard library is returned to application. &nbsp;Application will derive from this Logger Class. &nbsp;Call logging.setLoggerClass(&lt;Application derived class&gt;) to inform python standard library that application wants to use it's own class for logging. &nbsp; Then, when application calls logging.getLogger(&lt;name&gt;), application derived class is instantiated, which includes all the logging features of python standard library parent class Logger.</li>
</ol>
</div>

<div>
<div class="content wysiwyg-content">
I'm using python version 3.6.8. &nbsp; 
 
I'm looking at large python project. &nbsp;In beginning of __init__.py, there is following statement: 
 

<pre><code class="code-1 nolinks" id="code-10-29166553-1">Logger = logging.getLoggerClass()
</code></pre>
Is getLoggerClass a class? &nbsp;Is above code instantiating this class? 
What is the purpose of above code?
</div>
</div>

I'm using python version 3.6.8.  

I'm looking at large python project.  In beginning of __init__.py, there is following statement:

(CODE)
Is getLoggerClass a class?  Is above code instantiating this class? 
What is the purpose of above code?

What is logging.getLoggerClass() ?

Python is a widely used general-purpose, high-level programming language. Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than would be possible in other languages. Python supports multiple programming paradigms, including object-oriented, imperative and functional programming or procedural styles. It features a dynamic type system and automatic memory management and has a large and comprehensive set of standard libraries, including NumPy, SciPy, Django, PyQuery, and PyLibrary.