Feat: Measure app start time

CHANGELOG.md

@@ -3,6 +3,7 @@
 * Feat: OkHttp callback for Customising the Span (#1478)
 * Feat: Add breadcrumb in Spring RestTemplate integration (#1481)
 * Fix: Cloning Stack (#1483)
+* Feat: App start up metrics (#)
 
 # 5.0.0-beta.4
 

sentry-android-core/api/sentry-android-core.api

@@ -73,6 +73,11 @@ public final class io/sentry/android/core/NdkIntegration : io/sentry/Integration
 	public final fun register (Lio/sentry/IHub;Lio/sentry/SentryOptions;)V
 }
 
+public final class io/sentry/android/core/PerformanceAndroidEventProcessor : io/sentry/EventProcessor {
+	public fun <init> ()V
+	public fun process (Lio/sentry/protocol/SentryTransaction;Ljava/lang/Object;)Lio/sentry/protocol/SentryTransaction;
+}
+
 public final class io/sentry/android/core/PhoneStateBreadcrumbsIntegration : io/sentry/Integration, java/io/Closeable {
 	public fun <init> (Landroid/content/Context;)V
 	public fun close ()V
@@ -123,6 +128,17 @@ public final class io/sentry/android/core/SentryInitProvider : android/content/C
 	public fun update (Landroid/net/Uri;Landroid/content/ContentValues;Ljava/lang/String;[Ljava/lang/String;)I
 }
 
+public final class io/sentry/android/core/SentryPerformanceProvider : android/content/ContentProvider {
+	public fun <init> ()V
+	public fun attachInfo (Landroid/content/Context;Landroid/content/pm/ProviderInfo;)V
+	public fun delete (Landroid/net/Uri;Ljava/lang/String;[Ljava/lang/String;)I
+	public fun getType (Landroid/net/Uri;)Ljava/lang/String;
+	public fun insert (Landroid/net/Uri;Landroid/content/ContentValues;)Landroid/net/Uri;
+	public fun onCreate ()Z
+	public fun query (Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;
+	public fun update (Landroid/net/Uri;Landroid/content/ContentValues;Ljava/lang/String;[Ljava/lang/String;)I
+}
+
 public final class io/sentry/android/core/SystemEventsBreadcrumbsIntegration : io/sentry/Integration, java/io/Closeable {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;Ljava/util/List;)V

sentry-android-core/src/main/AndroidManifest.xml

@@ -8,5 +8,11 @@
       android:name=".SentryInitProvider"
       android:authorities="${applicationId}.SentryInitProvider"
       android:exported="false"/>
+
+    <provider
+        android:name=".SentryPerformanceProvider"
+        android:authorities="${applicationId}.SentryPerformanceProvider"
+        android:initOrder="200"
+        android:exported="false"/>
   </application>
 </manifest>

sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java

@@ -34,6 +34,9 @@ public final class ActivityLifecycleIntegration
 
   private boolean isAllActivityCallbacksAvailable;
 
+  private boolean firstActivityCreated = false;
+  private boolean firstActivityResumed = false;
+
   // WeakHashMap isn't thread safe but ActivityLifecycleCallbacks is only called from the
   // main-thread
   private final @NotNull WeakHashMap<Activity, ITransaction> activitiesWithOngoingTransactions =
@@ -186,6 +189,11 @@ public synchronized void onActivityPreCreated(
   @Override
   public synchronized void onActivityCreated(
       final @NonNull Activity activity, final @Nullable Bundle savedInstanceState) {
+    if (!firstActivityCreated) {
+      AppStartState.getInstance().setColdStart(savedInstanceState == null);
+      firstActivityCreated = true;
+    }
+
     addBreadcrumb(activity, "created");
 
     // fallback call for API < 29 compatibility, otherwise it happens on onActivityPreCreated
@@ -201,6 +209,11 @@ public synchronized void onActivityStarted(final @NonNull Activity activity) {
 
   @Override
   public synchronized void onActivityResumed(final @NonNull Activity activity) {
+    if (!firstActivityResumed) {
+      AppStartState.getInstance().setAppStartEnd();
+      firstActivityResumed = true;
+    }
+
     addBreadcrumb(activity, "resumed");
 
     // fallback call for API < 29 compatibility, otherwise it happens on onActivityPostResumed

sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java

@@ -105,6 +105,7 @@ static void init(
     readDefaultOptionValues(options, context);
 
     options.addEventProcessor(new DefaultAndroidEventProcessor(context, logger, buildInfoProvider));
+    options.addEventProcessor(new PerformanceAndroidEventProcessor());
 
     options.setTransportGate(new AndroidTransportGate(context, options.getLogger()));
   }

sentry-android-core/src/main/java/io/sentry/android/core/AppStartState.java

@@ -0,0 +1,56 @@
+package io.sentry.android.core;
+
+import android.os.SystemClock;
+import java.util.Date;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+final class AppStartState {
+
+  private static final @NotNull AppStartState instance = new AppStartState();
+
+  private @Nullable Long appStart;
+  private @Nullable Long appStartEnd;
+  private @Nullable Boolean coldStart;
+  private @Nullable Date appStartTime;
+
+  private AppStartState() {}
+
+  static @NotNull AppStartState getInstance() {
+    return instance;
+  }
+
+  void setAppStartEnd() {
+    appStartEnd = SystemClock.uptimeMillis();
+  }
+
+  @Nullable
+  Long getAppStartInterval() {
+    if (appStart == null || appStartEnd == null || coldStart == null) {
+      return null;
+    }
+    return appStartEnd - appStart;
+  }
+
+  boolean getColdStart() {
+    return Boolean.TRUE.equals(coldStart);
+  }
+
+  void setColdStart(final boolean coldStart) {
+    this.coldStart = coldStart;
+  }
+
+  @Nullable
+  Date getAppStartTime() {
+    return appStartTime;
+  }
+
+  synchronized void setAppStartTime(final long appStart, final @NotNull Date appStartTime) {
+    // method is synchronized because the SDK may by init. on a background thread.
+    if (this.appStartTime != null && this.appStart != null) {
+      return;
+    }
+    this.appStartTime = appStartTime;
+    this.appStart = appStart;
+  }
+}

sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java

@@ -70,9 +70,6 @@ final class DefaultAndroidEventProcessor implements EventProcessor {
   @TestOnly static final String EMULATOR = "emulator";
   @TestOnly static final String SIDE_LOADED = "sideLoaded";
 
-  // it could also be a parameter and get from Sentry.init(...)
-  private static final @Nullable Date appStartTime = DateUtils.getCurrentDateTime();
-
   @TestOnly final Context context;
 
   @TestOnly final Future<Map<String, Object>> contextData;
@@ -299,7 +296,7 @@ private void mergeDebugImages(final @NotNull SentryEvent event) {
 
   private void setAppExtras(final @NotNull App app) {
     app.setAppName(getApplicationName());
-    app.setAppStartTime(appStartTime);
+    app.setAppStartTime(AppStartState.getInstance().getAppStartTime());
   }
 
   @SuppressWarnings("deprecation")

sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java

@@ -0,0 +1,35 @@
+package io.sentry.android.core;
+
+import io.sentry.EventProcessor;
+import io.sentry.protocol.MeasurementValue;
+import io.sentry.protocol.SentryTransaction;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class PerformanceAndroidEventProcessor implements EventProcessor {
+
+  // transactions may be started in parallel, making this field volatile instead of a lock
+  // to avoid contention.
+  private volatile boolean sentStartMeasurement = false;
+
+  @Override
+  public @NotNull SentryTransaction process(
+      @NotNull SentryTransaction transaction, @Nullable Object hint) {
+    // the app start metric is sent only once when the 1st transaction happens
+    // after the app start is collected.
+    if (!sentStartMeasurement) {
+      Long appStartUpInterval = AppStartState.getInstance().getAppStartInterval();
+      if (appStartUpInterval != null) {
+        MeasurementValue value = new MeasurementValue((float) appStartUpInterval);
+
+        String appStartKey =
+            AppStartState.getInstance().getColdStart() ? "app_start_cold" : "app_start_warm";
+
+        transaction.getMeasurements().put(appStartKey, value);
+        sentStartMeasurement = true;
+      }
+    }
+
+    return transaction;
+  }
+}

sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java

@@ -1,16 +1,23 @@
 package io.sentry.android.core;
 
 import android.content.Context;
+import android.os.SystemClock;
+import io.sentry.DateUtils;
 import io.sentry.ILogger;
 import io.sentry.OptionsContainer;
 import io.sentry.Sentry;
 import io.sentry.SentryLevel;
 import java.lang.reflect.InvocationTargetException;
+import java.util.Date;
 import org.jetbrains.annotations.NotNull;
 
 /** Sentry initialization class */
 public final class SentryAndroid {
 
+  // static to rely on Class load
+  private static final @NotNull Date appStartTime = DateUtils.getCurrentDateTime();
+  private static final long appStart = SystemClock.uptimeMillis();
+
   private SentryAndroid() {}
 
   /**
@@ -51,10 +58,14 @@ public static void init(
    * @param logger your custom logger that implements ILogger
    * @param configuration Sentry.OptionsConfiguration configuration handler
    */
-  public static void init(
+  public static synchronized void init(
       @NotNull final Context context,
       @NotNull ILogger logger,
       @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration) {
+    // if SentryPerformanceProvider was disabled or removed, we set the App Start when
+    // the SDK is called.
+    AppStartState.getInstance().setAppStartTime(appStart, appStartTime);
+
     try {
       Sentry.init(
           OptionsContainer.create(SentryAndroidOptions.class),

sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java

@@ -0,0 +1,86 @@
+package io.sentry.android.core;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ProviderInfo;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.sentry.DateUtils;
+import java.util.Date;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * SentryPerformanceProvider is responsible for collecting data (eg appStart) as early as possible
+ * as ContentProvider is the only reliable hook for libraries that works across all the supported
+ * SDK versions. When minSDK is >= 24, we could use Process.getStartUptimeMillis()
+ */
+@ApiStatus.Internal
+public final class SentryPerformanceProvider extends ContentProvider {
+
+  // static to rely on Class load
+  private static final @NotNull Date appStartTime = DateUtils.getCurrentDateTime();
+  // SystemClock.uptimeMillis() isn't affected by phone provider or clock changes.
+  private static final long appStart = SystemClock.uptimeMillis();
+
+  public SentryPerformanceProvider() {
+    AppStartState.getInstance().setAppStartTime(appStart, appStartTime);
+  }
+
+  @Override
+  public boolean onCreate() {
+    return true;
+  }
+
+  @Override
+  public void attachInfo(Context context, ProviderInfo info) {
+    // applicationId is expected to be prepended. See AndroidManifest.xml
+    if (SentryPerformanceProvider.class.getName().equals(info.authority)) {
+      throw new IllegalStateException(
+          "An applicationId is required to fulfill the manifest placeholder.");
+    }
+    super.attachInfo(context, info);
+  }
+
+  @Nullable
+  @Override
+  public Cursor query(
+      @NonNull Uri uri,
+      @Nullable String[] projection,
+      @Nullable String selection,
+      @Nullable String[] selectionArgs,
+      @Nullable String sortOrder) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public String getType(@NonNull Uri uri) {
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public int delete(
+      @NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public int update(
+      @NonNull Uri uri,
+      @Nullable ContentValues values,
+      @Nullable String selection,
+      @Nullable String[] selectionArgs) {
+    return 0;
+  }
+}

sentry/api/sentry.api

@@ -1496,6 +1496,10 @@ public final class io/sentry/protocol/Gpu : io/sentry/IUnknownPropertiesConsumer
 	public fun setVersion (Ljava/lang/String;)V
 }
 
+public final class io/sentry/protocol/MeasurementValue {
+	public fun <init> (F)V
+}
+
 public final class io/sentry/protocol/Mechanism : io/sentry/IUnknownPropertiesConsumer {
 	public fun <init> ()V
 	public fun <init> (Ljava/lang/Thread;)V
@@ -1741,6 +1745,7 @@ public final class io/sentry/protocol/SentryThread : io/sentry/IUnknownPropertie
 
 public final class io/sentry/protocol/SentryTransaction : io/sentry/SentryBaseEvent {
 	public fun <init> (Lio/sentry/SentryTracer;)V
+	public fun getMeasurements ()Ljava/util/Map;
 	public fun getSpans ()Ljava/util/List;
 	public fun getStartTimestamp ()Ljava/util/Date;
 	public fun getStatus ()Lio/sentry/SpanStatus;

sentry/src/main/java/io/sentry/protocol/MeasurementValue.java

@@ -0,0 +1,13 @@
+package io.sentry.protocol;
+
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Internal
+public final class MeasurementValue {
+  @SuppressWarnings("UnusedVariable")
+  private final float value;
+
+  public MeasurementValue(final float value) {
+    this.value = value;
+  }
+}

sentry/src/main/java/io/sentry/protocol/SentryTransaction.java

@@ -9,6 +9,7 @@
 import io.sentry.util.Objects;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
@@ -34,6 +35,8 @@ public final class SentryTransaction extends SentryBaseEvent {
   @SuppressWarnings("UnusedVariable")
   private @NotNull final String type = "transaction";
 
+  private @NotNull final Map<String, @NotNull MeasurementValue> measurements = new HashMap<>();
+
   @SuppressWarnings("deprecation")
   public SentryTransaction(final @NotNull SentryTracer sentryTracer) {
     super(sentryTracer.getEventId());
@@ -85,4 +88,8 @@ public boolean isSampled() {
     final SpanContext trace = this.getContexts().getTrace();
     return trace != null && Boolean.TRUE.equals(trace.getSampled());
   }
+
+  public @NotNull Map<String, @NotNull MeasurementValue> getMeasurements() {
+    return measurements;
+  }
 }