tinydbg Logging System Design

Multi-level Debugger and Logging Challenges

Modern debuggers are complex systems, typically containing multiple layers and components such as core debugging engines, RPC communication layers, function call handling, stack traces, etc. In such complex systems, without a well-designed logging system, the following problems can arise:

1. Difficulty in Problem Location: When issues occur in the debugger, it's challenging to quickly identify which layer or component is affected
2. Logging Chaos: Logs from different layers are mixed together, lacking clear classification and identification
3. Incomplete Information: Missing critical context information, making it difficult to understand the specific scenarios where logs are generated
4. Performance Impact: Improper logging can affect the debugger's performance

Therefore, a well-designed logging system is crucial for the development and maintenance of debuggers.

tinydbg's Logging System Design

tinydbg's logging system is implemented based on Go 1.21's slog package with customized design. Its core design features are as follows:

Hierarchical Log Classification

tinydbg divides logs into multiple layers, each corresponding to different components of the debugger:

• debugger: Core debugger layer logs
• debuglineerr: DWARF line number information processing related error logs
• rpc: RPC communication layer logs
• fncall: Function call related logs
• stack: Stack trace related logs

This classification gives logs a clear hierarchical structure, facilitating problem location and analysis.

Flexible Log Configuration

The logging system provides flexible configuration options:

1. Log Switch Control:

   • Can globally enable/disable logging
   • Can individually control logging switches for each layer

2. Log Output Targets:

   • Supports output to file descriptors
   • Supports output to file paths
   • Default output to standard error

3. Log Levels:

   • Supports Debug, Info, Warn, Error levels
   • Each layer can independently set its log level

Structured Log Format

The logging system adopts a structured log format, with each log entry containing:

1. Timestamp: Using RFC3339 format
2. Log Level: In lowercase form (debug/info/warn/error)
3. Context Attributes: Displayed in key=value format
4. Log Message: Specific log content

Example log format:

2024-03-21T10:30:45Z debug layer=debugger,kind=fncall message content

Custom Handler Implementation

tinydbg implements a custom textHandler that:

1. Overrides the slog.Handler interface
2. Optimizes the log formatting process
3. Supports attribute pre-formatting for better performance
4. Implements flexible log level control

Convenient Logging Interfaces

Provides two sets of convenient logging interfaces:

1. Formatting Interfaces:

   • Debugf/Infof/Warnf/Errorf: Supports formatted strings

2. Direct Interfaces:

   • Debug/Info/Warn/Error: Direct parameter output

Each layer provides corresponding Logger retrieval functions, such as:

• LogDebuggerLogger()
• LogDebugLineLogger()
• RPCLogger()
• FnCallLogger()
• StackLogger()

Summary

tinydbg's logging system design fully considers the characteristics and requirements of debuggers:

1. Hierarchical Design: Through clear layer division, logs have better readability and maintainability
2. Flexibility: Provides rich configuration options to meet different scenario requirements
3. Performance Optimization: Ensures logging doesn't affect debugger performance through mechanisms like pre-formatting
4. Usability: Provides simple and intuitive interfaces for developers

This design not only improves the maintainability of the debugger but also provides strong support for problem diagnosis and performance analysis. In practical use, developers can quickly locate issues, understand system behavior, and improve development efficiency.