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 is designed to help you investigate issues and understand the flow of events that led to them in a specific user session. It provides a detailed, visual representation of app component lifecycles, thread activity, and events in each user session. The Timeline View enables you to:

  • Graphically identify issues: Issues are marked in the timeline with flags, making it easy to pinpoint the exact component or action causing the problem.
  • Navigate from the Issues View: When you access an issue from the Issues View, you are taken directly to the relevant event or component in the Timeline View. From there, you can expand the tree to explore related events or dependencies and continue your investigation.

  • Filter and search events: The Timeline View supports full-text filtering by category, content, and thread, allowing you to quickly find specific events or issues within the timeline.

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.