How to use the mitogen.core.LOG.debug function in mitogen

def _on_exit(self, msg, arg):
        LOG.debug('on_exit: proc = %r', self.proc)
        if self.proc:
            self.proc.terminate()
        else:
            self.router.broker.shutdown()

def _on_broker_exit(self):
        super(Router, self)._on_broker_exit()
        dct = self.get_stats()
        dct['self'] = self
        dct['minify_ms'] = 1000 * dct['minify_secs']
        dct['get_module_ms'] = 1000 * dct['get_module_secs']
        dct['good_load_module_size_kb'] = dct['good_load_module_size'] / 1024.0
        dct['good_load_module_size_avg'] = (
            (
                dct['good_load_module_size'] /
                (float(dct['good_load_module_count']) or 1.0)
            ) / 1024.0
        )

        LOG.debug(
            '%(self)r: stats: '
                '%(get_module_count)d module requests in '
                '%(get_module_ms)d ms, '
                '%(good_load_module_count)d sent '
                '(%(minify_ms)d ms minify time), '
                '%(bad_load_module_count)d negative responses. '
                'Sent %(good_load_module_size_kb).01f kb total, '
                '%(good_load_module_size_avg).01f kb avg.'
            % dct
        )

context_id = self._router.id_allocator.allocate()
        context = mitogen.parent.Context(self._router, context_id)
        stream = mitogen.core.Stream(self._router, context_id)
        stream.name = u'unix_client.%d' % (pid,)
        stream.auth_id = mitogen.context_id
        stream.is_privileged = True

        try:
            sock.send(struct.pack('>LLL', context_id, mitogen.context_id,
                                  os.getpid()))
        except socket.error:
            LOG.error('%r: failed to assign identity to PID %d: %s',
                      self, pid, sys.exc_info()[1])
            return

        LOG.debug('%r: accepted %r', self, stream)
        stream.accept(sock.fileno(), sock.fileno())
        self._router.register(context, stream)

def allocate_block(self):
        """
        Allocate a block of IDs for use in a child context.

        This function is safe to call from any thread.

        :returns:
            Tuple of the form `(id, end_id)` where `id` is the first usable ID
            and `end_id` is the last usable ID.
        """
        self.lock.acquire()
        try:
            id_ = self.next_id
            self.next_id += self.BLOCK_SIZE
            end_id = id_ + self.BLOCK_SIZE
            LOG.debug('%r: allocating [%d..%d)', self, id_, end_id)
            return id_, end_id
        finally:
            self.lock.release()

forwarded = self._forwarded_by_context.get(context)
        if forwarded is None:
            forwarded = set()
            self._forwarded_by_context[context] = forwarded

        if fullname in forwarded:
            return

        path = []
        while fullname:
            path.append(fullname)
            fullname, _, _ = str_rpartition(fullname, u'.')

        stream = self._router.stream_by_id(context.context_id)
        if stream is None:
            LOG.debug('%r: dropping forward of %s to no longer existent '
                      '%r', self, path[0], context)
            return

        for fullname in reversed(path):
            self._send_module_and_related(stream, fullname)
            self._send_forward_module(stream, context, fullname)

def find(self, fullname):
        """
        Find `fullname` using its :data:`__file__` attribute.
        """
        module = sys.modules.get(fullname)
        LOG.debug('_get_module_via_sys_modules(%r) -> %r', fullname, module)
        if getattr(module, '__name__', None) != fullname:
            LOG.debug('sys.modules[%r].__name__ does not match %r, assuming '
                      'this is a hacky module alias and ignoring it',
                      fullname, fullname)
            return

        if not isinstance(module, types.ModuleType):
            LOG.debug('%r: sys.modules[%r] absent or not a regular module',
                      self, fullname)
            return

        path = _py_filename(getattr(module, '__file__', ''))
        if not path:
            return

        LOG.debug('%r: sys.modules[%r]: found %s', self, fullname, path)
        is_pkg = hasattr(module, '__path__')
        try:
            source = inspect.getsource(module)
        except IOError:
            # Work around inspect.getsourcelines() bug for 0-byte __init__.py
            # files.
            if not is_pkg:
                raise

def _send_module_and_related(self, stream, fullname):
        if fullname in stream.protocol.sent_modules:
            return

        try:
            tup = self._build_tuple(fullname)
            for name in tup[4]:  # related
                parent, _, _ = str_partition(name, '.')
                if parent != fullname and parent not in stream.protocol.sent_modules:
                    # Parent hasn't been sent, so don't load submodule yet.
                    continue

                self._send_load_module(stream, name)
            self._send_load_module(stream, fullname)
        except Exception:
            LOG.debug('While importing %r', fullname, exc_info=True)
            self._send_module_load_failed(stream, fullname)

def __init__(self, router, path=None, backlog=100):
        self._router = router
        self.path = path or make_socket_path()
        self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

        if os.path.exists(self.path) and is_path_dead(self.path):
            LOG.debug('%r: deleting stale %r', self, self.path)
            os.unlink(self.path)

        self._sock.bind(self.path)
        os.chmod(self.path, int('0600', 8))
        self._sock.listen(backlog)
        self.receive_side = mitogen.core.Side(self, self._sock.fileno())
        router.broker.start_receive(self)

def find(self, fullname):
        """
        See implementation for a description of how this works.
        """
        if fullname not in sys.modules:
            # Don't attempt this unless a module really exists in sys.modules,
            # else we could return junk.
            return

        pkgname, _, modname = str_rpartition(to_text(fullname), u'.')
        pkg = sys.modules.get(pkgname)
        if pkg is None or not hasattr(pkg, '__file__'):
            LOG.debug('%r: %r is not a package or lacks __file__ attribute',
                      self, pkgname)
            return

        pkg_path = [os.path.dirname(pkg.__file__)]
        try:
            fp, path, (suffix, _, kind) = imp.find_module(modname, pkg_path)
        except ImportError:
            e = sys.exc_info()[1]
            LOG.debug('%r: imp.find_module(%r, %r) -> %s',
                      self, modname, [pkg_path], e)
            return None

        if kind == imp.PKG_DIRECTORY:
            return self._found_package(fullname, path)
        else:
            return self._found_module(fullname, path, fp)

if getattr(module, '__name__', None) != fullname:
            LOG.debug('sys.modules[%r].__name__ does not match %r, assuming '
                      'this is a hacky module alias and ignoring it',
                      fullname, fullname)
            return

        if not isinstance(module, types.ModuleType):
            LOG.debug('%r: sys.modules[%r] absent or not a regular module',
                      self, fullname)
            return

        path = _py_filename(getattr(module, '__file__', ''))
        if not path:
            return

        LOG.debug('%r: sys.modules[%r]: found %s', self, fullname, path)
        is_pkg = hasattr(module, '__path__')
        try:
            source = inspect.getsource(module)
        except IOError:
            # Work around inspect.getsourcelines() bug for 0-byte __init__.py
            # files.
            if not is_pkg:
                raise
            source = '\n'

        if isinstance(source, mitogen.core.UnicodeType):
            # get_source() returns "string" according to PEP-302, which was
            # reinterpreted for Python 3 to mean a Unicode string.
            source = source.encode('utf-8')

        return path, source, is_pkg