Skip to main content

Analytics

The SKIE plugin collects analytics while it is running. The analytics information is non-identifying, and used to help us improve the tool. It's also optional, so you can opt-out completely, or disable some of it.

The analytics process in SKIE has two phases, capturing and uploading. Disabling the upload allows you to inspect what data we're capturing and decide if you want to share them with us.

To disable the analytics upload add the following code to the build.gradle.kts where you apply the SKIE gradle plugin:

Disabling SKIE analytics upload (build.gradle.kts)
skie {
    analytics {
        disableUpload.set(true)
    }
}

After running the Kotlin Multiplatform link task, that produces your framework, head over to build/skie/{framework you built}/{architecture you built}/analytics. JSON files in this directory contain analytics captured by SKIE.

If you agree with the level of detail we're capturing, delete the block you just added to the build.gradle.kts and SKIE will capture and upload analytics from now on. If you wish to only share some of the data, please head over to analytics configuration to learn more.

In case you do not wish to share any data with us, you can either leave just the upload disabled, or you can disable the analytics capture altogether. Replacing the disableUpload.set(true) with enabled.set(false) will disable both phases, so there will be nothing generated in the directory you just inspected. Your configuration in build.gradle.kts should look like so:

Disabling SKIE analytics (build.gradle.kts)
skie {
    analytics {
        enabled.set(false)
    }
}

Detailed Configuration​

Setting the analytics.enabled property to true or false instruct SKIE to either capture all or no analytics. There's another, more detailed, way to control what data is captured and uploaded.

The properties additionalConfigurationFlags and supressedConfigurationFlags can be used to enable or disable specific analytics data categories.

The following code shows how to only send the SKIE Performance analytics and nothing else.

Enable specific analytics (build.gradle.kts)
skie {
    analytics {
        enabled.set(false)
    }
    additionalConfigurationFlags.add(SkieConfigurationFlag.Analytics_SkiePerformance)
}

If you wish to send all, but a certain set of data, you can supress these. The code below shows how to send all data except the Git statistics.

Disable specific analytics (build.gradle.kts)
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_Git)
}

Data Details​

SKIE analytics capture multiple categories of data. The following is the full list of these categories and data points we collect and the reason why. We chose these data points to give us a picture of SKIE's performance and usual configuration.

Each of the sections below also contains code snippets showing you how to enable or disable collection of those data points.

SKIE performance​

The most important data is the measurements of SKIE phases. We will use these values to keep an eye out on performance regressions and the impact of new features.

Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_SkiePerformance)
}

Gradle Environment​

Information from this category allows us to filter and categorize data based on the environment the Gradle build is running in.

  • Gradle version
  • Running on CI
    • Approximation of whether this build run on a CI machine.
    • CI builds often clean up the working directory between runs, which can help us see difference between clean and incremental builds.
  • SKIE version
  • Timestamp
    • When did this build run.
  • Kotlin Gradle Plugin version
  • JVM version
    • The version of JVM used to run this Gradle process.
  • macOS Version
    • What macOS version this build ran on.
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_GradleEnvironment)
}

Gradle Performance​

Along with the SKIE Performance category we aim to use the data to detect performance regressions and improve SKIE performance overall.

  • Link task duration
    • How long the Kotlin Multiplatform link task took in seconds.
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_GradlePerformance)
}

Project​

  • Project ID
    • A unique hash for a project, allowing us to group performance results and detect regressions between build of the same project.
    • We have no way to identify you or your project with this hash.
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_Project)
}

Modules​

One of the most important piece of the performance puzzle is the high-level structure of the project. We collect information about three types of modules:

  • BuiltIn
    • Kotlin standard library
  • Library
    • Library dependencies
  • Local
    • Modules in your project

For each we module we capture the following information:

  • Module ID
    • A unique hash for the module. We have no way to identify you or your project with this hash.
  • Module version
    • Version of the module if this is a dependency
  • Is Exported?
    • Whether you explicitly export this module into your Kotlin framework.
  • Declaration Statistics
    • Exported Declarations
      • Number of classes and callable members that are exported to the final Kotlin framework.
      • SKIE ehnances these declarations, so we expect to see a link between this number and how long SKIE takes to run.
    • Exportable Declarations
      • Number of classes and callable members that could be exported, but are not.
    • NonExportable Declarations
      • Number of classes and callable members that can't be visible to Swift.
    • Overridden Callable Members
      • How many overrides the module has. Function overrides generally introduce less overhead than the base functions which needs to be taken into account when analyzing SKIE performance.
    • Number of IR Elements
      • Total number of IR elements in the module.

Overall the declaration statistics should help us understand SKIE performance in the context of a wide variety of project configurations. That's crucial for improving SKIE's performance and debugging regressions.

Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_Modules)
}

Hardware​

Another set of information that we need to normalize the performance data is the hardware the build run on. As with the rest of data, none of these are identifying and are only meant for us to normalize performance data and possibly see if certain configurations behave unexpectedly.

  • CPU Type
    • Intel or Apple Silicon and which one
  • Machine Model
  • Machine Name
  • Model Number
  • Number of processors
  • Amount of RAM

Git statistics​

We need to get a sense of the project size, so we can try to normalize the performance data.

  • Number of commits
  • Number of tags
  • Number of contributors
  • Number of branches
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_Git)
}

Compiler Configuration​

Compiler configuration contains information about how the Kotlin framework link task is configured.

  • Kotlin Language version
  • Kotlin API version
  • Language version string
    • This contains Kotlin language flags that can modify certain Kotlin features.
  • Host
    • The platform and architecture of the machine you're building the Kotlin framework on.
  • Target
    • The platform and architecture of the target Kotlin framework.
  • Overridden properties
    • Key-value map with Kotlin properties that you can override, further changing the linking behavior
  • Is Debug Build
  • Linker Args
    • Additional linker arguments that Kotlin passes to ld when building a dynamic framework.
  • Override Clang Options
  • Static Framework
    • Whether the resulting framework is static or dynamic.
  • Objective-C generics
    • Whether the support for exporting Objective-C generics is enabled.
  • Memory model override
  • Allocation mode override
  • Garbage collector override
  • Objective-C Export Suspend Function Launch Thread Restriction
    • Whether you enabled support for calling suspend methods from other threads than main
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_CompilerConfiguration)
}

Compiler Environment​

  • JVM version
  • Kotlin Compiler version
  • Xcode version
  • Available processors
    • How many processors can the linking process use.
  • Max JVM memory
    • How much memory can the linking process use.
Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_CompilerEnvironment)
}

SKIE configuration​

This category contains the configuration SKIE is running with. Enabling and disabling features has an impact on the time SKIE needs.

Configuration
skie {
    suppressedConfigurationFlags.add(SkieConfigurationFlag.Analytics_SkieConfiguration)
}
Last updated on by Filip Dolník