🔍 Code Extractor

A base class that provides namespaced logging functionality to subclasses through a lazy-initialized class-level logger.

Purpose

LoggerContext serves as a superclass for any class that needs logging capabilities. It implements a lazy-loading pattern for loggers with automatic namespace generation based on the module and class name. The logger is shared across all instances of a class (class-level), and supports creating child loggers for specific methods. This design ensures consistent logging hierarchies and avoids redundant logger creation.

Source Code

class LoggerContext:
    """Superclass for all classes that require namespaced logger."""

    _logger = None

    @classmethod
    def logger(cls, method=None):
        if cls._logger is None:
            logger_name = cls.__module__ + "." + cls.__name__
            cls._logger = logging.getLogger(logger_name)

        if method is not None:
            return cls._logger.getChild(method)
        return cls._logger

Parameters

Parameter Details

__init__: This class does not define an __init__ method. It is intended to be inherited by other classes that may define their own constructors.

method (in logger classmethod): Optional string parameter specifying a method name. When provided, returns a child logger namespaced to that method. When None, returns the base class logger.

Return Value

The class itself doesn't return anything on instantiation (no custom __init__). The logger() classmethod returns a logging.Logger instance. If 'method' parameter is None, it returns the class-level logger with namespace '<module>.<classname>'. If 'method' is provided, it returns a child logger with namespace '<module>.<classname>.<method>'.

Class Interface

Methods

Attributes

Dependencies

• logging

Required Imports

import logging

Usage Example

import logging

# Configure logging at application level
logging.basicConfig(level=logging.INFO, format='%(name)s - %(levelname)s - %(message)s')

class MyService(LoggerContext):
    def __init__(self, name):
        self.name = name
    
    def process_data(self, data):
        # Get logger for this specific method
        logger = self.logger('process_data')
        logger.info(f'Processing data: {data}')
        return data.upper()
    
    def save_result(self, result):
        # Get class-level logger
        logger = self.logger()
        logger.info(f'Saving result: {result}')

# Usage
service = MyService('DataProcessor')
service.process_data('hello')  # Logs: __main__.MyService.process_data - INFO - Processing data: hello
service.save_result('HELLO')   # Logs: __main__.MyService - INFO - Saving result: HELLO

# Logger is shared across instances
service2 = MyService('AnotherProcessor')
print(service.logger() is service2.logger())  # True - same logger instance

Best Practices

• This class is designed to be inherited, not instantiated directly. Use it as a base class for any class that needs logging.
• The logger is initialized lazily on first access and cached at the class level, meaning all instances of a subclass share the same logger instance.
• Use the 'method' parameter when calling logger() from within methods to create hierarchical log namespaces that make it easier to trace log messages.
• Configure the logging module at the application entry point before using LoggerContext subclasses to ensure proper log formatting and output.
• The logger namespace is automatically generated as '<module>.<classname>', which helps organize logs in large applications.
• Since _logger is a class variable, it's shared across all instances of the same class but separate for different subclasses.
• Do not modify _logger directly; always use the logger() classmethod to access the logger instance.
• The lazy initialization pattern means the logger is only created when first accessed, reducing overhead for classes that may not always need logging.

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• class RequestUserContext 47.0% similar

  Represents the user context for the current SharePoint request, providing access to user information and context details typically available at the /_api/me endpoint.

  From: /tf/active/vicechatdev/SPFCsync/venv/lib64/python3.11/site-packages/office365/sharepoint/request_user_context.py

• class SharePointHomeServiceContextBuilder 43.6% similar

  A builder class for creating SharePoint Home Service contexts, inheriting from Entity and providing methods to construct and retrieve service context objects.

  From: /tf/active/vicechatdev/SPFCsync/venv/lib64/python3.11/site-packages/office365/sharepoint/portal/home/service_context_builder.py

• class ComponentContextInfo 43.5% similar

  A wrapper class for SharePoint's ContextInfo object, specifically designed for internal use with client-side components.

  From: /tf/active/vicechatdev/SPFCsync/venv/lib64/python3.11/site-packages/office365/sharepoint/clientsidecomponent/component_context_info.py

• class OrgLabelsContext 43.1% similar

  OrgLabelsContext is a client value class representing organizational labels context in SharePoint Portal, inheriting from ClientValue base class.

  From: /tf/active/vicechatdev/SPFCsync/venv/lib64/python3.11/site-packages/office365/sharepoint/portal/orglabels/context.py

• class ClientContext 42.9% similar

  SharePoint client context (SharePoint v1 API)

  From: /tf/active/vicechatdev/SPFCsync/venv/lib64/python3.11/site-packages/office365/sharepoint/client_context.py