Index

appimage_updater.instrumentation

HTTP instrumentation package.

HTTPTracker(stack_depth=3, track_headers=False, logger=None)

Tracks HTTP requests made during application execution.

Parameters:

Name	Type	Description	Default
stack_depth	int	Number of stack frames to capture for call stack	3
track_headers	bool	Whether to track request headers	False
logger	Any	HTTP logger interface (defaults to ConfigurableHTTPLogger)	None

Source code in src/appimage_updater/instrumentation/http_tracker.py

def __init__(self, stack_depth: int = 3, track_headers: bool = False, logger: Any = None):
    """Initialize HTTP request tracker.

    Args:
        stack_depth: Number of stack frames to capture for call stack
        track_headers: Whether to track request headers
        logger: HTTP logger interface (defaults to ConfigurableHTTPLogger)
    """
    self.stack_depth = stack_depth
    self.track_headers = track_headers
    self.requests: list[HTTPRequestRecord] = []
    self._original_request: Any = None
    self._patcher: Any = None

    # Set up logger with dependency injection
    if logger is None:
        self._logger = create_default_http_logger()
    else:
        self._logger = logger

requests = [] instance-attribute

stack_depth = stack_depth instance-attribute

track_headers = track_headers instance-attribute

start_tracking()

Start tracking HTTP requests.

Source code in src/appimage_updater/instrumentation/http_tracker.py

def start_tracking(self) -> None:
    """Start tracking HTTP requests."""
    if self._patcher:
        self._logger.warning("HTTP tracking is already active")
        return

    self._logger.log_tracking_start(f"Starting HTTP request tracking (stack depth: {self.stack_depth})")

    # Store original method and create wrapper
    self._original_request = httpx.AsyncClient.request

    # Create a wrapper that captures the self parameter
    async def request_wrapper(client_self: Any, method: str, url: str, **kwargs: Any) -> Any:
        return await self._tracked_request(client_self, method, url, **kwargs)

    # Patch the method (type: ignore for monkey patching)
    httpx.AsyncClient.request = request_wrapper  # type: ignore[method-assign,assignment]
    self._patcher = True  # Just use as a flag

stop_tracking()

Stop tracking HTTP requests.

Source code in src/appimage_updater/instrumentation/http_tracker.py

def stop_tracking(self) -> None:
    """Stop tracking HTTP requests."""
    if not self._patcher:
        self._logger.warning("HTTP tracking is not active")
        return

    self._logger.log_tracking_stop("Stopping HTTP request tracking")

    # Restore original method
    if self._original_request:
        httpx.AsyncClient.request = self._original_request  # type: ignore[method-assign]
    self._patcher = None
    self._original_request = None

create_default_http_logger(verbose=False)

Create default HTTP logger with appropriate verbosity.

Parameters:

Name	Type	Description	Default
verbose	bool	If True, use info level for tracking messages	False

Returns:

Type	Description
ConfigurableHTTPLogger	Configured HTTP logger

Source code in src/appimage_updater/instrumentation/logging_interface.py

def create_default_http_logger(verbose: bool = False) -> ConfigurableHTTPLogger:
    """Create default HTTP logger with appropriate verbosity.

    Args:
        verbose: If True, use info level for tracking messages

    Returns:
        Configured HTTP logger
    """
    base_logger = LoguruHTTPLogger()

    if verbose:
        return ConfigurableHTTPLogger(base_logger, tracking_level="info", request_level="debug", error_level="warning")
    else:
        return ConfigurableHTTPLogger(base_logger, tracking_level="debug", request_level="debug", error_level="debug")

create_http_tracker_from_params(params)

Create HTTP tracker based on command parameters.

Parameters:

Name	Type	Description	Default
params	CheckParams	Command parameters containing HTTP instrumentation settings	required

Returns:

Type	Description
HTTPTracker | None	HTTPTracker instance if instrumentation is enabled, None otherwise

Source code in src/appimage_updater/instrumentation/factory.py

def create_http_tracker_from_params(params: CheckParams) -> HTTPTracker | None:
    """Create HTTP tracker based on command parameters.

    Args:
        params: Command parameters containing HTTP instrumentation settings

    Returns:
        HTTPTracker instance if instrumentation is enabled, None otherwise
    """
    if not params.instrument_http:
        return None

    # Create logger based on debug level
    logger = create_default_http_logger(verbose=True) if params.debug else create_default_http_logger(verbose=False)

    return HTTPTracker(stack_depth=params.http_stack_depth, track_headers=params.http_track_headers, logger=logger)

create_silent_http_logger()

Create silent HTTP logger for testing.

Source code in src/appimage_updater/instrumentation/logging_interface.py

def create_silent_http_logger() -> SilentHTTPLogger:
    """Create silent HTTP logger for testing."""
    return SilentHTTPLogger()

create_silent_http_tracker(stack_depth=3, track_headers=False)

Create HTTP tracker with silent logging for testing.

Parameters:

Name	Type	Description	Default
stack_depth	int	Number of stack frames to capture	3
track_headers	bool	Whether to track request headers	False

Returns:

Type	Description
HTTPTracker	HTTPTracker with silent logging

Source code in src/appimage_updater/instrumentation/factory.py

def create_silent_http_tracker(stack_depth: int = 3, track_headers: bool = False) -> HTTPTracker:
    """Create HTTP tracker with silent logging for testing.

    Args:
        stack_depth: Number of stack frames to capture
        track_headers: Whether to track request headers

    Returns:
        HTTPTracker with silent logging
    """
    silent_logger = create_silent_http_logger()
    return HTTPTracker(stack_depth=stack_depth, track_headers=track_headers, logger=silent_logger)

create_verbose_http_tracker(stack_depth=3, track_headers=False)

Create HTTP tracker with verbose logging.

Parameters:

Name	Type	Description	Default
stack_depth	int	Number of stack frames to capture	3
track_headers	bool	Whether to track request headers	False

Returns:

Type	Description
HTTPTracker	HTTPTracker with verbose logging

Source code in src/appimage_updater/instrumentation/factory.py

def create_verbose_http_tracker(stack_depth: int = 3, track_headers: bool = False) -> HTTPTracker:
    """Create HTTP tracker with verbose logging.

    Args:
        stack_depth: Number of stack frames to capture
        track_headers: Whether to track request headers

    Returns:
        HTTPTracker with verbose logging
    """
    verbose_logger = create_default_http_logger(verbose=True)
    return HTTPTracker(stack_depth=stack_depth, track_headers=track_headers, logger=verbose_logger)