Kotzilla SDK changelog

Stay up-to-date with the latest changes, bug fixes, and improvements in the Kotzilla SDK.

Maven Packages

The Kotzilla SDK & Plugin are available on maven central.

Here is the current available version:

Module	Version
kotzilla-plugin
kotzilla-sdk-compose
kotzilla-sdk

Latest Changes

• 2.2.4 (22/06/2026)

  • Changed: Build reports no longer fail the build by default — skipBuildReportFailure now defaults to true, so a FAIL report prints its banner but keeps the build green. This prevents the report gate from blocking your very first build, before any data exists for the app version. To make a FAIL report fail the build, set kotzilla { skipBuildReportFailure = false }. PASS, 404 (no data yet), and transient HTTP errors still never fail the build.
  • Added: CI/CD override for the build report gate — flip the gate without editing build.gradle.kts using a Gradle property: -Pkotzilla.skipBuildReportFailure=false forces it ON (fail on FAIL), -Pkotzilla.skipBuildReportFailure=true forces it OFF. The property wins over the DSL value when present.

• 2.2.3 (18/06/2026)

  • Fixed: Correct timeline ordering of Koin events (recommended upgrade) — Koin events (DI resolutions, module load, eager instances, scope create/drop) now keep their true chronological position in the session timeline, relative to Activity/Fragment and Compose screen events. Previously, dependency work performed very early — most visibly the startKoin / module-load / eager-singleton resolutions during Application.onCreate — could appear after the first Activity event even though it happened before it, because Koin events were numbered when the SDK drained its internal buffer rather than when they occurred. The timeline (ordered by event order) now matches wall-clock order across the Koin↔screen boundary, so screen-rendering and startup analysis attribute the right work to the right phase. Recommended for any app that relies on timeline ordering or screen-rendering metrics; no API or configuration changes are required.

• 2.2.2 (11/06/2026)

  • Added: Accurate Compose screen render timing — Compose screens now measure render time on-device (monotonic clock, from screen creation) instead of relying on server-side timestamp math. The timing rides the existing timeInMs field on SCREEN_LIFECYCLE events (no new fields): on the first VISIBLE event it is the time to first frame painted (the render number); on RESUMED it is the time to interactive (which includes the navigation transition). Works identically for Navigation 2 and Navigation 3. Enable debug logs to see a per-screen load funnel — CREATED/STARTED/VISIBLE/RESUMED breakdown.

• 2.2.1 (08/06/2026)

  • Breaking: kotzilla.json required for SDK hosts — an app module (com.android.application / Gradle application) with no reachable kotzilla.json now fails the build early with a clear, branded error instead of a confusing Unresolved reference: monitoring. Add kotzilla.json to the module that starts the SDK, or set kotzilla { enabled = false } to opt out.
  • Added: Build ID propagation — the plugin generates a per-build buildId (UUID v7), sends it on every session and as the X-Kotzilla-Build-Id header, and tags mapping uploads with ?buildId=&sha1=, so crashes resolve to the exact mapping even when several builds share a version name. Per-variant on Android, so distinct minified variants (e.g. release + minified staging) no longer overwrite each other's mappings.
  • Added: isMinified on sessions — each session reports whether the build was minified (omitted when unknown), so the Console can tell a genuinely missing mapping on a minified build from the normal no-mapping case.
  • Added: Non-Koin monitoring() overload — generated config exposes monitoring(version) (and monitoring(application) from androidMain on KMP Android) to avoid ambiguity inside startKoin {}.
  • Added: Crash screen context — crash reports now include the last resumed screen (route + visit) at crash time.
  • Added: Reliable route visibility — VISIBLE/HIDDEN events are emitted from the route host node, so trivial wrapper routes track visibility correctly.
  • Changed: kotzilla.json ownership is file-presence based — config generation is owned by any module containing kotzilla.json (or whose kotzilla { projectFile } points to one). Misplaced files (e.g. src/main/assets/), zero-owner, and multiple-owner setups fail fast with actionable errors.
  • Changed: Koin SDK_LOG capped at WARNING — Koin DEBUG messages are no longer forwarded as SDK_LOG (DI activity is already captured structurally via KOIN_SCOPE / KOIN_RESOLUTION).
  • Deprecated: runtime/manual setup APIs — KotzillaCore.setApiKey(String), KotzillaCoreSDK.setup(token, version), and analytics(application) / androidAnalytics() are deprecated in favor of the plugin-generated monitoring() (which also wires the build ID). Existing builds keep working.
  • Fixed: SDK never crashes the host app — every SDK→app seam absorbs its own throwables; network failures (DNS / offline / timeout / TLS) are handled quietly instead of reported as SDK errors, and initial connect now retries indefinitely with jittered backoff (reconnects after network loss).
  • Fixed: Screen push vs pop — forward navigation emits STOPPED for the outgoing screen; only back-pop or dismiss emits DESTROYED (fixes inflated session counts).
  • Fixed: Native Activity/Fragment timing — Activity and Fragment screens now report elapsed time on PAUSED/DESTROYED (was always null), and DESTROYED/DETACHED are now emitted for fragments hosted in a NavHostFragment.
  • Fixed: Multi-module reliability — no more prepareLintJarForPublish failure on com.android.lint modules, and no per-module "No version detected" warning spam (surfaced once in the build report).
  • Fixed: Apple/Xcode tasks off-macOS and without Xcode — setupKotzillaXcode / uploadDsymFile skip gracefully on non-macOS and never fail the build when Xcode or the project file is absent; stale or duplicate dSYM scripts self-correct or warn.
  • Fixed: monitoring() resolves after Gradle sync — on KMP / Compose Multiplatform / JVM, the generated monitoring() symbol is resolvable after a sync (no first build required).
  • Fixed: Koin 4.x modules load + deep links — KOIN_MODULES_LOAD is recognised on Koin 4.x, and the navDeepLink { uriPattern = "..." } builder form is now captured at compile time.

• 2.2.0 (18/05/2026)

  • Added: Navigation 3 screen tracking — Navigation 3 screens are tracked for all KMP targets. Compose typed routes keep their full route name in Kotzilla, with safe route details attached when available (Nav2 and Nav3).
  • Added: Compose screen lifecycle events — Compose Navigation route boundaries (Nav2 and Nav3) are auto-instrumented and emit a SCREEN_LIFECYCLE event per screen visit. screenType is compose_nav2 / compose_nav3 for Compose screens, activity / fragment otherwise.
  • Added: Build report — Gradle builds now print the Kotzilla report for the selected app version, run by auto-wired kotzillaBuildReport{Variant} tasks. Build fails on a FAIL status; opt out with kotzilla { skipBuildReportFailure = true }.
  • Added: Automatic Android versionCode — Android apps now report versionCode automatically. Manual and non-Android integrations can still use setVersionCode(...).
  • Changed: Simpler plugin setup — The Kotzilla Gradle plugin is now applied at the root with apply true (previously apply false), so the plugin processes every module including feature modules with Compose Navigation routes. Module-level plugin application is unchanged.
  • Changed: Expanded compatibility — Added AGP 9.2.0, Gradle 9.5.0, Compose BOM 2026.04.01, AndroidX Navigation Compose 2.9.8, Compose Multiplatform 1.10.3 (Kotlin ceiling 2.3.20).
  • Breaking: compileSdk requirements — Android consumers now need compileSdk 35+. Navigation 3 Android projects need compileSdk 36+ and minSdk 23+. KMP native/web requires Kotlin 2.2+.
  • Fixed: Compose route starts — Route visits are no longer missed when a destination is already resumed before Kotzilla attaches.
  • Fixed: Generated config ownership — Android apps fail early when more than one runtime dependency owns the Kotzilla generated config. Keep kotzilla.json or projectFile in a single app/runtime module. Multi-key config is strict and fails fast on misconfiguration.
  • Fixed: Build-time app version detection — Generated config, mapping uploads, and dSYM uploads now consistently use the same app version.
  • Fixed: Kotlin 2.1 Android/JVM consumers — Android and JVM publications no longer expose Kotlin 2.2 runtime metadata.
  • Fixed: iOS dSYM setup — setupKotzillaXcode supports nested and more complex Xcode project layouts. Fix applies automatically on project sync or rebuild.
  • Fixed: AGP 9.2 mapping uploads — Mapping uploads work with AGP 9.2, R8/L8 outputs, and bundle<Variant>, with no configuration cache conflicts.
  • Fixed: Crash replay deduplication — Delivered crash reports are never resent.
  • Fixed: JS/WASM event delivery — Page-close saves, localStorage quota recovery, and gzip/CORS fallback now work on browser targets.
  • Fixed: Koin telemetry resilience — Long-running unresolved Koin resolutions can now be reported; unexpected Koin log/parser failures no longer stop later telemetry.

• 2.1.5 (08/06/2026)

  • Breaking: kotzilla.json required for SDK hosts — an app module (com.android.application / Gradle application) now fails the build early, with a clear branded error, when its runtime classpath has no — or more than one — owner of kotzilla.json (instead of a confusing Unresolved reference: monitoring). On the 2.1 line, apply the Kotzilla plugin in the SDK-starting module itself (root-build application does not propagate to subprojects). Add kotzilla.json to that module, use kotzilla { projectFile = "…" } for a non-standard path, or set kotzilla { enabled = false } to opt out. Route/library modules that ship no config are unaffected.
  • Added: Build ID propagation — the plugin generates a per-build buildId (UUID v7), sends it on every session (NeSs.buildId) and as the X-Kotzilla-Build-Id header, and tags mapping uploads with ?buildId=&sha1=, so crashes resolve to the exact mapping even when several builds share a version name. A kotzilla-build-id.txt sidecar and a # kotzilla_build_id: comment in mapping.txt keep the ID through a Console re-upload. The mapping ?version= is resolved from the same source that bakes the session version, so on KMP Android a build-type versionNameSuffix can no longer make the upload send a version the session never reports. Generated-config registration and the config loader are now version-skew safe — an older kotzilla-core than the plugin degrades to no sessions instead of crashing startKoin { monitoring() } at startup.
  • Deprecated: KotzillaCore.setApiKey() — configure the API key via kotzilla.json + the Gradle plugin instead of at runtime. The generated code still calls it internally, so existing builds keep working; only direct runtime use is discouraged (warning-level).
  • Fixed: SDK never crashes the host app — every synchronous SDK→app seam (public API, Koin hooks, OS lifecycle callbacks) absorbs its own throwables; previously e.g. analytics() without androidContext(), or a LinkageError from a missing optional dependency, propagated into startKoin {} / onCreate() and crashed the app.
  • Fixed: Network failures no longer reported as SDK errors — DNS / offline / timeout / refused / TLS now surface as a transport status handled quietly at DEBUG; no more SDK_DIAGNOSTIC stack traces emitted to Crashlytics / Firebase / Console as SDK faults.
  • Fixed: Reconnects after network loss — initial connect now retries indefinitely with full-jitter backoff (≤60 s/attempt) and is nudged by foreground transitions, instead of giving up after 3 fixed attempts for the rest of the process lifetime.
  • Fixed: Apple/Xcode tasks optional-by-capability — iOS dSYM upload and setupKotzillaXcode run only on macOS and skip gracefully elsewhere, so they no longer execute on every Linux/Windows IDE sync, and an absent or broken Xcode/dSYM setup degrades to a warning instead of failing a possibly non-Apple build.
  • Known issue: KMP Android shares one build ID across minified variants — if two or more minified Android variants resolve to the same applicationId, their ProGuard mappings upload under one backend key and the later overwrites the earlier. The plugin warns at build time (when mapping upload is enabled); give the colliding variants distinct applicationIds. Pure-Android apps are unaffected (per-variant identity).

• 2.1.4 (18/05/2026)

  • Fixed: Android multi-key variant selection — key selection is now package-first at build time, runtime, and mapping upload: single-key files work without isDefault, one exact applicationPackageName match wins, same-package keys refine by ordered Android flavor candidates, and isDefault is only the final fallback.
  • Fixed: Multi-key diagnostics — config generation and mapping upload now emit one default-visible selected-key line (masked API key suffix, selector, match reason, active package, flavor candidates, decision path); the Android runtime override logs the same detail when applied.

• 2.1.3 (01/04/2026)

  • Added: withAndroidContext(context) — Provide Android Application context for lifecycle instrumentation without Koin. Usage: KotzillaCoreSDK.setup(token, version).withAndroidContext(app).connect()
  • Fixed: Manual API missing platform lifecycle — KotzillaCoreSDK.setup(...).connect() now auto-installs lifecycle observers (APP_STATE, crash handling, activity tracking) on all platforms. Previously only the monitoring {} path installed them.
    • Android: auto-discovers Application from Koin when available; otherwise use withAndroidContext(app)
    • iOS: foreground/background/active observers auto-installed
    • JS/WASM: visibility, error, and unload handlers auto-installed
    • JVM: shutdown hook and uncaught-exception handler auto-installed
  • Fixed: Synthetic KOIN_INDEX on late Koin attachment — DI graph topology now available in Console when using the manual API with Koin discovered after connect.

• 2.1.2 (31/03/2026)

  • Fixed: Flavor-aware multi-key kotzilla.json resolution (KTZ-3814) — Android selection now uses one shared contract at build time and runtime: exact applicationPackageName + flavor, then exact package-only, then exact flavor-only, then one explicit default fallback. Same-package different-flavor variants now resolve correctly, and unmatched Android variants fail fast when no single fallback exists.
  • Fixed: Non-variant multi-key generation — KMP commonMain, Android library, and other non-variant generation paths now require one explicit default for multi-key configs. Single-key configs still behave as a natural default.
  • Fixed: Selector validation — The plugin now rejects duplicate normalized selector signatures (applicationPackageName, flavor) and multi-key unconstrained non-default entries before generation. Generated configs carry canonical flavor and module BuildConfig package metadata so Android runtime can resolve against BuildConfig.FLAVOR.
  • Fixed: Windows API validation for kotzilla-sdk-compose — The Compose module now host-gates its Apple targets the same way as the other SDK modules, so Windows/Linux apiCheck no longer tries to resolve nonexistent iOS variants.

• 2.1.1 (24/03/2026)

  • Changed: Default refresh rate — Reduced from 30 s to 15 s for faster data collection. Override with onConfig { refreshRate = 30_000L } to restore the previous interval.
  • Fixed: Android Activity lifecycle events — Fixed regression where initial Activity CREATED/STARTED/RESUMED events and host-Activity fragment events were silently lost due to deferred callback registration.
  • Fixed: Off-Main setup race — Fixed a race in the off-Main ProcessLifecycleOwner deferral path where the cleanup handle could be assigned after the deferred Runnable already fired, causing PLO registration to be silently skipped.

• 2.1.0 (20/03/2026)

  • Breaking: useSSLVerification removed — SDK now always uses platform-default TLS. Remove any onConfig { useSSLVerification = false } calls.
  • Security: TLS hardened — Removed DefaultTrustManager that allowed disabling certificate validation.
  • Added: App lifecycle tracking — APP_STATE events on all platforms. Scheduler pauses in background. Events persisted to disk and replayed if process killed. reportAppState() API for manual control (JVM/server).
  • Added: End-of-build report — Issue summary banner at build end; full report at build/reports/kotzilla/build-report.txt.
  • Added: Expanded compatibility — Kotlin 2.3.20, AGP 9.1.0, Compose BOM 2026.02.01, AndroidX Nav 2.9.7, JB Compose 1.10.2, JB Nav 2.9.2. AGP 9: built-in Kotlin auto-detected, AKMP plugin recognised.
  • Changed: KMP native/web requires Kotlin 2.2.0+ — klib metadata change. JVM/Android unaffected.
  • Changed: kotlinx-serialization 1.6.3 to 1.9.0 — verify if you pin serialization.
  • Changed: Build artifacts — PLCrashReporter scoped to KMP publication (minus 105 MB for non-iOS); KLIB source paths now relative.
  • Changed: setupKotzillaXcode repairs disabled dSYM scripts.
  • Changed: kotzillaDependencyDoctor declares CC incompatibility — use --no-configuration-cache.
  • Fixed: Configuration cache for multi-flavor projects (KTZ-3747) — per-flavor versionName no longer crashes CC. Remove defaultConfig { versionName } workarounds.
  • Fixed: Android analytics race — androidAnalytics runs on main thread after SDK setup.
  • Fixed: Fragment lifecycle — correct event from onFragmentStopped(); callbacks keyed by Activity instance.
  • Fixed: Backend schema resilience — new server fields no longer crash the SDK (ignoreUnknownKeys).
  • Fixed: Android crash handler isolation — third-party handlers always fire even if SDK handler fails.
  • Fixed: JVM shutdown flush — CountDownLatch (3s) replaces Thread.sleep(500).
  • Fixed: Dependency sync — cinterop/commonizer excluded from checks; errors include root cause and repo hint.
  • Fixed: Resolution tracker — orphan frames captured as NOT_FOUND; completed stacks removed (memory leak).
  • Fixed: ProGuard rules — keep rules for com.russhwolf.settings.
  • Fixed: HTTPS proxy — checks https.proxyHost first, falls back to http.proxyHost.
  • Known Issues: Crash backup capped at 1,000 events (live buffer is 4,000; signal handler constraints). Pre-connect events discarded during short connect window.

• 2.0.9 (13/03/2026)

  • Fixed: Android analytics race condition — androidAnalytics (activity lifecycle tracking, crash reporter, process lifecycle observer) now runs on the main thread after SDK setup completes, fixing a race condition where getCurrentService() could return an uninitialized service when using KotzillaSDK.setup(context)

• 2.0.8 (02/03/2026)

  • Fixed: Plugin/runtime dependency mismatch on local release builds — The Gradle plugin now tracks generated PluginVersion.kt with explicit task inputs, preventing stale version leakage into artifacts when switching branches
  • Fixed: Fail-fast plugin artifact integrity — Plugin apply now validates manifest version against embedded PluginVersion.VERSION and aborts on mismatch with a remediation hint
  • Fixed: Version source drift in SDK API — io.kotzilla.sdk.SDK.version is now generated from the Gradle version at build time, removing manual drift risk
  • Fixed: Dependency resolution diagnostics — DEPENDENCY-SYNC unresolved errors now include plugin version context plus explicit autoAddDependencies = false workaround guidance
  • Changed: Compose SDK dependency scope — kotzilla-sdk-compose now declares Compose runtime and navigation as api (was compileOnly), ensuring proper transitive resolution for all KMP targets
  • Version bump workflow — Added ./bump-version.sh to propagate version across podspecs and sample app
  • Version format now enforced as strict SemVer at Gradle configuration time

• 2.0.5 (13/02/2026)

  • Fixed: Plugin mapping file upload regression (appeared in 2.0.1)

• 2.0.4 (11/02/2026)

  • iOS crash reports now include Kotlin stack traces — Previously, iOS crash reports only contained PLCrashReporter's native stack trace. The SDK now captures the full Kotlin stack trace at the moment of an unhandled exception, persists it immediately, and includes it in the crash report sent on next launch.

• 2.0.3 (04/02/2026)

  • Fixed: Koin resolution failure — Fixed "Could not create instance for KotzillaHttpClientImpl" error caused by singleOf() DSL ignoring default parameter values
  • Fixed: Early flush race condition — Multiple coroutines could be spawned for early flush at 70% buffer capacity, causing request bursts. Now uses @Volatile flag to guarantee single flush
  • Fixed: SDK startup failure — Fixed edge case where KotzillaHttpClientImpl instantiation could fail due to a race condition between HttpEngine registration and lazy resolution
  • Fixed: Flag stuck after lifecycle — Reset earlyFlushPending on resume and shutdown to prevent stuck state
  • Added Koin singleton smoke tests to prevent similar regressions

• 2.0.2 (29/01/2026)

  • Breaking: Koin 4.0.4+ now required (was 3.5+)
  • monitoring() generated function — Replaces manual SDK setup with auto-configuration from kotzilla.json
  • analytics {} deprecated on JVM/JS/Native/WASM — Use monitoring {}; Android analytics() unchanged
  • keyGeneration DSL removed — Replaced by automatic GenerateKotzillaConfigTask
  • iOS crash reporting (Beta) — PLCrashReporter with dSYM upload automation (./gradlew setupKotzillaXcode)
  • JS/WASM support (Experimental) — Browser & Node.js exception handlers with localStorage persistence
  • JVM crash reporting (Experimental) — Crashes captured; mapping file support not yet available
  • Auto-dependency injection — SDK dependencies added automatically; opt-out: kotzilla { autoAddDependencies = false }
  • ProGuard/R8 rules auto-included — No manual configuration needed
  • composeInstrumentation default: true — Was false; opt-out: kotzilla { composeInstrumentation = false }
  • API key obfuscation — XOR+Base64 by default; opt-out: kotzilla { obfuscateGeneratedConfig = false }
  • Fail-fast on missing API key — Build fails with actionable error instead of silent failure
  • Environment mismatch detection — Warns when Gradle site differs from runtime Environment
  • sdkVersion deprecated in kotzilla.json — No longer used
  • Kotlin 2.1.0–2.3.0 support (was 2.0.21–2.1.20)
  • Compose Navigation upgraded to 2.9.1
  • Reduced and optimised SDK traffic
  • Improved reliability of mapping/dSYM upload
  • Fixed API 21 crash in Compose SDK (forEach method is not supported on API 21)

• 1.4.2 (17/12/2025)

  • Fixes a problem in CMP apps where the key wasn't found in the first folder
  • Prevented race condition in event reporter fixing duplicate event batches to be sent to Kotzilla
  • Prevented stale app version in Compose apps
  • Automatic app version resolution was added to Compose apps to help with configuration

• 1.4.2-RC1 (12/12/2025)

  • Fix Compose Android resources folder scanning

• 1.4.1 (04/12/2025)

  • Fix long running sessions analytics

• 1.4.0 (17/11/2025)

  • Kotlin 2.0.21 is the minimum required version
  • Ktor is replaced with a native HTTP client on each supported platform
    • Removed all Ktor HTTP client dependencies (up to ~500-700KB non-minified binary size reduction)
  • Added consumer ProGuard rules for better R8/ProGuard compatibility

• 1.3.1 (7/11/2025)

  • Kotzilla key selection by flavor
  • Fix Gradle Plugin, to skip Compose Navigation tracing if not using Kotlin 2.1.x (make it compat with Kotlin 2.2.x)

• 1.3.0 (23/10/2025)

  • Remove kotlinx date-time dependency to avoid conflicts
  • Upgrade Kotlin Compatibility version to 2.1.20

• 1.2.3 (07/10/2025)

  • Fixed connection retry strategies
  • Fixed events retry strategies

• 1.2.2 (10/09/2025)

  • Fixed core internals and schedulers threading
  • Fixed events mission + better retry strategies

• 1.2.1 (29/08/2025)

  • Added suspendTrace to trace coroutines function (used in Koin Annotations 2.2 with @Monitor)
  • Added Compose Nav arguments to the capture data

• 1.2.0 (29/08/2025)

  • Check for the Compose resources task in Gradle

• 1.2.0-Beta4 (27/05/2025)

  • Analytics/Koin logger active guard at start (to check if Koin config is ok)
  • Fixed events emitting & parallelism
  • Default push to 30s

• 1.2.0-Beta3 (16/05/2025)

  • Introduce new kotzilla-sdk-compose library to allow Compose Multiplatform setup
  • Track for Compose Navigation events from Kotlin Compiler instrumentation (Compose 1.7+)
  • Fixed Kotzilla generation for Android & CMP projects

• 1.1.0 (16/05/2025)

  • Fix kotzilla-plugin to be usable directly by Version Catalog

• 1.0.2-RC3 (15/05/2025)

  • Fix Context.apiKey() to find the right Kotzilla SDK context
  • Fix Gradle tasks with Gradle cache usage and clean task dependency

• 1.0.1 (05/03/2025)

  • upload mapping file following any 'assembleRelease' build. This can be disabled by uploadMappingFile = false in Kotzilla gradle config

• 1.0.0 (03/03/2025)

  • 0.13.6 - analytics() function in Koin + Plugin Fixes + Key fingerprint to help regeneration
  • Rework SDK to allow different http engine ktor2 / ktor3
  • Network resilience - recover connection & send events network errors
  • Rework analytics function for KMP API
  • Rearchitecture all API for ktor3 / Entry points

• 0.13.6 (05/02/2025)

  • analytics function setup by for Koin (one-line magic setup)
  • Gradle clean key assets task
  • cleanKotzillaKey Task hook on Gradle/Android clean task
  • Reinforcement for all Gradle Tasks to fail if the kotzilla key is not well-detected
  • Key injection in Gradle task fix
  • Change kotzilla key generation with SHA1 fingerprint key to help generation/verification

• 0.13.5 (09/12/2024)

  • Fix Gradle plugin Tasks generation

• 0.13.4 (26/11/2024)

  • Fix KotzillaSDK.setup API call to allow nullable advanced setup options

• 0.13.3 (26/11/2024)

  • Maven Central publish fix + Doc update to use classpath declaration at build.gradle.kts root project file

• 0.13.2 (20/11/2024)

  • Logger optimization & Fixes
  • Core Scheduler start optimization

• 0.13.1 (20/11/2024)

  • Project file format fix

• 0.13.0 (24/10/2024) - Rebranding to Kotzilla Platform + Api Key Managagement

  • renamed CloudInjectSDK to KotzillaSDK class
  • moved io.kotzilla.cloudinject in to io.kotzilla.sdk package
  • moved Maven package from io.kotzilla:cloud-inject to io.kotzilla:kotzilla-sdk
  • moved Maven package from io.kotzilla:cloud-inject-gradle to io.kotzilla:kotzilla-gradle
  • added proguard rule: -keep class io.kotzilla.sdk.** { *; }
  • added generateAndroidAssetsKey Gradle task to generate container key from kotzilla.json project file see more
  • added generateProjectFile Gradle task to generate empty kotzilla.json with all package see more

info

New Maven packages are kotzilla-sdk & kotzilla-plugin

info

You need to download a kotzilla.json project file

---

• 0.12.0 (27/9/2024)

  • CloudInjectSDK setup DSL revamped to allow easyer setup and options
  • Http engine fixed back to Ktor CIO
  • changed tag for logs in 'Kotzilla Platform'
  • updated to cloudInject Gradle DSL declaration part

• 0.11.1 (27/9/2024)

  • Fix Koin 4.0 compatibility
  • Fix min SDK to 21
  • Fix error report job cancelling
  • Breaking, due to package move. Add -keep class io.kotzilla.data.json.** { *; } to proguard rules

• 0.11.0 (9/9/2024)

  • New KMP/standalone context isolation
  • Fix plugin setup description

• 0.10.0-Beta6 (23/8/2024)

  • Fix to Handle Android Library from plugin

• 0.10.0-Beta5 (2/7/2024)

  • merge android & KMP project as single gradle module

• 0.10.0-Beta4 (2/7/2024)

  • work all native KMP API to help start on iOS

• 0.10.0-Beta3 (31/5/2024)

  • optimized startup process & Stricmode fixes
  • global background performances updates
  • SDK context isolation

• 0.10.0-Beta1

  • Start of new KMP Version (Experimental)

• 0.9.5

  • Fix Http Client engine to avoid StrictMode conflicts
  • Display sessionId in info logs
  • remove useless setUserId done at start
  • Optimize SDK start calls on IO for local storage

• 0.9.4

  • Fix some internals logging

• 0.9.3

  • Proguard fix

• 0.9.2

  • Feature createIssue to manually to create an issue from the app
  • API protection reinforcements

• 0.9.1

  • SDK startup Delay Fix
  • logError() can take up to 20 lines of stacktrace

• 0.9.0

  • log() function to log messages
  • trace() function to trace performances for a block code

• 0.8.1

  • Fix proguard flatten packages to avoid conflicts with other SDK

• 0.8.0

  • SDK is now public on Maven Central & Github
  • improved proguard rules internally

• 0.7.0

  • Fixing internals API - Push rate adjustements
  • Fixing mapping upload with Gradle plugin

• 0.6.2

  • fix offline networking error
  • handle android security config

• 0.6.1

  • Fix plugin id to help setup with Gradle KTS
  • New Logger system - report fatal internals
  • Check for Koin Logger setup if not properly setup when SDK is connecting

• 0.6.0

  • renaming both sdk & plugin to 0.6.x version track
  • publish back to JFrog

• 0.5.x

  • Gradle plugin to upload mapping & meta index to the platform

• 0.4.5

  • SDK internal initialization fix to allow async usage of different analytics reporter, in different threads

• 0.4.3 & 0.4.4

  • JFrog distribution hosting - kotzilla.jfrog.io
  • internals update with common-sdk

• 0.4.2

  • crash reporter enabled by default (compatible with crashlytics)
  • explicit API cleaning

• 0.4.1

  • Error reporting reconnection fix
  • Local backup format fix

• 0.4.0

  • Client connection handling 403/429 and reconnect strategy
  • Crash reporting (not yet enabled by default)
    • Store & resend saved crash report
  • Core scheduler update with Coroutines 1.7.1

• 0.3.x

  • cloud inject rebranding
  • new connection endpoint
  • new background scheduler

0**.3.1 - 2023-05-11**

• cloud-inject rebranding
• allow delayed SDK setup for Koin logger

0**.2.0 - 2023-**

• connection & control flow from the cloud
• persist refresh

0**.1.5 - 2023-04-24**

• atomic order management

0**.1.3 - 2023-03-17**

• Android event scheduling fix

0.1.2 - 2023-03-14

• Environment Configuration management
• Threading info Fix