Skip to main content

Kotzilla Console

The Kotzilla Console is a web-based environment that helps you analyze and resolve performance issues and crashes 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 critical issues sorted by impacted user sessions for a particular app version. These are the main issues that require immediate attention, as they are already affecting the user experience

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

  • Performance: slow startup times or slow component resolutions that block the main or background threads
  • Crashes: unhandled errors or hard crashes

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, average session duration and main components impacted.

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

Issues View​

This page provides visibility into all detected issues across your app, including crashes, performance problems, and architectural issues identified via the Kotzilla SDK. It offers multiple views to help monitor, prioritize, and resolve problems effectively.

The page is composed of two views, allowing you to focus on critical issues or to get an overview of all issues detected. Both views include 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 displays key information:

  • 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

Critical Issues View​

This view displays issues from the following types: Crashes, Startup performance, Main thread performance or Background thread performance.

Critical Issues highlight the problems that require immediate attention as they are directly impacting user experience. Notes may be included for additional context.

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.

All Issues View​

This view includes all issues from the Critical Issues view, as well as any other performance and architectural issues detected by the platform. Notes may also be included for each issue.

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

Critical Issues Notifications​

The Kotzilla Console includes a Notification Center that allows users to enable email notifications for critical issues detected in their apps.

Key points:

  • Notifications can be enabled or disabled globablly for all apps within your organization.
  • The schedule of notifications is configurable, ranging from every 15 minutes up to once per month.

This ensures that teams are promptly informed of critical issues affecting user experience, without requiring manual monitoring.

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 provides a visual breakdown of how the session behaved under the hood, helping you analyze both app workload and execution flow. It includes:

  • Memory Graph: Displays components’ memory usage during the session, including components currently in memory, components created, and any open scopes.

  • Thread Timeline: Provides 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 runtime 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

  • Live synchronization with other views, so filtering or zooming in any view automatically refines the data displayed here

A tree graph view displays child nodes for each component resolution event, allowing you to visually explore dependency hierarchies and identify which dependency resolutions take the most time.

This view also provides analysis and actionable recommendations to pinpoint slow dependency resolutions or component initialization issues.

Koin IDE Plugin integration​

The Koin IDE Plugin integrates with the Kotzilla Console, allowing you to view and address issues directly within your development environment. The plugin includes an Application Issues view that displays detected issues and impacted user sessions. For further investigation, you can explore issue details in the Kotzilla Console.