Skip to main content

Kotzilla Console

The Kotzilla Console is a web-based environment that helps you analyze and resolve issues in your Kotlin and Kotlin Multiplatform (KMP) applications. It provides a comprehensive suite of tools for detecting, investigating, and resolving performance and stability issues across your apps.

Automatic Issue Detection​

The Kotzilla Console automatically detects and surfaces critical issues in your app without requiring any additional instrumentation of your code. It uses the Kotzilla SDK to identify the following types of issues:

  • Startup performance issues: Delays in app initialization, preventing the first usable screen from appearing quickly.
  • Background performance issues: Slow or resource-heavy background components or dependencies resolutions impacting app responsiveness.
  • Main thread performance issues: Components or dependencies resolutions running on the main thread for over 100ms, potentially leading to freezes or ANRs.
  • Dependency performance issues: Inefficient resolution of dependencies slowing down app responsiveness.
  • Dependency complexity issues: Complex dependency graphs with more than five child dependencies, increasing maintenance and performance risks.
  • Child dependency performance issues: Dependencies taking over 5ms to resolve, causing cascading performance slowdowns.
  • Crash detection: Unhandled exceptions and hard crashes that terminate the app unexpectedly.

Investigating issues and root cause analysis​

The Kotzilla Console is designed for in-depth issue investigation and root cause analysis. It offers several views that provide rich contextual information to help you quickly diagnose and fix problems.

Dashboard View​

The Dashboard is the first view you’ll see when accessing the Kotzilla Console for a specific app and version. It provides a comprehensive snapshot of your app's current health, performance, and user activity, enabling you to identify and prioritize issues efficiently.

The main view of the Dashboard is organized into three main sections:

App vitals overview​

This section gives you a high-level summary of your app’s current state, including, total user sessions captured, total events consumed, devices detected, issues detected and open issues

Issues summary​

Displays all remaining open issues for a particular app version, including details such issue overview and description, severity level and number of impacted sessions.

A pie chart is also available to categorize open issues by type for a selected app version:

  • Crashes: unhandled errors or hard crashes
  • Performance: slow startup times, delayed component resolutions, thread blocking (main/background)
  • Architecture: complex dependency graphs that may affect maintainability and scalability

Recent user sessions recorded​

Shows the latest user sessions recorded for a particular app version, including information about session duration and the complexity of dependency graph resolution.

Version performance comparison​

The Dashboard also proposes a second view called Release Comparison that lets you compare the behavior and performance of different app versions to identify regressions or improvements. Metrics available for comparison include total user sessions, number of issues detected, number of affected devices and average session duration

Simply select the builds you want to compare, and the Console will automatically generate the insights.

Issues View​

The Issues View provides detailed visibility into all detected issues across your app, including crashes, performance problems, and architectural issues identified via the Kotzilla SDK API. It offers two complementary views to help you monitor, prioritize, and resolve problems effectively.

All Issues View​

This view displays the complete list of issues, with filtering options by app version, issue type, impacted class, and full-text search across properties. For each issue, the view includes key information such as:

  • Issue description: a concise explanation of the issue type and its impact
  • Impacted user sessions: the number of sessions in which the issue was observed
  • Affected app versions: versions of the app impacted by the issue
  • Issue status: whether the issue is open, acknowledged, or closed
  • Severity level: classification as Critical, High, Medium, or Low

Severity is determined using an algorithm based on the Apdex methodology, which evaluates how far an issue deviates from its defined performance targets and tolerances. This ensures consistent, objective prioritization based on real impact.

Issues by Class view​

This view groups issues by the app classes they affect, such as ViewModel, ListenableWorker, or DataRepository. It allows you to:

  • Identify components or dependencies most commonly associated with issues
  • Analyze patterns and trends across different parts of your app architecture
  • Improve debugging workflows by targeting problematic classes directly

You can click on any issue to view detailed information such as stack traces for crashes, or explanations on the cause of the issue for performance, memory and app complexity problems. The issue details view also shows impacted user sessions, allowing you to continue the investigation down to specific user sessions

Timeline View​

The Timeline View offers a complete, interactive picture of a specific user session to help you quickly understand app behavior and investigate the root causes of issues.

You can access the Timeline View by:

  • Selecting a specific user session from the Sessions View
  • Jumping directly from a flagged issue in the Issues View, where the view will focus on the session and event involved

The view is organized into three main sections:

Key user session moments​

At the top of the screen, this visual timeline highlights key moments across the session such as screen transitions, crashes, and issues detected by the platform. You can zoom in to narrow the focus, and the other two sections will automatically update to reflect the selected time range.

Session activity graphs (left section)​

This section gives you a visual breakdown of how the session behaved under the hood, helping you analyze both app workload and execution flow. It includes:

  • A dependency resolution graph, which shows how many instances were requested and created at different moments during the session
  • A thread timeline, providing a visual representation of how key events were scheduled and executed across your app’s threads

Two other tabs give access to session-level context:

  • Session summary: Displays device information, OS version, app version, and the timestamp of the session’s creation
  • Session properties: Shows custom metadata you’ve attached to the session using the Kotzilla SDK API, such as user preferences, app settings, or environment flags

Detailed event insights (right section)​

This section provides a deep dive into everything that occurred during the session, making it easier to trace specific issues or understand system behavior.

Here you’ll find:

  • The full sequence of events, including component and dependency resolutions, their types, bindings, and additional metadata
  • Issues flagged by the platform, displayed in context and directly linked to the components or dependencies involved
  • This section updates in sync with the others, so filtering or zooming in any view refines the data you see here.

A tree graph view displaying child nodes for each component resolution event, allows you to visually explore dependency hierarchies and see graphically which dependency resolutions are taking more time

Koin IDE Plugin integration​

If you want to view and address issues directly within your development environment, the Koin IDE Plugin integrates with the Kotzilla Console. The plugin includes a Issues view that lists detected issues and impacted user sessions within your IDE. You can use the plugin to view a list of detected issues and then explore the details in the Kotzilla Console for further investigation.