add app launch TTI log

examples/android/MainActivity.kt

@@ -48,6 +48,9 @@ import okhttp3.Request
 import okhttp3.Response
 import java.io.IOException
 import kotlin.system.exitProcess
+import kotlin.time.Duration
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
 
 class MainActivity : ComponentActivity() {
 
@@ -121,6 +124,8 @@ class MainActivity : ComponentActivity() {
 
         Logger.addField("field_container_field_key", "field_container_field_value")
         Logger.logInfo(mapOf("key" to "value")) { "MainActivity onCreate called" }
+
+        Logger.logAppLaunchTTI(1.toDuration(DurationUnit.SECONDS))
     }
 
     private fun createComposeUI() {

examples/swift/hello_world/ContentView.swift

@@ -17,8 +17,8 @@ struct ContentView: View {
     @State private var selectedLogLevel = LoggerCustomer.LogLevel.info
 
     init(navigationController: UINavigationController?) {
-        self.navigationController = navigationController
         self.loggerCustomer = LoggerCustomer()
+        self.navigationController = navigationController
         self.currentSessionID = self.loggerCustomer.sessionID ?? "No Session ID"
     }
 
@@ -103,6 +103,7 @@ struct ContentView: View {
             }
         }
         .padding(5)
+        .onAppear { self.loggerCustomer.logAppLaunchTTI() }
     }
 }
 

examples/swift/hello_world/LoggerCustomer.swift

@@ -44,6 +44,8 @@ final class LoggerCustomer: NSObject, URLSessionDelegate {
         var id: String { return self.rawValue }
     }
 
+    private var appStartTime: Date
+
     private let requestDefinitions = [
         // swiftlint:disable:next force_unwrapping use_static_string_url_init
         RequestDefinition(method: "GET", url: URL(string: "https://httpbin.org/get")!),
@@ -79,6 +81,8 @@ final class LoggerCustomer: NSObject, URLSessionDelegate {
     }
 
     override init() {
+        self.appStartTime = Date()
+
         Logger
             .configure(
                 withAPIKey: kBitdriftAPIKey,
@@ -160,6 +164,10 @@ final class LoggerCustomer: NSObject, URLSessionDelegate {
             Logger.logTrace("Sending log with level [Trace]", fields: fields)
         }
     }
+
+    func logAppLaunchTTI() {
+        Logger.logAppLaunchTTI(duration: Date().timeIntervalSince(self.appStartTime))
+    }
 }
 
 extension LoggerCustomer: MXMetricManagerSubscriber {

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/Capture.kt

@@ -20,6 +20,7 @@ import io.bitdrift.capture.providers.SystemDateProvider
 import io.bitdrift.capture.providers.session.SessionStrategy
 import okhttp3.HttpUrl
 import java.util.concurrent.atomic.AtomicReference
+import kotlin.time.Duration
 
 /**
  * Top level namespace Capture SDK.
@@ -278,6 +279,18 @@ object Capture {
             logger()?.log(level = level, fields = fields, throwable = throwable, message = message)
         }
 
+        /**
+         * Writes an app launch TTI log event. This event should be logged only once per Logger configuration.
+         * Consecutive calls have no effect.
+         *
+         * @param duration The time between a user's intent to launch the app and when the app becomes
+         *                 interactive.
+         */
+        @JvmStatic
+        fun logAppLaunchTTI(duration: Duration) {
+            logger()?.logAppLaunchTTI(duration)
+        }
+
         /**
          * Signals that an operation has started at this point in time.
          *

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/CaptureJniLibrary.kt

@@ -229,6 +229,19 @@ internal object CaptureJniLibrary {
         durationS: Double,
     )
 
+    /**
+     * Writes an app launch TTI log. The method should be called only once per logger Id. Consecutive calls
+     * have no effect.
+     *
+     * @param loggerId the ID of the logger to write to.
+     * @param durationS the time between a user's intent to launch the app and when the app becomes
+     *                  interactive.
+     */
+    external fun writeAppLaunchTTILog(
+        loggerId: Long,
+        durationS: Double,
+    )
+
     /**
      * Flushes logger's state to disk.
      *

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/ILogger.kt

@@ -10,6 +10,7 @@ package io.bitdrift.capture
 import io.bitdrift.capture.events.span.Span
 import io.bitdrift.capture.network.HttpRequestInfo
 import io.bitdrift.capture.network.HttpResponseInfo
+import kotlin.time.Duration
 
 /**
  * A Capture SDK logger interface.
@@ -72,6 +73,7 @@ interface ILogger {
 
     /**
      * Logs a message at a specified level.
+     *
      * @param level the severity of the log.
      * @param fields and optional collection of key-value pairs to be added to the log line.
      * @param throwable an optional throwable to include in the log line.
@@ -84,6 +86,15 @@ interface ILogger {
         message: () -> String,
     )
 
+    /**
+     * Writes an app launch TTI log event. This event should be logged only once per Logger configuration.
+     * Consecutive calls have no effect.
+     *
+     * @param duration The time between a user's intent to launch the app and when the app becomes
+     *                 interactive.
+     */
+    fun logAppLaunchTTI(duration: Duration)
+
     /**
      * Signals that an operation has started at this point in time. Each operation consists of start
      * and end event logs. The start event is emitted immediately upon calling the
@@ -100,12 +111,14 @@ interface ILogger {
 
     /**
      * Records information about an HTTP network request
+     *
      * @param httpRequestInfo information used to enrich the log line
      */
     fun log(httpRequestInfo: HttpRequestInfo)
 
     /**
      * Records information about an HTTP network response
+     *
      * @param httpResponseInfo information used to enrich the log line
      */
     fun log(httpResponseInfo: HttpResponseInfo)

platform/jvm/capture/src/main/kotlin/io/bitdrift/capture/LoggerImpl.kt

@@ -284,6 +284,10 @@ internal class LoggerImpl(
         )
     }
 
+    override fun logAppLaunchTTI(duration: Duration) {
+        CaptureJniLibrary.writeAppLaunchTTILog(this.loggerId, duration.toDouble(DurationUnit.SECONDS))
+    }
+
     override fun startSpan(name: String, level: LogLevel, fields: Map<String, String>?): Span {
         return Span(this, name, level, fields)
     }

platform/jvm/jni_symbols.lds

@@ -15,6 +15,7 @@ Java_io_bitdrift_capture_CaptureJniLibrary_writeResourceUtilizationLog
 Java_io_bitdrift_capture_CaptureJniLibrary_writeSDKConfiguredLog
 Java_io_bitdrift_capture_CaptureJniLibrary_shouldWriteAppUpdateLog
 Java_io_bitdrift_capture_CaptureJniLibrary_writeAppUpdateLog
+Java_io_bitdrift_capture_CaptureJniLibrary_writeAppLaunchTTILog
 Java_io_bitdrift_capture_CaptureJniLibrary_flush
 Java_io_bitdrift_capture_CaptureJniLibrary_debugDebug
 Java_io_bitdrift_capture_CaptureJniLibrary_debugError

platform/jvm/src/jni.rs

@@ -995,6 +995,25 @@ pub extern "system" fn Java_io_bitdrift_capture_CaptureJniLibrary_writeAppUpdate
   );
 }
 
+#[no_mangle]
+pub extern "system" fn Java_io_bitdrift_capture_CaptureJniLibrary_writeAppLaunchTTILog(
+  _env: JNIEnv<'_>,
+  _class: JClass<'_>,
+  logger_id: jlong,
+  duration_s: f64,
+) {
+  bd_client_common::error::with_handle_unexpected(
+    || -> anyhow::Result<()> {
+      let logger = unsafe { LoggerId::from_raw(logger_id) };
+      logger.log_app_launch_tti(Duration::seconds_f64(duration_s));
+
+      Ok(())
+    },
+    "jni write app launch TTI log",
+  );
+}
+
+
 #[no_mangle]
 pub extern "system" fn Java_io_bitdrift_capture_CaptureJniLibrary_flush(
   _env: JNIEnv<'_>,

platform/shared/Cargo.toml

@@ -14,6 +14,7 @@ bd-log-primitives.workspace     = true
 bd-logger.workspace             = true
 bd-runtime.workspace            = true
 bd-session.workspace            = true
+log.workspace                   = true
 parking_lot.workspace           = true
 regex.workspace                 = true
 time.workspace                  = true

platform/shared/src/lib.rs

@@ -9,7 +9,9 @@ pub mod error;
 pub mod metadata;
 
 use bd_client_common::error::handle_unexpected;
+use bd_logger::{log_level, AnnotatedLogField, LogField, LogFieldKind, LogType};
 use bd_runtime::runtime::Snapshot;
+use parking_lot::Once;
 use std::future::Future;
 use std::ops::Deref;
 use std::pin::Pin;
@@ -92,6 +94,7 @@ pub struct LoggerHolder {
   logger: bd_logger::Logger,
   handle: bd_logger::LoggerHandle,
   future: parking_lot::Mutex<Option<LoggerFuture>>,
+  app_launch_tti_log: Once,
 }
 
 impl Deref for LoggerHolder {
@@ -109,6 +112,7 @@ impl LoggerHolder {
       logger,
       handle,
       future: parking_lot::Mutex::new(Some(future)),
+      app_launch_tti_log: Once::new(),
     }
   }
 
@@ -158,6 +162,39 @@ impl LoggerHolder {
     holder.shutdown(false);
     drop(holder);
   }
+
+  /// Logs an out-of-the-box app launch TTI log event. The method should be called only once.
+  /// Consecutive calls have not effect.
+  pub fn log_app_launch_tti(&self, duration: time::Duration) {
+    self.app_launch_tti_log.call_once(|| {
+      let duration_ms = duration.as_seconds_f64() * 1_000f64;
+      if duration_ms < 0.0 {
+        log::warn!(
+          "dropping app launch TTI log: reported TTI is negative: {}",
+          duration_ms
+        );
+        return;
+      }
+
+      let fields = vec![AnnotatedLogField {
+        field: LogField {
+          key: "_duration_ms".into(),
+          value: duration_ms.to_string().into(),
+        },
+        kind: LogFieldKind::Ootb,
+      }];
+
+      self.log(
+        log_level::INFO,
+        LogType::Lifecycle,
+        "AppLaunchTTI".into(),
+        fields,
+        vec![],
+        None,
+        false,
+      );
+    });
+  }
 }
 
 impl<'a> From<LoggerId<'a>> for i64 {

platform/swift/source/Capture.swift

@@ -261,6 +261,17 @@ extension Logger {
         )
     }
 
+    // MARK: - Predefined Logs
+
+    /// Writes an app launch TTI log event. This event should be logged only once per Logger configuration.
+    /// Consecutive calls have no effect.
+    ///
+    /// - parameter duration: The time between a user's intent to launch the app and when the app becomes
+    ///                       interactive.
+    public static func logAppLaunchTTI(_ duration: TimeInterval) {
+        Self.getShared()?.logAppLaunchTTI(duration)
+    }
+
     // MARK: - Network Activity Logging
 
     /// Logs information about a network request.

platform/swift/source/CaptureRustBridge.h

@@ -137,14 +137,27 @@ bool capture_should_write_app_update_log(
  * @param app_version the version of the app.
  * @param build_number the app build number.
  * @param app_install_size_bytes the size of the app in bytes.
- * @param duration_ms the duration of time the preparation of the log took.
+ * @param duration_s the duration of time the preparation of the log took.
  */
 void capture_write_app_update_log(
     logger_id logger_id,
     NSString *app_version,
     NSString *build_number,
     uint64_t app_install_size_bytes,
-    double duration_ms
+    double duration_s
+);
+
+/*
+ * Writes an app launch TTI log. The method should be called only once per logger Id. Consecutive calls
+ * have no effect.
+ *
+ * @param loggerId the ID of the logger to write to.
+ * @param duration_s the duration of time between a user's intent to launch an app and the point in time 
+ *        when the app became interactive.
+ */
+void capture_write_app_launch_tti_log(
+    logger_id logger_id,
+    double duration_s
 );
 
 /*

platform/swift/source/CoreLogger.swift

@@ -120,6 +120,10 @@ extension CoreLogger: CoreLogging {
         )
     }
 
+    func logAppLaunchTTI(duration: TimeInterval) {
+        self.underlyingLogger.logAppLaunchTTI(duration: duration)
+    }
+
     func startNewSession() {
         self.underlyingLogger.startNewSession()
     }

platform/swift/source/CoreLogging.swift

@@ -89,6 +89,13 @@ protocol CoreLogging: AnyObject {
         duration: TimeInterval
     )
 
+    /// Writes an app launch TTI log event. This event should be logged only once per Logger configuration.
+    /// Consecutive calls have no effect.
+    ///
+    /// - parameter duration: The time between a user's intent to launch the app and when the app becomes
+    ///                       interactive.
+    func logAppLaunchTTI(duration: TimeInterval)
+
     /// Stars new session using configured session strategy.
     func startNewSession()
 

platform/swift/source/Logger.swift

@@ -442,6 +442,10 @@ extension Logger: Logging {
         self.deviceCodeController.createTemporaryDeviceCode(deviceID: self.deviceID, completion: completion)
     }
 
+    public func logAppLaunchTTI(_ duration: TimeInterval) {
+        self.underlyingLogger.logAppLaunchTTI(duration)
+    }
+
     public func startSpan(
         name: String,
         level: LogLevel,

platform/swift/source/LoggerBridge.swift

@@ -127,6 +127,10 @@ final class LoggerBridge: LoggerBridging {
         capture_write_app_update_log(self.loggerID, appVersion, buildNumber, appSizeBytes, duration)
     }
 
+    func logAppLaunchTTI(duration: TimeInterval) {
+        capture_write_app_launch_tti_log(self.loggerID, duration)
+    }
+
     func startNewSession() {
         capture_start_new_session(self.loggerID)
     }

platform/swift/source/LoggerBridging.swift

@@ -41,6 +41,8 @@ protocol LoggerBridging {
         duration: TimeInterval
     )
 
+    func logAppLaunchTTI(duration: TimeInterval)
+
     func start()
 
     func startNewSession()