What Is the Logging Mechanism in *reverse-skill*? Language-Specific Approaches Explained

The reverse-skill repository uses three distinct, language-specific logging mechanisms: Burp Montoya's Logging API for Java, Qiling's ql.log for Python, and Write-Host for PowerShell—rather than a unified cross-language logger.

The reverse-skill repository is a multi-language toolkit for reverse engineering tasks spanning Burp Suite extensions, dynamic analysis scripts, and automation helpers. Understanding its logging mechanism requires examining each component separately, as the project deliberately adopts idiomatic loggers native to each runtime environment.

Java Logging: Burp Montoya API

The Java components—specifically the Burp MCP extension—leverage Burp Suite's official Montoya API for structured logging.

Core Logging Methods

In burp-mcp-full/src/main/java/com/burpmcp/BurpMcpExtension.java, the extension obtains a Logging instance through the Burp API and uses two primary methods:

• logging.logToOutput() — for informational messages
• logging.logToError() — for error conditions

import burp.api.montoya.logging.Logging;

// Initialize during extension startup
this.logging = api.logging();

// Informational logging
logging.logToOutput("[MCP] Server started on http://127.0.0.1:" + port);

// Error logging with exception details
logging.logToError("[MCP] Failed to start server on port " + port
                  + ": " + e.getMessage());

The McpHttpServer.java file demonstrates conditional logging patterns, routing messages to the appropriate stream based on severity. This integrates natively with Burp's Extender > Output and Extender > Errors tabs, providing persistent, timestamped logs visible to security researchers during testing sessions.

Python Logging: Qiling Framework Logger

For dynamic reverse engineering workflows, reverse-skill uses Qiling's built-in logger accessed via ql.log.

Runtime Event Logging

The Python scripts in the documentation files skills/reverse-engineering/tools-dynamic.md and skills/reverse-engineering/tools-advanced.md demonstrate hook-based logging during emulation:

def hook_ptrace(ql, address, args):
    ql.log.info("ptrace bypassed")
    # Force syscall success to evade anti-debugging

    ql.arch.regs.rax = 0

# Address-specific logging

ql.log.info(f"Skipped check at {ql.arch.regs.rip:#x}")

The ql.log object provides standard Python logging levels (debug, info, warning, error, critical) configured through Qiling's emulation context. This approach surfaces runtime behavior—such as syscall interception, memory access patterns, and control-flow changes—without requiring external instrumentation.

PowerShell Logging: Console Output with Color Hints

The PowerShell automation scripts in skills/scripts/ employ a simpler pattern: direct console output via Write-Host with visual status indicators.

Status Function Pattern

Rather than a formal logging framework, these scripts wrap Write-Host in helper functions for consistent visual feedback:

function Ok($msg) {
    Write-Host "[OK] $msg" -ForegroundColor Green
}

function Bad($msg) {
    Write-Host "[FAIL] $msg" -ForegroundColor Red
}

# Usage in automation workflows

Ok "Primary skill loaded"
Bad "Failed to locate required tool"

This console-logging style serves interactive execution scenarios where persistent log files are unnecessary. The color coding provides immediate visual parsing for script operators reviewing terminal output.

Comparison: Why No Unified Logger?

Component	Logger	Output Destination	Persistence
Java (Burp extension)	burp.api.montoya.logging.Logging	Burp Suite Extender tabs	Session-persistent
Python (Qiling scripts)	ql.log	stderr/stdout or configured handlers	Configurable
PowerShell (automation)	Write-Host	Console only	Ephemeral

The reverse-skill maintainers intentionally avoided a custom cross-language logging library. Each component's logger aligns with its ecosystem's conventions: Burp users expect Montoya API integration, Qiling workflows assume ql.log availability, and PowerShell scripts prioritize immediate terminal feedback over structured logging.

Key Implementation Files

• burp-mcp-full/src/main/java/com/burpmcp/BurpMcpExtension.java — Java logging initialization and logToOutput usage
• burp-mcp-full/src/main/java/com/burpmcp/McpHttpServer.java — Conditional error logging with logToError
• skills/reverse-engineering/tools-dynamic.md — Python Qiling logger examples for ptrace hooks
• skills/reverse-engineering/tools-advanced.md — Extended Qiling logging patterns
• skills/scripts/*.ps1 — PowerShell Write-Host implementations

Summary

• Java components use burp.api.montoya.logging.Logging with logToOutput() and logToError() via the Burp Montoya API.
• Python scripts rely on ql.log.info() and related methods from the Qiling emulation framework.
• PowerShell scripts implement lightweight console logging through Write-Host with color-coded status prefixes.
• No unified logging library exists; each language uses its runtime's idiomatic approach for minimal friction and ecosystem compatibility.

Frequently Asked Questions

Does reverse-skill have a centralized logging configuration file?

No. The repository does not implement a cross-language logging layer or centralized configuration. Each component—Java, Python, and PowerShell—configures its logger independently according to runtime conventions.

How can I capture Burp MCP extension logs to a file?

The Burp Montoya API's Logging interface writes to Burp's internal Extender tabs by default. To persist logs externally, modify BurpMcpExtension.java to add a file handler or redirect System.out and System.err before initializing the Logging instance.

Is Qiling's logger configurable for different verbosity levels?

Yes. The ql.log object supports standard Python logging levels. You can adjust verbosity through Qiling's constructor parameters or by accessing ql.log.level directly in your script before emulation begins.

Why doesn't the PowerShell code use Write-Log or a formal logging module?

The PowerShell scripts in reverse-skill target quick automation tasks where console visibility matters more than audit trails. Write-Host provides immediate, color-coded feedback without module dependencies. For production deployments, operators can replace these functions with Start-Transcript or the PSFramework logging module.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}