Skip to main content
Version: 4.2

Koin Tooling and Performance Monitoring

Kotzilla, the company backing Koin, not only drives its ongoing development but also builds powerful tools to empower Kotlin developers.

Koin Built-in Monitoring​

Koin provides built-in tracing and monitoring capabilities through raw logging, which is useful for development but not practical for production applications.

Features​

  • Module Verification - Validate your Koin configuration at compile-time or runtime
  • Tracing API - Track dependency resolution and lifecycle events
  • Performance Metrics - Monitor injection performance and memory usage
  • Logging - Built-in logger support (SLF4J, Android, etc.)
startKoin {
    // Enable detailed logging (development only)
    printLogger(Level.DEBUG)

    // Your modules
    modules(appModule)
}
warning

Raw Logs: Built-in monitoring uses raw console/logcat output, which is suitable for development debugging but not for production apps. For production-ready monitoring with dashboards, metrics, and analytics, see the Kotzilla Platform section below.

info

Learn More: See Koin Built-in Tracing & Monitoring for complete documentation on built-in monitoring features.

External Development Tools​

Koin Plugin for Android Studio & IntelliJ IDEA​

info

The pragmatic Kotlin and Kotlin Multiplatform Dependency Injection framework now with native support for IntelliJ IDEA and Android Studio.

Features:

  • Code Navigation - Navigate between DSL/Annotations configuration and source code
    • Jump from definition declarations to injection points and vice versa
    • Navigate to usages of definitions across your codebase
  • Live Safety Checks - Real-time configuration validation
    • Verify that definitions match their usage sites
    • Catch configuration errors before runtime
  • Definitions & Modules View - Tree view of your Koin configuration
    • Visualize all modules and their definitions
    • Understand your dependency graph structure
  • Issues Detection - Comprehensive error reporting
    • Local issues view for configuration problems
    • Kotzilla-detected issues integration
  • Multiplatform Support - Works with KMP projects

Download: Jetbrains Marketplace

Quick Start with IDE Plugin​

After installing the plugin:

  1. Open your Koin module files (.kt files with module { } declarations)
  2. Use Ctrl+Click (Cmd+Click on Mac) to navigate bidirectionally:
    • From injection point → definition
    • From definition → usages
  3. Check the Definitions/Modules tool window to visualize your Koin structure
  4. Monitor the Issues panel for configuration safety warnings
  5. Get live feedback as you modify your Koin configuration

Production Monitoring & Analytics​

Crash Reporting & Performance Monitoring with Kotzilla Platform​

info

Console-based suite with connected cloud services that visualizes your Koin module structure, monitors runtime performance and memory metrics, provides advanced debugging and tracing, and seamlessly integrates with Kotlin Multiplatform projects.

Features:

  • Visual Module Structure - See your dependency graph in real-time
  • Runtime Performance Monitoring - Track injection performance in production
  • Memory Metrics - Identify memory leaks and optimize resource usage
  • Advanced Debugging - Step-by-step dependency resolution traces
  • Crash Reporting - Koin-specific crash analysis and reporting
  • KMP Integration - Full support for multiplatform projects
  • Production Analytics - Understand how your app uses dependencies in the wild

Sign Up: Free signup on Kotzilla

Getting Started with Kotzilla​

  1. Sign up for a free account at kotzilla.io

  2. Install the SDK in your project:

    dependencies {
        implementation("io.kotzilla:kotzilla-sdk:$kotzilla_version")
    }

  3. Configure your Koin application with the analytics() function:

    Android:

    startKoin {
        analytics()  // Setup Kotzilla SDK
        modules(appModule)
    }

    Android & Compose with KoinApplication():

    KoinApplication(
        application = { analytics() }  // Setup Kotzilla SDK
    ) {
        // Your composables
    }

    Compose Multiplatform:

    startKoin {
        analytics()  // Setup Kotzilla SDK
        modules(appModule)
    }

  4. Deploy your app and view metrics in the Kotzilla dashboard

info

Platform-Specific Setup Guides:

Testing Tools​

Module Verification​

Koin provides multiple approaches to verify your modules:

1. Runtime Verification (Koin Test API)

class ModuleCheckTest : KoinTest {

    @Test
    fun checkKoinModules() {
        koinApplication {
            modules(appModule)
            checkModules()
        }
    }
}

2. Compile-Time Safety (Koin Annotations)

@Module
@ComponentScan("com.myapp")
class AppModule

With Koin Annotations and KSP, your configuration is verified at compile time, catching errors before runtime.

info

Learn More: See Injecting in Tests for complete testing documentation.

note

Coming Soon: The Kotzilla team is actively working on comprehensive CI/CD support for all tooling, expanding beyond the current Koin Test API and Koin Annotations compile-time safety.

Choosing the Right Tools​

ToolBest ForPlatform Support
Built-in MonitoringDevelopment debugging (raw logs) - enhanced by Kotzilla SDKAll platforms
IDE PluginCode navigation, live safety checks, visualizationAndroid, JVM, KMP
Kotzilla PlatformProduction monitoring, crash reporting, analyticsAndroid, iOS, JVM, KMP
Testing ToolsRuntime/compile-time verificationAll platforms
tip

Recommended Setup:

  • Use IDE Plugin during development for navigation and live safety checks
  • Use Built-in Monitoring for local debugging (raw logs) - enhanced and visualized by Kotzilla Platform SDK
  • Use Koin Annotations for compile-time safety (optional)
  • Use Kotzilla Platform for production-ready monitoring, dashboards, and analytics
  • Use Testing Tools in CI/CD pipelines to catch configuration errors early

Resources​