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

> Explore the reverse-skill logging mechanism with language-specific approaches for Java, Python, and PowerShell. Understand how Burp Montoya, Qiling, and Write-Host facilitate logging in this technical guide.

- Repository: [ZhaoXu/reverse-skill](https://github.com/zhaoxuya520/reverse-skill)
- Tags: how-to-guide
- Published: 2026-08-04

---

**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*](https://github.com/zhaoxuya520/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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/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

```java
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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/reverse-engineering/tools-dynamic.md) and [`skills/reverse-engineering/tools-advanced.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/reverse-engineering/tools-advanced.md) demonstrate hook-based logging during emulation:

```python
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:

```powershell
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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/burp-mcp-full/src/main/java/com/burpmcp/McpHttpServer.java)** — Conditional error logging with `logToError`
- **[`skills/reverse-engineering/tools-dynamic.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/reverse-engineering/tools-dynamic.md)** — Python Qiling logger examples for ptrace hooks
- **[`skills/reverse-engineering/tools-advanced.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/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`](https://github.com/zhaoxuya520/reverse-skill/blob/main/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.