EasyLog - Intelligent Object Debugging

Michael.I — Fri, 19 Sep 2025 20:34:32 +0000

Why This Matters for Android Development Teams

Debugging consumes 25-50% of Android development time, yet most developers still rely on primitive Log.d() calls that dump unreadable object strings. When you're chasing a bug in production data with nested user profiles, API responses, or complex state objects, parsing User{id=123, profile=Profile{...}} wastes precious mental cycles.

EasyLog transforms Android debugging from a cognitive burden into visual scanning. Instead of mentally parsing object dumps, you see clear hierarchies that immediately reveal data relationships, missing values, and structural issues. This acceleration in issue resolution means less time stuck deciphering logs and more time building features.

The reflection-powered approach handles the tedious work of property inspection, type detection, and formatting that Android developers usually do manually. When complex data hierarchies become immediately comprehensible, production issue investigation that previously required multiple debugging sessions often resolves in a single investigation cycle.

For Android teams, this standardizes debugging output and creates clarity across experience levels. Junior developers get the same clear object visibility as seniors. Code reviews become more efficient when logs are consistently readable. The real value isn't the pretty output - it's reclaiming the mental bandwidth currently wasted on parsing debugging noise, which directly improves Android development velocity and code quality.

Overview

EasyLog transforms Android debugging with reflection-powered object analysis and beautiful tree visualizations. This major release evolves from basic logging utilities to intelligent debugging insights while maintaining complete backward compatibility.

What's New

Tree-Structured Object Visualization

Complex objects now display as readable hierarchies instead of unstructured dumps:

user.logD("User profile")

Before:

User{name='John', age=30, emails=[john@work.com, john@personal.com], preferences=UserPreferences{...}}

After:

🔍 USER PROFILE: at UserService.kt:45
╭─ User (com.example.model)
├─ name: "John"
├─ age: 30
├─ emails: List[2]
│  ├─ [0]: "john@work.com"
│  ╰─ [1]: "john@personal.com"
╰─ preferences: UserPreferences
   ├─ theme: "dark"
   ╰─ notifications: true

Smart Object Detection

Leverages Kotlin's reflection API to automatically detect and format:

Primitive types with appropriate quoting and formatting
Collections with indexing and size information
Nested objects with proper indentation
Arrays with safe handling for primitive types
Null values with clear indication

Runtime Log Level Filtering

Control log verbosity without rebuilding:

// Show only warnings and errors
EasyLog.setMinimumLogLevel(LogType.WARNING)

// Check current filter level
val currentLevel = EasyLog.getMinimumLogLevel()

Grouped Logging

Log related data with unified tree formatting:

logMany(
    header = "API Response Analysis",
    response.statusCode,
    response.headers,
    response.body,
    response.timestamp
)

Enhanced Safety

Robust reflection error handling
Safe primitive array processing
Protection against circular references
Graceful fallback for inaccessible properties

Features Available

Enhanced object formatting (automatic)
minimumLogLevel() configuration option
logMany() function for grouped logging
Improved performance and memory usage

Deprecated APIs

// Still works, but deprecated
.defaultLogger(DefaultLogger.DEFAULT_ANDROID)

// Recommended approach
.addDefaultLogger(DefaultLogger.DEFAULT_ANDROID)

Performance Considerations

EasyLog uses Kotlin reflection for enhanced formatting. Consider these guidelines:

Development: Use full capabilities with detailed object logging

Testing: Leverage complete EasyLog features in staging environments

Production: Configure appropriate log levels (WARNING or higher recommended)

// Production configuration example
EasyLog.setUp {
    debugMode(BuildConfig.DEBUG)
    minimumLogLevel(if (BuildConfig.DEBUG) LogType.DEBUG else LogType.WARNING)
    addDefaultLogger(DefaultLogger.DEFAULT_ANDROID)
}

Requirements

Android API Level: 24+
Kotlin: 1.8.0+
Dependencies: kotlin-reflect (automatically included)

Installation

implementation("com.github.mikeisesele:easylog:4.0.0")

Technical Details

Reflection Usage

Safe property access with exception handling
Optimized for Kotlin data classes and standard collections
Graceful degradation for obfuscated or restricted classes
Memory-efficient processing of large object graphs

Thread Safety

EasyLog is fully thread-safe with synchronized configuration updates and concurrent logging support.

Contributors

Thanks to the Android development community for feedback and suggestions that shaped this release.

Get started at 👉 https://github.com/mikeisesele/easylog
**Issues: GitHub Issues

EasyLog Library

Michael.I — Tue, 04 Jun 2024 05:49:52 +0000

Say hello to consistent and structured logging with EasyLog! 🚀

Enjoy

✨ Context-Aware Logging: Enjoy logs automatically referencing exact call lines and classes.

⚡ Intuitive APIs: Speed up your development process with easy-to-use and concise logging methods.

🛠️ Enhanced Debugging and Data Tracking: Keep your logs organized and efficient, ensuring you can track and analyze data effortlessly.

With great documentation, getting started with EasyLog is easy. Check it out at: https://github.com/mikeisesele/easylog

DEV Community: Michael.I